@mastra/code-sdk 0.0.0-esbuild-bundle-worker-20260807173433

package/dist/utils/storage-factory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage-factory.js","names":[],"sources":["../../src/utils/storage-factory.ts"],"sourcesContent":["/**\n * Storage factory — creates the appropriate storage backend based on resolved config.\n *\n * If PG is selected but fails to connect, falls back to LibSQL so the TUI\n * can start and the user can fix the connection via /settings.\n */\n\nimport type { MastraCompositeStore, RetentionConfig } from '@mastra/core/storage';\nimport type { MastraVector } from '@mastra/core/vector';\nimport { LibSQLStore, LibSQLVector } from '@mastra/libsql';\nimport { PostgresStore } from '@mastra/pg';\n\nimport type { StorageConfig, PgStorageConfig } from './project.js';\nimport { getDatabasePath, getVectorDatabasePath } from './project.js';\nimport { DEFAULT_RETENTION } from './storage-maintenance.js';\n\nexport const MASTRA_CODE_LOCAL_PRAGMAS = {\n  cacheSize: -128000,\n  mmapSize: 536870912,\n};\n\n/**\n * Construct a LibSQL store for an arbitrary url/authToken, applying the same\n * local pragmas the default factory uses.\n */\nexport function buildLibSQLStore(opts: {\n  id?: string;\n  url: string;\n  authToken?: string;\n  retention?: RetentionConfig;\n}): MastraCompositeStore {\n  return new LibSQLStore({\n    id: opts.id ?? 'mastra-code-storage',\n    url: opts.url,\n    ...(opts.authToken ? { authToken: opts.authToken } : {}),\n    ...(opts.retention ? { retention: opts.retention } : {}),\n    localPragmas: MASTRA_CODE_LOCAL_PRAGMAS,\n  });\n}\n\n/** Construct a LibSQL vector store for an arbitrary url/authToken. */\nexport function buildLibSQLVector(opts: { id?: string; url: string; authToken?: string }): MastraVector {\n  return new LibSQLVector({\n    id: opts.id ?? 'mastra-code-vectors',\n    url: opts.url,\n    ...(opts.authToken ? { authToken: opts.authToken } : {}),\n  });\n}\n\nexport interface StorageResult {\n  storage: MastraCompositeStore;\n  /** The effective backend after any fallback logic has run. */\n  backend: 'libsql' | 'pg';\n  /** Non-null when PG was requested but failed — contains a user-facing warning. */\n  warning?: string;\n}\n\nfunction createFallbackLibSQL(): MastraCompositeStore {\n  return buildLibSQLStore({ url: `file:${getDatabasePath()}`, retention: DEFAULT_RETENTION });\n}\n\n/**\n * Create a storage instance from the resolved config.\n *\n * - `libsql` backend → LibSQLStore (always available)\n * - `pg` backend → PostgresStore, falls back to LibSQL on connection failure\n */\nexport async function createStorage(config: StorageConfig): Promise<StorageResult> {\n  if (config.backend === 'pg') {\n    return createPgStorage(config);\n  }\n\n  // Default: LibSQL\n  return {\n    storage: buildLibSQLStore({ url: config.url, authToken: config.authToken, retention: DEFAULT_RETENTION }),\n    backend: 'libsql',\n  };\n}\n\nasync function createPgStorage(config: PgStorageConfig): Promise<StorageResult> {\n  // No connection info → fall back with guidance\n  if (!config.connectionString && !config.host) {\n    return {\n      storage: createFallbackLibSQL(),\n      backend: 'libsql',\n      warning:\n        'PostgreSQL backend selected but no connection info configured. ' +\n        'Using LibSQL fallback. Set a connection string via /settings.',\n    };\n  }\n\n  const base = {\n    id: 'mastra-code-storage' as const,\n    retention: DEFAULT_RETENTION,\n    ...(config.schemaName ? { schemaName: config.schemaName } : {}),\n    ...(config.disableInit ? { disableInit: config.disableInit } : {}),\n    ...(config.skipDefaultIndexes ? { skipDefaultIndexes: config.skipDefaultIndexes } : {}),\n  };\n\n  const store = config.connectionString\n    ? new PostgresStore({ ...base, connectionString: config.connectionString })\n    : new PostgresStore({\n        ...base,\n        host: config.host!,\n        port: config.port,\n        database: config.database,\n        user: config.user,\n        password: config.password,\n      });\n\n  // Test the connection before committing — if it fails, fall back to LibSQL\n  // so the user can fix the config via /settings.\n  try {\n    await store.init();\n  } catch (err: any) {\n    const msg = err?.message ?? String(err);\n    const target = config.connectionString ?? `${config.host}:${config.port ?? 5432}`;\n    try {\n      await store.close();\n    } catch {\n      // ignore cleanup errors\n    }\n    return {\n      storage: createFallbackLibSQL(),\n      backend: 'libsql',\n      warning:\n        `Failed to connect to PostgreSQL at ${target}: ${msg}\\n` +\n        'Using LibSQL fallback. Fix the connection via /settings.',\n    };\n  }\n\n  return { storage: store, backend: 'pg' };\n}\n\n/**\n * Create a vector store for recall search.\n * Uses a separate LibSQL file to avoid bloating the main storage DB with embedding data.\n * For PG backends, reuses the same connection (PG handles the extra tables fine).\n */\nexport async function createVectorStore(\n  config: StorageConfig,\n  effectiveBackend: 'libsql' | 'pg' = config.backend,\n): Promise<MastraVector | undefined> {\n  if (effectiveBackend === 'pg') {\n    // PG can handle vector tables in the same database\n    const pgConfig = config as PgStorageConfig;\n    if (!pgConfig.connectionString && !pgConfig.host) return undefined;\n\n    const { PgVector } = await import('@mastra/pg');\n    return new PgVector({\n      id: 'mastra-code-vectors',\n      connectionString:\n        pgConfig.connectionString ??\n        `postgresql://${pgConfig.user}:${pgConfig.password}@${pgConfig.host}:${pgConfig.port ?? 5432}/${pgConfig.database}`,\n    });\n  }\n\n  // LibSQL: separate file for vectors. Per-tenant configs supply an explicit\n  // vectorUrl so each tenant's recall vectors are isolated; otherwise use the\n  // shared default file.\n  const libsqlConfig = config as { vectorUrl?: string; vectorAuthToken?: string };\n  return buildLibSQLVector({\n    url: libsqlConfig.vectorUrl ?? `file:${getVectorDatabasePath()}`,\n    authToken: libsqlConfig.vectorAuthToken,\n  });\n}\n"],"mappings":";;;;;AAgBA,MAAa,4BAA4B;CACvC,WAAW;CACX,UAAU;AACZ;;;;;AAMA,SAAgB,iBAAiB,MAKR;CACvB,OAAO,IAAI,YAAY;EACrB,IAAI,KAAK,MAAM;EACf,KAAK,KAAK;EACV,GAAI,KAAK,YAAY,EAAE,WAAW,KAAK,UAAU,IAAI,CAAC;EACtD,GAAI,KAAK,YAAY,EAAE,WAAW,KAAK,UAAU,IAAI,CAAC;EACtD,cAAc;CAChB,CAAC;AACH;;AAGA,SAAgB,kBAAkB,MAAsE;CACtG,OAAO,IAAI,aAAa;EACtB,IAAI,KAAK,MAAM;EACf,KAAK,KAAK;EACV,GAAI,KAAK,YAAY,EAAE,WAAW,KAAK,UAAU,IAAI,CAAC;CACxD,CAAC;AACH;AAUA,SAAS,uBAA6C;CACpD,OAAO,iBAAiB;EAAE,KAAK,QAAQ,gBAAgB;EAAK,WAAW;CAAkB,CAAC;AAC5F;;;;;;;AAQA,eAAsB,cAAc,QAA+C;CACjF,IAAI,OAAO,YAAY,MACrB,OAAO,gBAAgB,MAAM;CAI/B,OAAO;EACL,SAAS,iBAAiB;GAAE,KAAK,OAAO;GAAK,WAAW,OAAO;GAAW,WAAW;EAAkB,CAAC;EACxG,SAAS;CACX;AACF;AAEA,eAAe,gBAAgB,QAAiD;CAE9E,IAAI,CAAC,OAAO,oBAAoB,CAAC,OAAO,MACtC,OAAO;EACL,SAAS,qBAAqB;EAC9B,SAAS;EACT,SACE;CAEJ;CAGF,MAAM,OAAO;EACX,IAAI;EACJ,WAAW;EACX,GAAI,OAAO,aAAa,EAAE,YAAY,OAAO,WAAW,IAAI,CAAC;EAC7D,GAAI,OAAO,cAAc,EAAE,aAAa,OAAO,YAAY,IAAI,CAAC;EAChE,GAAI,OAAO,qBAAqB,EAAE,oBAAoB,OAAO,mBAAmB,IAAI,CAAC;CACvF;CAEA,MAAM,QAAQ,OAAO,mBACjB,IAAI,cAAc;EAAE,GAAG;EAAM,kBAAkB,OAAO;CAAiB,CAAC,IACxE,IAAI,cAAc;EAChB,GAAG;EACH,MAAM,OAAO;EACb,MAAM,OAAO;EACb,UAAU,OAAO;EACjB,MAAM,OAAO;EACb,UAAU,OAAO;CACnB,CAAC;CAIL,IAAI;EACF,MAAM,MAAM,KAAK;CACnB,SAAS,KAAU;EACjB,MAAM,MAAM,KAAK,WAAW,OAAO,GAAG;EACtC,MAAM,SAAS,OAAO,oBAAoB,GAAG,OAAO,KAAK,GAAG,OAAO,QAAQ;EAC3E,IAAI;GACF,MAAM,MAAM,MAAM;EACpB,QAAQ,CAER;EACA,OAAO;GACL,SAAS,qBAAqB;GAC9B,SAAS;GACT,SACE,sCAAsC,OAAO,IAAI,IAAI;EAEzD;CACF;CAEA,OAAO;EAAE,SAAS;EAAO,SAAS;CAAK;AACzC;;;;;;AAOA,eAAsB,kBACpB,QACA,mBAAoC,OAAO,SACR;CACnC,IAAI,qBAAqB,MAAM;EAE7B,MAAM,WAAW;EACjB,IAAI,CAAC,SAAS,oBAAoB,CAAC,SAAS,MAAM,OAAO,KAAA;EAEzD,MAAM,EAAE,aAAa,MAAM,OAAO;EAClC,OAAO,IAAI,SAAS;GAClB,IAAI;GACJ,kBACE,SAAS,oBACT,gBAAgB,SAAS,KAAK,GAAG,SAAS,SAAS,GAAG,SAAS,KAAK,GAAG,SAAS,QAAQ,KAAK,GAAG,SAAS;EAC7G,CAAC;CACH;CAKA,MAAM,eAAe;CACrB,OAAO,kBAAkB;EACvB,KAAK,aAAa,aAAa,QAAQ,sBAAsB;EAC7D,WAAW,aAAa;CAC1B,CAAC;AACH"}

package/dist/utils/storage-maintenance.d.ts

@@ -0,0 +1,103 @@
+/**
+ * Storage maintenance — retention defaults and disk reclamation for mastracode.
+ *
+ * Retention (`DEFAULT_RETENTION`) is wired into the inner store by the storage
+ * factory so `storage.prune()` can delete aged rows across every domain,
+ * including the legacy libsql observability spans table.
+ *
+ * `prune()` only deletes rows — SQLite keeps the freed pages inside the file.
+ * `reclaimLibSQLDisk()` returns that space to the OS by streaming a
+ * `VACUUM INTO` copy of each file and swapping it into place. It requires all
+ * connections to be closed first, so it only runs from the post-TUI
+ * maintenance flow. We deliberately do NOT expose VACUUM as a public API on
+ * LibSQLStore.
+ */
+import type { MastraCompositeStore, PruneOptions, PruneResult, RetentionConfig } from '@mastra/core/storage';
+import type { StorageConfig } from './project.js';
+/**
+ * Default retention for mastracode's own storage. Tables not listed are kept
+ * forever. Ages chosen for a local dev tool where observability data dwarfs
+ * everything else (spans have been observed at 17+ GB):
+ * - spans/logs: short-lived debugging telemetry → 14d
+ * - scorer results & workflow snapshots: medium-lived run records → 30d
+ * - chat history (messages/threads): long-lived, user-visible → 90d
+ */
+export declare const DEFAULT_RETENTION: RetentionConfig;
+/** Result of reclaiming disk for one database file (sizes include the WAL). */
+export interface ReclaimResult {
+    file: string;
+    bytesBefore: number;
+    bytesAfter: number;
+}
+/** Handle the TUI uses to run storage maintenance without reaching into store internals. */
+export interface StorageMaintenance {
+    backend: 'libsql' | 'pg';
+    /** Retention policies in effect (for display in /prune output). */
+    retention: RetentionConfig;
+    /** Delete rows older than the retention policies. Safe to re-run; batched and cancellable. `options.retention` replaces the standing policies for this call only. */
+    prune: (options?: PruneOptions) => Promise<PruneResult[]>;
+    /** Close the long-lived storage connection (checkpoints WAL for local libsql). Nothing can use the store afterwards. */
+    closeStorage?: () => Promise<void>;
+    /** Compact local libsql files (VACUUM INTO + swap) to return freed pages to the OS. Only set for local libsql backends. */
+    reclaimDisk?: (onFileStart?: (file: string, bytesBefore: number, liveBytes: number) => void) => Promise<ReclaimResult[]>;
+}
+/** Free bytes required before compacting: the compacted copy plus 20% + 256 MB headroom. */
+export declare function requiredFreeBytes(liveBytes: number): number;
+/**
+ * Compact each local libsql db file by streaming a `VACUUM INTO` copy next to
+ * it, then swapping the copy into place. Reports before/after sizes.
+ *
+ * Deliberately NOT an in-place `VACUUM`: that copies all live content into a
+ * temp store (held in memory by libsql builds with `temp_store=MEMORY`) and
+ * then rewrites the entire database back through the WAL — on multi-GB
+ * databases that has frozen whole machines via memory/IO exhaustion.
+ * `VACUUM INTO` reads the logical database once and writes the compacted copy
+ * sequentially with bounded memory, and the WAL never grows.
+ *
+ * Each file is preflighted: live bytes are estimated from
+ * `page_count - freelist_count` and the copy is refused unless the volume has
+ * `requiredFreeBytes()` available.
+ *
+ * MUST run with every connection to these files closed (the swap replaces the
+ * inode — a surviving connection would keep writing to the unlinked old file).
+ * `runStorageMaintenance()` closes storage before calling this.
+ */
+export declare function reclaimLibSQLDisk(dbFiles: string[], onFileStart?: (file: string, bytesBefore: number, liveBytes: number) => void): Promise<ReclaimResult[]>;
+/**
+ * Resolve the local libsql db files eligible for checkpoint + VACUUM.
+ * Returns [] for remote (turso) urls and PG backends. When PG was requested
+ * but the factory fell back to libsql, the fallback uses the default files.
+ */
+export declare function resolveLocalDbFiles(config: StorageConfig, effectiveBackend: 'libsql' | 'pg'): string[];
+/**
+ * Build the maintenance handle for the effective storage backend.
+ * `localDbFiles` are the local libsql file paths eligible for VACUUM;
+ * pass an empty array for remote (turso) or PG backends.
+ */
+export declare function createStorageMaintenance(opts: {
+    storage: MastraCompositeStore;
+    backend: 'libsql' | 'pg';
+    retention: RetentionConfig;
+    localDbFiles: string[];
+    /** Closes the vector store's connection; required for local libsql so the compaction swap isn't blocked by our own handle. */
+    closeVector?: () => Promise<void>;
+}): StorageMaintenance;
+export declare function formatBytes(bytes: number): string;
+/**
+ * Run storage maintenance with exclusive access to the database, reporting
+ * progress through `log` (one line per pass so large deletes are visible).
+ *
+ * Must run AFTER the TUI is stopped and background writers are quiesced —
+ * batched deletes and VACUUM contend with live writes (SQLITE_BUSY) and can
+ * starve the event loop that renders the TUI. The storage connection is
+ * closed at the end (checkpointing the WAL for local libsql), so the process
+ * must exit afterwards.
+ */
+export declare function runStorageMaintenance(opts: {
+    maintenance: StorageMaintenance;
+    vacuum: boolean;
+    /** Skip the memory domain (messages/threads) so chat history is preserved. */
+    keepMemory?: boolean;
+    log: (line: string) => void;
+}): Promise<void>;
+//# sourceMappingURL=storage-maintenance.d.ts.map

package/dist/utils/storage-maintenance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage-maintenance.d.ts","sourceRoot":"","sources":["../../src/utils/storage-maintenance.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAKH,OAAO,KAAK,EAAE,oBAAoB,EAAE,YAAY,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAQ7G,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAGlD;;;;;;;GAOG;AACH,eAAO,MAAM,iBAAiB,EAAE,eAe/B,CAAC;AAEF,+EAA+E;AAC/E,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,4FAA4F;AAC5F,MAAM,WAAW,kBAAkB;IACjC,OAAO,EAAE,QAAQ,GAAG,IAAI,CAAC;IACzB,mEAAmE;IACnE,SAAS,EAAE,eAAe,CAAC;IAC3B,qKAAqK;IACrK,KAAK,EAAE,CAAC,OAAO,CAAC,EAAE,YAAY,KAAK,OAAO,CAAC,WAAW,EAAE,CAAC,CAAC;IAC1D,wHAAwH;IACxH,YAAY,CAAC,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IACnC,2HAA2H;IAC3H,WAAW,CAAC,EAAE,CACZ,WAAW,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,KAAK,IAAI,KACzE,OAAO,CAAC,aAAa,EAAE,CAAC,CAAC;CAC/B;AAeD,4FAA4F;AAC5F,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAE3D;AA0BD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAsB,iBAAiB,CACrC,OAAO,EAAE,MAAM,EAAE,EACjB,WAAW,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,KAAK,IAAI,GAC3E,OAAO,CAAC,aAAa,EAAE,CAAC,CA0G1B;AAQD;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,aAAa,EAAE,gBAAgB,EAAE,QAAQ,GAAG,IAAI,GAAG,MAAM,EAAE,CAatG;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,IAAI,EAAE;IAC7C,OAAO,EAAE,oBAAoB,CAAC;IAC9B,OAAO,EAAE,QAAQ,GAAG,IAAI,CAAC;IACzB,SAAS,EAAE,eAAe,CAAC;IAC3B,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,8HAA8H;IAC9H,WAAW,CAAC,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CACnC,GAAG,kBAAkB,CAiBrB;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAWjD;AAKD;;;;;;;;;GASG;AACH,wBAAsB,qBAAqB,CAAC,IAAI,EAAE;IAChD,WAAW,EAAE,kBAAkB,CAAC;IAChC,MAAM,EAAE,OAAO,CAAC;IAChB,8EAA8E;IAC9E,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,GAAG,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;CAC7B,GAAG,OAAO,CAAC,IAAI,CAAC,CA2EhB"}

package/dist/utils/storage-maintenance.js

@@ -0,0 +1,274 @@
+import { getDatabasePath, getVectorDatabasePath } from "./project.js";
+import { closeSync, existsSync, openSync, readSync, renameSync, rmSync, statSync, statfsSync } from "fs";
+import { dirname } from "path";
+import Database from "libsql";
+//#region src/utils/storage-maintenance.ts
+/**
+* Storage maintenance — retention defaults and disk reclamation for mastracode.
+*
+* Retention (`DEFAULT_RETENTION`) is wired into the inner store by the storage
+* factory so `storage.prune()` can delete aged rows across every domain,
+* including the legacy libsql observability spans table.
+*
+* `prune()` only deletes rows — SQLite keeps the freed pages inside the file.
+* `reclaimLibSQLDisk()` returns that space to the OS by streaming a
+* `VACUUM INTO` copy of each file and swapping it into place. It requires all
+* connections to be closed first, so it only runs from the post-TUI
+* maintenance flow. We deliberately do NOT expose VACUUM as a public API on
+* LibSQLStore.
+*/
+/**
+* Default retention for mastracode's own storage. Tables not listed are kept
+* forever. Ages chosen for a local dev tool where observability data dwarfs
+* everything else (spans have been observed at 17+ GB):
+* - spans/logs: short-lived debugging telemetry → 14d
+* - scorer results & workflow snapshots: medium-lived run records → 30d
+* - chat history (messages/threads): long-lived, user-visible → 90d
+*/
+const DEFAULT_RETENTION = {
+	memory: {
+		messages: { maxAge: "90d" },
+		threads: { maxAge: "90d" }
+	},
+	observability: {
+		spans: { maxAge: "14d" },
+		logs: { maxAge: "14d" }
+	},
+	scores: { scorers: { maxAge: "30d" } },
+	workflows: { workflowSnapshot: { maxAge: "30d" } }
+};
+/** db file size + its WAL sidecar, in bytes. Missing files count as 0. */
+function fileSizeWithWal(dbFile) {
+	let total = 0;
+	for (const candidate of [dbFile, `${dbFile}-wal`]) try {
+		total += statSync(candidate).size;
+	} catch {}
+	return total;
+}
+/** Free bytes required before compacting: the compacted copy plus 20% + 256 MB headroom. */
+function requiredFreeBytes(liveBytes) {
+	return Math.ceil(liveBytes * 1.2) + 256 * 1024 * 1024;
+}
+/** First column of the first row of a PRAGMA result, as a number. */
+function pragmaNumber(db, pragma) {
+	const row = db.pragma(pragma)?.[0];
+	return row ? Number(Object.values(row)[0]) : 0;
+}
+/**
+* Journal mode straight from the SQLite file header (bytes 18/19:
+* 1 = rollback journal, 2 = WAL) — readable without opening a connection.
+*/
+function journalModeFromHeader(file) {
+	const fd = openSync(file, "r");
+	try {
+		const buf = Buffer.alloc(2);
+		if (readSync(fd, buf, 0, 2, 18) !== 2) return "unknown";
+		if (buf[0] === 2 && buf[1] === 2) return "wal";
+		if (buf[0] === 1 && buf[1] === 1) return "delete";
+		return "unknown";
+	} finally {
+		closeSync(fd);
+	}
+}
+/**
+* Compact each local libsql db file by streaming a `VACUUM INTO` copy next to
+* it, then swapping the copy into place. Reports before/after sizes.
+*
+* Deliberately NOT an in-place `VACUUM`: that copies all live content into a
+* temp store (held in memory by libsql builds with `temp_store=MEMORY`) and
+* then rewrites the entire database back through the WAL — on multi-GB
+* databases that has frozen whole machines via memory/IO exhaustion.
+* `VACUUM INTO` reads the logical database once and writes the compacted copy
+* sequentially with bounded memory, and the WAL never grows.
+*
+* Each file is preflighted: live bytes are estimated from
+* `page_count - freelist_count` and the copy is refused unless the volume has
+* `requiredFreeBytes()` available.
+*
+* MUST run with every connection to these files closed (the swap replaces the
+* inode — a surviving connection would keep writing to the unlinked old file).
+* `runStorageMaintenance()` closes storage before calling this.
+*/
+async function reclaimLibSQLDisk(dbFiles, onFileStart) {
+	const results = [];
+	for (const file of dbFiles) {
+		if (!existsSync(file) || statSync(file).size < 100) continue;
+		const bytesBefore = fileSizeWithWal(file);
+		const tmp = `${file}.vacuum-tmp`;
+		rmSync(tmp, { force: true });
+		const probe = new Database(file);
+		try {
+			probe.exec("PRAGMA busy_timeout = 2000");
+			probe.exec("PRAGMA journal_mode = WAL");
+			probe.exec("PRAGMA journal_mode = DELETE");
+		} catch {} finally {
+			probe.close();
+		}
+		if (journalModeFromHeader(file) !== "delete") throw new Error(`${file} is in use by another process — is another Mastra Code session running? Close other sessions and run /prune vacuum again.`);
+		const db = new Database(file);
+		try {
+			db.exec("PRAGMA busy_timeout = 2000");
+			const pageSize = pragmaNumber(db, "page_size");
+			const pageCount = pragmaNumber(db, "page_count");
+			const freelistCount = pragmaNumber(db, "freelist_count");
+			const liveBytes = Math.max(0, pageCount - freelistCount) * pageSize;
+			const { bsize, bavail } = statfsSync(dirname(file));
+			const freeBytes = bsize * bavail;
+			if (freeBytes < requiredFreeBytes(liveBytes)) throw new Error(`Not enough free disk space to compact ${file}: need ${formatBytes(requiredFreeBytes(liveBytes))} for a ${formatBytes(liveBytes)} compacted copy, but only ${formatBytes(freeBytes)} is free.`);
+			onFileStart?.(file, bytesBefore, liveBytes);
+			db.exec(`VACUUM INTO '${tmp.replace(/'/g, "''")}'`);
+		} catch (err) {
+			rmSync(tmp, { force: true });
+			throw err;
+		} finally {
+			db.close();
+		}
+		if (journalModeFromHeader(file) !== "delete") {
+			rmSync(tmp, { force: true });
+			throw new Error(`${file} was opened by another process during compaction — is another Mastra Code session running? Close other sessions and run /prune vacuum again.`);
+		}
+		renameSync(file, `${file}.old`);
+		try {
+			rmSync(`${file}-wal`, { force: true });
+			rmSync(`${file}-shm`, { force: true });
+			renameSync(tmp, file);
+		} catch (err) {
+			try {
+				renameSync(`${file}.old`, file);
+			} catch {
+				throw new Error(`Failed to swap compacted copy into place AND failed to restore the original — your data is intact at ${file}.old; rename it back to ${file} manually. Original error: ${err instanceof Error ? err.message : String(err)}`);
+			}
+			rmSync(tmp, { force: true });
+			throw err;
+		}
+		rmSync(`${file}.old`, { force: true });
+		results.push({
+			file,
+			bytesBefore,
+			bytesAfter: fileSizeWithWal(file)
+		});
+	}
+	return results;
+}
+/** `file:/path` or `file:///path` → filesystem path; undefined for non-file urls. */
+function fileUrlToPath(url) {
+	if (!url.startsWith("file:")) return void 0;
+	return url.replace(/^file:\/\//, "").replace(/^file:/, "");
+}
+/**
+* Resolve the local libsql db files eligible for checkpoint + VACUUM.
+* Returns [] for remote (turso) urls and PG backends. When PG was requested
+* but the factory fell back to libsql, the fallback uses the default files.
+*/
+function resolveLocalDbFiles(config, effectiveBackend) {
+	if (effectiveBackend !== "libsql") return [];
+	if (config.backend === "pg") return [getDatabasePath(), getVectorDatabasePath()];
+	if (config.isRemote) return [];
+	const files = [];
+	const main = fileUrlToPath(config.url);
+	if (main) files.push(main);
+	const vector = config.vectorUrl ? fileUrlToPath(config.vectorUrl) : getVectorDatabasePath();
+	if (vector) files.push(vector);
+	return files;
+}
+/**
+* Build the maintenance handle for the effective storage backend.
+* `localDbFiles` are the local libsql file paths eligible for VACUUM;
+* pass an empty array for remote (turso) or PG backends.
+*/
+function createStorageMaintenance(opts) {
+	const { storage, backend, retention, localDbFiles, closeVector } = opts;
+	return {
+		backend,
+		retention,
+		prune: (options) => storage.prune(options),
+		closeStorage: async () => {
+			await storage.close?.();
+			await closeVector?.();
+		},
+		...backend === "libsql" && localDbFiles.length > 0 ? { reclaimDisk: (onFileStart) => reclaimLibSQLDisk(localDbFiles, onFileStart) } : {}
+	};
+}
+function formatBytes(bytes) {
+	if (bytes < 1024) return `${bytes} B`;
+	const units = [
+		"KB",
+		"MB",
+		"GB",
+		"TB"
+	];
+	let value = bytes;
+	let unit = "B";
+	for (const next of units) {
+		if (value < 1024) break;
+		value /= 1024;
+		unit = next;
+	}
+	return `${value.toFixed(1)} ${unit}`;
+}
+/** Rows deleted per table per pass: default batchSize (1000) × 20 batches. */
+const PASS_MAX_BATCHES = 20;
+/**
+* Run storage maintenance with exclusive access to the database, reporting
+* progress through `log` (one line per pass so large deletes are visible).
+*
+* Must run AFTER the TUI is stopped and background writers are quiesced —
+* batched deletes and VACUUM contend with live writes (SQLITE_BUSY) and can
+* starve the event loop that renders the TUI. The storage connection is
+* closed at the end (checkpointing the WAL for local libsql), so the process
+* must exit afterwards.
+*/
+async function runStorageMaintenance(opts) {
+	const { maintenance, vacuum, keepMemory = false, log } = opts;
+	const { memory: _memory, ...withoutMemory } = maintenance.retention;
+	const retentionForRun = keepMemory ? { retention: withoutMemory } : {};
+	log("Pruning rows older than the retention policies:");
+	for (const [domain, tables] of Object.entries(maintenance.retention)) for (const [table, policy] of Object.entries(tables ?? {})) log(`  ${domain}.${table}: ${keepMemory && domain === "memory" ? "kept (keep-memory)" : policy.maxAge}`);
+	const totals = /* @__PURE__ */ new Map();
+	for (;;) {
+		const results = await maintenance.prune({
+			maxBatches: PASS_MAX_BATCHES,
+			...retentionForRun
+		});
+		if (results.length === 0) break;
+		let remaining = false;
+		let deletedThisPass = 0;
+		for (const r of results) {
+			const key = `${r.domain}.${r.table}`;
+			totals.set(key, (totals.get(key) ?? 0) + r.deleted);
+			deletedThisPass += r.deleted;
+			if (!r.done) remaining = true;
+			if (r.deleted > 0) log(`  ${key}: ${totals.get(key)} rows deleted${r.done ? "" : " so far…"}`);
+		}
+		if (!remaining) break;
+		if (deletedThisPass === 0) {
+			log("  stopping: no progress in the last pass.");
+			break;
+		}
+	}
+	const totalDeleted = [...totals.values()].reduce((sum, n) => sum + n, 0);
+	log(totalDeleted === 0 ? "Nothing to prune — no retention-eligible rows found." : `Prune complete: ${totalDeleted} rows deleted.`);
+	await maintenance.closeStorage?.();
+	if (!vacuum) {
+		if (maintenance.reclaimDisk) log("Deleted rows free pages inside the db file but not on disk. Run /prune vacuum to reclaim disk space.");
+		return;
+	}
+	if (!maintenance.reclaimDisk) {
+		log("Disk reclamation (VACUUM) is only available for local libsql storage.");
+		return;
+	}
+	log("Reclaiming disk (compacting database files)… this can take several minutes on large databases.");
+	const reclaimed = await maintenance.reclaimDisk((file, bytesBefore, liveBytes) => {
+		log(`  vacuuming ${file} (${formatBytes(bytesBefore)}, ~${formatBytes(liveBytes)} live)…`);
+	});
+	if (reclaimed.length === 0) {
+		log("No local database files found to vacuum.");
+		return;
+	}
+	for (const r of reclaimed) log(`  ${r.file}: ${formatBytes(r.bytesBefore)} → ${formatBytes(r.bytesAfter)}`);
+	log(`Reclaimed ${formatBytes(reclaimed.reduce((sum, r) => sum + Math.max(0, r.bytesBefore - r.bytesAfter), 0))}.`);
+}
+//#endregion
+export { DEFAULT_RETENTION, createStorageMaintenance, formatBytes, reclaimLibSQLDisk, requiredFreeBytes, resolveLocalDbFiles, runStorageMaintenance };
+
+//# sourceMappingURL=storage-maintenance.js.map

package/dist/utils/storage-maintenance.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage-maintenance.js","names":[],"sources":["../../src/utils/storage-maintenance.ts"],"sourcesContent":["/**\n * Storage maintenance — retention defaults and disk reclamation for mastracode.\n *\n * Retention (`DEFAULT_RETENTION`) is wired into the inner store by the storage\n * factory so `storage.prune()` can delete aged rows across every domain,\n * including the legacy libsql observability spans table.\n *\n * `prune()` only deletes rows — SQLite keeps the freed pages inside the file.\n * `reclaimLibSQLDisk()` returns that space to the OS by streaming a\n * `VACUUM INTO` copy of each file and swapping it into place. It requires all\n * connections to be closed first, so it only runs from the post-TUI\n * maintenance flow. We deliberately do NOT expose VACUUM as a public API on\n * LibSQLStore.\n */\n\nimport { closeSync, existsSync, openSync, readSync, renameSync, rmSync, statSync, statfsSync } from 'node:fs';\nimport { dirname } from 'node:path';\n\nimport type { MastraCompositeStore, PruneOptions, PruneResult, RetentionConfig } from '@mastra/core/storage';\n// Native `libsql` driver, deliberately alongside `@libsql/client` (used by the\n// stores): maintenance needs deterministic connection close for the\n// exclusivity probe, and the wrapper's close() can leave the file lock held\n// until GC finalizes cached statements. Don't \"clean up\" either dependency.\n// Upstream report: https://github.com/tursodatabase/libsql-js/issues/228\nimport Database from 'libsql';\n\nimport type { StorageConfig } from './project.js';\nimport { getDatabasePath, getVectorDatabasePath } from './project.js';\n\n/**\n * Default retention for mastracode's own storage. Tables not listed are kept\n * forever. Ages chosen for a local dev tool where observability data dwarfs\n * everything else (spans have been observed at 17+ GB):\n * - spans/logs: short-lived debugging telemetry → 14d\n * - scorer results & workflow snapshots: medium-lived run records → 30d\n * - chat history (messages/threads): long-lived, user-visible → 90d\n */\nexport const DEFAULT_RETENTION: RetentionConfig = {\n  memory: {\n    messages: { maxAge: '90d' },\n    threads: { maxAge: '90d' },\n  },\n  observability: {\n    spans: { maxAge: '14d' },\n    logs: { maxAge: '14d' },\n  },\n  scores: {\n    scorers: { maxAge: '30d' },\n  },\n  workflows: {\n    workflowSnapshot: { maxAge: '30d' },\n  },\n};\n\n/** Result of reclaiming disk for one database file (sizes include the WAL). */\nexport interface ReclaimResult {\n  file: string;\n  bytesBefore: number;\n  bytesAfter: number;\n}\n\n/** Handle the TUI uses to run storage maintenance without reaching into store internals. */\nexport interface StorageMaintenance {\n  backend: 'libsql' | 'pg';\n  /** Retention policies in effect (for display in /prune output). */\n  retention: RetentionConfig;\n  /** Delete rows older than the retention policies. Safe to re-run; batched and cancellable. `options.retention` replaces the standing policies for this call only. */\n  prune: (options?: PruneOptions) => Promise<PruneResult[]>;\n  /** Close the long-lived storage connection (checkpoints WAL for local libsql). Nothing can use the store afterwards. */\n  closeStorage?: () => Promise<void>;\n  /** Compact local libsql files (VACUUM INTO + swap) to return freed pages to the OS. Only set for local libsql backends. */\n  reclaimDisk?: (\n    onFileStart?: (file: string, bytesBefore: number, liveBytes: number) => void,\n  ) => Promise<ReclaimResult[]>;\n}\n\n/** db file size + its WAL sidecar, in bytes. Missing files count as 0. */\nfunction fileSizeWithWal(dbFile: string): number {\n  let total = 0;\n  for (const candidate of [dbFile, `${dbFile}-wal`]) {\n    try {\n      total += statSync(candidate).size;\n    } catch {\n      // file may not exist (e.g. WAL already truncated)\n    }\n  }\n  return total;\n}\n\n/** Free bytes required before compacting: the compacted copy plus 20% + 256 MB headroom. */\nexport function requiredFreeBytes(liveBytes: number): number {\n  return Math.ceil(liveBytes * 1.2) + 256 * 1024 * 1024;\n}\n\n/** First column of the first row of a PRAGMA result, as a number. */\nfunction pragmaNumber(db: InstanceType<typeof Database>, pragma: string): number {\n  const rows = db.pragma(pragma) as Array<Record<string, unknown>> | undefined;\n  const row = rows?.[0];\n  return row ? Number(Object.values(row)[0]) : 0;\n}\n\n/**\n * Journal mode straight from the SQLite file header (bytes 18/19:\n * 1 = rollback journal, 2 = WAL) — readable without opening a connection.\n */\nfunction journalModeFromHeader(file: string): 'wal' | 'delete' | 'unknown' {\n  const fd = openSync(file, 'r');\n  try {\n    const buf = Buffer.alloc(2);\n    if (readSync(fd, buf, 0, 2, 18) !== 2) return 'unknown';\n    if (buf[0] === 2 && buf[1] === 2) return 'wal';\n    if (buf[0] === 1 && buf[1] === 1) return 'delete';\n    return 'unknown';\n  } finally {\n    closeSync(fd);\n  }\n}\n\n/**\n * Compact each local libsql db file by streaming a `VACUUM INTO` copy next to\n * it, then swapping the copy into place. Reports before/after sizes.\n *\n * Deliberately NOT an in-place `VACUUM`: that copies all live content into a\n * temp store (held in memory by libsql builds with `temp_store=MEMORY`) and\n * then rewrites the entire database back through the WAL — on multi-GB\n * databases that has frozen whole machines via memory/IO exhaustion.\n * `VACUUM INTO` reads the logical database once and writes the compacted copy\n * sequentially with bounded memory, and the WAL never grows.\n *\n * Each file is preflighted: live bytes are estimated from\n * `page_count - freelist_count` and the copy is refused unless the volume has\n * `requiredFreeBytes()` available.\n *\n * MUST run with every connection to these files closed (the swap replaces the\n * inode — a surviving connection would keep writing to the unlinked old file).\n * `runStorageMaintenance()` closes storage before calling this.\n */\nexport async function reclaimLibSQLDisk(\n  dbFiles: string[],\n  onFileStart?: (file: string, bytesBefore: number, liveBytes: number) => void,\n): Promise<ReclaimResult[]> {\n  const results: ReclaimResult[] = [];\n  for (const file of dbFiles) {\n    // Skip missing files and files too small to have a SQLite header — nothing to reclaim\n    if (!existsSync(file) || statSync(file).size < 100) continue;\n    const bytesBefore = fileSizeWithWal(file);\n    const tmp = `${file}.vacuum-tmp`;\n    rmSync(tmp, { force: true });\n    // Prove we're the only connection before the swap: every open WAL-mode\n    // connection (all Mastra Code sessions run WAL) holds a shared-memory\n    // lock, so switching WAL -> DELETE only succeeds with exclusive access.\n    // A surviving connection would keep writing to the unlinked old inode\n    // after the swap and silently lose data.\n    //\n    // The probe uses exec() only and verifies the outcome from the SQLite\n    // file header: prepared statements (including db.pragma()) pin a libsql\n    // connection open past close(), so a failed in-connection probe would\n    // itself hold the WAL lock and poison every retry in this process.\n    // Upstream bug (libsql 0.5.x / @libsql/client 0.17.x): Database.close()\n    // does not finalize outstanding statements — they are only finalized by\n    // GC, so lock release after close() is nondeterministic. Reported as\n    // https://github.com/tursodatabase/libsql-js/issues/228 (fix in flight in\n    // PR #214). Once that lands, the header check can become a plain\n    // journal_mode query.\n    const probe = new Database(file);\n    try {\n      probe.exec('PRAGMA busy_timeout = 2000');\n      // Round-trip through WAL so the probe also works when a clean shutdown\n      // already left the file in rollback mode.\n      probe.exec('PRAGMA journal_mode = WAL');\n      probe.exec('PRAGMA journal_mode = DELETE');\n    } catch {\n      // busy — the header check below reports the failure\n    } finally {\n      probe.close();\n    }\n    if (journalModeFromHeader(file) !== 'delete') {\n      throw new Error(\n        `${file} is in use by another process — is another Mastra Code session running? ` +\n          `Close other sessions and run /prune vacuum again.`,\n      );\n    }\n    // Native `libsql` driver, not `@libsql/client`: the wrapper's close() can\n    // leave the file lock held in-process (cached statements), which would\n    // block other connections afterwards. This connection stays in rollback\n    // mode, so even a pinned statement holds no lock once we're done.\n    const db = new Database(file);\n    try {\n      db.exec('PRAGMA busy_timeout = 2000');\n      const pageSize = pragmaNumber(db, 'page_size');\n      const pageCount = pragmaNumber(db, 'page_count');\n      const freelistCount = pragmaNumber(db, 'freelist_count');\n      const liveBytes = Math.max(0, pageCount - freelistCount) * pageSize;\n      const { bsize, bavail } = statfsSync(dirname(file));\n      const freeBytes = bsize * bavail;\n      if (freeBytes < requiredFreeBytes(liveBytes)) {\n        throw new Error(\n          `Not enough free disk space to compact ${file}: need ${formatBytes(requiredFreeBytes(liveBytes))} ` +\n            `for a ${formatBytes(liveBytes)} compacted copy, but only ${formatBytes(freeBytes)} is free.`,\n        );\n      }\n      onFileStart?.(file, bytesBefore, liveBytes);\n      db.exec(`VACUUM INTO '${tmp.replace(/'/g, \"''\")}'`);\n    } catch (err) {\n      rmSync(tmp, { force: true });\n      throw err;\n    } finally {\n      db.close();\n    }\n    // Re-probe right before the swap: `VACUUM INTO` can take tens of seconds\n    // on multi-GB files, and a session started in that window reopens the db\n    // in WAL mode (flipping the header back). Swapping under it would orphan\n    // that session's inode and silently lose its writes.\n    if (journalModeFromHeader(file) !== 'delete') {\n      rmSync(tmp, { force: true });\n      throw new Error(\n        `${file} was opened by another process during compaction — is another Mastra Code session running? ` +\n          `Close other sessions and run /prune vacuum again.`,\n      );\n    }\n    // Swap the compacted copy into place. The old WAL/SHM sidecars belong to\n    // the old inode — they must never be paired with the new file. If any step\n    // after the first rename fails, restore the original so the db path is\n    // never left empty (a naive restart would otherwise create a fresh db).\n    renameSync(file, `${file}.old`);\n    try {\n      rmSync(`${file}-wal`, { force: true });\n      rmSync(`${file}-shm`, { force: true });\n      renameSync(tmp, file);\n    } catch (err) {\n      try {\n        renameSync(`${file}.old`, file);\n      } catch {\n        throw new Error(\n          `Failed to swap compacted copy into place AND failed to restore the original — ` +\n            `your data is intact at ${file}.old; rename it back to ${file} manually. ` +\n            `Original error: ${err instanceof Error ? err.message : String(err)}`,\n        );\n      }\n      rmSync(tmp, { force: true });\n      throw err;\n    }\n    rmSync(`${file}.old`, { force: true });\n    results.push({ file, bytesBefore, bytesAfter: fileSizeWithWal(file) });\n  }\n  return results;\n}\n\n/** `file:/path` or `file:///path` → filesystem path; undefined for non-file urls. */\nfunction fileUrlToPath(url: string): string | undefined {\n  if (!url.startsWith('file:')) return undefined;\n  return url.replace(/^file:\\/\\//, '').replace(/^file:/, '');\n}\n\n/**\n * Resolve the local libsql db files eligible for checkpoint + VACUUM.\n * Returns [] for remote (turso) urls and PG backends. When PG was requested\n * but the factory fell back to libsql, the fallback uses the default files.\n */\nexport function resolveLocalDbFiles(config: StorageConfig, effectiveBackend: 'libsql' | 'pg'): string[] {\n  if (effectiveBackend !== 'libsql') return [];\n  if (config.backend === 'pg') {\n    // PG requested but fell back to the default local libsql files\n    return [getDatabasePath(), getVectorDatabasePath()];\n  }\n  if (config.isRemote) return [];\n  const files: string[] = [];\n  const main = fileUrlToPath(config.url);\n  if (main) files.push(main);\n  const vector = config.vectorUrl ? fileUrlToPath(config.vectorUrl) : getVectorDatabasePath();\n  if (vector) files.push(vector);\n  return files;\n}\n\n/**\n * Build the maintenance handle for the effective storage backend.\n * `localDbFiles` are the local libsql file paths eligible for VACUUM;\n * pass an empty array for remote (turso) or PG backends.\n */\nexport function createStorageMaintenance(opts: {\n  storage: MastraCompositeStore;\n  backend: 'libsql' | 'pg';\n  retention: RetentionConfig;\n  localDbFiles: string[];\n  /** Closes the vector store's connection; required for local libsql so the compaction swap isn't blocked by our own handle. */\n  closeVector?: () => Promise<void>;\n}): StorageMaintenance {\n  const { storage, backend, retention, localDbFiles, closeVector } = opts;\n  return {\n    backend,\n    retention,\n    prune: options => storage.prune(options),\n    closeStorage: async () => {\n      await storage.close?.();\n      await closeVector?.();\n    },\n    ...(backend === 'libsql' && localDbFiles.length > 0\n      ? {\n          reclaimDisk: (onFileStart?: (file: string, bytesBefore: number, liveBytes: number) => void) =>\n            reclaimLibSQLDisk(localDbFiles, onFileStart),\n        }\n      : {}),\n  };\n}\n\nexport function formatBytes(bytes: number): string {\n  if (bytes < 1024) return `${bytes} B`;\n  const units = ['KB', 'MB', 'GB', 'TB'];\n  let value = bytes;\n  let unit = 'B';\n  for (const next of units) {\n    if (value < 1024) break;\n    value /= 1024;\n    unit = next;\n  }\n  return `${value.toFixed(1)} ${unit}`;\n}\n\n/** Rows deleted per table per pass: default batchSize (1000) × 20 batches. */\nconst PASS_MAX_BATCHES = 20;\n\n/**\n * Run storage maintenance with exclusive access to the database, reporting\n * progress through `log` (one line per pass so large deletes are visible).\n *\n * Must run AFTER the TUI is stopped and background writers are quiesced —\n * batched deletes and VACUUM contend with live writes (SQLITE_BUSY) and can\n * starve the event loop that renders the TUI. The storage connection is\n * closed at the end (checkpointing the WAL for local libsql), so the process\n * must exit afterwards.\n */\nexport async function runStorageMaintenance(opts: {\n  maintenance: StorageMaintenance;\n  vacuum: boolean;\n  /** Skip the memory domain (messages/threads) so chat history is preserved. */\n  keepMemory?: boolean;\n  log: (line: string) => void;\n}): Promise<void> {\n  const { maintenance, vacuum, keepMemory = false, log } = opts;\n\n  // keep-memory: prune with the standing policies minus the memory domain,\n  // for this run only. The configured retention is untouched.\n  const { memory: _memory, ...withoutMemory } = maintenance.retention;\n  const retentionForRun = keepMemory ? { retention: withoutMemory } : {};\n\n  log('Pruning rows older than the retention policies:');\n  for (const [domain, tables] of Object.entries(maintenance.retention)) {\n    for (const [table, policy] of Object.entries(tables ?? {})) {\n      const kept = keepMemory && domain === 'memory';\n      log(`  ${domain}.${table}: ${kept ? 'kept (keep-memory)' : (policy as { maxAge: string | number }).maxAge}`);\n    }\n  }\n\n  const totals = new Map<string, number>();\n  for (;;) {\n    const results = await maintenance.prune({ maxBatches: PASS_MAX_BATCHES, ...retentionForRun });\n    if (results.length === 0) break;\n    let remaining = false;\n    let deletedThisPass = 0;\n    for (const r of results) {\n      const key = `${r.domain}.${r.table}`;\n      totals.set(key, (totals.get(key) ?? 0) + r.deleted);\n      deletedThisPass += r.deleted;\n      if (!r.done) remaining = true;\n      if (r.deleted > 0) {\n        log(`  ${key}: ${totals.get(key)} rows deleted${r.done ? '' : ' so far…'}`);\n      }\n    }\n    if (!remaining) break;\n    // Safety valve: a table reported more eligible rows but nothing was\n    // deleted this pass — bail instead of spinning forever.\n    if (deletedThisPass === 0) {\n      log('  stopping: no progress in the last pass.');\n      break;\n    }\n  }\n  const totalDeleted = [...totals.values()].reduce((sum, n) => sum + n, 0);\n  log(\n    totalDeleted === 0\n      ? 'Nothing to prune — no retention-eligible rows found.'\n      : `Prune complete: ${totalDeleted} rows deleted.`,\n  );\n\n  // Release the long-lived connection: checkpoints the WAL for local libsql\n  // and guarantees VACUUM below isn't blocked by our own open handles.\n  await maintenance.closeStorage?.();\n\n  if (!vacuum) {\n    if (maintenance.reclaimDisk) {\n      log('Deleted rows free pages inside the db file but not on disk. Run /prune vacuum to reclaim disk space.');\n    }\n    return;\n  }\n\n  if (!maintenance.reclaimDisk) {\n    log('Disk reclamation (VACUUM) is only available for local libsql storage.');\n    return;\n  }\n\n  log('Reclaiming disk (compacting database files)… this can take several minutes on large databases.');\n  const reclaimed = await maintenance.reclaimDisk((file, bytesBefore, liveBytes) => {\n    log(`  vacuuming ${file} (${formatBytes(bytesBefore)}, ~${formatBytes(liveBytes)} live)…`);\n  });\n  if (reclaimed.length === 0) {\n    log('No local database files found to vacuum.');\n    return;\n  }\n  for (const r of reclaimed) {\n    log(`  ${r.file}: ${formatBytes(r.bytesBefore)} → ${formatBytes(r.bytesAfter)}`);\n  }\n  const saved = reclaimed.reduce((sum, r) => sum + Math.max(0, r.bytesBefore - r.bytesAfter), 0);\n  log(`Reclaimed ${formatBytes(saved)}.`);\n}\n"],"mappings":"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"}

package/dist/utils/thread-lock.d.ts

@@ -0,0 +1,26 @@
+export declare class ThreadLockError extends Error {
+    readonly threadId: string;
+    readonly ownerPid: number;
+    constructor(threadId: string, ownerPid: number);
+}
+/**
+ * Attempt to acquire a lock for the given thread.
+ * Throws ThreadLockError if another live process holds the lock.
+ * Reclaims stale locks from dead processes.
+ */
+export declare function acquireThreadLock(threadId: string): void;
+/**
+ * Release the lock for the given thread (only if we own it).
+ */
+export declare function releaseThreadLock(threadId: string): void;
+/**
+ * Check if a thread is locked by another process.
+ * Returns the PID of the owner if locked, null otherwise.
+ */
+export declare function getThreadLockOwner(threadId: string): number | null;
+/**
+ * Release all thread locks owned by this process.
+ * Call this on process exit.
+ */
+export declare function releaseAllThreadLocks(): void;
+//# sourceMappingURL=thread-lock.d.ts.map

package/dist/utils/thread-lock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"thread-lock.d.ts","sourceRoot":"","sources":["../../src/utils/thread-lock.ts"],"names":[],"mappings":"AAWA,qBAAa,eAAgB,SAAQ,KAAK;aAEtB,QAAQ,EAAE,MAAM;aAChB,QAAQ,EAAE,MAAM;gBADhB,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM;CAKnC;AAyBD;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAsBxD;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAiBxD;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAuBlE;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,IAAI,IAAI,CAqB5C"}

package/dist/utils/thread-lock.js

@@ -0,0 +1,112 @@
+import { getAppDataDir } from "./project.js";
+import * as fs$1 from "fs";
+import * as path$1 from "path";
+//#region src/utils/thread-lock.ts
+/**
+* Thread lock — ensures only one process writes to a thread at a time.
+*
+* Uses filesystem lock files: <appDataDir>/locks/<threadId>.lock
+* Each lock file contains the PID of the owning process.
+* Stale locks (from crashed processes) are detected and reclaimed.
+*/
+var ThreadLockError = class extends Error {
+	threadId;
+	ownerPid;
+	constructor(threadId, ownerPid) {
+		super(`Thread ${threadId} is locked by another process (PID ${ownerPid})`);
+		this.threadId = threadId;
+		this.ownerPid = ownerPid;
+		this.name = "ThreadLockError";
+	}
+};
+function getLocksDir() {
+	const dir = path$1.join(getAppDataDir(), "locks");
+	if (!fs$1.existsSync(dir)) fs$1.mkdirSync(dir, { recursive: true });
+	return dir;
+}
+function getLockPath(threadId) {
+	const safeId = threadId.replace(/[^a-zA-Z0-9_-]/g, "_");
+	return path$1.join(getLocksDir(), `${safeId}.lock`);
+}
+function isProcessAlive(pid) {
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch {
+		return false;
+	}
+}
+/**
+* Attempt to acquire a lock for the given thread.
+* Throws ThreadLockError if another live process holds the lock.
+* Reclaims stale locks from dead processes.
+*/
+function acquireThreadLock(threadId) {
+	const lockPath = getLockPath(threadId);
+	const myPid = process.pid;
+	if (fs$1.existsSync(lockPath)) try {
+		const content = fs$1.readFileSync(lockPath, "utf-8").trim();
+		const ownerPid = parseInt(content, 10);
+		if (!isNaN(ownerPid) && ownerPid !== myPid && isProcessAlive(ownerPid)) throw new ThreadLockError(threadId, ownerPid);
+	} catch (error) {
+		if (error instanceof ThreadLockError) throw error;
+	}
+	fs$1.writeFileSync(lockPath, String(myPid), { mode: 420 });
+}
+/**
+* Release the lock for the given thread (only if we own it).
+*/
+function releaseThreadLock(threadId) {
+	const lockPath = getLockPath(threadId);
+	const myPid = process.pid;
+	try {
+		if (!fs$1.existsSync(lockPath)) return;
+		const content = fs$1.readFileSync(lockPath, "utf-8").trim();
+		if (parseInt(content, 10) === myPid) fs$1.unlinkSync(lockPath);
+	} catch {}
+}
+/**
+* Check if a thread is locked by another process.
+* Returns the PID of the owner if locked, null otherwise.
+*/
+function getThreadLockOwner(threadId) {
+	const lockPath = getLockPath(threadId);
+	try {
+		if (!fs$1.existsSync(lockPath)) return null;
+		const content = fs$1.readFileSync(lockPath, "utf-8").trim();
+		const ownerPid = parseInt(content, 10);
+		if (isNaN(ownerPid)) return null;
+		if (ownerPid === process.pid) return null;
+		if (!isProcessAlive(ownerPid)) {
+			try {
+				fs$1.unlinkSync(lockPath);
+			} catch {}
+			return null;
+		}
+		return ownerPid;
+	} catch {
+		return null;
+	}
+}
+/**
+* Release all thread locks owned by this process.
+* Call this on process exit.
+*/
+function releaseAllThreadLocks() {
+	try {
+		const locksDir = getLocksDir();
+		const files = fs$1.readdirSync(locksDir);
+		const myPid = String(process.pid);
+		for (const file of files) {
+			if (!file.endsWith(".lock")) continue;
+			const lockPath = path$1.join(locksDir, file);
+			try {
+				if (fs$1.readFileSync(lockPath, "utf-8").trim() === myPid) fs$1.unlinkSync(lockPath);
+			} catch {}
+		}
+	} catch {}
+}
+//#endregion
+export { ThreadLockError, acquireThreadLock, getThreadLockOwner, releaseAllThreadLocks, releaseThreadLock };
+
+//# sourceMappingURL=thread-lock.js.map

package/dist/utils/thread-lock.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"thread-lock.js","names":["path","fs"],"sources":["../../src/utils/thread-lock.ts"],"sourcesContent":["/**\n * Thread lock — ensures only one process writes to a thread at a time.\n *\n * Uses filesystem lock files: <appDataDir>/locks/<threadId>.lock\n * Each lock file contains the PID of the owning process.\n * Stale locks (from crashed processes) are detected and reclaimed.\n */\nimport * as fs from 'node:fs';\nimport * as path from 'node:path';\nimport { getAppDataDir } from './project.js';\n\nexport class ThreadLockError extends Error {\n  constructor(\n    public readonly threadId: string,\n    public readonly ownerPid: number,\n  ) {\n    super(`Thread ${threadId} is locked by another process (PID ${ownerPid})`);\n    this.name = 'ThreadLockError';\n  }\n}\n\nfunction getLocksDir(): string {\n  const dir = path.join(getAppDataDir(), 'locks');\n  if (!fs.existsSync(dir)) {\n    fs.mkdirSync(dir, { recursive: true });\n  }\n  return dir;\n}\n\nfunction getLockPath(threadId: string): string {\n  // Sanitize thread ID for filesystem safety\n  const safeId = threadId.replace(/[^a-zA-Z0-9_-]/g, '_');\n  return path.join(getLocksDir(), `${safeId}.lock`);\n}\n\nfunction isProcessAlive(pid: number): boolean {\n  try {\n    process.kill(pid, 0);\n    return true;\n  } catch {\n    return false;\n  }\n}\n\n/**\n * Attempt to acquire a lock for the given thread.\n * Throws ThreadLockError if another live process holds the lock.\n * Reclaims stale locks from dead processes.\n */\nexport function acquireThreadLock(threadId: string): void {\n  const lockPath = getLockPath(threadId);\n  const myPid = process.pid;\n\n  // Check for existing lock\n  if (fs.existsSync(lockPath)) {\n    try {\n      const content = fs.readFileSync(lockPath, 'utf-8').trim();\n      const ownerPid = parseInt(content, 10);\n\n      if (!isNaN(ownerPid) && ownerPid !== myPid && isProcessAlive(ownerPid)) {\n        throw new ThreadLockError(threadId, ownerPid);\n      }\n      // Stale lock (dead process) or our own lock — reclaim it\n    } catch (error) {\n      if (error instanceof ThreadLockError) throw error;\n      // File read error — try to overwrite\n    }\n  }\n\n  // Write our PID to the lock file\n  fs.writeFileSync(lockPath, String(myPid), { mode: 0o644 });\n}\n\n/**\n * Release the lock for the given thread (only if we own it).\n */\nexport function releaseThreadLock(threadId: string): void {\n  const lockPath = getLockPath(threadId);\n  const myPid = process.pid;\n\n  try {\n    if (!fs.existsSync(lockPath)) return;\n\n    const content = fs.readFileSync(lockPath, 'utf-8').trim();\n    const ownerPid = parseInt(content, 10);\n\n    // Only remove if we own it\n    if (ownerPid === myPid) {\n      fs.unlinkSync(lockPath);\n    }\n  } catch {\n    // Best-effort cleanup — ignore errors\n  }\n}\n\n/**\n * Check if a thread is locked by another process.\n * Returns the PID of the owner if locked, null otherwise.\n */\nexport function getThreadLockOwner(threadId: string): number | null {\n  const lockPath = getLockPath(threadId);\n\n  try {\n    if (!fs.existsSync(lockPath)) return null;\n\n    const content = fs.readFileSync(lockPath, 'utf-8').trim();\n    const ownerPid = parseInt(content, 10);\n\n    if (isNaN(ownerPid)) return null;\n    if (ownerPid === process.pid) return null; // Our own lock\n    if (!isProcessAlive(ownerPid)) {\n      // Stale lock — clean it up\n      try {\n        fs.unlinkSync(lockPath);\n      } catch {}\n      return null;\n    }\n\n    return ownerPid;\n  } catch {\n    return null;\n  }\n}\n\n/**\n * Release all thread locks owned by this process.\n * Call this on process exit.\n */\nexport function releaseAllThreadLocks(): void {\n  try {\n    const locksDir = getLocksDir();\n    const files = fs.readdirSync(locksDir);\n    const myPid = String(process.pid);\n\n    for (const file of files) {\n      if (!file.endsWith('.lock')) continue;\n      const lockPath = path.join(locksDir, file);\n      try {\n        const content = fs.readFileSync(lockPath, 'utf-8').trim();\n        if (content === myPid) {\n          fs.unlinkSync(lockPath);\n        }\n      } catch {\n        // Best-effort\n      }\n    }\n  } catch {\n    // Best-effort\n  }\n}\n"],"mappings":";;;;;;;;;;;AAWA,IAAa,kBAAb,cAAqC,MAAM;CAEvB;CACA;CAFlB,YACE,UACA,UACA;EACA,MAAM,UAAU,SAAS,qCAAqC,SAAS,EAAE;EAHzD,KAAA,WAAA;EACA,KAAA,WAAA;EAGhB,KAAK,OAAO;CACd;AACF;AAEA,SAAS,cAAsB;CAC7B,MAAM,MAAMA,OAAK,KAAK,cAAc,GAAG,OAAO;CAC9C,IAAI,CAACC,KAAG,WAAW,GAAG,GACpB,KAAG,UAAU,KAAK,EAAE,WAAW,KAAK,CAAC;CAEvC,OAAO;AACT;AAEA,SAAS,YAAY,UAA0B;CAE7C,MAAM,SAAS,SAAS,QAAQ,mBAAmB,GAAG;CACtD,OAAOD,OAAK,KAAK,YAAY,GAAG,GAAG,OAAO,MAAM;AAClD;AAEA,SAAS,eAAe,KAAsB;CAC5C,IAAI;EACF,QAAQ,KAAK,KAAK,CAAC;EACnB,OAAO;CACT,QAAQ;EACN,OAAO;CACT;AACF;;;;;;AAOA,SAAgB,kBAAkB,UAAwB;CACxD,MAAM,WAAW,YAAY,QAAQ;CACrC,MAAM,QAAQ,QAAQ;CAGtB,IAAIC,KAAG,WAAW,QAAQ,GACxB,IAAI;EACF,MAAM,UAAUA,KAAG,aAAa,UAAU,OAAO,CAAC,CAAC,KAAK;EACxD,MAAM,WAAW,SAAS,SAAS,EAAE;EAErC,IAAI,CAAC,MAAM,QAAQ,KAAK,aAAa,SAAS,eAAe,QAAQ,GACnE,MAAM,IAAI,gBAAgB,UAAU,QAAQ;CAGhD,SAAS,OAAO;EACd,IAAI,iBAAiB,iBAAiB,MAAM;CAE9C;CAIF,KAAG,cAAc,UAAU,OAAO,KAAK,GAAG,EAAE,MAAM,IAAM,CAAC;AAC3D;;;;AAKA,SAAgB,kBAAkB,UAAwB;CACxD,MAAM,WAAW,YAAY,QAAQ;CACrC,MAAM,QAAQ,QAAQ;CAEtB,IAAI;EACF,IAAI,CAACA,KAAG,WAAW,QAAQ,GAAG;EAE9B,MAAM,UAAUA,KAAG,aAAa,UAAU,OAAO,CAAC,CAAC,KAAK;EAIxD,IAHiB,SAAS,SAAS,EAGxB,MAAM,OACf,KAAG,WAAW,QAAQ;CAE1B,QAAQ,CAER;AACF;;;;;AAMA,SAAgB,mBAAmB,UAAiC;CAClE,MAAM,WAAW,YAAY,QAAQ;CAErC,IAAI;EACF,IAAI,CAACA,KAAG,WAAW,QAAQ,GAAG,OAAO;EAErC,MAAM,UAAUA,KAAG,aAAa,UAAU,OAAO,CAAC,CAAC,KAAK;EACxD,MAAM,WAAW,SAAS,SAAS,EAAE;EAErC,IAAI,MAAM,QAAQ,GAAG,OAAO;EAC5B,IAAI,aAAa,QAAQ,KAAK,OAAO;EACrC,IAAI,CAAC,eAAe,QAAQ,GAAG;GAE7B,IAAI;IACF,KAAG,WAAW,QAAQ;GACxB,QAAQ,CAAC;GACT,OAAO;EACT;EAEA,OAAO;CACT,QAAQ;EACN,OAAO;CACT;AACF;;;;;AAMA,SAAgB,wBAA8B;CAC5C,IAAI;EACF,MAAM,WAAW,YAAY;EAC7B,MAAM,QAAQA,KAAG,YAAY,QAAQ;EACrC,MAAM,QAAQ,OAAO,QAAQ,GAAG;EAEhC,KAAK,MAAM,QAAQ,OAAO;GACxB,IAAI,CAAC,KAAK,SAAS,OAAO,GAAG;GAC7B,MAAM,WAAWD,OAAK,KAAK,UAAU,IAAI;GACzC,IAAI;IAEF,IADgBC,KAAG,aAAa,UAAU,OAAO,CAAC,CAAC,KACzC,MAAM,OACd,KAAG,WAAW,QAAQ;GAE1B,QAAQ,CAER;EACF;CACF,QAAQ,CAER;AACF"}

package/dist/utils/token-estimator.d.ts

@@ -0,0 +1,3 @@
+export declare function tokenEstimate(text: string | object): number;
+export declare function truncateStringForTokenEstimate(text: string, desiredTokenCount: number, fromEnd?: boolean): string;
+//# sourceMappingURL=token-estimator.d.ts.map

package/dist/utils/token-estimator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"token-estimator.d.ts","sourceRoot":"","sources":["../../src/utils/token-estimator.ts"],"names":[],"mappings":"AASA,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAE3D;AAED,wBAAgB,8BAA8B,CAAC,IAAI,EAAE,MAAM,EAAE,iBAAiB,EAAE,MAAM,EAAE,OAAO,UAAO,UAUrG"}

package/dist/utils/token-estimator.js

@@ -0,0 +1,21 @@
+import { estimateTokenCount, sliceByTokens } from "tokenx";
+//#region src/utils/token-estimator.ts
+function sanitizeInput(text) {
+	if (!text) return "";
+	return (typeof text === `string` ? text : JSON.stringify(text)).replaceAll(`<|endoftext|>`, ``).replaceAll(`<|endofprompt|>`, ``);
+}
+function tokenEstimate(text) {
+	return estimateTokenCount(sanitizeInput(text));
+}
+function truncateStringForTokenEstimate(text, desiredTokenCount, fromEnd = true) {
+	const sanitized = sanitizeInput(text);
+	const totalTokens = estimateTokenCount(sanitized);
+	if (totalTokens <= desiredTokenCount) return sanitized;
+	const kept = fromEnd ? sliceByTokens(sanitized, -desiredTokenCount) : sliceByTokens(sanitized, 0, desiredTokenCount);
+	return `[Truncated ~${totalTokens - desiredTokenCount} tokens]
+${kept}`;
+}
+//#endregion
+export { tokenEstimate, truncateStringForTokenEstimate };
+
+//# sourceMappingURL=token-estimator.js.map

package/dist/utils/token-estimator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"token-estimator.js","names":[],"sources":["../../src/utils/token-estimator.ts"],"sourcesContent":["import { estimateTokenCount, sliceByTokens } from 'tokenx';\n\nfunction sanitizeInput(text: string | object) {\n  if (!text) return '';\n  return (typeof text === `string` ? text : JSON.stringify(text))\n    .replaceAll(`<|endoftext|>`, ``)\n    .replaceAll(`<|endofprompt|>`, ``);\n}\n\nexport function tokenEstimate(text: string | object): number {\n  return estimateTokenCount(sanitizeInput(text));\n}\n\nexport function truncateStringForTokenEstimate(text: string, desiredTokenCount: number, fromEnd = true) {\n  const sanitized = sanitizeInput(text);\n  const totalTokens = estimateTokenCount(sanitized);\n\n  if (totalTokens <= desiredTokenCount) return sanitized;\n\n  const kept = fromEnd ? sliceByTokens(sanitized, -desiredTokenCount) : sliceByTokens(sanitized, 0, desiredTokenCount);\n\n  return `[Truncated ~${totalTokens - desiredTokenCount} tokens]\n${kept}`;\n}\n"],"mappings":";;AAEA,SAAS,cAAc,MAAuB;CAC5C,IAAI,CAAC,MAAM,OAAO;CAClB,QAAQ,OAAO,SAAS,WAAW,OAAO,KAAK,UAAU,IAAI,EAAA,CAC1D,WAAW,iBAAiB,EAAE,CAAC,CAC/B,WAAW,mBAAmB,EAAE;AACrC;AAEA,SAAgB,cAAc,MAA+B;CAC3D,OAAO,mBAAmB,cAAc,IAAI,CAAC;AAC/C;AAEA,SAAgB,+BAA+B,MAAc,mBAA2B,UAAU,MAAM;CACtG,MAAM,YAAY,cAAc,IAAI;CACpC,MAAM,cAAc,mBAAmB,SAAS;CAEhD,IAAI,eAAe,mBAAmB,OAAO;CAE7C,MAAM,OAAO,UAAU,cAAc,WAAW,CAAC,iBAAiB,IAAI,cAAc,WAAW,GAAG,iBAAiB;CAEnH,OAAO,eAAe,cAAc,kBAAkB;EACtD;AACF"}