maxpool 1.0.3 → 1.0.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "maxpool",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "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];
@@ -47,6 +48,10 @@ switch (command) {
     await removeCommand();
     process.exit(0);
     break;
+  case 'rename':
+    await renameCommand();
+    process.exit(0);
+    break;
   case 'api':
     await apiCommand();
     process.exit(0);
@@ -361,6 +366,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'));
@@ -792,6 +802,42 @@ async function removeCommand() {
   console.log(`Removed account "${name}"`);
 }
 
+// Resolve an account by exact name, else by 1-based index. Returns -1 if none.
+function resolveAccountIndex(accounts, target) {
+  let idx = accounts.findIndex(a => a.name === target);
+  if (idx < 0 && /^\d+$/.test(String(target))) idx = Number(target) - 1;
+  return idx >= 0 && idx < accounts.length ? idx : -1;
+}
+
+async function renameCommand() {
+  const config = await loadOrCreateConfig();
+  const target = args[1];
+  const newName = args[2];
+
+  if (!target || !newName) {
+    console.error('Usage: maxpool rename <account-name|number> <new-name>');
+    process.exit(1);
+  }
+
+  const idx = resolveAccountIndex(config.accounts, target);
+  if (idx < 0) {
+    console.error(`Account "${target}" not found`);
+    process.exit(1);
+  }
+  if (config.accounts.some((a, i) => i !== idx && a.name === newName)) {
+    console.error(`An account named "${newName}" already exists`);
+    process.exit(1);
+  }
+
+  const old = config.accounts[idx].name;
+  config.accounts[idx].name = newName;
+  // Keep manual-preference routing pointing at the renamed account.
+  if (config.routing?.preferredAccount === old) config.routing.preferredAccount = newName;
+  await saveConfig(config);
+  console.log(`Renamed "${old}" → "${newName}"`);
+  console.log('Restart maxpool to apply this to a running proxy (or rename live from the TUI: a → n).');
+}
+
 // ── help ────────────────────────────────────────────────────
 
 function showHelp() {
@@ -809,6 +855,7 @@ Commands:
   status              Show proxy & account status (live)
   accounts            List configured accounts
   remove <name>       Remove an account
+  rename <name|#> <new>  Rename an account (by name or list number)
   api <path>          Call an API endpoint with account credentials
   help                Show this help
 

package/src/tui.js

@@ -1,4 +1,5 @@
-import { importCredentials, fetchProfile } from './oauth.js';
+import { createInterface } from 'node:readline';
+import { importCredentials, fetchProfile, loginOAuth } from './oauth.js';
 
 // ── ANSI helpers ─────────────────────────────────────────────
 
@@ -369,6 +370,14 @@ export class TUI {
           () => this._doAddKey(value),
         );
       };
+    } else if (k === 'l') {
+      this._confirm(
+        'Log in via browser?',
+        'Opens a browser to add any Claude account; you name it afterward.',
+        () => this._doLogin(),
+      );
+    } else if (k === 'n' && this.am.accounts.length > 0) {
+      this._startSelection('rename');
     } else if (k === 't' && this.am.accounts.length > 0) {
       this._startSelection('toggle');
     } else if (k === 'd' && this.am.accounts.length > 0) {
@@ -432,6 +441,14 @@ export class TUI {
           'Permanently remove it from Maxpool config. Deletion is blocked while it has active requests.',
           () => this._doDelete(this.selIdx),
         );
+      } else if (this.selAction === 'rename') {
+        const targetIdx = this.selIdx;
+        const current = account.name;
+        this.mode = 'input';
+        this.inputPrompt = `New name for "${current}"`;
+        this.inputBuf = '';
+        this.inputSensitive = false;
+        this.inputCb = value => this._doRename(targetIdx, String(value || '').trim());
       }
     }
     else if (k === 'esc' || k === 'q') { this.mode = 'normal'; }
@@ -519,74 +536,123 @@ export class TUI {
   async _doImport() {
     try {
       this._addLog('Importing credentials...');
-      const creds = await importCredentials('~/.claude/.credentials.json');
+      const creds = await importCredentials(); // file, then macOS Keychain fallback
       const profile = await fetchProfile(creds.accessToken);
-      const profileOk = profile && !profile.error;
-
-      if (!profileOk) {
+      if (!profile || profile.error) {
         this._addLog(`Warning: could not fetch profile — ${profile?.error || 'no token'}`);
       }
-
       let name;
       if (profile?.email) {
         name = profile.email;
         const tier = profile.hasClaudeMax ? 'Max' : profile.hasClaudePro ? 'Pro' : null;
         if (tier) this._addLog(`Detected Claude ${tier}: ${name}`);
-      } else {
-        const n = this.config.accounts.filter(a => a.name.startsWith('account-')).length + 1;
-        name = `account-${n}`;
       }
+      await this._upsertOAuthAccount({ creds, profile, name, source: 'import', verb: 'Imported' });
+    } catch (e) {
+      this._addLog(`Import failed: ${e.message}`);
+    }
+  }
 
-      const entry = {
-        name, type: 'oauth', source: 'import',
-        accountUuid: profile?.accountUuid || null,
-        accessToken: creds.accessToken,
-        refreshToken: creds.refreshToken,
-        expiresAt: creds.expiresAt,
-      };
+  // Browser OAuth login: any Claude account, named afterward. Suspends the TUI
+  // around the interactive flow (browser + name prompt), then resumes.
+  async _doLogin() {
+    const wasRunning = this.running;
+    if (wasRunning) this.stop();
+    try {
+      process.stdout.write('\nOpening browser to log into Claude…\n');
+      const creds = await loginOAuth();
+      const profile = await fetchProfile(creds.accessToken);
+      const suggested = profile?.email
+        || `account-${this.config.accounts.filter(a => a.name.startsWith('account-')).length + 1}`;
+      const rl = createInterface({ input: process.stdin, output: process.stdout });
+      const answer = await new Promise(resolve => rl.question(`Name this account [${suggested}]: `, resolve));
+      rl.close();
+      const name = String(answer || '').trim() || suggested;
+      await this._upsertOAuthAccount({ creds, profile, name, source: 'login', verb: 'Added' });
+      process.stdout.write(`\nAdded account "${name}". Returning to maxpool…\n`);
+    } catch (e) {
+      process.stdout.write(`\nLogin failed: ${e.message}\n`);
+    } finally {
+      if (wasRunning) this.start();
+    }
+  }
 
-      // Deduplicate: match by UUID first, then by name
-      let idx = profile?.accountUuid
-        ? this.config.accounts.findIndex(a => a.accountUuid === profile.accountUuid)
-        : -1;
-      if (idx < 0) idx = this.config.accounts.findIndex(a => a.name === name);
-
-      if (idx >= 0) {
-        const previous = this.config.accounts[idx];
-        entry.enabled = this.config.accounts[idx].enabled;
-        this.config.accounts[idx] = entry;
-        try {
-          await this.saveConfig(this.config);
-        } catch (error) {
-          this.config.accounts[idx] = previous;
-          throw error;
-        }
-        // Update the running account manager entry
-        const amAcct = this.am.accounts.find(account =>
-          (entry.accountUuid && account.accountUuid === entry.accountUuid) || account.name === name
-        );
-        if (amAcct) {
-          amAcct.credential = creds.accessToken;
-          amAcct.refreshToken = creds.refreshToken;
-          amAcct.expiresAt = creds.expiresAt;
-          amAcct.accountUuid = entry.accountUuid;
-          amAcct.name = name;
-          if (amAcct.status === 'error') amAcct.status = 'active';
-        }
-        this._addLog(`Updated account "${name}"`);
-      } else {
-        this.config.accounts.push(entry);
-        try {
-          await this.saveConfig(this.config);
-        } catch (error) {
-          this.config.accounts.pop();
-          throw error;
-        }
-        this.am.addAccount(entry);
-        this._addLog(`Imported account "${name}"`);
+  // Rename an account in config and in the running manager.
+  async _doRename(idx, newName) {
+    const account = this.am.accounts[idx];
+    if (!account) { this._addLog('Account no longer exists'); return; }
+    if (!newName) { this._addLog('Rename cancelled (empty name)'); return; }
+    if (this.am.accounts.some((a, i) => i !== idx && a.name === newName)) {
+      this._addLog(`An account named "${newName}" already exists`); return;
+    }
+    const cfgIdx = this._configAccountIndex(account);
+    if (cfgIdx < 0) { this._addLog(`Cannot rename "${account.name}" (not in config)`); return; }
+    const old = account.name;
+    const prev = this.config.accounts[cfgIdx].name;
+    this.config.accounts[cfgIdx].name = newName;
+    if (this.config.routing?.preferredAccount === old) this.config.routing.preferredAccount = newName;
+    try {
+      await this.saveConfig(this.config);
+    } catch (error) {
+      this.config.accounts[cfgIdx].name = prev;
+      throw error;
+    }
+    account.name = newName; // update the running account manager
+    this._addLog(`Renamed "${old}" → "${newName}"`);
+  }
+
+  // Upsert an OAuth account into config + the running manager. Dedupes by
+  // accountUuid, then name. Shared by import and browser login.
+  async _upsertOAuthAccount({ creds, profile, name, source, verb = 'Added' }) {
+    if (!name) {
+      name = profile?.email
+        || `account-${this.config.accounts.filter(a => a.name.startsWith('account-')).length + 1}`;
+    }
+    const entry = {
+      name, type: 'oauth', source,
+      accountUuid: profile?.accountUuid || null,
+      accessToken: creds.accessToken,
+      refreshToken: creds.refreshToken,
+      expiresAt: creds.expiresAt,
+    };
+
+    let idx = entry.accountUuid
+      ? this.config.accounts.findIndex(a => a.accountUuid === entry.accountUuid)
+      : -1;
+    if (idx < 0) idx = this.config.accounts.findIndex(a => a.name === name);
+
+    if (idx >= 0) {
+      const previous = this.config.accounts[idx];
+      entry.enabled = previous.enabled;
+      this.config.accounts[idx] = entry;
+      try {
+        await this.saveConfig(this.config);
+      } catch (error) {
+        this.config.accounts[idx] = previous;
+        throw error;
       }
-    } catch (e) {
-      this._addLog(`Import failed: ${e.message}`);
+      const amAcct = this.am.accounts.find(account =>
+        (entry.accountUuid && account.accountUuid === entry.accountUuid) || account.name === name
+      );
+      if (amAcct) {
+        amAcct.credential = creds.accessToken;
+        amAcct.refreshToken = creds.refreshToken;
+        amAcct.expiresAt = creds.expiresAt;
+        amAcct.accountUuid = entry.accountUuid;
+        amAcct.name = name;
+        if (amAcct.status === 'error') amAcct.status = 'active';
+      }
+      this._addLog(`Updated account "${name}"`);
+    } else {
+      this.config.accounts.push(entry);
+      try {
+        await this.saveConfig(this.config);
+      } catch (error) {
+        this.config.accounts.pop();
+        throw error;
+      }
+      this.am.addAccount(entry);
+      this._addLog(`${verb} account "${name}"`);
     }
   }
 
@@ -829,7 +895,13 @@ export class TUI {
 
   _renderAcct(idx, bw, showBoth) {
     const a = this.am.accounts[idx];
-    const isCur = this.am.routingMode === 'preferred' && a.name === this.am.preferredAccountName;
+    // Highlight the currently-active account. In manual mode that's the
+    // preferred account; in automatic mode it's the one most recently routed
+    // to (currentIndex). Previously only manual mode highlighted anything, so
+    // in automatic load-balancing no row was ever marked current.
+    const isCur = this.am.routingMode === 'preferred'
+      ? a.name === this.am.preferredAccountName
+      : idx === this.am.currentIndex;
     const isSel = this.mode === 'select' && idx === this.selIdx;
 
     // Prefix: selection marker + current marker
@@ -936,7 +1008,7 @@ export class TUI {
       case 'normal':
         return ` ${bold('a')} Accounts  ${bold('m')} Routing  ${bold('s')} Sync  ${bold('r')} Restart  ${bold('q')} Stop`;
       case 'accounts':
-        return ` ${bold('i')} Import Claude login  ${bold('k')} API key  ${bold('t')} Enable/disable  ${bold('d')} Delete  ${bold('Esc')} Back`;
+        return ` ${bold('i')} Import  ${bold('l')} Login (browser)  ${bold('k')} API key  ${bold('n')} Rename  ${bold('t')} Enable/disable  ${bold('d')} Delete  ${bold('Esc')} Back`;
       case 'routing':
         return ` ${bold('a')} Automatic  ${bold('p')} Manual preference  ${bold('Esc')} Back`;
       case 'select': {
@@ -944,7 +1016,9 @@ export class TUI {
           ? 'prefer'
           : this.selAction === 'toggle'
             ? 'enable/disable'
-            : 'delete';
+            : this.selAction === 'rename'
+              ? 'rename'
+              : 'delete';
         return ` ${dim('↑↓')} select  ${bold('Enter')} ${act}  ${bold('Esc')} cancel`;
       }
       case 'input':

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.`);
+  }
+}