@vellumai/assistant 0.7.0 → 0.7.2

package/src/tools/host-filesystem/read.ts

@@ -1,7 +1,10 @@
 import { extname } from "node:path";
 
+import { supportsHostProxy } from "../../channels/types.js";
+import { HostFileProxy } from "../../daemon/host-file-proxy.js";
 import { RiskLevel } from "../../permissions/types.js";
 import type { ToolDefinition } from "../../providers/types.js";
+import { assistantEventHub } from "../../runtime/assistant-event-hub.js";
 import { FileSystemOps } from "../shared/filesystem/file-ops-service.js";
 import {
   IMAGE_EXTENSIONS,
@@ -36,6 +39,11 @@ class HostFileReadTool implements Tool {
             type: "number",
             description: "Maximum number of lines to read",
           },
+          target_client_id: {
+            type: "string",
+            description:
+              "ID of the specific client to execute this on. Required when multiple clients support host_file; omit when only one is connected. Obtain IDs from `assistant clients list --capability host_file`.",
+          },
         },
         required: ["path"],
       },
@@ -54,16 +62,35 @@ class HostFileReadTool implements Tool {
       };
     }
 
+    const targetClientId =
+      typeof input.target_client_id === "string" && input.target_client_id !== ""
+        ? input.target_client_id
+        : undefined;
+
+    const transportInterface = context.transportInterface;
+    if (
+      targetClientId == null &&
+      transportInterface != null &&
+      !supportsHostProxy(transportInterface) &&
+      assistantEventHub.listClientsByCapability("host_file").length > 1
+    ) {
+      return {
+        content: `Error: multiple clients support host_file. Specify which client to use with \`target_client_id\`. Run \`assistant clients list --capability host_file\` to see client IDs and labels.`,
+        isError: true,
+      };
+    }
+
     // Proxy to connected client for execution on the user's machine
     // when a capable client is available (managed/cloud-hosted mode),
     // including image reads that need the host filesystem view.
-    if (context.hostFileProxy?.isAvailable()) {
-      return context.hostFileProxy.request(
+    if (HostFileProxy.instance.isAvailable()) {
+      return HostFileProxy.instance.request(
         {
           operation: "read",
           path: rawPath,
           offset: typeof input.offset === "number" ? input.offset : undefined,
           limit: typeof input.limit === "number" ? input.limit : undefined,
+          targetClientId,
         },
         context.conversationId,
         context.signal,

package/src/tools/host-filesystem/transfer.test.ts

@@ -1,14 +1,44 @@
 import { existsSync, mkdtempSync, realpathSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { afterEach, describe, expect, test } from "bun:test";
+import { afterEach, describe, expect, mock, test } from "bun:test";
 
 import type { ToolContext } from "../types.js";
-import { hostFileTransferTool } from "./transfer.js";
+
+// ---------------------------------------------------------------------------
+// Singleton mock — must precede the tool import so bun's module mock applies.
+// ---------------------------------------------------------------------------
+
+let mockProxyAvailable = false;
+const toSandboxCalls: Array<{ sourcePath: string; destPath: string }> = [];
+const toHostCalls: Array<{ sourcePath: string; destPath: string }> = [];
+
+mock.module("../../daemon/host-transfer-proxy.js", () => ({
+  HostTransferProxy: {
+    get instance() {
+      return {
+        isAvailable: () => mockProxyAvailable,
+        requestToSandbox: (args: { sourcePath: string; destPath: string; overwrite?: boolean; conversationId: string }) => {
+          toSandboxCalls.push({ sourcePath: args.sourcePath, destPath: args.destPath });
+          return Promise.resolve({ content: "ok", isError: false });
+        },
+        requestToHost: (args: { sourcePath: string; destPath: string; overwrite: boolean; conversationId: string }) => {
+          toHostCalls.push({ sourcePath: args.sourcePath, destPath: args.destPath });
+          return Promise.resolve({ content: "ok", isError: false });
+        },
+      };
+    },
+  },
+}));
+
+const { hostFileTransferTool } = await import("./transfer.js");
 
 const testDirs: string[] = [];
 
 afterEach(() => {
+  mockProxyAvailable = false;
+  toSandboxCalls.length = 0;
+  toHostCalls.length = 0;
   for (const dir of testDirs.splice(0)) {
     rmSync(dir, { recursive: true, force: true });
   }
@@ -25,7 +55,7 @@ function makeContext(workingDir: string): ToolContext {
 }
 
 // ---------------------------------------------------------------------------
-// Local-mode tests (no proxy; context.hostTransferProxy omitted)
+// Local-mode tests (proxy unavailable — falls back to local copy)
 // ---------------------------------------------------------------------------
 
 describe("host_file_transfer local mode", () => {
@@ -176,93 +206,66 @@ describe("host_file_transfer local mode to_host", () => {
 });
 
 // ---------------------------------------------------------------------------
-// Managed-mode tests (mock proxy via context.hostTransferProxy)
+// Managed-mode tests (singleton proxy available)
 // ---------------------------------------------------------------------------
 
 describe("host_file_transfer managed mode", () => {
   test("relative path is pre-resolved before proxy call", async () => {
+    mockProxyAvailable = true;
     const workingDir = makeTempDir();
     const srcDir = makeTempDir();
     const srcFile = join(srcDir, "source.txt");
     writeFileSync(srcFile, "content");
 
-    const calls: Array<{ destPath: string }> = [];
-    const mockProxy = {
-      isAvailable: () => true,
-      requestToSandbox: (args: { sourcePath: string; destPath: string; overwrite: boolean; conversationId: string }) => {
-        calls.push({ destPath: args.destPath });
-        return Promise.resolve({ content: "ok", isError: false });
-      },
-    };
-    const ctx = { ...makeContext(workingDir), hostTransferProxy: mockProxy as any };
-
     await hostFileTransferTool.execute(
       {
         source_path: srcFile,
         dest_path: "relative/file.txt",
         direction: "to_sandbox",
       },
-      ctx,
+      makeContext(workingDir),
     );
 
-    expect(calls.length).toBe(1);
-    expect(calls[0].destPath).toBe(join(workingDir, "relative", "file.txt"));
+    expect(toSandboxCalls.length).toBe(1);
+    expect(toSandboxCalls[0].destPath).toBe(join(workingDir, "relative", "file.txt"));
   });
 
   test("to_host relative source is pre-resolved before proxy call", async () => {
+    mockProxyAvailable = true;
     const workingDir = makeTempDir();
     writeFileSync(join(workingDir, "doc.md"), "content");
 
-    const calls: Array<{ sourcePath: string }> = [];
-    const mockProxy = {
-      isAvailable: () => true,
-      requestToHost: (args: { sourcePath: string; destPath: string; overwrite: boolean; conversationId: string }) => {
-        calls.push({ sourcePath: args.sourcePath });
-        return Promise.resolve({ content: "ok", isError: false });
-      },
-    };
-    const ctx = { ...makeContext(workingDir), hostTransferProxy: mockProxy as any };
-
     await hostFileTransferTool.execute(
       {
         source_path: "doc.md",
         dest_path: "/Users/someone/Desktop/doc.md",
         direction: "to_host",
       },
-      ctx,
+      makeContext(workingDir),
     );
 
-    expect(calls.length).toBe(1);
-    expect(calls[0].sourcePath).toBe(join(workingDir, "doc.md"));
+    expect(toHostCalls.length).toBe(1);
+    expect(toHostCalls[0].sourcePath).toBe(join(workingDir, "doc.md"));
   });
 
   test("out-of-bounds path rejected before proxy call", async () => {
+    mockProxyAvailable = true;
     const workingDir = makeTempDir();
     const srcDir = makeTempDir();
     const srcFile = join(srcDir, "source.txt");
     writeFileSync(srcFile, "content");
 
-    const calls: Array<{ destPath: string }> = [];
-    const mockProxy = {
-      isAvailable: () => true,
-      requestToSandbox: (args: { sourcePath: string; destPath: string; overwrite: boolean; conversationId: string }) => {
-        calls.push({ destPath: args.destPath });
-        return Promise.resolve({ content: "ok", isError: false });
-      },
-    };
-    const ctx = { ...makeContext(workingDir), hostTransferProxy: mockProxy as any };
-
     const result = await hostFileTransferTool.execute(
       {
         source_path: srcFile,
         dest_path: "/etc/passwd",
         direction: "to_sandbox",
       },
-      ctx,
+      makeContext(workingDir),
     );
 
     expect(result.isError).toBe(true);
     expect(result.content).toContain("Invalid destination path");
-    expect(calls.length).toBe(0);
+    expect(toSandboxCalls.length).toBe(0);
   });
 });

package/src/tools/host-filesystem/transfer.ts

@@ -2,15 +2,18 @@ import { constants } from "node:fs";
 import { copyFile, lstat, mkdir, realpath } from "node:fs/promises";
 import { dirname, isAbsolute } from "node:path";
 
+import { supportsHostProxy } from "../../channels/types.js";
+import { HostTransferProxy } from "../../daemon/host-transfer-proxy.js";
 import { RiskLevel } from "../../permissions/types.js";
 import type { ToolDefinition } from "../../providers/types.js";
+import { assistantEventHub } from "../../runtime/assistant-event-hub.js";
 import { sandboxPolicy } from "../shared/filesystem/path-policy.js";
 import type { Tool, ToolContext, ToolExecutionResult } from "../types.js";
 
 class HostFileTransferTool implements Tool {
   name = "host_file_transfer";
   description =
-    "Copy a file between the assistant's workspace and the user's host machine. Set direction to 'to_host' to send a workspace file to the host, or 'to_sandbox' to pull a host file into the workspace.";
+    "Copy a file between the assistant's workspace and the user's host machine. Set direction to 'to_host' to send a workspace file to the host, or 'to_sandbox' to pull a host file into the workspace. When multiple clients support host_file, specify which one to use with target_client_id.";
   category = "host-filesystem";
   defaultRiskLevel = RiskLevel.Medium;
 
@@ -47,6 +50,11 @@ class HostFileTransferTool implements Tool {
             description:
               "Brief description of why the file is being transferred (for audit logging)",
           },
+          target_client_id: {
+            type: "string",
+            description:
+              "ID of the specific client to transfer files to/from. Required when multiple clients support host_file; omit when only one is connected. Obtain IDs from `assistant clients list --capability host_file`.",
+          },
         },
         required: ["source_path", "dest_path", "direction"],
       },
@@ -84,6 +92,20 @@ class HostFileTransferTool implements Tool {
 
     const overwrite = input.overwrite === true;
 
+    const targetClientId =
+      typeof input.target_client_id === "string" && input.target_client_id !== ""
+        ? input.target_client_id
+        : undefined;
+
+    if (
+      targetClientId == null &&
+      context.transportInterface != null &&
+      !supportsHostProxy(context.transportInterface) &&
+      assistantEventHub.listClientsByCapability("host_file").length > 1
+    ) {
+      return { content: `Error: multiple clients support host_file. Specify which client to use with \`target_client_id\`. Run \`assistant clients list --capability host_file\` to see client IDs and labels.`, isError: true };
+    }
+
     // Validate that host-side paths are absolute.
     if (direction === "to_host" && !isAbsolute(destPath)) {
       return {
@@ -125,29 +147,38 @@ class HostFileTransferTool implements Tool {
     }
 
     // Managed mode: delegate to the host transfer proxy when available.
-    if (context.hostTransferProxy?.isAvailable()) {
+    if (HostTransferProxy.instance.isAvailable()) {
       if (direction === "to_host") {
-        return context.hostTransferProxy.requestToHost(
+        return HostTransferProxy.instance.requestToHost(
           {
             sourcePath: resolvedSourcePath,
             destPath,
             overwrite,
             conversationId: context.conversationId,
+            targetClientId,
           },
           context.signal,
         );
       }
-      return context.hostTransferProxy.requestToSandbox(
+      return HostTransferProxy.instance.requestToSandbox(
         {
           sourcePath,
           destPath: resolvedDestPath,
           overwrite,
           conversationId: context.conversationId,
+          targetClientId,
         },
         context.signal,
       );
     }
 
+    if (targetClientId != null) {
+      return {
+        content: `Error: target_client_id '${targetClientId}' was specified but no host client is available. Ensure the client is connected.`,
+        isError: true,
+      };
+    }
+
     // Local mode: direct filesystem copy.
     return this.executeLocal(resolvedSourcePath, resolvedDestPath, overwrite);
   }

package/src/tools/host-filesystem/write.ts

@@ -1,5 +1,8 @@
+import { supportsHostProxy } from "../../channels/types.js";
+import { HostFileProxy } from "../../daemon/host-file-proxy.js";
 import { RiskLevel } from "../../permissions/types.js";
 import type { ToolDefinition } from "../../providers/types.js";
+import { assistantEventHub } from "../../runtime/assistant-event-hub.js";
 import { FileSystemOps } from "../shared/filesystem/file-ops-service.js";
 import { formatWriteSummary } from "../shared/filesystem/format-diff.js";
 import { hostPolicy } from "../shared/filesystem/path-policy.js";
@@ -27,6 +30,11 @@ class HostFileWriteTool implements Tool {
             type: "string",
             description: "The content to write to the file",
           },
+          target_client_id: {
+            type: "string",
+            description:
+              "ID of the specific client to execute this on. Required when multiple clients support host_file; omit when only one is connected. Obtain IDs from `assistant clients list --capability host_file`.",
+          },
         },
         required: ["path", "content"],
       },
@@ -53,14 +61,33 @@ class HostFileWriteTool implements Tool {
       };
     }
 
+    const targetClientId =
+      typeof input.target_client_id === "string" && input.target_client_id !== ""
+        ? input.target_client_id
+        : undefined;
+
+    const transportInterface = context.transportInterface;
+    if (
+      targetClientId == null &&
+      transportInterface != null &&
+      !supportsHostProxy(transportInterface) &&
+      assistantEventHub.listClientsByCapability("host_file").length > 1
+    ) {
+      return {
+        content: `Error: multiple clients support host_file. Specify which client to use with \`target_client_id\`. Run \`assistant clients list --capability host_file\` to see client IDs and labels.`,
+        isError: true,
+      };
+    }
+
     // Proxy to connected client for execution on the user's machine
     // when a capable client is available (managed/cloud-hosted mode).
-    if (context.hostFileProxy?.isAvailable()) {
-      return context.hostFileProxy.request(
+    if (HostFileProxy.instance.isAvailable()) {
+      return HostFileProxy.instance.request(
         {
           operation: "write",
           path: rawPath,
           content: fileContent,
+          targetClientId,
         },
         context.conversationId,
         context.signal,

package/src/tools/host-terminal/host-shell.ts

@@ -18,12 +18,15 @@ import { existsSync } from "node:fs";
 import { homedir } from "node:os";
 import { isAbsolute } from "node:path";
 
+import { supportsHostProxy } from "../../channels/types.js";
 import { getConfig } from "../../config/loader.js";
 import { isCesShellLockdownEnabled } from "../../credential-execution/feature-gates.js";
+import { HostBashProxy } from "../../daemon/host-bash-proxy.js";
 import { RiskLevel } from "../../permissions/types.js";
 import type { ToolDefinition } from "../../providers/types.js";
 import { isUntrustedTrustClass } from "../../runtime/actor-trust-resolver.js";
 import { wakeAgentForOpportunity } from "../../runtime/agent-wake.js";
+import { assistantEventHub } from "../../runtime/assistant-event-hub.js";
 import { redactSecrets } from "../../security/secret-scanner.js";
 import { getLogger } from "../../util/logger.js";
 import {
@@ -130,6 +133,11 @@ class HostShellTool implements Tool {
             description:
               "Run the command in the background on the host machine. The tool returns immediately with a background tool ID. When the process exits, its output is delivered to the conversation as a wake.",
           },
+          target_client_id: {
+            type: "string",
+            description:
+              "ID of the specific client to execute this command on. Required when multiple clients support host_bash; omit when only one client is connected. Obtain IDs from `assistant clients list --capability host_bash`.",
+          },
         },
         required: ["command", "activity"],
       },
@@ -172,6 +180,11 @@ class HostShellTool implements Tool {
     }
     const background = input.background === true;
 
+    const targetClientId =
+      typeof input.target_client_id === "string" && input.target_client_id !== ""
+        ? input.target_client_id
+        : undefined;
+
     const config = getConfig();
     const { shellDefaultTimeoutSec, shellMaxTimeoutSec } = config.timeouts;
 
@@ -189,9 +202,53 @@ class HostShellTool implements Tool {
       isCesShellLockdownEnabled(config) &&
       isUntrustedTrustClass(context.trustClass);
 
+    // Guard: non-host-proxy interfaces need an explicit target when multiple
+    // capable clients are connected to avoid ambiguous untargeted broadcasts.
+    const transportInterface = context.transportInterface;
+    if (
+      targetClientId == null &&
+      transportInterface != null &&
+      !supportsHostProxy(transportInterface) &&
+      assistantEventHub.listClientsByCapability("host_bash").length > 1
+    ) {
+      return {
+        content: `Error: multiple clients support host_bash. Specify which client to use with \`target_client_id\`. Run \`assistant clients list --capability host_bash\` to see client IDs and labels.`,
+        isError: true,
+      };
+    }
+
+    // Guard: non-host-proxy interfaces with no capable clients connected.
+    if (
+      targetClientId == null &&
+      transportInterface != null &&
+      !supportsHostProxy(transportInterface) &&
+      !HostBashProxy.instance.isAvailable()
+    ) {
+      return {
+        content:
+          "Error: no client with host_bash capability is connected. Connect a macOS client to use host_bash from a non-desktop interface.",
+        isError: true,
+      };
+    }
+
+    // Guard: explicit targetClientId provided but proxy is unavailable (client
+    // disconnected between tool-definition and tool-execution). Without this
+    // guard both targetClientId != null guards above are bypassed, and the
+    // code falls through to local daemon execution — silently running commands
+    // inside the Docker container instead of on the intended host machine.
+    if (
+      targetClientId != null &&
+      !HostBashProxy.instance.isAvailable()
+    ) {
+      return {
+        content: `Error: target client "${targetClientId}" is no longer connected. The specified client may have disconnected since the tool was called. Run \`assistant clients list --capability host_bash\` to see currently connected clients.`,
+        isError: true,
+      };
+    }
+
     // Proxy to connected client for execution on the user's machine
     // when a capable client is available (managed/cloud-hosted mode).
-    if (context.hostBashProxy?.isAvailable()) {
+    if (HostBashProxy.instance.isAvailable()) {
       const rawSec =
         typeof input.timeout_seconds === "number"
           ? input.timeout_seconds
@@ -220,12 +277,13 @@ class HostShellTool implements Tool {
 
         const bgId = generateBackgroundToolId();
         const abortController = new AbortController();
-        const proxyPromise = context.hostBashProxy.request(
+        const proxyPromise = HostBashProxy.instance.request(
           {
             command,
             working_dir: rawWorkingDir as string | undefined,
             timeout_seconds: normalizedTimeout,
             env: proxyEnv,
+            targetClientId,
           },
           context.conversationId,
           abortController.signal,
@@ -266,12 +324,13 @@ class HostShellTool implements Tool {
         };
       }
 
-      return context.hostBashProxy.request(
+      return HostBashProxy.instance.request(
         {
           command,
           working_dir: rawWorkingDir as string | undefined,
           timeout_seconds: normalizedTimeout,
           env: proxyEnv,
+          targetClientId,
         },
         context.conversationId,
         context.signal,

package/src/tools/network/script-proxy/index.ts

@@ -1,10 +1 @@
-export {
-  createSession,
-  getActiveSession,
-  getOrStartSession,
-  getSessionEnv,
-  getSessionsForConversation,
-  startSession,
-  stopAllSessions,
-  stopSession,
-} from "./session-manager.js";
+export { getOrStartSession, getSessionEnv } from "./session-manager.js";