@wrongstack/acp 0.296.4 → 0.298.0

package/dist/client/terminal-server.d.ts

@@ -55,7 +55,11 @@ export declare class TerminalServer {
         exitCode: number | null;
         signal: string | null;
     }>;
-    /** Kill the process but keep the terminal record (agent can still read output). */
+    /**
+     * Kill the process but keep the terminal record (agent can still read output).
+     * On POSIX this signals only the direct child; descendants may survive because
+     * terminal processes are not spawned as process-group leaders.
+     */
     kill(terminalId: string): void;
     /** Kill the process if alive and remove the record. */
     release(terminalId: string): void;

package/dist/client/websocket-transport.d.ts

@@ -36,6 +36,8 @@ export declare class WebSocketClientTransport implements ACPClientTransport {
     private readonly maxBufferedBytes;
     private readonly maxMessageChars;
     constructor(opts: WebSocketClientTransportOptions);
+    /** Pending start() promise resolve/reject — settled in stop() to avoid leaking. */
+    private pendingStart;
     start(): Promise<void>;
     send(msg: ACPMessage): Promise<void>;
     onMessage(handler: (msg: ACPMessage) => void): () => void;

package/dist/client.js

@@ -3,32 +3,14 @@ import { expectDefined, writeErr } from "@wrongstack/core/utils";
 import { treeKill } from "@wrongstack/core/utils/tree-kill";
 
 // src/win32-cmd.ts
-var WIN32_CMD_META = /[&|<>"\r\n\0]/;
-function buildWin32CmdShimInvocation(command, args = []) {
-  assertSafeWin32CmdArgs([command, ...args]);
-  const line = ["call", quoteWin32CmdArg(command), ...args.map(quoteWin32CmdArg)].join(" ");
-  return {
-    command: process.env["COMSPEC"] ?? "cmd.exe",
-    args: ["/d", "/c", line],
-    windowsVerbatimArguments: true
-  };
-}
-function assertSafeWin32CmdArgs(args) {
-  for (const arg of args) {
-    if (typeof arg === "string" && WIN32_CMD_META.test(arg)) {
-      throw new Error(
-        'win32 cmd shim spawn: argument contains a shell metacharacter (one of & | < > ", or a newline) that could enable command injection through the .cmd/.bat wrapper - refusing to run. Offending argument: ' + JSON.stringify(arg)
-      );
-    }
-  }
-}
-function quoteWin32CmdArg(arg) {
-  return `"${arg}"`;
-}
+import {
+  buildWin32CmdShimInvocation
+} from "@wrongstack/core/utils";
 
 // src/agent/stdio-transport.ts
 var DEFAULT_MAX_FRAME_CHARS = 20 * 1024 * 1024;
 var DEFAULT_MAX_QUEUED_MESSAGES = 1e3;
+var DEFAULT_MAX_QUEUED_CHARS = 32 * 1024 * 1024;
 function positiveLimit(value, fallback) {
   return value !== void 0 && Number.isFinite(value) && value > 0 ? Math.floor(value) : fallback;
 }
@@ -36,12 +18,15 @@ var ClientTransport = class {
   child = null;
   buffer = "";
   handlers = /* @__PURE__ */ new Set();
+  claimHandlers = /* @__PURE__ */ new Set();
   closed = false;
   resolveRead = null;
   messageQueue = [];
+  queuedChars = 0;
   opts;
   maxFrameChars;
   maxQueuedMessages;
+  maxQueuedChars;
   constructor(options) {
     this.opts = {
       handshakeTimeoutMs: 3e4,
@@ -49,6 +34,7 @@ var ClientTransport = class {
     };
     this.maxFrameChars = positiveLimit(options.maxFrameChars, DEFAULT_MAX_FRAME_CHARS);
     this.maxQueuedMessages = positiveLimit(options.maxQueuedMessages, DEFAULT_MAX_QUEUED_MESSAGES);
+    this.maxQueuedChars = positiveLimit(options.maxQueuedChars, DEFAULT_MAX_QUEUED_CHARS);
   }
   async start() {
     if (this.child) return;
@@ -59,6 +45,14 @@ var ClientTransport = class {
     ]);
     return new Promise((resolve3, reject) => {
       const timeout = setTimeout(() => {
+        const child2 = this.child;
+        this.child = null;
+        if (child2) {
+          try {
+            treeKill(child2);
+          } catch {
+          }
+        }
         reject(
           new Error(`ACP child process failed to start within ${this.opts.handshakeTimeoutMs}ms`)
         );
@@ -141,8 +135,11 @@ var ClientTransport = class {
     });
   }
   read() {
-    if (this.messageQueue.length > 0)
-      return Promise.resolve(expectDefined(this.messageQueue.shift()));
+    if (this.messageQueue.length > 0) {
+      const queued = expectDefined(this.messageQueue.shift());
+      this.queuedChars = Math.max(0, this.queuedChars - queued.chars);
+      return Promise.resolve(queued.message);
+    }
     if (this.closed) return Promise.resolve(null);
     return new Promise((resolve3) => {
       this.resolveRead = resolve3;
@@ -152,13 +149,29 @@ var ClientTransport = class {
     this.handlers.add(handler);
     return () => this.handlers.delete(handler);
   }
+  /**
+   * Register a handler that MAY claim a message by returning `true`.
+   * Claimed messages are NOT enqueued for the read() loop — they are
+   * considered fully consumed by the handler. This is how the ACP
+   * server transport prevents the correlation handler (which always
+   * fires on every message but only actually correlates responses)
+   * from starving the read() loop of pipelined requests, notifications,
+   * and any message the handler chose to ignore. See dispatch() for
+   * the gating logic.
+   */
+  onMessageClaim(handler) {
+    this.claimHandlers.add(handler);
+    return () => this.claimHandlers.delete(handler);
+  }
   stop() {
     this.closed = true;
     this.resolveRead?.(null);
     this.resolveRead = null;
     this.buffer = "";
     this.messageQueue.length = 0;
+    this.queuedChars = 0;
     this.handlers.clear();
+    this.claimHandlers.clear();
     const child = this.child;
     if (!child) return;
     treeKill(child);
@@ -183,7 +196,7 @@ var ClientTransport = class {
         return;
       }
       try {
-        this.dispatch(JSON.parse(raw));
+        this.dispatch(JSON.parse(raw), raw.length);
       } catch {
       }
     }
@@ -193,29 +206,34 @@ var ClientTransport = class {
   }
   onChildClose(code) {
     this.closed = true;
+    this.child = null;
     this.resolveRead?.(null);
     this.resolveRead = null;
     this.buffer = "";
     this.messageQueue.length = 0;
+    this.queuedChars = 0;
     this.handlers.clear();
     if (code !== 0 && code !== null) {
       writeErr(`[acp-child exited with code ${code}]
 `);
     }
   }
-  dispatch(msg) {
+  dispatch(msg, chars = JSON.stringify(msg).length) {
     if (this.resolveRead) {
       const resolve3 = this.resolveRead;
       this.resolveRead = null;
       resolve3(msg);
     } else if (this.handlers.size === 0) {
-      if (this.messageQueue.length >= this.maxQueuedMessages) {
-        writeErr(`[acp-child message queue exceeds ${this.maxQueuedMessages} entries]
-`);
+      if (this.messageQueue.length >= this.maxQueuedMessages || this.queuedChars + chars > this.maxQueuedChars) {
+        writeErr(
+          `[acp-child message queue exceeds ${this.maxQueuedMessages} entries or ${this.maxQueuedChars} characters]
+`
+        );
         this.stop();
         return;
       }
-      this.messageQueue.push(msg);
+      this.messageQueue.push({ message: msg, chars });
+      this.queuedChars += chars;
     }
     for (const handler of this.handlers) {
       try {
@@ -500,6 +518,7 @@ import { spawn } from "node:child_process";
 import { realpathSync as realpathSync2 } from "node:fs";
 import * as path2 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);
 var TerminalServer = class {
   terminals = /* @__PURE__ */ new Map();
@@ -619,13 +638,11 @@ var TerminalServer = class {
         state.outputHead = 0;
       }
     };
+    state.onData = onData;
     proc.stdout?.on("data", onData);
     proc.stderr?.on("data", onData);
     state.timeoutHandle = setTimeout(() => {
-      try {
-        proc.kill("SIGTERM");
-      } catch {
-      }
+      treeKill2(proc);
     }, this.commandTimeoutMs);
     this.terminals.set(id, state);
     return { terminalId: id };
@@ -649,14 +666,15 @@ var TerminalServer = class {
     if (!state) throw new Error(`unknown terminal: ${terminalId}`);
     return state.exitPromise;
   }
-  /** Kill the process but keep the terminal record (agent can still read output). */
+  /**
+   * Kill the process but keep the terminal record (agent can still read output).
+   * On POSIX this signals only the direct child; descendants may survive because
+   * terminal processes are not spawned as process-group leaders.
+   */
   kill(terminalId) {
     const state = this.terminals.get(terminalId);
     if (!state) throw new Error(`unknown terminal: ${terminalId}`);
-    try {
-      state.proc.kill("SIGTERM");
-    } catch {
-    }
+    treeKill2(state.proc);
   }
   /** Kill the process if alive and remove the record. */
   release(terminalId) {
@@ -666,10 +684,17 @@ var TerminalServer = class {
       clearTimeout(state.timeoutHandle);
       state.timeoutHandle = null;
     }
-    try {
-      state.proc.kill("SIGKILL");
-    } catch {
-    }
+    if (state.onData) {
+      state.proc.stdout?.off("data", state.onData);
+      state.proc.stderr?.off("data", state.onData);
+      state.onData = void 0;
+    }
+    state.proc.stdout?.destroy?.();
+    state.proc.stderr?.destroy?.();
+    state.outputChunks.length = 0;
+    state.outputHead = 0;
+    state.retainedBytes = 0;
+    treeKill2(state.proc, { force: true });
     this.terminals.delete(terminalId);
   }
   /** Kill all active terminals. Used on session close. */
@@ -832,7 +857,12 @@ var WebSocketClientTransport = class {
     this.maxBufferedBytes = finitePositiveLimit(opts.maxBufferedBytes, 32 * 1024 * 1024);
     this.maxMessageChars = finitePositiveLimit(opts.maxMessageChars, 20 * 1024 * 1024);
   }
+  /** Pending start() promise resolve/reject — settled in stop() to avoid leaking. */
+  pendingStart = null;
   start() {
+    if (this.closed || this.ws !== null || this.pendingStart !== null) {
+      return Promise.reject(new Error("WebSocket transport has already been started or stopped"));
+    }
     const WS = globalThis.WebSocket;
     if (!WS) {
       return Promise.reject(
@@ -843,35 +873,53 @@ var WebSocketClientTransport = class {
     }
     const timeoutMs = this.opts.handshakeTimeoutMs ?? 3e4;
     return new Promise((resolve3, reject) => {
-      let settled = false;
       const ws = new WS(this.opts.url, this.opts.protocols);
       this.ws = ws;
       const timer = setTimeout(() => {
-        settled = true;
+        const pending = this.pendingStart;
+        if (pending === null) return;
+        this.pendingStart = null;
+        this.closed = true;
+        if (this.ws === ws) this.ws = null;
+        this.handlers.clear();
         try {
           ws.close();
         } catch {
         }
-        reject(new Error(`WebSocket failed to open within ${timeoutMs}ms`));
+        pending.reject(new Error(`WebSocket failed to open within ${timeoutMs}ms`));
       }, timeoutMs);
+      this.pendingStart = { resolve: resolve3, reject, timer };
       ws.addEventListener("open", () => {
-        if (settled) return;
-        settled = true;
-        clearTimeout(timer);
-        resolve3();
+        const pending = this.pendingStart;
+        if (pending === null) return;
+        this.pendingStart = null;
+        clearTimeout(pending.timer);
+        pending.resolve();
       });
       ws.addEventListener("error", (ev) => {
-        if (settled) {
-          this.closed = true;
+        const pending = this.pendingStart;
+        if (pending === null) {
+          this.stop();
           return;
         }
-        settled = true;
-        clearTimeout(timer);
+        this.pendingStart = null;
+        this.closed = true;
+        if (this.ws === ws) this.ws = null;
+        this.handlers.clear();
+        clearTimeout(pending.timer);
         const message = ev && typeof ev === "object" && "message" in ev ? String(ev.message) : "WebSocket error";
-        reject(new Error(message));
+        pending.reject(new Error(message));
       });
       ws.addEventListener("close", () => {
         this.closed = true;
+        if (this.ws === ws) this.ws = null;
+        this.handlers.clear();
+        const pending = this.pendingStart;
+        if (pending !== null) {
+          this.pendingStart = null;
+          clearTimeout(pending.timer);
+          pending.reject(new Error("WebSocket closed before the connection opened"));
+        }
       });
       ws.addEventListener("message", (ev) => {
         this.onData(ev.data);
@@ -901,6 +949,16 @@ var WebSocketClientTransport = class {
   }
   stop() {
     this.closed = true;
+    this.handlers.clear();
+    if (this.pendingStart !== null) {
+      const pending = this.pendingStart;
+      this.pendingStart = null;
+      clearTimeout(pending.timer);
+      try {
+        pending.reject(new Error("WebSocket transport stopped while connecting"));
+      } catch {
+      }
+    }
     if (this.ws) {
       try {
         this.ws.close();
@@ -1313,7 +1371,15 @@ var ACPSession = class _ACPSession {
     if (opts.env !== void 0) transportOpts.env = opts.env;
     if (opts.cwd !== void 0) transportOpts.cwd = opts.cwd;
     const transport = new ClientTransport(transportOpts);
-    return _ACPSession.attach(opts, transport, `failed to spawn ${opts.command}`);
+    try {
+      return await _ACPSession.attach(opts, transport, `failed to spawn ${opts.command}`);
+    } catch (err) {
+      try {
+        transport.stop();
+      } catch {
+      }
+      throw err;
+    }
   }
   /**
    * Connect to a REMOTE ACP agent over a WebSocket instead of spawning a