maxpool 1.24.17 → 1.24.19

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "maxpool",
-  "version": "1.24.17",
+  "version": "1.24.19",
   "description": "Multi-account Claude Code proxy with adaptive, rate-aware load balancing across Claude accounts",
   "type": "module",
   "main": "src/index.js",

package/src/restart-controller.js

@@ -87,17 +87,20 @@ export class RestartController {
     // Without the `pending` guard a second call (e.g. auto-apply firing while a manual
     // restart is draining) would orphan the first _drainTimer and re-log.
     if (this.restarting || this.pending) return;
-    this.pauseAdmission();
-    if (this.upstreamRequests.size === 0) {
+    // Seamless handoff → do not pre-drain AND do not pause admission. The old worker
+    // keeps serving everything it already holds after the baton passes — including
+    // requests WAITING in its queue. Pausing admission made the routing oracle report
+    // "no route will ever recover", so every queued waiter gave up at once: the
+    // v1.24.18 auto-update dropped 24 sessions that had waited 3-13 min (2026-10-11).
+    if (this.isSeamless()) {
+      if (this.upstreamRequests.size > 0) {
+        this.log(`[Maxpool] Restarting now — ${this.upstreamRequests.size} in-flight request(s) finish on the current version; new requests go to the updated one.`);
+      }
       this._restart();
       return;
     }
-
-    // Seamless handoff → do not pre-drain (see isSeamless above). The in-flight
-    // requests finish on the OLD worker after the baton passes; holding admission
-    // here would only 503 the rest of the fleet for nothing.
-    if (this.isSeamless()) {
-      this.log(`[Maxpool] Restarting now — ${this.upstreamRequests.size} in-flight request(s) finish on the current version; new requests go to the updated one.`);
+    this.pauseAdmission();
+    if (this.upstreamRequests.size === 0) {
       this._restart();
       return;
     }

package/src/server.js

@@ -163,7 +163,14 @@ export function createProxyServer(accountManager, config, hooks = {}) {
   // upstream-bound request headers elsewhere.
   const workerStamp = String(process.pid);
 
-  const server = http.createServer(async (req, res) => {
+  // REQUEST-ARRIVAL TIMEOUTS (2026-10-11 outage). Node's defaults (300s request
+  // timeout, 30s checking interval) are what fired live — but they must be in the
+  // constructor to be settable at all (property assignment after listen is a no-op
+  // in Node 20, measured), so they are read here, env-tunable, never mutated later.
+  const server = http.createServer({
+    requestTimeout: Math.max(1_000, Number(process.env.MAXPOOL_REQUEST_TIMEOUT_MS) || 300_000),
+    connectionsCheckingInterval: Math.max(100, Number(process.env.MAXPOOL_CONNECTIONS_CHECK_MS) || 30_000),
+  }, async (req, res) => {
     try {
       // Disable Nagle on the client socket: flush each SSE event immediately instead
       // of coalescing small writes into bursts. Smooths streaming cadence toward the
@@ -343,6 +350,28 @@ export function createProxyServer(accountManager, config, hooks = {}) {
   // this releasing worker.
   server.maxpoolBeginDrain = () => { draining = true; };
 
+  // STALLED-UPLOAD ANSWER (2026-10-11 outage). When a request body never finishes
+  // arriving, Node's requestTimeout fires and its default handler writes a BODY-LESS
+  // `408 Request Timeout`, which Claude Code surfaces as the opaque "API Error: 408
+  // status code (no body)" (1,711 of them overnight, while the Mac's network stack
+  // was starved). Answer with the standard Anthropic error envelope instead, naming
+  // the actual cause, so the user sees a real message and the CLI treats it like any
+  // other retryable API error. Every other client error keeps Node's own handling.
+  server.on('clientError', (err, socket) => {
+    if (err?.code === 'ERR_HTTP_REQUEST_TIMEOUT' && socket.writable && !socket._httpMessage?.headersSent) {
+      const body = JSON.stringify({
+        type: 'error',
+        error: {
+          type: 'request_timeout',
+          message: 'Maxpool did not receive the full request in time (the upload stalled — usually a network problem on this machine). Retrying should work once the network recovers.',
+        },
+      });
+      socket.end(`HTTP/1.1 408 Request Timeout\r\nContent-Type: application/json\r\nContent-Length: ${Buffer.byteLength(body)}\r\nConnection: close\r\n\r\n${body}`);
+      return;
+    }
+    socket.destroy(err);
+  });
+
   return server;
 }