@kamel-ahmed/proxy-claude 1.0.3 → 1.0.5

package/bin/cli.js

@@ -1,12 +1,31 @@
 #!/usr/bin/env node
 
+/**
+ * Proxy Claude CLI
+ * 
+ * Cross-platform CLI tool for running Claude Code with Antigravity proxy.
+ * Works on Windows, macOS, and Linux.
+ */
+
 import { fileURLToPath } from 'url';
 import { dirname, join } from 'path';
-import { readFileSync } from 'fs';
+import { readFileSync, existsSync } from 'fs';
+import { spawn, execSync } from 'child_process';
+import os from 'os';
+import http from 'http';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 
+// Platform detection
+const IS_WINDOWS = process.platform === 'win32';
+const HOME_DIR = os.homedir();
+
+// Config paths
+const CONFIG_DIR = join(HOME_DIR, '.config', 'antigravity-proxy');
+const ACCOUNTS_FILE = join(CONFIG_DIR, 'accounts.json');
+const CLAUDE_SETTINGS = join(HOME_DIR, '.claude', 'settings.json');
+
 // Read package.json for version
 const packageJson = JSON.parse(
   readFileSync(join(__dirname, '..', 'package.json'), 'utf-8')
@@ -15,50 +34,164 @@ const packageJson = JSON.parse(
 const args = process.argv.slice(2);
 const command = args[0];
 
+// Colors (cross-platform)
+const C = {
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+  dim: '\x1b[2m',
+  red: '\x1b[31m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  cyan: '\x1b[36m',
+};
+
+/**
+ * Check if first run (no accounts or settings configured)
+ */
+function isFirstRun() {
+  try {
+    if (!existsSync(ACCOUNTS_FILE)) return true;
+    const accounts = JSON.parse(readFileSync(ACCOUNTS_FILE, 'utf-8'));
+    if (!accounts.accounts || accounts.accounts.length === 0) return true;
+    
+    if (!existsSync(CLAUDE_SETTINGS)) return true;
+    const settings = JSON.parse(readFileSync(CLAUDE_SETTINGS, 'utf-8'));
+    if (!settings.env?.ANTHROPIC_BASE_URL) return true;
+    
+    return false;
+  } catch {
+    return true;
+  }
+}
+
+/**
+ * Check if command exists (cross-platform)
+ */
+function commandExists(cmd) {
+  try {
+    const checkCmd = IS_WINDOWS ? `where ${cmd}` : `which ${cmd}`;
+    execSync(checkCmd, { stdio: 'ignore' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Check if port is in use using Node.js (cross-platform)
+ */
+function checkPort(port) {
+  return new Promise((resolve) => {
+    const req = http.get(`http://localhost:${port}/health`, (res) => {
+      resolve(true);
+      res.resume();
+    });
+    req.on('error', () => resolve(false));
+    req.setTimeout(1000, () => {
+      req.destroy();
+      resolve(false);
+    });
+  });
+}
+
+/**
+ * Wait for proxy to be ready
+ */
+async function waitForProxy(port, maxAttempts = 60) {
+  for (let i = 0; i < maxAttempts; i++) {
+    if (await checkPort(port)) return true;
+    await new Promise(r => setTimeout(r, 500));
+  }
+  return false;
+}
+
+/**
+ * Stop proxy server (cross-platform)
+ */
+async function stopProxy(port) {
+  if (IS_WINDOWS) {
+    try {
+      // Find PID using netstat on Windows
+      const output = execSync(`netstat -ano | findstr :${port} | findstr LISTENING`, { 
+        encoding: 'utf-8',
+        stdio: ['pipe', 'pipe', 'ignore']
+      });
+      const lines = output.trim().split('\n');
+      for (const line of lines) {
+        const parts = line.trim().split(/\s+/);
+        const pid = parts[parts.length - 1];
+        if (pid && pid !== '0') {
+          try {
+            execSync(`taskkill /F /PID ${pid}`, { stdio: 'ignore' });
+          } catch {}
+        }
+      }
+      return true;
+    } catch {
+      return false;
+    }
+  } else {
+    try {
+      execSync(`lsof -ti tcp:${port} | xargs kill 2>/dev/null`, { 
+        stdio: 'ignore',
+        shell: true 
+      });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+}
+
+/**
+ * Get port from args or env
+ */
+function getPort() {
+  const portIndex = args.findIndex(a => a === '--port' || a === '-p');
+  if (portIndex !== -1 && args[portIndex + 1]) {
+    return parseInt(args[portIndex + 1], 10);
+  }
+  return parseInt(process.env.PORT || '8080', 10);
+}
+
 function showHelp() {
   console.log(`
-proxy-claude v${packageJson.version}
+${C.cyan}proxy-claude${C.reset} v${packageJson.version}
 
 Proxy server for using Antigravity's Claude models with Claude Code CLI.
 
-USAGE:
+${C.bold}USAGE:${C.reset}
   proxy-claude [command] [options]
 
-COMMANDS:
-  (default)             Start proxy + launch Claude Code (interactive)
-  run                   Same as default - start proxy + Claude Code
-  start                 Start the proxy server only (foreground)
-  web                   Same as start - server with web dashboard
-  accounts              Manage Google accounts (interactive)
-  accounts add          Add a new Google account via OAuth
-  accounts list         List all configured accounts
-  accounts remove       Remove accounts interactively
-  accounts verify       Verify account tokens are valid
-  accounts clear        Remove all accounts
-  refresh               Check and refresh account tokens
-  setup                 Install Claude Code CLI (if needed)
-
-OPTIONS:
+${C.bold}COMMANDS:${C.reset}
+  ${C.cyan}(default)${C.reset}             Start proxy + launch Claude Code
+  ${C.cyan}init${C.reset}                  Run setup wizard (configure models & accounts)
+  ${C.cyan}start${C.reset}                 Start the proxy server only
+  ${C.cyan}stop${C.reset}                  Stop running proxy server
+  ${C.cyan}status${C.reset}                Check if proxy is running
+  ${C.cyan}accounts${C.reset}              Manage Google accounts (add/list/remove/verify)
+  ${C.cyan}refresh${C.reset}               Check and refresh account tokens
+
+${C.bold}OPTIONS:${C.reset}
   --help, -h            Show this help message
   --version, -v         Show version number
+  --port, -p <port>     Set custom port (default: 8080)
+  --force               Force reconfigure (with init)
 
-ENVIRONMENT:
+${C.bold}ENVIRONMENT:${C.reset}
   PORT                  Server port (default: 8080)
 
-EXAMPLES:
+${C.bold}EXAMPLES:${C.reset}
   proxy-claude                    # Start proxy + Claude Code
-  proxy-claude run                # Same as above
+  proxy-claude init               # Run setup wizard
   proxy-claude start              # Start proxy server only
+  proxy-claude stop               # Stop proxy server
   PORT=3000 proxy-claude          # Use custom port
   proxy-claude accounts add       # Add Google account
 
-CONFIGURATION:
-  Claude Code CLI (~/.claude/settings.json):
-    {
-      "env": {
-        "ANTHROPIC_BASE_URL": "http://localhost:8080"
-      }
-    }
+${C.bold}FIRST TIME?${C.reset}
+  Run ${C.cyan}proxy-claude init${C.reset} to configure everything.
 `);
 }
 
@@ -66,6 +199,9 @@ function showVersion() {
   console.log(packageJson.version);
 }
 
+/**
+ * Main CLI handler
+ */
 async function main() {
   // Handle flags
   if (args.includes('--help') || args.includes('-h')) {
@@ -78,98 +214,52 @@ async function main() {
     process.exit(0);
   }
 
+  const port = getPort();
+
   // Handle commands
   switch (command) {
-    case 'setup':
-      await import('../src/cli/setup.js').then(module => module.runSetup());
+    case 'init':
+    case 'setup': {
+      // Run onboarding wizard
+      const force = args.includes('--force') || args.includes('-f');
+      const { runOnboarding } = await import('../src/cli/onboard.js');
+      const success = await runOnboarding({ skipIfConfigured: !force });
+      process.exit(success ? 0 : 1);
       break;
+    }
 
     case 'start':
+    case 'web': {
       // Start the server only
       await import('../src/index.js');
       break;
+    }
 
-    case 'web':
-      // Alias for start (server with web dashboard)
-      await import('../src/index.js');
+    case 'stop': {
+      // Stop running proxy
+      console.log(`${C.yellow}Stopping proxy on port ${port}...${C.reset}`);
+      const stopped = await stopProxy(port);
+      if (stopped) {
+        console.log(`${C.green}✓ Proxy stopped${C.reset}`);
+      } else {
+        console.log(`${C.dim}No proxy found running on port ${port}${C.reset}`);
+      }
       break;
+    }
 
-    case undefined:
-    case 'run': {
-      // Default: Start proxy in background + launch Claude Code
-      const { spawn, execSync } = await import('child_process');
-      const port = process.env.PORT || 8080;
-      
-      console.log(`\x1b[34mStarting Antigravity Claude Proxy on port ${port}...\x1b[0m`);
-      
-      // Start proxy in background
-      const proxyProcess = spawn('node', [join(__dirname, '..', 'src', 'index.js')], {
-        detached: true,
-        stdio: 'ignore',
-        env: { ...process.env, PORT: port }
-      });
-      proxyProcess.unref();
-      
-      // Wait for proxy to be ready
-      console.log('Waiting for proxy to be ready...');
-      let ready = false;
-      for (let i = 0; i < 60; i++) {
+    case 'status': {
+      // Check if proxy is running
+      const running = await checkPort(port);
+      if (running) {
+        console.log(`${C.green}✓ Proxy is running on port ${port}${C.reset}`);
         try {
-          execSync(`curl -s http://localhost:${port}/health`, { stdio: 'ignore' });
-          ready = true;
-          break;
-        } catch {
-          await new Promise(r => setTimeout(r, 500));
-        }
-      }
-      
-      if (!ready) {
-        console.error('\x1b[31mError: Proxy failed to start within 30 seconds.\x1b[0m');
-        process.exit(1);
-      }
-      
-      console.log(`\x1b[32m✓ Proxy is ready on port ${port}!\x1b[0m\n`);
-      
-      // Check if claude is installed
-      try {
-        execSync('which claude', { stdio: 'ignore' });
-      } catch {
-        console.error('\x1b[31mError: Claude Code CLI not found.\x1b[0m');
-        console.error('Install it with: npm install -g @anthropic-ai/claude-code');
-        process.exit(1);
-      }
-      
-      // Launch Claude with proxy config
-      const claudeArgs = args.slice(command === 'run' ? 1 : 0);
-      const claudeProcess = spawn('claude', claudeArgs, {
-        stdio: 'inherit',
-        env: {
-          ...process.env,
-          ANTHROPIC_BASE_URL: `http://localhost:${port}`,
-          ANTHROPIC_API_KEY: 'dummy'
-        }
-      });
-      
-      // Cleanup on exit
-      const cleanup = () => {
-        console.log('\n\x1b[33mStopping Antigravity Claude Proxy...\x1b[0m');
-        try {
-          execSync(`lsof -ti tcp:${port} | xargs kill 2>/dev/null`, { stdio: 'ignore' });
+          const res = await fetch(`http://localhost:${port}/health`);
+          const data = await res.json();
+          console.log(`  ${C.dim}Status: ${data.summary}${C.reset}`);
         } catch {}
-        console.log('\x1b[32m✓ Proxy stopped\x1b[0m');
-      };
-      
-      claudeProcess.on('close', (code) => {
-        cleanup();
-        process.exit(code || 0);
-      });
-      
-      process.on('SIGINT', () => {
-        claudeProcess.kill('SIGINT');
-      });
-      process.on('SIGTERM', () => {
-        claudeProcess.kill('SIGTERM');
-      });
+      } else {
+        console.log(`${C.yellow}✗ Proxy is not running on port ${port}${C.reset}`);
+      }
       break;
     }
 
@@ -198,14 +288,116 @@ async function main() {
       showVersion();
       break;
 
+    case undefined:
+    case 'run': {
+      // Check if first run - prompt for setup
+      if (isFirstRun()) {
+        console.log(`${C.cyan}Welcome to Proxy Claude!${C.reset}`);
+        console.log(`${C.dim}It looks like this is your first time running.${C.reset}`);
+        console.log('');
+        console.log(`Running setup wizard...`);
+        console.log('');
+        
+        const { runOnboarding } = await import('../src/cli/onboard.js');
+        const success = await runOnboarding();
+        if (!success) {
+          process.exit(1);
+        }
+        console.log('');
+      }
+
+      // Default: Start proxy in background + launch Claude Code
+      console.log(`${C.blue}Starting Antigravity Claude Proxy on port ${port}...${C.reset}`);
+      
+      // Check if already running
+      if (await checkPort(port)) {
+        console.log(`${C.green}✓ Proxy already running on port ${port}${C.reset}`);
+      } else {
+        // Start proxy in background
+        const proxyScript = join(__dirname, '..', 'src', 'index.js');
+        const proxyProcess = spawn(process.execPath, [proxyScript], {
+          detached: true,
+          stdio: 'ignore',
+          env: { ...process.env, PORT: String(port) },
+          shell: false,
+          windowsHide: true,
+        });
+        proxyProcess.unref();
+        
+        // Wait for proxy to be ready
+        console.log('Waiting for proxy to be ready...');
+        const ready = await waitForProxy(port);
+        
+        if (!ready) {
+          console.error(`${C.red}Error: Proxy failed to start within 30 seconds.${C.reset}`);
+          process.exit(1);
+        }
+        
+        console.log(`${C.green}✓ Proxy is ready on port ${port}!${C.reset}`);
+      }
+      console.log('');
+      
+      // Check if claude is installed
+      if (!commandExists('claude')) {
+        console.error(`${C.red}Error: Claude Code CLI not found.${C.reset}`);
+        console.error('Install it with: npm install -g @anthropic-ai/claude-code');
+        console.error('Or run: proxy-claude init');
+        process.exit(1);
+      }
+      
+      // Launch Claude with proxy config
+      const claudeArgs = args.slice(command === 'run' ? 1 : 0).filter(a => 
+        a !== '--port' && a !== '-p' && !args[args.indexOf('--port') + 1]?.includes(a)
+      );
+      
+      const claudeProcess = spawn('claude', claudeArgs, {
+        stdio: 'inherit',
+        env: {
+          ...process.env,
+          ANTHROPIC_BASE_URL: `http://localhost:${port}`,
+          ANTHROPIC_API_KEY: 'proxy-claude',
+        },
+        shell: IS_WINDOWS,
+      });
+      
+      // Cleanup on exit
+      const cleanup = async () => {
+        console.log(`\n${C.yellow}Stopping Antigravity Claude Proxy...${C.reset}`);
+        await stopProxy(port);
+        console.log(`${C.green}✓ Proxy stopped${C.reset}`);
+      };
+      
+      claudeProcess.on('close', async (code) => {
+        await cleanup();
+        process.exit(code || 0);
+      });
+      
+      // Handle signals
+      const handleSignal = (signal) => {
+        claudeProcess.kill(signal);
+      };
+      
+      process.on('SIGINT', () => handleSignal('SIGINT'));
+      process.on('SIGTERM', () => handleSignal('SIGTERM'));
+      
+      // Windows-specific handling
+      if (IS_WINDOWS) {
+        process.on('SIGHUP', () => handleSignal('SIGHUP'));
+      }
+      break;
+    }
+
     default:
-      console.error(`Unknown command: ${command}`);
+      console.error(`${C.red}Unknown command: ${command}${C.reset}`);
       console.error('Run "proxy-claude --help" for usage information.');
       process.exit(1);
   }
 }
 
 main().catch((err) => {
-  console.error('Error:', err.message);
+  console.error(`${C.red}Error:${C.reset}`, err.message);
+  if (process.env.DEBUG) {
+    console.error(err.stack);
+  }
   process.exit(1);
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kamel-ahmed/proxy-claude",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "description": "Proxy server to use Antigravity's Claude models with Claude Code CLI - run 'proxy-claude' to start",
   "main": "src/index.js",
   "type": "module",
@@ -26,7 +26,7 @@
     "accounts:verify": "node src/cli/accounts.js verify",
     "refresh": "node src/cli/refresh.js",
     "refresh:force": "node src/cli/refresh.js --force",
-    "setup": "node bin/cli.js setup",
+    "setup": "node bin/cli.js init",
     "test": "node tests/run-all.cjs",
     "test:signatures": "node tests/test-thinking-signatures.cjs",
     "test:multiturn": "node tests/test-multiturn-thinking-tools.cjs",

package/src/cli/onboard.js

@@ -0,0 +1,580 @@
+/**
+ * Professional CLI Onboarding
+ * 
+ * Cross-platform setup wizard that configures everything needed
+ * to run Claude Code with the Antigravity proxy.
+ */
+
+import { execSync, spawn } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import readline from 'readline';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// Colors (cross-platform safe)
+const supportsColor = process.stdout.isTTY && (
+    process.env.COLORTERM === 'truecolor' ||
+    process.env.TERM?.includes('256color') ||
+    process.platform === 'win32'
+);
+
+const COLORS = {
+    reset: supportsColor ? '\x1b[0m' : '',
+    bold: supportsColor ? '\x1b[1m' : '',
+    dim: supportsColor ? '\x1b[2m' : '',
+    red: supportsColor ? '\x1b[31m' : '',
+    green: supportsColor ? '\x1b[32m' : '',
+    yellow: supportsColor ? '\x1b[33m' : '',
+    blue: supportsColor ? '\x1b[34m' : '',
+    magenta: supportsColor ? '\x1b[35m' : '',
+    cyan: supportsColor ? '\x1b[36m' : '',
+    white: supportsColor ? '\x1b[37m' : '',
+};
+
+// Platform detection
+const PLATFORM = {
+    isWindows: process.platform === 'win32',
+    isMac: process.platform === 'darwin',
+    isLinux: process.platform === 'linux',
+    homeDir: os.homedir(),
+    pathSep: path.sep,
+};
+
+// Paths
+const CONFIG_DIR = path.join(PLATFORM.homeDir, '.config', 'antigravity-proxy');
+const ACCOUNTS_FILE = path.join(CONFIG_DIR, 'accounts.json');
+const CLAUDE_CONFIG_DIR = path.join(PLATFORM.homeDir, '.claude');
+const CLAUDE_SETTINGS_FILE = path.join(CLAUDE_CONFIG_DIR, 'settings.json');
+
+// All available models in Antigravity (fetched dynamically, but this is a fallback)
+const ALL_MODELS = [
+    // Claude models
+    { id: 'claude-opus-4-5-thinking', family: 'claude', tier: 'opus', description: 'Claude Opus 4.5 with thinking' },
+    { id: 'claude-sonnet-4-5-thinking', family: 'claude', tier: 'sonnet', description: 'Claude Sonnet 4.5 with thinking' },
+    { id: 'claude-sonnet-4-5', family: 'claude', tier: 'sonnet', description: 'Claude Sonnet 4.5' },
+    // Gemini models  
+    { id: 'gemini-3-pro-high', family: 'gemini', tier: 'opus', description: 'Gemini 3 Pro High (best quality)' },
+    { id: 'gemini-3-pro-low', family: 'gemini', tier: 'sonnet', description: 'Gemini 3 Pro Low' },
+    { id: 'gemini-3-flash', family: 'gemini', tier: 'sonnet', description: 'Gemini 3 Flash (fast)' },
+    { id: 'gemini-2.5-flash-lite', family: 'gemini', tier: 'haiku', description: 'Gemini 2.5 Flash Lite (fastest)' },
+];
+
+// Model tier descriptions
+const TIER_INFO = {
+    opus: {
+        name: 'Opus (Primary)',
+        description: 'Main model for complex tasks',
+        envKey: 'ANTHROPIC_DEFAULT_OPUS_MODEL',
+    },
+    sonnet: {
+        name: 'Sonnet (Default)',
+        description: 'Balanced model for most tasks',
+        envKey: 'ANTHROPIC_DEFAULT_SONNET_MODEL',
+    },
+    haiku: {
+        name: 'Haiku (Fast)',
+        description: 'Quick model for simple tasks & background',
+        envKey: 'ANTHROPIC_DEFAULT_HAIKU_MODEL',
+    },
+};
+
+/**
+ * Create readline interface for user input
+ */
+function createPrompt() {
+    return readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+}
+
+/**
+ * Prompt user for input
+ */
+async function prompt(rl, question, defaultValue = '') {
+    return new Promise((resolve) => {
+        const defaultText = defaultValue ? ` ${COLORS.dim}(${defaultValue})${COLORS.reset}` : '';
+        rl.question(`${question}${defaultText}: `, (answer) => {
+            resolve(answer.trim() || defaultValue);
+        });
+    });
+}
+
+/**
+ * Prompt for yes/no
+ */
+async function confirm(rl, question, defaultYes = true) {
+    const hint = defaultYes ? 'Y/n' : 'y/N';
+    const answer = await prompt(rl, `${question} [${hint}]`);
+    if (!answer) return defaultYes;
+    return answer.toLowerCase().startsWith('y');
+}
+
+/**
+ * Print styled message
+ */
+function print(message, type = 'info') {
+    const icons = {
+        info: `${COLORS.blue}ℹ${COLORS.reset}`,
+        success: `${COLORS.green}✓${COLORS.reset}`,
+        warn: `${COLORS.yellow}⚠${COLORS.reset}`,
+        error: `${COLORS.red}✗${COLORS.reset}`,
+        step: `${COLORS.cyan}▸${COLORS.reset}`,
+    };
+    console.log(`${icons[type] || ''} ${message}`);
+}
+
+/**
+ * Print header
+ */
+function printHeader() {
+    console.log('');
+    console.log(`${COLORS.cyan}╔══════════════════════════════════════════════════════════╗${COLORS.reset}`);
+    console.log(`${COLORS.cyan}║${COLORS.reset}     ${COLORS.bold}Proxy Claude - Setup Wizard${COLORS.reset}                         ${COLORS.cyan}║${COLORS.reset}`);
+    console.log(`${COLORS.cyan}║${COLORS.reset}     ${COLORS.dim}Configure everything in one go${COLORS.reset}                      ${COLORS.cyan}║${COLORS.reset}`);
+    console.log(`${COLORS.cyan}╚══════════════════════════════════════════════════════════╝${COLORS.reset}`);
+    console.log('');
+}
+
+/**
+ * Print step header
+ */
+function printStep(step, total, title) {
+    console.log('');
+    console.log(`${COLORS.bold}${COLORS.blue}[${step}/${total}]${COLORS.reset} ${COLORS.bold}${title}${COLORS.reset}`);
+    console.log(`${COLORS.dim}${'─'.repeat(50)}${COLORS.reset}`);
+}
+
+/**
+ * Check if a command exists
+ */
+function commandExists(cmd) {
+    try {
+        const checkCmd = PLATFORM.isWindows ? `where ${cmd}` : `which ${cmd}`;
+        execSync(checkCmd, { stdio: 'ignore' });
+        return true;
+    } catch {
+        return false;
+    }
+}
+
+/**
+ * Check Node.js version
+ */
+function checkNodeVersion() {
+    const version = process.version;
+    const major = parseInt(version.slice(1).split('.')[0], 10);
+    return { version, major, ok: major >= 18 };
+}
+
+/**
+ * Check if Claude Code CLI is installed
+ */
+function checkClaudeCli() {
+    return commandExists('claude');
+}
+
+/**
+ * Install Claude Code CLI
+ */
+async function installClaudeCli() {
+    print('Installing Claude Code CLI...', 'step');
+    try {
+        execSync('npm install -g @anthropic-ai/claude-code', { 
+            stdio: 'inherit',
+            shell: true 
+        });
+        print('Claude Code CLI installed successfully', 'success');
+        return true;
+    } catch (error) {
+        print(`Failed to install Claude Code CLI: ${error.message}`, 'error');
+        print('Please install manually: npm install -g @anthropic-ai/claude-code', 'info');
+        return false;
+    }
+}
+
+/**
+ * Check for existing accounts
+ */
+function getExistingAccounts() {
+    try {
+        if (fs.existsSync(ACCOUNTS_FILE)) {
+            const data = JSON.parse(fs.readFileSync(ACCOUNTS_FILE, 'utf-8'));
+            return data.accounts || [];
+        }
+    } catch {}
+    return [];
+}
+
+/**
+ * Fetch available models from the API using account token
+ */
+async function fetchAvailableModels(accounts) {
+    if (!accounts || accounts.length === 0) {
+        return ALL_MODELS;
+    }
+    
+    try {
+        // Get token from first account
+        const account = accounts[0];
+        const token = account.accessToken;
+        
+        if (!token) {
+            return ALL_MODELS;
+        }
+        
+        // Import the model API
+        const { fetchAvailableModels: fetchModels } = await import('../cloudcode/model-api.js');
+        const data = await fetchModels(token);
+        
+        if (data && data.models) {
+            const models = [];
+            for (const [modelId, modelData] of Object.entries(data.models)) {
+                // Only include Claude and Gemini models
+                if (!modelId.includes('claude') && !modelId.includes('gemini')) continue;
+                
+                // Determine family
+                const family = modelId.includes('claude') ? 'claude' : 'gemini';
+                
+                // Determine tier based on model name
+                let tier = 'sonnet';
+                if (modelId.includes('opus') || modelId.includes('pro-high')) tier = 'opus';
+                else if (modelId.includes('haiku') || modelId.includes('flash-lite')) tier = 'haiku';
+                
+                // Check if model has quota (remaining > 0)
+                const hasQuota = modelData.remainingFraction === undefined || modelData.remainingFraction > 0;
+                
+                models.push({
+                    id: modelId,
+                    family,
+                    tier,
+                    description: modelData.displayName || modelId,
+                    hasQuota,
+                    remainingFraction: modelData.remainingFraction,
+                });
+            }
+            
+            if (models.length > 0) {
+                return models;
+            }
+        }
+    } catch (error) {
+        print(`Could not fetch models from API: ${error.message}`, 'warn');
+    }
+    
+    return ALL_MODELS;
+}
+
+/**
+ * Add Google account via OAuth
+ */
+async function addGoogleAccount() {
+    print('Starting Google OAuth flow...', 'step');
+    print('A browser window will open for authentication.', 'info');
+    console.log('');
+    
+    return new Promise((resolve) => {
+        const accountsScript = path.join(__dirname, 'accounts.js');
+        const child = spawn('node', [accountsScript, 'add'], {
+            stdio: 'inherit',
+            shell: true,
+        });
+        
+        child.on('close', (code) => {
+            resolve(code === 0);
+        });
+    });
+}
+
+/**
+ * Load existing Claude settings
+ */
+function loadClaudeSettings() {
+    try {
+        if (fs.existsSync(CLAUDE_SETTINGS_FILE)) {
+            return JSON.parse(fs.readFileSync(CLAUDE_SETTINGS_FILE, 'utf-8'));
+        }
+    } catch {}
+    return {};
+}
+
+/**
+ * Save Claude settings
+ */
+function saveClaudeSettings(settings) {
+    // Ensure directory exists
+    if (!fs.existsSync(CLAUDE_CONFIG_DIR)) {
+        fs.mkdirSync(CLAUDE_CONFIG_DIR, { recursive: true });
+    }
+    fs.writeFileSync(CLAUDE_SETTINGS_FILE, JSON.stringify(settings, null, 2));
+}
+
+/**
+ * Select a model for a specific tier
+ */
+async function selectModelForTier(rl, tier, availableModels) {
+    const tierInfo = TIER_INFO[tier];
+    console.log('');
+    console.log(`${COLORS.bold}${tierInfo.name}${COLORS.reset} - ${COLORS.dim}${tierInfo.description}${COLORS.reset}`);
+    console.log('');
+    
+    // Filter models that are suitable for this tier or higher
+    // opus can use any model, sonnet can use sonnet/haiku, haiku uses haiku
+    const tierPriority = { opus: 3, sonnet: 2, haiku: 1 };
+    const minTier = tierPriority[tier];
+    
+    const suitableModels = availableModels.filter(m => {
+        const modelTier = tierPriority[m.tier] || 2;
+        return modelTier >= minTier - 1; // Allow one tier lower
+    });
+    
+    // Sort: models with quota first, then by family (claude first), then by tier
+    suitableModels.sort((a, b) => {
+        // Quota status
+        if (a.hasQuota !== b.hasQuota) return a.hasQuota ? -1 : 1;
+        // Family (claude first for opus/sonnet, gemini first for haiku)
+        if (tier === 'haiku') {
+            if (a.family !== b.family) return a.family === 'gemini' ? -1 : 1;
+        } else {
+            if (a.family !== b.family) return a.family === 'claude' ? -1 : 1;
+        }
+        // Tier priority
+        return (tierPriority[b.tier] || 0) - (tierPriority[a.tier] || 0);
+    });
+    
+    // Display models
+    console.log(`${COLORS.dim}Available models:${COLORS.reset}`);
+    suitableModels.forEach((model, index) => {
+        const quotaStatus = model.hasQuota === false 
+            ? `${COLORS.red}(no quota)${COLORS.reset}` 
+            : model.remainingFraction !== undefined 
+                ? `${COLORS.green}(${Math.round(model.remainingFraction * 100)}% quota)${COLORS.reset}`
+                : '';
+        const familyBadge = model.family === 'claude' 
+            ? `${COLORS.magenta}[Claude]${COLORS.reset}` 
+            : `${COLORS.blue}[Gemini]${COLORS.reset}`;
+        console.log(`  ${COLORS.cyan}${index + 1}.${COLORS.reset} ${model.id} ${familyBadge} ${quotaStatus}`);
+    });
+    console.log('');
+    
+    // Default to first model with quota
+    const defaultIndex = suitableModels.findIndex(m => m.hasQuota !== false) + 1 || 1;
+    
+    const choice = await prompt(rl, `Select model for ${tier} (1-${suitableModels.length})`, String(defaultIndex));
+    const index = parseInt(choice, 10) - 1;
+    
+    if (index >= 0 && index < suitableModels.length) {
+        return suitableModels[index].id;
+    }
+    return suitableModels[0]?.id || ALL_MODELS.find(m => m.tier === tier)?.id;
+}
+
+/**
+ * Configure Claude Code settings with selected models
+ */
+function configureClaudeSettingsWithModels(modelConfig, port = 8080) {
+    const existing = loadClaudeSettings();
+    
+    const newSettings = {
+        ...existing,
+        env: {
+            ...(existing.env || {}),
+            ANTHROPIC_AUTH_TOKEN: 'proxy-claude',
+            ANTHROPIC_BASE_URL: `http://localhost:${port}`,
+            ANTHROPIC_MODEL: modelConfig.sonnet, // Default model is sonnet
+            ANTHROPIC_DEFAULT_OPUS_MODEL: modelConfig.opus,
+            ANTHROPIC_DEFAULT_SONNET_MODEL: modelConfig.sonnet,
+            ANTHROPIC_DEFAULT_HAIKU_MODEL: modelConfig.haiku,
+            CLAUDE_CODE_SUBAGENT_MODEL: modelConfig.haiku, // Subagent uses haiku for efficiency
+            ENABLE_EXPERIMENTAL_MCP_CLI: 'true',
+        }
+    };
+    
+    // Also set hasCompletedOnboarding to skip Claude's own onboarding
+    if (!existing.hasCompletedOnboarding) {
+        newSettings.hasCompletedOnboarding = true;
+    }
+    
+    saveClaudeSettings(newSettings);
+    return newSettings;
+}
+
+/**
+ * Print summary with selected models
+ */
+function printSummary(accounts, modelConfig, port) {
+    console.log('');
+    console.log(`${COLORS.green}╔══════════════════════════════════════════════════════════╗${COLORS.reset}`);
+    console.log(`${COLORS.green}║${COLORS.reset}     ${COLORS.bold}${COLORS.green}Setup Complete!${COLORS.reset}                                   ${COLORS.green}║${COLORS.reset}`);
+    console.log(`${COLORS.green}╚══════════════════════════════════════════════════════════╝${COLORS.reset}`);
+    console.log('');
+    
+    console.log(`${COLORS.bold}Configuration Summary:${COLORS.reset}`);
+    console.log(`  ${COLORS.dim}•${COLORS.reset} Accounts: ${accounts.length} configured`);
+    console.log(`  ${COLORS.dim}•${COLORS.reset} Opus model: ${COLORS.cyan}${modelConfig.opus}${COLORS.reset}`);
+    console.log(`  ${COLORS.dim}•${COLORS.reset} Sonnet model: ${COLORS.cyan}${modelConfig.sonnet}${COLORS.reset}`);
+    console.log(`  ${COLORS.dim}•${COLORS.reset} Haiku model: ${COLORS.cyan}${modelConfig.haiku}${COLORS.reset}`);
+    console.log(`  ${COLORS.dim}•${COLORS.reset} Proxy port: ${port}`);
+    console.log(`  ${COLORS.dim}•${COLORS.reset} Settings saved to: ${CLAUDE_SETTINGS_FILE}`);
+    console.log('');
+    
+    console.log(`${COLORS.bold}To start using Claude with the proxy:${COLORS.reset}`);
+    console.log('');
+    console.log(`  ${COLORS.cyan}proxy-claude${COLORS.reset}`);
+    console.log('');
+    console.log(`${COLORS.dim}Or start components separately:${COLORS.reset}`);
+    console.log(`  ${COLORS.dim}proxy-claude start${COLORS.reset}  - Start proxy server only`);
+    console.log(`  ${COLORS.dim}proxy-claude web${COLORS.reset}    - Start with web dashboard`);
+    console.log('');
+}
+
+/**
+ * Main onboarding flow
+ */
+export async function runOnboarding(options = {}) {
+    const { skipIfConfigured = false, quiet = false } = options;
+    
+    // Check if already configured
+    const existingAccounts = getExistingAccounts();
+    const existingSettings = loadClaudeSettings();
+    const isConfigured = existingAccounts.length > 0 && existingSettings.env?.ANTHROPIC_BASE_URL;
+    
+    if (skipIfConfigured && isConfigured) {
+        if (!quiet) {
+            print('Already configured. Use --force to reconfigure.', 'info');
+        }
+        return true;
+    }
+    
+    printHeader();
+    
+    const rl = createPrompt();
+    const totalSteps = 4;
+    let currentStep = 0;
+    
+    try {
+        // Step 1: Check prerequisites
+        printStep(++currentStep, totalSteps, 'Checking Prerequisites');
+        
+        // Check Node.js
+        const nodeCheck = checkNodeVersion();
+        if (nodeCheck.ok) {
+            print(`Node.js ${nodeCheck.version} ✓`, 'success');
+        } else {
+            print(`Node.js ${nodeCheck.version} - version 18+ required`, 'error');
+            rl.close();
+            return false;
+        }
+        
+        // Check/Install Claude CLI
+        if (checkClaudeCli()) {
+            print('Claude Code CLI ✓', 'success');
+        } else {
+            print('Claude Code CLI not found', 'warn');
+            const install = await confirm(rl, 'Install Claude Code CLI now?');
+            if (install) {
+                const installed = await installClaudeCli();
+                if (!installed) {
+                    rl.close();
+                    return false;
+                }
+            } else {
+                print('Claude Code CLI is required. Please install it first.', 'error');
+                rl.close();
+                return false;
+            }
+        }
+        
+        // Step 2: Account Setup
+        printStep(++currentStep, totalSteps, 'Account Configuration');
+        
+        if (existingAccounts.length > 0) {
+            print(`Found ${existingAccounts.length} existing account(s):`, 'info');
+            existingAccounts.forEach((acc, i) => {
+                console.log(`  ${COLORS.dim}${i + 1}.${COLORS.reset} ${acc.email}`);
+            });
+            
+            const addMore = await confirm(rl, 'Add another account?', false);
+            if (addMore) {
+                await addGoogleAccount();
+            }
+        } else {
+            print('No accounts configured yet.', 'info');
+            const addAccount = await confirm(rl, 'Add a Google account now?');
+            if (addAccount) {
+                await addGoogleAccount();
+            } else {
+                print('You can add accounts later with: proxy-claude accounts add', 'info');
+            }
+        }
+        
+        // Reload accounts after potential additions
+        const accounts = getExistingAccounts();
+        
+        // Step 3: Model Configuration
+        printStep(++currentStep, totalSteps, 'Model Configuration');
+        
+        print('Fetching available models from your account...', 'step');
+        const availableModels = await fetchAvailableModels(accounts);
+        print(`Found ${availableModels.length} models available`, 'success');
+        
+        console.log('');
+        print('Now select a model for each tier. Models with quota are shown first.', 'info');
+        print(`${COLORS.dim}Tip: Use Gemini for Haiku to save your Claude quota!${COLORS.reset}`, 'info');
+        
+        // Select model for each tier
+        const modelConfig = {
+            opus: await selectModelForTier(rl, 'opus', availableModels),
+            sonnet: await selectModelForTier(rl, 'sonnet', availableModels),
+            haiku: await selectModelForTier(rl, 'haiku', availableModels),
+        };
+        
+        console.log('');
+        print('Model configuration:', 'success');
+        console.log(`  ${COLORS.dim}Opus:${COLORS.reset}   ${COLORS.cyan}${modelConfig.opus}${COLORS.reset}`);
+        console.log(`  ${COLORS.dim}Sonnet:${COLORS.reset} ${COLORS.cyan}${modelConfig.sonnet}${COLORS.reset}`);
+        console.log(`  ${COLORS.dim}Haiku:${COLORS.reset}  ${COLORS.cyan}${modelConfig.haiku}${COLORS.reset}`);
+        
+        // Step 4: Apply Configuration
+        printStep(++currentStep, totalSteps, 'Applying Configuration');
+        
+        const port = parseInt(process.env.PORT || '8080', 10);
+        
+        // Configure Claude Code settings
+        print('Configuring Claude Code settings...', 'step');
+        configureClaudeSettingsWithModels(modelConfig, port);
+        print(`Settings saved to ${CLAUDE_SETTINGS_FILE}`, 'success');
+        
+        // Print summary
+        printSummary(accounts, modelConfig, port);
+        
+        rl.close();
+        return true;
+        
+    } catch (error) {
+        print(`Setup error: ${error.message}`, 'error');
+        rl.close();
+        return false;
+    }
+}
+
+/**
+ * Check if first run (no config exists)
+ */
+export function isFirstRun() {
+    const accounts = getExistingAccounts();
+    const settings = loadClaudeSettings();
+    return accounts.length === 0 || !settings.env?.ANTHROPIC_BASE_URL;
+}
+
+// CLI entry point
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
+    const force = process.argv.includes('--force') || process.argv.includes('-f');
+    runOnboarding({ skipIfConfigured: !force }).then((success) => {
+        process.exit(success ? 0 : 1);
+    });
+}