claude-pool 0.0.0-stage → 0.1.0

package/src/config.js

@@ -0,0 +1,150 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+export const DEFAULT_CONFIG_DIR = path.join(os.homedir(), '.claude-pool');
+export const CONFIG_FILE = path.join(DEFAULT_CONFIG_DIR, 'config.json');
+
+export function getDefaultAccounts() {
+  const home = os.homedir();
+  const candidates = [
+    { name: 'primary', configDir: path.join(home, '.claude'), priority: 1 },
+    { name: 'account4', configDir: path.join(home, '.claude-account4'), priority: 2 },
+    { name: 'account2', configDir: path.join(home, '.claude-account2'), priority: 3 },
+    { name: 'bedrock', configDir: path.join(home, '.claude-bedrock'), priority: 4 },
+  ];
+
+  const detected = [];
+  for (const c of candidates) {
+    if (fs.existsSync(c.configDir)) {
+      detected.push({
+        ...c,
+        enabled: true,
+        email: null,
+        orgName: null,
+        subscriptionType: null,
+        rateLimitedUntil: null,
+      });
+    }
+  }
+
+  if (detected.length === 0) {
+    detected.push({
+      name: 'primary',
+      configDir: path.join(home, '.claude'),
+      priority: 1,
+      enabled: true,
+      email: null,
+      orgName: null,
+      subscriptionType: null,
+      rateLimitedUntil: null,
+    });
+  }
+
+  return detected;
+}
+
+export class ConfigManager {
+  constructor(customConfigFile = null) {
+    this.configFile = customConfigFile || CONFIG_FILE;
+    this.configDir = path.dirname(this.configFile);
+  }
+
+  ensureConfigDir() {
+    if (!fs.existsSync(this.configDir)) {
+      fs.mkdirSync(this.configDir, { recursive: true });
+    }
+  }
+
+  loadAccounts() {
+    if (!fs.existsSync(this.configFile)) {
+      const defaults = getDefaultAccounts();
+      this.saveAccounts(defaults);
+      return defaults;
+    }
+
+    try {
+      const raw = JSON.parse(fs.readFileSync(this.configFile, 'utf8'));
+      const accounts = (raw.accounts || []).map(a => ({
+        name: a.name,
+        configDir: a.configDir || a.config_dir,
+        priority: Number(a.priority || 99),
+        enabled: a.enabled !== false,
+        email: a.email || null,
+        orgName: a.orgName || a.org_name || null,
+        subscriptionType: a.subscriptionType || a.subscription_type || null,
+        rateLimitedUntil: a.rateLimitedUntil || a.rate_limited_until || null,
+        quota: null,
+      }));
+      accounts.sort((a, b) => a.priority - b.priority);
+      return accounts;
+    } catch {
+      return getDefaultAccounts();
+    }
+  }
+
+  saveAccounts(accounts) {
+    this.ensureConfigDir();
+    accounts.sort((a, b) => a.priority - b.priority);
+    const data = {
+      version: '1.0',
+      accounts: accounts.map(a => ({
+        name: a.name,
+        config_dir: a.configDir,
+        priority: a.priority,
+        enabled: a.enabled,
+        email: a.email,
+        org_name: a.orgName,
+        subscription_type: a.subscriptionType,
+        rate_limited_until: a.rateLimitedUntil,
+      })),
+      settings: {
+        cooldown_minutes: 60,
+        auto_switch: true,
+      },
+    };
+    fs.writeFileSync(this.configFile, JSON.stringify(data, null, 2), 'utf8');
+  }
+
+  updateAccountPriority(accountName, newPriority) {
+    const accounts = this.loadAccounts();
+    const target = accounts.find(a => a.name.toLowerCase() === accountName.toLowerCase());
+    if (!target) return false;
+
+    const others = accounts.filter(a => a.name.toLowerCase() !== accountName.toLowerCase());
+    const insertIdx = Math.max(0, Math.min(newPriority - 1, others.length));
+    others.splice(insertIdx, 0, target);
+
+    others.forEach((a, idx) => {
+      a.priority = idx + 1;
+    });
+
+    this.saveAccounts(others);
+    return true;
+  }
+
+  reorderPriorities(accountNames) {
+    const accounts = this.loadAccounts();
+    const map = new Map(accounts.map(a => [a.name.toLowerCase(), a]));
+    const newOrder = [];
+
+    for (const name of accountNames) {
+      const key = name.trim().toLowerCase();
+      if (map.has(key)) {
+        newOrder.push(map.get(key));
+        map.delete(key);
+      }
+    }
+
+    for (const remaining of map.values()) {
+      newOrder.push(remaining);
+    }
+
+    newOrder.forEach((a, idx) => {
+      a.priority = idx + 1;
+    });
+
+    this.saveAccounts(newOrder);
+    return true;
+  }
+}

package/src/metrics.js

@@ -0,0 +1,160 @@
+import fs from 'fs';
+import path from 'path';
+
+export class MetricsEngine {
+  static readAccountStats(account) {
+    const stats = {
+      accountName: account.name,
+      todayInputTokens: 0,
+      todayOutputTokens: 0,
+      todayCacheReadTokens: 0,
+      todayCacheCreationTokens: 0,
+      todayTotalTokens: 0,
+      todayTokensByModel: {},
+      todayModelsDetail: {},
+      lifetimeModels: {},
+      lifetimeTotalInput: 0,
+      lifetimeTotalOutput: 0,
+      lifetimeTotalCache: 0,
+      lifetimeTotalTokens: 0,
+      totalSessions: 0,
+      totalMessages: 0,
+    };
+
+    const configPath = account.configDir;
+
+    // 1. Base lifetime metrics from stats-cache.json
+    const statsFile = path.join(configPath, 'stats-cache.json');
+    if (fs.existsSync(statsFile)) {
+      try {
+        const raw = JSON.parse(fs.readFileSync(statsFile, 'utf8'));
+        stats.totalSessions = raw.totalSessions || 0;
+        stats.totalMessages = raw.totalMessages || 0;
+
+        const rawModels = raw.modelUsage || {};
+        for (const [mName, u] of Object.entries(rawModels)) {
+          const inp = u.inputTokens || 0;
+          const out = u.outputTokens || 0;
+          const cRead = u.cacheReadInputTokens || 0;
+          const cCreate = u.cacheCreationInputTokens || 0;
+          const tot = inp + out + cRead + cCreate;
+
+          stats.lifetimeModels[mName] = { input: inp, output: out, cacheRead: cRead, cacheCreate: cCreate, total: tot };
+          stats.lifetimeTotalInput += inp;
+          stats.lifetimeTotalOutput += out;
+          stats.lifetimeTotalCache += cRead + cCreate;
+          stats.lifetimeTotalTokens += tot;
+        }
+      } catch {}
+    }
+
+    // 2. Real-time extraction from live project session .jsonl files for today
+    const projDir = path.join(configPath, 'projects');
+    if (!fs.existsSync(projDir)) return stats;
+
+    const todayUtc = new Date().toISOString().slice(0, 10);
+    const todayLocal = new Date().toLocaleDateString('en-CA'); // YYYY-MM-DD
+    const cutoffMtime = Date.now() - 48 * 3600 * 1000;
+
+    let sessionCount = 0;
+
+    function walkDir(dir) {
+      try {
+        const entries = fs.readdirSync(dir, { withFileTypes: true });
+        for (const ent of entries) {
+          const full = path.join(dir, ent.name);
+          if (ent.isDirectory() && ent.name !== 'subagents') {
+            walkDir(full);
+          } else if (ent.isFile() && ent.name.endsWith('.jsonl') && !full.includes('subagents')) {
+            sessionCount++;
+            try {
+              const st = fs.statSync(full);
+              if (st.mtimeMs < cutoffMtime) continue;
+
+              const content = fs.readFileSync(full, 'utf8');
+              const lines = content.split('\n');
+
+              for (const line of lines) {
+                if (!line.includes('input_tokens')) continue;
+                try {
+                  const data = JSON.parse(line);
+                  const ts = data.timestamp || '';
+                  if (!ts.startsWith(todayUtc) && !ts.startsWith(todayLocal)) continue;
+
+                  const msg = data.message || {};
+                  const usage = msg.usage || {};
+                  const model = msg.model || 'unknown';
+
+                  const inp = usage.input_tokens || 0;
+                  const out = usage.output_tokens || 0;
+                  const cRead = usage.cache_read_input_tokens || 0;
+                  const cCreate = usage.cache_creation_input_tokens || 0;
+                  const cTotal = cRead + cCreate;
+                  const turnTokens = inp + out + cTotal;
+
+                  stats.todayInputTokens += inp;
+                  stats.todayOutputTokens += out;
+                  stats.todayCacheReadTokens += cRead;
+                  stats.todayCacheCreationTokens += cCreate;
+                  stats.todayTotalTokens += turnTokens;
+
+                  stats.todayTokensByModel[model] = (stats.todayTokensByModel[model] || 0) + turnTokens;
+
+                  if (!stats.todayModelsDetail[model]) {
+                    stats.todayModelsDetail[model] = { input: 0, output: 0, cacheRead: 0, cacheCreate: 0, total: 0 };
+                  }
+                  const mDet = stats.todayModelsDetail[model];
+                  mDet.input += inp;
+                  mDet.output += out;
+                  mDet.cacheRead += cRead;
+                  mDet.cacheCreate += cCreate;
+                  mDet.total += turnTokens;
+                } catch {}
+              }
+            } catch {}
+          }
+        }
+      } catch {}
+    }
+
+    walkDir(projDir);
+
+    if (stats.totalSessions === 0) {
+      stats.totalSessions = sessionCount;
+    }
+
+    return stats;
+  }
+
+  static getPoolStats(accounts) {
+    const pool = {
+      accounts: [],
+      todayPoolTokens: 0,
+      todayPoolInput: 0,
+      todayPoolOutput: 0,
+      todayPoolCache: 0,
+      lifetimePoolInput: 0,
+      lifetimePoolOutput: 0,
+      lifetimePoolCache: 0,
+      lifetimePoolTokens: 0,
+      totalPoolSessions: 0,
+    };
+
+    for (const acct of accounts) {
+      const acctStats = this.readAccountStats(acct);
+      pool.accounts.push(acctStats);
+      pool.todayPoolTokens += acctStats.todayTotalTokens;
+      pool.todayPoolInput += acctStats.todayInputTokens;
+      pool.todayPoolOutput += acctStats.todayOutputTokens;
+      pool.todayPoolCache += acctStats.todayCacheReadTokens + acctStats.todayCacheCreationTokens;
+
+      pool.lifetimePoolInput += acctStats.lifetimeTotalInput;
+      pool.lifetimePoolOutput += acctStats.lifetimeTotalOutput;
+      pool.lifetimePoolCache += acctStats.lifetimeTotalCache;
+      pool.lifetimePoolTokens += acctStats.lifetimeTotalTokens;
+      pool.totalPoolSessions += acctStats.totalSessions;
+    }
+
+    return pool;
+  }
+}

package/src/quota.js

@@ -0,0 +1,104 @@
+import { spawnSync } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+const CACHE_FILE = path.join(os.homedir(), '.claude-pool', 'quota_cache.json');
+
+export class QuotaEngine {
+  static loadCache() {
+    if (!fs.existsSync(CACHE_FILE)) return {};
+    try {
+      return JSON.parse(fs.readFileSync(CACHE_FILE, 'utf8'));
+    } catch {
+      return {};
+    }
+  }
+
+  static saveCache(data) {
+    try {
+      fs.mkdirSync(path.dirname(CACHE_FILE), { recursive: true });
+      fs.writeFileSync(CACHE_FILE, JSON.stringify(data, null, 2), 'utf8');
+    } catch {}
+  }
+
+  static fetchAccountQuota(account, forceRefresh = false) {
+    const cache = this.loadCache();
+    const cachedEntry = cache[account.name];
+
+    if (!forceRefresh && cachedEntry && cachedEntry.lastChecked) {
+      const ageSeconds = (Date.now() - cachedEntry.lastChecked) / 1000;
+      if (ageSeconds < 300) {
+        account.quota = cachedEntry;
+        return cachedEntry;
+      }
+    }
+
+    const env = { ...process.env };
+    const defaultClaudePath = path.resolve(path.join(os.homedir(), '.claude'));
+    if (path.resolve(account.configDir) !== defaultClaudePath) {
+      env.CLAUDE_CONFIG_DIR = account.configDir;
+    } else {
+      delete env.CLAUDE_CONFIG_DIR;
+    }
+
+    delete env.ANTHROPIC_BASE_URL;
+    delete env.ANTHROPIC_API_KEY;
+    delete env.ANTHROPIC_DEFAULT_SONNET_MODEL;
+
+    try {
+      const res = spawnSync('claude', ['-p', '/usage'], {
+        input: '',
+        env,
+        encoding: 'utf8',
+        timeout: 15000,
+      });
+
+      const output = (res.stdout || '') + '\n' + (res.stderr || '');
+
+      const mSession = output.match(/Current session:\s*(\d+)%[\s\S]*?resets\s*([^(\n\r]+)/i);
+      const mWeek = output.match(/Current week[\s\S]*?:\s*(\d+)%[\s\S]*?resets\s*([^(\n\r]+)/i);
+
+      let sessionUsed = null;
+      let sessionReset = null;
+      let weekUsed = null;
+      let weekReset = null;
+
+      if (mSession) {
+        sessionUsed = parseInt(mSession[1], 10);
+        sessionReset = mSession[2].trim();
+      }
+
+      if (mWeek) {
+        weekUsed = parseInt(mWeek[1], 10);
+        weekReset = mWeek[2].trim();
+      }
+
+      if (sessionUsed !== null || weekUsed !== null) {
+        const qInfo = {
+          sessionUsedPct: sessionUsed,
+          sessionRemainingPct: sessionUsed !== null ? Math.max(0, 100 - sessionUsed) : null,
+          sessionReset,
+          weekUsedPct: weekUsed,
+          weekRemainingPct: weekUsed !== null ? Math.max(0, 100 - weekUsed) : null,
+          weekReset,
+          lastChecked: Date.now(),
+        };
+
+        account.quota = qInfo;
+        cache[account.name] = qInfo;
+        this.saveCache(cache);
+        return qInfo;
+      }
+    } catch {}
+
+    return null;
+  }
+
+  static fetchAllQuotas(accounts, forceRefresh = false) {
+    for (const a of accounts) {
+      if (a.enabled === false) continue;
+      this.fetchAccountQuota(a, forceRefresh);
+    }
+  }
+}

package/src/runner.js

@@ -0,0 +1,132 @@
+import { spawnSync } from 'child_process';
+import path from 'path';
+import os from 'os';
+import { SessionSyncEngine } from './sessionSync.js';
+import { MetricsEngine } from './metrics.js';
+import { QuotaEngine } from './quota.js';
+import { renderSessionHeader, renderFailoverBanner, colors } from './ui.js';
+
+export class ProcessRunner {
+  constructor(configManager) {
+    this.configManager = configManager;
+  }
+
+  cleanEnvForAccount(account) {
+    const env = { ...process.env };
+    const defaultClaudePath = path.resolve(path.join(os.homedir(), '.claude'));
+
+    if (path.resolve(account.configDir) !== defaultClaudePath) {
+      env.CLAUDE_CONFIG_DIR = account.configDir;
+    } else {
+      delete env.CLAUDE_CONFIG_DIR;
+    }
+
+    // Clear overrides
+    delete env.ANTHROPIC_BASE_URL;
+    delete env.ANTHROPIC_API_KEY;
+    delete env.ANTHROPIC_DEFAULT_SONNET_MODEL;
+    delete env.CLAUDE_CODE_USE_BEDROCK;
+    delete env.AWS_PROFILE;
+    delete env.AWS_REGION;
+    delete env.ANTHROPIC_DEFAULT_OPUS_MODEL;
+
+    return env;
+  }
+
+  getReadyAccounts(accounts) {
+    const now = Date.now() / 1000;
+    return accounts
+      .filter(a => a.enabled !== false && (!a.rateLimitedUntil || a.rateLimitedUntil < now))
+      .sort((a, b) => a.priority - b.priority);
+  }
+
+  runSession(extraArgs = [], initialAccountName = null) {
+    const accounts = this.configManager.loadAccounts();
+
+    let activeAccount = null;
+    if (initialAccountName) {
+      activeAccount = accounts.find(a => a.name.toLowerCase() === initialAccountName.toLowerCase());
+    }
+
+    if (!activeAccount) {
+      const ready = this.getReadyAccounts(accounts);
+      activeAccount = ready[0] || null;
+    }
+
+    if (!activeAccount) {
+      console.log(`${colors.red}No ready accounts found in Claude Pool!${colors.reset}`);
+      console.log(`Run ${colors.indigo}claude-pool status${colors.reset} or ${colors.indigo}claude-pool setup${colors.reset} to configure accounts.`);
+      return;
+    }
+
+    let resumeSessionId = null;
+    for (let i = 0; i < extraArgs.length; i++) {
+      if ((extraArgs[i] === '-r' || extraArgs[i] === '--resume') && i + 1 < extraArgs.length) {
+        resumeSessionId = extraArgs[i + 1];
+      }
+    }
+
+    while (activeAccount) {
+      const readyAccounts = this.getReadyAccounts(accounts);
+      const standbyAccounts = readyAccounts.filter(a => a.name !== activeAccount.name);
+      const poolStats = MetricsEngine.getPoolStats(accounts);
+
+      // Fast check quota cache
+      QuotaEngine.fetchAllQuotas(accounts, false);
+
+      renderSessionHeader(activeAccount, standbyAccounts, poolStats);
+
+      const cmdArgs = [...extraArgs];
+      if (resumeSessionId && !cmdArgs.includes('-r') && !cmdArgs.includes('--resume')) {
+        cmdArgs.push('--resume', resumeSessionId);
+      }
+
+      const env = this.cleanEnvForAccount(activeAccount);
+
+      let exitCode = 0;
+      try {
+        const proc = spawnSync('claude', cmdArgs, {
+          env,
+          stdio: 'inherit', // Full terminal passthrough
+        });
+        exitCode = proc.status !== null ? proc.status : 1;
+      } catch (err) {
+        console.log(`${colors.red}Error launching claude:${colors.reset} ${err.message}`);
+        break;
+      }
+
+      if (exitCode === 0) {
+        console.log(`\n${colors.emerald}✓ Claude session finished normally.${colors.reset}`);
+        break;
+      }
+
+      // Non-zero exit code: check if rate limited and standby available
+      const latestId = SessionSyncEngine.getLatestSessionId(activeAccount);
+      if (latestId) {
+        resumeSessionId = latestId;
+      }
+
+      if (standbyAccounts.length > 0) {
+        const nextAccount = standbyAccounts[0];
+
+        // Apply 1-hour cooldown
+        activeAccount.rateLimitedUntil = Date.now() / 1000 + 3600;
+        this.configManager.saveAccounts(accounts);
+
+        let transferredId = null;
+        if (resumeSessionId) {
+          transferredId = SessionSyncEngine.transferSession(activeAccount, nextAccount, resumeSessionId);
+        }
+
+        renderFailoverBanner(activeAccount, nextAccount, transferredId || resumeSessionId);
+        activeAccount = nextAccount;
+        if (transferredId) {
+          resumeSessionId = transferredId;
+        }
+      } else {
+        console.log(`\n${colors.amber}⚠️ All accounts in pool are currently exhausted or unavailable.${colors.reset}`);
+        break;
+      }
+    }
+  }
+}

package/src/sessionSync.js

@@ -0,0 +1,79 @@
+import fs from 'fs';
+import path from 'path';
+
+export function encodeProjectName(cwdPath = null) {
+  const p = path.resolve(cwdPath || process.cwd());
+  const parsed = path.parse(p);
+
+  if (parsed.root && parsed.root.includes(':')) {
+    // Windows: E:\PP\accs -> E--PP-accs
+    const drive = parsed.root.replace(':', '').replace(/[\/\\]/g, '');
+    const relativeParts = p.slice(parsed.root.length).split(/[\\/]/).filter(Boolean);
+    if (relativeParts.length === 0) return `${drive}--`;
+    return `${drive}--` + relativeParts.join('-');
+  } else {
+    // POSIX (macOS / Linux): /home/user/app -> -home-user-app
+    const parts = p.split('/').filter(Boolean);
+    return '-' + parts.join('-');
+  }
+}
+
+export class SessionSyncEngine {
+  static getLatestSessionId(account, cwdPath = null) {
+    const projName = encodeProjectName(cwdPath);
+    const projDir = path.join(account.configDir, 'projects', projName);
+
+    if (!fs.existsSync(projDir)) return null;
+
+    try {
+      const files = fs
+        .readdirSync(projDir)
+        .filter(f => f.endsWith('.jsonl') && !f.includes('subagents'))
+        .map(f => {
+          const fullPath = path.join(projDir, f);
+          return { name: f, stem: path.basename(f, '.jsonl'), mtime: fs.statSync(fullPath).mtimeMs };
+        });
+
+      if (files.length === 0) return null;
+      files.sort((a, b) => b.mtime - a.mtime);
+      return files[0].stem;
+    } catch {
+      return null;
+    }
+  }
+
+  static transferSession(sourceAccount, targetAccount, sessionId = null, cwdPath = null) {
+    const projName = encodeProjectName(cwdPath);
+    const srcProjDir = path.join(sourceAccount.configDir, 'projects', projName);
+    const dstProjDir = path.join(targetAccount.configDir, 'projects', projName);
+
+    if (!fs.existsSync(srcProjDir)) return null;
+
+    const actualSessionId = sessionId || this.getLatestSessionId(sourceAccount, cwdPath);
+    if (!actualSessionId) return null;
+
+    const srcSessionFile = path.join(srcProjDir, `${actualSessionId}.jsonl`);
+    if (!fs.existsSync(srcSessionFile)) return null;
+
+    fs.mkdirSync(dstProjDir, { recursive: true });
+    const dstSessionFile = path.join(dstProjDir, `${actualSessionId}.jsonl`);
+
+    // Copy session transcript
+    fs.copyFileSync(srcSessionFile, dstSessionFile);
+
+    // Copy sidecar folder if present (tool-results, subagents)
+    const srcSidecarDir = path.join(srcProjDir, actualSessionId);
+    if (fs.existsSync(srcSidecarDir) && fs.statSync(srcSidecarDir).isDirectory()) {
+      const dstSidecarDir = path.join(dstProjDir, actualSessionId);
+      fs.cpSync(srcSidecarDir, dstSidecarDir, { recursive: true, force: true });
+    }
+
+    // Copy custom-title.json if present
+    const titleFile = path.join(srcProjDir, 'custom-title.json');
+    if (fs.existsSync(titleFile)) {
+      fs.copyFileSync(titleFile, path.join(dstProjDir, 'custom-title.json'));
+    }
+
+    return actualSessionId;
+  }
+}