@vellumai/assistant 0.6.6 → 0.7.1

package/src/tools/browser/__tests__/browser-status.test.ts

@@ -82,6 +82,25 @@ mock.module("../browser-manager.js", () => ({
   },
 }));
 
+/** Mutable proxy returned by HostBrowserProxy.instance. */
+let mockSingletonProxy: {
+  isAvailable: () => boolean;
+  request: unknown;
+} | null = null;
+
+const unavailableFallback = {
+  isAvailable: () => false,
+  request: () => Promise.reject(new Error("no extension")),
+};
+
+mock.module("../../../daemon/host-browser-proxy.js", () => ({
+  HostBrowserProxy: {
+    get instance() {
+      return mockSingletonProxy ?? unavailableFallback;
+    },
+  },
+}));
+
 const { executeBrowserStatus } = await import("../browser-execution.js");
 
 function makeContext(overrides: Partial<ToolContext> = {}): ToolContext {
@@ -101,6 +120,7 @@ describe("executeBrowserStatus", () => {
     probeErrors[BROWSER_STATUS_MODE.EXTENSION] = null;
     probeErrors[BROWSER_STATUS_MODE.CDP_INSPECT] = null;
     probeErrors[BROWSER_STATUS_MODE.LOCAL] = null;
+    mockSingletonProxy = null;
   });
 
   test("reports extension preflight-unavailable when no host browser proxy is bound", async () => {
@@ -139,20 +159,14 @@ describe("executeBrowserStatus", () => {
   });
 
   test("reports extension as connected when probe fails on restricted chrome:// page", async () => {
+    mockSingletonProxy = { isAvailable: () => true, request: () => {} };
     probeOutcomes[BROWSER_STATUS_MODE.EXTENSION] = "fail";
     probeErrors[BROWSER_STATUS_MODE.EXTENSION] = new CdpError(
       "cdp_error",
       "Cannot access a chrome:// URL",
     );
 
-    const result = await executeBrowserStatus(
-      {},
-      makeContext({
-        hostBrowserProxy: {
-          isAvailable: () => true,
-        } as ToolContext["hostBrowserProxy"],
-      }),
-    );
+    const result = await executeBrowserStatus({}, makeContext());
     expect(result.isError).toBe(false);
     const payload = JSON.parse(result.content);
     const extension = payload.modes.find(
@@ -166,14 +180,12 @@ describe("executeBrowserStatus", () => {
 
   // ── macOS host-browser proxy mode tests ─────────────────────────────
 
-  test("macOS: reports host browser proxy as available when proxy is bound and connected", async () => {
+  test("reports extension as available when singleton proxy is connected", async () => {
+    mockSingletonProxy = { isAvailable: () => true, request: () => {} };
     const result = await executeBrowserStatus(
       {},
       makeContext({
         transportInterface: "macos",
-        hostBrowserProxy: {
-          isAvailable: () => true,
-        } as ToolContext["hostBrowserProxy"],
       }),
     );
     expect(result.isError).toBe(false);
@@ -184,64 +196,12 @@ describe("executeBrowserStatus", () => {
     expect(extension).toBeDefined();
     expect(extension.available).toBe(true);
     expect(extension.verified).toBe("active_probe");
-    expect(extension.summary).toContain("macOS host browser proxy");
-    expect(extension.details.transport).toBe("macos-sse");
-  });
-
-  test("macOS: reports transport as extension-ws when hostBrowserRegistryRouted is true", async () => {
-    const result = await executeBrowserStatus(
-      {},
-      makeContext({
-        transportInterface: "macos",
-        hostBrowserRegistryRouted: true,
-        hostBrowserProxy: {
-          isAvailable: () => true,
-        } as ToolContext["hostBrowserProxy"],
-      }),
-    );
-    expect(result.isError).toBe(false);
-    const payload = JSON.parse(result.content);
-    const extension = payload.modes.find(
-      (m: { mode: string }) => m.mode === BROWSER_STATUS_MODE.EXTENSION,
-    );
-    expect(extension).toBeDefined();
-    expect(extension.available).toBe(true);
     expect(extension.details.transport).toBe("extension-ws");
   });
 
-  test("macOS: reports proxy unbound with macOS-specific actions when no proxy is present", async () => {
-    const result = await executeBrowserStatus(
-      {},
-      makeContext({
-        transportInterface: "macos",
-      }),
-    );
-    expect(result.isError).toBe(false);
-    const payload = JSON.parse(result.content);
-    const extension = payload.modes.find(
-      (m: { mode: string }) => m.mode === BROWSER_STATUS_MODE.EXTENSION,
-    );
-    expect(extension).toBeDefined();
-    expect(extension.available).toBe(false);
-    expect(extension.summary).toContain("macOS host browser proxy");
-    expect(extension.summary).toContain("desktop client");
-    expect(extension.details.transport).toBe("macos-sse");
-    // macOS-specific user actions should mention the desktop app, not the extension
-    expect(
-      extension.userActions.some((a: string) => a.includes("desktop app")),
-    ).toBe(true);
-  });
-
-  test("macOS: reports proxy disconnected with reconnect actions when proxy is bound but not available", async () => {
-    const result = await executeBrowserStatus(
-      {},
-      makeContext({
-        transportInterface: "macos",
-        hostBrowserProxy: {
-          isAvailable: () => false,
-        } as ToolContext["hostBrowserProxy"],
-      }),
-    );
+  test("reports extension disconnected when singleton proxy is not available", async () => {
+    // mockSingletonProxy = null → falls back to unavailableFallback
+    const result = await executeBrowserStatus({}, makeContext());
     expect(result.isError).toBe(false);
     const payload = JSON.parse(result.content);
     const extension = payload.modes.find(
@@ -249,31 +209,19 @@ describe("executeBrowserStatus", () => {
     );
     expect(extension).toBeDefined();
     expect(extension.available).toBe(false);
-    expect(extension.summary).toContain("macOS host browser proxy");
-    expect(extension.summary).toContain("SSE transport");
-    expect(extension.details.transport).toBe("macos-sse");
-    // Should suggest reconnection, not extension install
-    expect(
-      extension.userActions.some((a: string) => a.includes("desktop app")),
-    ).toBe(true);
+    expect(extension.summary).toContain("disconnected");
+    expect(extension.details.transport).toBe("extension-ws");
   });
 
-  test("macOS: probe failure diagnostics include transport-specific remediation", async () => {
+  test("probe failure diagnostics include remediation actions", async () => {
+    mockSingletonProxy = { isAvailable: () => true, request: () => {} };
     probeOutcomes[BROWSER_STATUS_MODE.EXTENSION] = "fail";
     probeErrors[BROWSER_STATUS_MODE.EXTENSION] = new CdpError(
       "transport_error",
       "transport disconnected before response",
     );
 
-    const result = await executeBrowserStatus(
-      {},
-      makeContext({
-        transportInterface: "macos",
-        hostBrowserProxy: {
-          isAvailable: () => true,
-        } as ToolContext["hostBrowserProxy"],
-      }),
-    );
+    const result = await executeBrowserStatus({}, makeContext());
     expect(result.isError).toBe(false);
     const payload = JSON.parse(result.content);
     const extension = payload.modes.find(
@@ -281,23 +229,12 @@ describe("executeBrowserStatus", () => {
     );
     expect(extension).toBeDefined();
     expect(extension.available).toBe(false);
-    expect(extension.summary).toContain("macOS host browser proxy");
-    // Should have remediation actions mentioning SSE bridge
-    expect(
-      extension.userActions.some((a: string) => a.includes("SSE bridge")),
-    ).toBe(true);
+    expect(extension.summary).toContain("probe failed");
   });
 
-  test("recommendation order follows auto candidate precedence for macOS with available extension proxy", async () => {
-    const result = await executeBrowserStatus(
-      {},
-      makeContext({
-        transportInterface: "macos",
-        hostBrowserProxy: {
-          isAvailable: () => true,
-        } as ToolContext["hostBrowserProxy"],
-      }),
-    );
+  test("recommendation order follows auto candidate precedence with available extension", async () => {
+    mockSingletonProxy = { isAvailable: () => true, request: () => {} };
+    const result = await executeBrowserStatus({}, makeContext());
     expect(result.isError).toBe(false);
     const payload = JSON.parse(result.content);
     // Extension is the top auto candidate and is available, so it should be recommended
@@ -305,43 +242,24 @@ describe("executeBrowserStatus", () => {
     expect(payload.autoCandidateOrder[0]).toBe(BROWSER_STATUS_MODE.EXTENSION);
   });
 
-  test("recommendation falls to cdp-inspect when macOS proxy is unavailable", async () => {
-    // Extension probe fails
-    probeOutcomes[BROWSER_STATUS_MODE.EXTENSION] = "fail";
-    probeErrors[BROWSER_STATUS_MODE.EXTENSION] = new CdpError(
-      "transport_error",
-      "proxy not connected",
-    );
-
-    const result = await executeBrowserStatus(
-      {},
-      makeContext({
-        transportInterface: "macos",
-        // No proxy bound, so extension unavailable
-      }),
-    );
+  test("recommendation falls to cdp-inspect when extension is unavailable", async () => {
+    // No singleton proxy → extension unavailable
+    const result = await executeBrowserStatus({}, makeContext());
     expect(result.isError).toBe(false);
     const payload = JSON.parse(result.content);
-    // Extension is unavailable (no proxy), so recommendation should fall to next available
+    // Extension is unavailable, so recommendation should fall to next available
     expect(payload.recommendedMode).toBe(BROWSER_STATUS_MODE.CDP_INSPECT);
   });
 
-  test("macOS: restricted chrome:// page probe includes macOS transport details", async () => {
+  test("restricted chrome:// page probe includes transport details", async () => {
+    mockSingletonProxy = { isAvailable: () => true, request: () => {} };
     probeOutcomes[BROWSER_STATUS_MODE.EXTENSION] = "fail";
     probeErrors[BROWSER_STATUS_MODE.EXTENSION] = new CdpError(
       "cdp_error",
       "Cannot access a chrome:// URL",
     );
 
-    const result = await executeBrowserStatus(
-      {},
-      makeContext({
-        transportInterface: "macos",
-        hostBrowserProxy: {
-          isAvailable: () => true,
-        } as ToolContext["hostBrowserProxy"],
-      }),
-    );
+    const result = await executeBrowserStatus({}, makeContext());
     expect(result.isError).toBe(false);
     const payload = JSON.parse(result.content);
     const extension = payload.modes.find(
@@ -349,7 +267,6 @@ describe("executeBrowserStatus", () => {
     );
     expect(extension).toBeDefined();
     expect(extension.available).toBe(true);
-    expect(extension.summary).toContain("macOS host browser proxy");
-    expect(extension.details.transport).toBe("macos-sse");
+    expect(extension.details.transport).toBe("extension-ws");
   });
 });

package/src/tools/browser/browser-execution.ts

@@ -1,4 +1,5 @@
 import { getConfig } from "../../config/loader.js";
+import { HostBrowserProxy } from "../../daemon/host-browser-proxy.js";
 import type { ImageContent } from "../../providers/types.js";
 import { getLogger } from "../../util/logger.js";
 import { truncate } from "../../util/truncate.js";
@@ -75,13 +76,13 @@ const log = getLogger("headless-browser");
 
 // ── Constants ────────────────────────────────────────────────────────
 
-export const NAVIGATE_TIMEOUT_MS = 15_000;
+const NAVIGATE_TIMEOUT_MS = 15_000;
 
-export const ACTION_TIMEOUT_MS = 10_000;
+const ACTION_TIMEOUT_MS = 10_000;
 
-export const MAX_WAIT_MS = 30_000;
+const MAX_WAIT_MS = 30_000;
 
-export const MAX_EXTRACT_LENGTH = 50_000;
+const MAX_EXTRACT_LENGTH = 50_000;
 
 type StatusCheckMode = BrowserStatusMode;
 
@@ -359,7 +360,7 @@ function isRestrictedChromePageProbeError(error: CdpError): boolean {
  * The returned client is wrapped so its first successful `send()`
  * writes the resolved kind back to the conversation memo.
  */
-export function acquireCdpClientWithMode(
+function acquireCdpClientWithMode(
   input: Record<string, unknown>,
   context: ToolContext,
 ):
@@ -514,7 +515,7 @@ export type ResolvedElement =
  * or when an `element_id` is provided but the snapshot map is
  * empty/stale.
  */
-export function resolveElement(
+function resolveElement(
   conversationId: string,
   input: Record<string, unknown>,
 ): { resolved: ResolvedElement | null; error: string | null } {
@@ -721,8 +722,19 @@ export async function executeBrowserNavigate(
     }
 
     // Read the current URL BEFORE calling navigateAndWait so we can
-    // detect the "page never moved" case on timeout.
-    const urlBeforeNav = await getCurrentUrl(cdp, context.signal);
+    // detect the "page never moved" case on timeout. This may fail if
+    // the active tab is on a chrome:// or other privileged URL where
+    // Runtime.evaluate is blocked — in that case we proceed without the
+    // baseline and skip the "page never moved" timeout heuristic.
+    let urlBeforeNav = "";
+    try {
+      urlBeforeNav = await getCurrentUrl(cdp, context.signal);
+    } catch {
+      log.debug(
+        { conversationId: context.conversationId },
+        "Could not read current URL before navigation (tab may be on a privileged page)",
+      );
+    }
 
     // Navigate via CDP Page.navigate + document.readyState polling.
     // navigateAndWait returns { finalUrl, timedOut }; HTTP status is
@@ -843,18 +855,9 @@ export async function executeBrowserNavigate(
 
     const safeFinalUrl = sanitizeUrlForOutput(new URL(finalUrl));
     const title = await getPageTitle(cdp, context.signal);
-    // HTTP status is not available on the CDP path: `Page.navigate`
-    // resolves the frame id and (on failure) an error text, but does
-    // not carry the response status code. Both the local and extension
-    // paths therefore print "unknown" here. A future phase may subscribe
-    // to `Network.responseReceived` events during the navigation window
-    // if the status is needed again.
-    const status: number | null = null;
-
     const lines: string[] = [
       `Requested URL: ${safeRequestedUrl}`,
       `Final URL: ${safeFinalUrl}`,
-      `Status: ${status ?? "unknown"}`,
       `Title: ${title || "(none)"}`,
     ];
 
@@ -2099,43 +2102,6 @@ function extensionSetupActions(): string[] {
   ];
 }
 
-function macOSHostBrowserSetupActions(): string[] {
-  return [
-    "Ensure the Vellum desktop app is running and connected to the assistant.",
-    "Open Google Chrome on the desktop machine so the host browser proxy can attach.",
-    "If the desktop client is not running, launch it and wait for the SSE connection to establish.",
-  ];
-}
-
-function macOSHostBrowserReconnectActions(): string[] {
-  return [
-    "Verify the Vellum desktop app is still running and has an active network connection.",
-    "If the desktop client was recently restarted, send a new message to re-establish the SSE bridge.",
-    "Ensure Chrome is open on the desktop machine for the host browser proxy to target.",
-  ];
-}
-
-function macOSHostBrowserProbeFailureActions(error: CdpError): string[] {
-  const actions: string[] = [
-    "Ensure Google Chrome is running on the desktop machine.",
-  ];
-  const message = error.message.toLowerCase();
-  if (message.includes("timeout") || message.includes("timed out")) {
-    actions.push(
-      "The desktop client may be unresponsive — try restarting the Vellum desktop app.",
-    );
-  }
-  if (message.includes("transport") || message.includes("disconnected")) {
-    actions.push(
-      "The SSE bridge between the assistant and the desktop client appears broken. Send a new message to re-establish the connection.",
-    );
-  }
-  actions.push(
-    "Switch Chrome to a regular http(s) tab (not chrome://...) and retry.",
-  );
-  return dedupeStrings(actions);
-}
-
 function cdpInspectSetupActions(): string[] {
   return [
     "Update Chrome to the latest version by going to chrome://settings/help",
@@ -2179,7 +2145,7 @@ function probeFailureActions(mode: StatusCheckMode, error: CdpError): string[] {
       )
     ) {
       actions.push(
-        "Ensure this extension ID is present in meta/browser-extension/chrome-extension-allowlist.json and restart the assistant.",
+        "Ensure this extension ID is present in chrome-extension-allowlist.local.json in $GATEWAY_SECURITY_DIR and restart the assistant.",
       );
     }
     if (
@@ -2283,55 +2249,19 @@ async function checkExtensionModeStatus(
   context: ToolContext,
   autoCandidate: boolean,
 ): Promise<BrowserStatusModeResult> {
-  const proxyBound = Boolean(context.hostBrowserProxy);
-  const proxyConnected = context.hostBrowserProxy?.isAvailable() ?? false;
-  const isMacOS = context.transportInterface === "macos";
+  const proxy = HostBrowserProxy.instance;
 
-  if (!proxyBound) {
+  if (!proxy.isAvailable()) {
     return {
       mode: BROWSER_STATUS_MODE.EXTENSION,
       available: false,
       verified: "preflight",
       autoCandidate,
-      summary: isMacOS
-        ? "Extension mode is unavailable: the macOS host browser proxy is not bound to this conversation. Ensure the desktop client is connected."
-        : "Extension mode is unavailable: no host browser proxy is bound to this conversation.",
-      userActions: isMacOS
-        ? macOSHostBrowserSetupActions()
-        : extensionSetupActions(),
-      tradeoffs: modeTradeoffs(BROWSER_STATUS_MODE.EXTENSION),
-      details: {
-        proxyBound,
-        proxyConnected,
-        transport:
-          isMacOS && !context.hostBrowserRegistryRouted
-            ? "macos-sse"
-            : "extension-ws",
-      },
-    };
-  }
-
-  if (!proxyConnected) {
-    return {
-      mode: BROWSER_STATUS_MODE.EXTENSION,
-      available: false,
-      verified: "preflight",
-      autoCandidate,
-      summary: isMacOS
-        ? "Extension mode is unavailable: the macOS host browser proxy is bound but the SSE transport is currently disconnected. Verify the desktop client is running and connected."
-        : "Extension mode is unavailable: the extension transport is currently disconnected.",
-      userActions: isMacOS
-        ? macOSHostBrowserReconnectActions()
-        : extensionSetupActions(),
+      summary:
+        "Extension mode is unavailable: the extension transport is currently disconnected.",
+      userActions: extensionSetupActions(),
       tradeoffs: modeTradeoffs(BROWSER_STATUS_MODE.EXTENSION),
-      details: {
-        proxyBound,
-        proxyConnected,
-        transport:
-          isMacOS && !context.hostBrowserRegistryRouted
-            ? "macos-sse"
-            : "extension-ws",
-      },
+      details: { transport: "extension-ws" },
     };
   }
 
@@ -2345,19 +2275,12 @@ async function checkExtensionModeStatus(
       available: true,
       verified: "active_probe",
       autoCandidate,
-      summary: isMacOS
-        ? "Extension mode is ready via macOS host browser proxy and responded to an active CDP probe."
-        : "Extension mode is ready and responded to an active CDP probe.",
+      summary: "Extension mode is ready and responded to an active CDP probe.",
       userActions: [],
       tradeoffs: modeTradeoffs(BROWSER_STATUS_MODE.EXTENSION),
       details: {
-        proxyBound,
-        proxyConnected,
         backendKind: probe.backendKind,
-        transport:
-          isMacOS && !context.hostBrowserRegistryRouted
-            ? "macos-sse"
-            : "extension-ws",
+        transport: "extension-ws",
       },
     };
   }
@@ -2368,24 +2291,18 @@ async function checkExtensionModeStatus(
       available: true,
       verified: "active_probe",
       autoCandidate,
-      summary: isMacOS
-        ? "Extension mode transport is connected via macOS host browser proxy, but the active Chrome tab is a restricted chrome:// page. Switch to a regular website tab if browser actions fail."
-        : "Extension mode transport is connected, but the active Chrome tab is a restricted chrome:// page. Switch to a regular website tab if browser actions fail.",
+      summary:
+        "Extension mode transport is connected, but the active Chrome tab is a restricted chrome:// page. Switch to a regular website tab if browser actions fail.",
       userActions: [
         "Switch Chrome to a regular http(s) tab (not chrome://...) and retry.",
       ],
       tradeoffs: modeTradeoffs(BROWSER_STATUS_MODE.EXTENSION),
       details: {
-        proxyBound,
-        proxyConnected,
         restrictedActiveTab: true,
         errorCode: probe.error.code,
         diagnostic: probe.diagnostic,
         attemptDiagnostics: probe.error.attemptDiagnostics ?? [],
-        transport:
-          isMacOS && !context.hostBrowserRegistryRouted
-            ? "macos-sse"
-            : "extension-ws",
+        transport: "extension-ws",
       },
     };
   }
@@ -2395,23 +2312,17 @@ async function checkExtensionModeStatus(
     available: false,
     verified: "active_probe",
     autoCandidate,
-    summary: isMacOS
-      ? `Extension mode probe failed via macOS host browser proxy: ${probe.error.message}`
-      : `Extension mode probe failed: ${probe.error.message}`,
-    userActions: isMacOS
-      ? macOSHostBrowserProbeFailureActions(probe.error)
-      : probeFailureActions(BROWSER_STATUS_MODE.EXTENSION, probe.error),
+    summary: `Extension mode probe failed: ${probe.error.message}`,
+    userActions: probeFailureActions(
+      BROWSER_STATUS_MODE.EXTENSION,
+      probe.error,
+    ),
     tradeoffs: modeTradeoffs(BROWSER_STATUS_MODE.EXTENSION),
     details: {
-      proxyBound,
-      proxyConnected,
       errorCode: probe.error.code,
       diagnostic: probe.diagnostic,
       attemptDiagnostics: probe.error.attemptDiagnostics ?? [],
-      transport:
-        isMacOS && !context.hostBrowserRegistryRouted
-          ? "macos-sse"
-          : "extension-ws",
+      transport: "extension-ws",
     },
   };
 }

package/src/tools/browser/browser-manager.ts

@@ -561,10 +561,7 @@ class BrowserManager {
    * any prior value so an explicit `browser_mode` override on one call
    * becomes the default for subsequent `auto`-mode calls.
    */
-  setPreferredBackendKind(
-    conversationId: string,
-    kind: CdpClientKind,
-  ): void {
+  setPreferredBackendKind(conversationId: string, kind: CdpClientKind): void {
     this.preferredBackendKinds.set(conversationId, kind);
   }
 
@@ -953,7 +950,3 @@ class BrowserManager {
 }
 
 export const browserManager = new BrowserManager();
-
-export function isAuthenticatedForDomain(domain: string): boolean {
-  return authSessionCache.isAuthenticated(domain);
-}