@karpeleslab/teamclaude 1.0.0

package/src/index.js

@@ -0,0 +1,577 @@
+#!/usr/bin/env node
+
+import { spawn } from 'node:child_process';
+import { createInterface } from 'node:readline';
+import { loadOrCreateConfig, saveConfig, getConfigPath } from './config.js';
+import { AccountManager } from './account-manager.js';
+import { createProxyServer } from './server.js';
+import { importCredentials, loginOAuth, fetchProfile } from './oauth.js';
+import { TUI } from './tui.js';
+
+const args = process.argv.slice(2);
+const command = args[0];
+
+switch (command) {
+  case 'server':
+    await serverCommand();
+    break;
+  case 'import':
+    await importCommand();
+    break;
+  case 'login':
+    await loginCommand();
+    break;
+  case 'env':
+    await envCommand();
+    break;
+  case 'run':
+    await runCommand();
+    break;
+  case 'status':
+    await statusCommand();
+    break;
+  case 'accounts':
+    await accountsCommand();
+    break;
+  case 'remove':
+    await removeCommand();
+    break;
+  case 'api':
+    await apiCommand();
+    break;
+  case 'help':
+  case '--help':
+  case '-h':
+    showHelp();
+    break;
+  default:
+    // No command or unknown command → start server
+    if (command && !command.startsWith('-')) {
+      console.error(`Unknown command: ${command}\n`);
+      showHelp();
+      process.exit(1);
+    }
+    await serverCommand();
+    break;
+}
+
+// ── server ──────────────────────────────────────────────────
+
+async function serverCommand() {
+  const config = await loadOrCreateConfig();
+
+  // --log-to <dir>
+  const logTo = argValue('--log-to');
+  if (logTo) config.logDir = logTo;
+
+  if (config.accounts.length === 0) {
+    console.error('No accounts configured.\n');
+    console.error('Add an account first:');
+    console.error('  teamclaude import           Import from Claude Code');
+    console.error('  teamclaude login            OAuth login via browser');
+    console.error('  teamclaude login --api      Add an API key');
+    process.exit(1);
+  }
+
+  const accounts = await resolveAccounts(config);
+  if (accounts.length === 0) {
+    console.error('No valid accounts after initialization');
+    process.exit(1);
+  }
+
+  const threshold = config.switchThreshold || 0.98;
+  const accountManager = new AccountManager(accounts, threshold);
+
+  // Persist refreshed tokens back to config
+  accountManager.onTokenRefresh((idx, newTokens) => {
+    const cfgAcct = config.accounts[idx];
+    if (cfgAcct) {
+      cfgAcct.accessToken = newTokens.accessToken;
+      cfgAcct.refreshToken = newTokens.refreshToken;
+      cfgAcct.expiresAt = newTokens.expiresAt;
+      saveConfig(config).catch(err => console.error(`[TeamClaude] Failed to save refreshed token: ${err.message}`));
+    }
+  });
+  const port = config.proxy.port;
+  const useTUI = process.stdout.isTTY && process.stdin.isTTY;
+
+  let tui = null;
+  let hooks = {};
+
+  if (useTUI) {
+    tui = new TUI({
+      accountManager, config, saveConfig,
+      onQuit: () => { server.close(() => process.exit(0)); },
+    });
+    hooks = {
+      onRequestStart: (id, info) => tui.onRequestStart(id, info),
+      onRequestRouted: (id, info) => tui.onRequestRouted(id, info),
+      onRequestEnd: (id, info) => tui.onRequestEnd(id, info),
+    };
+  }
+
+  const server = createProxyServer(accountManager, config, hooks);
+
+  server.listen(port, () => {
+    if (tui) {
+      tui.start();
+      console.log(`Listening on port ${port} with ${accounts.length} account(s)`);
+    } else {
+      const sep = '='.repeat(60);
+      console.log('');
+      console.log(sep);
+      console.log('  TeamClaude Proxy');
+      console.log(sep);
+      console.log(`  Port:       ${port}`);
+      console.log(`  Accounts:   ${accounts.length}`);
+      console.log(`  Threshold:  ${(threshold * 100).toFixed(0)}%`);
+      console.log(`  Upstream:   ${config.upstream || 'https://api.anthropic.com'}`);
+      console.log('');
+      accounts.forEach((a, i) => {
+        console.log(`  [${i + 1}] ${a.name} (${a.type})`);
+      });
+      console.log('');
+      console.log('  Run Claude through proxy:  teamclaude run');
+      console.log('  Show env vars:             teamclaude env');
+      console.log(sep);
+      console.log('');
+    }
+  });
+
+  if (!tui) {
+    process.on('SIGINT', () => {
+      console.log('\n[TeamClaude] Shutting down...');
+      server.close(() => process.exit(0));
+    });
+    process.on('SIGTERM', () => {
+      console.log('\n[TeamClaude] Shutting down...');
+      server.close(() => process.exit(0));
+    });
+  }
+}
+
+// ── import ──────────────────────────────────────────────────
+
+async function importCommand() {
+  const config = await loadOrCreateConfig();
+
+  let name = argValue('--name');
+  const fromPath = argValue('--from') || '~/.claude/.credentials.json';
+
+  let creds;
+  try {
+    creds = await importCredentials(fromPath);
+  } catch (err) {
+    console.error(`Failed to import from ${fromPath}: ${err.message}`);
+    process.exit(1);
+  }
+
+  await upsertOAuthAccount(config, name, creds, 'import');
+}
+
+// ── login ───────────────────────────────────────────────────
+
+async function loginCommand() {
+  if (args.includes('--api')) {
+    await loginApiCommand();
+    return;
+  }
+  if (args.includes('--oauth')) {
+    await loginOAuthCommand();
+    return;
+  }
+
+  // Default to OAuth if not a TTY
+  if (!process.stdout.isTTY) {
+    await loginOAuthCommand();
+    return;
+  }
+
+  // Interactive menu
+  const rl = createInterface({ input: process.stdin, output: process.stderr });
+  console.log('Select login method:\n');
+  console.log('  1. Claude subscription  (Pro, Max, Team, Enterprise)');
+  console.log('  2. Anthropic API key    (Console API billing)');
+  console.log('');
+  const choice = await new Promise(resolve => rl.question('Choice [1]: ', resolve));
+  rl.close();
+
+  switch (choice.trim() || '1') {
+    case '1': await loginOAuthCommand(); break;
+    case '2': await loginApiCommand(); break;
+    default:
+      console.error(`Invalid choice: ${choice.trim()}`);
+      process.exit(1);
+  }
+}
+
+async function loginApiCommand() {
+  const config = await loadOrCreateConfig();
+  let name = argValue('--name');
+
+  const rl = createInterface({ input: process.stdin, output: process.stderr });
+  const apiKey = await new Promise(resolve => rl.question('Anthropic API key: ', resolve));
+  rl.close();
+
+  if (!apiKey.trim()) {
+    console.error('No API key provided');
+    process.exit(1);
+  }
+
+  if (!name) {
+    const n = config.accounts.filter(a => a.name.startsWith('api-')).length + 1;
+    name = `api-${n}`;
+  }
+
+  config.accounts.push({ name, type: 'apikey', apiKey: apiKey.trim() });
+  await saveConfig(config);
+  console.log(`Added API key account "${name}"`);
+  console.log(`Saved to ${getConfigPath()}`);
+}
+
+async function loginOAuthCommand() {
+  const config = await loadOrCreateConfig();
+  let name = argValue('--name');
+
+  console.log('Starting OAuth login...');
+  let creds;
+  try {
+    creds = await loginOAuth();
+  } catch (err) {
+    console.error(`OAuth login failed: ${err.message}`);
+    console.error('');
+    console.error('Alternatives:');
+    console.error('  teamclaude import        Import from existing Claude Code credentials');
+    console.error('  teamclaude login --api   Add an API key instead');
+    process.exit(1);
+  }
+
+  await upsertOAuthAccount(config, name, creds, 'login');
+}
+
+// ── env ─────────────────────────────────────────────────────
+
+async function envCommand() {
+  const config = await loadOrCreateConfig();
+  console.log(`export ANTHROPIC_BASE_URL=http://localhost:${config.proxy.port}`);
+  console.log(`export ANTHROPIC_API_KEY=${config.proxy.apiKey}`);
+}
+
+// ── run ─────────────────────────────────────────────────────
+
+async function runCommand() {
+  const config = await loadOrCreateConfig();
+
+  // Everything after 'run' (skip -- separator if present)
+  const claudeArgs = args.slice(1);
+  if (claudeArgs[0] === '--') claudeArgs.shift();
+
+  const child = spawn('claude', claudeArgs, {
+    stdio: 'inherit',
+    env: {
+      ...process.env,
+      ANTHROPIC_BASE_URL: `http://localhost:${config.proxy.port}`,
+      ANTHROPIC_API_KEY: config.proxy.apiKey,
+    },
+  });
+
+  child.on('error', (err) => {
+    if (err.code === 'ENOENT') {
+      console.error('Claude Code not found in PATH. Install it first.');
+    } else {
+      console.error(`Failed to start claude: ${err.message}`);
+    }
+    process.exit(1);
+  });
+
+  child.on('exit', (code) => process.exit(code ?? 1));
+}
+
+// ── status ──────────────────────────────────────────────────
+
+async function statusCommand() {
+  const config = await loadOrCreateConfig();
+  const url = `http://localhost:${config.proxy.port}/teamclaude/status`;
+
+  try {
+    const res = await fetch(url, { headers: { 'x-api-key': config.proxy.apiKey } });
+    const data = await res.json();
+
+    console.log(`Active account: ${data.currentAccount}`);
+    console.log(`Switch at:      ${(data.switchThreshold * 100).toFixed(0)}% usage\n`);
+
+    for (const acct of data.accounts) {
+      const q = acct.quota;
+      const current = acct.name === data.currentAccount ? ' *' : '';
+
+      console.log(`  ${acct.name} (${acct.type})${current}`);
+      console.log(`    Status:   ${acct.status}`);
+
+      if (q.unified5h != null || q.unified7d != null) {
+        const ses = q.unified5h != null ? (q.unified5h * 100).toFixed(1) + '%' : '-';
+        const wk = q.unified7d != null ? (q.unified7d * 100).toFixed(1) + '%' : '-';
+        console.log(`    Session:  ${ses} used    Weekly: ${wk} used`);
+      } else {
+        const tok = q.tokensLimit ? ((1 - q.tokensRemaining / q.tokensLimit) * 100).toFixed(1) + '%' : '-';
+        const req = q.requestsLimit ? ((1 - q.requestsRemaining / q.requestsLimit) * 100).toFixed(1) + '%' : '-';
+        console.log(`    Tokens:   ${tok} used    Requests: ${req} used`);
+      }
+
+      console.log(`    Total:    ${acct.usage.totalInputTokens + acct.usage.totalOutputTokens} tokens, ${acct.usage.totalRequests} requests`);
+      if (acct.rateLimitedUntil) console.log(`    Throttled until: ${acct.rateLimitedUntil}`);
+      console.log('');
+    }
+  } catch {
+    console.error(`Cannot connect to proxy at localhost:${config.proxy.port}`);
+    console.error('Is the server running? Start with: teamclaude server');
+    process.exit(1);
+  }
+}
+
+// ── accounts ────────────────────────────────────────────────
+
+async function accountsCommand() {
+  const config = await loadOrCreateConfig();
+
+  if (config.accounts.length === 0) {
+    console.log('No accounts configured.');
+    console.log('Add one with: teamclaude import, teamclaude login, or teamclaude login --api');
+    return;
+  }
+
+  // Fetch profiles in parallel for all OAuth accounts
+  const profiles = await Promise.all(
+    config.accounts.map(a =>
+      a.type === 'oauth' && a.accessToken ? fetchProfile(a.accessToken) : null
+    )
+  );
+
+  // Deduplicate by accountUuid — keep the last (most recently added) entry
+  const seen = new Map();
+  let removed = 0;
+  for (let i = config.accounts.length - 1; i >= 0; i--) {
+    const a = config.accounts[i];
+    const uuid = profiles[i]?.accountUuid || a.accountUuid;
+    if (uuid) {
+      if (seen.has(uuid)) {
+        config.accounts.splice(i, 1);
+        profiles.splice(i, 1);
+        removed++;
+      } else {
+        seen.set(uuid, i);
+        // Update stored UUID and name from profile
+        if (profiles[i]) {
+          a.accountUuid = profiles[i].accountUuid;
+          if (profiles[i].email) a.name = profiles[i].email;
+        }
+      }
+    }
+  }
+  if (removed > 0) {
+    await saveConfig(config);
+    console.log(`Removed ${removed} duplicate account(s)\n`);
+  }
+
+  for (const [i, a] of config.accounts.entries()) {
+    const p = profiles[i];
+
+    if (a.type === 'apikey') {
+      console.log(`  [${i + 1}] ${a.name} (apikey)  ${a.apiKey?.slice(0, 15)}...`);
+      continue;
+    }
+
+    // OAuth account
+    const tier = p?.hasClaudeMax ? 'Max' : p?.hasClaudePro ? 'Pro' : 'subscription';
+    const status = p ? `Claude ${tier}` : 'unknown (profile fetch failed)';
+    const src = a.source ? `, ${a.source}` : '';
+    console.log(`  [${i + 1}] ${a.name} (${status}${src})`);
+    if (p?.email && p.email !== a.name) console.log(`       Email: ${p.email}`);
+    if (p?.orgName) console.log(`       Org:   ${p.orgName}`);
+  }
+}
+
+// ── api ─────────────────────────────────────────────────────
+
+async function apiCommand() {
+  const config = await loadOrCreateConfig();
+  const path = args[1];
+
+  if (!path) {
+    console.error('Usage: teamclaude api <path> [--account NAME] [--method POST] [--data JSON]');
+    console.error('Example: teamclaude api /api/oauth/claude_cli/roles');
+    process.exit(1);
+  }
+
+  // Find account to use
+  const accountName = argValue('--account');
+  const method = (argValue('--method') || 'GET').toUpperCase();
+  const data = argValue('--data');
+
+  const accounts = await resolveAccounts(config);
+  let account;
+  if (accountName) {
+    account = accounts.find(a => a.name === accountName);
+    if (!account) { console.error(`Account "${accountName}" not found`); process.exit(1); }
+  } else {
+    account = accounts.find(a => a.type === 'oauth') || accounts[0];
+    if (!account) { console.error('No accounts configured'); process.exit(1); }
+  }
+
+  const credential = account.accessToken || account.apiKey;
+  const isOAuth = account.type === 'oauth';
+  const upstream = config.upstream || 'https://api.anthropic.com';
+  const url = path.startsWith('http') ? path : `${upstream}${path}`;
+
+  const headers = isOAuth
+    ? { 'Authorization': `Bearer ${credential}` }
+    : { 'x-api-key': credential };
+
+  const fetchOpts = { method, headers };
+  if (data) {
+    headers['Content-Type'] = 'application/json';
+    fetchOpts.body = data;
+  }
+
+  const res = await fetch(url, fetchOpts);
+
+  // Print response headers to stderr
+  console.error(`${res.status} ${res.statusText}`);
+  for (const [k, v] of res.headers.entries()) {
+    console.error(`  ${k}: ${v}`);
+  }
+  console.error('');
+
+  // Print body to stdout
+  const body = await res.text();
+  try {
+    console.log(JSON.stringify(JSON.parse(body), null, 2));
+  } catch {
+    console.log(body);
+  }
+}
+
+// ── remove ──────────────────────────────────────────────────
+
+async function removeCommand() {
+  const config = await loadOrCreateConfig();
+  const name = args[1];
+
+  if (!name) {
+    console.error('Usage: teamclaude remove <account-name>');
+    process.exit(1);
+  }
+
+  const idx = config.accounts.findIndex(a => a.name === name);
+  if (idx < 0) {
+    console.error(`Account "${name}" not found`);
+    process.exit(1);
+  }
+
+  config.accounts.splice(idx, 1);
+  await saveConfig(config);
+  console.log(`Removed account "${name}"`);
+}
+
+// ── help ────────────────────────────────────────────────────
+
+function showHelp() {
+  console.log(`TeamClaude - Multi-account Claude proxy
+
+Usage: teamclaude [command] [options]
+
+Commands:
+  server              Start the proxy server (default)
+  import              Import credentials from Claude Code
+  login               OAuth login via browser
+  login --api         Add an API key account
+  env                 Print env vars to use with Claude
+  run [-- args...]    Run Claude Code through the proxy
+  status              Show proxy & account status (live)
+  accounts            List configured accounts
+  remove <name>       Remove an account
+  api <path>          Call an API endpoint with account credentials
+  help                Show this help
+
+Options:
+  --name NAME         Set account name (import/login)
+  --from PATH         Credentials path (import, default: ~/.claude/.credentials.json)
+  --log-to DIR        Log full requests/responses to DIR (server, one file per request)
+
+Config: ${getConfigPath()}
+`);
+}
+
+// ── shared account upsert ────────────────────────────────────
+
+async function upsertOAuthAccount(config, name, creds, source = 'unknown') {
+  // Fetch profile to auto-name and deduplicate by account UUID
+  const profile = await fetchProfile(creds.accessToken);
+
+  if (!name && profile?.email) {
+    name = profile.email;
+    const tier = profile.hasClaudeMax ? 'Max' : profile.hasClaudePro ? 'Pro' : null;
+    if (tier) console.log(`Detected Claude ${tier} account: ${profile.email}`);
+  }
+  if (!name) {
+    const n = config.accounts.filter(a => a.name.startsWith('account-')).length + 1;
+    name = `account-${n}`;
+  }
+
+  const account = {
+    name,
+    type: 'oauth',
+    source,
+    accountUuid: profile?.accountUuid || null,
+    accessToken: creds.accessToken,
+    refreshToken: creds.refreshToken,
+    expiresAt: creds.expiresAt,
+  };
+
+  // Deduplicate: match by UUID first, then by name
+  let idx = profile?.accountUuid
+    ? config.accounts.findIndex(a => a.accountUuid === profile.accountUuid)
+    : -1;
+  if (idx < 0) idx = config.accounts.findIndex(a => a.name === name);
+
+  if (idx >= 0) {
+    config.accounts[idx] = account;
+    console.log(`Updated account "${name}"`);
+  } else {
+    config.accounts.push(account);
+    console.log(`Added account "${name}"`);
+  }
+
+  await saveConfig(config);
+  console.log(`Saved to ${getConfigPath()}`);
+}
+
+// ── helpers ─────────────────────────────────────────────────
+
+async function resolveAccounts(config) {
+  const accounts = [];
+  for (const acct of config.accounts) {
+    if (acct.type === 'oauth') {
+      if (acct.importFrom) {
+        try {
+          const creds = await importCredentials(acct.importFrom);
+          accounts.push({ name: acct.name, type: 'oauth', ...creds });
+          console.log(`Imported "${acct.name}" from ${acct.importFrom}`);
+        } catch (err) {
+          console.error(`Failed to import "${acct.name}": ${err.message}`);
+        }
+      } else if (acct.accessToken) {
+        accounts.push(acct);
+      } else {
+        console.error(`No token for "${acct.name}", skipping`);
+      }
+    } else if (acct.type === 'apikey' && acct.apiKey) {
+      accounts.push(acct);
+    }
+  }
+  return accounts;
+}
+
+function argValue(flag) {
+  const i = args.indexOf(flag);
+  return (i >= 0 && args[i + 1]) ? args[i + 1] : null;
+}