polydev-ai 1.2.7 → 1.2.8

package/lib/cliManager.js

@@ -1,552 +1,508 @@
-const { exec, spawn } = require('child_process');
-const { promisify } = require('util');
-const path = require('path');
-const fs = require('fs');
+"use strict";
+/**
+ * CLI Manager with MCP Server Integration
+ * Handles detection, authentication, and prompt sending for Claude Code, Codex CLI, and Gemini CLI
+ * Uses MCP servers for database operations and status reporting
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CLIManager = void 0;
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const fs = __importStar(require("fs"));
 const which = require('which');
-
-const execAsync = promisify(exec);
-
+const shell = require('shelljs');
+const execAsync = (0, util_1.promisify)(child_process_1.exec);
 class CLIManager {
-  constructor() {
-    this.providers = new Map();
-    this.statusCache = new Map();
-    this.CACHE_TIMEOUT_MS = 5 * 60 * 1000; // 5 minutes
-    this.initializeProviders();
-  }
-
-  initializeProviders() {
-    const providers = [
-      {
-        id: 'claude_code',
-        name: 'Claude Code',
-        command: process.env.CLAUDE_CODE_PATH || 'claude',
-        subcommands: {
-          chat: [],
-          version: ['--version'],
-          auth_status: ['--print', 'test auth'], // Use --print to test auth
-          test_prompt: ['--print']
-        },
-        install_instructions: 'Install via: npm install -g @anthropic-ai/claude-code',
-        auth_instructions: 'Authenticate with Claude Code'
-      },
-      {
-        id: 'codex_cli',
-        name: 'Codex CLI',
-        command: process.env.CODEX_CLI_PATH || 'codex',
-        subcommands: {
-          chat: [],
-          version: ['--version'],
-          auth_status: ['login', 'status'], // Correct command: codex login status
-          test_prompt: ['exec']
-        },
-        install_instructions: 'Install Codex CLI from OpenAI',
-        auth_instructions: 'Authenticate with: codex login'
-      },
-      {
-        id: 'gemini_cli',
-        name: 'Gemini CLI',
-        command: process.env.GEMINI_CLI_PATH || 'gemini',
-        subcommands: {
-          chat: ['chat'],
-          version: ['--version'],
-          auth_status: ['auth-status'] // gemini-mcp auth-status command
-        },
-        install_instructions: 'Install Gemini CLI from Google',
-        auth_instructions: 'Authenticate with: gemini (then /auth login)'
-      }
-    ];
-
-    providers.forEach(provider => {
-      this.providers.set(provider.id, provider);
-    });
-  }
-
-  async forceCliDetection(specificProvider) {
-    const results = {};
-    const providersToCheck = specificProvider 
-      ? [this.providers.get(specificProvider)].filter(Boolean) 
-      : Array.from(this.providers.values());
-
-    // Log system environment for debugging
-    console.log(`[Polydev CLI] Detecting CLI providers - Node.js ${process.version}, Platform: ${process.platform}`);
-
-    for (const provider of providersToCheck) {
-      if (provider) {
-        try {
-          results[provider.id] = await this.detectCliProvider(provider);
-          this.statusCache.set(provider.id, results[provider.id]);
-          
-          // Log compatibility issues for user awareness
-          if (results[provider.id].error && results[provider.id].error.includes('Compatibility Issue')) {
-            console.warn(`[Polydev CLI] ⚠️  ${provider.name} compatibility issue detected. See error details for solutions.`);
-          }
-        } catch (error) {
-          results[provider.id] = {
-            available: false,
-            authenticated: false,
-            error: `Detection failed: ${error.message}`,
-            last_checked: new Date()
-          };
-        }
-      }
+    constructor() {
+        this.providers = new Map();
+        this.statusCache = new Map();
+        this.cacheTimeout = 5 * 60 * 1000; // 5 minutes
+        this.initializeProviders();
+    }
+    initializeProviders() {
+        const providers = [
+            {
+                id: 'claude_code',
+                name: 'Claude Code',
+                executable: 'claude',
+                versionCommand: 'claude --version',
+                authCheckCommand: 'claude auth status',
+                chatCommand: 'claude chat',
+                supportsStdin: true,
+                supportsArgs: true,
+                installInstructions: 'Install via: npm install -g @anthropic-ai/claude-code',
+                authInstructions: 'Authenticate with: claude auth login'
+            },
+            {
+                id: 'codex_cli',
+                name: 'Codex CLI',
+                executable: 'codex',
+                versionCommand: 'codex --version',
+                authCheckCommand: 'codex login --check', // Changed to check login status
+                chatCommand: 'codex exec', // Changed from 'codex chat' to 'codex exec'
+                supportsStdin: false, // Codex exec doesn't use stdin
+                supportsArgs: true,
+                installInstructions: 'Install via: npm install -g codex-cli',
+                authInstructions: 'Authenticate with: codex login'
+            },
+            {
+                id: 'gemini_cli',
+                name: 'Gemini CLI',
+                executable: 'gemini',
+                versionCommand: 'gemini --version',
+                authCheckCommand: 'gemini auth status',
+                chatCommand: 'gemini chat',
+                supportsStdin: true,
+                supportsArgs: true,
+                installInstructions: 'Install Gemini CLI from Google',
+                authInstructions: 'Authenticate with: gemini auth login'
+            }
+        ];
+        providers.forEach(provider => {
+            this.providers.set(provider.id, provider);
+        });
     }
-
-    return results;
-  }
-
-  async getCliStatus(specificProvider) {
-    const results = {};
-    const providersToCheck = specificProvider 
-      ? [this.providers.get(specificProvider)].filter(Boolean) 
-      : Array.from(this.providers.values());
-
-    for (const provider of providersToCheck) {
-      if (provider) {
-        const cached = this.statusCache.get(provider.id);
-        if (cached && this.isCacheValid(cached)) {
-          results[provider.id] = cached;
-        } else {
-          const detection = await this.forceCliDetection(provider.id);
-          results[provider.id] = detection[provider.id];
+    /**
+     * Force CLI detection for all providers or specific provider
+     * Updates status cache and reports to MCP server via Supabase
+     */
+    async forceCliDetection(userId, providerId) {
+        console.log(`[CLI Manager] Force detection started for ${providerId || 'all providers'}`);
+        const results = {};
+        const providersToCheck = providerId ? [providerId] : Array.from(this.providers.keys());
+        for (const id of providersToCheck) {
+            const provider = this.providers.get(id);
+            if (!provider)
+                continue;
+            try {
+                const status = await this.detectCLI(provider);
+                this.statusCache.set(id, status);
+                results[id] = status;
+                // Update database via MCP Supabase if userId provided
+                if (userId) {
+                    await this.updateCliStatusInDatabase(userId, id, status);
+                }
+                console.log(`[CLI Manager] ${provider.name}: ${status.available ? 'Available' : 'Not Available'}`);
+            }
+            catch (error) {
+                console.error(`[CLI Manager] Error detecting ${provider.name}:`, error);
+                const errorStatus = {
+                    available: false,
+                    authenticated: false,
+                    lastChecked: new Date(),
+                    error: error instanceof Error ? error.message : 'Unknown error'
+                };
+                this.statusCache.set(id, errorStatus);
+                results[id] = errorStatus;
+            }
         }
-      }
+        return results;
     }
-
-    return results;
-  }
-
-  isCacheValid(status) {
-    if (!status.last_checked) return false;
-    const now = new Date().getTime();
-    const checked = new Date(status.last_checked).getTime();
-    return (now - checked) < this.CACHE_TIMEOUT_MS;
-  }
-
-  async detectCliProvider(provider) {
-    try {
-      const cliPath = await this.findCliPath(provider.command);
-      if (!cliPath) {
-        return {
-          available: false,
-          authenticated: false,
-          error: `${provider.name} not found in PATH. ${provider.install_instructions}`,
-          last_checked: new Date()
+    /**
+     * Get CLI status with cache support
+     */
+    async getCliStatus(providerId, userId) {
+        const cached = this.statusCache.get(providerId);
+        const now = new Date();
+        // Return cached result if still valid
+        if (cached && (now.getTime() - cached.lastChecked.getTime()) < this.cacheTimeout) {
+            return cached;
+        }
+        // Force detection if cache is stale or missing
+        const results = await this.forceCliDetection(userId, providerId);
+        return results[providerId] || {
+            available: false,
+            authenticated: false,
+            lastChecked: now,
+            error: 'Provider not found'
         };
-      }
-
-      let version;
-      try {
-        const versionResult = await this.executeCliCommand(
-          provider.command, 
-          provider.subcommands.version,
-          'args',
-          5000
-        );
-        version = versionResult.stdout?.trim();
-      } catch (versionError) {
-        if (process.env.POLYDEV_CLI_DEBUG) {
-          console.log(`[CLI Debug] Version check failed for ${provider.id}:`, versionError);
+    }
+    /**
+     * Send prompt to CLI provider
+     */
+    async sendCliPrompt(providerId, prompt, mode = 'args', timeoutMs = 30000) {
+        const provider = this.providers.get(providerId);
+        if (!provider) {
+            return {
+                success: false,
+                error: `Unknown CLI provider: ${providerId}`
+            };
         }
-      }
-
-      let authenticated = false;
-      
-      // For Claude Code, skip command-based auth check and use file-based detection directly
-      // This avoids the recursion issue when running from within Claude Code
-      if (provider.id === 'claude_code') {
-        authenticated = await this.checkAuthenticationByFiles(provider.id);
-        
-        if (process.env.POLYDEV_CLI_DEBUG) {
-          console.log(`[CLI Debug] File-based auth check for ${provider.id}:`, authenticated);
+        // Check if CLI is available and authenticated
+        const status = await this.getCliStatus(providerId);
+        if (!status.available) {
+            return {
+                success: false,
+                error: `${provider.name} is not available. ${provider.installInstructions}`
+            };
         }
-      } else {
-        // For other providers, try command-based auth check first
-        try {
-          const authResult = await this.executeCliCommand(
-            provider.command,
-            provider.subcommands.auth_status,
-            'args',
-            5000 // Reduced timeout to 5 seconds
-          );
-          
-          // If command succeeds, check output for authentication indicators
-          const authOutput = (authResult.stdout + ' ' + authResult.stderr).toLowerCase();
-          
-          if (process.env.POLYDEV_CLI_DEBUG) {
-            console.log(`[CLI Debug] Auth output for ${provider.id}: "${authOutput}"`);
-          }
-          
-          authenticated = this.parseAuthenticationStatus(provider.id, authOutput);
-          
-        } catch (authError) {
-          if (process.env.POLYDEV_CLI_DEBUG) {
-            console.log(`[CLI Debug] Auth check failed for ${provider.id}:`, authError);
-          }
-          
-          // Fallback to file-based authentication detection
-          authenticated = await this.checkAuthenticationByFiles(provider.id);
-          
-          if (process.env.POLYDEV_CLI_DEBUG) {
-            console.log(`[CLI Debug] File-based auth check for ${provider.id}:`, authenticated);
-          }
+        if (!status.authenticated) {
+            return {
+                success: false,
+                error: `${provider.name} is not authenticated. ${provider.authInstructions}`
+            };
         }
-      }
-
-      // Special handling for Gemini CLI Node.js compatibility issues
-      let errorMessage = undefined;
-      if (!authenticated) {
-        if (provider.id === 'gemini_cli') {
-          // Check if the issue is Node.js compatibility
-          try {
-            const authResult = await this.executeCliCommand(
-              provider.command,
-              ['--help'],
-              'args',
-              2000
-            );
-            const testOutput = (authResult.stdout + ' ' + authResult.stderr).toLowerCase();
-            if (testOutput.includes('referenceerror: file is not defined') ||
-                testOutput.includes('undici/lib/web/webidl')) {
-              errorMessage = `⚠️  Gemini CLI Compatibility Issue: Node.js v${process.version} doesn't support the 'File' global that Gemini CLI requires. 
-
-Solutions:
-• Update to Node.js v20+ (recommended): nvm install 20 && nvm use 20
-• Reinstall Gemini CLI: npm uninstall -g @google/gemini-cli && npm install -g @google/gemini-cli@latest
-• Alternative: Use Google AI Studio directly or switch to Claude/OpenAI providers
-
-This is a known issue with @google/gemini-cli@0.3.4 and older Node.js versions.`;
-            } else {
-              errorMessage = `Not authenticated. ${provider.auth_instructions}`;
+        const startTime = Date.now();
+        try {
+            let result;
+            if (mode === 'stdin' && provider.supportsStdin) {
+                result = await this.sendPromptViaStdin(provider, prompt, timeoutMs);
+            }
+            else if (mode === 'args' && provider.supportsArgs) {
+                result = await this.sendPromptViaArgs(provider, prompt, timeoutMs);
             }
-          } catch {
-            errorMessage = `Not authenticated. ${provider.auth_instructions}`;
-          }
-        } else {
-          errorMessage = `Not authenticated. ${provider.auth_instructions}`;
+            else {
+                return {
+                    success: false,
+                    error: `${provider.name} does not support ${mode} mode`
+                };
+            }
+            const latencyMs = Date.now() - startTime;
+            return {
+                success: true,
+                content: result,
+                latencyMs
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'CLI execution failed',
+                latencyMs: Date.now() - startTime
+            };
         }
-      }
-
-      return {
-        available: true,
-        authenticated,
-        version,
-        path: cliPath,
-        last_checked: new Date(),
-        error: errorMessage
-      };
-
-    } catch (error) {
-      return {
-        available: false,
-        authenticated: false,
-        error: `Detection failed: ${error.message}`,
-        last_checked: new Date()
-      };
     }
-  }
-
-  async findCliPath(command) {
-    try {
-      return await which(command);
-    } catch (error) {
-      return null;
+    /**
+     * Detect CLI installation and authentication
+     */
+    async detectCLI(provider) {
+        const customPath = process.env[`${provider.id.toUpperCase()}_PATH`];
+        let executablePath;
+        try {
+            // Try custom path first, then system PATH
+            if (customPath && fs.existsSync(customPath)) {
+                executablePath = customPath;
+            }
+            else {
+                executablePath = await which(provider.executable);
+            }
+        }
+        catch (error) {
+            return {
+                available: false,
+                authenticated: false,
+                lastChecked: new Date(),
+                error: `${provider.name} not found in PATH. ${provider.installInstructions}`
+            };
+        }
+        // Check version
+        let version;
+        try {
+            const { stdout } = await execAsync(provider.versionCommand, { timeout: 10000 });
+            version = stdout.trim();
+        }
+        catch (error) {
+            return {
+                available: false,
+                authenticated: false,
+                lastChecked: new Date(),
+                path: executablePath,
+                error: `Failed to get ${provider.name} version`
+            };
+        }
+        // Check authentication
+        let authenticated = false;
+        try {
+            const { stdout, stderr } = await execAsync(provider.authCheckCommand, { timeout: 10000 });
+            // Look for success indicators in output
+            const output = (stdout + stderr).toLowerCase();
+            authenticated = output.includes('authenticated') ||
+                output.includes('logged in') ||
+                output.includes('valid') ||
+                !output.includes('not authenticated');
+        }
+        catch (error) {
+            // Some CLIs might not have auth status command, assume authenticated if version works
+            authenticated = true;
+        }
+        // Detect available models for this CLI tool
+        let default_model;
+        let available_models;
+        let model_detection_method;
+        try {
+            const modelDetection = await this.detectDefaultModel(provider.id);
+            default_model = modelDetection.defaultModel;
+            available_models = modelDetection.availableModels;
+            model_detection_method = modelDetection.detectionMethod;
+        }
+        catch (error) {
+            console.error(`[CLI Manager] Model detection failed for ${provider.name}:`, error);
+            // Continue without model info - fallback will be used
+        }
+        return {
+            available: true,
+            authenticated,
+            version,
+            path: executablePath,
+            lastChecked: new Date(),
+            default_model,
+            available_models,
+            model_detection_method
+        };
     }
-  }
-
-  async checkAuthenticationByFiles(providerId) {
-    const os = require('os');
-    
-    try {
-      switch (providerId) {
-        case 'claude_code':
-          // Check for Claude Code session files
-          const claudeConfigPath = path.join(os.homedir(), '.claude.json');
-          if (fs.existsSync(claudeConfigPath)) {
-            const configContent = fs.readFileSync(claudeConfigPath, 'utf8');
-            // Look for session or auth tokens in the config
-            return configContent.length > 100 && 
-                   (configContent.includes('session') || 
-                    configContent.includes('token') || 
-                    configContent.includes('auth'));
-          }
-          return false;
-        
-        case 'codex_cli':
-          // Check for Codex auth files
-          const codexAuthPath = path.join(os.homedir(), '.codex', 'auth.json');
-          if (fs.existsSync(codexAuthPath)) {
-            const authContent = fs.readFileSync(codexAuthPath, 'utf8');
-            try {
-              const authData = JSON.parse(authContent);
-              return authData && (authData.token || authData.access_token || authData.authenticated);
-            } catch {
-              return authContent.length > 10; // Has some auth content
+    /**
+     * Send prompt via stdin mode
+     */
+    async sendPromptViaStdin(provider, prompt, timeoutMs) {
+        return new Promise((resolve, reject) => {
+            const child = (0, child_process_1.spawn)(provider.chatCommand, [], {
+                stdio: ['pipe', 'pipe', 'pipe'],
+                timeout: timeoutMs
+            });
+            let stdout = '';
+            let stderr = '';
+            child.stdout?.on('data', (data) => {
+                stdout += data.toString();
+            });
+            child.stderr?.on('data', (data) => {
+                stderr += data.toString();
+            });
+            child.on('close', (code) => {
+                if (code === 0) {
+                    resolve(stdout.trim());
+                }
+                else {
+                    reject(new Error(`CLI exited with code ${code}: ${stderr}`));
+                }
+            });
+            child.on('error', (error) => {
+                reject(error);
+            });
+            // Send prompt via stdin
+            if (child.stdin) {
+                child.stdin.write(prompt);
+                child.stdin.end();
             }
-          }
-          return false;
-        
-        case 'gemini_cli':
-          // Check for Gemini CLI auth files (if any)
-          const geminiConfigPath = path.join(os.homedir(), '.config', 'gemini-cli', 'config.json');
-          if (fs.existsSync(geminiConfigPath)) {
-            const configContent = fs.readFileSync(geminiConfigPath, 'utf8');
-            return configContent.includes('auth') || configContent.includes('token');
-          }
-          return false;
-        
-        default:
-          return false;
-      }
-    } catch (error) {
-      if (process.env.POLYDEV_CLI_DEBUG) {
-        console.log(`[CLI Debug] File-based auth check error for ${providerId}:`, error.message);
-      }
-      return false;
+        });
     }
-  }
-
-  parseAuthenticationStatus(providerId, authOutput) {
-    
-    switch (providerId) {
-      case 'claude_code':
-        // If --print "test auth" works without error, Claude Code is authenticated
-        // Look for actual response content (not authentication errors)
-        const claudeAuth = !authOutput.includes('not authenticated') && 
-               !authOutput.includes('please log in') &&
-               !authOutput.includes('authentication required') &&
-               !authOutput.includes('login required') &&
-               authOutput.length > 10; // Has actual content response
-        
-        return claudeAuth;
-      
-      case 'codex_cli':
-        // Look for specific codex login status responses
-        const hasLoggedIn = authOutput.includes('logged in using');
-        const hasAuthenticated = authOutput.includes('authenticated');
-        const hasChatGpt = authOutput.includes('chatgpt') && !authOutput.includes('not logged in');
-        
-        
-        return hasLoggedIn || hasAuthenticated || hasChatGpt;
-      
-      case 'gemini_cli':
-        // Check for Node.js compatibility issues first
-        if (authOutput.includes('referenceerror: file is not defined') || 
-            authOutput.includes('undici/lib/web/webidl') ||
-            authOutput.includes('file is not defined')) {
-          return false; // CLI is broken due to Node.js compatibility
+    /**
+     * Send prompt via command arguments
+     */
+    async sendPromptViaArgs(provider, prompt, timeoutMs) {
+        const command = `${provider.chatCommand} "${prompt.replace(/"/g, '\\"')}"`;
+        try {
+            const { stdout } = await execAsync(command, { timeout: timeoutMs });
+            return stdout.trim();
+        }
+        catch (error) {
+            throw new Error(`CLI command failed: ${error}`);
         }
-        
-        return !authOutput.includes('not authenticated') && 
-               !authOutput.includes('please login') &&
-               (authOutput.includes('authenticated') || authOutput.includes('logged in'));
-      
-      default:
-        return authOutput.includes('authenticated') || authOutput.includes('logged in');
-    }
-  }
-
-  async sendCliPrompt(providerId, prompt, mode = 'args', timeoutMs = null) {
-    // Set provider-specific default timeouts
-    if (timeoutMs === null) {
-      timeoutMs = providerId === 'claude_code' ? 60000 : 30000; // 60s for Claude Code, 30s for others
     }
-    
-    // Ensure timeoutMs is valid (not undefined, null, Infinity, or negative)
-    if (!timeoutMs || timeoutMs === Infinity || timeoutMs < 1 || timeoutMs > 300000) {
-      timeoutMs = 30000 // Default to 30 seconds
+    /**
+     * Update CLI status in database using MCP Supabase server
+     * This integrates with existing MCP infrastructure
+     */
+    async updateCliStatusInDatabase(userId, providerId, status) {
+        try {
+            // Use existing CLI status API endpoint with MCP Supabase integration
+            const statusUpdate = {
+                server: this.getServerNameForProvider(providerId),
+                tool: 'cli_detection',
+                args: {
+                    provider: providerId,
+                    available: status.available,
+                    authenticated: status.authenticated,
+                    version: status.version,
+                    path: status.path,
+                    error: status.error
+                }
+            };
+            // Call existing API endpoint that has MCP Supabase integration
+            const response = await fetch('/api/cli-status', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'User-Agent': 'polydev-cli-manager/1.0.0'
+                },
+                body: JSON.stringify(statusUpdate)
+            });
+            if (!response.ok) {
+                throw new Error(`Failed to update CLI status: ${response.status}`);
+            }
+            const result = await response.json();
+            console.log(`[CLI Manager] Updated database via MCP Supabase for ${providerId}: ${status.available}`);
+        }
+        catch (error) {
+            console.error(`[CLI Manager] Failed to update database via MCP Supabase:`, error);
+        }
     }
-    
-    const startTime = Date.now();
-
-    try {
-      const provider = this.providers.get(providerId);
-      if (!provider) {
-        return {
-          success: false,
-          error: `Unknown provider: ${providerId}`,
-          latency_ms: Date.now() - startTime,
-          timestamp: new Date()
-        };
-      }
-
-      const status = await this.getCliStatus(providerId);
-      const providerStatus = status[providerId];
-      
-      if (!providerStatus?.available) {
-        return {
-          success: false,
-          error: `${provider.name} is not available. ${provider.install_instructions}`,
-          latency_ms: Date.now() - startTime,
-          timestamp: new Date()
-        };
-      }
-
-      if (!providerStatus.authenticated) {
-        return {
-          success: false,
-          error: `${provider.name} is not authenticated. ${provider.auth_instructions}`,
-          latency_ms: Date.now() - startTime,
-          timestamp: new Date()
+    /**
+     * Map provider ID to server name for MCP integration
+     */
+    getServerNameForProvider(providerId) {
+        const serverMap = {
+            'claude_code': 'claude-code-cli-bridge',
+            'codex_cli': 'cross-llm-bridge-test',
+            'gemini_cli': 'gemini-cli-bridge'
         };
-      }
-
-      const args = [...provider.subcommands.test_prompt];
-      if (mode === 'args') {
-        args.push(prompt);
-      }
-
-      const result = await this.executeCliCommand(
-        provider.command,
-        args,
-        mode,
-        timeoutMs,
-        mode === 'stdin' ? prompt : undefined
-      );
-
-      if (result.error) {
-        return {
-          success: false,
-          error: `CLI command failed: ${result.error}`,
-          latency_ms: Date.now() - startTime,
-          provider: providerId,
-          mode,
-          timestamp: new Date()
-        };
-      }
-
-      const content = this.cleanCliResponse(result.stdout || '');
-      const tokens_used = this.estimateTokens(prompt + content);
-
-      return {
-        success: true,
-        content,
-        tokens_used,
-        latency_ms: Date.now() - startTime,
-        provider: providerId,
-        mode,
-        timestamp: new Date()
-      };
-
-    } catch (error) {
-      return {
-        success: false,
-        error: `CLI execution failed: ${error.message}`,
-        latency_ms: Date.now() - startTime,
-        provider: providerId,
-        mode,
-        timestamp: new Date()
-      };
+        return serverMap[providerId] || 'unknown-cli-bridge';
     }
-  }
-
-  async executeCliCommand(command, args, mode = 'args', timeoutMs = 30000, stdinInput) {
-    // Ensure timeoutMs is valid (not undefined, null, Infinity, or negative)
-    if (!timeoutMs || timeoutMs === Infinity || timeoutMs < 1 || timeoutMs > 300000) {
-      timeoutMs = 30000 // Default to 30 seconds
+    /**
+     * Get all CLI providers configuration
+     */
+    getProviders() {
+        return Array.from(this.providers.values());
     }
-    
-    return new Promise((resolve, reject) => {
-      if (process.env.POLYDEV_CLI_DEBUG) {
-        console.log(`[CLI Debug] Executing: ${command} ${args.join(' ')} (mode: ${mode})`);
-      }
-
-      const child = spawn(command, args, {
-        stdio: mode === 'stdin' ? ['pipe', 'pipe', 'pipe'] : ['ignore', 'pipe', 'pipe'],
-        shell: process.platform === 'win32',
-        timeout: timeoutMs
-      });
-
-      let stdout = '';
-      let stderr = '';
-
-      child.stdout?.on('data', (data) => {
-        stdout += data.toString();
-      });
-
-      child.stderr?.on('data', (data) => {
-        stderr += data.toString();
-      });
-
-      if (mode === 'stdin' && stdinInput && child.stdin) {
-        child.stdin.write(stdinInput);
-        child.stdin.end();
-      }
-
-      child.on('close', (code) => {
-        if (process.env.POLYDEV_CLI_DEBUG) {
-          console.log(`[CLI Debug] Command finished with code ${code}`);
-        }
-
-        if (code === 0) {
-          resolve({ stdout, stderr });
-        } else {
-          resolve({ 
-            stdout, 
-            stderr, 
-            error: `Command exited with code ${code}` 
-          });
+    /**
+     * Get provider by ID
+     */
+    getProvider(providerId) {
+        return this.providers.get(providerId);
+    }
+    /**
+     * Detect available models for a CLI provider using interactive commands
+     */
+    async detectDefaultModel(providerId) {
+        try {
+            // Try interactive detection using CLI commands
+            let command = '';
+            switch (providerId) {
+                case 'claude_code':
+                    command = 'models'; // Claude Code model listing command
+                    break;
+                case 'codex_cli':
+                    command = 'list-models'; // Codex CLI model listing command
+                    break;
+                case 'gemini_cli':
+                    command = 'models'; // Gemini CLI model listing command
+                    break;
+            }
+            if (!command) {
+                throw new Error(`No model detection command for ${providerId}`);
+            }
+            const result = await this.sendCliPrompt(providerId, command, 'args', 10000);
+            if (result.success && result.content) {
+                const models = this.parseModelsFromOutput(providerId, result.content);
+                if (models.length > 0) {
+                    return {
+                        defaultModel: this.extractDefaultModel(providerId, models),
+                        availableModels: models,
+                        detectionMethod: 'interactive'
+                    };
+                }
+            }
         }
-      });
-
-      child.on('error', (error) => {
-        if (process.env.POLYDEV_CLI_DEBUG) {
-          console.log(`[CLI Debug] Command error:`, error);
+        catch (error) {
+            console.error(`Interactive model detection failed for ${providerId}:`, error);
         }
-        reject(error);
-      });
-
-      let timeoutId;
-      const cleanup = () => {
-        if (timeoutId) {
-          clearTimeout(timeoutId);
-          timeoutId = null;
+        // Fallback to known defaults if interactive detection fails
+        return {
+            defaultModel: this.getDefaultModelFallback(providerId),
+            availableModels: [this.getDefaultModelFallback(providerId)],
+            detectionMethod: 'fallback'
+        };
+    }
+    /**
+     * Parse model names from CLI output
+     */
+    parseModelsFromOutput(providerId, output) {
+        const models = [];
+        const lines = output.split('\n');
+        switch (providerId) {
+            case 'claude_code':
+                // Parse Claude Code output format
+                lines.forEach(line => {
+                    const matches = line.match(/claude-[\w\-.]+/gi);
+                    if (matches)
+                        models.push(...matches);
+                });
+                break;
+            case 'codex_cli':
+                // Parse Codex CLI output format
+                lines.forEach(line => {
+                    const matches = line.match(/gpt-[\w\-.]+|o1-[\w\-.]+/gi);
+                    if (matches)
+                        models.push(...matches);
+                });
+                break;
+            case 'gemini_cli':
+                // Parse Gemini CLI output format
+                lines.forEach(line => {
+                    const matches = line.match(/gemini-[\w\-.]+/gi);
+                    if (matches)
+                        models.push(...matches);
+                });
+                break;
         }
-      };
-
-      timeoutId = setTimeout(() => {
-        cleanup();
-        if (!child.killed) {
-          child.kill('SIGTERM');
-          // Force kill after 2 seconds if still running
-          setTimeout(() => {
-            if (!child.killed) {
-              child.kill('SIGKILL');
-            }
-          }, 2000);
+        return [...new Set(models)]; // Remove duplicates
+    }
+    /**
+     * Extract the default model from available models
+     */
+    extractDefaultModel(providerId, models) {
+        if (models.length === 0)
+            return this.getDefaultModelFallback(providerId);
+        switch (providerId) {
+            case 'claude_code':
+                // Prefer Claude 3.5 Sonnet, then Claude 3 Sonnet
+                return models.find(m => m.includes('claude-3-5-sonnet')) ||
+                    models.find(m => m.includes('claude-3-sonnet')) ||
+                    models[0];
+            case 'codex_cli':
+                // Prefer GPT-4, then GPT-3.5
+                return models.find(m => m.includes('gpt-4')) || models[0];
+            case 'gemini_cli':
+                // Prefer Gemini Pro, then Gemini Flash
+                return models.find(m => m.includes('gemini-1.5-pro')) ||
+                    models.find(m => m.includes('gemini-pro')) ||
+                    models[0];
         }
-        reject(new Error(`Command timeout after ${timeoutMs}ms`));
-      }, timeoutMs);
-
-      child.on('close', () => {
-        cleanup();
-      });
-
-      child.on('exit', () => {
-        cleanup();
-      });
-    });
-  }
-
-  cleanCliResponse(response) {
-    const cleanResponse = response.replace(/\x1b\[[0-9;]*m/g, '');
-    
-    return cleanResponse
-      .replace(/^(\s*>\s*|\s*$)/gm, '')
-      .replace(/\n{3,}/g, '\n\n')
-      .trim();
-  }
-
-  estimateTokens(text) {
-    return Math.ceil(text.length / 4);
-  }
-
-  getAvailableProviders() {
-    return Array.from(this.providers.values());
-  }
-
-  getProvider(providerId) {
-    return this.providers.get(providerId);
-  }
+        return models[0];
+    }
+    /**
+     * Get fallback default model for a provider
+     */
+    getDefaultModelFallback(providerId) {
+        const fallbacks = {
+            'claude_code': 'claude-3-sonnet',
+            'codex_cli': 'gpt-4',
+            'gemini_cli': 'gemini-pro'
+        };
+        return fallbacks[providerId] || 'unknown';
+    }
 }
-
-module.exports = { CLIManager, default: CLIManager };
+exports.CLIManager = CLIManager;
+exports.default = CLIManager;

package/lib/cliManager.ts

@@ -75,12 +75,12 @@ export class CLIManager {
         name: 'Codex CLI',
         executable: 'codex',
         versionCommand: 'codex --version',
-        authCheckCommand: 'codex auth status',
-        chatCommand: 'codex chat',
-        supportsStdin: true,
+        authCheckCommand: 'codex login --check',  // Changed to check login status
+        chatCommand: 'codex exec',  // Changed from 'codex chat' to 'codex exec'
+        supportsStdin: false,  // Codex exec doesn't use stdin
         supportsArgs: true,
-        installInstructions: 'Install Codex CLI from OpenAI',
-        authInstructions: 'Authenticate with: codex auth'
+        installInstructions: 'Install via: npm install -g codex-cli',
+        authInstructions: 'Authenticate with: codex login'
       },
       {
         id: 'gemini_cli',

package/mcp/package.json

@@ -1,6 +1,6 @@
 {
   "name": "polydev-ai",
-  "version": "1.2.6",
+  "version": "1.2.8",
   "description": "Get diverse AI perspectives from multiple LLMs via MCP - supports Cline, Claude Code, and other MCP clients",
   "main": "stdio-wrapper.js",
   "bin": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "polydev-ai",
-  "version": "1.2.7",
+  "version": "1.2.8",
   "description": "Agentic workflow assistant with CLI integration - get diverse perspectives from multiple LLMs when stuck or need enhanced reasoning",
   "keywords": [
     "mcp",