@vellumai/assistant 0.8.3 → 0.8.4

package/src/__tests__/headless-browser-navigate.test.ts

@@ -27,6 +27,7 @@ let cdpSendHandler: (
   params?: Record<string, unknown>,
 ) => unknown = () => ({});
 let cdpDisposed = false;
+let cdpSetSessionIdCalls: Array<string | undefined> = [];
 
 function makeFakeCdp(kind: "local" | "extension", conversationId: string) {
   return {
@@ -43,6 +44,12 @@ function makeFakeCdp(kind: "local" | "extension", conversationId: string) {
     dispose() {
       cdpDisposed = true;
     },
+    // Mirrors the optional method on the real CdpClient interface so
+    // the --new-tab path can be exercised end-to-end. Recorded for
+    // per-test assertions.
+    setCdpSessionId(cdpSessionId: string | undefined) {
+      cdpSetSessionIdCalls.push(cdpSessionId);
+    },
   };
 }
 
@@ -135,6 +142,7 @@ mock.module("../tools/network/url-safety.js", () => ({
 }));
 
 import { executeBrowserNavigate } from "../tools/browser/browser-execution.js";
+import { __resetPinnedTabsForTests } from "../tools/browser/pinned-tabs.js";
 import type { ToolContext } from "../tools/types.js";
 
 const ctx: ToolContext = {
@@ -212,6 +220,7 @@ function resetCdp() {
   cdpSendCalls = [];
   cdpDisposed = false;
   cdpSendHandler = defaultCdpHandler;
+  cdpSetSessionIdCalls = [];
 }
 
 describe("executeBrowserNavigate", () => {
@@ -223,6 +232,7 @@ describe("executeBrowserNavigate", () => {
     resolveResult = {};
     resetMockPage();
     resetCdp();
+    __resetPinnedTabsForTests();
   });
 
   // ── Input validation ───────────────────────────────────────────
@@ -664,6 +674,168 @@ describe("executeBrowserNavigate", () => {
     expect(cdpDisposed).toBe(true);
   });
 
+  // ── --new-tab flag (extension path only) ──────────────────────
+
+  test("extension path with new_tab: true opens a fresh tab and pins it before Page.navigate", async () => {
+    parseUrlResult = new URL("https://example.com/page");
+    mockExtensionAvailable = true;
+
+    cdpSendHandler = (method, params) => {
+      if (method === "Vellum.createTab") return { tabId: "999" };
+      return defaultCdpHandler(method, params);
+    };
+
+    const result = await executeBrowserNavigate(
+      { url: "https://example.com/page", new_tab: true },
+      { ...ctx },
+    );
+
+    expect(result.isError).toBe(false);
+
+    // Vellum.createTab fired and fired BEFORE Page.navigate.
+    const createIdx = cdpSendCalls.findIndex(
+      (c) => c.method === "Vellum.createTab",
+    );
+    const navIdx = cdpSendCalls.findIndex((c) => c.method === "Page.navigate");
+    expect(createIdx).toBeGreaterThanOrEqual(0);
+    expect(navIdx).toBeGreaterThanOrEqual(0);
+    expect(createIdx).toBeLessThan(navIdx);
+
+    // setCdpSessionId was invoked with the returned tabId so the
+    // follow-on commands on this client route to the new tab.
+    expect(cdpSetSessionIdCalls).toContain("999");
+  });
+
+  test("new_tab: true on extension path with createTab failure aborts with a clear error", async () => {
+    parseUrlResult = new URL("https://example.com/page");
+    mockExtensionAvailable = true;
+
+    cdpSendHandler = (method, params) => {
+      if (method === "Vellum.createTab") {
+        throw new Error("createTab returned no tabId");
+      }
+      return defaultCdpHandler(method, params);
+    };
+
+    const result = await executeBrowserNavigate(
+      { url: "https://example.com/page", new_tab: true },
+      { ...ctx },
+    );
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain("Failed to open a new tab");
+    // Page.navigate must NOT fire — that's exactly what --new-tab is
+    // supposed to prevent in the failure case (silent fallback to
+    // active-tab clobbering would defeat the purpose of the flag).
+    expect(cdpSendCalls.some((c) => c.method === "Page.navigate")).toBe(false);
+    // The createTab-failure path early-returns BEFORE the main
+    // try/finally that wraps the navigate flow, so the executor has to
+    // dispose the CDP client manually. Verifying here so future edits
+    // to that early-return don't silently regress the cleanup.
+    expect(cdpDisposed).toBe(true);
+  });
+
+  test("new_tab: true on extension path with no tabId in response clears live session and still continues", async () => {
+    // Defensive: dispatcher returns success but no tabId. The
+    // executor logs a warn, resets the live cdp session to undefined
+    // (so the follow-on Page.navigate routes to the active tab
+    // instead of any stale pin the cdp instance was constructed
+    // with), and proceeds. The navigate still runs (degraded
+    // behaviour but not a hard failure).
+    parseUrlResult = new URL("https://example.com/page");
+    mockExtensionAvailable = true;
+
+    cdpSendHandler = (method, params) => {
+      if (method === "Vellum.createTab") return {}; // no tabId
+      return defaultCdpHandler(method, params);
+    };
+
+    const result = await executeBrowserNavigate(
+      { url: "https://example.com/page", new_tab: true },
+      { ...ctx },
+    );
+
+    expect(result.isError).toBe(false);
+    // No new pin was set, BUT the live session was reset to undefined
+    // so the follow-on Page.navigate falls back to active-tab routing
+    // instead of any stale pin the cdp instance held at construction.
+    expect(cdpSetSessionIdCalls).toEqual([undefined]);
+    // Page.navigate still ran.
+    expect(cdpSendCalls.some((c) => c.method === "Page.navigate")).toBe(true);
+  });
+
+  test("new_tab: true with no tabId in response clears a pre-existing stale pin AND live session (regression)", async () => {
+    // Regression for the Codex round-2 findings (P2 + round-3 P1):
+    // when Vellum.createTab returns a malformed response with no
+    // tabId, the executor falls back to active-tab routing — but
+    // (a) the pin store still held the stale pin (round-2 P2 fix
+    // added clearPinnedTab), and (b) the LIVE cdp instance was
+    // already constructed with that stale cdpSessionId, so the
+    // follow-on Page.navigate would still route to the dead tab
+    // unless we reset the session on the cdp instance too (round-3
+    // P1 fix added cdp.setCdpSessionId(undefined)).
+    const { setPinnedTab, getPinnedTab } = await import(
+      "../tools/browser/pinned-tabs.js"
+    );
+    setPinnedTab(ctx.conversationId, "stale-pinned-tab-id");
+    expect(getPinnedTab(ctx.conversationId)).toBe("stale-pinned-tab-id");
+
+    parseUrlResult = new URL("https://example.com/page");
+    mockExtensionAvailable = true;
+
+    cdpSendHandler = (method, params) => {
+      if (method === "Vellum.createTab") return {}; // no tabId
+      return defaultCdpHandler(method, params);
+    };
+
+    const result = await executeBrowserNavigate(
+      { url: "https://example.com/page", new_tab: true },
+      { ...ctx },
+    );
+
+    expect(result.isError).toBe(false);
+    // (a) Pin store cleared.
+    expect(getPinnedTab(ctx.conversationId)).toBeUndefined();
+    // (b) Live cdp session reset (the fake records every
+    // setCdpSessionId arg; expect exactly one call with undefined).
+    expect(cdpSetSessionIdCalls).toEqual([undefined]);
+  });
+
+  test("new_tab: true on LOCAL path is a no-op (Playwright manages its own isolated browser)", async () => {
+    parseUrlResult = new URL("https://example.com/page");
+    mockExtensionAvailable = false; // local path
+
+    const result = await executeBrowserNavigate(
+      { url: "https://example.com/page", new_tab: true },
+      { ...ctx },
+    );
+
+    expect(result.isError).toBe(false);
+    // No Vellum.createTab was issued on the local path — the flag is
+    // silently ignored because Playwright opens its own browser and
+    // there's no user-tab to disturb.
+    expect(cdpSendCalls.some((c) => c.method === "Vellum.createTab")).toBe(
+      false,
+    );
+    expect(cdpSetSessionIdCalls).toEqual([]);
+  });
+
+  test("absence of new_tab leaves extension path untouched (no Vellum.createTab)", async () => {
+    parseUrlResult = new URL("https://example.com/page");
+    mockExtensionAvailable = true;
+
+    const result = await executeBrowserNavigate(
+      { url: "https://example.com/page" }, // no new_tab key at all
+      { ...ctx },
+    );
+
+    expect(result.isError).toBe(false);
+    expect(cdpSendCalls.some((c) => c.method === "Vellum.createTab")).toBe(
+      false,
+    );
+    expect(cdpSetSessionIdCalls).toEqual([]);
+  });
+
   // ── Defense-in-depth: post-navigation final URL check ─────────
 
   test("post-nav check blocks when final URL resolves to private target", async () => {

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

@@ -31,6 +31,12 @@ mock.module("../runtime/assistant-event-hub.js", () => ({
     _conversationId?: string,
     options?: unknown,
   ) => {
+    // `interaction_resolved` envelopes are emitted by the pending-interactions
+    // tracker for every resolution. They are orthogonal to the host-proxy
+    // wire messages these tests assert on, so swallow them here.
+    if ((msg as { type?: string } | null)?.type === "interaction_resolved") {
+      return;
+    }
     sentMessages.push(msg);
     sentMessageOptions.push(options);
   },

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

@@ -31,6 +31,13 @@ let mockClients: MockClient[] = [];
 mock.module("../runtime/assistant-event-hub.js", () => ({
   assistantEventHub: {
     publish: async (event: unknown, _options?: unknown) => {
+      // `interaction_resolved` envelopes are emitted by the
+      // pending-interactions tracker for every resolution. They are
+      // orthogonal to the host-browser wire messages these tests assert
+      // on, so swallow them here.
+      if ((event as { type?: string } | null)?.type === "interaction_resolved") {
+        return;
+      }
       publishedEvents.push(event);
     },
     getMostRecentClientByCapability: (cap: string) =>
@@ -41,6 +48,9 @@ mock.module("../runtime/assistant-event-hub.js", () => ({
       mockClients.find((c) => c.clientId === clientId)?.actorPrincipalId,
   },
   broadcastMessage: (msg: unknown) => {
+    if ((msg as { type?: string } | null)?.type === "interaction_resolved") {
+      return;
+    }
     publishedEvents.push(msg);
   },
 }));

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

@@ -10,7 +10,14 @@ type MockClient = {
 let mockClients: MockClient[] = [];
 
 mock.module("../runtime/assistant-event-hub.js", () => ({
-  broadcastMessage: (msg: unknown) => sentMessages.push(msg),
+  broadcastMessage: (msg: unknown) => {
+    // Skip `interaction_resolved` envelopes — pending-interactions emits one
+    // on every resolve and these tests assert on host-proxy wire messages.
+    if ((msg as { type?: string } | null)?.type === "interaction_resolved") {
+      return;
+    }
+    sentMessages.push(msg);
+  },
   assistantEventHub: {
     getMostRecentClientByCapability: (cap: string) =>
       cap === "host_cu" && mockHasClient ? { id: "mock-client" } : null,

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

@@ -12,7 +12,14 @@ interface MockClient {
 let mockClients: MockClient[] = [];
 
 mock.module("../runtime/assistant-event-hub.js", () => ({
-  broadcastMessage: (msg: unknown) => sentMessages.push(msg),
+  broadcastMessage: (msg: unknown) => {
+    // Skip `interaction_resolved` envelopes — pending-interactions emits one
+    // on every resolve and these tests assert on host-proxy wire messages.
+    if ((msg as { type?: string } | null)?.type === "interaction_resolved") {
+      return;
+    }
+    sentMessages.push(msg);
+  },
   assistantEventHub: {
     getMostRecentClientByCapability: (cap: string) => {
       if (mockClients.length > 0) {

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

@@ -8,7 +8,14 @@ const sentMessages: unknown[] = [];
 let mockHasClient = false;
 
 mock.module("../runtime/assistant-event-hub.js", () => ({
-  broadcastMessage: (msg: unknown) => sentMessages.push(msg),
+  broadcastMessage: (msg: unknown) => {
+    // Skip `interaction_resolved` envelopes — pending-interactions emits one
+    // on every resolve and these tests assert on host-proxy wire messages.
+    if ((msg as { type?: string } | null)?.type === "interaction_resolved") {
+      return;
+    }
+    sentMessages.push(msg);
+  },
   assistantEventHub: {
     getMostRecentClientByCapability: (cap: string) =>
       cap === "host_file" && mockHasClient ? { id: "mock-client" } : null,

package/src/__tests__/identity-routes.test.ts

@@ -24,8 +24,12 @@ mock.module("../util/logger.js", () => ({
 
 import {
   handleDetailedHealth,
+  handleReadyz,
   ROUTES,
 } from "../runtime/routes/identity-routes.js";
+import {
+  setCesClient,
+} from "../security/secure-keys.js";
 import { getWorkspaceDir } from "../util/platform.js";
 import {
   getHatchedSidecarPath,
@@ -177,6 +181,59 @@ describe("identity routes — health endpoint", () => {
       expect(body.timestamp).toBeDefined();
       expect(body.migrations).toBeDefined();
     });
+
+    test("includes ces.connected=false when no CES client is registered", async () => {
+      const res = handleDetailedHealth();
+      const body = (await res.json()) as Record<string, unknown>;
+
+      expect(body.ces).toBeDefined();
+      expect((body.ces as Record<string, unknown>).connected).toBe(false);
+    });
+  });
+
+  describe("CES readiness", () => {
+    beforeEach(() => {
+      setCesClient(undefined);
+    });
+
+    test("readyz returns 200 and logs warning when CES is unavailable", () => {
+      const res = handleReadyz();
+      expect(res.status).toBe(200);
+    });
+
+    test("readyz returns 200 when CES is connected and ready", () => {
+      const mockClient = { isReady: () => true, close: () => {} } as unknown as import("../credential-execution/client.js").CesClient;
+      setCesClient(mockClient);
+      const res = handleReadyz();
+      expect(res.status).toBe(200);
+    });
+
+    test("readyz returns 200 when CES client exists but is not ready", () => {
+      const mockClient = { isReady: () => false, close: () => {} } as unknown as import("../credential-execution/client.js").CesClient;
+      setCesClient(mockClient);
+      const res = handleReadyz();
+      expect(res.status).toBe(200);
+    });
+
+    test("/v1/health reports ces.connected=true when CES is ready", async () => {
+      const mockClient = { isReady: () => true, close: () => {} } as unknown as import("../credential-execution/client.js").CesClient;
+      setCesClient(mockClient);
+      const res = handleDetailedHealth();
+      const body = (await res.json()) as Record<string, unknown>;
+
+      expect(body.ces).toBeDefined();
+      expect((body.ces as Record<string, unknown>).connected).toBe(true);
+    });
+
+    test("/v1/health reports ces.connected=false when CES is not ready", async () => {
+      const mockClient = { isReady: () => false, close: () => {} } as unknown as import("../credential-execution/client.js").CesClient;
+      setCesClient(mockClient);
+      const res = handleDetailedHealth();
+      const body = (await res.json()) as Record<string, unknown>;
+
+      expect(body.ces).toBeDefined();
+      expect((body.ces as Record<string, unknown>).connected).toBe(false);
+    });
   });
 
   describe("profiler payload (profiler enabled)", () => {

package/src/__tests__/inbound-slack-persistence.test.ts

@@ -148,6 +148,7 @@ describe("PR 11 — inbound Slack message metadata persistence", () => {
       {
         slackInbound: {
           channelId: "C0123CHANNEL",
+          channelName: "engineering",
           channelTs: "1700000001.111111",
           threadTs: "1700000000.000001",
           displayName: "Alice",
@@ -162,6 +163,7 @@ describe("PR 11 — inbound Slack message metadata persistence", () => {
     expect(slackMeta!.source).toBe("slack");
     expect(slackMeta!.eventKind).toBe("message");
     expect(slackMeta!.channelId).toBe("C0123CHANNEL");
+    expect(slackMeta!.channelName).toBe("engineering");
     expect(slackMeta!.channelTs).toBe("1700000001.111111");
     expect(slackMeta!.threadTs).toBe("1700000000.000001");
     expect(slackMeta!.displayName).toBe("Alice");
@@ -194,6 +196,7 @@ describe("PR 11 — inbound Slack message metadata persistence", () => {
     expect(slackMeta!.channelTs).toBe("1700000010.222222");
     expect(slackMeta!.threadTs).toBeUndefined();
     expect(slackMeta!.displayName).toBe("Bob");
+    expect(slackMeta!.channelName).toBeUndefined();
   });
 
   test("Slack normalized content is persisted with raw channelTs in slackMeta", async () => {

package/src/__tests__/injector-chain.test.ts

@@ -102,6 +102,7 @@ describe("injector chain", () => {
       "memory-v2-static",
       "now-md",
       "active-documents",
+      "document-comments",
       "subagent-status",
       "slack-messages",
       "thread-focus",
@@ -166,6 +167,7 @@ describe("injector chain", () => {
       "memory-v2-static", // 38
       "now-md", // 40
       "active-documents", // 45
+      "document-comments", // 46
       "subagent-status", // 50
       "slack-messages", // 60
       "thread-focus", // 70