@vellumai/assistant 0.6.3 → 0.6.5

package/src/__tests__/home-state-routes.test.ts

@@ -0,0 +1,162 @@
+import {
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+
+// Stub the OAuth connection store before importing anything that
+// transitively pulls in the writer — otherwise importing the route
+// module would try to open the real OAuth DB.
+mock.module("../oauth/oauth-store.js", () => ({
+  listConnections: () => [],
+}));
+
+// Stub the DB-authoritative conversation count helper so the writer
+// (invoked by the read-through fallback) does not lazy-open a real
+// sqlite handle against a stale or deleted per-test tmpdir.
+mock.module("../memory/conversation-queries.js", () => ({
+  countConversations: () => 0,
+}));
+
+const { handleGetHomeState, homeStateRouteDefinitions } =
+  await import("../runtime/routes/home-state-routes.js");
+const { writeRelationshipState, getRelationshipStatePath } =
+  await import("../home/relationship-state-writer.js");
+
+interface RelationshipStateWire {
+  version: number;
+  assistantId: string;
+  tier: number;
+  progressPercent: number;
+  facts: unknown[];
+  capabilities: Array<{ id: string; tier: string }>;
+  conversationCount: number;
+  hatchedDate: string;
+  assistantName: string;
+  userName?: string;
+  updatedAt: string;
+}
+
+let workspaceDir: string;
+let origWorkspaceDir: string | undefined;
+
+beforeEach(() => {
+  workspaceDir = mkdtempSync(join(tmpdir(), "vellum-hsr-"));
+  origWorkspaceDir = process.env.VELLUM_WORKSPACE_DIR;
+  process.env.VELLUM_WORKSPACE_DIR = workspaceDir;
+});
+
+afterEach(() => {
+  if (origWorkspaceDir === undefined) {
+    delete process.env.VELLUM_WORKSPACE_DIR;
+  } else {
+    process.env.VELLUM_WORKSPACE_DIR = origWorkspaceDir;
+  }
+  try {
+    rmSync(workspaceDir, { recursive: true, force: true });
+  } catch {
+    // best-effort cleanup
+  }
+});
+
+describe("home-state-routes", () => {
+  describe("route registration", () => {
+    test("exposes GET /v1/home/state", () => {
+      const routes = homeStateRouteDefinitions();
+      expect(routes).toHaveLength(1);
+      expect(routes[0].endpoint).toBe("home/state");
+      expect(routes[0].method).toBe("GET");
+    });
+  });
+
+  describe("handleGetHomeState", () => {
+    test("returns persisted state when the JSON file exists", async () => {
+      // Seed a minimal USER.md so the writer produces a non-empty
+      // state, then let the writer persist it.
+      mkdirSync(workspaceDir, { recursive: true });
+      writeFileSync(
+        join(workspaceDir, "USER.md"),
+        "- Preferred name: Casey\n- Work role: Engineer\n",
+        "utf-8",
+      );
+      await writeRelationshipState();
+      expect(existsSync(getRelationshipStatePath())).toBe(true);
+
+      const res = await handleGetHomeState();
+      expect(res.status).toBe(200);
+      const body = (await res.json()) as RelationshipStateWire;
+      expect(body.version).toBe(1);
+      expect(body.assistantId).toBe("default");
+      expect(body.capabilities).toHaveLength(6);
+      expect(body.userName).toBe("Casey");
+      expect(typeof body.updatedAt).toBe("string");
+      expect(Number.isNaN(Date.parse(body.updatedAt))).toBe(false);
+    });
+
+    test("read-through fallback when the file is missing", async () => {
+      // Do NOT call the writer — the file should not exist. The
+      // route must still succeed via computeRelationshipState().
+      expect(existsSync(getRelationshipStatePath())).toBe(false);
+
+      const res = await handleGetHomeState();
+      expect(res.status).toBe(200);
+      const body = (await res.json()) as RelationshipStateWire;
+      expect(body.version).toBe(1);
+      expect(body.tier).toBe(1);
+      expect(body.progressPercent).toBe(0);
+      expect(body.capabilities).toHaveLength(6);
+      expect(body.conversationCount).toBe(0);
+
+      // Fallback must NOT write the file — that's the writer's job.
+      expect(existsSync(getRelationshipStatePath())).toBe(false);
+    });
+
+    test("falls back to compute when the persisted file is malformed", async () => {
+      // Write a deliberately broken file at the state path.
+      const path = getRelationshipStatePath();
+      mkdirSync(join(path, ".."), { recursive: true });
+      writeFileSync(path, "this is not json", "utf-8");
+
+      const res = await handleGetHomeState();
+      expect(res.status).toBe(200);
+      const body = (await res.json()) as RelationshipStateWire;
+      // Parsed body is a fresh compute, not the garbage on disk.
+      expect(body.version).toBe(1);
+      expect(body.capabilities).toHaveLength(6);
+    });
+
+    test("GET returns fresh state even when the persisted file is stale", async () => {
+      // Persist a snapshot with userName=Casey.
+      mkdirSync(workspaceDir, { recursive: true });
+      writeFileSync(
+        join(workspaceDir, "USER.md"),
+        "- Preferred name: Casey\n",
+        "utf-8",
+      );
+      await writeRelationshipState();
+      expect(existsSync(getRelationshipStatePath())).toBe(true);
+
+      // Mutate USER.md outside of any turn-boundary writer call. This
+      // simulates: a user editing their persona file, OAuth connecting
+      // a provider, or a conversation delete flow touching state
+      // outside the turn-boundary writer.
+      writeFileSync(
+        join(workspaceDir, "USER.md"),
+        "- Preferred name: Jamie\n",
+        "utf-8",
+      );
+
+      // The route must return the FRESH value (Jamie), not the
+      // cached value (Casey) from the persisted file.
+      const res = await handleGetHomeState();
+      expect(res.status).toBe(200);
+      const body = (await res.json()) as RelationshipStateWire;
+      expect(body.userName).toBe("Jamie");
+    });
+  });
+});

package/src/__tests__/host-bash-proxy.test.ts

@@ -405,26 +405,21 @@ describe("HostBashProxy", () => {
     function spySignal(source: AbortSignal): Spied {
       const addCalls: string[] = [];
       const removeCalls: string[] = [];
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
       const s = source as any;
       const origAdd = source.addEventListener.bind(source);
       const origRemove = source.removeEventListener.bind(source);
       s.addEventListener = (
         type: string,
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         ...rest: any[]
       ) => {
         addCalls.push(type);
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         return (origAdd as any)(type, ...rest);
       };
       s.removeEventListener = (
         type: string,
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         ...rest: any[]
       ) => {
         removeCalls.push(type);
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         return (origRemove as any)(type, ...rest);
       };
       return { signal: source, addCalls, removeCalls };

package/src/__tests__/host-browser-e2e-cloud.test.ts

@@ -225,8 +225,7 @@ describe("host_browser cloud-hosted e2e round-trip", () => {
     // Same fixture as the HTTP happy path, but configured to return
     // results over the /v1/browser-relay WebSocket instead of POSTing
     // /v1/host-browser-result. This exercises the runtime WS
-    // `message` handler's host_browser_result dispatch path added in
-    // PR2 of the browser-use remediation plan.
+    // `message` handler's host_browser_result dispatch path.
     const mockExt = createMockChromeExtension({
       runtimeBaseUrl,
       token,
@@ -309,8 +308,7 @@ describe("host_browser cloud-hosted e2e round-trip", () => {
   });
 
   test("abort: late /v1/host-browser-result POST after cancel is ignored (no ghost completion)", async () => {
-    // Regression for PR6 of the browser-use remediation plan. The
-    // daemon-side proxy must treat a late result POST — arriving
+    // The daemon-side proxy must treat a late result POST — arriving
     // after the caller has already been resolved with "Aborted" —
     // as a benign race, not a noisy false-positive timeout. It must
     // also NOT resolve the caller a second time.
@@ -434,6 +432,142 @@ describe("host_browser cloud-hosted e2e round-trip", () => {
   });
 });
 
+// ── macOS message ingress with connected extension ──────────────────
+//
+// Verifies the end-to-end path for macOS-originated turns when the user
+// has the chrome extension connected. On macOS, browser commands should
+// route through the registry-backed host browser flow (extension → user's
+// real Chrome session) rather than falling back to local Playwright.
+//
+// The macOS browser backend preference order is:
+//
+//   macOS + extension connected → extension backend (registry-routed)
+//   macOS + extension absent    → cdp-inspect (desktop-auto) → local
+//
+// NOTE: These tests construct a HostBrowserProxy directly and call
+// proxy.request(), which validates the extension relay round-trip but
+// bypasses handleSendMessage / conversation-routes. Full ingress-path
+// coverage (interface propagation, resolveHostBrowserSender wiring, and
+// CDP factory candidate selection) is exercised by the route-level tests
+// in conversation-routes-disk-view.test.ts.
+//
+// If future refactors break the wiring between conversation-routes
+// (`resolveHostBrowserSender`) and the CDP factory's candidate list, those
+// route-level tests will fail.
+
+describe("macOS message ingress with connected extension", () => {
+  let server: RuntimeHttpServer;
+  let port: number;
+  let runtimeBaseUrl: string;
+
+  beforeEach(async () => {
+    const db = getDb();
+    db.run("DELETE FROM contact_channels");
+    db.run("DELETE FROM contacts");
+    pendingInteractions.clear();
+    __resetChromeExtensionRegistryForTests();
+
+    port = 20000 + Math.floor(Math.random() * 200);
+    runtimeBaseUrl = `http://127.0.0.1:${port}`;
+    server = new RuntimeHttpServer({ port });
+    await server.start();
+  });
+
+  afterEach(async () => {
+    await server?.stop();
+    pendingInteractions.clear();
+    __resetChromeExtensionRegistryForTests();
+  });
+
+  test("macOS turn routes Browser.getVersion through the registry-backed extension, not local Playwright", async () => {
+    // Arrange: connect a mock extension for a given guardianId.
+    const guardianId = `test-guardian-macos-${crypto.randomUUID()}`;
+    const token = mintActorToken(guardianId);
+
+    const { createMockChromeExtension } =
+      await import("./fixtures/mock-chrome-extension.js");
+    const mockExt = createMockChromeExtension({
+      runtimeBaseUrl,
+      token,
+    });
+    await mockExt.start();
+    await mockExt.waitForConnection();
+    await waitForRegistryEntry(guardianId);
+
+    // Build a proxy bound to the guardian's extension connection, mimicking
+    // the wiring that conversation-routes.ts performs for macOS turns when
+    // the ChromeExtensionRegistry has an active entry for the guardian.
+    const { proxy } = createBoundProxy(guardianId, "conv-macos-ext");
+
+    // Act: issue a CDP command through the proxy (same as how browser tools
+    // dispatch commands during a macOS turn with extension override).
+    const result = await proxy.request(
+      { cdpMethod: "Browser.getVersion" },
+      "conv-macos-ext",
+    );
+
+    // Assert: the command reached the mock extension (not local Playwright)
+    // and the round-trip completed successfully.
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain("Chrome/MockTest");
+
+    const received = mockExt.receivedRequests();
+    expect(received).toHaveLength(1);
+    expect(received[0].cdpMethod).toBe("Browser.getVersion");
+    expect(received[0].conversationId).toBe("conv-macos-ext");
+
+    proxy.dispose();
+    await mockExt.stop();
+  });
+
+  test("macOS turn with extension disconnected mid-conversation does not hang (proxy detects unavailability)", async () => {
+    // Arrange: connect a mock extension then forcibly disconnect it.
+    const guardianId = `test-guardian-macos-disco-${crypto.randomUUID()}`;
+    const token = mintActorToken(guardianId);
+
+    const { createMockChromeExtension } =
+      await import("./fixtures/mock-chrome-extension.js");
+    const mockExt = createMockChromeExtension({
+      runtimeBaseUrl,
+      token,
+    });
+    await mockExt.start();
+    await mockExt.waitForConnection();
+    await waitForRegistryEntry(guardianId);
+
+    // The proxy is bound while the extension is still connected.
+    const { proxy } = createBoundProxy(guardianId, "conv-macos-disco");
+
+    // Disconnect the extension before sending any commands.
+    mockExt.forceDisconnect();
+
+    // Wait for the registry to notice the close event.
+    await waitFor(
+      () => getChromeExtensionRegistry().get(guardianId) === undefined,
+    );
+
+    // Act: attempt a CDP command through the proxy. The registry send should
+    // fail because the connection is gone, and the proxy's sendToClient
+    // wrapper throws immediately.
+    try {
+      await proxy.request(
+        { cdpMethod: "Browser.getVersion", timeout_seconds: 0.5 },
+        "conv-macos-disco",
+      );
+      // If we reach here, the test should still verify the result indicates
+      // an error rather than a successful extension round-trip.
+      expect(true).toBe(false); // Should not reach here
+    } catch {
+      // Expected: the send failed because the extension is disconnected.
+      // This confirms the macOS path detects disconnection rather than
+      // silently routing to the wrong backend.
+    }
+
+    proxy.dispose();
+    await mockExt.stop();
+  });
+});
+
 // ── Local wait helpers ──────────────────────────────────────────────
 
 async function waitFor(

package/src/__tests__/host-browser-e2e-self-hosted.test.ts

@@ -321,7 +321,7 @@ describe("host-browser E2E — self-hosted native messaging path", () => {
   }
 
   // -------------------------------------------------------------------------
-  // Dev-only `~/.vellum/daemon-token` fallback
+  // Dev-only daemon-token fallback (per-instance protected dir)
   // -------------------------------------------------------------------------
 
   describe("dev daemon-token fallback path", () => {
@@ -338,9 +338,9 @@ describe("host-browser E2E — self-hosted native messaging path", () => {
     test("a token written to a local file round-trips through verifyHostBrowserCapability", () => {
       // Emulate the `writeDaemonTokenFallback` lifecycle: mint a fresh
       // capability token, persist it to a 0600 file (the production
-      // helper writes to `~/.vellum/daemon-token`, but we use a tempdir
-      // so the test doesn't clobber real dev state), then read it back
-      // and verify.
+      // helper writes to `<protectedDir>/daemon-token`, but we use a
+      // tempdir so the test doesn't clobber real dev state), then read
+      // it back and verify.
       //
       // This path is what the Mac app's manual "paste daemon token"
       // pairing UI ends up exercising — the file on disk is the only

package/src/__tests__/host-browser-ws-events-e2e.test.ts

@@ -284,6 +284,109 @@ describe("host_browser WS event + invalidation e2e", () => {
     await mockExt.stop();
   });
 
+  test("keepalive frames are accepted without closing the socket or producing warnings", async () => {
+    const guardianId = `guardian-${crypto.randomUUID()}`;
+    const { token } = mintHostBrowserCapability(guardianId);
+
+    const { createMockChromeExtension } =
+      await import("./fixtures/mock-chrome-extension.js");
+    const mockExt = createMockChromeExtension({
+      runtimeBaseUrl,
+      token,
+      resultTransport: "ws",
+    });
+    await mockExt.start();
+    await mockExt.waitForConnection();
+    await waitForRegistryEntry(guardianId);
+
+    // Grab the initial timestamps so we can verify that keepalive
+    // bumps lastKeepaliveAt but NOT lastActiveAt (routing field).
+    const connBefore = getChromeExtensionRegistry().get(guardianId)!;
+    const lastActiveBefore = connBefore.lastActiveAt;
+
+    // Small delay to ensure Date.now() advances at least 1ms.
+    await new Promise((r) => setTimeout(r, 15));
+
+    // Send a keepalive frame (the extension sends these periodically
+    // to prevent the runtime from considering the connection stale).
+    // The frame may contain extra keys (e.g. timestamp) that the
+    // runtime should silently ignore (lenient validation).
+    mockExt.sendRaw(JSON.stringify({ type: "keepalive", ts: Date.now() }));
+
+    // Wait for the touch to propagate — touch() updates
+    // lastKeepaliveAt (not lastActiveAt) to avoid routing interference.
+    await waitFor(() => {
+      const conn = getChromeExtensionRegistry().get(guardianId);
+      return conn !== undefined && (conn.lastKeepaliveAt ?? 0) > 0;
+    });
+
+    const connAfter = getChromeExtensionRegistry().get(guardianId)!;
+    expect(connAfter.lastKeepaliveAt).toBeGreaterThan(0);
+    // lastActiveAt must remain unchanged — keepalives must not affect routing.
+    expect(connAfter.lastActiveAt).toBe(lastActiveBefore);
+
+    // Verify the socket is still alive by sending a normal host_browser_event
+    // frame after the keepalive — if the socket had been torn down, this
+    // would never arrive.
+    const observed: ForwardedCdpEvent[] = [];
+    const unsubscribe = onCdpEvent((event) => observed.push(event));
+
+    mockExt.sendHostBrowserEvent({ method: "Page.loadEventFired" });
+    await waitFor(() => observed.length === 1);
+    expect(observed[0].method).toBe("Page.loadEventFired");
+
+    unsubscribe();
+    await mockExt.stop();
+  });
+
+  test("normal host_browser flows still pass after keepalive traffic", async () => {
+    const guardianId = `guardian-${crypto.randomUUID()}`;
+    const { token } = mintHostBrowserCapability(guardianId);
+
+    const { createMockChromeExtension } =
+      await import("./fixtures/mock-chrome-extension.js");
+    const mockExt = createMockChromeExtension({
+      runtimeBaseUrl,
+      token,
+      resultTransport: "ws",
+    });
+    await mockExt.start();
+    await mockExt.waitForConnection();
+    await waitForRegistryEntry(guardianId);
+
+    // Simulate a burst of keepalive frames (as would happen during an
+    // idle period with the extension's alarm-based keepalive ticker).
+    for (let i = 0; i < 5; i++) {
+      mockExt.sendRaw(JSON.stringify({ type: "keepalive" }));
+    }
+
+    // Small delay to let all keepalive frames process.
+    await new Promise((r) => setTimeout(r, 50));
+
+    // Now send a host_browser_event and verify it still fans out
+    // correctly — proving keepalive traffic does not interfere with
+    // normal message processing.
+    const observed: ForwardedCdpEvent[] = [];
+    const unsubscribe = onCdpEvent((event) => observed.push(event));
+
+    mockExt.sendHostBrowserEvent({
+      method: "Network.requestWillBeSent",
+      params: { requestId: "req-42", url: "https://example.com/api" },
+      cdpSessionId: "session-xyz",
+    });
+
+    await waitFor(() => observed.length === 1);
+    expect(observed[0].method).toBe("Network.requestWillBeSent");
+    expect(observed[0].params).toEqual({
+      requestId: "req-42",
+      url: "https://example.com/api",
+    });
+    expect(observed[0].cdpSessionId).toBe("session-xyz");
+
+    unsubscribe();
+    await mockExt.stop();
+  });
+
   test("malformed host_browser_event frames are dropped without tearing down the socket", async () => {
     const guardianId = `guardian-${crypto.randomUUID()}`;
     const { token } = mintHostBrowserCapability(guardianId);

package/src/__tests__/host-cu-proxy.test.ts

@@ -792,26 +792,21 @@ describe("HostCuProxy", () => {
     function spySignal(source: AbortSignal): Spied {
       const addCalls: string[] = [];
       const removeCalls: string[] = [];
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
       const s = source as any;
       const origAdd = source.addEventListener.bind(source);
       const origRemove = source.removeEventListener.bind(source);
       s.addEventListener = (
         type: string,
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         ...rest: any[]
       ) => {
         addCalls.push(type);
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         return (origAdd as any)(type, ...rest);
       };
       s.removeEventListener = (
         type: string,
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         ...rest: any[]
       ) => {
         removeCalls.push(type);
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         return (origRemove as any)(type, ...rest);
       };
       return { signal: source, addCalls, removeCalls };