@mastra/code-sdk 0.0.0-livekit-beta-v3-20260709031728

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 } 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. Shared so per-tenant storage
+ * (see `web/tenant-storage.ts`) doesn't duplicate the construction.
+ */
+export declare function buildLibSQLStore(opts: {
+    id?: string;
+    url: string;
+    authToken?: string;
+}): 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,MAAM,sBAAsB,CAAC;AACjE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAIxD,OAAO,KAAK,EAAE,aAAa,EAAmB,MAAM,cAAc,CAAC;AAGnE,eAAO,MAAM,yBAAyB;;;CAGrC,CAAC;AAEF;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE;IAAE,EAAE,CAAC,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,oBAAoB,CAO7G;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;AAwDD;;;;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,98 @@
+import { LibSQLStore, LibSQLVector } from "@mastra/libsql";
+import { PostgresStore } from "@mastra/pg";
+import { getDatabasePath, getVectorDatabasePath } from "./project.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 } : {},
+    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()}` });
+}
+async function createStorage(config) {
+  if (config.backend === "pg") {
+    return createPgStorage(config);
+  }
+  return {
+    storage: buildLibSQLStore({ url: config.url, authToken: config.authToken }),
+    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",
+    ...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 } 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';\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. Shared so per-tenant storage\n * (see `web/tenant-storage.ts`) doesn't duplicate the construction.\n */\nexport function buildLibSQLStore(opts: { id?: string; url: string; authToken?: string }): MastraCompositeStore {\n  return new LibSQLStore({\n    id: opts.id ?? 'mastra-code-storage',\n    url: opts.url,\n    ...(opts.authToken ? { authToken: opts.authToken } : {}),\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()}` });\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 }),\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    ...(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/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,108 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { getAppDataDir } from "./project.js";
+class ThreadLockError extends Error {
+  constructor(threadId, ownerPid) {
+    super(`Thread ${threadId} is locked by another process (PID ${ownerPid})`);
+    this.threadId = threadId;
+    this.ownerPid = ownerPid;
+    this.name = "ThreadLockError";
+  }
+  threadId;
+  ownerPid;
+}
+function getLocksDir() {
+  const dir = path.join(getAppDataDir(), "locks");
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  return dir;
+}
+function getLockPath(threadId) {
+  const safeId = threadId.replace(/[^a-zA-Z0-9_-]/g, "_");
+  return path.join(getLocksDir(), `${safeId}.lock`);
+}
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function acquireThreadLock(threadId) {
+  const lockPath = getLockPath(threadId);
+  const myPid = process.pid;
+  if (fs.existsSync(lockPath)) {
+    try {
+      const content = fs.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.writeFileSync(lockPath, String(myPid), { mode: 420 });
+}
+function releaseThreadLock(threadId) {
+  const lockPath = getLockPath(threadId);
+  const myPid = process.pid;
+  try {
+    if (!fs.existsSync(lockPath)) return;
+    const content = fs.readFileSync(lockPath, "utf-8").trim();
+    const ownerPid = parseInt(content, 10);
+    if (ownerPid === myPid) {
+      fs.unlinkSync(lockPath);
+    }
+  } catch {
+  }
+}
+function getThreadLockOwner(threadId) {
+  const lockPath = getLockPath(threadId);
+  try {
+    if (!fs.existsSync(lockPath)) return null;
+    const content = fs.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.unlinkSync(lockPath);
+      } catch {
+      }
+      return null;
+    }
+    return ownerPid;
+  } catch {
+    return null;
+  }
+}
+function releaseAllThreadLocks() {
+  try {
+    const locksDir = getLocksDir();
+    const files = fs.readdirSync(locksDir);
+    const myPid = String(process.pid);
+    for (const file of files) {
+      if (!file.endsWith(".lock")) continue;
+      const lockPath = path.join(locksDir, file);
+      try {
+        const content = fs.readFileSync(lockPath, "utf-8").trim();
+        if (content === myPid) {
+          fs.unlinkSync(lockPath);
+        }
+      } catch {
+      }
+    }
+  } catch {
+  }
+}
+export {
+  ThreadLockError,
+  acquireThreadLock,
+  getThreadLockOwner,
+  releaseAllThreadLocks,
+  releaseThreadLock
+};
+//# sourceMappingURL=thread-lock.js.map

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

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

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";
+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}`;
+}
+export {
+  tokenEstimate,
+  truncateStringForTokenEstimate
+};
+//# sourceMappingURL=token-estimator.js.map

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

@@ -0,0 +1 @@
+{"version":3,"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":"AAAA,SAAS,oBAAoB,qBAAqB;AAElD,SAAS,cAAc,MAAuB;AAC5C,MAAI,CAAC,KAAM,QAAO;AAClB,UAAQ,OAAO,SAAS,WAAW,OAAO,KAAK,UAAU,IAAI,GAC1D,WAAW,iBAAiB,EAAE,EAC9B,WAAW,mBAAmB,EAAE;AACrC;AAEO,SAAS,cAAc,MAA+B;AAC3D,SAAO,mBAAmB,cAAc,IAAI,CAAC;AAC/C;AAEO,SAAS,+BAA+B,MAAc,mBAA2B,UAAU,MAAM;AACtG,QAAM,YAAY,cAAc,IAAI;AACpC,QAAM,cAAc,mBAAmB,SAAS;AAEhD,MAAI,eAAe,kBAAmB,QAAO;AAE7C,QAAM,OAAO,UAAU,cAAc,WAAW,CAAC,iBAAiB,IAAI,cAAc,WAAW,GAAG,iBAAiB;AAEnH,SAAO,eAAe,cAAc,iBAAiB;AAAA,EACrD,IAAI;AACN;","names":[]}

package/dist/utils/update-check.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Check for newer versions of mastracode on npm.
+ */
+export type PackageManager = 'npm' | 'pnpm' | 'yarn' | 'bun';
+/**
+ * Detect which package manager was used to install mastracode globally.
+ *
+ * Uses a multi-tier approach:
+ * 1. npm_config_user_agent env var (set when run via `pnpm run`, `npm run`, etc.)
+ * 2. npm_execpath env var (fallback for script-based invocation)
+ * 3. NODE_PATH env var (set by pnpm global bin stubs)
+ * 4. Resolved path of the running script (process.argv[1])
+ * 5. Shell-out to `pnpm list -g` to check if pnpm manages the package
+ * 6. Falls back to 'npm'
+ */
+export declare function detectPackageManager(): Promise<PackageManager>;
+/**
+ * Build the shell command string a user would run to install/update globally.
+ */
+export declare function getInstallCommand(pm: PackageManager, version?: string): string;
+/**
+ * Read the current version, injected at build time by tsup's `define` option.
+ * Falls back to reading package.json at runtime (e.g. when running from source with tsx).
+ */
+export declare function getCurrentVersion(): string;
+/**
+ * Fetch the latest published version from npm.
+ * Returns null if the fetch fails (network error, timeout, etc.).
+ */
+export declare function fetchLatestVersion(): Promise<string | null>;
+/**
+ * Simple semver comparison: returns true if `latest` is newer than `current`.
+ * Handles standard x.y.z versions. Ignores pre-release tags.
+ */
+export declare function isNewerVersion(current: string, latest: string): boolean;
+/**
+ * Fetch the CHANGELOG.md for a specific published version from the npm CDN
+ * and extract a human-readable summary of changes.
+ * Returns null if the fetch fails or the changelog can't be parsed.
+ */
+export declare function fetchChangelog(version: string): Promise<string | null>;
+/**
+ * Extract the changelog section for a specific version and format it
+ * as a concise bullet list suitable for terminal display.
+ */
+export declare function parseChangelog(markdown: string, version: string): string | null;
+/**
+ * Run the appropriate global install command to update mastracode.
+ * Returns true on success, false on failure.
+ */
+export declare function runUpdate(pm: PackageManager, targetVersion: string): Promise<boolean>;
+//# sourceMappingURL=update-check.d.ts.map

package/dist/utils/update-check.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"update-check.d.ts","sourceRoot":"","sources":["../../src/utils/update-check.ts"],"names":[],"mappings":"AAAA;;GAEG;AAeH,MAAM,MAAM,cAAc,GAAG,KAAK,GAAG,MAAM,GAAG,MAAM,GAAG,KAAK,CAAC;AAW7D;;;;;;;;;;GAUG;AACH,wBAAsB,oBAAoB,IAAI,OAAO,CAAC,cAAc,CAAC,CA0CpE;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,EAAE,EAAE,cAAc,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,CAY9E;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,IAAI,MAAM,CAS1C;AAED;;;GAGG;AACH,wBAAsB,kBAAkB,IAAI,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAcjE;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAevE;AAKD;;;;GAIG;AACH,wBAAsB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAe5E;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAiD/E;AAED;;;GAGG;AACH,wBAAgB,SAAS,CAAC,EAAE,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAOrF"}