openclaw/dist/openclaw-agent-db-maintenance-BmCyifrn.mjs

Multi-channel AI gateway with extensible messaging integrations

import "./kysely-sync-DUWzQvCU.mjs";
import { r as enableNodeSqliteKyselyStatementCache, t as clearNodeSqliteKyselyCacheForDatabase } from "./kysely-sync-cache-state-DbAMR_DD.mjs";
import { r as openNodeSqliteDatabase } from "./node-sqlite-DyeJqxPf.mjs";
import { f as readExistingAgentSchemaMeta } from "./sqlite-readonly-location-DEj0l7LR.mjs";
import { t as SqliteSchemaMismatchError } from "./sqlite-schema-issues-BnRd2KGO.mjs";
import { s as OPENCLAW_SQLITE_BUSY_TIMEOUT_MS } from "./openclaw-state-db-contract-BYv0nUQr.mjs";
import { t as createSubsystemLogger } from "./subsystem-4NzR43uz.mjs";
import { a as readSqliteUserVersion } from "./sqlite-user-version-DLMl1A7W.mjs";
import { s as resolveSqliteInspectionSignal } from "./sqlite-readonly-worker-RO6waSGe.mjs";
import { n as normalizeAgentId } from "./agent-id-D1-Q6vR4.mjs";
import "./session-key-DY3MOX4N.mjs";
import { t as OPENCLAW_AGENT_SCHEMA_SQL } from "./openclaw-agent-schema-V6rru8Sr.mjs";
import "./openclaw-agent-db-contract-OYt2DCoK.mjs";
import { i as assertSupportedAgentSchemaVersion, r as assertExistingAgentSchemaOwner } from "./openclaw-agent-db-schema-read-y-s2h2dU.mjs";
import { t as assertSqliteIntegrityInWorker } from "./sqlite-integrity-worker-B-14oZqk.mjs";
import { g as repairDoctorSqliteIndexCorruption } from "./openclaw-state-db-DJZ7EKoI.mjs";
import { t as configureSqliteMaintenanceCache } from "./sqlite-maintenance-cache-AYpxl8JZ.mjs";
import { r as assertAgentDatabaseMaintenanceAuthority, u as invalidateOpenClawAgentDatabaseIntegrityBeforeMutation } from "./openclaw-agent-db-lease-zP0JO4hP.mjs";
import { r as assertOpenClawAgentSchemaContains } from "./openclaw-agent-db-schema-helpers-CXpPV9Zn.mjs";
import { i as ensureOpenClawAgentDatabaseSchemaSteps } from "./openclaw-agent-db-schema-CppMSzFp.mjs";
import { t as AGENT_FTS_SCHEMAS } from "./openclaw-agent-fts-schema-BY3B67St.mjs";
//#region src/infra/sqlite-integrity-operation.ts
/** Keep the caller's connection and authority until every native reader closes. */
async function runSqliteIntegrityOperationInWorker(operation, options) {
	const signal = resolveSqliteInspectionSignal(options.signal) ?? options.signal;
	const beforeResume = () => {
		signal.throwIfAborted();
		options.beforeResume();
	};
	try {
		beforeResume();
		let step = operation.next();
		while (!step.done) {
			let failure;
			try {
				await assertSqliteIntegrityInWorker(step.value.databaseLabel, options.busyTimeoutMs, signal, void 0, step.value.timing);
			} catch (error) {
				failure = { error };
			}
			beforeResume();
			step = failure && !options.repairIntegrityError?.() ? operation.throw(failure.error) : operation.next();
		}
	} finally {
		operation.return();
	}
}
//#endregion
//#region src/state/openclaw-agent-db-maintenance.ts
const agentDbLog = createSubsystemLogger("state/agent-db");
/** Require exact agent ownership without requiring the latest schema. */
function assertOpenClawAgentDatabaseOwner(database, options) {
	const agentId = normalizeAgentId(options.agentId);
	const metadata = readExistingAgentSchemaMeta(database);
	if (!metadata) throw new SqliteSchemaMismatchError(`OpenClaw agent database ${options.pathname} has no schema ownership metadata. Run openclaw doctor --fix to inspect and repair its ownership.`);
	assertExistingAgentSchemaOwner(metadata, agentId, options.pathname);
	if (metadata.agentId !== agentId) throw new SqliteSchemaMismatchError(`OpenClaw agent database ${options.pathname} belongs to agent ${metadata.agentId}; requested agent ${agentId}.`);
	return metadata;
}
/** Require the exact agent owner and schema before offline file maintenance. */
function assertOpenClawAgentDatabaseForMaintenance(database, options) {
	const metadata = assertOpenClawAgentDatabaseOwner(database, options);
	const userVersion = assertSupportedAgentSchemaVersion(database, options.pathname);
	if (userVersion !== 25) throw new SqliteSchemaMismatchError(`OpenClaw agent database ${options.pathname} uses schema version ${userVersion}; run openclaw doctor --fix before compacting it.`);
	if (metadata.schemaVersion !== 25) throw new SqliteSchemaMismatchError(`OpenClaw agent database ${options.pathname} metadata schema version ${metadata.schemaVersion ?? "invalid"} does not match 25; run openclaw doctor --fix before compacting it.`);
	return assertOpenClawAgentSchemaContains(database, options.pathname, OPENCLAW_AGENT_SCHEMA_SQL, "current", options.allowStartupIndexRepair);
}
/** Upgrade or repair a supported owned schema before strict offline maintenance. */
async function migrateOpenClawAgentDatabaseForMaintenance(options, maintenance) {
	const agentId = normalizeAgentId(options.agentId);
	const pathname = options.pathname;
	const env = { ...process.env };
	const assertOwned = () => {
		maintenance.signal.throwIfAborted();
		assertAgentDatabaseMaintenanceAuthority(maintenance);
	};
	assertOwned();
	invalidateOpenClawAgentDatabaseIntegrityBeforeMutation(pathname, env);
	const database = openNodeSqliteDatabase(pathname);
	try {
		configureSqliteMaintenanceCache(database);
		enableNodeSqliteKyselyStatementCache(database);
		database.exec(`PRAGMA busy_timeout = ${OPENCLAW_SQLITE_BUSY_TIMEOUT_MS};`);
		const metadata = readExistingAgentSchemaMeta(database);
		if (!metadata) return;
		assertExistingAgentSchemaOwner(metadata, agentId, pathname);
		assertSupportedAgentSchemaVersion(database, pathname);
		const userVersion = readSqliteUserVersion(database);
		const metadataVersion = metadata.schemaVersion;
		if (!(userVersion === 25 && metadataVersion === 25) && !(userVersion >= 1 && userVersion < 25 && metadataVersion === userVersion)) return;
		const repairIndexes = () => {
			const changes = repairDoctorSqliteIndexCorruption(database, pathname, {
				ftsSchemas: AGENT_FTS_SCHEMAS,
				label: `agent ${agentId}`,
				assertCurrent: () => {
					assertOwned();
					assertOpenClawAgentDatabaseOwner(database, {
						agentId,
						pathname
					});
					assertSupportedAgentSchemaVersion(database, pathname);
				}
			});
			for (const change of changes) agentDbLog.warn(change);
			return changes.length > 0;
		};
		if (userVersion === 17) repairIndexes();
		await runSqliteIntegrityOperationInWorker(ensureOpenClawAgentDatabaseSchemaSteps(database, {
			agentId,
			path: pathname,
			env
		}), {
			busyTimeoutMs: OPENCLAW_SQLITE_BUSY_TIMEOUT_MS,
			signal: maintenance.signal,
			beforeResume: () => {
				assertOwned();
				assertExistingAgentSchemaOwner(readExistingAgentSchemaMeta(database), agentId, pathname);
				assertSupportedAgentSchemaVersion(database, pathname);
			},
			repairIntegrityError: repairIndexes
		});
		assertOwned();
		assertOpenClawAgentDatabaseForMaintenance(database, {
			agentId,
			pathname
		});
	} finally {
		clearNodeSqliteKyselyCacheForDatabase(database);
		database.close();
	}
}
//#endregion
export { runSqliteIntegrityOperationInWorker as i, assertOpenClawAgentDatabaseOwner as n, migrateOpenClawAgentDatabaseForMaintenance as r, assertOpenClawAgentDatabaseForMaintenance as t };