@wrongstack/acp 1.0.24 → 1.0.27

package/dist/index.js

@@ -991,6 +991,16 @@ import {
 var DEFAULT_MAX_FRAME_CHARS = 20 * 1024 * 1024;
 var DEFAULT_MAX_QUEUED_MESSAGES = 1e3;
 var DEFAULT_MAX_QUEUED_CHARS = 32 * 1024 * 1024;
+function takeLines(pending, chunk) {
+  const lines = [];
+  let start = 0;
+  for (let nl = chunk.indexOf("\n"); nl !== -1; nl = chunk.indexOf("\n", start)) {
+    lines.push(pending + chunk.slice(start, nl));
+    pending = "";
+    start = nl + 1;
+  }
+  return { lines, pending: pending + chunk.slice(start) };
+}
 function positiveLimit(value, fallback) {
   return value !== void 0 && Number.isFinite(value) && value > 0 ? Math.floor(value) : fallback;
 }
@@ -1078,9 +1088,8 @@ var StdioTransport = class {
     this.claimHandlers.clear();
   }
   onData(chunk) {
-    this.buffer += chunk;
-    const lines = this.buffer.split("\n");
-    this.buffer = lines.pop() ?? "";
+    const { lines, pending } = takeLines(this.buffer, chunk);
+    this.buffer = pending;
     if (this.buffer.length > this.maxFrameChars) {
       this.stderr.write(
         `[wstack-acp frame error] pending frame exceeds ${this.maxFrameChars} characters
@@ -1320,9 +1329,8 @@ var ClientTransport = class {
     this.child = null;
   }
   onChildData(chunk) {
-    this.buffer += chunk;
-    const lines = this.buffer.split("\n");
-    this.buffer = lines.pop() ?? "";
+    const { lines, pending } = takeLines(this.buffer, chunk);
+    this.buffer = pending;
     if (this.buffer.length > this.maxFrameChars) {
       writeErr(`[acp-child pending frame exceeds ${this.maxFrameChars} characters]
 `);
@@ -1858,6 +1866,324 @@ function isBestEffortAckMethod(method) {
   return method === "mcp/connect" || method === "mcp/message" || method === "mcp/disconnect" || method === "elicitation/create" || method === "elicitation/complete";
 }
 
+// src/client/acp-session-errors.ts
+var ACPSessionError = class extends Error {
+  kind;
+  cause;
+  constructor(kind, message, cause) {
+    super(message);
+    this.name = "ACPSessionError";
+    this.kind = kind;
+    this.cause = cause;
+  }
+};
+function isJsonRpcError(v) {
+  return typeof v === "object" && v !== null && typeof v.code === "number" && typeof v.message === "string";
+}
+function isAuthRequiredError(err) {
+  const message = err instanceof Error ? err.message : String(err);
+  if (/auth(_|-)?required|authentication required/i.test(message)) return true;
+  const cause = err instanceof ACPSessionError ? err.cause : err && typeof err === "object" && "cause" in err ? err.cause : err;
+  if (!cause || typeof cause !== "object") return false;
+  const data = cause.data;
+  if (data === "auth_required" || data === "AUTH_REQUIRED") return true;
+  if (data && typeof data === "object") {
+    const d = data;
+    if (d.authRequired === true) return true;
+    if (d.code === "auth_required" || d.code === "AUTH_REQUIRED") return true;
+  }
+  return false;
+}
+
+// src/client/acp-session-ops.ts
+function filterMcpServers(agentCapabilities, servers) {
+  if (!servers || servers.length === 0) return [];
+  const mcpCaps = agentCapabilities.mcpCapabilities ?? {};
+  return servers.filter((s) => {
+    if ("type" in s && s.type === "http") return mcpCaps.http === true;
+    if ("type" in s && s.type === "sse") return mcpCaps.sse === true;
+    return true;
+  });
+}
+async function executeLoadSession(ctx, sessionId, mcpServers, cwd) {
+  if (ctx.closed) throw new ACPSessionError("closed", "session is closed");
+  if (!ctx.agentCapabilities.loadSession) {
+    throw new ACPSessionError(
+      "unsupported_capability",
+      "agent does not support session/load (loadSession capability not advertised)"
+    );
+  }
+  if (ctx.sessionId && ctx.sessionId !== sessionId) {
+    await ctx.closeSession();
+  }
+  ctx.resetScratch();
+  const servers = filterMcpServers(ctx.agentCapabilities, mcpServers ?? ctx.opts.mcpServers);
+  const id = ctx.allocId();
+  const result = await ctx.sendRequest(id, "session/load", {
+    sessionId,
+    cwd: cwd ?? ctx.opts.cwd ?? ctx.opts.projectRoot,
+    mcpServers: servers
+  });
+  if (isJsonRpcError(result)) {
+    throw new ACPSessionError("prompt_failed", `session/load failed: ${result.message}`, result);
+  }
+  ctx.setSessionId(sessionId);
+}
+async function executeResumeSession(ctx, sessionId, mcpServers, cwd) {
+  if (ctx.closed) throw new ACPSessionError("closed", "session is closed");
+  if (!ctx.agentCapabilities.sessionCapabilities?.resume) {
+    throw new ACPSessionError(
+      "unsupported_capability",
+      "agent does not support session/resume (sessionCapabilities.resume not advertised)"
+    );
+  }
+  if (ctx.sessionId && ctx.sessionId !== sessionId) {
+    await ctx.closeSession();
+  }
+  const servers = filterMcpServers(ctx.agentCapabilities, mcpServers ?? ctx.opts.mcpServers);
+  const id = ctx.allocId();
+  const result = await ctx.sendRequest(id, "session/resume", {
+    sessionId,
+    cwd: cwd ?? ctx.opts.cwd ?? ctx.opts.projectRoot,
+    mcpServers: servers
+  });
+  if (isJsonRpcError(result)) {
+    throw new ACPSessionError("prompt_failed", `session/resume failed: ${result.message}`, result);
+  }
+  ctx.setSessionId(sessionId);
+}
+async function executeListSessions(ctx, cursor, cwd) {
+  if (ctx.closed) throw new ACPSessionError("closed", "session is closed");
+  if (!ctx.agentCapabilities.sessionCapabilities?.list) {
+    throw new ACPSessionError(
+      "unsupported_capability",
+      "agent does not support session/list (sessionCapabilities.list not advertised)"
+    );
+  }
+  const id = ctx.allocId();
+  const params = {};
+  if (cursor !== void 0) params.cursor = cursor;
+  if (cwd !== void 0) params.cwd = cwd;
+  const result = await ctx.sendRequest(id, "session/list", params);
+  if (isJsonRpcError(result)) {
+    throw new ACPSessionError("prompt_failed", `session/list failed: ${result.message}`, result);
+  }
+  const r = result;
+  return {
+    sessions: r.sessions ?? [],
+    nextCursor: r.nextCursor
+  };
+}
+async function executeDeleteSession(ctx, sessionId) {
+  if (ctx.closed) throw new ACPSessionError("closed", "session is closed");
+  if (!ctx.agentCapabilities.sessionCapabilities?.delete) {
+    throw new ACPSessionError(
+      "unsupported_capability",
+      "agent does not support session/delete (sessionCapabilities.delete not advertised)"
+    );
+  }
+  const id = ctx.allocId();
+  const result = await ctx.sendRequest(id, "session/delete", { sessionId });
+  if (isJsonRpcError(result)) {
+    throw new ACPSessionError("prompt_failed", `session/delete failed: ${result.message}`, result);
+  }
+  if (ctx.sessionId === sessionId) {
+    ctx.setSessionId(null);
+  }
+}
+async function executeForkSession(ctx, sourceSessionId, cwd, mcpServers) {
+  if (ctx.closed) throw new ACPSessionError("closed", "session is closed");
+  const servers = filterMcpServers(ctx.agentCapabilities, mcpServers ?? ctx.opts.mcpServers);
+  const id = ctx.allocId();
+  const result = await ctx.sendRequest(id, "session/fork", {
+    sessionId: sourceSessionId,
+    cwd: cwd ?? ctx.opts.cwd ?? ctx.opts.projectRoot,
+    ...servers.length > 0 ? { mcpServers: servers } : {}
+  });
+  if (isJsonRpcError(result)) {
+    throw new ACPSessionError("prompt_failed", `session/fork failed: ${result.message}`, result);
+  }
+  const newId = result.sessionId;
+  if (typeof newId !== "string" || !newId) {
+    throw new ACPSessionError("protocol_error", "session/fork returned no sessionId", result);
+  }
+  return newId;
+}
+async function executeSetMode(ctx, sessionId, modeId) {
+  if (ctx.closed) throw new ACPSessionError("closed", "session is closed");
+  const id = ctx.allocId();
+  const result = await ctx.sendRequest(id, "session/set_mode", { sessionId, modeId });
+  if (isJsonRpcError(result)) {
+    throw new ACPSessionError(
+      "prompt_failed",
+      `session/set_mode failed: ${result.message}`,
+      result
+    );
+  }
+}
+async function executeSetConfigOption(ctx, sessionId, configId, value) {
+  if (ctx.closed) throw new ACPSessionError("closed", "session is closed");
+  const id = ctx.allocId();
+  const result = await ctx.sendRequest(id, "session/set_config_option", {
+    sessionId,
+    configId,
+    value
+  });
+  if (isJsonRpcError(result)) {
+    throw new ACPSessionError(
+      "prompt_failed",
+      `session/set_config_option failed: ${result.message}`,
+      result
+    );
+  }
+}
+async function executeListProviders(ctx) {
+  if (ctx.closed) throw new ACPSessionError("closed", "session is closed");
+  const id = ctx.allocId();
+  const result = await ctx.sendRequest(id, "providers/list", {});
+  if (isJsonRpcError(result)) {
+    throw new ACPSessionError("prompt_failed", `providers/list failed: ${result.message}`, result);
+  }
+  const r = result;
+  return { providers: r.providers ?? [], currentProviderId: r.currentProviderId ?? null };
+}
+async function executeSetProvider(ctx, providerId, config) {
+  if (ctx.closed) throw new ACPSessionError("closed", "session is closed");
+  const id = ctx.allocId();
+  const result = await ctx.sendRequest(id, "providers/set", { providerId, ...config ?? {} });
+  if (isJsonRpcError(result)) {
+    throw new ACPSessionError("prompt_failed", `providers/set failed: ${result.message}`, result);
+  }
+}
+async function executeDisableProvider(ctx) {
+  if (ctx.closed) throw new ACPSessionError("closed", "session is closed");
+  const id = ctx.allocId();
+  const result = await ctx.sendRequest(id, "providers/disable", {});
+  if (isJsonRpcError(result)) {
+    throw new ACPSessionError(
+      "prompt_failed",
+      `providers/disable failed: ${result.message}`,
+      result
+    );
+  }
+}
+async function executeMcpMessage(ctx, connectionId, message) {
+  if (ctx.closed) throw new ACPSessionError("closed", "session is closed");
+  const id = ctx.allocId();
+  const result = await ctx.sendRequest(id, "mcp/message", { connectionId, message });
+  if (isJsonRpcError(result)) {
+    throw new ACPSessionError("prompt_failed", `mcp/message failed: ${result.message}`, result);
+  }
+  return result;
+}
+async function executeCreateSession(ctx) {
+  const servers = filterMcpServers(ctx.agentCapabilities, ctx.opts.mcpServers);
+  const id = ctx.allocId();
+  const result = await ctx.sendRequest(id, "session/new", {
+    cwd: ctx.opts.cwd ?? ctx.opts.projectRoot,
+    mcpServers: servers
+  });
+  if (isJsonRpcError(result)) {
+    throw new ACPSessionError(
+      "session_create_failed",
+      `session/new failed: ${result.message}`,
+      result
+    );
+  }
+  const sessionId = result.sessionId;
+  if (typeof sessionId !== "string" || sessionId.length === 0) {
+    throw new ACPSessionError("protocol_error", "session/new returned no sessionId", result);
+  }
+  return sessionId;
+}
+
+// src/client/acp-session-auth.ts
+async function authenticate(host, methodId) {
+  if (host.state === "closed") {
+    throw new ACPSessionError("closed", "session is closed");
+  }
+  if (host.state !== "ready" && host.state !== "authenticated") {
+    throw new ACPSessionError(
+      "protocol_error",
+      `authenticate called in state=${host.state} (expected 'ready')`
+    );
+  }
+  if (host.state === "authenticated") return;
+  if (!host.authMethods.some((m) => m.id === methodId)) {
+    throw new ACPSessionError(
+      "auth_failed",
+      `auth method "${methodId}" not in advertised methods: ${host.authMethods.map((m) => m.id).join(", ")}`
+    );
+  }
+  if (host.authMethods.find((m) => m.id === methodId)?.type === "terminal") {
+    throw new ACPSessionError(
+      "auth_failed",
+      "Terminal authentication requires interactive login followed by reconnect; it cannot use authenticate"
+    );
+  }
+  const id = host.allocId();
+  const result = await host.sendRequest(id, "authenticate", { methodId });
+  if (isJsonRpcError(result)) {
+    throw new ACPSessionError("auth_failed", `authenticate failed: ${result.message}`, result);
+  }
+  host.state = "authenticated";
+}
+async function logout(host) {
+  if (host.state === "closed") {
+    throw new ACPSessionError("closed", "session is closed");
+  }
+  if (!host.agentCapabilities.auth?.logout) {
+    throw new ACPSessionError(
+      "unsupported_capability",
+      "agent does not support logout (auth.logout capability not advertised)"
+    );
+  }
+  const id = host.allocId();
+  const result = await host.sendRequest(id, "logout", {});
+  if (isJsonRpcError(result)) {
+    throw new ACPSessionError("logout_failed", `logout failed: ${result.message}`, result);
+  }
+  host.state = "ready";
+}
+async function createSessionWithAuth(host) {
+  try {
+    return await executeCreateSession(host.opContext());
+  } catch (err) {
+    if (host.state === "authenticated" || !isAuthRequiredError(err)) {
+      throw err instanceof ACPSessionError ? err : new ACPSessionError(
+        "session_create_failed",
+        err instanceof Error ? err.message : String(err),
+        err
+      );
+    }
+    await host.ensureAuthenticated();
+    return executeCreateSession(host.opContext());
+  }
+}
+async function ensureAuthenticated(host) {
+  if (host.state === "authenticated") return;
+  if (host.authMethods.length === 0) {
+    throw new ACPSessionError(
+      "auth_failed",
+      "This agent requires authentication before a session can start, but advertised no authMethods. Log into the CLI, then retry."
+    );
+  }
+  const inProcess = host.authMethods.find(
+    (m) => m.type === void 0 || m.type === "agent" || m.type === "oauth" || m.type === "http"
+  );
+  if (inProcess) {
+    await host.authenticate(inProcess.id);
+    return;
+  }
+  const terminal = host.authMethods.find((m) => m.type === "terminal");
+  const setupArgs = terminal?.args?.length ? terminal.args.join(" ") : void 0;
+  const setup = setupArgs !== void 0 ? `${host.opts.command}${host.opts.args?.length ? ` ${host.opts.args.join(" ")}` : ""} ${setupArgs}` : `${host.opts.command}${host.opts.args?.length ? ` ${host.opts.args.join(" ")}` : ""}`;
+  throw new ACPSessionError(
+    "auth_failed",
+    `This agent requires a terminal login before ACP can start. Run \`${setup}\` (or the CLI's /login), then retry.`
+  );
+}
+
 // src/client/file-server.ts
 import { randomBytes } from "node:crypto";
 import { realpathSync } from "node:fs";
@@ -2222,344 +2548,113 @@ async function handleAcpTerminalRequest(msg, terminalServer, permissionPolicy, s
         await sender.sendErrorResponse(id, -32601, `unknown method: ${msg.method}`);
     }
   } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    await sender.sendErrorResponse(id, -32603, message);
-  }
-}
-async function authorizeAcpCallback(permissionPolicy, partial, callbackOptions) {
-  try {
-    const outcome = await runPermissionWithDeadline(
-      permissionPolicy,
-      {
-        toolCall: {
-          sessionUpdate: "tool_call_update",
-          toolCallId: partial.toolCallId,
-          title: partial.title,
-          kind: partial.kind,
-          status: "pending",
-          rawInput: partial.rawInput
-        },
-        options: [
-          { optionId: "allow", name: "Allow", kind: "allow_once" },
-          { optionId: "reject", name: "Reject", kind: "reject_once" }
-        ]
-      },
-      callbackOptions
-    );
-    return outcome.outcome === "selected" && outcome.optionId !== "reject" && outcome.optionId !== "reject_once" && outcome.optionId !== "reject_always" ? "allowed" : "denied";
-  } catch (err) {
-    return isAbortLikeError(err) ? "cancelled" : "denied";
-  }
-}
-async function runPermissionWithDeadline(permissionPolicy, call, callbackOptions) {
-  const timeoutMs = resolvePermissionDeadline(callbackOptions.permissionTimeoutMs);
-  const controller = new AbortController();
-  const abort = () => controller.abort();
-  const timer = timeoutMs === null ? null : setTimeout(abort, timeoutMs);
-  let removeAbort;
-  if (callbackOptions.signal) {
-    if (callbackOptions.signal.aborted) {
-      abort();
-    } else {
-      callbackOptions.signal.addEventListener("abort", abort, { once: true });
-      removeAbort = () => callbackOptions.signal?.removeEventListener("abort", abort);
-    }
-  }
-  try {
-    return await Promise.race([
-      permissionPolicy({
-        toolCall: call.toolCall,
-        options: call.options,
-        signal: controller.signal
-      }),
-      rejectOnAbort(controller.signal)
-    ]);
-  } finally {
-    if (timer !== null) clearTimeout(timer);
-    removeAbort?.();
-  }
-}
-function rejectOnAbort(signal) {
-  return new Promise((_, reject) => {
-    const rejectAbort = () => reject(new Error("permission request cancelled or timed out"));
-    if (signal.aborted) {
-      rejectAbort();
-      return;
-    }
-    signal.addEventListener("abort", rejectAbort, { once: true });
-  });
-}
-function isAbortLikeError(err) {
-  return err instanceof Error && /cancelled|canceled|timed out|aborted/i.test(err.message);
-}
-function resolvePermissionDeadline(value) {
-  if (value === Number.POSITIVE_INFINITY) return null;
-  if (value !== void 0 && Number.isFinite(value) && value > 0) return Math.trunc(value);
-  return DEFAULT_PERMISSION_TIMEOUT_MS;
-}
-
-// src/client/acp-session-content.ts
-function textContent(text) {
-  return { type: "text", text };
-}
-function imageContent(mimeType, data) {
-  return { type: "image", mimeType, data };
-}
-function audioContent(mimeType, data) {
-  return { type: "audio", mimeType, data };
-}
-function extractText(block) {
-  if (typeof block !== "object" || block === null) return "";
-  const b = block;
-  if (b.type === "text" && typeof b.text === "string") return b.text;
-  if (b.type === "resource" && b.resource && typeof b.resource === "object" && typeof b.resource.text === "string") {
-    return b.resource.text;
-  }
-  return "";
-}
-function isRecord(v) {
-  return typeof v === "object" && v !== null && !Array.isArray(v);
-}
-function emptyRunResult(stopReason) {
-  return {
-    text: "",
-    stopReason,
-    hasText: false,
-    toolCalls: [],
-    diffs: [],
-    thoughts: ""
-  };
-}
-
-// src/client/acp-session-errors.ts
-var ACPSessionError = class extends Error {
-  kind;
-  cause;
-  constructor(kind, message, cause) {
-    super(message);
-    this.name = "ACPSessionError";
-    this.kind = kind;
-    this.cause = cause;
-  }
-};
-function isJsonRpcError(v) {
-  return typeof v === "object" && v !== null && typeof v.code === "number" && typeof v.message === "string";
-}
-function isAuthRequiredError(err) {
-  const message = err instanceof Error ? err.message : String(err);
-  if (/auth(_|-)?required|authentication required/i.test(message)) return true;
-  const cause = err instanceof ACPSessionError ? err.cause : err && typeof err === "object" && "cause" in err ? err.cause : err;
-  if (!cause || typeof cause !== "object") return false;
-  const data = cause.data;
-  if (data === "auth_required" || data === "AUTH_REQUIRED") return true;
-  if (data && typeof data === "object") {
-    const d = data;
-    if (d.authRequired === true) return true;
-    if (d.code === "auth_required" || d.code === "AUTH_REQUIRED") return true;
-  }
-  return false;
-}
-
-// src/client/acp-session-ops.ts
-function filterMcpServers(agentCapabilities, servers) {
-  if (!servers || servers.length === 0) return [];
-  const mcpCaps = agentCapabilities.mcpCapabilities ?? {};
-  return servers.filter((s) => {
-    if ("type" in s && s.type === "http") return mcpCaps.http === true;
-    if ("type" in s && s.type === "sse") return mcpCaps.sse === true;
-    return true;
-  });
-}
-async function executeLoadSession(ctx, sessionId, mcpServers, cwd) {
-  if (ctx.closed) throw new ACPSessionError("closed", "session is closed");
-  if (!ctx.agentCapabilities.loadSession) {
-    throw new ACPSessionError(
-      "unsupported_capability",
-      "agent does not support session/load (loadSession capability not advertised)"
-    );
-  }
-  if (ctx.sessionId && ctx.sessionId !== sessionId) {
-    await ctx.closeSession();
-  }
-  ctx.resetScratch();
-  const servers = filterMcpServers(ctx.agentCapabilities, mcpServers ?? ctx.opts.mcpServers);
-  const id = ctx.allocId();
-  const result = await ctx.sendRequest(id, "session/load", {
-    sessionId,
-    cwd: cwd ?? ctx.opts.cwd ?? ctx.opts.projectRoot,
-    mcpServers: servers
-  });
-  if (isJsonRpcError(result)) {
-    throw new ACPSessionError("prompt_failed", `session/load failed: ${result.message}`, result);
-  }
-  ctx.setSessionId(sessionId);
-}
-async function executeResumeSession(ctx, sessionId, mcpServers, cwd) {
-  if (ctx.closed) throw new ACPSessionError("closed", "session is closed");
-  if (!ctx.agentCapabilities.sessionCapabilities?.resume) {
-    throw new ACPSessionError(
-      "unsupported_capability",
-      "agent does not support session/resume (sessionCapabilities.resume not advertised)"
-    );
-  }
-  if (ctx.sessionId && ctx.sessionId !== sessionId) {
-    await ctx.closeSession();
-  }
-  const servers = filterMcpServers(ctx.agentCapabilities, mcpServers ?? ctx.opts.mcpServers);
-  const id = ctx.allocId();
-  const result = await ctx.sendRequest(id, "session/resume", {
-    sessionId,
-    cwd: cwd ?? ctx.opts.cwd ?? ctx.opts.projectRoot,
-    mcpServers: servers
-  });
-  if (isJsonRpcError(result)) {
-    throw new ACPSessionError("prompt_failed", `session/resume failed: ${result.message}`, result);
-  }
-  ctx.setSessionId(sessionId);
-}
-async function executeListSessions(ctx, cursor, cwd) {
-  if (ctx.closed) throw new ACPSessionError("closed", "session is closed");
-  if (!ctx.agentCapabilities.sessionCapabilities?.list) {
-    throw new ACPSessionError(
-      "unsupported_capability",
-      "agent does not support session/list (sessionCapabilities.list not advertised)"
-    );
-  }
-  const id = ctx.allocId();
-  const params = {};
-  if (cursor !== void 0) params.cursor = cursor;
-  if (cwd !== void 0) params.cwd = cwd;
-  const result = await ctx.sendRequest(id, "session/list", params);
-  if (isJsonRpcError(result)) {
-    throw new ACPSessionError("prompt_failed", `session/list failed: ${result.message}`, result);
+    const message = err instanceof Error ? err.message : String(err);
+    await sender.sendErrorResponse(id, -32603, message);
   }
-  const r = result;
-  return {
-    sessions: r.sessions ?? [],
-    nextCursor: r.nextCursor
-  };
 }
-async function executeDeleteSession(ctx, sessionId) {
-  if (ctx.closed) throw new ACPSessionError("closed", "session is closed");
-  if (!ctx.agentCapabilities.sessionCapabilities?.delete) {
-    throw new ACPSessionError(
-      "unsupported_capability",
-      "agent does not support session/delete (sessionCapabilities.delete not advertised)"
+async function authorizeAcpCallback(permissionPolicy, partial, callbackOptions) {
+  try {
+    const outcome = await runPermissionWithDeadline(
+      permissionPolicy,
+      {
+        toolCall: {
+          sessionUpdate: "tool_call_update",
+          toolCallId: partial.toolCallId,
+          title: partial.title,
+          kind: partial.kind,
+          status: "pending",
+          rawInput: partial.rawInput
+        },
+        options: [
+          { optionId: "allow", name: "Allow", kind: "allow_once" },
+          { optionId: "reject", name: "Reject", kind: "reject_once" }
+        ]
+      },
+      callbackOptions
     );
+    return outcome.outcome === "selected" && outcome.optionId !== "reject" && outcome.optionId !== "reject_once" && outcome.optionId !== "reject_always" ? "allowed" : "denied";
+  } catch (err) {
+    return isAbortLikeError(err) ? "cancelled" : "denied";
   }
-  const id = ctx.allocId();
-  const result = await ctx.sendRequest(id, "session/delete", { sessionId });
-  if (isJsonRpcError(result)) {
-    throw new ACPSessionError("prompt_failed", `session/delete failed: ${result.message}`, result);
+}
+async function runPermissionWithDeadline(permissionPolicy, call, callbackOptions) {
+  const timeoutMs = resolvePermissionDeadline(callbackOptions.permissionTimeoutMs);
+  const controller = new AbortController();
+  const abort = () => controller.abort();
+  const timer = timeoutMs === null ? null : setTimeout(abort, timeoutMs);
+  let removeAbort;
+  if (callbackOptions.signal) {
+    if (callbackOptions.signal.aborted) {
+      abort();
+    } else {
+      callbackOptions.signal.addEventListener("abort", abort, { once: true });
+      removeAbort = () => callbackOptions.signal?.removeEventListener("abort", abort);
+    }
   }
-  if (ctx.sessionId === sessionId) {
-    ctx.setSessionId(null);
+  try {
+    return await Promise.race([
+      permissionPolicy({
+        toolCall: call.toolCall,
+        options: call.options,
+        signal: controller.signal
+      }),
+      rejectOnAbort(controller.signal)
+    ]);
+  } finally {
+    if (timer !== null) clearTimeout(timer);
+    removeAbort?.();
   }
 }
-async function executeForkSession(ctx, sourceSessionId, cwd, mcpServers) {
-  if (ctx.closed) throw new ACPSessionError("closed", "session is closed");
-  const servers = filterMcpServers(ctx.agentCapabilities, mcpServers ?? ctx.opts.mcpServers);
-  const id = ctx.allocId();
-  const result = await ctx.sendRequest(id, "session/fork", {
-    sessionId: sourceSessionId,
-    cwd: cwd ?? ctx.opts.cwd ?? ctx.opts.projectRoot,
-    ...servers.length > 0 ? { mcpServers: servers } : {}
+function rejectOnAbort(signal) {
+  return new Promise((_, reject) => {
+    const rejectAbort = () => reject(new Error("permission request cancelled or timed out"));
+    if (signal.aborted) {
+      rejectAbort();
+      return;
+    }
+    signal.addEventListener("abort", rejectAbort, { once: true });
   });
-  if (isJsonRpcError(result)) {
-    throw new ACPSessionError("prompt_failed", `session/fork failed: ${result.message}`, result);
-  }
-  const newId = result.sessionId;
-  if (typeof newId !== "string" || !newId) {
-    throw new ACPSessionError("protocol_error", "session/fork returned no sessionId", result);
-  }
-  return newId;
 }
-async function executeSetMode(ctx, sessionId, modeId) {
-  if (ctx.closed) throw new ACPSessionError("closed", "session is closed");
-  const id = ctx.allocId();
-  const result = await ctx.sendRequest(id, "session/set_mode", { sessionId, modeId });
-  if (isJsonRpcError(result)) {
-    throw new ACPSessionError(
-      "prompt_failed",
-      `session/set_mode failed: ${result.message}`,
-      result
-    );
-  }
+function isAbortLikeError(err) {
+  return err instanceof Error && /cancelled|canceled|timed out|aborted/i.test(err.message);
 }
-async function executeSetConfigOption(ctx, sessionId, configId, value) {
-  if (ctx.closed) throw new ACPSessionError("closed", "session is closed");
-  const id = ctx.allocId();
-  const result = await ctx.sendRequest(id, "session/set_config_option", {
-    sessionId,
-    configId,
-    value
-  });
-  if (isJsonRpcError(result)) {
-    throw new ACPSessionError(
-      "prompt_failed",
-      `session/set_config_option failed: ${result.message}`,
-      result
-    );
-  }
+function resolvePermissionDeadline(value) {
+  if (value === Number.POSITIVE_INFINITY) return null;
+  if (value !== void 0 && Number.isFinite(value) && value > 0) return Math.trunc(value);
+  return DEFAULT_PERMISSION_TIMEOUT_MS;
 }
-async function executeListProviders(ctx) {
-  if (ctx.closed) throw new ACPSessionError("closed", "session is closed");
-  const id = ctx.allocId();
-  const result = await ctx.sendRequest(id, "providers/list", {});
-  if (isJsonRpcError(result)) {
-    throw new ACPSessionError("prompt_failed", `providers/list failed: ${result.message}`, result);
-  }
-  const r = result;
-  return { providers: r.providers ?? [], currentProviderId: r.currentProviderId ?? null };
+
+// src/client/acp-session-content.ts
+function textContent(text) {
+  return { type: "text", text };
 }
-async function executeSetProvider(ctx, providerId, config) {
-  if (ctx.closed) throw new ACPSessionError("closed", "session is closed");
-  const id = ctx.allocId();
-  const result = await ctx.sendRequest(id, "providers/set", { providerId, ...config ?? {} });
-  if (isJsonRpcError(result)) {
-    throw new ACPSessionError("prompt_failed", `providers/set failed: ${result.message}`, result);
-  }
+function imageContent(mimeType, data) {
+  return { type: "image", mimeType, data };
 }
-async function executeDisableProvider(ctx) {
-  if (ctx.closed) throw new ACPSessionError("closed", "session is closed");
-  const id = ctx.allocId();
-  const result = await ctx.sendRequest(id, "providers/disable", {});
-  if (isJsonRpcError(result)) {
-    throw new ACPSessionError(
-      "prompt_failed",
-      `providers/disable failed: ${result.message}`,
-      result
-    );
-  }
+function audioContent(mimeType, data) {
+  return { type: "audio", mimeType, data };
 }
-async function executeMcpMessage(ctx, connectionId, message) {
-  if (ctx.closed) throw new ACPSessionError("closed", "session is closed");
-  const id = ctx.allocId();
-  const result = await ctx.sendRequest(id, "mcp/message", { connectionId, message });
-  if (isJsonRpcError(result)) {
-    throw new ACPSessionError("prompt_failed", `mcp/message failed: ${result.message}`, result);
+function extractText(block) {
+  if (typeof block !== "object" || block === null) return "";
+  const b = block;
+  if (b.type === "text" && typeof b.text === "string") return b.text;
+  if (b.type === "resource" && b.resource && typeof b.resource === "object" && typeof b.resource.text === "string") {
+    return b.resource.text;
   }
-  return result;
+  return "";
 }
-async function executeCreateSession(ctx) {
-  const servers = filterMcpServers(ctx.agentCapabilities, ctx.opts.mcpServers);
-  const id = ctx.allocId();
-  const result = await ctx.sendRequest(id, "session/new", {
-    cwd: ctx.opts.cwd ?? ctx.opts.projectRoot,
-    mcpServers: servers
-  });
-  if (isJsonRpcError(result)) {
-    throw new ACPSessionError(
-      "session_create_failed",
-      `session/new failed: ${result.message}`,
-      result
-    );
-  }
-  const sessionId = result.sessionId;
-  if (typeof sessionId !== "string" || sessionId.length === 0) {
-    throw new ACPSessionError("protocol_error", "session/new returned no sessionId", result);
-  }
-  return sessionId;
+function isRecord(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function emptyRunResult(stopReason) {
+  return {
+    text: "",
+    stopReason,
+    hasText: false,
+    toolCalls: [],
+    diffs: [],
+    thoughts: ""
+  };
 }
 
 // src/client/acp-session-updates.ts
@@ -2699,11 +2794,30 @@ function makePermissionPolicy(decide) {
 // src/client/terminal-server.ts
 import { spawn } from "node:child_process";
 import { randomBytes as randomBytes2 } from "node:crypto";
-import { realpathSync as realpathSync2 } from "node:fs";
+import { accessSync, realpathSync as realpathSync2 } from "node:fs";
 import * as path3 from "node:path";
 import { buildChildEnv } from "@wrongstack/core/utils";
 import { treeKill as treeKill2 } from "@wrongstack/core/utils/tree-kill";
 var EMPTY_BUFFER = Buffer.alloc(0);
+function win32BatchTarget(command) {
+  if (/\.(?:cmd|bat)$/i.test(command)) return command;
+  if (/[\\/]/.test(command) || path3.extname(command)) return void 0;
+  const exts = (process.env["PATHEXT"] ?? ".COM;.EXE;.BAT;.CMD").toLowerCase().split(";");
+  for (const dir of (process.env["PATH"] ?? "").split(path3.delimiter)) {
+    if (!dir) continue;
+    for (const ext of exts) {
+      if (!ext) continue;
+      const full = path3.join(dir, `${command}${ext}`);
+      try {
+        accessSync(full);
+      } catch {
+        continue;
+      }
+      return ext === ".cmd" || ext === ".bat" ? full : void 0;
+    }
+  }
+  return void 0;
+}
 var DEBUG_DISPOSE = typeof process !== "undefined" && !!process.env?.WRONGSTACK_DEBUG && process.env.WRONGSTACK_DEBUG !== "0" && process.env.WRONGSTACK_DEBUG !== "false";
 var TerminalServer = class {
   terminals = /* @__PURE__ */ new Map();
@@ -2754,11 +2868,14 @@ var TerminalServer = class {
       Math.max(1, this.clampFiniteInt(params.outputByteLimit, this.outputByteLimit)),
       this.maxOutputByteLimit
     );
-    const proc = spawn(params.command, params.args ?? [], {
+    const batch = process.platform === "win32" ? win32BatchTarget(params.command) : void 0;
+    const shim = batch ? buildWin32CmdShimInvocation(batch, params.args ?? []) : void 0;
+    const proc = spawn(shim?.command ?? params.command, shim?.args ?? params.args ?? [], {
       cwd,
       env: this.buildEnv(params.env),
       stdio: ["ignore", "pipe", "pipe"],
-      windowsHide: true
+      windowsHide: true,
+      ...shim ? { windowsVerbatimArguments: shim.windowsVerbatimArguments } : {}
       // shell: false on purpose. The terminal server is invoked with
       // the agent's explicit argv; turning on shell-mode would make
       // the command a single shell-parsed string, which breaks
@@ -3435,55 +3552,14 @@ var ACPSession = class _ACPSession {
    * Call this AFTER start() and BEFORE any session/new call.
    */
   async authenticate(methodId) {
-    if (this.state === "closed") {
-      throw new ACPSessionError("closed", "session is closed");
-    }
-    if (this.state !== "ready" && this.state !== "authenticated") {
-      throw new ACPSessionError(
-        "protocol_error",
-        `authenticate called in state=${this.state} (expected 'ready')`
-      );
-    }
-    if (this.state === "authenticated") return;
-    if (!this.authMethods.some((m) => m.id === methodId)) {
-      throw new ACPSessionError(
-        "auth_failed",
-        `auth method "${methodId}" not in advertised methods: ${this.authMethods.map((m) => m.id).join(", ")}`
-      );
-    }
-    if (this.authMethods.find((m) => m.id === methodId)?.type === "terminal") {
-      throw new ACPSessionError(
-        "auth_failed",
-        "Terminal authentication requires interactive login followed by reconnect; it cannot use authenticate"
-      );
-    }
-    const id = this.allocId();
-    const result = await this.sendRequest(id, "authenticate", { methodId });
-    if (isJsonRpcError(result)) {
-      throw new ACPSessionError("auth_failed", `authenticate failed: ${result.message}`, result);
-    }
-    this.state = "authenticated";
+    return authenticate(this.acpSessionAuthHost(), methodId);
   }
   /**
    * Log out from the current authenticated session.
    * Only callable if the agent advertises `auth.logout` capability.
    */
   async logout() {
-    if (this.state === "closed") {
-      throw new ACPSessionError("closed", "session is closed");
-    }
-    if (!this.agentCapabilities.auth?.logout) {
-      throw new ACPSessionError(
-        "unsupported_capability",
-        "agent does not support logout (auth.logout capability not advertised)"
-      );
-    }
-    const id = this.allocId();
-    const result = await this.sendRequest(id, "logout", {});
-    if (isJsonRpcError(result)) {
-      throw new ACPSessionError("logout_failed", `logout failed: ${result.message}`, result);
-    }
-    this.state = "ready";
+    return logout(this.acpSessionAuthHost());
   }
   // ──────────────────────────────────────────────────────────────────────
   // Session management delegation
@@ -3781,19 +3857,7 @@ var ACPSession = class _ACPSession {
    * `authMethods`; we do not pop OAuth on every spawn.
    */
   async createSessionWithAuth() {
-    try {
-      return await executeCreateSession(this.opContext());
-    } catch (err) {
-      if (this.state === "authenticated" || !isAuthRequiredError(err)) {
-        throw err instanceof ACPSessionError ? err : new ACPSessionError(
-          "session_create_failed",
-          err instanceof Error ? err.message : String(err),
-          err
-        );
-      }
-      await this.ensureAuthenticated();
-      return executeCreateSession(this.opContext());
-    }
+    return createSessionWithAuth(this.acpSessionAuthHost());
   }
   /**
    * Pick a non-terminal auth method and run `authenticate`. Terminal-only
@@ -3801,27 +3865,7 @@ var ACPSession = class _ACPSession {
    * we refuse rather than hang a TUI inside the JSON-RPC child.
    */
   async ensureAuthenticated() {
-    if (this.state === "authenticated") return;
-    if (this.authMethods.length === 0) {
-      throw new ACPSessionError(
-        "auth_failed",
-        "This agent requires authentication before a session can start, but advertised no authMethods. Log into the CLI, then retry."
-      );
-    }
-    const inProcess = this.authMethods.find(
-      (m) => m.type === void 0 || m.type === "agent" || m.type === "oauth" || m.type === "http"
-    );
-    if (inProcess) {
-      await this.authenticate(inProcess.id);
-      return;
-    }
-    const terminal = this.authMethods.find((m) => m.type === "terminal");
-    const setupArgs = terminal?.args?.length ? terminal.args.join(" ") : void 0;
-    const setup = setupArgs !== void 0 ? `${this.opts.command}${this.opts.args?.length ? ` ${this.opts.args.join(" ")}` : ""} ${setupArgs}` : `${this.opts.command}${this.opts.args?.length ? ` ${this.opts.args.join(" ")}` : ""}`;
-    throw new ACPSessionError(
-      "auth_failed",
-      `This agent requires a terminal login before ACP can start. Run \`${setup}\` (or the CLI's /login), then retry.`
-    );
+    return ensureAuthenticated(this.acpSessionAuthHost());
   }
   sendResult(id, result) {
     return this.transport.send({ jsonrpc: "2.0", id, result });
@@ -3937,6 +3981,29 @@ var ACPSession = class _ACPSession {
   resetScratch() {
     this.scratch = createSessionScratch();
   }
+  acpSessionAuthHost() {
+    const self = this;
+    return {
+      get state() {
+        return self.state;
+      },
+      set state(value) {
+        self.state = value;
+      },
+      get authMethods() {
+        return self.authMethods;
+      },
+      allocId: (...args) => this.allocId(...args),
+      sendRequest: (...args) => this.sendRequest(...args),
+      get agentCapabilities() {
+        return self.agentCapabilities;
+      },
+      opContext: (...args) => this.opContext(...args),
+      ensureAuthenticated: (...args) => this.ensureAuthenticated(...args),
+      authenticate: (...args) => this.authenticate(...args),
+      opts: this.opts
+    };
+  }
 };
 
 // src/client/tool-translator.ts