maxpool 1.0.0

package/src/oauth.js

@@ -0,0 +1,391 @@
+import { readFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { randomBytes, createHash } from 'node:crypto';
+import { exec } from 'node:child_process';
+import { createInterface } from 'node:readline';
+import http from 'node:http';
+
+/**
+ * Import OAuth credentials from a Claude Code credentials file.
+ */
+export async function importCredentials(filePath) {
+  const resolvedPath = filePath.replace(/^~/, homedir());
+  const raw = JSON.parse(await readFile(resolvedPath, 'utf-8'));
+
+  // Claude Code stores credentials nested under "claudeAiOauth"
+  const data = raw.claudeAiOauth || raw;
+  return {
+    accessToken: data.accessToken,
+    refreshToken: data.refreshToken,
+    expiresAt: data.expiresAt,
+    subscriptionType: data.subscriptionType,
+    rateLimitTier: data.rateLimitTier,
+  };
+}
+
+const PROFILE_URL = 'https://api.anthropic.com/api/oauth/profile';
+const DEFAULT_TOKEN_ENDPOINT = 'https://platform.claude.com/v1/oauth/token';
+const DEFAULT_CLIENT_ID = '9d1c250a-e61b-44d9-88ed-5944d1962f5e';
+
+/**
+ * Refresh an expired OAuth access token using the refresh token.
+ * Retries on 5xx and network errors with exponential backoff.
+ */
+export async function refreshAccessToken(refreshToken, endpoint = DEFAULT_TOKEN_ENDPOINT) {
+  const maxRetries = 2;
+  const baseDelayMs = 500;
+
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      if (attempt > 0) {
+        const delay = baseDelayMs * 2 ** (attempt - 1);
+        await new Promise(resolve => setTimeout(resolve, delay));
+      }
+
+      const res = await fetch(endpoint, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Accept': 'application/json, text/plain, */*',
+          'User-Agent': 'axios/1.13.6',
+        },
+        body: JSON.stringify({
+          grant_type: 'refresh_token',
+          refresh_token: refreshToken,
+          client_id: DEFAULT_CLIENT_ID,
+        }),
+      });
+
+      if (!res.ok) {
+        if (res.status >= 500 && attempt < maxRetries) {
+          await res.body?.cancel();
+          continue;
+        }
+        const text = await res.text();
+        const error = new Error(`Token refresh failed (${res.status}): ${text}`);
+        error.status = res.status;
+        error.retryable = res.status === 429 || res.status >= 500;
+        throw error;
+      }
+
+      const data = await res.json();
+      return {
+        accessToken: data.access_token,
+        refreshToken: data.refresh_token || refreshToken,
+        expiresAt: normalizeExpiresAt(data.expires_at) || (Date.now() + (data.expires_in || 3600) * 1000),
+      };
+    } catch (err) {
+      const isNetworkError = err instanceof Error &&
+        (err.message.includes('fetch failed') ||
+          (err.code === 'ECONNRESET' || err.code === 'ECONNREFUSED' ||
+           err.code === 'ETIMEDOUT' || err.code === 'UND_ERR_CONNECT_TIMEOUT'));
+
+      if (attempt < maxRetries && isNetworkError) {
+        continue;
+      }
+      if (isNetworkError) err.retryable = true;
+      throw err;
+    }
+  }
+}
+
+/**
+ * Normalize an expires_at value to milliseconds.
+ * OAuth endpoints may return seconds; Claude Code credentials use milliseconds.
+ */
+export function normalizeExpiresAt(expiresAt) {
+  if (!expiresAt) return expiresAt;
+  // If the value is plausibly in seconds (< 10^12 ≈ year 2001 in ms, year 33658 in s),
+  // convert to milliseconds
+  return expiresAt < 1e12 ? expiresAt * 1000 : expiresAt;
+}
+
+/**
+ * Check if an OAuth token is expiring within the given threshold.
+ */
+export function isTokenExpiringSoon(expiresAt, thresholdMs = 5 * 60 * 1000) {
+  if (!expiresAt) return false;
+  return Date.now() + thresholdMs >= normalizeExpiresAt(expiresAt);
+}
+
+/**
+ * Fetch account profile for an OAuth token.
+ * Returns { email, name, orgName, orgType, ... } on success,
+ * or { error: 'reason' } on failure.
+ */
+export async function fetchProfile(accessToken) {
+  try {
+    const res = await fetch(PROFILE_URL, {
+      headers: { 'Authorization': `Bearer ${accessToken}` },
+    });
+    if (!res.ok) {
+      let detail = '';
+      try {
+        const body = await res.json();
+        detail = body?.error?.message || JSON.stringify(body).slice(0, 200);
+      } catch {
+        detail = await res.text().catch(() => '');
+      }
+      return { error: `HTTP ${res.status}${detail ? ': ' + detail : ''}` };
+    }
+    const data = await res.json();
+    return {
+      accountUuid: data.account?.uuid,
+      email: data.account?.email,
+      name: data.account?.display_name,
+      orgName: data.organization?.name,
+      orgType: data.organization?.organization_type,
+      hasClaudeMax: data.account?.has_claude_max,
+      hasClaudePro: data.account?.has_claude_pro,
+    };
+  } catch (err) {
+    return { error: err.message || String(err) };
+  }
+}
+
+const USAGE_URL = 'https://api.anthropic.com/api/oauth/usage';
+const OAUTH_USAGE_BETA = 'oauth-2025-04-20';
+
+/** Normalize one usage bucket from the /api/oauth/usage response to
+ *  { utilization: 0..1, resetAt: ms-timestamp } (tolerant of field-name and
+ *  percentage/epoch-vs-iso variations). */
+export function normalizeUsageBucket(bucket) {
+  if (!bucket || typeof bucket !== 'object') return null;
+
+  const rawPct = bucket.used_percentage ?? bucket.utilization ?? bucket.usedPercentage;
+  const parsedPct = typeof rawPct === 'number' ? rawPct : parseFloat(rawPct);
+  const utilization = Number.isFinite(parsedPct)
+    ? (parsedPct > 1 ? parsedPct / 100 : parsedPct)
+    : null;
+
+  const rawReset = bucket.resets_at ?? bucket.resetsAt ?? bucket.reset_at ?? bucket.resetAt;
+  let resetAt = null;
+  if (typeof rawReset === 'number') {
+    resetAt = rawReset < 1e12 ? rawReset * 1000 : rawReset;
+  } else if (typeof rawReset === 'string') {
+    const asNum = Number(rawReset);
+    if (Number.isFinite(asNum) && rawReset.trim() !== '') {
+      resetAt = asNum < 1e12 ? asNum * 1000 : asNum;
+    } else {
+      const parsed = Date.parse(rawReset);
+      if (Number.isFinite(parsed)) resetAt = parsed;
+    }
+  }
+
+  return { utilization, resetAt };
+}
+
+/** Read an account's quota from the zero-spend /api/oauth/usage endpoint.
+ *  Returns { fiveHour, sevenDay, sevenDaySonnet } buckets, or { error, status }. */
+export async function fetchUsage(accessToken) {
+  try {
+    const res = await fetch(USAGE_URL, {
+      headers: {
+        'Authorization': `Bearer ${accessToken}`,
+        'anthropic-beta': OAUTH_USAGE_BETA,
+        'Accept': 'application/json',
+      },
+    });
+
+    if (!res.ok) {
+      let detail = '';
+      try {
+        const body = await res.json();
+        detail = body?.error?.message || JSON.stringify(body).slice(0, 200);
+      } catch {
+        detail = await res.text().catch(() => '');
+      }
+      return { error: `HTTP ${res.status}${detail ? ': ' + detail : ''}`, status: res.status };
+    }
+
+    const data = await res.json();
+    return {
+      fiveHour: normalizeUsageBucket(data?.five_hour),
+      sevenDay: normalizeUsageBucket(data?.seven_day),
+      sevenDaySonnet: normalizeUsageBucket(data?.seven_day_sonnet),
+    };
+  } catch (err) {
+    return { error: err.message || String(err), status: null };
+  }
+}
+
+// OAuth config (extracted from Claude Code)
+const OAUTH_CLIENT_ID = '9d1c250a-e61b-44d9-88ed-5944d1962f5e';
+const OAUTH_AUTHORIZE = 'https://claude.ai/oauth/authorize';
+const OAUTH_TOKEN = 'https://platform.claude.com/v1/oauth/token';
+const OAUTH_SCOPES = 'org:create_api_key user:profile user:inference user:sessions:claude_code user:mcp_servers user:file_upload';
+
+/**
+ * Perform OAuth login via browser with PKCE flow.
+ * Opens the user's browser, waits for the callback, exchanges the code for tokens.
+ */
+export async function loginOAuth() {
+  // Generate PKCE
+  const codeVerifier = randomBytes(32).toString('base64url');
+  const codeChallenge = createHash('sha256').update(codeVerifier).digest('base64url');
+  const state = randomBytes(32).toString('base64url');
+
+  // Start local callback server on a random port
+  const { port, codePromise, server } = await startCallbackServer(state);
+  const redirectUri = `http://localhost:${port}/callback`;
+
+  // Build authorization URL
+  const authUrl = new URL(OAUTH_AUTHORIZE);
+  authUrl.searchParams.set('code', 'true');
+  authUrl.searchParams.set('client_id', OAUTH_CLIENT_ID);
+  authUrl.searchParams.set('response_type', 'code');
+  authUrl.searchParams.set('redirect_uri', redirectUri);
+  authUrl.searchParams.set('scope', OAUTH_SCOPES);
+  authUrl.searchParams.set('code_challenge', codeChallenge);
+  authUrl.searchParams.set('code_challenge_method', 'S256');
+  authUrl.searchParams.set('state', state);
+
+  // Open browser
+  console.log('Opening browser for authentication...');
+  console.log(`If it doesn't open, visit:\n  ${authUrl.toString()}\n`);
+  openBrowser(authUrl.toString());
+
+  // Wait for either the callback server or manual paste from stdin
+  let code;
+  try {
+    code = await raceWithStdinCode(codePromise, state);
+  } finally {
+    server.close();
+  }
+
+  // Exchange code for tokens
+  console.log('Exchanging authorization code for tokens...');
+  const tokenRes = await fetch(OAUTH_TOKEN, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({
+      code,
+      state,
+      grant_type: 'authorization_code',
+      client_id: OAUTH_CLIENT_ID,
+      redirect_uri: redirectUri,
+      code_verifier: codeVerifier,
+    }),
+  });
+
+  if (!tokenRes.ok) {
+    const text = await tokenRes.text();
+    throw new Error(`Token exchange failed (${tokenRes.status}): ${text}`);
+  }
+
+  const tokens = await tokenRes.json();
+  return {
+    accessToken: tokens.access_token,
+    refreshToken: tokens.refresh_token,
+    expiresAt: normalizeExpiresAt(tokens.expires_at) || (Date.now() + (tokens.expires_in || 3600) * 1000),
+  };
+}
+
+/**
+ * Race the callback server promise against manual code entry from stdin.
+ * The user can paste the full callback URL or just the authorization code.
+ */
+function raceWithStdinCode(callbackPromise, expectedState) {
+  if (!process.stdin.isTTY) return callbackPromise;
+
+  return new Promise((resolve, reject) => {
+    const rl = createInterface({ input: process.stdin, output: process.stderr });
+    let settled = false;
+
+    const settle = (fn, val) => {
+      if (settled) return;
+      settled = true;
+      rl.close();
+      fn(val);
+    };
+
+    rl.question('Paste authorization code here (or wait for browser callback): ', answer => {
+      const trimmed = answer.trim();
+      if (!trimmed) return; // empty input, keep waiting for callback
+
+      // Try to parse as a URL with ?code= parameter
+      try {
+        const url = new URL(trimmed);
+        const code = url.searchParams.get('code');
+        const state = url.searchParams.get('state');
+        if (code) {
+          if (expectedState && state && state !== expectedState) {
+            settle(reject, new Error('OAuth state mismatch'));
+          } else {
+            settle(resolve, code);
+          }
+          return;
+        }
+      } catch {}
+
+      // Treat raw input as the authorization code
+      settle(resolve, trimmed);
+    });
+
+    callbackPromise.then(
+      code => settle(resolve, code),
+      err => settle(reject, err),
+    );
+  });
+}
+
+function startCallbackServer(expectedState) {
+  return new Promise((resolve, reject) => {
+    let resolveCode, rejectCode;
+    const codePromise = new Promise((res, rej) => { resolveCode = res; rejectCode = rej; });
+
+    const server = http.createServer((req, res) => {
+      const url = new URL(req.url, `http://localhost`);
+
+      if (url.pathname === '/callback') {
+        const code = url.searchParams.get('code');
+        const error = url.searchParams.get('error');
+        const state = url.searchParams.get('state');
+
+        if (error) {
+          res.writeHead(200, { 'Content-Type': 'text/html' });
+          res.end('<html><body><h2>Authentication failed</h2><p>You can close this tab.</p></body></html>');
+          rejectCode(new Error(`OAuth error: ${error} - ${url.searchParams.get('error_description') || ''}`));
+          return;
+        }
+
+        if (expectedState && state !== expectedState) {
+          res.writeHead(200, { 'Content-Type': 'text/html' });
+          res.end('<html><body><h2>Authentication failed</h2><p>State mismatch. You can close this tab.</p></body></html>');
+          rejectCode(new Error('OAuth state mismatch'));
+          return;
+        }
+
+        if (code) {
+          res.writeHead(302, { 'Location': 'https://platform.claude.com/oauth/code/success?app=claude-code' });
+          res.end();
+          resolveCode(code);
+          return;
+        }
+      }
+
+      res.writeHead(404);
+      res.end('Not found');
+    });
+
+    server.listen(0, 'localhost', () => {
+      resolve({ port: server.address().port, codePromise, server });
+    });
+    server.on('error', reject);
+
+    // Timeout after 2 minutes (unref so it doesn't keep the process alive)
+    const timer = setTimeout(() => {
+      rejectCode(new Error('Login timed out after 2 minutes'));
+      server.close();
+    }, 120_000);
+    timer.unref();
+  });
+}
+
+function openBrowser(url) {
+  const platform = process.platform;
+  const cmd = platform === 'darwin' ? 'open'
+    : platform === 'win32' ? 'start'
+    : 'xdg-open';
+  exec(`${cmd} ${JSON.stringify(url)}`, () => {});
+}

package/src/prober.js

@@ -0,0 +1,82 @@
+// Opt-in background quota probe.
+//
+// DISABLED BY DEFAULT. When enabled (config.quotaProbeSeconds > 0), 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.
+
+import { fetchUsage } from './oauth.js';
+
+export class Prober {
+  constructor(accountManager, { intervalMs = 0, probeFn = fetchUsage, timeoutMs = 10_000, log = console.log } = {}) {
+    this.am = accountManager;
+    this.intervalMs = intervalMs;
+    this.probeFn = probeFn;
+    this.timeoutMs = timeoutMs;
+    this.log = log;
+    this.timer = null;
+    this._running = false;
+  }
+
+  start() {
+    if (this.intervalMs > 0) this.reschedule(this.intervalMs);
+  }
+
+  /** Change the interval at runtime (0 = off). Probes once immediately when on. */
+  reschedule(intervalMs) {
+    const wasOn = this.intervalMs > 0 && this.timer;
+    this.intervalMs = intervalMs;
+    if (this.timer) { clearInterval(this.timer); this.timer = null; }
+
+    if (intervalMs > 0) {
+      // Probe right away so quota populates without waiting a full cycle.
+      this.probeAll().catch(() => {});
+      this.timer = setInterval(() => this.probeAll().catch(() => {}), intervalMs);
+      this.timer.unref?.();
+      this.log(`[Maxpool] Quota probe enabled (every ${Math.round(intervalMs / 1000)}s)`);
+    } else if (wasOn) {
+      this.log('[Maxpool] Quota probe disabled');
+    }
+  }
+
+  stop() {
+    if (this.timer) { clearInterval(this.timer); this.timer = null; }
+  }
+
+  /** Probe every OAuth account once. Overlapping cycles are skipped. */
+  async probeAll() {
+    if (this._running) return;
+    this._running = true;
+    try {
+      const accounts = this.am.accounts.filter(a => a.type === 'oauth' && a.credential);
+      await Promise.all(accounts.map(a => this.probeOne(a)));
+    } finally {
+      this._running = false;
+    }
+  }
+
+  async probeOne(account) {
+    try {
+      await this.am.ensureTokenFresh(account.index);
+      let usage = await this._withTimeout(this.probeFn(account.credential));
+      if (usage?.status === 401) {
+        // Token rejected — force a refresh and retry once.
+        await this.am.ensureTokenFresh(account.index, true);
+        usage = await this._withTimeout(this.probeFn(account.credential));
+      }
+      if (!usage || usage.error) return; // transient — try again next cycle
+      this.am.applyUsageData(account.index, usage);
+    } catch { /* best-effort; never let a probe throw */ }
+  }
+
+  _withTimeout(promise) {
+    return Promise.race([
+      promise,
+      new Promise(resolve => {
+        const t = setTimeout(() => resolve(null), this.timeoutMs);
+        t.unref?.();
+      }),
+    ]);
+  }
+}

package/src/restart-controller.js

@@ -0,0 +1,58 @@
+const NON_UPSTREAM_ROUTES = new Set(['(queued)', '(none available)']);
+
+export class RestartController {
+  constructor({ pauseAdmission, restartNow, log = console.log }) {
+    this.pauseAdmission = pauseAdmission;
+    this.restartNow = restartNow;
+    this.log = log;
+    this.activeRequests = new Set();
+    this.upstreamRequests = new Set();
+    this.pending = false;
+    this.restarting = false;
+  }
+
+  requestStarted(id) {
+    if (this.pending || this.restarting) return false;
+    this.activeRequests.add(id);
+    return true;
+  }
+
+  requestRouted(id, account) {
+    if (!this.activeRequests.has(id)) return false;
+    if (NON_UPSTREAM_ROUTES.has(account)) this.upstreamRequests.delete(id);
+    else this.upstreamRequests.add(id);
+    this._maybeRestart();
+    return true;
+  }
+
+  requestEnded(id) {
+    this.activeRequests.delete(id);
+    this.upstreamRequests.delete(id);
+    this._maybeRestart();
+  }
+
+  requestRestart() {
+    if (this.restarting) return;
+    this.pauseAdmission();
+    if (this.upstreamRequests.size === 0) {
+      this._restart();
+      return;
+    }
+
+    this.pending = true;
+    const queuedOrIdle = Math.max(0, this.activeRequests.size - this.upstreamRequests.size);
+    this.log(`[Maxpool] Restart pending; admission paused while ${this.upstreamRequests.size} upstream request(s) finish. ${queuedOrIdle} queued/idle request(s) will reconnect after restart.`);
+  }
+
+  _maybeRestart() {
+    if (!this.pending || this.restarting || this.upstreamRequests.size > 0) return;
+    this._restart();
+  }
+
+  _restart() {
+    if (this.restarting) return;
+    this.restarting = true;
+    this.pending = false;
+    this.restartNow();
+  }
+}