@vellumai/assistant 0.7.0 → 0.7.2

package/src/channels/types.ts

@@ -91,17 +91,18 @@ export function isInteractiveInterface(id: InterfaceId): boolean {
 
 /**
  * Host proxy capabilities that an interface can support. The macOS client
- * supports all four; the chrome-extension interface only supports
+ * supports all five; the chrome-extension interface only supports
  * host_browser (via the Chrome DevTools Protocol proxy).
  */
 export type HostProxyCapability =
   | "host_bash"
   | "host_file"
   | "host_cu"
-  | "host_browser";
+  | "host_browser"
+  | "host_app_control";
 
 /**
- * Interfaces that support the full desktop host-proxy set (all four
+ * Interfaces that support the full desktop host-proxy set (all five
  * `HostProxyCapability` values). This is the capability-level identity used
  * by the discriminated transport metadata union and by the
  * `supportsHostProxy(id)` type predicate.
@@ -135,50 +136,15 @@ export function supportsHostProxy(
   id: InterfaceId,
   capability?: HostProxyCapability,
 ): boolean {
-  // macOS supports all four host proxy capabilities including host_browser.
-  // The host_browser proxy is provisioned via the SSE sender path (or via the
-  // ChromeExtensionRegistry when an extension connection is present). When no
-  // extension is connected, browser tools fall through to cdp-inspect/local
-  // via the CDP factory's candidate chain.
+  // macOS supports all five host proxy capabilities including host_browser
+  // and host_app_control. The host_browser proxy is provisioned via the
+  // assistant event hub. When no extension is connected, browser tools fall
+  // through to cdp-inspect/local via the CDP factory's candidate chain.
   if (id === "macos") return true;
   if (id === "chrome-extension" && capability === "host_browser") return true;
   return false;
 }
 
-/**
- * Whether the interface can service host_browser frames via the
- * ChromeExtensionRegistry (WebSocket) when an extension connection exists.
- *
- * Returns `true` for interfaces where the daemon should set
- * `hostBrowserSenderOverride` and provision a `HostBrowserProxy` when the
- * guardian has an active extension connection — currently `chrome-extension`
- * and `macos`.
- *
- * Use this instead of hard-coding interface checks so new desktop interfaces
- * only need to be added in one place.
- */
-export function canServiceRegistryBrowser(id: InterfaceId): boolean {
-  return id === "chrome-extension" || id === "macos";
-}
-
-/**
- * Whether the interface can service host_browser frames via the SSE event
- * hub when a chrome-extension client is connected over SSE (cloud mode).
- *
- * In cloud/platform-hosted deployments the chrome extension connects via
- * SSE (`GET /v1/events`) instead of a direct WebSocket. There is no
- * ChromeExtensionRegistry entry, but the extension is a valid SSE consumer
- * for `host_browser_request` frames and can POST results back to
- * `/v1/host-browser-result`.
- *
- * Returns `true` for interfaces that should provision a `HostBrowserProxy`
- * with the SSE hub sender when a chrome-extension SSE client is present in
- * the ClientRegistry.
- */
-export function canServiceSseBrowser(id: InterfaceId): boolean {
-  return id === "web" || id === "chrome-extension" || id === "macos";
-}
-
 export interface TurnInterfaceContext {
   userMessageInterface: InterfaceId;
   assistantMessageInterface: InterfaceId;

package/src/cli/commands/__tests__/backup.test.ts

@@ -9,7 +9,6 @@
  * or via a commander program (for end-to-end arg parsing).
  */
 
-import { Readable } from "node:stream";
 import {
   afterEach,
   beforeEach,
@@ -130,8 +129,8 @@ let mockDaemonRunning = false;
 const recoveryCallOrder: string[] = [];
 
 /** Number of times each recovery helper was invoked. */
-let mockResetDbCalls = 0;
-let mockInvalidateConfigCacheCalls = 0;
+let _mockResetDbCalls = 0;
+let _mockInvalidateConfigCacheCalls = 0;
 
 /** Log calls captured by the mocked logger. */
 let mockLogInfo: string[] = [];
@@ -167,7 +166,7 @@ mock.module("../../../config/loader.js", () => ({
     backup: getComputedBackupConfig(),
   }),
   invalidateConfigCache: () => {
-    mockInvalidateConfigCacheCalls += 1;
+    _mockInvalidateConfigCacheCalls += 1;
     recoveryCallOrder.push("invalidateConfigCache");
   },
 }));
@@ -178,7 +177,7 @@ mock.module("../../../daemon/daemon-control.js", () => ({
 
 mock.module("../../../memory/db-connection.js", () => ({
   resetDb: () => {
-    mockResetDbCalls += 1;
+    _mockResetDbCalls += 1;
     recoveryCallOrder.push("resetDb");
   },
 }));
@@ -323,9 +322,6 @@ const {
   handleDestinationsList,
   handleStatus,
   handleList,
-  handleCreate,
-  handleVerify,
-  handleRestore,
   registerBackupCommand,
 } = backupMod;
 
@@ -342,8 +338,8 @@ beforeEach(() => {
   mockLogError = [];
   mockCreateShouldThrow = null;
   mockDaemonRunning = false;
-  mockResetDbCalls = 0;
-  mockInvalidateConfigCacheCalls = 0;
+  _mockResetDbCalls = 0;
+  _mockInvalidateConfigCacheCalls = 0;
   recoveryCallOrder.length = 0;
   process.exitCode = 0;
   mockVerifyResult = { valid: true };
@@ -768,273 +764,6 @@ describe("handleList", () => {
 // create
 // ---------------------------------------------------------------------------
 
-describe("handleCreate", () => {
-  test("renders successful snapshot result with empty offsite", async () => {
-    await handleCreate();
-    const out = mockLogInfo.join("\n");
-    expect(out).toContain("Created snapshot:");
-    expect(out).toContain("backup-20260411-093000.vbundle");
-    expect(out).toContain("offsite: (none)");
-  });
-
-  test("renders per-destination outcome mix (ok, skipped, error)", async () => {
-    mockCreateSnapshotResult = {
-      ...mockCreateSnapshotResult,
-      offsite: [
-        {
-          destination: { path: "/ok", encrypt: true },
-          entry: {
-            path: "/ok/f.vbundle.enc",
-            filename: "f.vbundle.enc",
-            createdAt: new Date(),
-            sizeBytes: 100,
-            encrypted: true,
-          },
-        },
-        {
-          destination: { path: "/skipped", encrypt: true },
-          entry: null,
-          skipped: "parent-missing",
-        },
-        {
-          destination: { path: "/broken", encrypt: false },
-          entry: null,
-          error: "disk full",
-        },
-      ],
-    };
-    await handleCreate();
-    const out = mockLogInfo.join("\n");
-    expect(out).toContain("ok       /ok");
-    expect(out).toContain("skipped  /skipped");
-    expect(out).toContain("error    /broken");
-    expect(out).toContain("disk full");
-  });
-
-  test("concurrency error prints clear message", async () => {
-    mockCreateShouldThrow = new Error("snapshot in progress");
-    await handleCreate();
-    expect(process.exitCode).toBe(1);
-    expect(
-      mockLogError.some((m) =>
-        m.toLowerCase().includes("already running"),
-      ),
-    ).toBe(true);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// verify
-// ---------------------------------------------------------------------------
-
-describe("handleVerify", () => {
-  test("returns valid result from verifySnapshot", async () => {
-    mockVerifyResult = {
-      valid: true,
-      manifest: {
-        schema_version: "1.0.0",
-        created_at: "2026-04-11T09:30:00Z",
-        source: "backup-worker",
-        files: [],
-        manifest_sha256: "abc",
-      },
-    };
-    await handleVerify("/tmp/local/backup.vbundle");
-    const out = mockLogInfo.join("\n");
-    expect(out).toContain("OK:");
-    expect(out).toContain("1.0.0");
-    expect(process.exitCode).toBe(0);
-  });
-
-  test("propagates invalid result with error details", async () => {
-    mockVerifyResult = { valid: false, error: "bad checksum" };
-    await handleVerify("/tmp/local/backup.vbundle");
-    expect(process.exitCode).toBe(1);
-    expect(
-      mockLogError.some((m) => m.includes("Invalid:")),
-    ).toBe(true);
-    expect(
-      mockLogError.some((m) => m.includes("bad checksum")),
-    ).toBe(true);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// restore
-// ---------------------------------------------------------------------------
-
-/**
- * Replace `process.stdin` with a readable stream that emits the given line.
- * `readline.createInterface` consumes this as a single line so prompt-based
- * confirmation tests stay deterministic.
- */
-function stubStdin(input: string): () => void {
-  const original = process.stdin;
-  const stream = Readable.from([input + "\n"]) as NodeJS.ReadableStream;
-  Object.defineProperty(process, "stdin", {
-    value: stream,
-    writable: true,
-    configurable: true,
-  });
-  return () => {
-    Object.defineProperty(process, "stdin", {
-      value: original,
-      writable: true,
-      configurable: true,
-    });
-  };
-}
-
-describe("handleRestore", () => {
-  test("--yes flag bypasses confirmation and calls restoreFromSnapshot", async () => {
-    await handleRestore({
-      path: "/tmp/local/backup-20260411-093000.vbundle",
-      yes: true,
-    });
-    expect(process.exitCode).toBe(0);
-    const out = mockLogInfo.join("\n");
-    expect(out).toContain("Restored from");
-    expect(out).toContain("files restored: 42");
-  });
-
-  test("without --yes and 'n' answer aborts", async () => {
-    const restore = stubStdin("n");
-    try {
-      await handleRestore({
-        path: "/tmp/local/backup-20260411-093000.vbundle",
-      });
-    } finally {
-      restore();
-    }
-    expect(process.exitCode).toBe(0);
-    const out = mockLogInfo.join("\n");
-    expect(out).toContain("Restore cancelled");
-  });
-
-  test("without --path and without --latest errors", async () => {
-    await handleRestore({});
-    expect(process.exitCode).toBe(1);
-    expect(
-      mockLogError.some((m) => m.includes("--path")),
-    ).toBe(true);
-  });
-
-  test("both --path and --latest errors", async () => {
-    await handleRestore({
-      path: "/tmp/x.vbundle",
-      latest: true,
-      yes: true,
-    });
-    expect(process.exitCode).toBe(1);
-    expect(
-      mockLogError.some((m) => m.includes("Cannot combine")),
-    ).toBe(true);
-  });
-
-  test("--latest with no local snapshots errors", async () => {
-    mockSnapshots["/tmp/local"] = [];
-    await handleRestore({ latest: true, yes: true });
-    expect(process.exitCode).toBe(1);
-    expect(
-      mockLogError.some((m) => m.includes("No local snapshots")),
-    ).toBe(true);
-  });
-
-  test("--latest picks newest local snapshot", async () => {
-    mockSnapshots["/tmp/local"] = [
-      {
-        path: "/tmp/local/newest.vbundle",
-        filename: "newest.vbundle",
-        createdAt: new Date("2026-04-11T12:00:00Z"),
-        sizeBytes: 1024,
-        encrypted: false,
-      },
-      {
-        path: "/tmp/local/older.vbundle",
-        filename: "older.vbundle",
-        createdAt: new Date("2026-04-10T12:00:00Z"),
-        sizeBytes: 1024,
-        encrypted: false,
-      },
-    ];
-    await handleRestore({ latest: true, yes: true });
-    expect(process.exitCode).toBe(0);
-    expect(mockLogInfo.some((m) => m.includes("newest.vbundle"))).toBe(
-      true,
-    );
-  });
-
-  test("refuses to run while the assistant is running (no --force)", async () => {
-    // Safety gate: the CLI must refuse to restore against a live assistant
-    // unless --force is passed. Restoring under a running assistant is
-    // dangerous — the open SQLite handle, cached config, and cached trust
-    // rules all contradict the on-disk state after the bundle is written.
-    mockDaemonRunning = true;
-
-    await handleRestore({
-      path: "/tmp/local/backup-20260411-093000.vbundle",
-      yes: true,
-    });
-
-    expect(process.exitCode).toBe(1);
-    expect(
-      mockLogError.some((m) =>
-        m.toLowerCase().includes("assistant is running"),
-      ),
-    ).toBe(true);
-    // restoreFromSnapshot must not have been called — the safety gate
-    // bails before reaching the recovery sequence.
-    expect(mockResetDbCalls).toBe(0);
-    expect(recoveryCallOrder).toEqual([]);
-  });
-
-  test("--force overrides the daemon-running refusal and still runs recovery sequence", async () => {
-    mockDaemonRunning = true;
-
-    await handleRestore({
-      path: "/tmp/local/backup-20260411-093000.vbundle",
-      yes: true,
-      force: true,
-    });
-
-    expect(process.exitCode).toBe(0);
-    // Recovery sequence must still run even with --force — the flag only
-    // overrides the running-assistant refusal, not the DB reset or cache
-    // invalidation.
-    expect(mockResetDbCalls).toBe(1);
-    expect(mockInvalidateConfigCacheCalls).toBe(1);
-    expect(recoveryCallOrder).toEqual([
-      "resetDb",
-      "restoreFromSnapshot",
-      "invalidateConfigCache",    ]);
-  });
-
-  test("successful restore runs resetDb, restore, then cache invalidation in order", async () => {
-    // Regression test for the restore-corrupts-daemon-state gap. The CLI
-    // handler must mirror the HTTP handler's recovery sequence so an
-    // in-process CLI invocation leaves the shared runtime in a consistent
-    // state.
-    mockDaemonRunning = false;
-
-    await handleRestore({
-      path: "/tmp/local/backup-20260411-093000.vbundle",
-      yes: true,
-    });
-
-    expect(process.exitCode).toBe(0);
-    expect(mockResetDbCalls).toBe(1);
-    expect(mockInvalidateConfigCacheCalls).toBe(1);
-    expect(recoveryCallOrder).toEqual([
-      "resetDb",
-      "restoreFromSnapshot",
-      "invalidateConfigCache",    ]);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// End-to-end: via Commander program
-// ---------------------------------------------------------------------------
-
 async function runProgram(
   args: string[],
 ): Promise<{ exitCode: number }> {

package/src/cli/commands/__tests__/cache.test.ts

@@ -11,14 +11,21 @@
  *   - JSON output shape and exit-code behavior on IPC errors
  */
 
-import {
-  existsSync as actualExistsSync,
-  readFileSync as actualReadFileSync,
-} from "node:fs";
+import * as nodeFs from "node:fs";
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 import { Command } from "commander";
 
+// Snapshot the real fs functions into local constants BEFORE the
+// `mock.module("node:fs", ...)` below replaces the module's live bindings.
+// A bare `import { readFileSync as actualReadFileSync }` is an ESM live
+// binding — once the module is mocked the binding resolves to the mock,
+// so the fall-through call inside the mock recurses into itself and hangs.
+// Storing the function in a local variable captures the value at this
+// point and is unaffected by the later module replacement.
+const actualReadFileSync = nodeFs.readFileSync;
+const actualExistsSync = nodeFs.existsSync;
+
 // ---------------------------------------------------------------------------
 // Mock state
 // ---------------------------------------------------------------------------
@@ -80,7 +87,7 @@ mock.module("../../../util/logger.js", () => ({
   }),
 }));
 
-mock.module("node:fs", () => ({
+mock.module("../cache-fs.js", () => ({
   readFileSync: (path: string, encoding?: BufferEncoding) => {
     if (path === "/dev/stdin") {
       if (mockStdinContent === null) {
@@ -290,6 +297,146 @@ describe("cache set", () => {
   });
 });
 
+// ---------------------------------------------------------------------------
+// set — --value and --file input methods
+// ---------------------------------------------------------------------------
+
+describe("cache set --value", () => {
+  test("accepts inline JSON via --value", async () => {
+    mockIpcResult = { ok: true, result: { key: "val-key" } };
+
+    const { exitCode } = await runCommand([
+      "cache",
+      "set",
+      "--value",
+      '{"scores":[98,85,72]}',
+    ]);
+
+    expect(exitCode).toBe(0);
+    expect(lastIpcCall).toBeDefined();
+    expect(lastIpcCall!.method).toBe("cache_set");
+    expect(lastBody().data).toEqual({ scores: [98, 85, 72] });
+  });
+
+  test("--value takes precedence over stdin", async () => {
+    mockStdinContent = '{"from":"stdin"}';
+    mockIpcResult = { ok: true, result: { key: "k" } };
+
+    const { exitCode } = await runCommand([
+      "cache",
+      "set",
+      "--value",
+      '{"from":"flag"}',
+    ]);
+
+    expect(exitCode).toBe(0);
+    expect(lastBody().data).toEqual({ from: "flag" });
+  });
+
+  test("errors on invalid JSON in --value", async () => {
+    const { exitCode } = await runCommand([
+      "cache",
+      "set",
+      "--value",
+      "{not-json}",
+    ]);
+
+    expect(exitCode).toBe(1);
+    expect(lastIpcCall).toBeNull();
+  });
+
+  test("errors on empty --value", async () => {
+    const { exitCode } = await runCommand(["cache", "set", "--value", "   "]);
+
+    expect(exitCode).toBe(1);
+    expect(lastIpcCall).toBeNull();
+  });
+
+  test("--json outputs error on invalid --value", async () => {
+    const { exitCode, stdout } = await runCommand([
+      "cache",
+      "set",
+      "--value",
+      "bad",
+      "--json",
+    ]);
+
+    expect(exitCode).toBe(1);
+    const parsed = JSON.parse(stdout);
+    expect(parsed.ok).toBe(false);
+    expect(parsed.error).toContain("Invalid JSON");
+  });
+
+  test("errors when both --value and --file are provided", async () => {
+    const { exitCode } = await runCommand([
+      "cache",
+      "set",
+      "--value",
+      '"x"',
+      "--file",
+      "/tmp/foo.json",
+    ]);
+
+    expect(exitCode).toBe(1);
+    expect(lastIpcCall).toBeNull();
+  });
+
+  test("works in TTY mode (no stdin required)", async () => {
+    mockStdinIsTTY = true;
+    mockIpcResult = { ok: true, result: { key: "tty-key" } };
+
+    const { exitCode } = await runCommand([
+      "cache",
+      "set",
+      "--value",
+      '"hello"',
+    ]);
+
+    expect(exitCode).toBe(0);
+    expect(lastBody().data).toBe("hello");
+  });
+});
+
+describe("cache set --file", () => {
+  test("reads JSON from a file", async () => {
+    mockIpcResult = { ok: true, result: { key: "file-key" } };
+    const pkgPath = new URL("../../../../package.json", import.meta.url)
+      .pathname;
+
+    const { exitCode } = await runCommand(["cache", "set", "--file", pkgPath]);
+
+    expect(exitCode).toBe(0);
+    expect(lastIpcCall).toBeDefined();
+    expect(lastIpcCall!.method).toBe("cache_set");
+    // package.json is valid JSON, so data should be an object
+    expect(typeof lastBody().data).toBe("object");
+  });
+
+  test("errors on non-existent file", async () => {
+    const { exitCode } = await runCommand([
+      "cache",
+      "set",
+      "--file",
+      "/tmp/does-not-exist-vellum-cache-test.json",
+    ]);
+
+    expect(exitCode).toBe(1);
+    expect(lastIpcCall).toBeNull();
+  });
+
+  test("works in TTY mode (no stdin required)", async () => {
+    mockStdinIsTTY = true;
+    mockIpcResult = { ok: true, result: { key: "file-tty-key" } };
+    const pkgPath = new URL("../../../../package.json", import.meta.url)
+      .pathname;
+
+    const { exitCode } = await runCommand(["cache", "set", "--file", pkgPath]);
+
+    expect(exitCode).toBe(0);
+    expect(lastBody().data).toBeDefined();
+  });
+});
+
 // ---------------------------------------------------------------------------
 // set — TTL parsing edge cases
 // ---------------------------------------------------------------------------