maxpool 1.0.2 → 1.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "maxpool",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "Multi-account Claude Code proxy with adaptive, rate-aware load balancing across Claude accounts",
   "type": "module",
   "main": "src/index.js",
@@ -14,7 +14,8 @@
   "scripts": {
     "start": "node src/index.js",
     "test": "node --test",
-    "lint": "eslint src/ test/"
+    "lint": "eslint src/ test/",
+    "release": "bash scripts/release.sh"
   },
   "keywords": [
     "claude",

package/src/config.js

@@ -36,6 +36,11 @@ export function createDefaultConfig() {
       apiKey: 'mp-' + randomBytes(24).toString('base64url'),
     },
     upstream: 'https://api.anthropic.com',
+    // 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)
+    // and applied on the NEXT restart — running sessions are never interrupted.
+    autoUpdate: false,
     // Per-account "stop using this account" gate, applied to BOTH the 5h
     // session window and the 7d weekly window (whichever utilization is
     // higher). 0.90 = stop routing to an account once it crosses 90% of a

package/src/index.js

@@ -10,6 +10,7 @@ import { importCredentials, loginOAuth, fetchProfile, refreshAccessToken, isToke
 import { TUI } from './tui.js';
 import { RestartController } from './restart-controller.js';
 import { resolveAccounts } from './account-config.js';
+import { maybeCheckForUpdate } from './updater.js';
 
 const args = process.argv.slice(2);
 const command = args[0];
@@ -361,6 +362,11 @@ async function serverWorkerCommand() {
     } else {
       logPlainServerStart({ host, port, accounts, threshold, config });
     }
+
+    // Non-blocking update check. Notifies (or self-updates if config.autoUpdate);
+    // never interrupts the running proxy. Failures are swallowed.
+    const notify = msg => (tui?._addLog ? tui._addLog(msg) : console.log(`[Maxpool] ${msg}`));
+    maybeCheckForUpdate(config, notify).catch(() => {});
   });
 
   process.on('SIGINT', () => shutdownGracefully('SIGINT'));

package/src/server.js

@@ -846,7 +846,7 @@ function unavailableMessage(accountManager, requestInfo = {}, retryAfter, willRe
   return `All ${n} accounts exhausted. Retry in ${retryAfter}s.`;
 }
 
-export const __serverTest = { unavailableMessage, isRetriableUpstreamStatus };
+export const __serverTest = { unavailableMessage, isRetriableUpstreamStatus, headerValue, getMaxpoolProfile };
 
 async function readErrorBody(upstreamRes, limitBytes = 64 * 1024) {
   if (!upstreamRes.body) return '';
@@ -1227,7 +1227,8 @@ function containsThinkingBlock(value) {
 }
 
 function getMaxpoolProfile(headers) {
-  const profile = String(headers['x-maxpool-profile'] || 'claude').trim().toLowerCase();
+  // headerValue() handles the x-teamclaude-* legacy fallback.
+  const profile = String(headerValue(headers, 'x-maxpool-profile') || 'claude').trim().toLowerCase();
   return profile || 'claude';
 }
 
@@ -1272,7 +1273,15 @@ function prepareRuntimeProviders(accountManager, headers) {
 }
 
 function headerValue(headers, name) {
-  const value = headers[name.toLowerCase()];
+  const lname = name.toLowerCase();
+  let value = headers[lname];
+  // Backward compatibility: sessions launched before the teamclaude→maxpool
+  // rename send x-teamclaude-* headers (a process's ANTHROPIC_CUSTOM_HEADERS is
+  // fixed at launch). Fall back to the legacy name so already-running sessions
+  // keep full routing/fallback without needing a restart.
+  if ((value == null || value === '') && lname.startsWith('x-maxpool-')) {
+    value = headers['x-teamclaude-' + lname.slice('x-maxpool-'.length)];
+  }
   if (Array.isArray(value)) return value[0];
   return value ? String(value).trim() : '';
 }

package/src/updater.js

@@ -0,0 +1,93 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { readFile } from 'node:fs/promises';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+
+const execFileAsync = promisify(execFile);
+const PACKAGE = 'maxpool';
+const DEFAULT_REGISTRY = 'https://registry.npmjs.org';
+
+/** Read the running maxpool version from its own package.json. Null on failure. */
+export async function getCurrentVersion() {
+  try {
+    const here = dirname(fileURLToPath(import.meta.url));
+    const pkg = JSON.parse(await readFile(join(here, '..', 'package.json'), 'utf-8'));
+    return pkg.version || null;
+  } catch {
+    return null;
+  }
+}
+
+/** Compare two dotted versions. Returns 1 if a>b, -1 if a<b, 0 if equal. */
+export function compareVersions(a, b) {
+  const pa = String(a).split('.').map(n => Number(n) || 0);
+  const pb = String(b).split('.').map(n => Number(n) || 0);
+  for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
+    if ((pa[i] || 0) > (pb[i] || 0)) return 1;
+    if ((pa[i] || 0) < (pb[i] || 0)) return -1;
+  }
+  return 0;
+}
+
+/**
+ * Check npm for a newer published version. Network-failure-safe: returns null
+ * on any error (offline, timeout, bad response) so a check never breaks startup.
+ */
+export async function checkForUpdate(currentVersion, { timeoutMs = 4000, registry = DEFAULT_REGISTRY } = {}) {
+  try {
+    const ctrl = new AbortController();
+    const timer = setTimeout(() => ctrl.abort(), timeoutMs);
+    let res;
+    try {
+      res = await fetch(`${registry}/${PACKAGE}/latest`, { signal: ctrl.signal });
+    } finally {
+      clearTimeout(timer);
+    }
+    if (!res.ok) return null;
+    const data = await res.json();
+    const latest = data.version;
+    if (!latest) return null;
+    return {
+      latest,
+      current: currentVersion,
+      hasUpdate: currentVersion ? compareVersions(latest, currentVersion) > 0 : false,
+    };
+  } catch {
+    return null;
+  }
+}
+
+/** Run `npm install -g maxpool@latest`. Returns {ok, output|error}. */
+export async function selfUpdate({ timeoutMs = 120_000 } = {}) {
+  try {
+    const { stdout, stderr } = await execFileAsync('npm', ['install', '-g', `${PACKAGE}@latest`], { timeout: timeoutMs });
+    return { ok: true, output: (stdout || stderr || '').trim() };
+  } catch (err) {
+    return { ok: false, error: err.message };
+  }
+}
+
+/**
+ * Startup hook: check for an update and either notify (default) or self-install
+ * (config.autoUpdate). Never auto-restarts a running proxy — the new version
+ * applies on the next restart, so in-flight sessions are never interrupted.
+ * Fire-and-forget; all failures are swallowed.
+ */
+export async function maybeCheckForUpdate(config, notify) {
+  if (config?.updateCheck === false) return;
+  const current = await getCurrentVersion();
+  const result = await checkForUpdate(current);
+  if (!result || !result.hasUpdate) return;
+
+  notify(`Update available: ${result.current} → ${result.latest}`);
+  if (config?.autoUpdate) {
+    notify(`Auto-updating to ${result.latest}…`);
+    const r = await selfUpdate();
+    notify(r.ok
+      ? `Updated to ${result.latest}. Restart maxpool to apply (running sessions are not interrupted).`
+      : `Auto-update failed: ${r.error}. Run: npm i -g ${PACKAGE}`);
+  } else {
+    notify(`Run 'npm i -g ${PACKAGE}' to update, or set "autoUpdate": true in your config.`);
+  }
+}