maxpool 1.5.5 → 1.5.6

package/package.json

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

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)

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,
@@ -656,6 +665,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 +676,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/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();
+  }
+}