@xopcai/xopc 0.0.95 → 0.0.97

package/dist/src/storage/sqlite/config-repository.js

@@ -0,0 +1,56 @@
+import { getSqliteDatabase, runSqliteWriteTransaction } from "./transaction.js";
+import { sessionConfigRowToConfig } from "./row-mappers.js";
+import { ensureSessionInTransaction } from "./session-repository.js";
+//#region src/storage/sqlite/config-repository.ts
+function readConfigRow(db, sessionKey) {
+	return db.prepare(`SELECT session_key, thinking_level, reasoning_level, verbose_level, elevated_mode,
+              model_override, provider_override, working_directory_override, updated_at
+       FROM session_config WHERE session_key = ?`).get(sessionKey);
+}
+function getSessionConfig(sessionKey) {
+	const row = readConfigRow(getSqliteDatabase(), sessionKey);
+	if (!row) return null;
+	return sessionConfigRowToConfig(row);
+}
+function setSessionConfig(sessionKey, config, cwd) {
+	return runSqliteWriteTransaction((db) => {
+		ensureSessionInTransaction(db, sessionKey, cwd);
+		const updatedAt = Date.now();
+		const next = {
+			...config,
+			updatedAt
+		};
+		db.prepare(`INSERT INTO session_config (
+        session_key, thinking_level, reasoning_level, verbose_level, elevated_mode,
+        model_override, provider_override, working_directory_override, updated_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(session_key) DO UPDATE SET
+        thinking_level = excluded.thinking_level,
+        reasoning_level = excluded.reasoning_level,
+        verbose_level = excluded.verbose_level,
+        elevated_mode = excluded.elevated_mode,
+        model_override = excluded.model_override,
+        provider_override = excluded.provider_override,
+        working_directory_override = excluded.working_directory_override,
+        updated_at = excluded.updated_at`).run(sessionKey, next.thinkingLevel ?? null, next.reasoningLevel ?? null, next.verboseLevel ?? null, next.elevatedMode ?? null, next.modelOverride ?? null, next.providerOverride ?? null, next.workingDirectoryOverride ?? null, updatedAt);
+		return next;
+	});
+}
+function updateSessionConfig(sessionKey, partial, cwd) {
+	return setSessionConfig(sessionKey, {
+		...getSessionConfig(sessionKey),
+		...partial
+	}, cwd);
+}
+function deleteSessionConfig(sessionKey) {
+	runSqliteWriteTransaction((db) => {
+		db.prepare(`DELETE FROM session_config WHERE session_key = ?`).run(sessionKey);
+	});
+}
+function hasSessionConfig(sessionKey) {
+	return getSqliteDatabase().prepare(`SELECT 1 AS ok FROM session_config WHERE session_key = ?`).get(sessionKey)?.ok === 1;
+}
+//#endregion
+export { deleteSessionConfig, getSessionConfig, hasSessionConfig, setSessionConfig, updateSessionConfig };
+
+//# sourceMappingURL=config-repository.js.map

package/dist/src/storage/sqlite/config-repository.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"config-repository.js","names":[],"sources":["../../../../src/storage/sqlite/config-repository.ts"],"sourcesContent":["import type { DatabaseSync } from 'node:sqlite';\n\nimport type { SessionAgentConfig } from '../../session/config-types.js';\nimport { sessionConfigRowToConfig, type SessionConfigRow } from './row-mappers.js';\nimport { ensureSessionInTransaction } from './session-repository.js';\nimport { getSqliteDatabase, runSqliteWriteTransaction } from './transaction.js';\n\nfunction readConfigRow(db: DatabaseSync, sessionKey: string): SessionConfigRow | undefined {\n  return db\n    .prepare(\n      `SELECT session_key, thinking_level, reasoning_level, verbose_level, elevated_mode,\n              model_override, provider_override, working_directory_override, updated_at\n       FROM session_config WHERE session_key = ?`,\n    )\n    .get(sessionKey) as SessionConfigRow | undefined;\n}\n\nexport function getSessionConfig(sessionKey: string): SessionAgentConfig | null {\n  const db = getSqliteDatabase();\n  const row = readConfigRow(db, sessionKey);\n  if (!row) {\n    return null;\n  }\n  return sessionConfigRowToConfig(row);\n}\n\nexport function setSessionConfig(sessionKey: string, config: SessionAgentConfig, cwd: string): SessionAgentConfig {\n  return runSqliteWriteTransaction((db) => {\n    ensureSessionInTransaction(db, sessionKey, cwd);\n    const updatedAt = Date.now();\n    const next = { ...config, updatedAt };\n    db.prepare(\n      `INSERT INTO session_config (\n        session_key, thinking_level, reasoning_level, verbose_level, elevated_mode,\n        model_override, provider_override, working_directory_override, updated_at\n      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)\n      ON CONFLICT(session_key) DO UPDATE SET\n        thinking_level = excluded.thinking_level,\n        reasoning_level = excluded.reasoning_level,\n        verbose_level = excluded.verbose_level,\n        elevated_mode = excluded.elevated_mode,\n        model_override = excluded.model_override,\n        provider_override = excluded.provider_override,\n        working_directory_override = excluded.working_directory_override,\n        updated_at = excluded.updated_at`,\n    ).run(\n      sessionKey,\n      next.thinkingLevel ?? null,\n      next.reasoningLevel ?? null,\n      next.verboseLevel ?? null,\n      next.elevatedMode ?? null,\n      next.modelOverride ?? null,\n      next.providerOverride ?? null,\n      next.workingDirectoryOverride ?? null,\n      updatedAt,\n    );\n    return next;\n  });\n}\n\nexport function updateSessionConfig(\n  sessionKey: string,\n  partial: Partial<SessionAgentConfig>,\n  cwd: string,\n): SessionAgentConfig {\n  const existing = getSessionConfig(sessionKey);\n  return setSessionConfig(sessionKey, { ...existing, ...partial }, cwd);\n}\n\nexport function deleteSessionConfig(sessionKey: string): void {\n  runSqliteWriteTransaction((db) => {\n    db.prepare(`DELETE FROM session_config WHERE session_key = ?`).run(sessionKey);\n  });\n}\n\nexport function hasSessionConfig(sessionKey: string): boolean {\n  const db = getSqliteDatabase();\n  const row = db\n    .prepare(`SELECT 1 AS ok FROM session_config WHERE session_key = ?`)\n    .get(sessionKey) as { ok?: number } | undefined;\n  return row?.ok === 1;\n}\n"],"mappings":";;;;AAOA,SAAS,cAAc,IAAkB,YAAkD;AACzF,QAAO,GACJ,QACC;;kDAGD,CACA,IAAI,WAAW;;AAGpB,SAAgB,iBAAiB,YAA+C;CAE9E,MAAM,MAAM,cADD,mBACiB,EAAE,WAAW;AACzC,KAAI,CAAC,IACH,QAAO;AAET,QAAO,yBAAyB,IAAI;;AAGtC,SAAgB,iBAAiB,YAAoB,QAA4B,KAAiC;AAChH,QAAO,2BAA2B,OAAO;AACvC,6BAA2B,IAAI,YAAY,IAAI;EAC/C,MAAM,YAAY,KAAK,KAAK;EAC5B,MAAM,OAAO;GAAE,GAAG;GAAQ;GAAW;AACrC,KAAG,QACD;;;;;;;;;;;;0CAaD,CAAC,IACA,YACA,KAAK,iBAAiB,MACtB,KAAK,kBAAkB,MACvB,KAAK,gBAAgB,MACrB,KAAK,gBAAgB,MACrB,KAAK,iBAAiB,MACtB,KAAK,oBAAoB,MACzB,KAAK,4BAA4B,MACjC,UACD;AACD,SAAO;GACP;;AAGJ,SAAgB,oBACd,YACA,SACA,KACoB;AAEpB,QAAO,iBAAiB,YAAY;EAAE,GADrB,iBAAiB,WACe;EAAE,GAAG;EAAS,EAAE,IAAI;;AAGvE,SAAgB,oBAAoB,YAA0B;AAC5D,4BAA2B,OAAO;AAChC,KAAG,QAAQ,mDAAmD,CAAC,IAAI,WAAW;GAC9E;;AAGJ,SAAgB,iBAAiB,YAA6B;AAK5D,QAJW,mBACG,CACX,QAAQ,2DAA2D,CACnE,IAAI,WACG,EAAE,OAAO"}

package/dist/src/storage/sqlite/connection.d.ts

@@ -0,0 +1,38 @@
+import type { DatabaseSync } from 'node:sqlite';
+type SqliteWalCheckpointMode = 'PASSIVE' | 'FULL' | 'RESTART' | 'TRUNCATE';
+export type SqliteWalMaintenance = {
+    checkpoint: () => boolean;
+    close: () => boolean;
+};
+export type SqliteConnectionPragmaOptions = {
+    autoCheckpointPages?: number;
+    checkpointIntervalMs?: number;
+    checkpointMode?: SqliteWalCheckpointMode;
+    busyTimeoutMs?: number;
+    foreignKeys?: boolean;
+    synchronous?: 'NORMAL';
+    databasePath?: string;
+    onCheckpointError?: (error: unknown) => void;
+};
+export type XopcDatabase = {
+    db: DatabaseSync;
+    path: string;
+    walMaintenance: SqliteWalMaintenance;
+};
+export type OpenXopcDatabaseOptions = {
+    path?: string;
+    env?: NodeJS.ProcessEnv;
+};
+export declare function openXopcDatabase(options?: OpenXopcDatabaseOptions): XopcDatabase;
+export declare function getXopcDatabase(): XopcDatabase;
+/**
+ * Ensure the xopc SQLite database is open and return it.
+ * Opens with default path if not already open. Use this instead of
+ * the repetitive `if (!isXopcDatabaseOpen()) { openXopcDatabase(); }` pattern.
+ */
+export declare function requireXopcDatabase(options?: OpenXopcDatabaseOptions): XopcDatabase;
+export declare function isXopcDatabaseOpen(): boolean;
+export declare function closeXopcDatabase(): void;
+/** Test-only: reset singleton without touching files on disk. */
+export declare function resetXopcDatabaseSingletonForTest(): void;
+export {};

package/dist/src/storage/sqlite/connection.js

@@ -0,0 +1,258 @@
+import { createLogger } from "../../utils/logger/index.js";
+import { init_logger } from "../../utils/logger.js";
+import { resolveXopcDatabasePath } from "../../config/paths-state.js";
+import { ensureXopcDatabaseSchema } from "./schema.js";
+import { requireNodeSqlite } from "../../infra/node-sqlite.js";
+import { installSqliteTransientRejectionHandler } from "../../infra/unhandled-rejections.js";
+import fs from "node:fs";
+import path from "node:path";
+import childProcess from "node:child_process";
+//#region src/storage/sqlite/connection.ts
+init_logger();
+const log = createLogger("Sqlite:Connection");
+const XOPC_SQLITE_BUSY_TIMEOUT_MS = 3e4;
+const DB_DIR_MODE = 448;
+const DB_FILE_MODE = 384;
+const DB_SIDECAR_SUFFIXES = [
+	"",
+	"-shm",
+	"-wal"
+];
+const LINUX_NFS_SUPER_MAGIC = 26985;
+const PROC_MOUNTINFO_PATH = "/proc/self/mountinfo";
+const MAX_TIMER_TIMEOUT_MS = 2 ** 31 - 1;
+function normalizeNonNegativeInteger(value, label) {
+	if (!Number.isInteger(value) || value < 0) throw new Error(`${label} must be a non-negative integer`);
+	return value;
+}
+function findExistingVolumePath(targetPath) {
+	let current = path.resolve(targetPath);
+	while (true) try {
+		return fs.statSync(current).isDirectory() ? current : path.dirname(current);
+	} catch {
+		const parent = path.dirname(current);
+		if (parent === current) return null;
+		current = parent;
+	}
+}
+function decodeMountPath(value) {
+	return value.replace(/\\([0-7]{3})/g, (_match, octal) => String.fromCharCode(Number.parseInt(octal, 8)));
+}
+function parseProcMountInfoEntries(contents) {
+	const entries = [];
+	for (const line of contents.split("\n")) {
+		const separator = line.indexOf(" - ");
+		if (separator === -1) continue;
+		const fields = line.slice(0, separator).split(" ");
+		const suffixFields = line.slice(separator + 3).split(" ");
+		const mountPoint = fields[4];
+		const fsType = suffixFields[0];
+		if (mountPoint && fsType) entries.push({
+			mountPoint: decodeMountPath(mountPoint),
+			fsType
+		});
+	}
+	return entries;
+}
+function parseMountCommandEntries(contents) {
+	const entries = [];
+	for (const line of contents.split("\n")) {
+		const linuxMatch = /^.* on (.+) type ([^,\s)]+) \(/.exec(line);
+		if (linuxMatch) {
+			entries.push({
+				mountPoint: linuxMatch[1],
+				fsType: linuxMatch[2]
+			});
+			continue;
+		}
+		const bsdMatch = /^.* on (.+) \(([^,\s)]+)/.exec(line);
+		if (bsdMatch) entries.push({
+			mountPoint: bsdMatch[1],
+			fsType: bsdMatch[2]
+		});
+	}
+	return entries;
+}
+function readMountEntries() {
+	try {
+		return parseProcMountInfoEntries(fs.readFileSync(PROC_MOUNTINFO_PATH, "utf8"));
+	} catch {}
+	try {
+		return parseMountCommandEntries(String(childProcess.execFileSync("mount", [])));
+	} catch {
+		return [];
+	}
+}
+function isPathWithinMount(targetPath, mountPoint) {
+	const resolvedTarget = path.resolve(targetPath);
+	const resolvedMountPoint = path.resolve(mountPoint);
+	return resolvedTarget === resolvedMountPoint || resolvedMountPoint === path.parse(resolvedMountPoint).root || resolvedTarget.startsWith(`${resolvedMountPoint}${path.sep}`);
+}
+function isNfsMountType(fsType) {
+	return fsType.toLowerCase().startsWith("nfs");
+}
+function isNfsMountEntryPath(targetPath) {
+	const mountEntry = readMountEntries().filter((entry) => isPathWithinMount(targetPath, entry.mountPoint)).toSorted((a, b) => b.mountPoint.length - a.mountPoint.length)[0];
+	return mountEntry ? isNfsMountType(mountEntry.fsType) : false;
+}
+function isNfsBackedPath(targetPath) {
+	if (typeof fs.statfsSync !== "function") return isNfsMountEntryPath(targetPath);
+	const checkedPath = findExistingVolumePath(targetPath);
+	if (!checkedPath) return false;
+	try {
+		if (fs.statfsSync(checkedPath).type === LINUX_NFS_SUPER_MAGIC) return true;
+	} catch {
+		return isNfsMountEntryPath(checkedPath);
+	}
+	return isNfsMountEntryPath(checkedPath);
+}
+function readJournalModeResult(row) {
+	if (!row || typeof row !== "object") return null;
+	const record = row;
+	const value = record.journal_mode ?? Object.values(record)[0];
+	return typeof value === "string" ? value.toLowerCase() : null;
+}
+function requireRollbackJournalMode(db, dbPath) {
+	const mode = readJournalModeResult(db.prepare("PRAGMA journal_mode = DELETE;").get());
+	if (mode !== "delete") throw new Error(`xopc.db at ${dbPath} is on an NFS-backed volume but SQLite kept journal_mode=${mode ?? "unknown"}. WAL mode is unsafe on NFS. Move ~/.xopc to a local filesystem, or set XOPC_STATE_DIR to a local path.`);
+}
+function configureSqliteConnectionPragmas(db, options = {}) {
+	const busyTimeoutMs = options.busyTimeoutMs ?? XOPC_SQLITE_BUSY_TIMEOUT_MS;
+	db.exec(`PRAGMA busy_timeout = ${normalizeNonNegativeInteger(busyTimeoutMs, "busyTimeoutMs")};`);
+	if (options.databasePath && isNfsBackedPath(options.databasePath)) {
+		requireRollbackJournalMode(db, options.databasePath);
+		return {
+			checkpoint: () => true,
+			close: () => true
+		};
+	}
+	db.exec("PRAGMA journal_mode = WAL;");
+	const autoCheckpointPages = normalizeNonNegativeInteger(options.autoCheckpointPages ?? 1e3, "autoCheckpointPages");
+	db.exec(`PRAGMA wal_autocheckpoint = ${autoCheckpointPages};`);
+	if (options.synchronous) db.exec(`PRAGMA synchronous = ${options.synchronous};`);
+	if (options.foreignKeys) db.exec("PRAGMA foreign_keys = ON;");
+	const checkpointMode = options.checkpointMode ?? "TRUNCATE";
+	const periodicCheckpointMode = options.checkpointMode ?? "PASSIVE";
+	const checkpointIntervalMs = normalizeNonNegativeInteger(options.checkpointIntervalMs ?? 1800 * 1e3, "checkpointIntervalMs");
+	const runCheckpoint = (mode) => {
+		try {
+			db.exec(`PRAGMA wal_checkpoint(${mode});`);
+			return true;
+		} catch (error) {
+			options.onCheckpointError?.(error);
+			return false;
+		}
+	};
+	let timer = null;
+	if (checkpointIntervalMs > 0) {
+		timer = setInterval(() => runCheckpoint(periodicCheckpointMode), Math.min(checkpointIntervalMs, MAX_TIMER_TIMEOUT_MS));
+		timer.unref?.();
+	}
+	return {
+		checkpoint: () => runCheckpoint(checkpointMode),
+		close: () => {
+			if (timer) {
+				clearInterval(timer);
+				timer = null;
+			}
+			return runCheckpoint(checkpointMode);
+		}
+	};
+}
+let cachedDatabase = null;
+function ensureDatabasePermissions(pathname) {
+	const dir = pathname.slice(0, Math.max(pathname.lastIndexOf("/"), pathname.lastIndexOf("\\")));
+	if (dir) {
+		fs.mkdirSync(dir, { recursive: true });
+		fs.chmodSync(dir, DB_DIR_MODE);
+	}
+	for (const suffix of DB_SIDECAR_SUFFIXES) {
+		const candidate = `${pathname}${suffix}`;
+		if (!fs.existsSync(candidate)) continue;
+		fs.chmodSync(candidate, DB_FILE_MODE);
+	}
+}
+function openDatabaseAtPath(pathname) {
+	installSqliteTransientRejectionHandler();
+	ensureDatabasePermissions(pathname);
+	const { DatabaseSync } = requireNodeSqlite();
+	const db = new DatabaseSync(pathname);
+	const walMaintenance = configureSqliteConnectionPragmas(db, {
+		databasePath: pathname,
+		synchronous: "NORMAL",
+		foreignKeys: true,
+		onCheckpointError: (error) => {
+			const em = error instanceof Error ? error.message : String(error);
+			log.warn({
+				err: error instanceof Error ? error : void 0,
+				errorMessage: em
+			}, `SQLite WAL checkpoint failed: ${em}`);
+		}
+	});
+	ensureXopcDatabaseSchema(db);
+	ensureDatabasePermissions(pathname);
+	log.info({ path: pathname }, "Opened xopc SQLite database");
+	return {
+		db,
+		path: pathname,
+		walMaintenance
+	};
+}
+function openXopcDatabase(options = {}) {
+	const env = options.env ?? process.env;
+	const pathname = options.path ?? resolveXopcDatabasePath(env);
+	if (cachedDatabase && cachedDatabase.path === pathname) return cachedDatabase;
+	if (cachedDatabase) closeXopcDatabase();
+	cachedDatabase = openDatabaseAtPath(pathname);
+	return cachedDatabase;
+}
+function getXopcDatabase() {
+	if (!cachedDatabase) throw new Error("xopc SQLite database is not open; call openXopcDatabase() first");
+	return cachedDatabase;
+}
+/**
+* Ensure the xopc SQLite database is open and return it.
+* Opens with default path if not already open. Use this instead of
+* the repetitive `if (!isXopcDatabaseOpen()) { openXopcDatabase(); }` pattern.
+*/
+function requireXopcDatabase(options) {
+	if (!cachedDatabase) openXopcDatabase(options ?? {});
+	return cachedDatabase;
+}
+function isXopcDatabaseOpen() {
+	return cachedDatabase !== null;
+}
+function closeXopcDatabase() {
+	if (!cachedDatabase) return;
+	const { db, path, walMaintenance } = cachedDatabase;
+	try {
+		walMaintenance.close();
+	} catch (error) {
+		const em = error instanceof Error ? error.message : String(error);
+		log.warn({
+			err: error instanceof Error ? error : void 0,
+			errorMessage: em,
+			path
+		}, `SQLite close checkpoint failed: ${em}`);
+	}
+	try {
+		db.close();
+	} catch (error) {
+		const em = error instanceof Error ? error.message : String(error);
+		log.warn({
+			err: error instanceof Error ? error : void 0,
+			errorMessage: em,
+			path
+		}, `SQLite database close failed: ${em}`);
+	}
+	cachedDatabase = null;
+	log.debug({ path }, "Closed xopc SQLite database");
+}
+/** Test-only: reset singleton without touching files on disk. */
+function resetXopcDatabaseSingletonForTest() {
+	cachedDatabase = null;
+}
+//#endregion
+export { closeXopcDatabase, getXopcDatabase, isXopcDatabaseOpen, openXopcDatabase, requireXopcDatabase, resetXopcDatabaseSingletonForTest };
+
+//# sourceMappingURL=connection.js.map

package/dist/src/storage/sqlite/connection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"connection.js","names":[],"sources":["../../../../src/storage/sqlite/connection.ts"],"sourcesContent":["import fs from 'node:fs';\nimport childProcess from 'node:child_process';\nimport path from 'node:path';\nimport type { DatabaseSync } from 'node:sqlite';\n\nimport { requireNodeSqlite } from '../../infra/node-sqlite.js';\nimport { installSqliteTransientRejectionHandler } from '../../infra/unhandled-rejections.js';\nimport { createLogger } from '../../utils/logger.js';\nimport { resolveXopcDatabasePath } from './paths.js';\nimport { ensureXopcDatabaseSchema } from './schema.js';\n\nconst log = createLogger('Sqlite:Connection');\n\nconst XOPC_SQLITE_BUSY_TIMEOUT_MS = 30_000;\nconst DB_DIR_MODE = 0o700;\nconst DB_FILE_MODE = 0o600;\nconst DB_SIDECAR_SUFFIXES = ['', '-shm', '-wal'] as const;\nconst LINUX_NFS_SUPER_MAGIC = 0x6969;\nconst PROC_MOUNTINFO_PATH = '/proc/self/mountinfo';\nconst MAX_TIMER_TIMEOUT_MS = 2 ** 31 - 1;\n\ntype IntervalHandle = ReturnType<typeof setInterval> & { unref?: () => void };\ntype SqliteWalCheckpointMode = 'PASSIVE' | 'FULL' | 'RESTART' | 'TRUNCATE';\n\nexport type SqliteWalMaintenance = {\n  checkpoint: () => boolean;\n  close: () => boolean;\n};\n\nexport type SqliteConnectionPragmaOptions = {\n  autoCheckpointPages?: number;\n  checkpointIntervalMs?: number;\n  checkpointMode?: SqliteWalCheckpointMode;\n  busyTimeoutMs?: number;\n  foreignKeys?: boolean;\n  synchronous?: 'NORMAL';\n  databasePath?: string;\n  onCheckpointError?: (error: unknown) => void;\n};\n\nfunction normalizeNonNegativeInteger(value: number, label: string): number {\n  if (!Number.isInteger(value) || value < 0) {\n    throw new Error(`${label} must be a non-negative integer`);\n  }\n  return value;\n}\n\n// ---------------------------------------------------------------------------\n// NFS detection — refuse WAL on NFS-backed volumes (openclaw parity)\n// ---------------------------------------------------------------------------\n\nfunction findExistingVolumePath(targetPath: string): string | null {\n  let current = path.resolve(targetPath);\n  while (true) {\n    try {\n      const stats = fs.statSync(current);\n      return stats.isDirectory() ? current : path.dirname(current);\n    } catch {\n      const parent = path.dirname(current);\n      if (parent === current) return null;\n      current = parent;\n    }\n  }\n}\n\nfunction decodeMountPath(value: string): string {\n  return value.replace(/\\\\([0-7]{3})/g, (_match, octal: string) =>\n    String.fromCharCode(Number.parseInt(octal, 8)),\n  );\n}\n\nfunction parseProcMountInfoEntries(\n  contents: string,\n): Array<{ mountPoint: string; fsType: string }> {\n  const entries: Array<{ mountPoint: string; fsType: string }> = [];\n  for (const line of contents.split('\\n')) {\n    const separator = line.indexOf(' - ');\n    if (separator === -1) continue;\n    const fields = line.slice(0, separator).split(' ');\n    const suffixFields = line.slice(separator + 3).split(' ');\n    const mountPoint = fields[4];\n    const fsType = suffixFields[0];\n    if (mountPoint && fsType) {\n      entries.push({ mountPoint: decodeMountPath(mountPoint), fsType });\n    }\n  }\n  return entries;\n}\n\nfunction parseMountCommandEntries(contents: string): Array<{ mountPoint: string; fsType: string }> {\n  const entries: Array<{ mountPoint: string; fsType: string }> = [];\n  for (const line of contents.split('\\n')) {\n    // Linux: /dev/sda1 on /mnt type ext4 (rw,relatime)\n    const linuxMatch = /^.* on (.+) type ([^,\\s)]+) \\(/.exec(line);\n    if (linuxMatch) {\n      entries.push({ mountPoint: linuxMatch[1], fsType: linuxMatch[2] });\n      continue;\n    }\n    // macOS/BSD: //host/share on /Volumes/share (nfs, nodev, nosuid)\n    const bsdMatch = /^.* on (.+) \\(([^,\\s)]+)/.exec(line);\n    if (bsdMatch) {\n      entries.push({ mountPoint: bsdMatch[1], fsType: bsdMatch[2] });\n    }\n  }\n  return entries;\n}\n\nfunction readMountEntries(): Array<{ mountPoint: string; fsType: string }> {\n  try {\n    return parseProcMountInfoEntries(fs.readFileSync(PROC_MOUNTINFO_PATH, 'utf8'));\n  } catch {\n    // macOS/BSD: fall through to mount command\n  }\n  try {\n    return parseMountCommandEntries(String(childProcess.execFileSync('mount', [])));\n  } catch {\n    return [];\n  }\n}\n\nfunction isPathWithinMount(targetPath: string, mountPoint: string): boolean {\n  const resolvedTarget = path.resolve(targetPath);\n  const resolvedMountPoint = path.resolve(mountPoint);\n  return (\n    resolvedTarget === resolvedMountPoint ||\n    resolvedMountPoint === path.parse(resolvedMountPoint).root ||\n    resolvedTarget.startsWith(`${resolvedMountPoint}${path.sep}`)\n  );\n}\n\nfunction isNfsMountType(fsType: string): boolean {\n  return fsType.toLowerCase().startsWith('nfs');\n}\n\nfunction isNfsMountEntryPath(targetPath: string): boolean {\n  const mountEntry = readMountEntries()\n    .filter((entry) => isPathWithinMount(targetPath, entry.mountPoint))\n    .toSorted((a, b) => b.mountPoint.length - a.mountPoint.length)[0];\n  return mountEntry ? isNfsMountType(mountEntry.fsType) : false;\n}\n\nfunction isNfsBackedPath(targetPath: string): boolean {\n  if (typeof fs.statfsSync !== 'function') {\n    return isNfsMountEntryPath(targetPath);\n  }\n  const checkedPath = findExistingVolumePath(targetPath);\n  if (!checkedPath) return false;\n  try {\n    if (fs.statfsSync(checkedPath).type === LINUX_NFS_SUPER_MAGIC) return true;\n  } catch {\n    return isNfsMountEntryPath(checkedPath);\n  }\n  return isNfsMountEntryPath(checkedPath);\n}\n\nfunction readJournalModeResult(row: unknown): string | null {\n  if (!row || typeof row !== 'object') return null;\n  const record = row as Record<string, unknown>;\n  const value = record.journal_mode ?? Object.values(record)[0];\n  return typeof value === 'string' ? value.toLowerCase() : null;\n}\n\nfunction requireRollbackJournalMode(db: DatabaseSync, dbPath: string): void {\n  const row = db.prepare('PRAGMA journal_mode = DELETE;').get();\n  const mode = readJournalModeResult(row);\n  if (mode !== 'delete') {\n    throw new Error(\n      `xopc.db at ${dbPath} is on an NFS-backed volume but SQLite kept journal_mode=${mode ?? 'unknown'}. ` +\n        `WAL mode is unsafe on NFS. Move ~/.xopc to a local filesystem, or set XOPC_STATE_DIR to a local path.`,\n    );\n  }\n}\n\n// ---------------------------------------------------------------------------\n// Unified PRAGMA + WAL configuration (openclaw parity)\n// ---------------------------------------------------------------------------\n\nfunction configureSqliteConnectionPragmas(\n  db: DatabaseSync,\n  options: SqliteConnectionPragmaOptions = {},\n): SqliteWalMaintenance {\n  // Set busy_timeout before journal_mode to avoid lock-retry ordering issues\n  const busyTimeoutMs = options.busyTimeoutMs ?? XOPC_SQLITE_BUSY_TIMEOUT_MS;\n  db.exec(`PRAGMA busy_timeout = ${normalizeNonNegativeInteger(busyTimeoutMs, 'busyTimeoutMs')};`);\n\n  // NFS detection: refuse WAL, force DELETE mode\n  if (options.databasePath && isNfsBackedPath(options.databasePath)) {\n    requireRollbackJournalMode(db, options.databasePath);\n    // No WAL checkpoint timer needed on DELETE mode\n    return { checkpoint: () => true, close: () => true };\n  }\n\n  // WAL setup\n  db.exec('PRAGMA journal_mode = WAL;');\n  const autoCheckpointPages = normalizeNonNegativeInteger(\n    options.autoCheckpointPages ?? 1000,\n    'autoCheckpointPages',\n  );\n  db.exec(`PRAGMA wal_autocheckpoint = ${autoCheckpointPages};`);\n\n  // Remaining pragmas in safe order\n  if (options.synchronous) db.exec(`PRAGMA synchronous = ${options.synchronous};`);\n  if (options.foreignKeys) db.exec('PRAGMA foreign_keys = ON;');\n\n  // Periodic checkpoint timer\n  const checkpointMode = options.checkpointMode ?? 'TRUNCATE';\n  const periodicCheckpointMode = options.checkpointMode ?? 'PASSIVE';\n  const checkpointIntervalMs = normalizeNonNegativeInteger(\n    options.checkpointIntervalMs ?? 30 * 60 * 1000,\n    'checkpointIntervalMs',\n  );\n\n  const runCheckpoint = (mode: SqliteWalCheckpointMode): boolean => {\n    try {\n      db.exec(`PRAGMA wal_checkpoint(${mode});`);\n      return true;\n    } catch (error) {\n      options.onCheckpointError?.(error);\n      return false;\n    }\n  };\n\n  let timer: IntervalHandle | null = null;\n  if (checkpointIntervalMs > 0) {\n    const timerIntervalMs = Math.min(checkpointIntervalMs, MAX_TIMER_TIMEOUT_MS);\n    timer = setInterval(() => runCheckpoint(periodicCheckpointMode), timerIntervalMs) as IntervalHandle;\n    timer.unref?.();\n  }\n\n  return {\n    checkpoint: () => runCheckpoint(checkpointMode),\n    close: () => {\n      if (timer) { clearInterval(timer); timer = null; }\n      return runCheckpoint(checkpointMode);\n    },\n  };\n}\n\n// ---------------------------------------------------------------------------\n// Database lifecycle\n// ---------------------------------------------------------------------------\n\nexport type XopcDatabase = {\n  db: DatabaseSync;\n  path: string;\n  walMaintenance: SqliteWalMaintenance;\n};\n\nexport type OpenXopcDatabaseOptions = {\n  path?: string;\n  env?: NodeJS.ProcessEnv;\n};\n\nlet cachedDatabase: XopcDatabase | null = null;\n\nfunction ensureDatabasePermissions(pathname: string): void {\n  const dir = pathname.slice(0, Math.max(pathname.lastIndexOf('/'), pathname.lastIndexOf('\\\\')));\n  if (dir) {\n    fs.mkdirSync(dir, { recursive: true });\n    fs.chmodSync(dir, DB_DIR_MODE);\n  }\n  for (const suffix of DB_SIDECAR_SUFFIXES) {\n    const candidate = `${pathname}${suffix}`;\n    if (!fs.existsSync(candidate)) continue;\n    fs.chmodSync(candidate, DB_FILE_MODE);\n  }\n}\n\nfunction openDatabaseAtPath(pathname: string): XopcDatabase {\n  installSqliteTransientRejectionHandler();\n  ensureDatabasePermissions(pathname);\n\n  const { DatabaseSync } = requireNodeSqlite();\n  const db = new DatabaseSync(pathname);\n\n  // Single call: busy_timeout (30s) → WAL/NFS detection → synchronous → foreign_keys → checkpoint timer\n  const walMaintenance = configureSqliteConnectionPragmas(db, {\n    databasePath: pathname,\n    synchronous: 'NORMAL',\n    foreignKeys: true,\n    onCheckpointError: (error) => {\n      const em = error instanceof Error ? error.message : String(error);\n      log.warn({ err: error instanceof Error ? error : undefined, errorMessage: em }, `SQLite WAL checkpoint failed: ${em}`);\n    },\n  });\n\n  ensureXopcDatabaseSchema(db);\n  ensureDatabasePermissions(pathname);\n\n  log.info({ path: pathname }, 'Opened xopc SQLite database');\n  return { db, path: pathname, walMaintenance };\n}\n\nexport function openXopcDatabase(options: OpenXopcDatabaseOptions = {}): XopcDatabase {\n  const env = options.env ?? process.env;\n  const pathname = options.path ?? resolveXopcDatabasePath(env);\n\n  if (cachedDatabase && cachedDatabase.path === pathname) {\n    return cachedDatabase;\n  }\n\n  if (cachedDatabase) {\n    closeXopcDatabase();\n  }\n\n  cachedDatabase = openDatabaseAtPath(pathname);\n  return cachedDatabase;\n}\n\nexport function getXopcDatabase(): XopcDatabase {\n  if (!cachedDatabase) {\n    throw new Error('xopc SQLite database is not open; call openXopcDatabase() first');\n  }\n  return cachedDatabase;\n}\n\n/**\n * Ensure the xopc SQLite database is open and return it.\n * Opens with default path if not already open. Use this instead of\n * the repetitive `if (!isXopcDatabaseOpen()) { openXopcDatabase(); }` pattern.\n */\nexport function requireXopcDatabase(options?: OpenXopcDatabaseOptions): XopcDatabase {\n  if (!cachedDatabase) {\n    openXopcDatabase(options ?? {});\n  }\n  return cachedDatabase!;\n}\n\nexport function isXopcDatabaseOpen(): boolean {\n  return cachedDatabase !== null;\n}\n\nexport function closeXopcDatabase(): void {\n  if (!cachedDatabase) {\n    return;\n  }\n\n  const { db, path, walMaintenance } = cachedDatabase;\n  try {\n    walMaintenance.close();\n  } catch (error) {\n    const em = error instanceof Error ? error.message : String(error);\n    log.warn({ err: error instanceof Error ? error : undefined, errorMessage: em, path }, `SQLite close checkpoint failed: ${em}`);\n  }\n\n  try {\n    db.close();\n  } catch (error) {\n    const em = error instanceof Error ? error.message : String(error);\n    log.warn({ err: error instanceof Error ? error : undefined, errorMessage: em, path }, `SQLite database close failed: ${em}`);\n  }\n\n  cachedDatabase = null;\n  log.debug({ path }, 'Closed xopc SQLite database');\n}\n\n/** Test-only: reset singleton without touching files on disk. */\nexport function resetXopcDatabaseSingletonForTest(): void {\n  cachedDatabase = null;\n}\n"],"mappings":"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"}

package/dist/src/storage/sqlite/cron-run-repository.d.ts

@@ -0,0 +1,5 @@
+import type { JobExecution } from '../../cron/execution-types.js';
+export declare function appendCronRun(execution: JobExecution): void;
+export declare function readCronJobHistory(jobId: string, limit: number): JobExecution[];
+export declare function readAllCronRuns(limit: number): JobExecution[];
+export declare function deleteCronRunsForJob(jobId: string): void;

package/dist/src/storage/sqlite/cron-run-repository.js

@@ -0,0 +1,97 @@
+import { getSqliteDatabase, runSqliteWriteTransaction } from "./transaction.js";
+//#region src/storage/sqlite/cron-run-repository.ts
+const MAX_RUNS_PER_JOB = 2e3;
+const TRIM_TO_RUNS = 1500;
+function rowToExecution(row) {
+	return {
+		id: row.run_id,
+		jobId: row.job_id,
+		status: row.status,
+		startedAt: new Date(row.started_at).toISOString(),
+		endedAt: row.ended_at != null ? new Date(row.ended_at).toISOString() : void 0,
+		duration: row.duration_ms ?? void 0,
+		error: row.error ?? void 0,
+		output: row.output ?? void 0,
+		retryCount: row.retry_count,
+		summary: row.summary ?? void 0,
+		sessionId: row.session_id ?? void 0,
+		sessionKey: row.session_key ?? void 0,
+		sessionType: row.session_type ?? void 0,
+		model: row.model ?? void 0,
+		provider: row.provider ?? void 0,
+		usage: row.usage_json ? JSON.parse(row.usage_json) : void 0,
+		workflowRunId: row.workflow_run_id ?? void 0
+	};
+}
+function executionToInsert(execution) {
+	const startedAt = Date.parse(execution.startedAt);
+	const endedAt = execution.endedAt ? Date.parse(execution.endedAt) : null;
+	return {
+		run_id: execution.id,
+		job_id: execution.jobId,
+		status: execution.status,
+		started_at: startedAt,
+		ended_at: endedAt,
+		duration_ms: execution.duration ?? null,
+		error: execution.error ?? null,
+		output: execution.output ?? null,
+		retry_count: execution.retryCount,
+		summary: execution.summary ?? null,
+		session_id: execution.sessionId ?? null,
+		session_key: execution.sessionKey ?? null,
+		session_type: execution.sessionType ?? null,
+		model: execution.model ?? null,
+		provider: execution.provider ?? null,
+		usage_json: execution.usage ? JSON.stringify(execution.usage) : null,
+		workflow_run_id: execution.workflowRunId ?? null
+	};
+}
+function trimJobRuns(db, jobId) {
+	const countRow = db.prepare(`SELECT COUNT(*) AS count FROM cron_runs WHERE job_id = ?`).get(jobId);
+	if (countRow.count <= MAX_RUNS_PER_JOB) return;
+	const excess = countRow.count - TRIM_TO_RUNS;
+	db.prepare(`DELETE FROM cron_runs WHERE run_id IN (
+       SELECT run_id FROM cron_runs WHERE job_id = ?
+       ORDER BY started_at ASC LIMIT ?
+     )`).run(jobId, excess);
+}
+function appendCronRun(execution) {
+	if (execution.status === "running") return;
+	const row = executionToInsert(execution);
+	runSqliteWriteTransaction((db) => {
+		db.prepare(`INSERT OR REPLACE INTO cron_runs (
+        run_id, job_id, status, started_at, ended_at, duration_ms,
+        error, output, retry_count, summary, session_id, session_key,
+        session_type, model, provider, usage_json, workflow_run_id
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(row.run_id, row.job_id, row.status, row.started_at, row.ended_at, row.duration_ms, row.error, row.output, row.retry_count, row.summary, row.session_id, row.session_key, row.session_type, row.model, row.provider, row.usage_json, row.workflow_run_id);
+		trimJobRuns(db, row.job_id);
+	});
+}
+function readCronJobHistory(jobId, limit) {
+	if (limit <= 0) return [];
+	return getSqliteDatabase().prepare(`SELECT run_id, job_id, status, started_at, ended_at, duration_ms,
+              error, output, retry_count, summary, session_id, session_key,
+              session_type, model, provider, usage_json, workflow_run_id
+       FROM cron_runs
+       WHERE job_id = ?
+       ORDER BY started_at DESC
+       LIMIT ?`).all(jobId, limit).map(rowToExecution);
+}
+function readAllCronRuns(limit) {
+	if (limit <= 0) return [];
+	return getSqliteDatabase().prepare(`SELECT run_id, job_id, status, started_at, ended_at, duration_ms,
+              error, output, retry_count, summary, session_id, session_key,
+              session_type, model, provider, usage_json, workflow_run_id
+       FROM cron_runs
+       ORDER BY started_at DESC
+       LIMIT ?`).all(limit).map(rowToExecution);
+}
+function deleteCronRunsForJob(jobId) {
+	runSqliteWriteTransaction((db) => {
+		db.prepare(`DELETE FROM cron_runs WHERE job_id = ?`).run(jobId);
+	});
+}
+//#endregion
+export { appendCronRun, deleteCronRunsForJob, readAllCronRuns, readCronJobHistory };
+
+//# sourceMappingURL=cron-run-repository.js.map

package/dist/src/storage/sqlite/cron-run-repository.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cron-run-repository.js","names":[],"sources":["../../../../src/storage/sqlite/cron-run-repository.ts"],"sourcesContent":["import type { JobExecution } from '../../cron/execution-types.js';\nimport { getSqliteDatabase, runSqliteWriteTransaction } from './transaction.js';\n\nconst MAX_RUNS_PER_JOB = 2000;\nconst TRIM_TO_RUNS = 1500;\n\ntype CronRunRow = {\n  run_id: string;\n  job_id: string;\n  status: string;\n  started_at: number;\n  ended_at: number | null;\n  duration_ms: number | null;\n  error: string | null;\n  output: string | null;\n  retry_count: number;\n  summary: string | null;\n  session_id: string | null;\n  session_key: string | null;\n  session_type: string | null;\n  model: string | null;\n  provider: string | null;\n  usage_json: string | null;\n  workflow_run_id: string | null;\n};\n\nfunction rowToExecution(row: CronRunRow): JobExecution {\n  return {\n    id: row.run_id,\n    jobId: row.job_id,\n    status: row.status as JobExecution['status'],\n    startedAt: new Date(row.started_at).toISOString(),\n    endedAt: row.ended_at != null ? new Date(row.ended_at).toISOString() : undefined,\n    duration: row.duration_ms ?? undefined,\n    error: row.error ?? undefined,\n    output: row.output ?? undefined,\n    retryCount: row.retry_count,\n    summary: row.summary ?? undefined,\n    sessionId: row.session_id ?? undefined,\n    sessionKey: row.session_key ?? undefined,\n    sessionType: row.session_type ?? undefined,\n    model: row.model ?? undefined,\n    provider: row.provider ?? undefined,\n    usage: row.usage_json ? (JSON.parse(row.usage_json) as JobExecution['usage']) : undefined,\n    workflowRunId: row.workflow_run_id ?? undefined,\n  };\n}\n\nfunction executionToInsert(execution: JobExecution): CronRunRow {\n  const startedAt = Date.parse(execution.startedAt);\n  const endedAt = execution.endedAt ? Date.parse(execution.endedAt) : null;\n  return {\n    run_id: execution.id,\n    job_id: execution.jobId,\n    status: execution.status,\n    started_at: startedAt,\n    ended_at: endedAt,\n    duration_ms: execution.duration ?? null,\n    error: execution.error ?? null,\n    output: execution.output ?? null,\n    retry_count: execution.retryCount,\n    summary: execution.summary ?? null,\n    session_id: execution.sessionId ?? null,\n    session_key: execution.sessionKey ?? null,\n    session_type: execution.sessionType ?? null,\n    model: execution.model ?? null,\n    provider: execution.provider ?? null,\n    usage_json: execution.usage ? JSON.stringify(execution.usage) : null,\n    workflow_run_id: execution.workflowRunId ?? null,\n  };\n}\n\nfunction trimJobRuns(db: ReturnType<typeof getSqliteDatabase>, jobId: string): void {\n  const countRow = db\n    .prepare(`SELECT COUNT(*) AS count FROM cron_runs WHERE job_id = ?`)\n    .get(jobId) as { count: number };\n  if (countRow.count <= MAX_RUNS_PER_JOB) {\n    return;\n  }\n  const excess = countRow.count - TRIM_TO_RUNS;\n  db.prepare(\n    `DELETE FROM cron_runs WHERE run_id IN (\n       SELECT run_id FROM cron_runs WHERE job_id = ?\n       ORDER BY started_at ASC LIMIT ?\n     )`,\n  ).run(jobId, excess);\n}\n\nexport function appendCronRun(execution: JobExecution): void {\n  if (execution.status === 'running') {\n    return;\n  }\n  const row = executionToInsert(execution);\n  runSqliteWriteTransaction((db) => {\n    db.prepare(\n      `INSERT OR REPLACE INTO cron_runs (\n        run_id, job_id, status, started_at, ended_at, duration_ms,\n        error, output, retry_count, summary, session_id, session_key,\n        session_type, model, provider, usage_json, workflow_run_id\n      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,\n    ).run(\n      row.run_id,\n      row.job_id,\n      row.status,\n      row.started_at,\n      row.ended_at,\n      row.duration_ms,\n      row.error,\n      row.output,\n      row.retry_count,\n      row.summary,\n      row.session_id,\n      row.session_key,\n      row.session_type,\n      row.model,\n      row.provider,\n      row.usage_json,\n      row.workflow_run_id,\n    );\n    trimJobRuns(db, row.job_id);\n  });\n}\n\nexport function readCronJobHistory(jobId: string, limit: number): JobExecution[] {\n  if (limit <= 0) {\n    return [];\n  }\n  const db = getSqliteDatabase();\n  const rows = db\n    .prepare(\n      `SELECT run_id, job_id, status, started_at, ended_at, duration_ms,\n              error, output, retry_count, summary, session_id, session_key,\n              session_type, model, provider, usage_json, workflow_run_id\n       FROM cron_runs\n       WHERE job_id = ?\n       ORDER BY started_at DESC\n       LIMIT ?`,\n    )\n    .all(jobId, limit) as CronRunRow[];\n  return rows.map(rowToExecution);\n}\n\nexport function readAllCronRuns(limit: number): JobExecution[] {\n  if (limit <= 0) {\n    return [];\n  }\n  const db = getSqliteDatabase();\n  const rows = db\n    .prepare(\n      `SELECT run_id, job_id, status, started_at, ended_at, duration_ms,\n              error, output, retry_count, summary, session_id, session_key,\n              session_type, model, provider, usage_json, workflow_run_id\n       FROM cron_runs\n       ORDER BY started_at DESC\n       LIMIT ?`,\n    )\n    .all(limit) as CronRunRow[];\n  return rows.map(rowToExecution);\n}\n\nexport function deleteCronRunsForJob(jobId: string): void {\n  runSqliteWriteTransaction((db) => {\n    db.prepare(`DELETE FROM cron_runs WHERE job_id = ?`).run(jobId);\n  });\n}\n"],"mappings":";;AAGA,MAAM,mBAAmB;AACzB,MAAM,eAAe;AAsBrB,SAAS,eAAe,KAA+B;AACrD,QAAO;EACL,IAAI,IAAI;EACR,OAAO,IAAI;EACX,QAAQ,IAAI;EACZ,WAAW,IAAI,KAAK,IAAI,WAAW,CAAC,aAAa;EACjD,SAAS,IAAI,YAAY,OAAO,IAAI,KAAK,IAAI,SAAS,CAAC,aAAa,GAAG,KAAA;EACvE,UAAU,IAAI,eAAe,KAAA;EAC7B,OAAO,IAAI,SAAS,KAAA;EACpB,QAAQ,IAAI,UAAU,KAAA;EACtB,YAAY,IAAI;EAChB,SAAS,IAAI,WAAW,KAAA;EACxB,WAAW,IAAI,cAAc,KAAA;EAC7B,YAAY,IAAI,eAAe,KAAA;EAC/B,aAAa,IAAI,gBAAgB,KAAA;EACjC,OAAO,IAAI,SAAS,KAAA;EACpB,UAAU,IAAI,YAAY,KAAA;EAC1B,OAAO,IAAI,aAAc,KAAK,MAAM,IAAI,WAAW,GAA6B,KAAA;EAChF,eAAe,IAAI,mBAAmB,KAAA;EACvC;;AAGH,SAAS,kBAAkB,WAAqC;CAC9D,MAAM,YAAY,KAAK,MAAM,UAAU,UAAU;CACjD,MAAM,UAAU,UAAU,UAAU,KAAK,MAAM,UAAU,QAAQ,GAAG;AACpE,QAAO;EACL,QAAQ,UAAU;EAClB,QAAQ,UAAU;EAClB,QAAQ,UAAU;EAClB,YAAY;EACZ,UAAU;EACV,aAAa,UAAU,YAAY;EACnC,OAAO,UAAU,SAAS;EAC1B,QAAQ,UAAU,UAAU;EAC5B,aAAa,UAAU;EACvB,SAAS,UAAU,WAAW;EAC9B,YAAY,UAAU,aAAa;EACnC,aAAa,UAAU,cAAc;EACrC,cAAc,UAAU,eAAe;EACvC,OAAO,UAAU,SAAS;EAC1B,UAAU,UAAU,YAAY;EAChC,YAAY,UAAU,QAAQ,KAAK,UAAU,UAAU,MAAM,GAAG;EAChE,iBAAiB,UAAU,iBAAiB;EAC7C;;AAGH,SAAS,YAAY,IAA0C,OAAqB;CAClF,MAAM,WAAW,GACd,QAAQ,2DAA2D,CACnE,IAAI,MAAM;AACb,KAAI,SAAS,SAAS,iBACpB;CAEF,MAAM,SAAS,SAAS,QAAQ;AAChC,IAAG,QACD;;;QAID,CAAC,IAAI,OAAO,OAAO;;AAGtB,SAAgB,cAAc,WAA+B;AAC3D,KAAI,UAAU,WAAW,UACvB;CAEF,MAAM,MAAM,kBAAkB,UAAU;AACxC,4BAA2B,OAAO;AAChC,KAAG,QACD;;;;oEAKD,CAAC,IACA,IAAI,QACJ,IAAI,QACJ,IAAI,QACJ,IAAI,YACJ,IAAI,UACJ,IAAI,aACJ,IAAI,OACJ,IAAI,QACJ,IAAI,aACJ,IAAI,SACJ,IAAI,YACJ,IAAI,aACJ,IAAI,cACJ,IAAI,OACJ,IAAI,UACJ,IAAI,YACJ,IAAI,gBACL;AACD,cAAY,IAAI,IAAI,OAAO;GAC3B;;AAGJ,SAAgB,mBAAmB,OAAe,OAA+B;AAC/E,KAAI,SAAS,EACX,QAAO,EAAE;AAcX,QAZW,mBACI,CACZ,QACC;;;;;;gBAOD,CACA,IAAI,OAAO,MACH,CAAC,IAAI,eAAe;;AAGjC,SAAgB,gBAAgB,OAA+B;AAC7D,KAAI,SAAS,EACX,QAAO,EAAE;AAaX,QAXW,mBACI,CACZ,QACC;;;;;gBAMD,CACA,IAAI,MACI,CAAC,IAAI,eAAe;;AAGjC,SAAgB,qBAAqB,OAAqB;AACxD,4BAA2B,OAAO;AAChC,KAAG,QAAQ,yCAAyC,CAAC,IAAI,MAAM;GAC/D"}

package/dist/src/storage/sqlite/fts.d.ts

@@ -0,0 +1,2 @@
+/** Quote a user query for FTS5 phrase/prefix-safe matching. */
+export declare function escapeFts5Query(raw: string): string;

package/dist/src/storage/sqlite/fts.js

@@ -0,0 +1,11 @@
+//#region src/storage/sqlite/fts.ts
+/** Quote a user query for FTS5 phrase/prefix-safe matching. */
+function escapeFts5Query(raw) {
+	const trimmed = raw.trim();
+	if (!trimmed) return "";
+	return `"${trimmed.replace(/"/g, "\"\"")}"`;
+}
+//#endregion
+export { escapeFts5Query };
+
+//# sourceMappingURL=fts.js.map

package/dist/src/storage/sqlite/fts.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fts.js","names":[],"sources":["../../../../src/storage/sqlite/fts.ts"],"sourcesContent":["/** Quote a user query for FTS5 phrase/prefix-safe matching. */\nexport function escapeFts5Query(raw: string): string {\n  const trimmed = raw.trim();\n  if (!trimmed) {\n    return '';\n  }\n  return `\"${trimmed.replace(/\"/g, '\"\"')}\"`;\n}\n"],"mappings":";;AACA,SAAgB,gBAAgB,KAAqB;CACnD,MAAM,UAAU,IAAI,MAAM;AAC1B,KAAI,CAAC,QACH,QAAO;AAET,QAAO,IAAI,QAAQ,QAAQ,MAAM,OAAK,CAAC"}

package/dist/src/storage/sqlite/index.d.ts

@@ -0,0 +1,12 @@
+export { resolveXopcDatabasePath, XOPC_DB_FILENAME } from './paths.js';
+export { XOPC_DB_SCHEMA_VERSION, SCHEMA_META_SCHEMA_VERSION_KEY, ensureXopcDatabaseSchema, readSchemaVersionForTest, } from './schema.js';
+export { closeXopcDatabase, getXopcDatabase, isXopcDatabaseOpen, openXopcDatabase, requireXopcDatabase, resetXopcDatabaseSingletonForTest, type OpenXopcDatabaseOptions, type XopcDatabase, } from './connection.js';
+export { getSqliteDatabase, runSqliteWriteTransaction } from './transaction.js';
+export { buildDefaultSessionMetadata, extractRoutingFromSessionKey, parseSessionKeySource, resolveAgentIdFromSessionKey, } from './session-metadata.js';
+export { buildGlobalSessionStats, classifyStoredRow, estimateTokensFromMessages, extractFtsContent, metadataToSessionInsert, sessionConfigRowToConfig, sessionRowToMetadata, transcriptEntryRowToStoredRow, type SessionConfigRow, type SessionRow, type TranscriptEntryRow, } from './row-mappers.js';
+export { deleteSessionRecord, ensureSessionRecord, getCurrentTranscriptId, getGlobalSessionStats, findSessionKeyByTranscriptId, getSessionPersistedLevels, getSessionMetadata, incrementSessionStatsOnAppend, listSessionMetadata, listSessionsByAgent, patchSessionMetadata, resetSessionRecord, resolveSessionAgentId, updateSessionStats, } from './session-repository.js';
+export { appendTranscriptEntry, captureCompactionCheckpoint, getCompactionCheckpointDetail, listCompactionCheckpoints, loadCheckpointRows, loadLlmMessagesForSession, loadTranscriptRows, loadTranscriptRowsForSession, paginateTranscriptMessages, replaceTranscriptRows, restoreCompactionCheckpoint, } from './transcript-repository.js';
+export { appendCronRun, deleteCronRunsForJob, readAllCronRuns, readCronJobHistory, } from './cron-run-repository.js';
+export { deleteNoteRecord, getNoteRecord, listNoteRecords, upsertNoteRecord, } from './notes-repository.js';
+export { resolveAgentIdFromMemoriesDir, searchMemoryIndex, syncMemoryIndex, type MemorySearchHit, } from './memory-index-repository.js';
+export { deleteSessionConfig, getSessionConfig, hasSessionConfig, setSessionConfig, updateSessionConfig, } from './config-repository.js';

package/dist/src/storage/sqlite/index.js

@@ -0,0 +1,13 @@
+import { XOPC_DB_FILENAME, resolveXopcDatabasePath } from "../../config/paths-state.js";
+import { SCHEMA_META_SCHEMA_VERSION_KEY, XOPC_DB_SCHEMA_VERSION, ensureXopcDatabaseSchema, readSchemaVersionForTest } from "./schema.js";
+import { closeXopcDatabase, getXopcDatabase, isXopcDatabaseOpen, openXopcDatabase, requireXopcDatabase, resetXopcDatabaseSingletonForTest } from "./connection.js";
+import { getSqliteDatabase, runSqliteWriteTransaction } from "./transaction.js";
+import { buildDefaultSessionMetadata, extractRoutingFromSessionKey, parseSessionKeySource, resolveAgentIdFromSessionKey } from "./session-metadata.js";
+import { buildGlobalSessionStats, classifyStoredRow, estimateTokensFromMessages, extractFtsContent, metadataToSessionInsert, sessionConfigRowToConfig, sessionRowToMetadata, transcriptEntryRowToStoredRow } from "./row-mappers.js";
+import { deleteSessionRecord, ensureSessionRecord, findSessionKeyByTranscriptId, getCurrentTranscriptId, getGlobalSessionStats, getSessionMetadata, getSessionPersistedLevels, incrementSessionStatsOnAppend, listSessionMetadata, listSessionsByAgent, patchSessionMetadata, resetSessionRecord, resolveSessionAgentId, updateSessionStats } from "./session-repository.js";
+import { appendTranscriptEntry, captureCompactionCheckpoint, getCompactionCheckpointDetail, listCompactionCheckpoints, loadCheckpointRows, loadLlmMessagesForSession, loadTranscriptRows, loadTranscriptRowsForSession, paginateTranscriptMessages, replaceTranscriptRows, restoreCompactionCheckpoint } from "./transcript-repository.js";
+import { appendCronRun, deleteCronRunsForJob, readAllCronRuns, readCronJobHistory } from "./cron-run-repository.js";
+import { deleteNoteRecord, getNoteRecord, listNoteRecords, upsertNoteRecord } from "./notes-repository.js";
+import { resolveAgentIdFromMemoriesDir, searchMemoryIndex, syncMemoryIndex } from "./memory-index-repository.js";
+import { deleteSessionConfig, getSessionConfig, hasSessionConfig, setSessionConfig, updateSessionConfig } from "./config-repository.js";
+export { SCHEMA_META_SCHEMA_VERSION_KEY, XOPC_DB_FILENAME, XOPC_DB_SCHEMA_VERSION, appendCronRun, appendTranscriptEntry, buildDefaultSessionMetadata, buildGlobalSessionStats, captureCompactionCheckpoint, classifyStoredRow, closeXopcDatabase, deleteCronRunsForJob, deleteNoteRecord, deleteSessionConfig, deleteSessionRecord, ensureSessionRecord, ensureXopcDatabaseSchema, estimateTokensFromMessages, extractFtsContent, extractRoutingFromSessionKey, findSessionKeyByTranscriptId, getCompactionCheckpointDetail, getCurrentTranscriptId, getGlobalSessionStats, getNoteRecord, getSessionConfig, getSessionMetadata, getSessionPersistedLevels, getSqliteDatabase, getXopcDatabase, hasSessionConfig, incrementSessionStatsOnAppend, isXopcDatabaseOpen, listCompactionCheckpoints, listNoteRecords, listSessionMetadata, listSessionsByAgent, loadCheckpointRows, loadLlmMessagesForSession, loadTranscriptRows, loadTranscriptRowsForSession, metadataToSessionInsert, openXopcDatabase, paginateTranscriptMessages, parseSessionKeySource, patchSessionMetadata, readAllCronRuns, readCronJobHistory, readSchemaVersionForTest, replaceTranscriptRows, requireXopcDatabase, resetSessionRecord, resetXopcDatabaseSingletonForTest, resolveAgentIdFromMemoriesDir, resolveAgentIdFromSessionKey, resolveSessionAgentId, resolveXopcDatabasePath, restoreCompactionCheckpoint, runSqliteWriteTransaction, searchMemoryIndex, sessionConfigRowToConfig, sessionRowToMetadata, setSessionConfig, syncMemoryIndex, transcriptEntryRowToStoredRow, updateSessionConfig, updateSessionStats, upsertNoteRecord };

package/dist/src/storage/sqlite/memory-index-repository.d.ts

@@ -0,0 +1,18 @@
+export type MemorySearchHit = {
+    path: string;
+    lines: string;
+    score: number;
+    lineNumbers: number[];
+};
+export declare function resolveAgentIdFromMemoriesDir(memoriesDir: string | undefined): string;
+export declare function syncMemoryIndex(params: {
+    agentId: string;
+    workspaceDir: string;
+    memoriesDir?: string;
+}): void;
+export declare function searchMemoryIndex(params: {
+    agentId: string;
+    query: string;
+    maxResults?: number;
+    minScore?: number;
+}): MemorySearchHit[];