@vellumai/assistant 0.7.0 → 0.7.2

package/src/daemon/host-bash-proxy.ts

@@ -1,43 +1,55 @@
 import { v4 as uuid } from "uuid";
 
 import { getConfig } from "../config/loader.js";
+import {
+  assistantEventHub,
+  broadcastMessage,
+} from "../runtime/assistant-event-hub.js";
+import * as pendingInteractions from "../runtime/pending-interactions.js";
 import { formatShellOutput } from "../tools/shared/shell-output.js";
 import type { ToolExecutionResult } from "../tools/types.js";
 import { AssistantError, ErrorCode } from "../util/errors.js";
 import { getLogger } from "../util/logger.js";
-import type { ServerMessage } from "./message-protocol.js";
 
 const log = getLogger("host-bash-proxy");
 
-interface PendingRequest {
-  resolve: (result: ToolExecutionResult) => void;
-  reject: (err: Error) => void;
-  timer: ReturnType<typeof setTimeout>;
-  timeoutSec: number;
-  /** Detach the abort listener from the caller's signal. No-op when no signal was passed. */
-  detachAbort: () => void;
-}
 
 export class HostBashProxy {
-  private pending = new Map<string, PendingRequest>();
-  private sendToClient: (msg: ServerMessage) => void;
-  private onInternalResolve?: (requestId: string) => void;
-  private clientConnected = false;
-
-  constructor(
-    sendToClient: (msg: ServerMessage) => void,
-    onInternalResolve?: (requestId: string) => void,
-  ) {
-    this.sendToClient = sendToClient;
-    this.onInternalResolve = onInternalResolve;
+  private static _instance: HostBashProxy | null = null;
+
+  /**
+   * Lazily-initialized singleton. Availability of an actual desktop
+   * connection is checked at send time via the assistant event hub,
+   * not at construction time.
+   */
+  static get instance(): HostBashProxy {
+    if (!HostBashProxy._instance) {
+      log.info("Creating singleton HostBashProxy");
+      HostBashProxy._instance = new HostBashProxy();
+    }
+    return HostBashProxy._instance;
   }
 
-  updateSender(
-    sendToClient: (msg: ServerMessage) => void,
-    clientConnected: boolean,
-  ): void {
-    this.sendToClient = sendToClient;
-    this.clientConnected = clientConnected;
+  /** Dispose the singleton. Called during graceful shutdown. */
+  static disposeInstance(): void {
+    if (HostBashProxy._instance) {
+      HostBashProxy._instance.dispose();
+      HostBashProxy._instance = null;
+    }
+  }
+
+  /** For tests. */
+  static reset(): void {
+    HostBashProxy._instance = null;
+  }
+
+  /**
+   * Whether a client with `host_bash` capability is connected.
+   */
+  isAvailable(): boolean {
+    return (
+      assistantEventHub.getMostRecentClientByCapability("host_bash") != null
+    );
   }
 
   request(
@@ -46,6 +58,7 @@ export class HostBashProxy {
       working_dir?: string;
       timeout_seconds?: number;
       env?: Record<string, string>;
+      targetClientId?: string;
     },
     conversationId: string,
     signal?: AbortSignal,
@@ -55,30 +68,50 @@ export class HostBashProxy {
       return Promise.resolve(result);
     }
 
+    const capableClients = assistantEventHub.listClientsByCapability("host_bash");
+
+    let resolvedTargetClientId: string | undefined;
+
+    if (input.targetClientId) {
+      const target = assistantEventHub.getClientById(input.targetClientId);
+      if (!target || !target.capabilities.includes("host_bash")) {
+        return Promise.resolve({
+          content: `Error: client "${input.targetClientId}" is not connected or does not support host_bash. Run \`assistant clients list --capability host_bash\` to see available clients.`,
+          isError: true,
+        });
+      }
+      resolvedTargetClientId = input.targetClientId;
+    } else if (capableClients.length === 1) {
+      // Auto-resolve when exactly one capable client is connected.
+      resolvedTargetClientId = capableClients[0].clientId;
+    }
+    // capableClients.length === 0 or > 1 without explicit target: resolvedTargetClientId
+    // stays undefined and falls through to untargeted broadcast — the existing timeout/error
+    // path handles the zero-client case, and multi-client ambiguity is enforced at the tool
+    // executor layer (not here) once target_client_id is exposed in the tool schema.
+
     const requestId = uuid();
 
     return new Promise<ToolExecutionResult>((resolve, reject) => {
       const shellMaxTimeoutSec = getConfig().timeouts.shellMaxTimeoutSec;
       const timeoutSec = input.timeout_seconds ?? shellMaxTimeoutSec;
-      // Proxy timeout: slightly after client-side timeout, but before executor's outer timeout
       const proxyTimeoutSec = timeoutSec + 3;
 
-      // Declared up-front so onAbort (defined before detachAbort is assigned)
-      // can close over a stable reference once it's wired below.
       let detachAbort: () => void = () => {};
 
       const timer = setTimeout(() => {
-        this.pending.delete(requestId);
-        detachAbort();
-        this.onInternalResolve?.(requestId);
+        pendingInteractions.resolve(requestId);
         log.warn(
           { requestId, command: input.command },
           "Host bash proxy request timed out",
         );
+        const timeoutMessage = resolvedTargetClientId
+          ? `Host bash proxy timed out waiting for response from client ${resolvedTargetClientId}`
+          : "Host bash proxy timed out waiting for client response";
         resolve(
           formatShellOutput(
             "",
-            "Host bash proxy timed out waiting for client response",
+            timeoutMessage,
             null,
             true,
             timeoutSec,
@@ -88,20 +121,21 @@ export class HostBashProxy {
 
       if (signal) {
         const onAbort = () => {
-          if (this.pending.has(requestId)) {
-            clearTimeout(timer);
-            this.pending.delete(requestId);
-            // Abort fired — nothing to detach, but call the no-op for symmetry
-            // so callers can rely on detachAbort being idempotent.
-            detachAbort();
-            this.onInternalResolve?.(requestId);
+          if (pendingInteractions.get(requestId)) {
+            pendingInteractions.resolve(requestId);
             try {
-              this.sendToClient({
-                type: "host_bash_cancel",
-                requestId,
-              } as ServerMessage);
+              broadcastMessage(
+                {
+                  type: "host_bash_cancel",
+                  requestId,
+                  conversationId,
+                  targetClientId: resolvedTargetClientId,
+                },
+                conversationId,
+                { targetClientId: resolvedTargetClientId },
+              );
             } catch {
-              // Best-effort cancel notification — connection may already be closed.
+              // Best-effort cancel notification
             }
             resolve(formatShellOutput("", "Aborted", null, false, 0));
           }
@@ -110,34 +144,36 @@ export class HostBashProxy {
         detachAbort = () => signal.removeEventListener("abort", onAbort);
       }
 
-      this.pending.set(requestId, {
-        resolve,
-        reject,
+      pendingInteractions.register(requestId, {
+        conversationId,
+        kind: "host_bash",
+        rpcResolve: resolve,
+        rpcReject: reject,
         timer,
-        timeoutSec,
         detachAbort,
+        targetClientId: resolvedTargetClientId,
+        metadata: { timeoutSec },
       });
 
       try {
-        this.sendToClient({
-          type: "host_bash_request",
-          requestId,
+        broadcastMessage(
+          {
+            type: "host_bash_request",
+            requestId,
+            conversationId,
+            command: input.command,
+            working_dir: input.working_dir,
+            timeout_seconds: input.timeout_seconds,
+            targetClientId: resolvedTargetClientId,
+            ...(input.env && Object.keys(input.env).length > 0
+                ? { env: input.env }
+                : {}),
+          },
           conversationId,
-          command: input.command,
-          working_dir: input.working_dir,
-          timeout_seconds: input.timeout_seconds,
-          ...(input.env && Object.keys(input.env).length > 0
-            ? { env: input.env }
-            : {}),
-        } as ServerMessage);
+          { targetClientId: resolvedTargetClientId },
+        );
       } catch (err) {
-        // Sender threw synchronously (e.g. client transport error during
-        // event emission). Clean up pending state and timer so we don't
-        // leak an in-flight entry that nothing will ever resolve.
-        clearTimeout(timer);
-        this.pending.delete(requestId);
-        detachAbort();
-        this.onInternalResolve?.(requestId);
+        pendingInteractions.resolve(requestId);
         log.warn(
           { requestId, command: input.command, err },
           "Host bash proxy send failed",
@@ -147,7 +183,10 @@ export class HostBashProxy {
     });
   }
 
-  resolve(
+  /**
+   * Process a client result and resolve the RPC. Called by route handlers.
+   */
+  resolveResult(
     requestId: string,
     response: {
       stdout: string;
@@ -156,52 +195,45 @@ export class HostBashProxy {
       timedOut: boolean;
     },
   ): void {
-    const entry = this.pending.get(requestId);
-    if (!entry) {
+    const interaction = pendingInteractions.resolve(requestId);
+    if (!interaction?.rpcResolve) {
       log.warn({ requestId }, "No pending host bash request for response");
       return;
     }
-    clearTimeout(entry.timer);
-    entry.detachAbort();
-    this.pending.delete(requestId);
+    const timeoutSec = (interaction.metadata?.timeoutSec as number) ?? 0;
     const result = formatShellOutput(
       response.stdout,
       response.stderr,
       response.exitCode,
       response.timedOut,
-      entry.timeoutSec,
+      timeoutSec,
     );
-    entry.resolve(result);
-  }
-
-  hasPendingRequest(requestId: string): boolean {
-    return this.pending.has(requestId);
-  }
-
-  isAvailable(): boolean {
-    return this.clientConnected;
+    interaction.rpcResolve(result);
   }
 
   dispose(): void {
-    for (const [requestId, entry] of this.pending) {
-      clearTimeout(entry.timer);
-      entry.detachAbort();
-      this.onInternalResolve?.(requestId);
+    for (const entry of pendingInteractions.getByKind("host_bash")) {
+      pendingInteractions.resolve(entry.requestId);
       try {
-        this.sendToClient({
-          type: "host_bash_cancel",
-          requestId,
-        } as ServerMessage);
+        broadcastMessage(
+          {
+            type: "host_bash_cancel",
+            requestId: entry.requestId,
+            conversationId: entry.conversationId,
+            targetClientId: entry.targetClientId,
+          },
+          entry.conversationId,
+          { targetClientId: entry.targetClientId },
+        );
       } catch {
         // Best-effort cancel notification — connection may already be closed.
       }
-      entry.reject(
+      entry.rpcReject?.(
         new AssistantError(
           "Host bash proxy disposed",
           ErrorCode.INTERNAL_ERROR,
         ),
       );
     }
-    this.pending.clear();
   }
 }

package/src/daemon/host-browser-proxy.ts

@@ -1,9 +1,14 @@
 import { v4 as uuid } from "uuid";
 
+import type { InterfaceId } from "../channels/types.js";
+import {
+  assistantEventHub,
+  broadcastMessage,
+} from "../runtime/assistant-event-hub.js";
+import * as pendingInteractions from "../runtime/pending-interactions.js";
 import type { ToolExecutionResult } from "../tools/types.js";
 import { AssistantError, ErrorCode } from "../util/errors.js";
 import { getLogger } from "../util/logger.js";
-import type { ServerMessage } from "./message-protocol.js";
 import type { HostBrowserRequest } from "./message-types/host-browser.js";
 
 /** Distributive omit that preserves union variant fields. */
@@ -19,34 +24,64 @@ export type HostBrowserInput = DistributiveOmit<
 
 const log = getLogger("host-browser-proxy");
 
-interface PendingRequest {
-  resolve: (result: ToolExecutionResult) => void;
-  reject: (err: Error) => void;
-  timer: ReturnType<typeof setTimeout>;
-  /** Detach the abort listener from the caller's signal. No-op when no signal was passed. */
-  detachAbort: () => void;
-}
+/** Interface priority order for host_browser: Chrome Extension first, macOS SSE bridge second. */
+const HOST_BROWSER_INTERFACE_PREFERENCE: InterfaceId[] = [
+  "chrome-extension",
+  "macos",
+];
 
 export class HostBrowserProxy {
-  private pending = new Map<string, PendingRequest>();
-  private sendToClient: (msg: ServerMessage) => void;
-  private onInternalResolve?: (requestId: string) => void;
-  private clientConnected = false;
-
-  constructor(
-    sendToClient: (msg: ServerMessage) => void,
-    onInternalResolve?: (requestId: string) => void,
-  ) {
-    this.sendToClient = sendToClient;
-    this.onInternalResolve = onInternalResolve;
+  private static _instance: HostBrowserProxy | null = null;
+
+  /**
+   * Lazily-initialized singleton. Always creates the instance on first
+   * access — availability of an actual extension connection is checked
+   * at send time, not at construction time.
+   */
+  static get instance(): HostBrowserProxy {
+    if (!HostBrowserProxy._instance) {
+      log.info("Creating singleton HostBrowserProxy");
+      HostBrowserProxy._instance = new HostBrowserProxy();
+    }
+    return HostBrowserProxy._instance;
   }
 
-  updateSender(
-    sendToClient: (msg: ServerMessage) => void,
-    clientConnected: boolean,
-  ): void {
-    this.sendToClient = sendToClient;
-    this.clientConnected = clientConnected;
+  /** Dispose the singleton. Called during graceful shutdown. */
+  static disposeInstance(): void {
+    if (HostBrowserProxy._instance) {
+      HostBrowserProxy._instance.dispose();
+      HostBrowserProxy._instance = null;
+    }
+  }
+
+  /** For tests. */
+  static reset(): void {
+    HostBrowserProxy._instance = null;
+  }
+
+  /**
+   * Whether a client with `host_browser` capability is connected.
+   * Returns `true` when either the Chrome Extension or the macOS SSE
+   * bridge is available — i.e. any transport can forward host-browser
+   * requests.
+   */
+  isAvailable(): boolean {
+    return (
+      assistantEventHub.getPreferredClientByCapability(
+        "host_browser",
+        HOST_BROWSER_INTERFACE_PREFERENCE,
+      ) != null
+    );
+  }
+
+  /**
+   * Whether a Chrome Extension client specifically is connected.
+   * Returns `false` when only the macOS SSE bridge is available.
+   * Unlike {@link isAvailable}, this does not consider the macOS bridge
+   * a valid extension transport.
+   */
+  hasExtensionClient(): boolean {
+    return assistantEventHub.listClientsByInterface("chrome-extension").length > 0;
   }
 
   request(
@@ -61,44 +96,34 @@ export class HostBrowserProxy {
     const requestId = uuid();
 
     return new Promise<ToolExecutionResult>((resolve, reject) => {
-      // CDP operations should be fast — 30 second default timeout matches host_file.
       const timeoutSec = input.timeout_seconds ?? 30;
 
-      // Declared up-front so onAbort (defined before detachAbort is assigned)
-      // can close over a stable reference once it's wired below.
       let detachAbort: () => void = () => {};
 
       const timer = setTimeout(() => {
-        this.pending.delete(requestId);
-        detachAbort();
-        this.onInternalResolve?.(requestId);
+        pendingInteractions.resolve(requestId);
         log.warn(
           { requestId, cdpMethod: input.cdpMethod },
           "Host browser proxy request timed out",
         );
         resolve({
           content:
-            "Host browser proxy timed out waiting for extension response (check browser-relay connectivity and /v1/host-browser-result callback failures such as 404/401).",
+            "Host browser proxy timed out waiting for extension response (check SSE connectivity and /v1/host-browser-result callback failures such as 404/401).",
           isError: true,
         });
       }, timeoutSec * 1000);
 
       if (signal) {
         const onAbort = () => {
-          if (this.pending.has(requestId)) {
-            clearTimeout(timer);
-            this.pending.delete(requestId);
-            // Abort fired — nothing to detach, but call the no-op for symmetry
-            // so callers can rely on detachAbort being idempotent.
-            detachAbort();
-            this.onInternalResolve?.(requestId);
+          if (pendingInteractions.get(requestId)) {
+            pendingInteractions.resolve(requestId);
             try {
-              this.sendToClient({
+              broadcastMessage({
                 type: "host_browser_cancel",
                 requestId,
-              } as ServerMessage);
+              });
             } catch {
-              // Best-effort cancel notification — connection may already be closed.
+              // Best-effort cancel notification
             }
             resolve({ content: "Aborted", isError: true });
           }
@@ -107,23 +132,37 @@ export class HostBrowserProxy {
         detachAbort = () => signal.removeEventListener("abort", onAbort);
       }
 
-      this.pending.set(requestId, { resolve, reject, timer, detachAbort });
+      pendingInteractions.register(requestId, {
+        conversationId,
+        kind: "host_browser",
+        rpcResolve: resolve,
+        rpcReject: reject,
+        timer,
+        detachAbort,
+      });
 
       try {
-        this.sendToClient({
-          ...input,
-          type: "host_browser_request",
-          requestId,
+        const preferredClient = assistantEventHub.getPreferredClientByCapability(
+          "host_browser",
+          HOST_BROWSER_INTERFACE_PREFERENCE,
+        );
+        if (!preferredClient) {
+          pendingInteractions.resolve(requestId);
+          reject(
+            new Error(
+              "host_browser send failed: no active extension connection",
+            ),
+          );
+          return;
+        }
+
+        broadcastMessage(
+          { ...input, type: "host_browser_request", requestId, conversationId },
           conversationId,
-        } as ServerMessage);
+          { targetClientId: preferredClient.clientId },
+        );
       } catch (err) {
-        // Sender threw synchronously (e.g. client transport error during
-        // event emission). Clean up pending state and timer so we don't
-        // leak an in-flight entry that nothing will ever resolve.
-        clearTimeout(timer);
-        this.pending.delete(requestId);
-        detachAbort();
-        this.onInternalResolve?.(requestId);
+        pendingInteractions.resolve(requestId);
         log.warn(
           { requestId, cdpMethod: input.cdpMethod, err },
           "Host browser proxy send failed",
@@ -133,60 +172,44 @@ export class HostBrowserProxy {
     });
   }
 
-  resolve(
+  /**
+   * Process a client result and resolve the RPC. Called by route handlers.
+   */
+  resolveResult(
     requestId: string,
     response: { content: string; isError: boolean },
   ): void {
-    const entry = this.pending.get(requestId);
-    if (!entry) {
-      // Benign race, not an error. A late result frame with no matching
-      // pending entry means one of:
-      //   - the proxy-side setTimeout has already resolved the caller;
-      //   - the caller's AbortSignal fired and the entry was torn down;
-      //   - a duplicate result frame was delivered (e.g. retry after a
-      //     transient WS drop).
-      // Log at debug so operators don't chase false-positive "timeout"
-      // alerts on what is actually a cleanly-handled race.
+    const interaction = pendingInteractions.resolve(requestId);
+    if (!interaction?.rpcResolve) {
       log.debug(
         { requestId },
         "Ignoring host_browser_result for unknown or already-resolved request",
       );
       return;
     }
-    clearTimeout(entry.timer);
-    entry.detachAbort();
-    this.pending.delete(requestId);
-    entry.resolve({ content: response.content, isError: response.isError });
-  }
-
-  hasPendingRequest(requestId: string): boolean {
-    return this.pending.has(requestId);
-  }
-
-  isAvailable(): boolean {
-    return this.clientConnected;
+    interaction.rpcResolve({
+      content: response.content,
+      isError: response.isError,
+    });
   }
 
   dispose(): void {
-    for (const [requestId, entry] of this.pending) {
-      clearTimeout(entry.timer);
-      entry.detachAbort();
-      this.onInternalResolve?.(requestId);
+    for (const entry of pendingInteractions.getByKind("host_browser")) {
+      pendingInteractions.resolve(entry.requestId);
       try {
-        this.sendToClient({
+        broadcastMessage({
           type: "host_browser_cancel",
-          requestId,
-        } as ServerMessage);
+          requestId: entry.requestId,
+        });
       } catch {
-        // Best-effort cancel notification — connection may already be closed.
+        // Best-effort cancel notification
       }
-      entry.reject(
+      entry.rpcReject?.(
         new AssistantError(
           "Host browser proxy disposed",
           ErrorCode.INTERNAL_ERROR,
         ),
       );
     }
-    this.pending.clear();
   }
 }