polydev-ai 1.8.74 → 1.8.76

package/mcp/login.js

@@ -1,169 +1,396 @@
 #!/usr/bin/env node
 
 /**
- * Polydev CLI Login - Browser-based authentication for Polydev
+ * Polydev CLI - Clean, professional onboarding
+ * Works in: Claude Code, Cursor, Cline, VS Code, any terminal
  *
- * Usage: npx polydev-ai login
- *
- * This script:
- * 1. Starts a local HTTP server to receive the callback
- * 2. Opens the browser to polydev.ai/auth/cli
- * 3. After authentication, receives the token via callback
- * 4. Saves the token to your shell config (~/.zshrc or ~/.bashrc)
+ * Usage:
+ *   npx polydev-ai              # Full setup
+ *   npx polydev-ai login        # Just login
+ *   npx polydev-ai status       # Show status
+ *   npx polydev-ai models       # Open models page
  */
 
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
 const http = require('http');
-const { execFile } = require('child_process');
+const { execFile, exec } = require('child_process');
+const { promisify } = require('util');
+
+const execAsync = promisify(exec);
+
+// CLI tool definitions
+const CLI_TOOLS = [
+  { id: 'claude_code', name: 'Claude Code', command: 'claude', desc: 'Anthropic' },
+  { id: 'codex_cli', name: 'Codex CLI', command: 'codex', desc: 'OpenAI' },
+  { id: 'gemini_cli', name: 'Gemini CLI', command: 'gemini', desc: 'Google' },
+  { id: 'aider', name: 'Aider', command: 'aider', desc: 'AI Pair Programming' }
+];
 
 const command = process.argv[2];
 
+// Route commands
 if (command === 'status') {
-  showStatus();
+  showFullStatus();
+} else if (command === 'login') {
+  runLogin();
+} else if (command === 'setup') {
+  runFullSetup();
 } else if (command === 'help' || command === '--help' || command === '-h') {
   showHelp();
+} else if (command === 'models') {
+  openModelsPage();
 } else {
-  runLogin();
+  smartOnboarding();
 }
 
 function showHelp() {
   console.log(`
-Polydev AI Login
+Polydev CLI - Multi-model AI perspectives
 
 Commands:
-  login          Authenticate with Polydev (opens browser)
-  status         Show current authentication status
-  help           Show this help message
-
-Usage:
-  npx polydev-ai login     # Opens browser to authenticate
-  npx polydev-ai status    # Check if authenticated
+  npx polydev-ai           Full setup (login + detect tools)
+  npx polydev-ai login     Authenticate via browser
+  npx polydev-ai status    Show current status
+  npx polydev-ai models    Open models configuration
+  npx polydev-ai help      Show this help
 
 After login, restart your terminal or run: source ~/.zshrc
+
+Links:
+  Dashboard: https://polydev.ai/dashboard
+  Docs:      https://polydev.ai/docs
 `);
 }
 
-function showStatus() {
-  loadEnvFile(path.join(os.homedir(), '.polydev.env'));
-  loadEnvFile(path.join(os.homedir(), '.zshrc'));
-
-  const token = process.env.POLYDEV_USER_TOKEN;
-  if (token && token.startsWith('pd_')) {
-    console.log('✓ Authenticated with Polydev');
-    console.log(`  Token: ${token.slice(0, 12)}...${token.slice(-4)}`);
+async function smartOnboarding() {
+  const token = getExistingToken();
+  if (token) {
+    await showFullStatus();
   } else {
-    console.log('✗ Not authenticated');
-    console.log('  Run: npx polydev-ai login');
+    await runFullSetup();
   }
 }
 
-function loadEnvFile(filePath) {
-  try {
-    if (!fs.existsSync(filePath)) return;
-    const content = fs.readFileSync(filePath, 'utf8');
-    const match = content.match(/POLYDEV_USER_TOKEN[=\s]["']?([^"'\n]+)["']?/);
-    if (match && !process.env.POLYDEV_USER_TOKEN) {
-      process.env.POLYDEV_USER_TOKEN = match[1];
+async function runFullSetup() {
+  printHeader();
+
+  // Step 1: Authentication
+  console.log('STEP 1 of 3: Authentication');
+  console.log('─'.repeat(40));
+
+  let token = getExistingToken();
+
+  if (token) {
+    console.log('[OK] Already authenticated');
+    console.log(`    Token: ${token.slice(0, 12)}...${token.slice(-4)}\n`);
+  } else {
+    console.log('[..] Not authenticated - opening browser...\n');
+    token = await runLoginFlow();
+
+    if (!token) {
+      console.log('\n[!] Login cancelled or timed out.');
+      console.log('    Run: npx polydev-ai login\n');
+      return;
     }
-  } catch (e) {
-    // ignore
   }
+
+  // Step 2: Detect CLI tools
+  console.log('\nSTEP 2 of 3: Local AI Tools');
+  console.log('─'.repeat(40));
+
+  const cliStatus = await detectAllCLIs();
+  printCLIStatus(cliStatus);
+
+  // Step 3: Verify API
+  console.log('\nSTEP 3 of 3: API Connection');
+  console.log('─'.repeat(40));
+
+  const apiStatus = await verifyAPIConnection(token);
+  printAPIStatus(apiStatus);
+
+  // Summary
+  printSetupComplete(token, cliStatus, apiStatus);
+}
+
+function printHeader() {
+  console.log(`
+ ___  ____ _   _ ___  ____ _  _
+ |__] |  | |   |  |  | |__  |  |
+ |    |__| |__ |  |  |___|   \\/
+
+ Multi-model AI: GPT-5 | Claude | Gemini | Grok
+${'─'.repeat(50)}
+`);
 }
 
 async function runLogin() {
-  console.log('\n🔐 Polydev Authentication\n');
-
-  const server = http.createServer((req, res) => {
-    const url = new URL(req.url, `http://localhost`);
-
-    if (req.method === 'OPTIONS') {
-      res.writeHead(204, {
-        'Access-Control-Allow-Origin': '*',
-        'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',
-        'Access-Control-Allow-Headers': 'Content-Type'
-      });
-      res.end();
-      return;
-    }
+  console.log('\nPolydev Authentication\n');
+  const token = await runLoginFlow();
 
-    if (url.pathname === '/callback') {
-      const token = url.searchParams.get('token');
+  if (token) {
+    console.log('\n[OK] Authentication successful!');
+    console.log('     Restart your terminal or run: source ~/.zshrc\n');
+  }
+}
 
-      if (token && token.startsWith('pd_')) {
-        const savedTo = saveToken(token);
+function runLoginFlow() {
+  return new Promise((resolve) => {
+    const server = http.createServer((req, res) => {
+      const url = new URL(req.url, `http://localhost`);
 
-        res.writeHead(200, {
-          'Content-Type': 'text/html',
-          'Access-Control-Allow-Origin': '*'
+      if (req.method === 'OPTIONS') {
+        res.writeHead(204, {
+          'Access-Control-Allow-Origin': '*',
+          'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',
+          'Access-Control-Allow-Headers': 'Content-Type'
         });
-        res.end(`
-<!DOCTYPE html>
-<html>
-<head>
-  <title>Polydev - Success</title>
-  <style>
-    body { font-family: system-ui, -apple-system, sans-serif; display: flex; justify-content: center; align-items: center; height: 100vh; margin: 0; background: #fff; }
-    .container { text-align: center; padding: 40px; max-width: 400px; }
-    h1 { color: #000; margin-bottom: 16px; font-size: 24px; }
-    p { color: #666; margin: 8px 0; }
-    .success { color: #16a34a; font-size: 48px; margin-bottom: 16px; }
-    code { background: #f5f5f5; padding: 2px 8px; border-radius: 4px; font-size: 14px; }
-  </style>
-</head>
-<body>
-  <div class="container">
-    <div class="success">✓</div>
-    <h1>Authenticated!</h1>
-    <p>Token saved to your shell config.</p>
-    <p>Restart your terminal or run:</p>
-    <p><code>source ~/.zshrc</code></p>
-    <p style="margin-top: 24px; font-size: 14px;">You can close this window.</p>
-  </div>
-</body>
-</html>
-        `);
+        res.end();
+        return;
+      }
+
+      if (url.pathname === '/callback') {
+        const token = url.searchParams.get('token');
+
+        if (token && token.startsWith('pd_')) {
+          const savedTo = saveToken(token);
+
+          res.writeHead(200, {
+            'Content-Type': 'text/html; charset=utf-8',
+            'Access-Control-Allow-Origin': '*'
+          });
+          res.end(getSuccessHTML());
+
+          console.log(`[OK] Token saved to ${savedTo}`);
+
+          setTimeout(() => {
+            server.close();
+            resolve(token);
+          }, 500);
+        } else {
+          res.writeHead(400, { 'Content-Type': 'text/plain' });
+          res.end('Invalid or missing token');
+        }
+      } else {
+        res.writeHead(404);
+        res.end('Not found');
+      }
+    });
+
+    server.listen(0, 'localhost', () => {
+      const port = server.address().port;
+      const callbackUrl = `http://localhost:${port}/callback`;
+      const authUrl = `https://polydev.ai/auth/cli?callback=${encodeURIComponent(callbackUrl)}&redirect=claude-code`;
+
+      console.log('Opening browser for authentication...');
+      console.log(`If browser doesn\'t open, visit:\n${authUrl}\n`);
 
-        console.log('✓ Token saved successfully!');
-        console.log(`  Saved to: ${savedTo}`);
-        console.log('\n  Restart your terminal or run: source ~/.zshrc\n');
+      openBrowser(authUrl);
+
+      setTimeout(() => {
+        server.close();
+        resolve(null);
+      }, 5 * 60 * 1000);
+    });
+
+    server.on('error', (err) => {
+      console.error('[!] Server error:', err.message);
+      resolve(null);
+    });
+  });
+}
 
-        setTimeout(() => {
-          server.close();
-          process.exit(0);
-        }, 500);
+async function detectAllCLIs() {
+  const results = {};
+
+  for (const tool of CLI_TOOLS) {
+    try {
+      const { stdout } = await execAsync(`which ${tool.command} 2>/dev/null`);
+      const cliPath = stdout.trim();
+
+      if (cliPath) {
+        let version = 'installed';
+        try {
+          const { stdout: versionOut } = await execAsync(`${tool.command} --version 2>/dev/null || ${tool.command} -v 2>/dev/null`);
+          version = versionOut.trim().split('\n')[0].substring(0, 30);
+        } catch (e) {}
+
+        let authenticated = false;
+        try {
+          if (tool.id === 'claude_code') {
+            const { stdout: authOut } = await execAsync(`${tool.command} auth status 2>/dev/null || echo "not"`);
+            authenticated = !authOut.toLowerCase().includes('not');
+          } else if (tool.id === 'codex_cli') {
+            authenticated = !!process.env.OPENAI_API_KEY;
+          } else if (tool.id === 'gemini_cli') {
+            authenticated = !!process.env.GOOGLE_API_KEY;
+          }
+        } catch (e) {}
+
+        results[tool.id] = { available: true, authenticated, version, path: cliPath, tool };
+        console.log(`[OK] ${tool.name.padEnd(12)} ${version}`);
       } else {
-        res.writeHead(400, { 'Content-Type': 'text/plain' });
-        res.end('Invalid or missing token');
+        throw new Error('Not found');
       }
+    } catch (e) {
+      results[tool.id] = { available: false, authenticated: false, tool };
+      console.log(`[--] ${tool.name.padEnd(12)} not installed`);
+    }
+  }
+
+  return results;
+}
+
+function printCLIStatus(cliStatus) {
+  const available = Object.values(cliStatus).filter(s => s.available);
+  const authenticated = available.filter(s => s.authenticated);
+
+  if (available.length === 0) {
+    console.log('\n    No local CLI tools detected.');
+    console.log('    Install Claude Code or Codex CLI to use local tools (free).');
+  } else {
+    console.log(`\n    ${available.length} tool(s) found, ${authenticated.length} authenticated`);
+    console.log('    Local tools = FREE (no API credits used)');
+  }
+}
+
+async function verifyAPIConnection(token) {
+  try {
+    const response = await fetch('https://www.polydev.ai/api/mcp', {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${token}`,
+        'User-Agent': 'polydev-cli/1.0.0'
+      },
+      body: JSON.stringify({ action: 'check_status' })
+    });
+
+    if (response.ok) {
+      const data = await response.json();
+      return {
+        connected: true,
+        email: data.email,
+        credits: data.credits_remaining,
+        tier: data.subscription_tier || 'Free',
+        models: data.enabled_models || ['GPT-5', 'Gemini', 'Grok', 'GLM']
+      };
     } else {
-      res.writeHead(404);
-      res.end('Not found');
+      return { connected: false, error: 'Invalid token' };
     }
-  });
+  } catch (error) {
+    return { connected: false, error: error.message };
+  }
+}
 
-  server.listen(0, 'localhost', () => {
-    const port = server.address().port;
-    const callbackUrl = `http://localhost:${port}/callback`;
-    const authUrl = `https://polydev.ai/auth/cli?callback=${encodeURIComponent(callbackUrl)}&redirect=claude-code`;
+function printAPIStatus(apiStatus) {
+  if (apiStatus.connected) {
+    console.log(`[OK] Connected to Polydev API`);
+    console.log(`    Account: ${apiStatus.email || 'Connected'}`);
+    console.log(`    Credits: ${apiStatus.credits?.toLocaleString() || 0} | Tier: ${apiStatus.tier}`);
+  } else {
+    console.log(`[!] Could not verify API connection`);
+    console.log(`    Error: ${apiStatus.error}`);
+  }
+}
 
-    console.log('Opening browser for authentication...');
-    console.log(`\nIf browser doesn't open, visit:\n${authUrl}\n`);
+function printSetupComplete(token, cliStatus, apiStatus) {
+  const availableCLIs = Object.values(cliStatus).filter(s => s.available);
 
-    openBrowser(authUrl);
+  console.log(`
+${'═'.repeat(50)}
+SETUP COMPLETE
+${'═'.repeat(50)}
 
-    setTimeout(() => {
-      console.log('\n✗ Login timed out. Please try again.\n');
-      server.close();
-      process.exit(1);
-    }, 5 * 60 * 1000);
-  });
+What's ready:`);
 
-  server.on('error', (err) => {
-    console.error('Server error:', err.message);
-    process.exit(1);
-  });
+  if (availableCLIs.length > 0) {
+    console.log('\n  Local Tools (FREE):');
+    for (const cli of availableCLIs) {
+      const status = cli.authenticated ? 'ready' : 'needs auth';
+      console.log(`    - ${cli.tool.name} [${status}]`);
+    }
+  }
+
+  if (apiStatus.connected) {
+    console.log(`\n  Polydev API (${apiStatus.credits?.toLocaleString() || 0} credits):`);
+    console.log('    - GPT-5, Claude, Gemini, Grok in parallel');
+  }
+
+  console.log(`
+Next steps:
+
+  1. Restart terminal or run: source ~/.zshrc
+  2. Start your IDE (Claude Code, Cursor, Cline, etc.)
+  3. Use "get_perspectives" tool or /polydev command
+
+Links:
+  Dashboard: https://polydev.ai/dashboard
+  Models:    https://polydev.ai/dashboard/models
+`);
+}
+
+async function showFullStatus() {
+  console.log('\nPolydev Status');
+  console.log('─'.repeat(40));
+
+  const token = getExistingToken();
+
+  console.log('\nAuthentication:');
+  if (token) {
+    const apiStatus = await verifyAPIConnection(token);
+    if (apiStatus.connected) {
+      console.log(`  [OK] ${apiStatus.email || 'Authenticated'}`);
+      console.log(`       Credits: ${apiStatus.credits?.toLocaleString() || 0} | Tier: ${apiStatus.tier}`);
+    } else {
+      console.log('  [!] Token found but invalid');
+      console.log('      Run: npx polydev-ai login');
+    }
+  } else {
+    console.log('  [--] Not authenticated');
+    console.log('       Run: npx polydev-ai login');
+  }
+
+  console.log('\nLocal AI Tools (free):');
+  await detectAllCLIs();
+
+  if (token) {
+    console.log('\nAPI Models (uses credits):');
+    console.log('  GPT-5, Gemini, Grok, GLM - query in parallel');
+    console.log('  Configure: https://polydev.ai/dashboard/models');
+  }
+
+  console.log('');
+}
+
+function openModelsPage() {
+  const url = 'https://polydev.ai/dashboard/models';
+  console.log(`\nOpening: ${url}\n`);
+  openBrowser(url);
+}
+
+// Utility functions
+function getExistingToken() {
+  if (process.env.POLYDEV_USER_TOKEN) {
+    return process.env.POLYDEV_USER_TOKEN;
+  }
+
+  const locations = [
+    path.join(os.homedir(), '.polydev.env'),
+    path.join(os.homedir(), '.zshrc'),
+    path.join(os.homedir(), '.bashrc')
+  ];
+
+  for (const loc of locations) {
+    if (fs.existsSync(loc)) {
+      const content = fs.readFileSync(loc, 'utf8');
+      const match = content.match(/POLYDEV_USER_TOKEN[=\s]["']?([^"'\n]+)["']?/);
+      if (match) return match[1];
+    }
+  }
+
+  return null;
 }
 
 function saveToken(token) {
@@ -173,9 +400,7 @@ function saveToken(token) {
                  path.join(os.homedir(), '.profile');
 
   let content = '';
-  try {
-    content = fs.readFileSync(rcFile, 'utf8');
-  } catch (e) {}
+  try { content = fs.readFileSync(rcFile, 'utf8'); } catch (e) {}
 
   const lines = content.split('\n').filter(line =>
     !line.trim().startsWith('export POLYDEV_USER_TOKEN') &&
@@ -192,7 +417,6 @@ function saveToken(token) {
 }
 
 function openBrowser(url) {
-  // Use execFile with explicit command and arguments for safety
   const platform = process.platform;
   let cmd, args;
 
@@ -209,8 +433,61 @@ function openBrowser(url) {
 
   execFile(cmd, args, (err) => {
     if (err) {
-      console.log('Could not open browser automatically.');
-      console.log(`Please open this URL manually: ${url}`);
+      console.log('[!] Could not open browser automatically.');
+      console.log(`    Please open: ${url}`);
     }
   });
 }
+
+function getSuccessHTML() {
+  return `<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8">
+  <title>Polydev - Success</title>
+  <style>
+    * { box-sizing: border-box; margin: 0; padding: 0; }
+    body {
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+      display: flex; justify-content: center; align-items: center;
+      height: 100vh; background: #f5f5f5;
+    }
+    .container {
+      text-align: center; padding: 48px; max-width: 400px;
+      background: white; border-radius: 8px;
+      box-shadow: 0 2px 8px rgba(0,0,0,0.1);
+    }
+    .logo { font-size: 24px; font-weight: 700; color: #111; margin-bottom: 24px; letter-spacing: -0.5px; }
+    .check {
+      width: 48px; height: 48px; border: 3px solid #111; border-radius: 50%;
+      display: flex; align-items: center; justify-content: center;
+      margin: 0 auto 24px; font-size: 24px;
+    }
+    h1 { color: #111; font-size: 20px; font-weight: 600; margin-bottom: 12px; }
+    p { color: #666; font-size: 14px; line-height: 1.6; margin-bottom: 8px; }
+    .steps {
+      background: #f9f9f9; border-radius: 6px; padding: 16px;
+      margin: 20px 0; text-align: left;
+    }
+    .step { color: #444; font-size: 13px; margin-bottom: 8px; }
+    .step:last-child { margin-bottom: 0; }
+    code { background: #eee; padding: 2px 6px; border-radius: 3px; font-size: 12px; }
+    .close { color: #999; font-size: 12px; margin-top: 20px; }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <div class="logo">Polydev</div>
+    <div class="check">✓</div>
+    <h1>Authentication Complete</h1>
+    <p>Your token has been saved automatically.</p>
+    <div class="steps">
+      <div class="step">1. Restart terminal or run <code>source ~/.zshrc</code></div>
+      <div class="step">2. Start your IDE (Claude Code, Cursor, etc.)</div>
+      <div class="step">3. Use the <code>get_perspectives</code> tool</div>
+    </div>
+    <p class="close">You can close this window.</p>
+  </div>
+</body>
+</html>`;
+}

package/mcp/manifest.json

@@ -1,6 +1,6 @@
 {
   "name": "polydev-perspectives",
-  "version": "1.4.0",
+  "version": "1.8.76",
   "description": "Multi-model AI perspectives - query GPT 5.2, Claude Opus 4.5, Gemini 3, and Grok 4.1 simultaneously. Get diverse perspectives when stuck or need enhanced reasoning. Achieved 74.6% on SWE-bench Verified.",
   "author": "Polydev AI",
   "license": "MIT",

package/mcp/stdio-wrapper.js

@@ -248,20 +248,7 @@ function cleanCliResponse(content) {
 class StdioMCPWrapper {
   constructor() {
     this.userToken = process.env.POLYDEV_USER_TOKEN;
-    if (!this.userToken) {
-      console.error('\n╔════════════════════════════════════════════════════════════════╗');
-      console.error('║  POLYDEV_USER_TOKEN is not set                                 ║');
-      console.error('╠════════════════════════════════════════════════════════════════╣');
-      console.error('║  Get your free token at:                                       ║');
-      console.error('║  👉 https://polydev.ai/dashboard/mcp-tokens                    ║');
-      console.error('║                                                                ║');
-      console.error('║  Then add to ~/.zshrc or ~/.bashrc:                            ║');
-      console.error('║  export POLYDEV_USER_TOKEN="pd_your_token_here"                ║');
-      console.error('║                                                                ║');
-      console.error('║  Restart your terminal and Claude Code after adding the token ║');
-      console.error('╚════════════════════════════════════════════════════════════════╝\n');
-      process.exit(1);
-    }
+    this.isAuthenticated = !!this.userToken;
     
     // Server URL for API calls
     this.serverUrl = 'https://www.polydev.ai/api/mcp';
@@ -272,6 +259,14 @@ class StdioMCPWrapper {
     // Load manifest for tool definitions
     this.loadManifest();
     
+    // Log startup status
+    if (this.userToken) {
+      console.error('[Polydev] Starting with authentication token');
+    } else {
+      console.error('[Polydev] Starting without token - login required');
+      console.error('[Polydev] Use the "login" tool or run: npx polydev-ai');
+    }
+    
     // Smart refresh scheduler (will be started after initialization)
     this.refreshScheduler = null;
     
@@ -287,6 +282,9 @@ class StdioMCPWrapper {
     this.perspectivesPerMessage = 2; // Default to 2 perspectives
     this.modelPreferencesCacheTime = null;
     this.MODEL_PREFERENCES_CACHE_TTL = 5 * 60 * 1000; // 5 minutes cache
+    
+    // Login server reference (for cleanup)
+    this._loginServer = null;
   }
 
   loadManifest() {
@@ -332,9 +330,36 @@ class StdioMCPWrapper {
           };
         
         case 'tools/call':
-          // Handle get_perspectives with local CLIs + remote perspectives
           const toolName = params.name;
           
+          // These tools work without authentication
+          const noAuthTools = ['login', 'get_auth_status', 'polydev.login', 'polydev.get_auth_status'];
+          
+          if (noAuthTools.includes(toolName)) {
+            if (toolName === 'login' || toolName === 'polydev.login') {
+              return await this.handleLoginTool(params, id);
+            }
+            if (toolName === 'get_auth_status' || toolName === 'polydev.get_auth_status') {
+              return await this.handleGetAuthStatus(params, id);
+            }
+          }
+          
+          // All other tools require authentication
+          if (!this.isAuthenticated) {
+            return {
+              jsonrpc: '2.0',
+              id,
+              result: {
+                content: [{
+                  type: 'text',
+                  text: `Authentication required.\n\nTo login, either:\n1. Use the "login" tool (opens browser)\n2. Run in terminal: npx polydev-ai\n\nAfter login, restart your IDE.`
+                }],
+                isError: true
+              }
+            };
+          }
+          
+          // Handle get_perspectives with local CLIs + remote perspectives
           if (toolName === 'get_perspectives' || toolName === 'polydev.get_perspectives') {
             return await this.handleGetPerspectivesWithCLIs(params, id);
           }
@@ -370,6 +395,277 @@ class StdioMCPWrapper {
     }
   }
 
+  /**
+   * Handle login tool - opens browser for authentication
+   */
+  async handleLoginTool(params, id) {
+    const http = require('http');
+    const { execFile } = require('child_process');
+    
+    return new Promise((resolve) => {
+      // Check if already authenticated
+      if (this.isAuthenticated && this.userToken) {
+        resolve({
+          jsonrpc: '2.0',
+          id,
+          result: {
+            content: [{
+              type: 'text',
+              text: `Already authenticated.\n\nYour token is configured. Use get_perspectives to query multiple AI models.\n\nTo re-login, run in terminal: npx polydev-ai login`
+            }]
+          }
+        });
+        return;
+      }
+      
+      const server = http.createServer((req, res) => {
+        const url = new URL(req.url, `http://localhost`);
+
+        if (req.method === 'OPTIONS') {
+          res.writeHead(204, {
+            'Access-Control-Allow-Origin': '*',
+            'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',
+            'Access-Control-Allow-Headers': 'Content-Type'
+          });
+          res.end();
+          return;
+        }
+
+        if (url.pathname === '/callback') {
+          const token = url.searchParams.get('token');
+
+          if (token && token.startsWith('pd_')) {
+            // Save token
+            this.saveTokenToFiles(token);
+            this.userToken = token;
+            this.isAuthenticated = true;
+
+            res.writeHead(200, {
+              'Content-Type': 'text/html; charset=utf-8',
+              'Access-Control-Allow-Origin': '*'
+            });
+            res.end(this.getLoginSuccessHTML());
+
+            console.error('[Polydev] Login successful, token saved');
+
+            setTimeout(() => {
+              server.close();
+              resolve({
+                jsonrpc: '2.0',
+                id,
+                result: {
+                  content: [{
+                    type: 'text',
+                    text: `Login successful!\n\nYour token has been saved to ~/.zshrc and ~/.polydev.env\n\nIMPORTANT: Restart your IDE to use the new token.\n\nAfter restart, use get_perspectives to query GPT-5, Claude, Gemini, and Grok in parallel.`
+                  }]
+                }
+              });
+            }, 500);
+          } else {
+            res.writeHead(400, { 'Content-Type': 'text/plain' });
+            res.end('Invalid or missing token');
+          }
+        } else {
+          res.writeHead(404);
+          res.end('Not found');
+        }
+      });
+
+      server.listen(0, 'localhost', () => {
+        const port = server.address().port;
+        const callbackUrl = `http://localhost:${port}/callback`;
+        const authUrl = `https://polydev.ai/auth/cli?callback=${encodeURIComponent(callbackUrl)}&redirect=ide-plugin`;
+
+        console.error(`[Polydev] Opening browser for authentication: ${authUrl}`);
+        
+        // Open browser
+        const platform = process.platform;
+        let cmd, args;
+        if (platform === 'darwin') {
+          cmd = 'open';
+          args = [authUrl];
+        } else if (platform === 'win32') {
+          cmd = 'cmd';
+          args = ['/c', 'start', '', authUrl];
+        } else {
+          cmd = 'xdg-open';
+          args = [authUrl];
+        }
+
+        execFile(cmd, args, (err) => {
+          if (err) {
+            console.error('[Polydev] Could not open browser:', err.message);
+          }
+        });
+
+        // Timeout after 5 minutes
+        setTimeout(() => {
+          server.close();
+          resolve({
+            jsonrpc: '2.0',
+            id,
+            result: {
+              content: [{
+                type: 'text',
+                text: `Login timed out.\n\nPlease try again or run in terminal: npx polydev-ai`
+              }],
+              isError: true
+            }
+          });
+        }, 5 * 60 * 1000);
+      });
+
+      server.on('error', (err) => {
+        console.error('[Polydev] Login server error:', err.message);
+        resolve({
+          jsonrpc: '2.0',
+          id,
+          result: {
+            content: [{
+              type: 'text',
+              text: `Login failed: ${err.message}\n\nPlease run in terminal: npx polydev-ai`
+            }],
+            isError: true
+          }
+        });
+      });
+    });
+  }
+
+  /**
+   * Handle get_auth_status tool
+   */
+  async handleGetAuthStatus(params, id) {
+    if (!this.isAuthenticated || !this.userToken) {
+      return {
+        jsonrpc: '2.0',
+        id,
+        result: {
+          content: [{
+            type: 'text',
+            text: `Not authenticated.\n\nTo login:\n1. Use the "login" tool (opens browser)\n2. Or run in terminal: npx polydev-ai\n\nAfter login, restart your IDE.`
+          }]
+        }
+      };
+    }
+
+    try {
+      const response = await fetch('https://www.polydev.ai/api/mcp', {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${this.userToken}`,
+          'User-Agent': 'polydev-stdio-wrapper/1.0.0'
+        },
+        body: JSON.stringify({ action: 'check_status' })
+      });
+
+      if (response.ok) {
+        const data = await response.json();
+        const credits = data.credits_remaining?.toLocaleString() || 0;
+        const tier = data.subscription_tier || 'Free';
+        
+        return {
+          jsonrpc: '2.0',
+          id,
+          result: {
+            content: [{
+              type: 'text',
+              text: `Polydev Status\n${'─'.repeat(40)}\n\nAuthenticated: Yes\nAccount: ${data.email || 'Connected'}\nCredits: ${credits}\nTier: ${tier}\n\nAvailable tools:\n- get_perspectives (query multiple AI models)\n- get_cli_status (check local CLI tools)\n- send_cli_prompt (use local CLIs)\n\nDashboard: https://polydev.ai/dashboard`
+            }]
+          }
+        };
+      } else {
+        return {
+          jsonrpc: '2.0',
+          id,
+          result: {
+            content: [{
+              type: 'text',
+              text: `Token invalid or expired.\n\nPlease re-login:\n1. Use the "login" tool\n2. Or run: npx polydev-ai login`
+            }],
+            isError: true
+          }
+        };
+      }
+    } catch (error) {
+      return {
+        jsonrpc: '2.0',
+        id,
+        result: {
+          content: [{
+            type: 'text',
+            text: `Could not verify status (offline?)\n\nError: ${error.message}`
+          }],
+          isError: true
+        }
+      };
+    }
+  }
+
+  /**
+   * Save token to shell config files
+   */
+  saveTokenToFiles(token) {
+    const shell = process.env.SHELL || '/bin/zsh';
+    const rcFile = shell.includes('zsh') ? path.join(os.homedir(), '.zshrc') :
+                   shell.includes('bash') ? path.join(os.homedir(), '.bashrc') :
+                   path.join(os.homedir(), '.profile');
+
+    let content = '';
+    try { content = fs.readFileSync(rcFile, 'utf8'); } catch (e) {}
+
+    const lines = content.split('\n').filter(line =>
+      !line.trim().startsWith('export POLYDEV_USER_TOKEN') &&
+      !line.trim().startsWith('POLYDEV_USER_TOKEN')
+    );
+
+    lines.push(`export POLYDEV_USER_TOKEN="${token}"`);
+    fs.writeFileSync(rcFile, lines.join('\n').replace(/\n+$/, '') + '\n');
+
+    // Also save to .polydev.env
+    const envFile = path.join(os.homedir(), '.polydev.env');
+    fs.writeFileSync(envFile, `POLYDEV_USER_TOKEN="${token}"\n`);
+
+    console.error(`[Polydev] Token saved to ${rcFile} and ${envFile}`);
+  }
+
+  /**
+   * Get login success HTML page
+   */
+  getLoginSuccessHTML() {
+    return `<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8">
+  <title>Polydev - Success</title>
+  <style>
+    * { box-sizing: border-box; margin: 0; padding: 0; }
+    body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif; display: flex; justify-content: center; align-items: center; height: 100vh; background: #f5f5f5; }
+    .container { text-align: center; padding: 48px; max-width: 400px; background: white; border-radius: 8px; box-shadow: 0 2px 8px rgba(0,0,0,0.1); }
+    .logo { font-size: 24px; font-weight: 700; color: #111; margin-bottom: 24px; }
+    .check { width: 48px; height: 48px; border: 3px solid #111; border-radius: 50%; display: flex; align-items: center; justify-content: center; margin: 0 auto 24px; font-size: 24px; }
+    h1 { color: #111; font-size: 20px; font-weight: 600; margin-bottom: 12px; }
+    p { color: #666; font-size: 14px; line-height: 1.6; }
+    .important { background: #f0f0f0; padding: 16px; border-radius: 6px; margin: 20px 0; }
+    .important strong { color: #111; }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <div class="logo">Polydev</div>
+    <div class="check">✓</div>
+    <h1>Login Successful</h1>
+    <p>Your token has been saved.</p>
+    <div class="important">
+      <strong>Important:</strong> Restart your IDE to use the new token.
+    </div>
+    <p>You can close this window.</p>
+  </div>
+</body>
+</html>`;
+  }
+
   async forwardToRemoteServer(request) {
     console.error(`[Stdio Wrapper] Forwarding request to remote server`);
 
@@ -1634,7 +1930,7 @@ class StdioMCPWrapper {
   }
 
   async start() {
-    console.error('Starting Polydev Stdio MCP Wrapper...');
+    console.error('Starting Polydev MCP Server...');
 
     process.stdin.setEncoding('utf8');
     let buffer = '';
@@ -1651,7 +1947,7 @@ class StdioMCPWrapper {
             const request = JSON.parse(line);
             // Notifications have no id - don't respond to them (JSON-RPC spec)
             if (request.id === undefined) {
-              console.error(`[Stdio Wrapper] Received notification: ${request.method}`);
+              console.error(`[Polydev] Received notification: ${request.method}`);
               continue;
             }
             const response = await this.handleRequest(request);
@@ -1664,7 +1960,7 @@ class StdioMCPWrapper {
     });
 
     process.stdin.on('end', () => {
-      console.error('Stdio MCP Wrapper shutting down...');
+      console.error('Polydev MCP Server shutting down...');
       this.stopSmartRefreshScheduler();
       process.exit(0);
     });
@@ -1682,30 +1978,243 @@ class StdioMCPWrapper {
       process.exit(0);
     });
 
-    console.error('Stdio MCP Wrapper ready and listening on stdin...');
+    console.error('Polydev MCP Server ready.\n');
+
+    // Run the onboarding/status check
+    await this.runStartupFlow();
 
-    // Run initial CLI detection in the background so MCP handshake isn't blocked.
-    // The promise was already created in constructor so requests will wait for it
-    console.error('[Stdio Wrapper] Running initial CLI detection...');
+    // Run CLI detection in background
+    console.error('[Polydev] Detecting local CLI tools...');
     
     this.localForceCliDetection({})
-      .then(() => {
-        console.error('[Stdio Wrapper] Initial CLI detection completed');
+      .then(async () => {
         this._cliDetectionComplete = true;
+        // Display CLI status after detection
+        await this.displayCliStatus();
       })
       .catch((error) => {
-        console.error('[Stdio Wrapper] Initial CLI detection failed:', error);
-        this._cliDetectionComplete = true; // Mark complete even on failure
+        console.error('[Polydev] CLI detection failed:', error.message);
+        this._cliDetectionComplete = true;
       })
       .finally(() => {
-        // Resolve the readiness promise so waiting requests can proceed
         if (this._cliDetectionResolver) {
           this._cliDetectionResolver();
         }
-        // Start smart refresh scheduler after initial detection attempt
         this.startSmartRefreshScheduler();
       });
   }
+
+  /**
+   * Run startup flow - auto-login if no token, verify if has token
+   */
+  async runStartupFlow() {
+    if (!this.userToken) {
+      // No token - auto-open browser for login
+      console.error('─'.repeat(50));
+      console.error('Polydev - First Time Setup');
+      console.error('─'.repeat(50));
+      console.error('Opening browser for authentication...\n');
+      
+      await this.autoLoginOnStartup();
+    } else {
+      // Has token - verify it
+      await this.verifyAndDisplayAuth();
+    }
+  }
+
+  /**
+   * Auto-login on startup (opens browser automatically)
+   */
+  async autoLoginOnStartup() {
+    const http = require('http');
+    const { execFile } = require('child_process');
+
+    return new Promise((resolve) => {
+      const server = http.createServer((req, res) => {
+        const url = new URL(req.url, `http://localhost`);
+
+        if (req.method === 'OPTIONS') {
+          res.writeHead(204, {
+            'Access-Control-Allow-Origin': '*',
+            'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',
+            'Access-Control-Allow-Headers': 'Content-Type'
+          });
+          res.end();
+          return;
+        }
+
+        if (url.pathname === '/callback') {
+          const token = url.searchParams.get('token');
+
+          if (token && token.startsWith('pd_')) {
+            this.saveTokenToFiles(token);
+            this.userToken = token;
+            this.isAuthenticated = true;
+
+            res.writeHead(200, {
+              'Content-Type': 'text/html; charset=utf-8',
+              'Access-Control-Allow-Origin': '*'
+            });
+            res.end(this.getLoginSuccessHTML());
+
+            console.error('[OK] Authentication successful!');
+            console.error('     Token saved to ~/.zshrc and ~/.polydev.env');
+            console.error('');
+            console.error('     IMPORTANT: Restart your IDE to use the new token.');
+            console.error('─'.repeat(50) + '\n');
+
+            setTimeout(() => {
+              server.close();
+              resolve(true);
+            }, 500);
+          } else {
+            res.writeHead(400, { 'Content-Type': 'text/plain' });
+            res.end('Invalid or missing token');
+          }
+        } else {
+          res.writeHead(404);
+          res.end('Not found');
+        }
+      });
+
+      server.listen(0, 'localhost', () => {
+        const port = server.address().port;
+        const callbackUrl = `http://localhost:${port}/callback`;
+        const authUrl = `https://polydev.ai/auth/cli?callback=${encodeURIComponent(callbackUrl)}&redirect=ide-plugin&auto=true`;
+
+        console.error('If browser does not open, visit:');
+        console.error(authUrl);
+        console.error('');
+
+        // Open browser
+        const platform = process.platform;
+        let cmd, args;
+        if (platform === 'darwin') {
+          cmd = 'open';
+          args = [authUrl];
+        } else if (platform === 'win32') {
+          cmd = 'cmd';
+          args = ['/c', 'start', '', authUrl];
+        } else {
+          cmd = 'xdg-open';
+          args = [authUrl];
+        }
+
+        execFile(cmd, args, (err) => {
+          if (err) {
+            console.error('[!] Could not open browser automatically.');
+          }
+        });
+
+        // Don't block forever - resolve after timeout
+        setTimeout(() => {
+          if (!this.isAuthenticated) {
+            console.error('[!] Login timeout - use "login" tool to try again');
+            console.error('─'.repeat(50) + '\n');
+          }
+          server.close();
+          resolve(false);
+        }, 2 * 60 * 1000); // 2 minute timeout for startup
+      });
+
+      server.on('error', (err) => {
+        console.error('[!] Could not start login server:', err.message);
+        console.error('    Use "login" tool or run: npx polydev-ai');
+        console.error('─'.repeat(50) + '\n');
+        resolve(false);
+      });
+    });
+  }
+
+  /**
+   * Verify token and display auth status
+   */
+  async verifyAndDisplayAuth() {
+    try {
+      const response = await fetch('https://www.polydev.ai/api/mcp', {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${this.userToken}`,
+          'User-Agent': 'polydev-mcp/1.0.0'
+        },
+        body: JSON.stringify({ action: 'check_status' })
+      });
+
+      if (response.ok) {
+        const data = await response.json();
+        this.isAuthenticated = true;
+        const credits = data.credits_remaining?.toLocaleString() || 0;
+        const tier = data.subscription_tier || 'Free';
+        
+        console.error('─'.repeat(50));
+        console.error('Polydev - Authenticated');
+        console.error('─'.repeat(50));
+        console.error(`Account: ${data.email || 'Connected'}`);
+        console.error(`Credits: ${credits} | Tier: ${tier}`);
+        console.error('─'.repeat(50) + '\n');
+      } else {
+        this.isAuthenticated = false;
+        console.error('─'.repeat(50));
+        console.error('Polydev - Token Invalid');
+        console.error('─'.repeat(50));
+        console.error('Your token may have expired.');
+        console.error('Use the "login" tool or run: npx polydev-ai login');
+        console.error('─'.repeat(50) + '\n');
+      }
+    } catch (error) {
+      console.error('[Polydev] Could not verify auth (offline?)');
+    }
+  }
+
+  /**
+   * Display CLI tools status after detection
+   */
+  async displayCliStatus() {
+    try {
+      const status = await this.loadLocalCliStatus();
+      if (!status || Object.keys(status).length === 0) {
+        console.error('[Polydev] No local CLI tools detected.\n');
+        return;
+      }
+
+      const tools = Object.entries(status);
+      const available = tools.filter(([_, s]) => s.available);
+      const authenticated = available.filter(([_, s]) => s.authenticated);
+
+      console.error('─'.repeat(50));
+      console.error('Local AI Tools (FREE - no API credits)');
+      console.error('─'.repeat(50));
+
+      for (const [id, s] of tools) {
+        const name = id.replace('_', ' ').replace(/\b\w/g, l => l.toUpperCase());
+        if (s.available) {
+          const authStatus = s.authenticated ? '[ready]' : '[needs auth]';
+          console.error(`[OK] ${name.padEnd(15)} ${authStatus}`);
+        } else {
+          console.error(`[--] ${name.padEnd(15)} not installed`);
+        }
+      }
+
+      if (available.length > 0) {
+        console.error('');
+        console.error(`${available.length} tool(s) installed, ${authenticated.length} ready to use`);
+        console.error('Local tools save API credits!');
+      }
+      
+      console.error('─'.repeat(50) + '\n');
+    } catch (error) {
+      // Ignore errors in status display
+    }
+  }
+
+  /**
+   * Check and display authentication status on startup
+   * @deprecated Use verifyAndDisplayAuth instead
+   */
+  async checkAndDisplayAuthStatus() {
+    await this.verifyAndDisplayAuth();
+  }
 }
 
 if (require.main === module) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "polydev-ai",
-  "version": "1.8.74",
+  "version": "1.8.76",
   "engines": {
     "node": ">=20.x <=22.x"
   },