@wrongstack/acp 0.319.1 → 1.0.0

package/dist/agent/wrongstack-acp-agent.d.ts

@@ -77,6 +77,8 @@ export declare class WrongStackACPServer {
     private readonly options;
     /** HTTP server when transport mode is HTTP. */
     private httpServer;
+    /** Live sockets on `httpServer`; destroyed on `stop()` so `close()` settles. */
+    private readonly httpSockets;
     private running;
     constructor(opts?: WrongStackACPServerOptions);
     /**
@@ -87,8 +89,22 @@ export declare class WrongStackACPServer {
     start(): Promise<void>;
     private startStdio;
     private startHttp;
-    /** Stop the server. */
-    stop(): void;
+    /**
+     * `listen()` reports failure through an `'error'` event, not the callback.
+     * Without a listener that event is an unhandled exception *and* the start
+     * promise never settles — a hang rather than a diagnosable failure.
+     *
+     * An ephemeral bind (`port === 0`) additionally retries the transient
+     * resource-exhaustion codes: under a saturated parallel test run the OS can
+     * momentarily have no buffer or port to hand out even though nothing is wrong.
+     */
+    private listenWithRetry;
+    /**
+     * Stop the server. Resolves once the HTTP handle is fully closed, so a
+     * caller (a test `afterEach`, a restart) cannot race its next bind against
+     * sockets this server still owns.
+     */
+    stop(): Promise<void>;
 }
 declare function headerValue(value: string | string[] | undefined): string | undefined;
 declare function requestPath(value: string | undefined): string;

package/dist/agent.js

@@ -1623,12 +1623,16 @@ import { createServer } from "node:http";
 import { isIP } from "node:net";
 import { fileURLToPath } from "node:url";
 import { expandIPv6, writeErr as writeErr2 } from "@wrongstack/core/utils";
+var LISTEN_RETRY_LIMIT = 5;
+var LISTEN_RETRY_BASE_MS = 25;
 var WrongStackACPServer = class {
   transport;
   handler;
   options;
   /** HTTP server when transport mode is HTTP. */
   httpServer = null;
+  /** Live sockets on `httpServer`; destroyed on `stop()` so `close()` settles. */
+  httpSockets = /* @__PURE__ */ new Set();
   running = false;
   constructor(opts = {}) {
     this.options = opts;
@@ -1683,7 +1687,7 @@ var WrongStackACPServer = class {
       throw new Error("ACP HTTP transport requires authToken for non-loopback hosts");
     }
     let httpChain = Promise.resolve();
-    this.httpServer = createServer(async (req, res) => {
+    const httpServer = createServer(async (req, res) => {
       if (authToken) {
         const url = new URL(requestPath(req.url), `http://${host}:${port}`);
         const bearerToken = headerValue(req.headers.authorization)?.replace(/^Bearer\s+/i, "");
@@ -1780,24 +1784,73 @@ var WrongStackACPServer = class {
         res.end(JSON.stringify({ error: { code: -32603, message: "Internal error" } }));
       }
     });
-    return new Promise((resolve2) => {
-      this.httpServer.listen(port, host, () => {
-        writeErr2(`[wstack-acp] HTTP server listening on http://${host}:${port}
+    this.httpServer = httpServer;
+    const sockets = this.httpSockets;
+    httpServer.on("connection", (socket) => {
+      sockets.add(socket);
+      socket.on("close", () => sockets.delete(socket));
+    });
+    await this.listenWithRetry(port, host);
+    const bound = httpServer.address();
+    const shown = typeof bound === "object" && bound ? bound.port : port;
+    writeErr2(`[wstack-acp] HTTP server listening on http://${host}:${shown}
 `);
-        this.running = true;
+    this.running = true;
+  }
+  /**
+   * `listen()` reports failure through an `'error'` event, not the callback.
+   * Without a listener that event is an unhandled exception *and* the start
+   * promise never settles — a hang rather than a diagnosable failure.
+   *
+   * An ephemeral bind (`port === 0`) additionally retries the transient
+   * resource-exhaustion codes: under a saturated parallel test run the OS can
+   * momentarily have no buffer or port to hand out even though nothing is wrong.
+   */
+  listenWithRetry(port, host, attempt = 0) {
+    const server = this.httpServer;
+    if (!server) return Promise.resolve();
+    return new Promise((resolve2, reject) => {
+      const onListening = () => {
+        server.removeListener("error", onError);
         resolve2();
-      });
+      };
+      const onError = (err) => {
+        server.removeListener("listening", onListening);
+        const transient = err.code === "ENOBUFS" || err.code === "EADDRINUSE" || err.code === "EADDRNOTAVAIL";
+        if (port === 0 && transient && attempt < LISTEN_RETRY_LIMIT) {
+          const timer = setTimeout(
+            () => {
+              this.listenWithRetry(port, host, attempt + 1).then(resolve2, reject);
+            },
+            LISTEN_RETRY_BASE_MS * (attempt + 1)
+          );
+          timer.unref?.();
+          return;
+        }
+        reject(err);
+      };
+      server.once("error", onError);
+      server.once("listening", onListening);
+      server.listen(port, host);
     });
   }
-  /** Stop the server. */
-  stop() {
+  /**
+   * Stop the server. Resolves once the HTTP handle is fully closed, so a
+   * caller (a test `afterEach`, a restart) cannot race its next bind against
+   * sockets this server still owns.
+   */
+  async stop() {
     this.running = false;
     this.handler.close();
     this.transport.close();
-    if (this.httpServer) {
-      this.httpServer.close();
-      this.httpServer = null;
-    }
+    const server = this.httpServer;
+    this.httpServer = null;
+    if (!server) return;
+    for (const socket of this.httpSockets) socket.destroy();
+    this.httpSockets.clear();
+    await new Promise((resolve2) => {
+      server.close(() => resolve2());
+    });
   }
 };
 var defaultEchoRunTurn = async (_input, _emit) => {

package/dist/client.js

@@ -2337,6 +2337,7 @@ var ToolTranslator = class {
   cancelAll() {
     for (const [, p] of this.pending) {
       clearTimeout(p.timeout);
+      p.reject(new Error("Call cancelled by client"));
     }
     this.pending.clear();
   }

package/dist/index.js

@@ -1298,12 +1298,16 @@ import { createServer } from "node:http";
 import { isIP } from "node:net";
 import { fileURLToPath } from "node:url";
 import { expandIPv6, writeErr as writeErr2 } from "@wrongstack/core/utils";
+var LISTEN_RETRY_LIMIT = 5;
+var LISTEN_RETRY_BASE_MS = 25;
 var WrongStackACPServer = class {
   transport;
   handler;
   options;
   /** HTTP server when transport mode is HTTP. */
   httpServer = null;
+  /** Live sockets on `httpServer`; destroyed on `stop()` so `close()` settles. */
+  httpSockets = /* @__PURE__ */ new Set();
   running = false;
   constructor(opts = {}) {
     this.options = opts;
@@ -1358,7 +1362,7 @@ var WrongStackACPServer = class {
       throw new Error("ACP HTTP transport requires authToken for non-loopback hosts");
     }
     let httpChain = Promise.resolve();
-    this.httpServer = createServer(async (req, res) => {
+    const httpServer = createServer(async (req, res) => {
       if (authToken) {
         const url = new URL(requestPath(req.url), `http://${host}:${port}`);
         const bearerToken = headerValue(req.headers.authorization)?.replace(/^Bearer\s+/i, "");
@@ -1455,24 +1459,73 @@ var WrongStackACPServer = class {
         res.end(JSON.stringify({ error: { code: -32603, message: "Internal error" } }));
       }
     });
-    return new Promise((resolve4) => {
-      this.httpServer.listen(port, host, () => {
-        writeErr2(`[wstack-acp] HTTP server listening on http://${host}:${port}
+    this.httpServer = httpServer;
+    const sockets = this.httpSockets;
+    httpServer.on("connection", (socket) => {
+      sockets.add(socket);
+      socket.on("close", () => sockets.delete(socket));
+    });
+    await this.listenWithRetry(port, host);
+    const bound = httpServer.address();
+    const shown = typeof bound === "object" && bound ? bound.port : port;
+    writeErr2(`[wstack-acp] HTTP server listening on http://${host}:${shown}
 `);
-        this.running = true;
+    this.running = true;
+  }
+  /**
+   * `listen()` reports failure through an `'error'` event, not the callback.
+   * Without a listener that event is an unhandled exception *and* the start
+   * promise never settles — a hang rather than a diagnosable failure.
+   *
+   * An ephemeral bind (`port === 0`) additionally retries the transient
+   * resource-exhaustion codes: under a saturated parallel test run the OS can
+   * momentarily have no buffer or port to hand out even though nothing is wrong.
+   */
+  listenWithRetry(port, host, attempt = 0) {
+    const server = this.httpServer;
+    if (!server) return Promise.resolve();
+    return new Promise((resolve4, reject) => {
+      const onListening = () => {
+        server.removeListener("error", onError);
         resolve4();
-      });
+      };
+      const onError = (err) => {
+        server.removeListener("listening", onListening);
+        const transient = err.code === "ENOBUFS" || err.code === "EADDRINUSE" || err.code === "EADDRNOTAVAIL";
+        if (port === 0 && transient && attempt < LISTEN_RETRY_LIMIT) {
+          const timer = setTimeout(
+            () => {
+              this.listenWithRetry(port, host, attempt + 1).then(resolve4, reject);
+            },
+            LISTEN_RETRY_BASE_MS * (attempt + 1)
+          );
+          timer.unref?.();
+          return;
+        }
+        reject(err);
+      };
+      server.once("error", onError);
+      server.once("listening", onListening);
+      server.listen(port, host);
     });
   }
-  /** Stop the server. */
-  stop() {
+  /**
+   * Stop the server. Resolves once the HTTP handle is fully closed, so a
+   * caller (a test `afterEach`, a restart) cannot race its next bind against
+   * sockets this server still owns.
+   */
+  async stop() {
     this.running = false;
     this.handler.close();
     this.transport.close();
-    if (this.httpServer) {
-      this.httpServer.close();
-      this.httpServer = null;
-    }
+    const server = this.httpServer;
+    this.httpServer = null;
+    if (!server) return;
+    for (const socket of this.httpSockets) socket.destroy();
+    this.httpSockets.clear();
+    await new Promise((resolve4) => {
+      server.close(() => resolve4());
+    });
   }
 };
 var defaultEchoRunTurn = async (_input, _emit) => {
@@ -3474,6 +3527,7 @@ var ToolTranslator = class {
   cancelAll() {
     for (const [, p] of this.pending) {
       clearTimeout(p.timeout);
+      p.reject(new Error("Call cancelled by client"));
     }
     this.pending.clear();
   }

package/dist/wrongstack-acp-agent.js

@@ -942,12 +942,16 @@ var StdioTransport = class {
 };
 
 // src/agent/wrongstack-acp-agent.ts
+var LISTEN_RETRY_LIMIT = 5;
+var LISTEN_RETRY_BASE_MS = 25;
 var WrongStackACPServer = class {
   transport;
   handler;
   options;
   /** HTTP server when transport mode is HTTP. */
   httpServer = null;
+  /** Live sockets on `httpServer`; destroyed on `stop()` so `close()` settles. */
+  httpSockets = /* @__PURE__ */ new Set();
   running = false;
   constructor(opts = {}) {
     this.options = opts;
@@ -1002,7 +1006,7 @@ var WrongStackACPServer = class {
       throw new Error("ACP HTTP transport requires authToken for non-loopback hosts");
     }
     let httpChain = Promise.resolve();
-    this.httpServer = createServer(async (req, res) => {
+    const httpServer = createServer(async (req, res) => {
       if (authToken) {
         const url = new URL(requestPath(req.url), `http://${host}:${port}`);
         const bearerToken = headerValue(req.headers.authorization)?.replace(/^Bearer\s+/i, "");
@@ -1099,24 +1103,73 @@ var WrongStackACPServer = class {
         res.end(JSON.stringify({ error: { code: -32603, message: "Internal error" } }));
       }
     });
-    return new Promise((resolve2) => {
-      this.httpServer.listen(port, host, () => {
-        writeErr2(`[wstack-acp] HTTP server listening on http://${host}:${port}
+    this.httpServer = httpServer;
+    const sockets = this.httpSockets;
+    httpServer.on("connection", (socket) => {
+      sockets.add(socket);
+      socket.on("close", () => sockets.delete(socket));
+    });
+    await this.listenWithRetry(port, host);
+    const bound = httpServer.address();
+    const shown = typeof bound === "object" && bound ? bound.port : port;
+    writeErr2(`[wstack-acp] HTTP server listening on http://${host}:${shown}
 `);
-        this.running = true;
+    this.running = true;
+  }
+  /**
+   * `listen()` reports failure through an `'error'` event, not the callback.
+   * Without a listener that event is an unhandled exception *and* the start
+   * promise never settles — a hang rather than a diagnosable failure.
+   *
+   * An ephemeral bind (`port === 0`) additionally retries the transient
+   * resource-exhaustion codes: under a saturated parallel test run the OS can
+   * momentarily have no buffer or port to hand out even though nothing is wrong.
+   */
+  listenWithRetry(port, host, attempt = 0) {
+    const server = this.httpServer;
+    if (!server) return Promise.resolve();
+    return new Promise((resolve2, reject) => {
+      const onListening = () => {
+        server.removeListener("error", onError);
         resolve2();
-      });
+      };
+      const onError = (err) => {
+        server.removeListener("listening", onListening);
+        const transient = err.code === "ENOBUFS" || err.code === "EADDRINUSE" || err.code === "EADDRNOTAVAIL";
+        if (port === 0 && transient && attempt < LISTEN_RETRY_LIMIT) {
+          const timer = setTimeout(
+            () => {
+              this.listenWithRetry(port, host, attempt + 1).then(resolve2, reject);
+            },
+            LISTEN_RETRY_BASE_MS * (attempt + 1)
+          );
+          timer.unref?.();
+          return;
+        }
+        reject(err);
+      };
+      server.once("error", onError);
+      server.once("listening", onListening);
+      server.listen(port, host);
     });
   }
-  /** Stop the server. */
-  stop() {
+  /**
+   * Stop the server. Resolves once the HTTP handle is fully closed, so a
+   * caller (a test `afterEach`, a restart) cannot race its next bind against
+   * sockets this server still owns.
+   */
+  async stop() {
     this.running = false;
     this.handler.close();
     this.transport.close();
-    if (this.httpServer) {
-      this.httpServer.close();
-      this.httpServer = null;
-    }
+    const server = this.httpServer;
+    this.httpServer = null;
+    if (!server) return;
+    for (const socket of this.httpSockets) socket.destroy();
+    this.httpSockets.clear();
+    await new Promise((resolve2) => {
+      server.close(() => resolve2());
+    });
   }
 };
 var defaultEchoRunTurn = async (_input, _emit) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wrongstack/acp",
-  "version": "0.319.1",
+  "version": "1.0.0",
   "license": "MIT",
   "description": "ACP (Agent Client Protocol) integration for WrongStack — client + agent support",
   "keywords": [
@@ -52,7 +52,7 @@
   ],
   "dependencies": {
     "@agentclientprotocol/sdk": "^1.4.0",
-    "@wrongstack/core": "0.319.1"
+    "@wrongstack/core": "1.0.0"
   },
   "devDependencies": {
     "@types/node": "^26.2.0",