@wrongstack/acp 0.293.0 → 0.295.0

package/dist/agent.js

@@ -1,5 +1,10 @@
 // src/agent/stdio-transport.ts
-import { expectDefined, writeErr } from "@wrongstack/core";
+import { expectDefined, writeErr } from "@wrongstack/core/utils";
+var DEFAULT_MAX_FRAME_CHARS = 20 * 1024 * 1024;
+var DEFAULT_MAX_QUEUED_MESSAGES = 1e3;
+function positiveLimit(value, fallback) {
+  return Number.isFinite(value) && (value ?? 0) > 0 ? Math.floor(value) : fallback;
+}
 var StdioTransport = class {
   stdin = process.stdin;
   stdout = process.stdout;
@@ -9,7 +14,14 @@ var StdioTransport = class {
   closed = false;
   resolveRead = null;
   messageQueue = [];
-  constructor() {
+  maxFrameChars;
+  maxQueuedMessages;
+  constructor(opts = {}) {
+    this.maxFrameChars = positiveLimit(opts.maxFrameChars, DEFAULT_MAX_FRAME_CHARS);
+    this.maxQueuedMessages = positiveLimit(
+      opts.maxQueuedMessages,
+      DEFAULT_MAX_QUEUED_MESSAGES
+    );
     this.stdin.resume();
     this.stdin.setEncoding("utf8");
     this.stdin.on("data", (chunk) => this.onData(chunk));
@@ -45,13 +57,34 @@ var StdioTransport = class {
     this.stdin.pause();
     this.resolveRead?.(null);
     this.resolveRead = null;
+    this.buffer = "";
+    this.messageQueue.length = 0;
+    this.handlers.clear();
   }
   onData(chunk) {
     this.buffer += chunk;
     const lines = this.buffer.split("\n");
     this.buffer = lines.pop() ?? "";
+    if (this.buffer.length > this.maxFrameChars) {
+      this.stderr.write(
+        `[wstack-acp frame error] pending frame exceeds ${this.maxFrameChars} characters
+`,
+        "utf8"
+      );
+      this.close();
+      return;
+    }
     for (const raw of lines) {
       if (!raw.trim()) continue;
+      if (raw.length > this.maxFrameChars) {
+        this.stderr.write(
+          `[wstack-acp frame error] frame exceeds ${this.maxFrameChars} characters
+`,
+          "utf8"
+        );
+        this.close();
+        return;
+      }
       try {
         this.dispatch(JSON.parse(raw));
       } catch (err) {
@@ -66,6 +99,15 @@ var StdioTransport = class {
       this.resolveRead = null;
       resolve(msg);
     } else {
+      if (this.messageQueue.length >= this.maxQueuedMessages) {
+        this.stderr.write(
+          `[wstack-acp queue error] pending message queue exceeds ${this.maxQueuedMessages} entries
+`,
+          "utf8"
+        );
+        this.close();
+        return;
+      }
       this.messageQueue.push(msg);
     }
     for (const handler of this.handlers) {
@@ -78,9 +120,7 @@ var StdioTransport = class {
     }
   }
   handleClose() {
-    this.closed = true;
-    this.resolveRead?.(null);
-    this.resolveRead = null;
+    this.close();
   }
   failAll(err) {
     this.stderr.write(`[wstack-acp stdin error] ${err.message}
@@ -206,11 +246,28 @@ function toolToPriority(tool) {
 // src/types/acp-v1.ts
 var ACP_PROTOCOL_VERSION = 1;
 
-// src/agent/protocol-handler.ts
+// src/version.ts
+import { createRequire } from "node:module";
+var require2 = createRequire(import.meta.url);
+function readPackageVersion() {
+  try {
+    const packageJson = require2("../package.json");
+    if (typeof packageJson.version === "string" && packageJson.version.length > 0) {
+      return packageJson.version;
+    }
+  } catch {
+  }
+  return "dev";
+}
+var ACP_PACKAGE_VERSION = readPackageVersion();
+
+// src/agent/protocol-contract.ts
 function toWire(msg) {
   return msg;
 }
-var WRONGSTACK_VERSION = "0.274.1";
+var WRONGSTACK_VERSION = ACP_PACKAGE_VERSION;
+
+// src/agent/protocol-handler.ts
 var WRONGSTACK_AUTH_METHODS = [
   {
     id: "wrongstack-auth",
@@ -221,6 +278,7 @@ var WRONGSTACK_AUTH_METHODS = [
   }
 ];
 var DEFAULT_MODE_ID = "code";
+var DEFAULT_MAX_SESSIONS = 64;
 var DEFAULT_MODES = [
   {
     id: DEFAULT_MODE_ID,
@@ -238,6 +296,8 @@ var ACPProtocolHandler = class {
   agentName;
   replayFor;
   seedFor;
+  disposeFor;
+  maxSessions;
   store;
   initialized = false;
   clientCapabilities = {};
@@ -258,6 +318,8 @@ var ACPProtocolHandler = class {
     this.agentName = opts.agentName ?? "wrongstack";
     this.replayFor = opts.replayFor;
     this.seedFor = opts.seedFor;
+    this.disposeFor = opts.disposeFor;
+    this.maxSessions = Number.isFinite(opts.maxSessions) && (opts.maxSessions ?? 0) > 0 ? Math.floor(opts.maxSessions) : DEFAULT_MAX_SESSIONS;
     this.store = opts.store;
     if (typeof this.transport.onMessage === "function") {
       this.transport.onMessage((m) => this.maybeResolvePending(m));
@@ -315,8 +377,9 @@ var ACPProtocolHandler = class {
   }
   /** Abort all active turns and drop session state. */
   close() {
-    for (const [, session] of this.sessions) {
+    for (const [sessionId, session] of this.sessions) {
       session.abort.abort();
+      this.disposeSession(sessionId);
     }
     this.sessions.clear();
     for (const [, p] of this.pendingOut) {
@@ -325,6 +388,12 @@ var ACPProtocolHandler = class {
     }
     this.pendingOut.clear();
   }
+  disposeSession(sessionId) {
+    try {
+      this.disposeFor?.(sessionId);
+    } catch {
+    }
+  }
   // ────────────────────────────────────────────────────────────────────
   // Requests
   // ────────────────────────────────────────────────────────────────────
@@ -444,6 +513,10 @@ var ACPProtocolHandler = class {
     return false;
   }
   async handleSessionNew(id, params) {
+    if (this.sessions.size >= this.maxSessions) {
+      await this.sendError(id, -32e3, `active session limit reached (${this.maxSessions})`);
+      return false;
+    }
     const p = params ?? {};
     const cwd = typeof p.cwd === "string" ? p.cwd : this.defaultCwd;
     const sessionId = `sess_${this.allocId()}`;
@@ -494,6 +567,10 @@ var ACPProtocolHandler = class {
     if (!existing && sessionId && this.store) {
       const persisted = await this.store.load(sessionId);
       if (persisted) {
+        if (this.sessions.size >= this.maxSessions) {
+          await this.sendError(id, -32e3, `active session limit reached (${this.maxSessions})`);
+          return false;
+        }
         const restored = {
           id: sessionId,
           cwd: persisted.cwd ?? loadCwd ?? this.defaultCwd,
@@ -589,7 +666,10 @@ var ACPProtocolHandler = class {
       return false;
     }
     session.abort.abort();
-    if (sessionId) this.sessions.delete(sessionId);
+    if (sessionId) {
+      this.sessions.delete(sessionId);
+      this.disposeSession(sessionId);
+    }
     await this.transport.send(toWire({
       jsonrpc: "2.0",
       id,
@@ -611,6 +691,7 @@ var ACPProtocolHandler = class {
     const session = this.sessions.get(sessionId);
     session.abort.abort();
     this.sessions.delete(sessionId);
+    this.disposeSession(sessionId);
     await this.transport.send(toWire({
       jsonrpc: "2.0",
       id,
@@ -626,6 +707,10 @@ var ACPProtocolHandler = class {
       await this.sendError(id, -32e3, `session not found: ${sourceId}`);
       return false;
     }
+    if (this.sessions.size >= this.maxSessions) {
+      await this.sendError(id, -32e3, `active session limit reached (${this.maxSessions})`);
+      return false;
+    }
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const sessionId = `sess_${this.allocId()}`;
     const forked = {
@@ -1094,7 +1179,7 @@ var WsBridgeTransport = class {
 // src/agent/wrongstack-acp-agent.ts
 import { fileURLToPath } from "node:url";
 import { createServer } from "node:http";
-import { writeErr as writeErr2 } from "@wrongstack/core";
+import { writeErr as writeErr2 } from "@wrongstack/core/utils";
 var WrongStackACPServer = class {
   transport;
   handler;
@@ -1113,6 +1198,7 @@ var WrongStackACPServer = class {
       agentName: opts.agentName,
       ...opts.replayFor ? { replayFor: opts.replayFor } : {},
       ...opts.seedFor ? { seedFor: opts.seedFor } : {},
+      ...opts.disposeFor ? { disposeFor: opts.disposeFor } : {},
       ...opts.store ? { store: opts.store } : {}
     });
   }
@@ -1134,13 +1220,17 @@ var WrongStackACPServer = class {
       this.transport.sendStartupMarker();
     }
     this.running = true;
-    while (this.running) {
-      const msg = await this.transport.read();
-      if (!msg) break;
-      const terminal = await this.handler.handleMessage(msg);
-      if (terminal) break;
+    try {
+      while (this.running) {
+        const msg = await this.transport.read();
+        if (!msg) break;
+        const terminal = await this.handler.handleMessage(msg);
+        if (terminal) break;
+      }
+    } finally {
+      this.handler.close();
+      this.transport.close();
     }
-    this.transport.close();
   }
   async startHttp(port) {
     const host = this.options.host ?? "127.0.0.1";
@@ -1255,6 +1345,7 @@ var WrongStackACPServer = class {
   /** Stop the server. */
   stop() {
     this.running = false;
+    this.handler.close();
     this.transport.close();
     if (this.httpServer) {
       this.httpServer.close();
@@ -1283,8 +1374,11 @@ function makeACPServerAgentTurn(opts) {
   const agents = /* @__PURE__ */ new Map();
   const timeouts = /* @__PURE__ */ new Map();
   const history = /* @__PURE__ */ new Map();
+  const historyBytes = /* @__PURE__ */ new Map();
   const pendingSeed = /* @__PURE__ */ new Set();
   const timeoutMs = opts.timeoutMs ?? 5 * 6e4;
+  const maxHistoryEntries = finitePositiveLimit(opts.maxHistoryEntries, 1e3);
+  const maxHistoryBytes = finitePositiveLimit(opts.maxHistoryBytes, 8 * 1024 * 1024);
   const turn = async (input, emit, api) => {
     let agent = agents.get(input.sessionId);
     if (!agent) {
@@ -1348,13 +1442,36 @@ function makeACPServerAgentTurn(opts) {
       }
       const userText = promptToText(input.prompt);
       const hist = history.get(input.sessionId) ?? [];
+      let retainedHistoryBytes = historyBytes.get(input.sessionId) ?? 0;
       if (userText) {
-        hist.push({ sessionUpdate: "user_message_chunk", content: { type: "text", text: userText } });
+        const update = {
+          sessionUpdate: "user_message_chunk",
+          content: { type: "text", text: userText }
+        };
+        hist.push(update);
+        retainedHistoryBytes += replayEntryBytes(update);
       }
       if (text) {
-        hist.push({ sessionUpdate: "agent_message_chunk", content: { type: "text", text } });
+        const update = {
+          sessionUpdate: "agent_message_chunk",
+          content: { type: "text", text }
+        };
+        hist.push(update);
+        retainedHistoryBytes += replayEntryBytes(update);
+      }
+      retainedHistoryBytes = trimHistory(
+        hist,
+        retainedHistoryBytes,
+        maxHistoryEntries,
+        maxHistoryBytes
+      );
+      if (hist.length > 0) {
+        history.set(input.sessionId, hist);
+        historyBytes.set(input.sessionId, retainedHistoryBytes);
+      } else {
+        history.delete(input.sessionId);
+        historyBytes.delete(input.sessionId);
       }
-      if (hist.length > 0) history.set(input.sessionId, hist);
       const plan = extractPlan(result);
       if (plan.length > 0) {
         emit({
@@ -1388,13 +1505,46 @@ function makeACPServerAgentTurn(opts) {
       for (const u of unsub) u();
     }
   };
-  const replay = (sessionId) => history.get(sessionId) ?? [];
+  const replay = (sessionId) => [
+    ...history.get(sessionId) ?? []
+  ];
   const seed = (sessionId, incoming) => {
     if (incoming.length === 0) return;
-    history.set(sessionId, [...incoming]);
+    const seeded = [...incoming];
+    const retainedBytes = trimHistory(
+      seeded,
+      seeded.reduce((total, entry) => total + replayEntryBytes(entry), 0),
+      maxHistoryEntries,
+      maxHistoryBytes
+    );
+    history.set(sessionId, seeded);
+    historyBytes.set(sessionId, retainedBytes);
     pendingSeed.add(sessionId);
   };
-  return Object.assign(turn, { replay, seed });
+  const dispose = (sessionId) => {
+    const timer = timeouts.get(sessionId);
+    if (timer) clearTimeout(timer);
+    timeouts.delete(sessionId);
+    agents.delete(sessionId);
+    history.delete(sessionId);
+    historyBytes.delete(sessionId);
+    pendingSeed.delete(sessionId);
+  };
+  return Object.assign(turn, { replay, seed, dispose });
+}
+function finitePositiveLimit(value, fallback) {
+  return Number.isFinite(value) && (value ?? 0) > 0 ? Math.floor(value) : fallback;
+}
+function trimHistory(entries, retainedBytes, maxEntries, maxBytes) {
+  while (entries.length > maxEntries || retainedBytes > maxBytes) {
+    const removed = entries.shift();
+    if (!removed) break;
+    retainedBytes -= replayEntryBytes(removed);
+  }
+  return Math.max(0, retainedBytes);
+}
+function replayEntryBytes(entry) {
+  return Buffer.byteLength(JSON.stringify(entry), "utf8");
 }
 function seedAgentContext(agent, history) {
   const state = agent.ctx?.state;