@vellumai/assistant 0.7.0 → 0.7.1

package/src/channels/types.ts

@@ -136,8 +136,7 @@ export function supportsHostProxy(
   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
+  // 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;
@@ -145,40 +144,6 @@ export function supportsHostProxy(
   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__/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
 // ---------------------------------------------------------------------------

package/src/cli/commands/__tests__/memory-v2.test.ts

@@ -137,7 +137,7 @@ beforeEach(() => {
 // ---------------------------------------------------------------------------
 
 describe("subcommand registration", () => {
-  test("registers v2 under memory with all six subcommands", () => {
+  test("registers v2 under memory with the expected subcommands", () => {
     const program = buildProgramWithStubParent();
     const memory = program.commands.find((c) => c.name() === "memory");
     expect(memory).toBeDefined();
@@ -147,7 +147,6 @@ describe("subcommand registration", () => {
     expect(subcommandNames).toEqual([
       "activation",
       "migrate",
-      "rebuild-edges",
       "reembed",
       "reembed-skills",
       "validate",
@@ -161,18 +160,19 @@ describe("subcommand registration", () => {
     );
   });
 
-  test("--help lists all six subcommands", () => {
+  test("--help lists every registered subcommand", () => {
     const program = buildProgramWithStubParent();
     const memory = program.commands.find((c) => c.name() === "memory")!;
     const v2 = memory.commands.find((c) => c.name() === "v2")!;
     const help = v2.helpInformation();
     // Commander renders each subcommand on its own line under "Commands:".
     expect(help).toContain("migrate");
-    expect(help).toContain("rebuild-edges");
     expect(help).toContain("reembed");
     expect(help).toContain("reembed-skills");
     expect(help).toContain("activation");
     expect(help).toContain("validate");
+    // rebuild-edges was retired alongside the directed-edges work.
+    expect(help).not.toContain("rebuild-edges");
   });
 });
 
@@ -218,34 +218,20 @@ describe("memory v2 migrate", () => {
 });
 
 // ---------------------------------------------------------------------------
-// rebuild-edges
+// rebuild-edges (removed — directed edges live in page frontmatter, no rebuild
+// step is needed). The CLI subcommand was retired alongside the job handler.
 // ---------------------------------------------------------------------------
 
 describe("memory v2 rebuild-edges", () => {
-  test("sends memory_v2/backfill with op=rebuild-edges", async () => {
-    mockIpcResult = { ok: true, result: { jobId: "rebuild-1" } };
+  test("subcommand is no longer registered", async () => {
+    mockIpcResult = { ok: true, result: { jobId: "should-not-fire" } };
 
     const { exitCode } = await runCommand(["memory", "v2", "rebuild-edges"]);
 
-    expect(exitCode).toBe(0);
-    expect(lastIpcCall!.method).toBe("memory_v2_backfill");
-    expect(lastIpcCall!.params.body).toEqual({ op: "rebuild-edges" });
-  });
-
-  test("logs the returned jobId", async () => {
-    mockIpcResult = { ok: true, result: { jobId: "rebuild-abc" } };
-
-    await runCommand(["memory", "v2", "rebuild-edges"]);
-
-    expect(logOutput.some((line) => line.includes("rebuild-abc"))).toBe(true);
-  });
-
-  test("exits with code 1 on IPC failure", async () => {
-    mockIpcResult = { ok: false, error: "Daemon not running" };
-
-    const { exitCode } = await runCommand(["memory", "v2", "rebuild-edges"]);
-
-    expect(exitCode).toBe(1);
+    // commander emits a non-zero exit for unknown subcommands; we just need
+    // to verify the IPC call never happened.
+    expect(exitCode).not.toBe(0);
+    expect(lastIpcCall).toBeNull();
   });
 });
 
@@ -356,7 +342,7 @@ describe("memory v2 validate", () => {
     const joined = logOutput.join("\n");
     expect(joined).toContain("Pages: 12");
     expect(joined).toContain("Edges: 30");
-    expect(joined).toContain("Missing edge endpoints: none");
+    expect(joined).toContain("Missing outgoing edge targets: none");
     expect(joined).toContain("Oversized pages: none");
     expect(joined).toContain("Parse failures: none");
   });
@@ -376,7 +362,7 @@ describe("memory v2 validate", () => {
     await runCommand(["memory", "v2", "validate"]);
 
     const joined = logOutput.join("\n");
-    expect(joined).toContain("Missing edge endpoints: 1");
+    expect(joined).toContain("Missing outgoing edge targets: 1");
     expect(joined).toContain("alice");
     expect(joined).toContain("bob");
     expect(joined).toContain("Oversized pages: 1");