nolo-cli 0.1.30 → 0.1.31

package/client/localRuntimeAdapter.ts

@@ -3,8 +3,11 @@ import type {
   AgentRuntimeHostAdapter,
   AgentRuntimeSaveTurnInput,
 } from "../agentRuntimeLocal";
+import { request as httpRequest } from "node:http";
+import { request as httpsRequest } from "node:https";
 import {
   buildLocalWorkspacePolicyToolNames,
+  resolveLocalWorkspaceShellToolExposure,
   buildLocalWorkspaceToolset,
   buildLocalWorkspaceOpenAiTools,
   buildOpenAiCompatibleChatCompletionRequest,
@@ -13,8 +16,11 @@ import {
   parseOpenAiCompatibleChatCompletionResponse,
   parsePlatformChatCompletionData,
   parsePlatformChatCompletionResponse,
+  resolveHostRuntimeConfigFromEnv,
   resolvePlatformChatProviderConfig,
+  resolveRequestedRuntimeToolNames,
   shouldUsePlatformChatProvider,
+  type HostRuntimeConfig,
 } from "../agentRuntimeLocal";
 import type { AgentRuntimeChatMessage } from "../agent-runtime";
 import { getDefaultCliLocalRuntimeDb } from "../localRuntimeDb";
@@ -46,6 +52,29 @@ import {
 type EnvLike = Record<string, string | undefined>;
 type FetchInput = Parameters<typeof fetch>[0];
 type FetchInit = Parameters<typeof fetch>[1];
+type CliLocalRuntimeCliExecution = {
+  text: string;
+  raw?: string;
+  elapsed?: number;
+  warnings?: string[];
+};
+type CliLocalRuntimeCliExecutor = (
+  provider: string,
+  prompt: string,
+  options: {
+    model?: string;
+    timeout?: number;
+    cwd?: string;
+    yolo?: boolean;
+    env?: EnvLike;
+    systemPrompt?: string;
+    reasoningEffort?: "low" | "medium" | "high" | "xhigh" | "max";
+    temperature?: number;
+    topP?: number;
+    frequencyPenalty?: number;
+    maxTokens?: number;
+  }
+) => Promise<CliLocalRuntimeCliExecution>;
 const TRANSIENT_FETCH_MAX_ATTEMPTS = 8;
 const TRANSIENT_FETCH_RETRY_BASE_DELAY_MS = 250;
 
@@ -53,23 +82,34 @@ export type CliLocalRuntimeDb = CliKvDb;
 
 export type CliLocalRuntimeAdapterDeps = {
   env: EnvLike;
+  hostRuntimeConfig?: HostRuntimeConfig;
   db?: CliLocalRuntimeDb;
   store?: HybridRecordStore;
   now?: () => number;
   createId?: () => string;
   fetchImpl?: typeof fetch;
   cwd?: string;
-  useCwdAsTaskWorkspaceBase?: boolean;
   output?: { write(chunk: string): unknown };
   prepareTaskWorktree?: typeof prepareTaskWorktree;
   localToolExecutors?: Record<string, (call: any) => Promise<{ content: string; metadata?: Record<string, unknown> }>>;
+  executeCli?: CliLocalRuntimeCliExecutor;
   sleep?: (ms: number) => Promise<void>;
+  loopbackRequest?: (input: FetchInput, init?: FetchInit) => Promise<Response>;
 };
 
 async function defaultLocalRuntimeDb(): Promise<CliLocalRuntimeDb> {
   return getDefaultCliLocalRuntimeDb();
 }
 
+async function defaultExecuteCli(
+  provider: string,
+  prompt: string,
+  options: Parameters<CliLocalRuntimeCliExecutor>[2]
+) {
+  const { executeCli } = await import("../ai/agent/cliExecutor");
+  return executeCli(provider as any, prompt, options);
+}
+
 function createFallbackId() {
   return `${Date.now().toString(36)}${Math.random().toString(36).slice(2, 10)}`.toUpperCase();
 }
@@ -78,10 +118,6 @@ function resolveLocalUserId(env: EnvLike) {
   return env.NOLO_LOCAL_USER_ID || env.NOLO_USER_ID || "local";
 }
 
-function shellModeEnabled(env: EnvLike) {
-  return ["worktree", "dangerous", "1", "true"].includes(env.NOLO_LOCAL_SHELL_MODE || "");
-}
-
 function parseLocalToolBudgets(env: EnvLike) {
   const raw = env.NOLO_LOCAL_TOOL_BUDGETS?.trim();
   if (!raw) return {};
@@ -122,15 +158,70 @@ function transientFetchRetryDelayMs(attempt: number) {
   return Math.min(attempt * TRANSIENT_FETCH_RETRY_BASE_DELAY_MS, 2_000);
 }
 
+function isLoopbackUrl(input: FetchInput) {
+  try {
+    const target = typeof input === "string" || input instanceof URL
+      ? new URL(String(input))
+      : new URL(input.url);
+    const hostname = target.hostname.toLowerCase();
+    return hostname === "127.0.0.1" || hostname === "localhost" || hostname === "::1";
+  } catch {
+    return false;
+  }
+}
+
+function toNodeRequestBody(body: FetchInit["body"]) {
+  if (typeof body === "string") return Buffer.from(body);
+  if (body instanceof Uint8Array) return Buffer.from(body);
+  if (body instanceof ArrayBuffer) return Buffer.from(body);
+  return null;
+}
+
+async function defaultLoopbackRequest(input: FetchInput, init?: FetchInit) {
+  const target = typeof input === "string" || input instanceof URL
+    ? new URL(String(input))
+    : new URL(input.url);
+  const headers = new Headers(init?.headers);
+  const body = toNodeRequestBody(init?.body);
+  if (body && !headers.has("Content-Length")) {
+    headers.set("Content-Length", String(body.byteLength));
+  }
+  return await new Promise<Response>((resolve, reject) => {
+    const requestImpl = target.protocol === "https:" ? httpsRequest : httpRequest;
+    const req = requestImpl(target, {
+      method: init?.method ?? "GET",
+      headers: Object.fromEntries(headers.entries()),
+    }, (res) => {
+      const chunks: Buffer[] = [];
+      res.on("data", (chunk) => chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)));
+      res.on("end", () => {
+        resolve(new Response(Buffer.concat(chunks), {
+          status: res.statusCode ?? 500,
+          headers: res.headers as Record<string, string>,
+        }));
+      });
+    });
+    req.on("error", reject);
+    if (body) req.write(body);
+    req.end();
+  });
+}
+
 async function fetchWithTransientRetry(
   fetchImpl: typeof fetch,
   input: FetchInput,
   init?: FetchInit,
-  options: { sleep?: (ms: number) => Promise<void> } = {}
+  options: {
+    sleep?: (ms: number) => Promise<void>;
+    loopbackRequest?: (input: FetchInput, init?: FetchInit) => Promise<Response>;
+  } = {}
 ) {
   let lastError: unknown;
   for (let attempt = 1; attempt <= TRANSIENT_FETCH_MAX_ATTEMPTS; attempt += 1) {
     try {
+      if (options.loopbackRequest && isLoopbackUrl(input)) {
+        return await options.loopbackRequest(input, init);
+      }
       return await fetchImpl(input, init);
     } catch (error) {
       if (!isTransientFetchError(error)) throw error;
@@ -143,32 +234,52 @@ async function fetchWithTransientRetry(
   throw lastError;
 }
 
-function buildOpenAiTools(args: { toolNames?: string[]; env: EnvLike }) {
-  const toolset = buildLocalWorkspaceToolsetForEnv(args);
+function buildOpenAiTools(args: {
+  requestedToolNames?: string[];
+  platformToolNames?: string[];
+  hostRuntimeConfig: HostRuntimeConfig;
+}) {
+  const toolset = buildLocalWorkspaceToolsetForHost(args);
   return [
     ...buildLocalWorkspaceOpenAiTools({
       toolNames: toolset.toolNames,
       exposeShellTools: toolset.exposeShellTools,
     }),
-    ...buildServerPlatformOpenAiTools({ toolNames: args.toolNames }),
+    ...buildServerPlatformOpenAiTools({ toolNames: args.platformToolNames }),
   ];
 }
 
-function buildLocalWorkspaceToolsetForEnv(args: { toolNames?: string[]; env: EnvLike }) {
+function buildLocalWorkspaceToolsetForHost(args: {
+  requestedToolNames?: string[];
+  hostRuntimeConfig: HostRuntimeConfig;
+}) {
+  const requestedToolNames = args.requestedToolNames ?? [];
+  const exposeShellTools = resolveLocalWorkspaceShellToolExposure({
+    declaredToolNames: requestedToolNames,
+    hostRuntimeConfig: args.hostRuntimeConfig,
+  });
   const toolset = buildLocalWorkspaceToolset({
-    declaredToolNames: args.toolNames,
-    exposeShellTools: shellModeEnabled(args.env),
+    declaredToolNames: requestedToolNames,
+    exposeShellTools,
   });
   return toolset;
 }
 
-function buildLocalPolicyToolNames(args: { toolNames?: string[]; env: EnvLike }) {
+function buildLocalPolicyToolNames(args: {
+  requestedToolNames?: string[];
+  platformToolNames?: string[];
+  hostRuntimeConfig: HostRuntimeConfig;
+}) {
+  const exposeShellTools = resolveLocalWorkspaceShellToolExposure({
+    declaredToolNames: args.requestedToolNames,
+    hostRuntimeConfig: args.hostRuntimeConfig,
+  });
   return [
     ...buildLocalWorkspacePolicyToolNames({
-      declaredToolNames: args.toolNames,
-      exposeShellTools: shellModeEnabled(args.env),
+      declaredToolNames: args.requestedToolNames,
+      exposeShellTools,
     }),
-    ...((args.toolNames ?? []).includes("taskRun") ? ["taskRun"] : []),
+    ...((args.platformToolNames ?? []).includes("taskRun") ? ["taskRun"] : []),
   ];
 }
 
@@ -254,6 +365,33 @@ function readLocalWorkspaceMode(agentConfig: AgentRuntimeAgentConfig | null) {
   return value === "task-worktree" ? "task-worktree" : "current";
 }
 
+function extractRuntimeMessageText(content: AgentRuntimeChatMessage["content"]) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content
+    .filter((part): part is Extract<typeof part, { type: "text" }> => part?.type === "text")
+    .map((part) => part.text ?? "")
+    .join("");
+}
+
+function buildCliTaskPromptFromMessages(messages: AgentRuntimeChatMessage[]) {
+  const history = messages
+    .filter((message) => message.role === "user" || message.role === "assistant")
+    .map((message) => {
+      const text = extractRuntimeMessageText(message.content).trim();
+      if (!text) return null;
+      return `[${message.role === "user" ? "用户" : "助手"}]\n${text}`;
+    })
+    .filter((message): message is string => Boolean(message))
+    .slice(-6);
+
+  if (history.length === 0) return "";
+  if (history.length === 1 && history[0]?.startsWith("[用户]\n")) {
+    return history[0].slice("[用户]\n".length);
+  }
+  return `请基于以下最近对话继续完成当前任务。\n\n${history.join("\n\n")}`;
+}
+
 async function resolveStore(deps: CliLocalRuntimeAdapterDeps) {
   if (deps.store) return deps.store;
   return createCliHybridRecordStore({
@@ -323,12 +461,19 @@ export function createCliLocalRuntimeAdapter(
   const now = deps.now ?? Date.now;
   const createId = deps.createId ?? createFallbackId;
   const fetchImpl = deps.fetchImpl ?? fetch;
+  const loopbackRequest = deps.loopbackRequest ?? (deps.fetchImpl ? undefined : defaultLoopbackRequest);
+  const executeCli = deps.executeCli ?? defaultExecuteCli;
   const userId = resolveLocalUserId(deps.env);
+  const hostRuntimeConfig = deps.hostRuntimeConfig ?? resolveHostRuntimeConfigFromEnv({
+    env: deps.env,
+    surface: "cli-local",
+    workspaceBinding: "explicit-cwd",
+  });
   const localToolBudgets = parseLocalToolBudgets(deps.env);
   const localToolUsage = new Map<string, number>();
   let activeAgentToolNames: string[] = [];
   let workspaceSession: WorkspaceSession = createWorkspaceSession(
-    deps.useCwdAsTaskWorkspaceBase
+    hostRuntimeConfig.workspaceBinding === "default-cwd"
       ? { defaultCwd: deps.cwd }
       : { cwd: deps.cwd }
   );
@@ -369,9 +514,13 @@ export function createCliLocalRuntimeAdapter(
         store: await resolveStore(deps),
         userId,
       });
+      const requestedToolNames = agentConfig
+        ? resolveRequestedRuntimeToolNames({ agentConfig })
+        : [];
       activeAgentToolNames = buildLocalPolicyToolNames({
-        toolNames: agentConfig?.toolNames,
-        env: deps.env,
+        requestedToolNames,
+        platformToolNames: agentConfig?.toolNames,
+        hostRuntimeConfig,
       });
       await activateAgentWorkspaceSession({ agentRef, agentConfig });
       return agentConfig;
@@ -389,6 +538,48 @@ export function createCliLocalRuntimeAdapter(
       cwd: workspaceSession.workspaceRoot,
     }),
     resolveProvider: async (agentConfig) => {
+      if (agentConfig.apiSource === "cli") {
+        const cliProvider = String(agentConfig.cliProvider || "copilot").trim() || "copilot";
+        return {
+          model: agentConfig.model || cliProvider,
+          complete: async (messages) => {
+            const [firstMessage, ...remainingMessages] = messages;
+            const systemPrompt = firstMessage?.role === "system"
+              ? extractRuntimeMessageText(firstMessage.content).trim()
+              : "";
+            const taskPrompt = buildCliTaskPromptFromMessages(
+              firstMessage?.role === "system" ? remainingMessages : messages
+            );
+            const result = await executeCli(cliProvider, taskPrompt, {
+              ...(agentConfig.model ? { model: agentConfig.model } : {}),
+              cwd: workspaceSession.workspaceRoot,
+              yolo: true,
+              env: deps.env,
+              ...(systemPrompt ? { systemPrompt } : {}),
+              ...(typeof agentConfig.reasoning_effort === "string"
+                ? { reasoningEffort: agentConfig.reasoning_effort as "low" | "medium" | "high" | "xhigh" | "max" }
+                : {}),
+              ...(typeof agentConfig.temperature === "number"
+                ? { temperature: agentConfig.temperature }
+                : {}),
+              ...(typeof agentConfig.top_p === "number" ? { topP: agentConfig.top_p } : {}),
+              ...(typeof agentConfig.frequency_penalty === "number"
+                ? { frequencyPenalty: agentConfig.frequency_penalty }
+                : {}),
+              ...(typeof agentConfig.max_tokens === "number"
+                ? { maxTokens: agentConfig.max_tokens }
+                : {}),
+            });
+            return {
+              content: result.text,
+              model: agentConfig.model || cliProvider,
+              provider: cliProvider,
+              trace: messages,
+            };
+          },
+        };
+      }
+
       if (shouldUsePlatformChatProvider(deps.env, agentConfig)) {
         const providerConfig = resolvePlatformChatProviderConfig({
           agentConfig,
@@ -397,9 +588,11 @@ export function createCliLocalRuntimeAdapter(
         return {
           model: providerConfig.model,
           complete: async (messages) => {
+            const requestedToolNames = resolveRequestedRuntimeToolNames({ agentConfig });
             const tools = buildOpenAiTools({
-              toolNames: agentConfig.toolNames,
-              env: deps.env,
+              requestedToolNames,
+              platformToolNames: agentConfig.toolNames,
+              hostRuntimeConfig,
             });
             const request = buildPlatformChatCompletionRequest({
               providerConfig,
@@ -408,6 +601,7 @@ export function createCliLocalRuntimeAdapter(
             });
             const res = await fetchWithTransientRetry(fetchImpl, request.url, request.init, {
               sleep: deps.sleep,
+              loopbackRequest,
             });
             const data = parsePlatformChatCompletionData(await res.text().catch(() => ""));
             if (!res.ok) {
@@ -429,9 +623,11 @@ export function createCliLocalRuntimeAdapter(
       return {
         model: providerConfig.model,
         complete: async (messages) => {
+          const requestedToolNames = resolveRequestedRuntimeToolNames({ agentConfig });
           const tools = buildOpenAiTools({
-            toolNames: agentConfig.toolNames,
-            env: deps.env,
+            requestedToolNames,
+            platformToolNames: agentConfig.toolNames,
+            hostRuntimeConfig,
           });
           const request = buildOpenAiCompatibleChatCompletionRequest({
             providerConfig,
@@ -440,6 +636,7 @@ export function createCliLocalRuntimeAdapter(
           });
           const res = await fetchWithTransientRetry(fetchImpl, request.url, request.init, {
             sleep: deps.sleep,
+            loopbackRequest,
           });
           const data = await res.json().catch(() => ({}));
           if (!res.ok) {
@@ -461,6 +658,7 @@ export function createCliLocalRuntimeAdapter(
       });
       const result = await executeLocalToolWithPolicy({
         env: deps.env,
+        hostRuntimeConfig,
         agentToolNames: activeAgentToolNames,
         call,
         executors: localToolExecutors,

package/client/localToolPolicy.test.ts

@@ -1,24 +1,47 @@
 import { describe, expect, test } from "bun:test";
 
 import { executeLocalToolWithPolicy, resolveLocalToolPolicy } from "./localToolPolicy";
+import { createHostRuntimeConfig } from "../agent-runtime";
+
+function createCliHostRuntimeConfig(allowShell = false) {
+  return createHostRuntimeConfig({
+    surface: "cli-local",
+    workspaceBinding: "explicit-cwd",
+    allowShell,
+  });
+}
 
 describe("CLI local tool policy", () => {
-  test("allows execShell in explicit worktree shell mode", () => {
+  test("allows execShell when the host grants shell capability", () => {
     expect(resolveLocalToolPolicy({
-      env: { NOLO_LOCAL_SHELL_MODE: "worktree" },
-      agentToolNames: [],
+      env: {},
+      hostRuntimeConfig: createCliHostRuntimeConfig(true),
+      agentToolNames: ["execShell"],
       toolName: "execShell",
     })).toEqual({ allowed: true, toolName: "execShell" });
   });
 
-  test("blocks execShell unless explicit shell mode is enabled", () => {
+  test("blocks execShell unless the host grants shell capability", () => {
     expect(resolveLocalToolPolicy({
       env: { NOLO_LOCAL_ALLOWED_TOOLS: "execShell" },
+      hostRuntimeConfig: createCliHostRuntimeConfig(),
       agentToolNames: ["execShell"],
       toolName: "execShell",
     })).toMatchObject({ allowed: false });
   });
 
+  test("blocks execShell when shell was not requested by the runtime", () => {
+    expect(resolveLocalToolPolicy({
+      env: {},
+      hostRuntimeConfig: createCliHostRuntimeConfig(true),
+      agentToolNames: [],
+      toolName: "execShell",
+    })).toMatchObject({
+      allowed: false,
+      reason: "execShell is not requested by this agent runtime.",
+    });
+  });
+
   test("requires both env allowlist and agent declaration", () => {
     expect(resolveLocalToolPolicy({
       env: { NOLO_LOCAL_ALLOWED_TOOLS: "readFile" },
@@ -36,6 +59,7 @@ describe("CLI local tool policy", () => {
   test("executes only registered tools after policy allows them", async () => {
     const result = await executeLocalToolWithPolicy({
       env: { NOLO_LOCAL_ALLOWED_TOOLS: "readFile" },
+      hostRuntimeConfig: createCliHostRuntimeConfig(),
       agentToolNames: ["readFile"],
       call: { id: "call-1", name: "readFile", arguments: "{\"path\":\"README.md\"}" },
       executors: {

package/connector-experimental/daemonLauncher.ts

@@ -127,8 +127,42 @@ export function resolveDaemonLogPath(env: ConnectorDaemonEnv) {
   return env.NOLO_CONNECT_LOG || join(homedir(), ".nolo", "logs", "connector.log");
 }
 
-export function buildDaemonCommand(cliEntrypointPath: string | undefined, fallbackEntrypointPath = import.meta.path) {
-  return [process.execPath, cliEntrypointPath || fallbackEntrypointPath, "connect", "--ws"];
+export function buildConnectorDaemonEnv(env: ConnectorDaemonEnv, cwd: string) {
+  return {
+    ...env,
+    NOLO_CONNECTOR_WORKDIR: env.NOLO_CONNECTOR_WORKDIR?.trim() || cwd,
+    NOLO_AGENT_WORKDIR: env.NOLO_AGENT_WORKDIR?.trim() || cwd,
+    NOLO_LOCAL_WORKTREE: env.NOLO_LOCAL_WORKTREE?.trim() || cwd,
+  };
+}
+
+function firstNonEmptyValue(...values: Array<string | undefined>) {
+  for (const value of values) {
+    if (typeof value === "string" && value.trim()) return value.trim();
+  }
+  return "";
+}
+
+export function buildDaemonCommand(
+  cliEntrypointPath: string | undefined,
+  env: ConnectorDaemonEnv,
+  fallbackEntrypointPath = import.meta.path,
+) {
+  const command = [process.execPath, cliEntrypointPath || fallbackEntrypointPath, "connect", "--ws"];
+  const serverUrl = firstNonEmptyValue(env.NOLO_SERVER, env.NOLO_SERVER_URL, env.BASE_URL);
+  const authToken = firstNonEmptyValue(
+    env.NOLO_MACHINE_API_KEY,
+    env.AUTH_TOKEN,
+    env.AUTH,
+    env.BENCHMARK_AUTH_TOKEN,
+  );
+  if (serverUrl) {
+    command.push("--server-url", serverUrl);
+  }
+  if (authToken) {
+    command.push("--api-key", authToken);
+  }
+  return command;
 }
 
 export function defaultSpawnDaemon(args: {
@@ -179,9 +213,9 @@ export async function runConnectorDaemon(deps: ConnectorDaemonDeps = {}) {
 
   const logPath = resolveDaemonLogPath(env);
   const result = (deps.spawnDaemon ?? defaultSpawnDaemon)({
-    cmd: buildDaemonCommand(deps.cliEntrypointPath, deps.fallbackEntrypointPath),
+    cmd: buildDaemonCommand(deps.cliEntrypointPath, env, deps.fallbackEntrypointPath),
     cwd,
-    env,
+    env: buildConnectorDaemonEnv(env, cwd),
     logPath,
   });
   output.write(`Connector daemon started${result.pid ? ` pid=${result.pid}` : ""}. Log: ${logPath}\n`);

package/connectorRunArtifact.ts

@@ -24,22 +24,46 @@ function normalizePath(value: string) {
   return resolve(value.trim());
 }
 
+function resolveExistingCandidate(
+  value: string | undefined,
+  checked: string[],
+  label: string
+) {
+  const trimmed = value?.trim();
+  if (!trimmed) return null;
+  const normalized = normalizePath(trimmed);
+  if (existsSync(normalized)) return normalized;
+  checked.push(`${label}=${normalized}`);
+  return null;
+}
+
 export function resolveConnectorRunCwd(args: {
   env?: EnvLike;
   policy: MachineRunPermissionPolicy;
   fallbackCwd?: string;
 }) {
-  const explicit =
-    args.env?.NOLO_CONNECTOR_WORKDIR ||
-    args.env?.NOLO_AGENT_WORKDIR ||
-    args.env?.NOLO_LOCAL_WORKTREE ||
-    "";
-  const candidate = explicit || args.policy.writableRoots[0] || args.fallbackCwd || process.cwd();
-  const cwd = normalizePath(candidate);
-  if (!existsSync(cwd)) {
-    throw new Error(`Connector run cwd does not exist: ${cwd}`);
+  const checked: string[] = [];
+  const candidates: Array<[string | undefined, string]> = [
+    [args.env?.NOLO_CONNECTOR_WORKDIR, "NOLO_CONNECTOR_WORKDIR"],
+    [args.env?.NOLO_AGENT_WORKDIR, "NOLO_AGENT_WORKDIR"],
+    [args.env?.NOLO_LOCAL_WORKTREE, "NOLO_LOCAL_WORKTREE"],
+    [args.policy.writableRoots[0], "writableRoots[0]"],
+    [args.fallbackCwd, "fallbackCwd"],
+    [process.env.PWD, "PWD"],
+    [process.cwd(), "process.cwd()"],
+  ];
+
+  for (const [value, label] of candidates) {
+    const resolved = resolveExistingCandidate(value, checked, label);
+    if (resolved) return resolved;
+  }
+
+  if (checked.length > 0) {
+    throw new Error(
+      `Connector run cwd does not exist. Checked: ${checked.join(", ")}`
+    );
   }
-  return cwd;
+  throw new Error("Connector run cwd could not be resolved.");
 }
 
 async function runGit(

package/connectorWebSocketTarget.ts

@@ -15,14 +15,18 @@ export function isConnectorWebSocketAuthError(error: unknown): error is Connecto
 export async function resolveConnectorWebSocketTarget(input: {
   serverUrl: string;
   machineId: string;
-  headers: Record<string, string>;
-  fetchImpl?: typeof fetch;
-}) {
+  connectorSurface?: string;
+  headers: Record<string, string>;
+  fetchImpl?: typeof fetch;
+}) {
   const directWsUrl = new URL(input.serverUrl);
   directWsUrl.protocol = directWsUrl.protocol === "https:" ? "wss:" : "ws:";
   directWsUrl.pathname = "/api/connector/ws";
-  directWsUrl.search = "";
-  directWsUrl.searchParams.set("machineId", input.machineId);
+  directWsUrl.search = "";
+  directWsUrl.searchParams.set("machineId", input.machineId);
+  if (input.connectorSurface?.trim()) {
+    directWsUrl.searchParams.set("connectorSurface", input.connectorSurface.trim().toLowerCase());
+  }
 
   const probeUrl = new URL(input.serverUrl);
   probeUrl.pathname = "/api/connector/ws";