@vellumai/assistant 0.10.2-dev.202606250318.5e7cfb0 → 0.10.2

package/src/cli/commands/cache.ts

@@ -17,9 +17,6 @@ import { log } from "../logger.js";
 /** Warn (stderr) when a raw payload exceeds this byte count. */
 const MAX_PAYLOAD_BYTES = 1_000_000; // 1 MB
 
-/** Standard input file descriptor. */
-const STDIN_FD = 0;
-
 // ── TTL parsing ───────────────────────────────────────────────────────
 
 const TTL_PATTERN = /^(\d+(?:\.\d+)?)\s*(ms|s|m|h)$/;
@@ -102,11 +99,6 @@ function parseJsonPayload(raw: string, source: string): unknown {
  * Read JSON payload from stdin when piped. Throws when stdin is a TTY
  * (no piped input) or when the input is empty/invalid JSON, so the CLI
  * can surface actionable parse errors.
- *
- * Reads file descriptor 0 directly rather than reopening the `/dev/stdin`
- * path. When the caller is a spawned subprocess whose stdin is a pipe (e.g.
- * `Bun.spawn(..., { stdin: "pipe" })`), `open("/dev/stdin")` fails with ENXIO
- * because a pipe read-end cannot be reopened by path; the fd is readable.
  */
 function readPayloadFromStdin(): unknown {
   if (process.stdin.isTTY) {
@@ -119,7 +111,7 @@ function readPayloadFromStdin(): unknown {
 
   let raw: string;
   try {
-    raw = readFileSync(STDIN_FD, "utf-8");
+    raw = readFileSync("/dev/stdin", "utf-8");
   } catch (err) {
     throw new Error(
       `Failed to read stdin: ${err instanceof Error ? err.message : String(err)}.\n` +
@@ -181,9 +173,10 @@ export function registerCacheCommand(program: Command): void {
     transport: "ipc",
     description: "Interact with the assistant's in-memory key/value cache",
     build: (cache) => {
-      cache.addHelpText(
-        "after",
-        `
+
+  cache.addHelpText(
+    "after",
+    `
 The cache is a TTL-aware, LRU-evicting in-memory store managed by the
 running assistant. Data is scoped to the assistant process lifetime and
 is not persisted across restarts.
@@ -197,33 +190,33 @@ Examples:
   $ echo '{"result": [1,2,3]}' | assistant cache set --ttl 5m
   $ assistant cache get my-key
   $ assistant cache delete my-key`,
-      );
-
-      // ── set ───────────────────────────────────────────────────────────
-
-      cache
-        .command("set")
-        .description("Store a JSON value in the cache")
-        .option(
-          "--key <key>",
-          "Cache key for idempotent upsert. Omit to auto-generate.",
-        )
-        .option(
-          "--ttl <duration>",
-          "Time-to-live (minimum 1s). Units: ms, s, m, h (e.g. 1000ms, 30s, 5m, 2h). Defaults to 30m if omitted.",
-        )
-        .option(
-          "--value <json>",
-          "JSON payload to store. Alternative to piping via stdin.",
-        )
-        .option(
-          "--file <path>",
-          "Path to a file containing the JSON payload. Alternative to piping via stdin.",
-        )
-        .option("--json", "Output result as machine-readable JSON.")
-        .addHelpText(
-          "after",
-          `
+  );
+
+  // ── set ───────────────────────────────────────────────────────────
+
+  cache
+    .command("set")
+    .description("Store a JSON value in the cache")
+    .option(
+      "--key <key>",
+      "Cache key for idempotent upsert. Omit to auto-generate.",
+    )
+    .option(
+      "--ttl <duration>",
+      "Time-to-live (minimum 1s). Units: ms, s, m, h (e.g. 1000ms, 30s, 5m, 2h). Defaults to 30m if omitted.",
+    )
+    .option(
+      "--value <json>",
+      "JSON payload to store. Alternative to piping via stdin.",
+    )
+    .option(
+      "--file <path>",
+      "Path to a file containing the JSON payload. Alternative to piping via stdin.",
+    )
+    .option("--json", "Output result as machine-readable JSON.")
+    .addHelpText(
+      "after",
+      `
 Stores a JSON payload in the cache and prints the assigned key. The payload
 can be provided via --value, --file, or piped through stdin. If --key is
 provided, the entry is upserted (created or replaced). If omitted, a new
@@ -247,86 +240,86 @@ Examples:
   $ assistant cache set --file /tmp/payload.json --key scores --ttl 10m
   $ echo '{"scores":[98,85,72]}' | assistant cache set
   $ echo '"simple string"' | assistant cache set --ttl 1h --json`,
-        )
-        .action(
-          async (opts: {
-            key?: string;
-            ttl?: string;
-            value?: string;
-            file?: string;
-            json?: boolean;
-          }) => {
-            let data: unknown;
-            try {
-              data = resolvePayload(opts);
-            } catch (err) {
-              const msg = err instanceof Error ? err.message : String(err);
-              if (opts.json) {
-                process.stdout.write(
-                  JSON.stringify({ ok: false, error: msg }) + "\n",
-                );
-              } else {
-                log.error(msg);
-              }
-              process.exitCode = 1;
-              return;
-            }
-
-            let ttl_ms: number | undefined;
-            try {
-              ttl_ms = parseTtl(opts.ttl);
-            } catch (err) {
-              const msg = err instanceof Error ? err.message : String(err);
-              if (opts.json) {
-                process.stdout.write(
-                  JSON.stringify({ ok: false, error: msg }) + "\n",
-                );
-              } else {
-                log.error(msg);
-              }
-              process.exitCode = 1;
-              return;
-            }
-
-            const params: Record<string, unknown> = { data };
-            if (ttl_ms !== undefined) params.ttl_ms = ttl_ms;
-            if (opts.key) params.key = opts.key;
-
-            const result = await cliIpcCall<{ key: string }>("cache_set", {
-              body: params,
-            });
-
-            if (!result.ok) {
-              if (opts.json) {
-                process.stdout.write(
-                  JSON.stringify({ ok: false, error: result.error }) + "\n",
-                );
-              } else {
-                log.error(`Error: ${result.error}`);
-              }
-              process.exitCode = 1;
-              return;
-            }
-
-            if (opts.json) {
-              process.stdout.write(
-                JSON.stringify({ ok: true, key: result.result!.key }) + "\n",
-              );
-            } else {
-              log.info(`Cached with key: ${result.result!.key}`);
-            }
-          },
-        );
+    )
+    .action(
+      async (opts: {
+        key?: string;
+        ttl?: string;
+        value?: string;
+        file?: string;
+        json?: boolean;
+      }) => {
+        let data: unknown;
+        try {
+          data = resolvePayload(opts);
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          if (opts.json) {
+            process.stdout.write(
+              JSON.stringify({ ok: false, error: msg }) + "\n",
+            );
+          } else {
+            log.error(msg);
+          }
+          process.exitCode = 1;
+          return;
+        }
+
+        let ttl_ms: number | undefined;
+        try {
+          ttl_ms = parseTtl(opts.ttl);
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          if (opts.json) {
+            process.stdout.write(
+              JSON.stringify({ ok: false, error: msg }) + "\n",
+            );
+          } else {
+            log.error(msg);
+          }
+          process.exitCode = 1;
+          return;
+        }
+
+        const params: Record<string, unknown> = { data };
+        if (ttl_ms !== undefined) params.ttl_ms = ttl_ms;
+        if (opts.key) params.key = opts.key;
+
+        const result = await cliIpcCall<{ key: string }>("cache_set", {
+          body: params,
+        });
+
+        if (!result.ok) {
+          if (opts.json) {
+            process.stdout.write(
+              JSON.stringify({ ok: false, error: result.error }) + "\n",
+            );
+          } else {
+            log.error(`Error: ${result.error}`);
+          }
+          process.exitCode = 1;
+          return;
+        }
 
-      // ── get ───────────────────────────────────────────────────────────
+        if (opts.json) {
+          process.stdout.write(
+            JSON.stringify({ ok: true, key: result.result!.key }) + "\n",
+          );
+        } else {
+          log.info(`Cached with key: ${result.result!.key}`);
+        }
+      },
+    );
+
+  // ── get ───────────────────────────────────────────────────────────
 
-      cache
-        .command("get <key>")
-        .description("Retrieve a cached value by key")
-        .option("--json", "Output result as machine-readable JSON.")
-        .addHelpText(
-          "after",
-          `
+  cache
+    .command("get <key>")
+    .description("Retrieve a cached value by key")
+    .option("--json", "Output result as machine-readable JSON.")
+    .addHelpText(
+      "after",
+      `
 Arguments:
   key   The cache key to look up. Run 'assistant cache set' to store a
         value and receive its key.
@@ -338,52 +331,49 @@ exist or has expired, reports not-found. In --json mode, a miss returns
 Examples:
   $ assistant cache get my-key
   $ assistant cache get my-key --json`,
-        )
-        .action(async (key: string, opts: { json?: boolean }) => {
-          const result = await cliIpcCall<{ data: unknown } | null>(
-            "cache_get",
-            {
-              body: { key },
-            },
+    )
+    .action(async (key: string, opts: { json?: boolean }) => {
+      const result = await cliIpcCall<{ data: unknown } | null>("cache_get", {
+        body: { key },
+      });
+
+      if (!result.ok) {
+        if (opts.json) {
+          process.stdout.write(
+            JSON.stringify({ ok: false, error: result.error }) + "\n",
           );
-
-          if (!result.ok) {
-            if (opts.json) {
-              process.stdout.write(
-                JSON.stringify({ ok: false, error: result.error }) + "\n",
-              );
-            } else {
-              log.error(`Error: ${result.error}`);
-            }
-            process.exitCode = 1;
-            return;
-          }
-
-          if (opts.json) {
-            process.stdout.write(
-              JSON.stringify({
-                ok: true,
-                data: result.result ? result.result.data : null,
-              }) + "\n",
-            );
-          } else {
-            if (result.result == null) {
-              log.info(`No cache entry found for key "${key}".`);
-            } else {
-              log.info(JSON.stringify(result.result.data, null, 2));
-            }
-          }
-        });
-
-      // ── delete ────────────────────────────────────────────────────────
-
-      cache
-        .command("delete <key>")
-        .description("Remove a cached entry by key")
-        .option("--json", "Output result as machine-readable JSON.")
-        .addHelpText(
-          "after",
-          `
+        } else {
+          log.error(`Error: ${result.error}`);
+        }
+        process.exitCode = 1;
+        return;
+      }
+
+      if (opts.json) {
+        process.stdout.write(
+          JSON.stringify({
+            ok: true,
+            data: result.result ? result.result.data : null,
+          }) + "\n",
+        );
+      } else {
+        if (result.result == null) {
+          log.info(`No cache entry found for key "${key}".`);
+        } else {
+          log.info(JSON.stringify(result.result.data, null, 2));
+        }
+      }
+    });
+
+  // ── delete ────────────────────────────────────────────────────────
+
+  cache
+    .command("delete <key>")
+    .description("Remove a cached entry by key")
+    .option("--json", "Output result as machine-readable JSON.")
+    .addHelpText(
+      "after",
+      `
 Arguments:
   key   The cache key to remove. Run 'assistant cache get <key>' to
         verify a key exists before deleting.
@@ -394,39 +384,36 @@ existed or not, but reports whether an entry was actually removed.
 Examples:
   $ assistant cache delete my-key
   $ assistant cache delete my-key --json`,
-        )
-        .action(async (key: string, opts: { json?: boolean }) => {
-          const result = await cliIpcCall<{ deleted: boolean }>(
-            "cache_delete",
-            {
-              body: { key },
-            },
+    )
+    .action(async (key: string, opts: { json?: boolean }) => {
+      const result = await cliIpcCall<{ deleted: boolean }>("cache_delete", {
+        body: { key },
+      });
+
+      if (!result.ok) {
+        if (opts.json) {
+          process.stdout.write(
+            JSON.stringify({ ok: false, error: result.error }) + "\n",
           );
-
-          if (!result.ok) {
-            if (opts.json) {
-              process.stdout.write(
-                JSON.stringify({ ok: false, error: result.error }) + "\n",
-              );
-            } else {
-              log.error(`Error: ${result.error}`);
-            }
-            process.exitCode = 1;
-            return;
-          }
-
-          const deleted = result.result!.deleted;
-
-          if (opts.json) {
-            process.stdout.write(JSON.stringify({ ok: true, deleted }) + "\n");
-          } else {
-            if (deleted) {
-              log.info(`Deleted cache entry "${key}".`);
-            } else {
-              log.info(`No cache entry "${key}" (nothing to delete).`);
-            }
-          }
-        });
+        } else {
+          log.error(`Error: ${result.error}`);
+        }
+        process.exitCode = 1;
+        return;
+      }
+
+      const deleted = result.result!.deleted;
+
+      if (opts.json) {
+        process.stdout.write(JSON.stringify({ ok: true, deleted }) + "\n");
+      } else {
+        if (deleted) {
+          log.info(`Deleted cache entry "${key}".`);
+        } else {
+          log.info(`No cache entry "${key}" (nothing to delete).`);
+        }
+      }
+    });
     },
   });
 }

package/src/cli/commands/db/__tests__/repair.test.ts

@@ -456,9 +456,6 @@ async function initSchema(): Promise<void> {
   clearStoredDb("memory");
 }
 
-// Every test here runs initSchema(), which replays the full production
-// migration suite, plus at least one repair pass. On a loaded machine that
-// comfortably exceeds bun's 5s per-test default, so each gets a 30s ceiling.
 describe("assistant db repair — conversation-backfill step", () => {
   test("backfills a disk-only conversation into SQLite", async () => {
     await initSchema();
@@ -502,7 +499,7 @@ describe("assistant db repair — conversation-backfill step", () => {
     } finally {
       verify.close();
     }
-  }, 30_000);
+  });
 
   test("skips conversations already present (idempotent)", async () => {
     await initSchema();
@@ -519,6 +516,8 @@ describe("assistant db repair — conversation-backfill step", () => {
     expect(parsed.steps[1].result.data.recovered).toBe(0);
     expect(parsed.steps[1].result.data.skipped).toBe(1);
     expect(parsed.steps[1].result.status).toBe("ok");
+    // Two full repair passes (each walks the DB via integrity-check) exceed
+    // bun's 5s per-test default, so raise the ceiling to keep CI stable.
   }, 30_000);
 
   test("reports nothing-to-backfill on an empty conversations dir", async () => {
@@ -530,7 +529,7 @@ describe("assistant db repair — conversation-backfill step", () => {
     expect(parsed.steps[1].result.status).toBe("ok");
     expect(parsed.steps[1].result.summary).toContain("nothing to backfill");
     expect(parsed.steps[1].result.data.recovered).toBe(0);
-  }, 30_000);
+  });
 
   test("surfaces warnings for malformed meta.json without erroring the step", async () => {
     await initSchema();
@@ -548,5 +547,5 @@ describe("assistant db repair — conversation-backfill step", () => {
         w.includes("malformed meta.json"),
       ),
     ).toBe(true);
-  }, 30_000);
+  });
 });

package/src/cli/commands/db/status.ts

@@ -31,7 +31,6 @@ import type { Command } from "commander";
 import { getLogsDbPath } from "../../../util/logs-db-path.js";
 import { getMemoryDbPath } from "../../../util/memory-db-path.js";
 import { getDbPath } from "../../../util/platform.js";
-import { getTelemetryDbPath } from "../../../util/telemetry-db-path.js";
 import { red } from "../../lib/cli-colors.js";
 import { shouldOutputJson, writeOutput } from "../../output.js";
 import {
@@ -100,15 +99,6 @@ interface StatusReport {
    */
   memoryFile?: FileFacts;
   memoryDb?: DbFacts | null;
-  /**
-   * The dedicated telemetry database (`assistant-telemetry.db`). Like
-   * `logsFile` and `memoryFile`, it is omitted from the report until the file
-   * exists on disk — it is created the first time the daemon opens its
-   * connection, so a fresh install that has never run the daemon won't have
-   * one.
-   */
-  telemetryFile?: FileFacts;
-  telemetryDb?: DbFacts | null;
 }
 
 interface MigrationSummary {
@@ -337,13 +327,6 @@ function renderHuman(report: StatusReport): string {
     out += renderDbBlock(report.memoryFile, report.memoryDb ?? null);
   }
 
-  // The secondary telemetry file is likewise only reported once it exists.
-  if (report.telemetryFile?.exists) {
-    out += "\n";
-    out += "Telemetry database (telemetry event tables)\n";
-    out += renderDbBlock(report.telemetryFile, report.telemetryDb ?? null);
-  }
-
   // Cross-database migration summary — the checkpoint ledger lives only in
   // the main DB, so this is a single block at the end covering all three.
   out += renderSummary(report.migration);
@@ -426,13 +409,7 @@ function readMigrationSummary(mainDbPath: string): MigrationSummary | null {
       // No table yet.
     }
 
-    return {
-      latestKey,
-      latestUpdatedAtMs,
-      appliedSteps,
-      appliedRegistry,
-      crashed,
-    };
+    return { latestKey, latestUpdatedAtMs, appliedSteps, appliedRegistry, crashed };
   } finally {
     db.close();
   }
@@ -542,17 +519,6 @@ export function registerDbStatus(parent: Command): void {
         }
       }
 
-      // Same best-effort probe for the dedicated telemetry DB.
-      const telemetryFile = readFileFacts(getTelemetryDbPath());
-      let telemetryDb: DbFacts | null = null;
-      if (telemetryFile.exists) {
-        try {
-          telemetryDb = readDbFacts(telemetryFile.path);
-        } catch {
-          telemetryDb = null;
-        }
-      }
-
       // Cross-database migration summary from the main DB's checkpoint ledger.
       let migration: MigrationSummary | null = null;
       try {
@@ -569,8 +535,6 @@ export function registerDbStatus(parent: Command): void {
         logsDb,
         memoryFile,
         memoryDb,
-        telemetryFile,
-        telemetryDb,
       };
       if (shouldOutputJson(this)) {
         writeOutput(this, report);