maxpool 1.5.52 → 1.5.54

package/package.json

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

package/src/index.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 
+import net from 'node:net';
 import { spawn, spawnSync } from 'node:child_process';
 import { createInterface } from 'node:readline';
 import { loadOrCreateConfig, loadConfig, saveConfig, atomicConfigUpdate, getConfigPath, loadState, saveState, getStatePath, getLogPath, readGeneration, flushConfigWrites, flushStateWrites } from './config.js';
@@ -7,6 +8,24 @@ import { setEventLogPath, installConsoleMirror, setConsoleStdoutSuppressed } fro
 import { SleepGuard } from './sleep-guard.js';
 import { AccountManager } from './account-manager.js';
 import { createProxyServer, REQUEST_IDLE_MAX_MS } from './server.js';
+
+// ── Happy Eyeballs: stop racing a dead IPv6 leg ────────────────────────────────
+// Node 20 resolves both families and, 250ms after starting the IPv4 connect, races an
+// IPv6 one (autoSelectFamily, autoSelectFamilyAttemptTimeout=250). On a machine whose
+// resolver returns an AAAA that BLACKHOLES — a VPN advertising IPv6 it cannot carry is
+// the common case — that second leg never completes and takes the whole connect down
+// with it, surfacing as UND_ERR_CONNECT_TIMEOUT / ETIMEDOUT on a network that is
+// otherwise fine (curl, which falls back cleanly, succeeds in the same second).
+//
+// Measured 2026-08-01 on this fleet: 6,848 connect failures in one day; A/B over 14
+// requests gave 12/14 at the 250ms default vs 14/14 with the timeout raised. Raising it
+// is preferred over disabling the race outright: real IPv6 still wins where it works,
+// and a blackholed leg simply loses instead of poisoning the attempt. `dns
+// setDefaultResultOrder('ipv4first')` was ALSO measured and is NOT reliable (6 of 14 in a
+// degraded window) — it reorders preference but still starts the doomed leg.
+net.setDefaultAutoSelectFamilyAttemptTimeout(
+  Math.max(1000, Number(process.env.MAXPOOL_FAMILY_ATTEMPT_TIMEOUT_MS) || 5000),
+);
 import { Prober } from './prober.js';
 import { loginOAuth, fetchProfile, refreshAccessToken, isTokenExpiringSoon, tokenFingerprint } from './oauth.js';
 import { TUI } from './tui.js';

package/src/server.js

@@ -256,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 = [];
@@ -2407,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/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}` : '';