maxpool 1.5.5 → 1.5.7

package/package.json

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

package/src/account-manager.js

@@ -1432,11 +1432,15 @@ export class AccountManager {
 
     const ramp = this._recoveryRamp(account, now);
     const failurePenalty = account.consecutiveFailures * 5;
-    // Bias toward an account whose weekly quota is still unknown so it gets
-    // probed and learned (matches the legacy unknown-quota exploration nudge).
-    const explorationBonus = account.quota.unified7dReset == null ? -0.5 : 0;
-
-    return concurrency + capPenalty + paceCost + spread + ramp + failurePenalty + explorationBonus;
+    // NO unknown-quota bonus. An account whose quota we cannot see must never be
+    // MORE attractive than a known-healthy one — the old -0.5 nudge (safe only
+    // while the prober quickly resolved "unknown") turned into a relentless pull
+    // toward blind accounts once probing was off, driving an out-of-band-burned
+    // account to exhaustion. Unknown now scores neutral; the prober (on by
+    // default) learns the real number within a cycle. `probing`/requalify still
+    // flags a never-seen account for learning — that path is unchanged.
+
+    return concurrency + capPenalty + paceCost + spread + ramp + failurePenalty;
   }
 
   /**

package/src/config.js

@@ -46,6 +46,10 @@ export function createDefaultConfig() {
       apiKey: 'mp-' + randomBytes(24).toString('base64url'),
     },
     upstream: 'https://api.anthropic.com',
+    // (macOS) Keep the system awake while requests are in flight so long overnight
+    // streams survive Maintenance Sleep; the Mac sleeps normally when idle. Set false
+    // to disable. AC power only; the display still sleeps (screen stays dark).
+    preventSleep: true,
     // On startup, check npm for a newer maxpool and notify. Set false to disable.
     updateCheck: true,
     // When true, a newer version is installed automatically (npm i -g maxpool@latest)
@@ -58,7 +62,11 @@ export function createDefaultConfig() {
     // Raise toward 0.97 to squeeze more out of accounts before rotating
     // (less margin, slightly higher 429 risk); lower to rotate more eagerly.
     switchThreshold: 0.90,
-    quotaProbeSeconds: 0, // background quota probe; 0 = off (opt-in)
+    // Background quota probe: poll every account's real 5h/7d utilization from the
+    // zero-spend usage endpoint every N seconds. ON by default — without it maxpool
+    // is blind to idle / out-of-band-used accounts and the scorer will pile traffic
+    // onto exactly the account it cannot see. 0 = off.
+    quotaProbeSeconds: 60,
     routing: {
       mode: 'automatic',
       preferredAccount: null,
@@ -131,8 +139,9 @@ export async function loadConfig() {
     if (err.code === 'ENOENT') return null;
     throw err;
   }
+  let parsed;
   try {
-    return JSON.parse(raw);
+    parsed = JSON.parse(raw);
   } catch (err) {
     // With atomic temp+rename writes a torn read is impossible, so a parse
     // failure means genuine corruption. Surface it clearly rather than as a
@@ -140,6 +149,18 @@ export async function loadConfig() {
     // the file with defaults and lose recoverable OAuth credentials.
     throw new Error(`config at ${path} is not valid JSON (corrupt?): ${err.message}`);
   }
+  // Backfill top-level keys ABSENT from an older on-disk config with the current
+  // defaults, so a changed default (e.g. quotaProbeSeconds flipping on) actually
+  // reaches existing installs instead of shipping inert. A key that is present —
+  // even falsy, like an explicit `0` — is an intentional user choice and always
+  // wins; only genuinely-missing keys inherit the default.
+  if (parsed && typeof parsed === 'object') {
+    const defaults = createDefaultConfig();
+    for (const key of Object.keys(defaults)) {
+      if (!(key in parsed)) parsed[key] = defaults[key];
+    }
+  }
+  return parsed;
 }
 
 export async function loadOrCreateConfig() {

package/src/index.js

@@ -4,6 +4,7 @@ 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';
 import { setEventLogPath, installConsoleMirror } from './event-log.js';
+import { SleepGuard } from './sleep-guard.js';
 import { AccountManager } from './account-manager.js';
 import { createProxyServer } from './server.js';
 import { Prober } from './prober.js';
@@ -469,6 +470,14 @@ async function serverWorkerCommand() {
 
   const threshold = config.switchThreshold || 0.90;
   const accountManager = new AccountManager(accounts, threshold, config.scheduler || {});
+  // (macOS) Keep the system awake ONLY while there is work in flight or queued, so a
+  // long overnight streaming request survives Maintenance Sleep; the Mac sleeps
+  // normally when idle. Disable via `preventSleep: false` in config.
+  const sleepGuard = new SleepGuard({
+    enabled: config.preventSleep !== false && process.platform === 'darwin' && process.env.MAXPOOL_DISABLE_SLEEP_GUARD !== '1',
+    getWorkPending: () => accountManager.getGlobalInFlight() > 0 || accountManager.queueState.waiting.length > 0,
+    log: msg => console.log(`[Maxpool] ${msg}`),
+  });
   accountManager.setRoutingMode(
     config.routing?.mode,
     config.routing?.preferredAccount,
@@ -521,8 +530,13 @@ async function serverWorkerCommand() {
   // Persist quota every minute; unref so it never keeps the process alive.
   let quotaSaveInterval = null;
 
-  // Opt-in background quota probe (config.quotaProbeSeconds, default 0 = off).
-  const prober = new Prober(accountManager, { intervalMs: (config.quotaProbeSeconds || 0) * 1000 });
+  // Background quota probe (config.quotaProbeSeconds, default 60s). Keeps every
+  // account's real 5h/7d utilization fresh so the scorer is never blind to an idle
+  // or out-of-band-used account. MAXPOOL_DISABLE_QUOTA_PROBE=1 forces it off — used
+  // by spawned integration tests so a startup probe can't race their refresh/rotation
+  // assertions (mirrors MAXPOOL_DISABLE_SLEEP_GUARD).
+  const probeSeconds = process.env.MAXPOOL_DISABLE_QUOTA_PROBE === '1' ? 0 : (config.quotaProbeSeconds || 0);
+  const prober = new Prober(accountManager, { intervalMs: probeSeconds * 1000 });
 
   // Persist refreshed tokens back to config. Defense-in-depth: the updater reads
   // the on-disk refresh token and SKIPS the rotation if a fresher writer already
@@ -656,6 +670,7 @@ async function serverWorkerCommand() {
       quotaSaveInterval.unref?.();
     }
     prober.start();
+    sleepGuard.start(); // (macOS) keep the system awake while serving, so long streams survive Maintenance Sleep
   };
   // Stop scheduling writes and flip the lease. Returns a promise that settles
   // once any in-flight prober cycle has finished (so no probe-driven token
@@ -666,6 +681,7 @@ async function serverWorkerCommand() {
     hasLease = false;
     if (quotaSaveInterval) { clearInterval(quotaSaveInterval); quotaSaveInterval = null; }
     accountManager.setWriterLease(false);
+    sleepGuard.stop(); // release the wake — only the active lease-holder keeps the Mac awake
     await prober.stop(); // awaits any in-flight probe cycle (B1)
   };
 

package/src/prober.js

@@ -1,10 +1,11 @@
-// Opt-in background quota probe.
+// Background quota probe.
 //
-// DISABLED BY DEFAULT. When enabled (config.quotaProbeSeconds > 0), periodically
+// ON BY DEFAULT (config.quotaProbeSeconds, default 60s; 0 = off). Periodically
 // reads each OAuth account's quota from the zero-spend /api/oauth/usage endpoint
-// so idle accounts' utilization/reset stay fresh without waiting to be rotated
-// to — and without consuming any message quota. This is the one sanctioned
-// active-upstream feature; the proxy is otherwise passive.
+// so idle / out-of-band-used accounts' utilization/reset stay fresh without waiting
+// to be rotated to — and without consuming any message quota. Without it the scorer
+// is blind to an account it isn't actively routing to and will pile traffic onto it.
+// This is the one sanctioned active-upstream feature; the proxy is otherwise passive.
 
 import { fetchUsage } from './oauth.js';
 

package/src/sleep-guard.js

@@ -0,0 +1,77 @@
+// Conditional sleep guard (macOS): while maxpool has work in flight, prevent the
+// SYSTEM from sleeping so long-lived streaming requests survive overnight
+// Maintenance Sleep (which powers down the network stack and kills the
+// connection → "terminated"). When idle, it releases so the Mac sleeps normally.
+//
+// Uses the built-in `caffeinate -s` (prevent SYSTEM sleep only — the DISPLAY still
+// sleeps, so the screen stays dark) with `-w <pid>` so caffeinate auto-exits if the
+// worker dies (never a zombie keeping the Mac awake forever). `-s` is AC-power only
+// by design. Complete no-op off macOS or when disabled (e.g. the test suite).
+
+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
+
+export class SleepGuard {
+  constructor({ getWorkPending, log = () => {}, spawn = realSpawn, enabled, pollMs = POLL_MS, graceMs = GRACE_MS } = {}) {
+    this.getWorkPending = getWorkPending;   // () => boolean: true while there's active/queued work
+    this.log = log;
+    this._spawn = spawn;
+    this.enabled = enabled ?? (process.platform === 'darwin' && process.env.MAXPOOL_DISABLE_SLEEP_GUARD !== '1');
+    this.pollMs = pollMs;
+    this.graceMs = graceMs;
+    this.child = null;
+    this.pollTimer = null;
+    this.graceTimer = null;
+  }
+
+  start() {
+    if (!this.enabled || this.pollTimer) return;
+    this.pollTimer = setInterval(() => this._tick(), this.pollMs);
+    this.pollTimer.unref?.();
+    this._tick(); // engage immediately if there's already work
+  }
+
+  _tick() {
+    let pending = false;
+    try { pending = Boolean(this.getWorkPending?.()); } catch { pending = false; }
+    if (pending) {
+      if (this.graceTimer) { clearTimeout(this.graceTimer); this.graceTimer = null; }
+      this._ensureAwake();
+    } else if (this.child && !this.graceTimer) {
+      // Idle: hold the wake for a grace period, then release (bridges brief gaps
+      // between back-to-back requests so we never drop it mid-conversation).
+      this.graceTimer = setTimeout(() => { this.graceTimer = null; this._allowSleep(); }, this.graceMs);
+      this.graceTimer.unref?.();
+    }
+  }
+
+  _ensureAwake() {
+    if (!this.enabled || this.child) return;
+    try {
+      const c = this._spawn('/usr/bin/caffeinate', ['-s', '-w', String(process.pid)], { stdio: 'ignore' });
+      this.child = c;
+      // Only clear the ref if it's still THIS child (a stale exit can't null a newer one).
+      // caffeinate missing/unspawnable → disable so we don't re-spawn every poll forever.
+      c.once('error', () => { if (this.child === c) this.child = null; this.enabled = false; });
+      c.once('exit', () => { if (this.child === c) this.child = null; });
+      // Honest: -s keeps the SYSTEM awake ON AC ONLY (a no-op on battery); the display
+      // still sleeps so the screen stays dark.
+      this.log('Keeping the system awake while busy (caffeinate -s; AC power only, display still sleeps)');
+    } catch { this.child = null; this.enabled = false; }
+  }
+
+  _allowSleep() {
+    if (!this.child) return;
+    try { this.child.kill('SIGTERM'); } catch { /* already gone */ }
+    this.child = null;
+    this.log('Idle — allowing normal system sleep again');
+  }
+
+  stop() {
+    if (this.pollTimer) { clearInterval(this.pollTimer); this.pollTimer = null; }
+    if (this.graceTimer) { clearTimeout(this.graceTimer); this.graceTimer = null; }
+    this._allowSleep();
+  }
+}