@mastra/code-sdk 0.0.0-fix-workflow-step-timing-and-parallel-status-20260715180716

package/dist/utils/stdin-pipe.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Clean up raw piped output so the agent sees readable text, not terminal
+ * control noise.
+ *
+ * 1. Strip all ANSI escape sequences (colors, cursor movement, line clears).
+ * 2. Simulate carriage-return overwrites: for each line, split on `\r` and
+ *    keep only the last segment — this is what the terminal would display
+ *    after a spinner/progress bar finishes.
+ * 3. Collapse runs of blank lines.
+ */
+export declare function sanitizePipedOutput(raw: string): string;
+/**
+ * If stdin is a pipe (not a TTY), read **all** data until EOF and return it as
+ * a string. The returned promise only resolves once the write end of the pipe
+ * is closed — i.e. the sending process has fully exited — so callers are
+ * guaranteed to receive the complete output, not a partial snapshot from a
+ * program that writes progressively.
+ *
+ * Returns `null` when:
+ * - stdin is a TTY (interactive terminal)
+ * - the pipe was empty or contained only whitespace
+ */
+export declare function drainPipedStdin(): Promise<string | null>;
+/**
+ * Reopen `/dev/tty` (or `CON` on Windows) as `process.stdin` so that the
+ * interactive TUI can read keyboard input after the original piped stdin has
+ * been consumed.
+ *
+ * @returns `true` if the swap succeeded, `false` if a TTY could not be opened
+ * (e.g. running in a headless CI container with no controlling terminal).
+ */
+export declare function reopenStdinFromTTY(): boolean;
+//# sourceMappingURL=stdin-pipe.d.ts.map

package/dist/utils/stdin-pipe.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stdin-pipe.d.ts","sourceRoot":"","sources":["../../src/utils/stdin-pipe.ts"],"names":[],"mappings":"AAYA;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CA0BvD;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,eAAe,IAAI,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CA2C9D;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,IAAI,OAAO,CAmB5C"}

package/dist/utils/stdin-pipe.js

@@ -0,0 +1,72 @@
+import * as fs from "node:fs";
+import * as tty from "node:tty";
+const MAX_PIPE_BYTES = 1024 * 1024;
+const ANSI_RE = /\x1b(?:\[[0-9;?]*[A-Za-z]|\][^\x07\x1b]*(?:\x07|\x1b\\)?|\([A-Z])/g;
+function sanitizePipedOutput(raw) {
+  let text = raw.replace(ANSI_RE, "");
+  text = text.replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]/g, "");
+  text = text.split("\n").map((line) => {
+    if (!line.includes("\r")) return line;
+    const segments = line.split("\r");
+    for (let i = segments.length - 1; i >= 0; i--) {
+      if (segments[i].length > 0) return segments[i];
+    }
+    return "";
+  }).join("\n");
+  text = text.replace(/\n{3,}/g, "\n\n");
+  return text.trim();
+}
+async function drainPipedStdin() {
+  if (process.stdin.isTTY) return null;
+  const chunks = [];
+  let totalBytes = 0;
+  let truncated = false;
+  for await (const chunk of process.stdin) {
+    const buf = chunk;
+    if (totalBytes + buf.length > MAX_PIPE_BYTES) {
+      const remaining = MAX_PIPE_BYTES - totalBytes;
+      if (remaining > 0) {
+        chunks.push(Buffer.from(buf.subarray(0, remaining)));
+      }
+      buf.fill(0);
+      totalBytes = MAX_PIPE_BYTES;
+      truncated = true;
+      continue;
+    }
+    chunks.push(buf);
+    totalBytes += buf.length;
+  }
+  if (truncated) {
+    process.stderr.write(`Warning: Piped input exceeded ${MAX_PIPE_BYTES / 1024 / 1024}MB and was truncated.
+`);
+  }
+  const raw = Buffer.concat(chunks).toString("utf-8");
+  for (const buf of chunks) {
+    buf.fill(0);
+  }
+  chunks.length = 0;
+  const content = sanitizePipedOutput(raw);
+  return content.length > 0 ? content : null;
+}
+function reopenStdinFromTTY() {
+  const ttyPath = process.platform === "win32" ? "CON" : "/dev/tty";
+  let fd;
+  try {
+    fd = fs.openSync(ttyPath, "r");
+  } catch {
+    return false;
+  }
+  const ttyStream = new tty.ReadStream(fd);
+  Object.defineProperty(process, "stdin", {
+    value: ttyStream,
+    writable: true,
+    configurable: true
+  });
+  return true;
+}
+export {
+  drainPipedStdin,
+  reopenStdinFromTTY,
+  sanitizePipedOutput
+};
+//# sourceMappingURL=stdin-pipe.js.map

package/dist/utils/stdin-pipe.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utils/stdin-pipe.ts"],"sourcesContent":["import * as fs from 'node:fs';\nimport * as tty from 'node:tty';\n\n/** Maximum piped input size (1 MB). Content beyond this is truncated. */\nconst MAX_PIPE_BYTES = 1024 * 1024;\n\n/**\n * Matches all ANSI escape sequences — SGR (colors), cursor movement, line\n * clears, scrolling, window titles, etc.\n */\nconst ANSI_RE = /\\x1b(?:\\[[0-9;?]*[A-Za-z]|\\][^\\x07\\x1b]*(?:\\x07|\\x1b\\\\)?|\\([A-Z])/g;\n\n/**\n * Clean up raw piped output so the agent sees readable text, not terminal\n * control noise.\n *\n * 1. Strip all ANSI escape sequences (colors, cursor movement, line clears).\n * 2. Simulate carriage-return overwrites: for each line, split on `\\r` and\n *    keep only the last segment — this is what the terminal would display\n *    after a spinner/progress bar finishes.\n * 3. Collapse runs of blank lines.\n */\nexport function sanitizePipedOutput(raw: string): string {\n  // Strip ANSI escapes first\n  let text = raw.replace(ANSI_RE, '');\n\n  // Strip binary control characters (everything below 0x20 except \\t, \\n, \\r)\n  text = text.replace(/[\\x00-\\x08\\x0B\\x0C\\x0E-\\x1F\\x7F]/g, '');\n\n  // Simulate \\r overwrites: for each line, the last \\r-segment wins\n  text = text\n    .split('\\n')\n    .map(line => {\n      if (!line.includes('\\r')) return line;\n      const segments = line.split('\\r');\n      // Walk backwards to find the last non-empty segment — a trailing \\r\n      // produces an empty final segment that would otherwise discard visible text.\n      for (let i = segments.length - 1; i >= 0; i--) {\n        if (segments[i]!.length > 0) return segments[i]!;\n      }\n      return '';\n    })\n    .join('\\n');\n\n  // Collapse 3+ consecutive blank lines into 2\n  text = text.replace(/\\n{3,}/g, '\\n\\n');\n\n  return text.trim();\n}\n\n/**\n * If stdin is a pipe (not a TTY), read **all** data until EOF and return it as\n * a string. The returned promise only resolves once the write end of the pipe\n * is closed — i.e. the sending process has fully exited — so callers are\n * guaranteed to receive the complete output, not a partial snapshot from a\n * program that writes progressively.\n *\n * Returns `null` when:\n * - stdin is a TTY (interactive terminal)\n * - the pipe was empty or contained only whitespace\n */\nexport async function drainPipedStdin(): Promise<string | null> {\n  if (process.stdin.isTTY) return null;\n\n  const chunks: Buffer[] = [];\n  let totalBytes = 0;\n  let truncated = false;\n\n  for await (const chunk of process.stdin) {\n    const buf = chunk as Buffer;\n\n    if (totalBytes + buf.length > MAX_PIPE_BYTES) {\n      // Take only what fits under the cap — copy so we don't retain the\n      // original backing buffer, then zero the source.\n      const remaining = MAX_PIPE_BYTES - totalBytes;\n      if (remaining > 0) {\n        chunks.push(Buffer.from(buf.subarray(0, remaining)));\n      }\n      buf.fill(0);\n      totalBytes = MAX_PIPE_BYTES;\n      truncated = true;\n      // Keep draining so we don't leave unread data in the pipe, but don't\n      // store it — we still need to wait for EOF.\n      continue;\n    }\n\n    chunks.push(buf);\n    totalBytes += buf.length;\n  }\n\n  if (truncated) {\n    process.stderr.write(`Warning: Piped input exceeded ${MAX_PIPE_BYTES / 1024 / 1024}MB and was truncated.\\n`);\n  }\n\n  const raw = Buffer.concat(chunks).toString('utf-8');\n\n  // Zero out raw buffers so piped secrets don't linger in memory\n  for (const buf of chunks) {\n    buf.fill(0);\n  }\n  chunks.length = 0;\n\n  const content = sanitizePipedOutput(raw);\n  return content.length > 0 ? content : null;\n}\n\n/**\n * Reopen `/dev/tty` (or `CON` on Windows) as `process.stdin` so that the\n * interactive TUI can read keyboard input after the original piped stdin has\n * been consumed.\n *\n * @returns `true` if the swap succeeded, `false` if a TTY could not be opened\n * (e.g. running in a headless CI container with no controlling terminal).\n */\nexport function reopenStdinFromTTY(): boolean {\n  const ttyPath = process.platform === 'win32' ? 'CON' : '/dev/tty';\n\n  let fd: number;\n  try {\n    fd = fs.openSync(ttyPath, 'r');\n  } catch {\n    return false;\n  }\n\n  const ttyStream = new tty.ReadStream(fd);\n\n  Object.defineProperty(process, 'stdin', {\n    value: ttyStream,\n    writable: true,\n    configurable: true,\n  });\n\n  return true;\n}\n"],"mappings":"AAAA,YAAY,QAAQ;AACpB,YAAY,SAAS;AAGrB,MAAM,iBAAiB,OAAO;AAM9B,MAAM,UAAU;AAYT,SAAS,oBAAoB,KAAqB;AAEvD,MAAI,OAAO,IAAI,QAAQ,SAAS,EAAE;AAGlC,SAAO,KAAK,QAAQ,qCAAqC,EAAE;AAG3D,SAAO,KACJ,MAAM,IAAI,EACV,IAAI,UAAQ;AACX,QAAI,CAAC,KAAK,SAAS,IAAI,EAAG,QAAO;AACjC,UAAM,WAAW,KAAK,MAAM,IAAI;AAGhC,aAAS,IAAI,SAAS,SAAS,GAAG,KAAK,GAAG,KAAK;AAC7C,UAAI,SAAS,CAAC,EAAG,SAAS,EAAG,QAAO,SAAS,CAAC;AAAA,IAChD;AACA,WAAO;AAAA,EACT,CAAC,EACA,KAAK,IAAI;AAGZ,SAAO,KAAK,QAAQ,WAAW,MAAM;AAErC,SAAO,KAAK,KAAK;AACnB;AAaA,eAAsB,kBAA0C;AAC9D,MAAI,QAAQ,MAAM,MAAO,QAAO;AAEhC,QAAM,SAAmB,CAAC;AAC1B,MAAI,aAAa;AACjB,MAAI,YAAY;AAEhB,mBAAiB,SAAS,QAAQ,OAAO;AACvC,UAAM,MAAM;AAEZ,QAAI,aAAa,IAAI,SAAS,gBAAgB;AAG5C,YAAM,YAAY,iBAAiB;AACnC,UAAI,YAAY,GAAG;AACjB,eAAO,KAAK,OAAO,KAAK,IAAI,SAAS,GAAG,SAAS,CAAC,CAAC;AAAA,MACrD;AACA,UAAI,KAAK,CAAC;AACV,mBAAa;AACb,kBAAY;AAGZ;AAAA,IACF;AAEA,WAAO,KAAK,GAAG;AACf,kBAAc,IAAI;AAAA,EACpB;AAEA,MAAI,WAAW;AACb,YAAQ,OAAO,MAAM,iCAAiC,iBAAiB,OAAO,IAAI;AAAA,CAAyB;AAAA,EAC7G;AAEA,QAAM,MAAM,OAAO,OAAO,MAAM,EAAE,SAAS,OAAO;AAGlD,aAAW,OAAO,QAAQ;AACxB,QAAI,KAAK,CAAC;AAAA,EACZ;AACA,SAAO,SAAS;AAEhB,QAAM,UAAU,oBAAoB,GAAG;AACvC,SAAO,QAAQ,SAAS,IAAI,UAAU;AACxC;AAUO,SAAS,qBAA8B;AAC5C,QAAM,UAAU,QAAQ,aAAa,UAAU,QAAQ;AAEvD,MAAI;AACJ,MAAI;AACF,SAAK,GAAG,SAAS,SAAS,GAAG;AAAA,EAC/B,QAAQ;AACN,WAAO;AAAA,EACT;AAEA,QAAM,YAAY,IAAI,IAAI,WAAW,EAAE;AAEvC,SAAO,eAAe,SAAS,SAAS;AAAA,IACtC,OAAO;AAAA,IACP,UAAU;AAAA,IACV,cAAc;AAAA,EAChB,CAAC;AAED,SAAO;AACT;","names":[]}

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

@@ -0,0 +1,50 @@
+/**
+ * Storage factory — creates the appropriate storage backend based on resolved config.
+ *
+ * If PG is selected but fails to connect, falls back to LibSQL so the TUI
+ * can start and the user can fix the connection via /settings.
+ */
+import type { MastraCompositeStore, RetentionConfig } from '@mastra/core/storage';
+import type { MastraVector } from '@mastra/core/vector';
+import type { StorageConfig } from './project.js';
+export declare const MASTRA_CODE_LOCAL_PRAGMAS: {
+    cacheSize: number;
+    mmapSize: number;
+};
+/**
+ * Construct a LibSQL store for an arbitrary url/authToken, applying the same
+ * local pragmas the default factory uses.
+ */
+export declare function buildLibSQLStore(opts: {
+    id?: string;
+    url: string;
+    authToken?: string;
+    retention?: RetentionConfig;
+}): MastraCompositeStore;
+/** Construct a LibSQL vector store for an arbitrary url/authToken. */
+export declare function buildLibSQLVector(opts: {
+    id?: string;
+    url: string;
+    authToken?: string;
+}): MastraVector;
+export interface StorageResult {
+    storage: MastraCompositeStore;
+    /** The effective backend after any fallback logic has run. */
+    backend: 'libsql' | 'pg';
+    /** Non-null when PG was requested but failed — contains a user-facing warning. */
+    warning?: string;
+}
+/**
+ * Create a storage instance from the resolved config.
+ *
+ * - `libsql` backend → LibSQLStore (always available)
+ * - `pg` backend → PostgresStore, falls back to LibSQL on connection failure
+ */
+export declare function createStorage(config: StorageConfig): Promise<StorageResult>;
+/**
+ * Create a vector store for recall search.
+ * Uses a separate LibSQL file to avoid bloating the main storage DB with embedding data.
+ * For PG backends, reuses the same connection (PG handles the extra tables fine).
+ */
+export declare function createVectorStore(config: StorageConfig, effectiveBackend?: 'libsql' | 'pg'): Promise<MastraVector | undefined>;
+//# sourceMappingURL=storage-factory.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"storage-factory.d.ts","sourceRoot":"","sources":["../../src/utils/storage-factory.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,oBAAoB,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAClF,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAIxD,OAAO,KAAK,EAAE,aAAa,EAAmB,MAAM,cAAc,CAAC;AAInE,eAAO,MAAM,yBAAyB;;;CAGrC,CAAC;AAEF;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE;IACrC,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;IACZ,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,eAAe,CAAC;CAC7B,GAAG,oBAAoB,CAQvB;AAED,sEAAsE;AACtE,wBAAgB,iBAAiB,CAAC,IAAI,EAAE;IAAE,EAAE,CAAC,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,YAAY,CAMtG;AAED,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,oBAAoB,CAAC;IAC9B,8DAA8D;IAC9D,OAAO,EAAE,QAAQ,GAAG,IAAI,CAAC;IACzB,kFAAkF;IAClF,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAMD;;;;;GAKG;AACH,wBAAsB,aAAa,CAAC,MAAM,EAAE,aAAa,GAAG,OAAO,CAAC,aAAa,CAAC,CAUjF;AAyDD;;;;GAIG;AACH,wBAAsB,iBAAiB,CACrC,MAAM,EAAE,aAAa,EACrB,gBAAgB,GAAE,QAAQ,GAAG,IAAqB,GACjD,OAAO,CAAC,YAAY,GAAG,SAAS,CAAC,CAuBnC"}

package/dist/utils/storage-factory.js

@@ -0,0 +1,101 @@
+import { LibSQLStore, LibSQLVector } from "@mastra/libsql";
+import { PostgresStore } from "@mastra/pg";
+import { getDatabasePath, getVectorDatabasePath } from "./project.js";
+import { DEFAULT_RETENTION } from "./storage-maintenance.js";
+const MASTRA_CODE_LOCAL_PRAGMAS = {
+  cacheSize: -128e3,
+  mmapSize: 536870912
+};
+function buildLibSQLStore(opts) {
+  return new LibSQLStore({
+    id: opts.id ?? "mastra-code-storage",
+    url: opts.url,
+    ...opts.authToken ? { authToken: opts.authToken } : {},
+    ...opts.retention ? { retention: opts.retention } : {},
+    localPragmas: MASTRA_CODE_LOCAL_PRAGMAS
+  });
+}
+function buildLibSQLVector(opts) {
+  return new LibSQLVector({
+    id: opts.id ?? "mastra-code-vectors",
+    url: opts.url,
+    ...opts.authToken ? { authToken: opts.authToken } : {}
+  });
+}
+function createFallbackLibSQL() {
+  return buildLibSQLStore({ url: `file:${getDatabasePath()}`, retention: DEFAULT_RETENTION });
+}
+async function createStorage(config) {
+  if (config.backend === "pg") {
+    return createPgStorage(config);
+  }
+  return {
+    storage: buildLibSQLStore({ url: config.url, authToken: config.authToken, retention: DEFAULT_RETENTION }),
+    backend: "libsql"
+  };
+}
+async function createPgStorage(config) {
+  if (!config.connectionString && !config.host) {
+    return {
+      storage: createFallbackLibSQL(),
+      backend: "libsql",
+      warning: "PostgreSQL backend selected but no connection info configured. Using LibSQL fallback. Set a connection string via /settings."
+    };
+  }
+  const base = {
+    id: "mastra-code-storage",
+    retention: DEFAULT_RETENTION,
+    ...config.schemaName ? { schemaName: config.schemaName } : {},
+    ...config.disableInit ? { disableInit: config.disableInit } : {},
+    ...config.skipDefaultIndexes ? { skipDefaultIndexes: config.skipDefaultIndexes } : {}
+  };
+  const store = config.connectionString ? new PostgresStore({ ...base, connectionString: config.connectionString }) : new PostgresStore({
+    ...base,
+    host: config.host,
+    port: config.port,
+    database: config.database,
+    user: config.user,
+    password: config.password
+  });
+  try {
+    await store.init();
+  } catch (err) {
+    const msg = err?.message ?? String(err);
+    const target = config.connectionString ?? `${config.host}:${config.port ?? 5432}`;
+    try {
+      await store.close();
+    } catch {
+    }
+    return {
+      storage: createFallbackLibSQL(),
+      backend: "libsql",
+      warning: `Failed to connect to PostgreSQL at ${target}: ${msg}
+Using LibSQL fallback. Fix the connection via /settings.`
+    };
+  }
+  return { storage: store, backend: "pg" };
+}
+async function createVectorStore(config, effectiveBackend = config.backend) {
+  if (effectiveBackend === "pg") {
+    const pgConfig = config;
+    if (!pgConfig.connectionString && !pgConfig.host) return void 0;
+    const { PgVector } = await import("@mastra/pg");
+    return new PgVector({
+      id: "mastra-code-vectors",
+      connectionString: pgConfig.connectionString ?? `postgresql://${pgConfig.user}:${pgConfig.password}@${pgConfig.host}:${pgConfig.port ?? 5432}/${pgConfig.database}`
+    });
+  }
+  const libsqlConfig = config;
+  return buildLibSQLVector({
+    url: libsqlConfig.vectorUrl ?? `file:${getVectorDatabasePath()}`,
+    authToken: libsqlConfig.vectorAuthToken
+  });
+}
+export {
+  MASTRA_CODE_LOCAL_PRAGMAS,
+  buildLibSQLStore,
+  buildLibSQLVector,
+  createStorage,
+  createVectorStore
+};
+//# sourceMappingURL=storage-factory.js.map

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

@@ -0,0 +1 @@
+{"version":3,"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":"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","names":[]}

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,236 @@
+import { closeSync, existsSync, openSync, readSync, renameSync, rmSync, statSync, statfsSync } from "node:fs";
+import { dirname } from "node:path";
+import Database from "libsql";
+import { getDatabasePath, getVectorDatabasePath } from "./project.js";
+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" }
+  }
+};
+function fileSizeWithWal(dbFile) {
+  let total = 0;
+  for (const candidate of [dbFile, `${dbFile}-wal`]) {
+    try {
+      total += statSync(candidate).size;
+    } catch {
+    }
+  }
+  return total;
+}
+function requiredFreeBytes(liveBytes) {
+  return Math.ceil(liveBytes * 1.2) + 256 * 1024 * 1024;
+}
+function pragmaNumber(db, pragma) {
+  const rows = db.pragma(pragma);
+  const row = rows?.[0];
+  return row ? Number(Object.values(row)[0]) : 0;
+}
+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);
+  }
+}
+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 \u2014 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 \u2014 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 \u2014 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;
+}
+function fileUrlToPath(url) {
+  if (!url.startsWith("file:")) return void 0;
+  return url.replace(/^file:\/\//, "").replace(/^file:/, "");
+}
+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;
+}
+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}`;
+}
+const PASS_MAX_BATCHES = 20;
+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 ?? {})) {
+      const kept = keepMemory && domain === "memory";
+      log(`  ${domain}.${table}: ${kept ? "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\u2026"}`);
+      }
+    }
+    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 \u2014 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)\u2026 this can take several minutes on large databases.");
+  const reclaimed = await maintenance.reclaimDisk((file, bytesBefore, liveBytes) => {
+    log(`  vacuuming ${file} (${formatBytes(bytesBefore)}, ~${formatBytes(liveBytes)} live)\u2026`);
+  });
+  if (reclaimed.length === 0) {
+    log("No local database files found to vacuum.");
+    return;
+  }
+  for (const r of reclaimed) {
+    log(`  ${r.file}: ${formatBytes(r.bytesBefore)} \u2192 ${formatBytes(r.bytesAfter)}`);
+  }
+  const saved = reclaimed.reduce((sum, r) => sum + Math.max(0, r.bytesBefore - r.bytesAfter), 0);
+  log(`Reclaimed ${formatBytes(saved)}.`);
+}
+export {
+  DEFAULT_RETENTION,
+  createStorageMaintenance,
+  formatBytes,
+  reclaimLibSQLDisk,
+  requiredFreeBytes,
+  resolveLocalDbFiles,
+  runStorageMaintenance
+};
+//# sourceMappingURL=storage-maintenance.js.map