maxpool 1.5.51 → 1.5.53

package/package.json

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

package/src/server.js

@@ -60,6 +60,13 @@ const DEFAULT_QUEUE = {
   maxWaitMs: 24 * 60 * 60 * 1000,
   autoMaxWaitMs: null,
   capacityMaxWaitMs: 15 * 60 * 1000,
+  // NETWORK-cause hold ceiling. A quota/capacity hold is worth waiting out — a reset is
+  // genuinely coming. A NETWORK hold is not: the connection is dead, and holding it just
+  // parks the caller on a socket nothing is watching. On 2026-07-28 a request was held
+  // 10,445s (2h54m) having produced ZERO bytes; nothing aborted it until the user touched
+  // the keyboard. Give up quickly instead and return a retryable 429, so the client
+  // reconnects on a FRESH connection — which is what actually self-heals a dead route.
+  networkMaxWaitMs: 2 * 60 * 1000,
   weeklyMaxWaitMs: 24 * 60 * 60 * 1000, // legacy bound; streaming holds use streamHoldMaxMs
   // STREAMING hold ceiling: how long a streaming request may be HELD ALIVE on
   // the SSE heartbeat waiting for any account to free up. Defaults to 7d (the
@@ -249,7 +256,7 @@ export function createProxyServer(accountManager, config, hooks = {}) {
       let requestInfo = {};
       // Backstop reaper (defense-in-depth for any UNKNOWN future hang the specific
       // TTFB/idle/body/drain guards don't cover). See startIdleRequestReaper.
-      const reaperTimer = startIdleRequestReaper(res, reqId, REQUEST_IDLE_MAX_MS);
+      const reaperTimer = startIdleRequestReaper(res, reqId, REQUEST_IDLE_MAX_MS, { getRequestInfo: () => requestInfo });
       try {
         // Buffer request body (needed for retry on 429)
         const bodyChunks = [];
@@ -1387,7 +1394,7 @@ function formatRetryDuration(seconds) {
 function computeQueueWindowMs({
   cause, stream, retryPlanCause,
   maxWaitMs, capacityMaxWaitMs, nonStreamMaxWaitMs, streamHoldMaxMs, streamClientToleranceMs,
-  isCountTokens, countTokensMaxWaitMs,
+  isCountTokens, countTokensMaxWaitMs, networkMaxWaitMs,
 }) {
   let windowMs;
   if (!stream) {
@@ -1408,6 +1415,11 @@ function computeQueueWindowMs({
   // the upstream processing once acquired) so a non-heartbeated metadata call fast-
   // fails with a retryable 429 instead of hanging past the client's idle window.
   if (isCountTokens && countTokensMaxWaitMs != null) windowMs = Math.min(windowMs, countTokensMaxWaitMs);
+  // A dead ROUTE is not a scheduled reset: holding it out is waiting for nothing. Cap it
+  // hard, independent of how patient the client is — a raised CLAUDE_STREAM_IDLE_TIMEOUT_MS
+  // (the `cc` alias sets 3h) otherwise licenses a multi-hour hold on a connection that is
+  // simply gone. Error-fast + client reconnect beats an unattended hold.
+  if (cause === 'network' && networkMaxWaitMs != null) windowMs = Math.min(windowMs, networkMaxWaitMs);
   return windowMs;
 }
 
@@ -1950,6 +1962,9 @@ async function queueAndRetry(
   const streamClientToleranceMs = queueConfig.streamClientToleranceMs == null
     ? 3 * 60 * 60 * 1000
     : Math.max(0, Number(queueConfig.streamClientToleranceMs) || 0);
+  const networkMaxWaitMs = queueConfig.networkMaxWaitMs == null
+    ? 2 * 60 * 1000
+    : Math.max(0, Number(queueConfig.networkMaxWaitMs) || 0);
   const queueWindowMs = computeQueueWindowMs({
     cause,
     stream: Boolean(requestInfo.stream),
@@ -1957,6 +1972,7 @@ async function queueAndRetry(
     maxWaitMs,
     capacityMaxWaitMs,
     nonStreamMaxWaitMs,
+    networkMaxWaitMs,
     streamHoldMaxMs,
     streamClientToleranceMs,
     isCountTokens: Boolean(requestInfo.isCountTokens),
@@ -2391,12 +2407,24 @@ function mappedModel(originalModel, account) {
  * (which has no idempotency guard). Clock/timer injectable for tests. Returns the
  * interval handle (caller clearInterval()s it in the request's finally).
  */
-function startIdleRequestReaper(res, reqId, idleMs, { now = Date.now, setIntervalFn = setInterval } = {}) {
+function startIdleRequestReaper(res, reqId, idleMs, { now = Date.now, setIntervalFn = setInterval, getRequestInfo = null } = {}) {
   let lastBytes = res.socket?.bytesWritten ?? 0;
   let lastProgressAt = now();
   const timer = setIntervalFn(() => {
+    // Count only REAL progress. `bytesWritten` includes maxpool's OWN queue keepalive,
+    // which pings every 10s — so a request stuck forever kept resetting this watchdog with
+    // our own noise and could never be reaped. Observed 2026-07-29: 50 requests pinned
+    // "in-flight" on one account for up to 6.7h, serving zero, which distorted the load
+    // balancer into avoiding a healthy account. A held request is progressing only if the
+    // UPSTREAM produced something; heartbeat bytes prove nothing.
+    const heldOnHeartbeat = Boolean(getRequestInfo?.()?.queueHeartbeatActive);
     const bytes = res.socket?.bytesWritten ?? lastBytes;
-    if (bytes !== lastBytes) { lastBytes = bytes; lastProgressAt = now(); return; }
+    if (bytes !== lastBytes) {
+      lastBytes = bytes;
+      if (!heldOnHeartbeat) { lastProgressAt = now(); return; }
+      // Held: those bytes were OUR keepalive, so they are not progress — deliberately
+      // fall through to the staleness check rather than returning.
+    }
     if (now() - lastProgressAt >= idleMs && !res.writableEnded && !res.destroyed) {
       console.error(`[Maxpool] Request ${reqId} — no write progress for ${Math.round(idleMs / 1000)}s (backstop reaper); force-aborting a stuck request to free its account slot`);
       res.destroy();

package/src/sleep-guard.js

@@ -11,7 +11,12 @@
 import { spawn as realSpawn } from 'node:child_process';
 
 const POLL_MS = 5_000;      // re-check the in-flight signal (idle-sleep timers are minutes)
-const GRACE_MS = 60_000;    // stay awake this long after the last request, to bridge gaps
+// Stay awake this long after the last request. 60s lost a measured race on 2026-07-28: a
+// network outage drained all in-flight work, the guard released exactly 74s later, and
+// macOS (idle-sleep timer) slept in the SAME SECOND — so the machine went down while the
+// outage was still in progress and recovery had to wait for a keystroke. 5 minutes bridges
+// an outage-shaped gap without meaningfully delaying a genuinely idle sleep.
+const GRACE_MS = 300_000;
 
 export class SleepGuard {
   constructor({ getWorkPending, log = () => {}, spawn = realSpawn, enabled, pollMs = POLL_MS, graceMs = GRACE_MS } = {}) {

package/src/tui.js

@@ -1214,7 +1214,11 @@ export class TUI {
 
     // Active requests
     const now = Date.now();
-    for (const [, r] of this.active) {
+    // NEWEST FIRST, matching the completed log directly below (which is `unshift`ed).
+    // A Map iterates in INSERTION order, so this block used to run oldest-first while the
+    // log under it ran newest-first — the panel disagreed with itself and the newest thing
+    // that happened was buried in the middle of the screen.
+    for (const [, r] of [...this.active].reverse()) {
       const el = ((now - r.started) / 1000).toFixed(1);
       const sp = cyan(SPINNER[this.frame]);
       const a = r.account ? ` → ${r.account}` : '';