@wrongstack/acp 0.297.0 → 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.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;
@@ -149,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;
@@ -160,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);
@@ -191,7 +196,7 @@ var ClientTransport = class {
         return;
       }
       try {
-        this.dispatch(JSON.parse(raw));
+        this.dispatch(JSON.parse(raw), raw.length);
       } catch {
       }
     }
@@ -201,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 {
@@ -508,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();
@@ -627,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 };
@@ -657,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) {
@@ -674,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. */
@@ -862,6 +879,9 @@ var WebSocketClientTransport = class {
         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 {
@@ -879,16 +899,21 @@ var WebSocketClientTransport = class {
       ws.addEventListener("error", (ev) => {
         const pending = this.pendingStart;
         if (pending === null) {
-          this.closed = true;
+          this.stop();
           return;
         }
         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";
         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;
@@ -924,6 +949,7 @@ var WebSocketClientTransport = class {
   }
   stop() {
     this.closed = true;
+    this.handlers.clear();
     if (this.pendingStart !== null) {
       const pending = this.pendingStart;
       this.pendingStart = null;