@wrongstack/acp 1.0.19 → 1.0.26

package/dist/agent.js

@@ -1,5 +1,6 @@
 // src/agent/protocol-handler.ts
 import { randomUUID } from "node:crypto";
+import { isAbsolute as isAbsolute2, resolve as resolve2 } from "node:path";
 
 // src/types/acp-v1.ts
 var ACP_PROTOCOL_VERSION = 1;
@@ -177,7 +178,7 @@ function createRunTurnApi(sessionId, clientCapabilities, request, sendSessionUpd
     ...sendSessionUpdate ? { sendSessionUpdate } : {}
   };
 }
-function buildInitializeResult(agentName, modes, configOptions) {
+function buildInitializeResult(agentName, modes, configOptions, clientCapabilities = {}) {
   return {
     protocolVersion: ACP_PROTOCOL_VERSION,
     agentCapabilities: {
@@ -204,9 +205,6 @@ function buildInitializeResult(agentName, modes, configOptions) {
         delete: {},
         resume: {},
         fork: {}
-      },
-      auth: {
-        logout: {}
       }
     },
     agentInfo: {
@@ -214,7 +212,7 @@ function buildInitializeResult(agentName, modes, configOptions) {
       title: "WrongStack",
       version: WRONGSTACK_VERSION
     },
-    authMethods: WRONGSTACK_AUTH_METHODS,
+    authMethods: clientCapabilities.auth?.terminal === true ? WRONGSTACK_AUTH_METHODS : [],
     modes,
     configOptions
   };
@@ -244,7 +242,8 @@ async function handleSessionNewOp(ctx, id, params) {
     id: sessionId,
     cwd,
     abort: new AbortController(),
-    modeId: DEFAULT_MODE_ID,
+    modeId: ctx.modes[0]?.id ?? DEFAULT_MODE_ID,
+    configOptions: structuredClone([...ctx.configOptions]),
     createdAt: now,
     updatedAt: now,
     ...mcpServers.length > 0 ? { mcpServers } : {}
@@ -256,6 +255,7 @@ async function handleSessionNewOp(ctx, id, params) {
     sessionId,
     update: {
       sessionUpdate: "current_mode_update",
+      currentModeId: ctx.modes[0]?.id ?? DEFAULT_MODE_ID,
       modeId: ctx.modes[0]?.id ?? DEFAULT_MODE_ID
     }
   });
@@ -271,12 +271,12 @@ async function handleSessionNewOp(ctx, id, params) {
   await reportSkippedMcpServers(ctx, sessionId, skipped);
   await ctx.sendResult(id, {
     sessionId,
-    modes: ctx.modes,
-    configOptions: ctx.configOptions
+    modes: { currentModeId: state.modeId, availableModes: ctx.modes },
+    configOptions: state.configOptions
   });
   return false;
 }
-async function handleSessionLoadOp(ctx, id, params) {
+async function handleSessionLoadOp(ctx, id, params, replayHistory = true) {
   const p = params ?? {};
   const sessionId = typeof p.sessionId === "string" ? p.sessionId : null;
   const loadCwd = typeof p.cwd === "string" ? p.cwd : void 0;
@@ -301,6 +301,7 @@ async function handleSessionLoadOp(ctx, id, params) {
         cwd: restoredCwd,
         abort: new AbortController(),
         modeId: persisted.modeId ?? DEFAULT_MODE_ID,
+        configOptions: structuredClone(persisted.configOptions ?? [...ctx.configOptions]),
         createdAt: persisted.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
         updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
         ...persisted.title !== void 0 ? { title: persisted.title } : {},
@@ -308,51 +309,69 @@ async function handleSessionLoadOp(ctx, id, params) {
       };
       ctx.sessions.set(sessionId, restored);
       ctx.seedFor?.(sessionId, persisted.history ?? []);
-      for (const update of persisted.history ?? []) {
+      for (const update of replayHistory ? persisted.history ?? [] : []) {
         await ctx.sendNotification({ sessionId, update });
       }
-      await ctx.sendNotification({
-        sessionId,
-        update: { sessionUpdate: "current_mode_update", modeId: restored.modeId }
-      });
+      if (replayHistory)
+        await ctx.sendNotification({
+          sessionId,
+          update: {
+            sessionUpdate: "current_mode_update",
+            currentModeId: restored.modeId,
+            modeId: restored.modeId
+          }
+        });
       await reportSkippedMcpServers(ctx, sessionId, loadSkipped);
       await ctx.sendResult(id, {
-        initialMode: { currentModeId: restored.modeId, availableModes: ctx.modes }
+        modes: { currentModeId: restored.modeId, availableModes: ctx.modes },
+        configOptions: restored.configOptions
       });
       return false;
     }
   }
   if (existing) {
+    if (existing.prompting) {
+      await ctx.sendError(id, -32e3, "cannot reload a session while a prompt is running");
+      return false;
+    }
     existing.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-    if (loadMcpServers.length > 0) {
+    const replay = ctx.replayFor?.(sessionId);
+    if (Array.isArray(p.mcpServers)) {
+      if (JSON.stringify(existing.mcpServers ?? []) !== JSON.stringify(loadMcpServers)) {
+        ctx.disposeFor?.(sessionId);
+        ctx.seedFor?.(sessionId, replay ?? []);
+      }
       existing.mcpServers = loadMcpServers;
     }
-    const replay = ctx.replayFor?.(sessionId);
-    if (replay) {
+    if (replayHistory && replay) {
       for (const update of replay) {
         await ctx.sendNotification({ sessionId, update });
       }
     }
-    await ctx.sendNotification({
-      sessionId,
-      update: {
-        sessionUpdate: "session_info_update",
-        updatedAt: existing.updatedAt
-      }
-    });
-    await ctx.sendNotification({
-      sessionId,
-      update: {
-        sessionUpdate: "current_mode_update",
-        modeId: existing.modeId
-      }
-    });
+    if (replayHistory)
+      await ctx.sendNotification({
+        sessionId,
+        update: {
+          sessionUpdate: "session_info_update",
+          updatedAt: existing.updatedAt
+        }
+      });
+    if (replayHistory)
+      await ctx.sendNotification({
+        sessionId,
+        update: {
+          sessionUpdate: "current_mode_update",
+          currentModeId: existing.modeId,
+          modeId: existing.modeId
+        }
+      });
     await reportSkippedMcpServers(ctx, sessionId, loadSkipped);
     await ctx.sendResult(id, {
-      initialMode: {
+      modes: {
         currentModeId: existing.modeId,
         availableModes: ctx.modes
-      }
+      },
+      configOptions: existing.configOptions ?? [...ctx.configOptions]
     });
     return false;
   }
@@ -390,6 +409,7 @@ async function handleSessionForkOp(ctx, id, params) {
     cwd: forkCwd,
     abort: new AbortController(),
     modeId: source.modeId,
+    configOptions: structuredClone(source.configOptions ?? [...ctx.configOptions]),
     createdAt: now,
     updatedAt: now,
     ...source.title !== void 0 ? { title: source.title } : {},
@@ -405,13 +425,17 @@ async function handleSessionForkOp(ctx, id, params) {
   await ctx.persist(forked, history);
   await ctx.sendNotification({
     sessionId,
-    update: { sessionUpdate: "current_mode_update", modeId: forked.modeId }
+    update: {
+      sessionUpdate: "current_mode_update",
+      currentModeId: forked.modeId,
+      modeId: forked.modeId
+    }
   });
   await reportSkippedMcpServers(ctx, sessionId, forkSkipped);
   await ctx.sendResult(id, {
     sessionId,
-    modes: ctx.modes,
-    configOptions: ctx.configOptions
+    modes: { currentModeId: forked.modeId, availableModes: ctx.modes },
+    configOptions: forked.configOptions
   });
   return false;
 }
@@ -427,6 +451,11 @@ async function handleSessionPromptOp(ctx, id, params) {
     return false;
   }
   const session = ctx.sessions.get(sessionId);
+  if (session.prompting) {
+    await ctx.sendError(id, -32e3, "a prompt is already running for this session");
+    return false;
+  }
+  session.prompting = true;
   if (session.abort.signal.aborted) {
     session.abort = new AbortController();
   }
@@ -455,6 +484,8 @@ async function handleSessionPromptOp(ctx, id, params) {
       {
         sessionId,
         prompt: p.prompt,
+        modeId: session.modeId,
+        configOptions: session.configOptions,
         signal: turnSignal.signal,
         cwd: session.cwd,
         ...session.mcpServers ? { mcpServers: session.mcpServers } : {}
@@ -463,16 +494,25 @@ async function handleSessionPromptOp(ctx, id, params) {
       api
     );
   } catch (err) {
+    session.prompting = false;
     session.abort.signal.removeEventListener("abort", onCancel);
+    await Promise.all(pendingNotifications);
+    if (turnSignal.signal.aborted) {
+      await ctx.sendResult(id, { stopReason: "cancelled" });
+      return false;
+    }
     const { code, message, data } = errorToJsonRpc(err);
     await ctx.sendError(id, code, message, data);
     return false;
   }
   await Promise.all(pendingNotifications);
+  session.prompting = false;
   session.abort.signal.removeEventListener("abort", onCancel);
   session.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-  await ctx.persist(session);
-  await ctx.sendResult(id, { stopReason: result.stopReason });
+  if (ctx.sessions.get(sessionId) === session) await ctx.persist(session);
+  await ctx.sendResult(id, {
+    stopReason: turnSignal.signal.aborted ? "cancelled" : result.stopReason
+  });
   return false;
 }
 async function handleSetModeOp(ctx, id, params) {
@@ -488,7 +528,11 @@ async function handleSetModeOp(ctx, id, params) {
   session.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
   await ctx.sendNotification({
     sessionId,
-    update: { sessionUpdate: "current_mode_update", modeId }
+    update: {
+      sessionUpdate: "current_mode_update",
+      currentModeId: modeId,
+      modeId
+    }
   });
   await ctx.sendResult(id, {});
   return false;
@@ -499,21 +543,24 @@ async function handleSetConfigOptionOp(ctx, id, params) {
   const optionId = typeof p.configId === "string" ? p.configId : null;
   const value = typeof p.value === "string" ? p.value : null;
   const session = sessionId ? ctx.sessions.get(sessionId) : void 0;
-  const option = optionId ? ctx.configOptions.find((o) => o.id === optionId) : void 0;
+  const options = session?.configOptions ?? structuredClone([...ctx.configOptions]);
+  const option = optionId ? options.find((o) => o.id === optionId) : void 0;
   if (!session || !option || value === null || !option.options.some((o) => o.value === value)) {
     await ctx.sendError(id, -32602, "invalid sessionId, configId, or value");
     return false;
   }
   option.currentValue = value;
+  session.configOptions = options;
   session.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
   await ctx.sendNotification({
     sessionId,
     update: {
       sessionUpdate: "config_option_update",
-      configOptions: [...ctx.configOptions]
+      configOptions: options
     }
   });
-  await ctx.sendResult(id, { configOptions: [...ctx.configOptions] });
+  await ctx.persist(session);
+  await ctx.sendResult(id, { configOptions: options });
   return false;
 }
 async function reportSkippedMcpServers(ctx, sessionId, skipped) {
@@ -555,6 +602,8 @@ var ACPProtocolHandler = class {
   // session/request_permission). Keyed by our own `srv_N` ids.
   pendingOut = /* @__PURE__ */ new Map();
   nextOutId = 1;
+  promptRequests = /* @__PURE__ */ new Map();
+  persistenceWrites = /* @__PURE__ */ new Map();
   constructor(opts) {
     this.transport = opts.transport;
     this.defaultCwd = opts.defaultCwd;
@@ -580,20 +629,46 @@ var ACPProtocolHandler = class {
    */
   request(method, params, timeoutMs = 6e4) {
     const id = `srv_${this.nextOutId++}`;
-    return new Promise((resolve2, reject) => {
-      const timer = setTimeout(() => {
+    const sessionId = params?.sessionId;
+    const signal = sessionId ? this.sessions.get(sessionId)?.abort.signal : void 0;
+    return new Promise((resolve3, reject) => {
+      const cleanup = () => {
+        clearTimeout(timer);
+        signal?.removeEventListener("abort", abort);
         this.pendingOut.delete(id);
-        reject(new Error(`${method} timed out after ${timeoutMs}ms`));
+      };
+      const fail = (error) => {
+        cleanup();
+        reject(error);
+      };
+      const abort = () => {
+        fail(new Error("client request cancelled"));
+        void this.transport.send(toWire({ jsonrpc: "2.0", method: "$/cancel_request", params: { requestId: id } })).catch(() => {
+        });
+      };
+      const timer = setTimeout(() => {
+        fail(new Error(`${method} timed out after ${timeoutMs}ms`));
       }, timeoutMs);
-      this.pendingOut.set(id, { resolve: resolve2, reject, timer });
+      if (signal?.aborted) {
+        fail(new Error("client request cancelled"));
+        return;
+      }
+      signal?.addEventListener("abort", abort, { once: true });
+      this.pendingOut.set(id, {
+        resolve: (value) => {
+          cleanup();
+          resolve3(value);
+        },
+        reject: fail,
+        timer
+      });
       this.transport.send(toWire({ jsonrpc: "2.0", id, method, params })).catch((e) => {
-        clearTimeout(timer);
-        this.pendingOut.delete(id);
-        reject(e instanceof Error ? e : new Error(String(e)));
+        fail(e instanceof Error ? e : new Error(String(e)));
       });
     });
   }
   maybeResolvePending(m) {
+    if (m.result === void 0 && m.error === void 0) return;
     const id = m.id;
     if (typeof id !== "string") return;
     const pending = this.pendingOut.get(id);
@@ -613,6 +688,7 @@ var ACPProtocolHandler = class {
     if (typeof msg !== "object" || msg === null) return false;
     const m = msg;
     if (m.id !== void 0 && (m.result !== void 0 || m.error !== void 0)) {
+      this.maybeResolvePending(msg);
       return false;
     }
     if (m.id !== void 0 && typeof m.method === "string") {
@@ -652,6 +728,7 @@ var ACPProtocolHandler = class {
       store: this.store,
       replayFor: this.replayFor,
       seedFor: this.seedFor,
+      disposeFor: this.disposeFor,
       onSessionNew: this.onSessionNew,
       allocId: () => this.allocId(),
       persist: (state, history) => this.persist(state, history),
@@ -689,14 +766,23 @@ var ACPProtocolHandler = class {
           return await this.handleSessionClose(id, params);
         case "session/delete":
           return await this.handleSessionDelete(id, params);
-        case "session/prompt":
-          return await handleSessionPromptOp(this.sessionContext(), id, params);
+        case "session/prompt": {
+          const sessionId = params?.sessionId;
+          if (typeof sessionId === "string" && !this.sessions.get(sessionId)?.prompting) {
+            this.promptRequests.set(id, sessionId);
+          }
+          try {
+            return await handleSessionPromptOp(this.sessionContext(), id, params);
+          } finally {
+            this.promptRequests.delete(id);
+          }
+        }
         case "session/set_mode":
           return await handleSetModeOp(this.sessionContext(), id, params);
         case "session/set_config_option":
           return await handleSetConfigOptionOp(this.sessionContext(), id, params);
         case "session/list":
-          return await this.handleSessionList(id);
+          return await this.handleSessionList(id, params);
         case "session/fork":
           return await handleSessionForkOp(this.sessionContext(), id, params);
         case "providers/list":
@@ -725,7 +811,12 @@ var ACPProtocolHandler = class {
     this.initialized = true;
     await this.sendResult(
       id,
-      buildInitializeResult(this.agentName, this.modes, this.configOptions)
+      buildInitializeResult(
+        this.agentName,
+        this.modes,
+        this.configOptions,
+        this.clientCapabilities
+      )
     );
     return false;
   }
@@ -734,29 +825,15 @@ var ACPProtocolHandler = class {
     return false;
   }
   async handleLogout(id, _params) {
-    await this.sendResult(id, {});
+    await this.sendError(
+      id,
+      -32601,
+      "logout is not supported; manage provider credentials with wstack auth"
+    );
     return false;
   }
   async handleSessionResume(id, params) {
-    const p = params ?? {};
-    const sessionId = typeof p.sessionId === "string" ? p.sessionId : null;
-    const existing = sessionId ? this.sessions.get(sessionId) : void 0;
-    if (existing) {
-      existing.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-      const resumeServers = parseMcpServers(p.mcpServers);
-      if (resumeServers.length > 0) {
-        existing.mcpServers = resumeServers;
-      }
-      await this.sendResult(id, {
-        initialMode: {
-          currentModeId: existing.modeId,
-          availableModes: this.modes
-        }
-      });
-      return false;
-    }
-    await this.sendError(id, -32e3, `session not found: ${sessionId}`);
-    return false;
+    return handleSessionLoadOp(this.sessionContext(), id, params, false);
   }
   async handleSessionClose(id, params) {
     const p = params ?? {};
@@ -779,14 +856,12 @@ var ACPProtocolHandler = class {
       await this.sendError(id, -32e3, `session not found: ${sessionId}`);
       return false;
     }
-    if (!this.sessions.has(sessionId)) {
-      await this.sendResult(id, { configOptions: [...this.configOptions] });
-      return false;
-    }
     const session = this.sessions.get(sessionId);
-    session.abort.abort();
+    session?.abort.abort();
     this.sessions.delete(sessionId);
     this.disposeSession(sessionId);
+    await this.persistenceWrites.get(sessionId);
+    await this.store?.delete?.(sessionId);
     await this.sendResult(id, {});
     return false;
   }
@@ -813,12 +888,23 @@ var ACPProtocolHandler = class {
     await this.sendError(id, -32e3, "MCP message routing not available through ACP");
     return false;
   }
-  async handleSessionList(id) {
-    const sessions = Array.from(this.sessions.values()).map((s) => {
+  async handleSessionList(id, params) {
+    const p = params ?? {};
+    if (p.cwd != null && (typeof p.cwd !== "string" || !isAbsolute2(p.cwd)) || p.cursor != null) {
+      await this.sendError(id, -32602, "invalid cwd or cursor");
+      return false;
+    }
+    const known = new Map(this.sessions);
+    for (const entry of await this.store?.list?.() ?? []) {
+      if (known.has(entry.id)) continue;
+      const saved = await this.store?.load(entry.id);
+      if (saved?.cwd) known.set(entry.id, { ...saved, id: entry.id });
+    }
+    const sessions = Array.from(known.values()).filter((s) => typeof p.cwd !== "string" || s.cwd && resolve2(s.cwd) === resolve2(p.cwd)).map((s) => {
       const out = {
         sessionId: s.id,
         cwd: s.cwd,
-        updatedAt: s.updatedAt
+        updatedAt: s.updatedAt ?? ""
       };
       if (s.title !== void 0) out.title = s.title;
       return out;
@@ -841,6 +927,11 @@ var ACPProtocolHandler = class {
         return false;
       }
       case "$/cancel_request": {
+        const requestId = params?.requestId;
+        if (typeof requestId === "string" || typeof requestId === "number") {
+          const sessionId = this.promptRequests.get(requestId);
+          if (sessionId) this.sessions.get(sessionId)?.abort.abort();
+        }
         return false;
       }
       case "exit":
@@ -861,10 +952,18 @@ var ACPProtocolHandler = class {
   }
   async persist(state, history = void 0) {
     if (!this.store) return;
-    try {
-      await this.store.save(state, history ?? this.replayFor?.(state.id));
-    } catch {
-    }
+    const store = this.store;
+    const replay = history ?? this.replayFor?.(state.id);
+    const previous = this.persistenceWrites.get(state.id) ?? Promise.resolve();
+    const write = previous.then(() => store.save(state, replay)).then(
+      () => {
+      },
+      () => {
+      }
+    );
+    this.persistenceWrites.set(state.id, write);
+    await write;
+    if (this.persistenceWrites.get(state.id) === write) this.persistenceWrites.delete(state.id);
   }
   async sendError(id, code, message, data) {
     const error = { code, message };
@@ -1131,7 +1230,10 @@ function makeACPServerAgentTurn(opts) {
         }
       }
     }
+    const agent = agents.get(sessionId);
     agents.delete(sessionId);
+    void Promise.resolve().then(() => agent?.teardown?.()).catch(() => {
+    });
     history.delete(sessionId);
     historyBytes.delete(sessionId);
     pendingSeed.delete(sessionId);
@@ -1254,7 +1356,10 @@ function promptToText(blocks) {
     } else if (b.type === "audio") {
       parts.push(`[audio: ${b.mimeType}]`);
     } else if (b.type === "resource") {
-      parts.push(`[embedded resource: ${b.resource.uri}]`);
+      parts.push(
+        "text" in b.resource && typeof b.resource.text === "string" ? `[embedded resource: ${b.resource.uri}]
+${b.resource.text}` : `[embedded resource: ${b.resource.uri}]`
+      );
     } else if (b.type === "resource_link") {
       parts.push(`[resource link: ${b.uri}]`);
     }
@@ -1398,6 +1503,7 @@ var ACPSessionStore = class {
           id: state.id,
           cwd: state.cwd,
           modeId: state.modeId,
+          configOptions: state.configOptions,
           createdAt: state.createdAt,
           updatedAt: state.updatedAt,
           title: state.title,
@@ -1558,7 +1664,8 @@ var ACPSessionStore = class {
     if (target === null) return;
     try {
       await fsp2.unlink(target);
-    } catch {
+    } catch (err) {
+      if (err.code !== "ENOENT") throw err;
     }
     await this.withIndexLock(async () => {
       const entries = await this.readIndex();
@@ -1619,9 +1726,9 @@ var StdioTransport = class {
   }
   send(msg) {
     if (this.closed) return Promise.resolve();
-    return new Promise((resolve2) => {
+    return new Promise((resolve3) => {
       const line = JSON.stringify(msg) + "\n";
-      this.stdout.write(line, "utf8", () => resolve2());
+      this.stdout.write(line, "utf8", () => resolve3());
     });
   }
   sendRaw(chunk) {
@@ -1634,8 +1741,8 @@ var StdioTransport = class {
       return Promise.resolve(queued.message);
     }
     if (this.closed) return Promise.resolve(null);
-    return new Promise((resolve2) => {
-      this.resolveRead = resolve2;
+    return new Promise((resolve3) => {
+      this.resolveRead = resolve3;
     });
   }
   onMessage(handler) {
@@ -1704,9 +1811,9 @@ var StdioTransport = class {
   }
   dispatch(msg, chars = JSON.stringify(msg).length) {
     if (this.resolveRead) {
-      const resolve2 = this.resolveRead;
+      const resolve3 = this.resolveRead;
       this.resolveRead = null;
-      resolve2(msg);
+      resolve3(msg);
     } else {
       let claimed = false;
       for (const handler of this.claimHandlers) {
@@ -1866,7 +1973,7 @@ function toolToPriority(tool) {
 import { createServer } from "node:http";
 import { isIP } from "node:net";
 import { fileURLToPath } from "node:url";
-import { expandIPv6, writeErr as writeErr2 } from "@wrongstack/core/utils";
+import { expandIPv6, isStandaloneBinary, writeErr as writeErr2 } from "@wrongstack/core/utils";
 import { timingSafeTokenEqual } from "@wrongstack/primitives";
 var LISTEN_RETRY_LIMIT = 5;
 var LISTEN_RETRY_BASE_MS = 25;
@@ -1912,15 +2019,30 @@ var WrongStackACPServer = class {
       this.transport.sendStartupMarker();
     }
     this.running = true;
+    const prompts = /* @__PURE__ */ new Set();
     try {
       while (this.running) {
         const msg = await this.transport.read();
         if (!msg) break;
+        if (msg.method === "session/prompt") {
+          const task = this.handler.handleMessage(msg).then(
+            () => {
+            },
+            (err) => {
+              writeErr2(`[wstack-acp] prompt dispatch failed: ${String(err)}
+`);
+            }
+          );
+          prompts.add(task);
+          void task.finally(() => prompts.delete(task));
+          continue;
+        }
         const terminal = await this.handler.handleMessage(msg);
         if (terminal) break;
       }
     } finally {
       this.handler.close();
+      await Promise.allSettled(prompts);
       this.transport.close();
     }
   }
@@ -2054,10 +2176,10 @@ var WrongStackACPServer = class {
   listenWithRetry(port, host, attempt = 0) {
     const server = this.httpServer;
     if (!server) return Promise.resolve();
-    return new Promise((resolve2, reject) => {
+    return new Promise((resolve3, reject) => {
       const onListening = () => {
         server.removeListener("error", onError);
-        resolve2();
+        resolve3();
       };
       const onError = (err) => {
         server.removeListener("listening", onListening);
@@ -2065,7 +2187,7 @@ var WrongStackACPServer = class {
         if (port === 0 && transient && attempt < LISTEN_RETRY_LIMIT) {
           const timer = setTimeout(
             () => {
-              this.listenWithRetry(port, host, attempt + 1).then(resolve2, reject);
+              this.listenWithRetry(port, host, attempt + 1).then(resolve3, reject);
             },
             LISTEN_RETRY_BASE_MS * (attempt + 1)
           );
@@ -2093,8 +2215,8 @@ var WrongStackACPServer = class {
     if (!server) return;
     for (const socket of this.httpSockets) socket.destroy();
     this.httpSockets.clear();
-    await new Promise((resolve2) => {
-      server.close(() => resolve2());
+    await new Promise((resolve3) => {
+      server.close(() => resolve3());
     });
   }
 };
@@ -2125,7 +2247,7 @@ async function main() {
   const server = new WrongStackACPServer();
   await server.start();
 }
-var isEntrypoint = process.argv[1] !== void 0 && fileURLToPath(import.meta.url) === process.argv[1];
+var isEntrypoint = process.argv[1] !== void 0 && !isStandaloneBinary() && fileURLToPath(import.meta.url) === process.argv[1];
 if (isEntrypoint) {
   main().catch((err) => {
     writeErr2(`[wstack-acp fatal] ${err}

package/dist/client/acp-late-session.d.ts

@@ -0,0 +1,4 @@
+import type { ACPClientTransport } from '../agent/stdio-transport.js';
+import type { SessionId } from '../types/acp-v1.js';
+export declare function cancelLateAcpSession(transport: ACPClientTransport, createPromise: Promise<SessionId>): void;
+//# sourceMappingURL=acp-late-session.d.ts.map

package/dist/client/acp-request-state.d.ts

@@ -0,0 +1,9 @@
+export interface PendingRequest {
+    method: string;
+    resolve: (v: unknown) => void;
+    reject: (e: Error) => void;
+    timeoutMs: number;
+    timeoutHandle: ReturnType<typeof setTimeout>;
+}
+export type State = 'init' | 'ready' | 'authenticated' | 'sessioning' | 'prompting' | 'done' | 'closed';
+//# sourceMappingURL=acp-request-state.d.ts.map