polydev-ai 1.8.63 → 1.8.71

package/README.md

@@ -24,6 +24,26 @@ Get insights from GPT 5.2, Claude Opus 4.5, Gemini 3, and Grok 4.1 — all throu
 
 ---
 
+## 🔑 Key Advantage: Use Your Existing Subscriptions
+
+**Already paying for ChatGPT Plus, Claude Pro, or Gemini Advanced?** Use those subscriptions directly through your CLI tools — no API keys needed.
+
+| Subscription | CLI Tool | How to Use |
+|--------------|----------|------------|
+| Claude Pro ($20/mo) | Claude Code | `claude login` with your Anthropic account |
+| ChatGPT Plus ($20/mo) | Codex CLI | `codex login` with your OpenAI account |
+| Gemini Advanced ($20/mo) | Gemini CLI | `gemini login` with your Google account |
+
+**How it works:**
+1. Login to your CLI tool with your subscription account (no API keys!)
+2. Add Polydev as an MCP server to your CLI
+3. Polydev queries models through your authenticated CLI sessions
+4. Your subscription quota is used — no extra costs
+
+**No API keys. No double-paying.** Your existing subscriptions just work.
+
+---
+
 ## Quick Start
 
 ### 1. Get your free API token

package/mcp/manifest.json

@@ -1,6 +1,6 @@
 {
   "name": "polydev-perspectives",
-  "version": "1.3.0",
+  "version": "1.4.0",
   "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",
@@ -12,6 +12,138 @@
     "prompts": false
   },
   "tools": [
+    {
+      "name": "get_auth_status",
+      "description": "Check Polydev authentication status and get setup instructions. Use this first to verify your token is valid or get help setting up Polydev. Works in all IDEs (Claude Desktop, Cursor, Continue, Windsurf, VSCode, etc.).",
+      "inputSchema": {
+        "type": "object",
+        "properties": {
+          "user_token": {
+            "type": "string",
+            "description": "Polydev user authentication token (optional - checks if provided, shows setup instructions if not)"
+          }
+        }
+      },
+      "outputSchema": {
+        "type": "object",
+        "properties": {
+          "authenticated": {
+            "type": "boolean",
+            "description": "Whether the user is authenticated"
+          },
+          "user_email": {
+            "type": "string",
+            "description": "User email if authenticated"
+          },
+          "credits_remaining": {
+            "type": "integer",
+            "description": "Credits remaining if authenticated"
+          },
+          "subscription_tier": {
+            "type": "string",
+            "description": "Current subscription tier"
+          },
+          "setup_instructions": {
+            "type": "object",
+            "description": "Setup instructions if not authenticated"
+          },
+          "message": {
+            "type": "string",
+            "description": "Human-readable status message"
+          }
+        }
+      },
+      "examples": [
+        {
+          "description": "Check auth status without token",
+          "input": {},
+          "output": {
+            "authenticated": false,
+            "setup_instructions": {
+              "step_1": "Visit https://polydev.ai to create your free account",
+              "step_2": "Go to https://polydev.ai/dashboard/mcp-tools",
+              "step_3": "Generate your MCP access token",
+              "step_4": "Add the token to your IDE configuration"
+            },
+            "message": "Welcome to Polydev! Get started in 2 minutes."
+          }
+        },
+        {
+          "description": "Check auth status with valid token",
+          "input": { "user_token": "polydev_abc123..." },
+          "output": {
+            "authenticated": true,
+            "user_email": "user@example.com",
+            "credits_remaining": 9500,
+            "subscription_tier": "Premium",
+            "message": "Ready to use Polydev! You have 9,500 credits remaining."
+          }
+        }
+      ]
+    },
+    {
+      "name": "login",
+      "description": "Authenticate with Polydev by opening your browser. Automatically configures your MCP token after successful login. Use this for a seamless signup/login experience - no manual token copying required.",
+      "inputSchema": {
+        "type": "object",
+        "properties": {
+          "open_browser": {
+            "type": "boolean",
+            "description": "Whether to automatically open the browser (default: true)",
+            "default": true
+          },
+          "timeout_seconds": {
+            "type": "integer",
+            "description": "How long to wait for authentication (default: 300 = 5 minutes)",
+            "minimum": 30,
+            "maximum": 600,
+            "default": 300
+          }
+        }
+      },
+      "outputSchema": {
+        "type": "object",
+        "properties": {
+          "success": {
+            "type": "boolean",
+            "description": "Whether authentication was successful"
+          },
+          "user_email": {
+            "type": "string",
+            "description": "Authenticated user's email"
+          },
+          "token": {
+            "type": "string",
+            "description": "MCP access token (save this for future use)"
+          },
+          "credits_remaining": {
+            "type": "integer",
+            "description": "Available credits"
+          },
+          "message": {
+            "type": "string",
+            "description": "Human-readable status message"
+          },
+          "auth_url": {
+            "type": "string",
+            "description": "URL to open if browser didn't open automatically"
+          }
+        }
+      },
+      "examples": [
+        {
+          "description": "Login with browser auto-open",
+          "input": {},
+          "output": {
+            "success": true,
+            "user_email": "user@example.com",
+            "token": "polydev_abc123...",
+            "credits_remaining": 500,
+            "message": "Successfully authenticated! Token has been saved."
+          }
+        }
+      ]
+    },
     {
       "name": "get_perspectives",
       "description": "When stuck in agentic workflows, get diverse perspectives from multiple LLMs to overcome roadblocks. All models use Polydev-managed API keys - just configure once in dashboard.",

package/mcp/server.js

@@ -145,6 +145,14 @@ class MCPServer {
       let result;
       
       switch (name) {
+        case 'get_auth_status':
+          result = await this.getAuthStatus(args);
+          break;
+        
+        case 'login':
+          result = await this.login(args);
+          break;
+        
         case 'get_perspectives':
           result = await this.callPerspectivesAPI(args);
           break;
@@ -262,10 +270,31 @@ class MCPServer {
     console.error(`[Polydev MCP] Debug - final userToken: ${userToken ? 'present' : 'missing'}`);
     
     if (!userToken || typeof userToken !== 'string') {
-      throw new Error('user_token is required. Either:\n' +
-        '1. Pass user_token parameter, or\n' +
-        '2. Set POLYDEV_USER_TOKEN environment variable\n' +
-        'Generate token at: https://polydev.ai/dashboard/mcp-tokens');
+      // Return helpful setup instructions instead of just throwing an error
+      const detectedIDE = this.detectIDE();
+      const setupInstructions = this.getSetupInstructions(detectedIDE);
+      
+      throw new Error(
+        '═══════════════════════════════════════════════════════════════\n' +
+        '                    POLYDEV SETUP REQUIRED\n' +
+        '═══════════════════════════════════════════════════════════════\n\n' +
+        'To use Polydev, you need an authentication token.\n\n' +
+        'QUICK SETUP (2 minutes):\n' +
+        '1. Create free account: https://polydev.ai/signup\n' +
+        '2. Get your token: https://polydev.ai/dashboard/mcp-tools\n' +
+        '3. Add token to your MCP configuration\n\n' +
+        'FREE TIER INCLUDES:\n' +
+        '• 500 credits/month (no credit card needed)\n' +
+        '• Access to GLM-4.7, Gemini 3 Flash, Grok 4.1, GPT-5 Mini\n' +
+        '• 1 credit per request (all models)\n\n' +
+        'CONFIGURATION:\n' +
+        'Set POLYDEV_USER_TOKEN in your MCP server env, or\n' +
+        'Pass user_token parameter with each request.\n\n' +
+        'NEED HELP?\n' +
+        '• Setup guide: https://polydev.ai/docs/mcp-integration\n' +
+        '• Use get_auth_status tool for personalized instructions\n' +
+        '═══════════════════════════════════════════════════════════════'
+      );
     }
 
     console.error(`[Polydev MCP] Getting perspectives for: "${args.prompt.substring(0, 60)}${args.prompt.length > 60 ? '...' : ''}"`);
@@ -307,7 +336,24 @@ class MCPServer {
       }
 
       if (response.status === 401) {
-        throw new Error(`Authentication failed: ${errorMessage}. Generate a new token at https://polydev.ai/dashboard/mcp-tools`);
+        throw new Error(
+          '═══════════════════════════════════════════════════════════════\n' +
+          '                 AUTHENTICATION FAILED\n' +
+          '═══════════════════════════════════════════════════════════════\n\n' +
+          `Error: ${errorMessage}\n\n` +
+          'YOUR TOKEN MAY BE:\n' +
+          '• Expired (tokens last 30 days)\n' +
+          '• Invalid or mistyped\n' +
+          '• From a different account\n\n' +
+          'TO FIX:\n' +
+          '1. Go to: https://polydev.ai/dashboard/mcp-tools\n' +
+          '2. Generate a new token\n' +
+          '3. Update your MCP configuration\n\n' +
+          'QUICK CHECK:\n' +
+          '• Use get_auth_status tool to verify your setup\n' +
+          '• Token should start with "polydev_"\n' +
+          '═══════════════════════════════════════════════════════════════'
+        );
       }
 
       throw new Error(`Polydev API error: ${errorMessage}`);
@@ -328,8 +374,551 @@ class MCPServer {
     return result;
   }
 
+  /**
+   * Get authentication status and setup instructions
+   * Works universally across all IDEs (Claude Desktop, Cursor, Continue, Windsurf, VSCode, etc.)
+   */
+  async getAuthStatus(args) {
+    const serverUrl = 'https://www.polydev.ai/api/mcp/auth-status';
+    const userToken = args.user_token || process.env.POLYDEV_USER_TOKEN;
+    
+    console.error('[Polydev MCP] Checking authentication status...');
+
+    // Detect IDE from environment
+    const detectedIDE = this.detectIDE();
+
+    // If no token provided, return setup instructions
+    if (!userToken) {
+      return {
+        authenticated: false,
+        detected_ide: detectedIDE,
+        setup_instructions: this.getSetupInstructions(detectedIDE),
+        quick_links: {
+          signup: 'https://polydev.ai/signup',
+          login: 'https://polydev.ai/login',
+          dashboard: 'https://polydev.ai/dashboard',
+          mcp_tools: 'https://polydev.ai/dashboard/mcp-tools',
+          documentation: 'https://polydev.ai/docs/mcp-integration'
+        },
+        available_models: ['GLM-4.7', 'Gemini 3 Flash', 'Grok 4.1 Fast Reasoning', 'GPT-5 Mini'],
+        pricing: {
+          free_tier: '500 credits/month (no credit card required)',
+          premium_tier: '$10/month for 10,000 credits',
+          credit_cost: '1 credit per request (all models)'
+        },
+        message: 'Welcome to Polydev! Create your free account to get started.',
+        timestamp: new Date().toISOString()
+      };
+    }
+
+    // Validate token with the server
+    try {
+      const response = await fetch(serverUrl, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${userToken}`,
+          'User-Agent': 'polydev-mcp/1.4.0'
+        },
+        body: JSON.stringify({ action: 'check_status' })
+      });
+
+      if (response.ok) {
+        const data = await response.json();
+        return {
+          authenticated: true,
+          user_email: data.email,
+          credits_remaining: data.credits_remaining,
+          credits_used_today: data.credits_used_today || 0,
+          subscription_tier: data.subscription_tier || 'Free',
+          token_expires_at: data.token_expires_at,
+          enabled_models: data.enabled_models || ['GLM-4.7', 'Gemini 3 Flash', 'Grok 4.1 Fast Reasoning', 'GPT-5 Mini'],
+          cli_subscriptions: data.cli_subscriptions || [],
+          quick_links: {
+            dashboard: 'https://polydev.ai/dashboard',
+            usage: 'https://polydev.ai/dashboard/usage',
+            settings: 'https://polydev.ai/dashboard/settings',
+            upgrade: 'https://polydev.ai/dashboard/subscription'
+          },
+          message: `Ready to use Polydev! You have ${data.credits_remaining?.toLocaleString() || 0} credits remaining.`,
+          timestamp: new Date().toISOString()
+        };
+      } else if (response.status === 401) {
+        return {
+          authenticated: false,
+          error: 'invalid_token',
+          detected_ide: detectedIDE,
+          setup_instructions: this.getSetupInstructions(detectedIDE),
+          quick_links: {
+            regenerate_token: 'https://polydev.ai/dashboard/mcp-tools',
+            login: 'https://polydev.ai/login'
+          },
+          message: 'Your token is invalid or expired. Please generate a new one.',
+          timestamp: new Date().toISOString()
+        };
+      } else {
+        const errorText = await response.text();
+        return {
+          authenticated: false,
+          error: 'server_error',
+          error_details: errorText,
+          message: 'Unable to verify authentication. Please try again.',
+          timestamp: new Date().toISOString()
+        };
+      }
+    } catch (error) {
+      console.error('[Polydev MCP] Auth status check error:', error);
+      return {
+        authenticated: false,
+        error: 'connection_error',
+        error_details: error.message,
+        offline_mode: true,
+        message: 'Unable to connect to Polydev servers. Check your internet connection.',
+        timestamp: new Date().toISOString()
+      };
+    }
+  }
+
+  /**
+   * Detect the IDE/MCP client from environment
+   */
+  detectIDE() {
+    // Check common environment variables and process info
+    const env = process.env;
+    
+    if (env.CURSOR_CHANNEL || env.CURSOR_VERSION) return 'cursor';
+    if (env.CONTINUE_EXTENSION_ID) return 'continue';
+    if (env.VSCODE_PID || env.VSCODE_CWD) return 'vscode';
+    if (env.CLAUDE_DESKTOP) return 'claude-desktop';
+    if (env.WINDSURF_VERSION) return 'windsurf';
+    if (env.CLINE_VERSION) return 'cline';
+    
+    // Check process title/args for hints
+    const processTitle = process.title || '';
+    const args = process.argv.join(' ').toLowerCase();
+    
+    if (args.includes('cursor') || processTitle.includes('cursor')) return 'cursor';
+    if (args.includes('claude') || processTitle.includes('claude')) return 'claude-desktop';
+    if (args.includes('continue')) return 'continue';
+    if (args.includes('windsurf')) return 'windsurf';
+    
+    return 'unknown';
+  }
+
+  /**
+   * Get IDE-specific setup instructions
+   */
+  getSetupInstructions(ide) {
+    const baseSteps = {
+      step_1: 'Create your free Polydev account at https://polydev.ai/signup',
+      step_2: 'Go to https://polydev.ai/dashboard/mcp-tools',
+      step_3: 'Click "Generate Token" to create your MCP access token',
+      step_4: 'Copy the token (it starts with "polydev_")'
+    };
+
+    const ideConfigs = {
+      'cursor': {
+        ...baseSteps,
+        step_5: 'Open Cursor Settings (Cmd/Ctrl + ,)',
+        step_6: 'Search for "MCP" in settings',
+        step_7: 'Add Polydev server with your token',
+        config_example: `{
+  "mcpServers": {
+    "polydev": {
+      "command": "npx",
+      "args": ["-y", "polydev-mcp"],
+      "env": { "POLYDEV_USER_TOKEN": "polydev_your_token_here" }
+    }
+  }
+}`
+      },
+      'claude-desktop': {
+        ...baseSteps,
+        step_5: 'Open Claude Desktop settings',
+        step_6: 'Navigate to Developer > MCP Servers',
+        step_7: 'Add the Polydev server configuration',
+        config_example: `{
+  "mcpServers": {
+    "polydev": {
+      "command": "npx",
+      "args": ["-y", "polydev-mcp"],
+      "env": { "POLYDEV_USER_TOKEN": "polydev_your_token_here" }
+    }
+  }
+}`
+      },
+      'continue': {
+        ...baseSteps,
+        step_5: 'Open Continue extension settings in VSCode',
+        step_6: 'Add Polydev to your config.json',
+        config_example: `{
+  "mcpServers": [{
+    "name": "polydev",
+    "command": "npx",
+    "args": ["-y", "polydev-mcp"],
+    "env": { "POLYDEV_USER_TOKEN": "polydev_your_token_here" }
+  }]
+}`
+      },
+      'windsurf': {
+        ...baseSteps,
+        step_5: 'Open Windsurf Settings',
+        step_6: 'Navigate to MCP Configuration',
+        step_7: 'Add Polydev server with your token',
+        config_example: `{
+  "mcp": {
+    "servers": {
+      "polydev": {
+        "command": "npx",
+        "args": ["-y", "polydev-mcp"],
+        "env": { "POLYDEV_USER_TOKEN": "polydev_your_token_here" }
+      }
+    }
+  }
+}`
+      },
+      'vscode': {
+        ...baseSteps,
+        step_5: 'Install an MCP-compatible extension (Continue, Cline, etc.)',
+        step_6: 'Configure the extension with Polydev',
+        step_7: 'Add your token to the configuration'
+      },
+      'unknown': {
+        ...baseSteps,
+        step_5: 'Configure your MCP client with the Polydev server',
+        step_6: 'Set POLYDEV_USER_TOKEN environment variable with your token',
+        note: 'Visit https://polydev.ai/docs/mcp-integration for detailed setup guides'
+      }
+    };
+
+    return ideConfigs[ide] || ideConfigs['unknown'];
+  }
+
+  /**
+   * Format authentication status response for beautiful output
+   */
+  formatAuthStatusResponse(result) {
+    let formatted = '';
+
+    if (result.authenticated) {
+      formatted += `# Polydev Authentication Status\n\n`;
+      formatted += `## Account\n`;
+      formatted += `Email: ${result.user_email}\n`;
+      formatted += `Tier: ${result.subscription_tier}\n\n`;
+      
+      formatted += `## Credits\n`;
+      formatted += `Remaining: ${result.credits_remaining?.toLocaleString() || 0}\n`;
+      if (result.credits_used_today !== undefined) {
+        formatted += `Used Today: ${result.credits_used_today}\n`;
+      }
+      formatted += `\n`;
+      
+      formatted += `## Available Models (1 credit each)\n`;
+      if (result.enabled_models && result.enabled_models.length > 0) {
+        result.enabled_models.forEach(model => {
+          formatted += `- ${model}\n`;
+        });
+      }
+      formatted += `\n`;
+      
+      if (result.cli_subscriptions && result.cli_subscriptions.length > 0) {
+        formatted += `## Connected CLI Subscriptions (no credit cost)\n`;
+        result.cli_subscriptions.forEach(cli => {
+          formatted += `- ${cli}\n`;
+        });
+        formatted += `\n`;
+      }
+      
+      formatted += `## Quick Links\n`;
+      formatted += `- Dashboard: ${result.quick_links.dashboard}\n`;
+      formatted += `- Usage History: ${result.quick_links.usage}\n`;
+      formatted += `- Settings: ${result.quick_links.settings}\n`;
+      
+      if (result.subscription_tier === 'Free') {
+        formatted += `\n## Upgrade to Premium\n`;
+        formatted += `Get 10,000 credits/month for $10: ${result.quick_links.upgrade}\n`;
+      }
+    } else {
+      formatted += `# Welcome to Polydev\n\n`;
+      formatted += `Multi-model AI that helps when you're stuck. Query GPT-5, Claude, Gemini, and Grok simultaneously.\n\n`;
+      
+      if (result.error === 'invalid_token') {
+        formatted += `## Token Issue\n`;
+        formatted += `Your token is invalid or expired.\n`;
+        formatted += `Generate a new one: ${result.quick_links.regenerate_token}\n\n`;
+      }
+      
+      formatted += `## Get Started (Free)\n\n`;
+      
+      if (result.setup_instructions) {
+        Object.entries(result.setup_instructions).forEach(([key, value]) => {
+          if (key.startsWith('step_')) {
+            const stepNum = key.replace('step_', '');
+            formatted += `${stepNum}. ${value}\n`;
+          }
+        });
+        
+        if (result.setup_instructions.config_example) {
+          formatted += `\n## Configuration Example\n`;
+          formatted += `\`\`\`json\n${result.setup_instructions.config_example}\n\`\`\`\n`;
+        }
+        
+        if (result.setup_instructions.note) {
+          formatted += `\nNote: ${result.setup_instructions.note}\n`;
+        }
+      }
+      
+      formatted += `\n## Pricing\n`;
+      if (result.pricing) {
+        formatted += `- Free Tier: ${result.pricing.free_tier}\n`;
+        formatted += `- Premium: ${result.pricing.premium_tier}\n`;
+        formatted += `- Cost: ${result.pricing.credit_cost}\n`;
+      }
+      
+      formatted += `\n## Available Models\n`;
+      if (result.available_models) {
+        result.available_models.forEach(model => {
+          formatted += `- ${model}\n`;
+        });
+      }
+      
+      if (result.detected_ide && result.detected_ide !== 'unknown') {
+        formatted += `\n## Detected IDE\n`;
+        formatted += `${result.detected_ide.charAt(0).toUpperCase() + result.detected_ide.slice(1)}\n`;
+      }
+    }
+
+    return formatted;
+  }
+
+  /**
+   * Browser-based login with automatic token retrieval
+   * Implements OAuth Device Authorization Grant (RFC 8628)
+   */
+  async login(args) {
+    const { open_browser = true, timeout_seconds = 300 } = args;
+    const deviceAuthUrl = 'https://www.polydev.ai/api/mcp/device-auth';
+    
+    console.error('[Polydev MCP] Initiating browser-based login...');
+
+    try {
+      // Step 1: Request device code from server
+      const initResponse = await fetch(deviceAuthUrl, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'User-Agent': 'polydev-mcp/1.4.0'
+        },
+        body: JSON.stringify({ action: 'init' })
+      });
+
+      if (!initResponse.ok) {
+        const errorText = await initResponse.text();
+        throw new Error(`Failed to initiate login: ${errorText}`);
+      }
+
+      const deviceData = await initResponse.json();
+      const { device_code, user_code, verification_url, expires_in, interval } = deviceData;
+
+      console.error(`[Polydev MCP] Device code obtained. User code: ${user_code}`);
+      console.error(`[Polydev MCP] Verification URL: ${verification_url}`);
+
+      // Step 2: Open browser if requested
+      if (open_browser) {
+        const browserOpened = await this.openBrowser(verification_url);
+        if (!browserOpened) {
+          console.error('[Polydev MCP] Could not open browser automatically');
+        }
+      }
+
+      // Step 3: Poll for token
+      const pollInterval = (interval || 5) * 1000; // Convert to ms
+      const maxPollTime = Math.min(timeout_seconds, expires_in || 300) * 1000;
+      const startTime = Date.now();
+
+      console.error(`[Polydev MCP] Polling for token (timeout: ${maxPollTime / 1000}s)...`);
+
+      while (Date.now() - startTime < maxPollTime) {
+        await this.sleep(pollInterval);
+
+        const pollResponse = await fetch(deviceAuthUrl, {
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json',
+            'User-Agent': 'polydev-mcp/1.4.0'
+          },
+          body: JSON.stringify({ 
+            action: 'poll',
+            device_code 
+          })
+        });
+
+        if (pollResponse.ok) {
+          const pollData = await pollResponse.json();
+
+          if (pollData.status === 'completed' && pollData.token) {
+            console.error('[Polydev MCP] Authentication successful!');
+            
+            // Store token in environment for this session
+            process.env.POLYDEV_USER_TOKEN = pollData.token;
+
+            return {
+              success: true,
+              user_email: pollData.email,
+              token: pollData.token,
+              credits_remaining: pollData.credits_remaining || 500,
+              subscription_tier: pollData.subscription_tier || 'Free',
+              message: 'Successfully authenticated! Your token has been configured for this session.',
+              next_steps: [
+                'Your token is now active for this session',
+                'Add POLYDEV_USER_TOKEN to your MCP config for persistent access',
+                'Use get_perspectives to query multiple AI models'
+              ],
+              timestamp: new Date().toISOString()
+            };
+          }
+
+          if (pollData.status === 'pending') {
+            console.error('[Polydev MCP] Waiting for user to complete authentication...');
+            continue;
+          }
+
+          if (pollData.status === 'expired') {
+            throw new Error('Login session expired. Please try again.');
+          }
+
+          if (pollData.error) {
+            throw new Error(pollData.error);
+          }
+        }
+      }
+
+      // Timeout reached
+      return {
+        success: false,
+        error: 'timeout',
+        message: `Login timed out after ${timeout_seconds} seconds. Please try again.`,
+        auth_url: verification_url,
+        user_code: user_code,
+        instructions: 'Open the URL above and enter the user code to complete authentication.',
+        timestamp: new Date().toISOString()
+      };
+
+    } catch (error) {
+      console.error('[Polydev MCP] Login error:', error);
+      return {
+        success: false,
+        error: error.message,
+        message: 'Login failed. Please try again or use manual token setup.',
+        manual_setup_url: 'https://polydev.ai/dashboard/mcp-tools',
+        timestamp: new Date().toISOString()
+      };
+    }
+  }
+
+  /**
+   * Open browser to a URL (cross-platform)
+   */
+  async openBrowser(url) {
+    const { exec } = require('child_process');
+    const platform = process.platform;
+
+    let command;
+    if (platform === 'darwin') {
+      command = `open "${url}"`;
+    } else if (platform === 'win32') {
+      command = `start "" "${url}"`;
+    } else {
+      // Linux and others
+      command = `xdg-open "${url}" || sensible-browser "${url}" || x-www-browser "${url}"`;
+    }
+
+    return new Promise((resolve) => {
+      exec(command, (error) => {
+        if (error) {
+          console.error('[Polydev MCP] Browser open error:', error.message);
+          resolve(false);
+        } else {
+          console.error('[Polydev MCP] Browser opened successfully');
+          resolve(true);
+        }
+      });
+    });
+  }
+
+  /**
+   * Sleep utility for polling
+   */
+  sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+  }
+
+  /**
+   * Format login response for beautiful output
+   */
+  formatLoginResponse(result) {
+    let formatted = '';
+
+    if (result.success) {
+      formatted += `# Polydev Login Successful\n\n`;
+      formatted += `## Account\n`;
+      formatted += `Email: ${result.user_email}\n`;
+      formatted += `Tier: ${result.subscription_tier}\n`;
+      formatted += `Credits: ${result.credits_remaining?.toLocaleString() || 'N/A'}\n\n`;
+      
+      formatted += `## Token\n`;
+      formatted += `\`\`\`\n${result.token}\n\`\`\`\n\n`;
+      
+      formatted += `## Next Steps\n`;
+      if (result.next_steps) {
+        result.next_steps.forEach((step, i) => {
+          formatted += `${i + 1}. ${step}\n`;
+        });
+      }
+      
+      formatted += `\n## Save Token for Persistent Access\n`;
+      formatted += `Add this to your MCP configuration:\n`;
+      formatted += `\`\`\`json\n`;
+      formatted += `{\n`;
+      formatted += `  "env": { "POLYDEV_USER_TOKEN": "${result.token}" }\n`;
+      formatted += `}\n`;
+      formatted += `\`\`\`\n`;
+    } else {
+      formatted += `# Polydev Login\n\n`;
+      
+      if (result.error === 'timeout') {
+        formatted += `## Timeout\n`;
+        formatted += `${result.message}\n\n`;
+        
+        if (result.auth_url) {
+          formatted += `## Complete Manually\n`;
+          formatted += `1. Open: ${result.auth_url}\n`;
+          formatted += `2. Enter code: **${result.user_code}**\n`;
+          formatted += `3. Run login again after completing\n`;
+        }
+      } else {
+        formatted += `## Error\n`;
+        formatted += `${result.message}\n\n`;
+        
+        if (result.manual_setup_url) {
+          formatted += `## Manual Setup\n`;
+          formatted += `Visit: ${result.manual_setup_url}\n`;
+          formatted += `Generate a token and add it to your MCP configuration.\n`;
+        }
+      }
+    }
+
+    return formatted;
+  }
+
   formatResponse(toolName, result) {
     switch (toolName) {
+      case 'get_auth_status':
+        return this.formatAuthStatusResponse(result);
+      
+      case 'login':
+        return this.formatLoginResponse(result);
+      
       case 'get_perspectives':
         return this.formatPerspectivesResponse(result);
       

package/mcp/stdio-wrapper.js

@@ -1712,25 +1712,65 @@ if (require.main === module) {
  * This allows Smithery to discover tools/resources without real credentials
  */
 function createSandboxServer() {
-  // Return a minimal server that exposes our tool definitions for scanning
-  // No real API calls will be made - this is just for capability discovery
-  const fs = require('fs');
-  const path = require('path');
-  
-  const manifestPath = path.join(__dirname, 'manifest.json');
-  const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
-  
+  // Embed manifest directly to work with Smithery bundling
+  // (file paths don't resolve in bundled context)
   return {
     serverInfo: {
-      name: manifest.name,
-      version: manifest.version
+      name: 'polydev-perspectives',
+      version: '1.8.70'
     },
     capabilities: { tools: {} },
-    tools: manifest.tools.map(tool => ({
-      name: tool.name,
-      description: tool.description,
-      inputSchema: tool.inputSchema
-    }))
+    tools: [
+      {
+        name: 'get_perspectives',
+        description: 'Query GPT 5.2, Claude Opus 4.5, Gemini 3, and Grok 4.1 simultaneously for diverse AI perspectives when debugging, making architecture decisions, or reviewing code.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            prompt: {
+              type: 'string',
+              description: 'The prompt to get perspectives on'
+            },
+            user_token: {
+              type: 'string',
+              description: 'Polydev user authentication token'
+            }
+          },
+          required: ['prompt']
+        }
+      },
+      {
+        name: 'get_cli_status',
+        description: 'Check status of local CLI tools (Claude Code, Codex CLI, Gemini CLI)',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            provider_id: {
+              type: 'string',
+              description: 'Optional specific provider to check'
+            }
+          }
+        }
+      },
+      {
+        name: 'force_cli_detection',
+        description: 'Force re-detection of installed local CLI tools',
+        inputSchema: { type: 'object', properties: {} }
+      },
+      {
+        name: 'send_cli_prompt',
+        description: 'Send prompt to local CLI with perspectives fallback',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            provider_id: { type: 'string', description: 'CLI provider ID' },
+            prompt: { type: 'string', description: 'Prompt to send' },
+            mode: { type: 'string', enum: ['args', 'stdin'], default: 'args' }
+          },
+          required: ['provider_id', 'prompt']
+        }
+      }
+    ]
   };
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "polydev-ai",
-  "version": "1.8.63",
+  "version": "1.8.71",
   "engines": {
     "node": ">=20.x <=22.x"
   },
@@ -22,7 +22,8 @@
   "private": false,
   "main": "mcp/stdio-wrapper.js",
   "bin": {
-    "polydev-stdio": "mcp/stdio-wrapper.js"
+    "polydev-stdio": "mcp/stdio-wrapper.js",
+    "polydev-ai": "mcp/stdio-wrapper.js"
   },
   "files": [
     "mcp/",