polydev-ai 1.2.13 → 1.2.15

package/lib/cliManager.js

@@ -1,508 +1,715 @@
-"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 { exec, spawn } = require('child_process');
+const { promisify } = require('util');
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
 const which = require('which');
-const shell = require('shelljs');
-const execAsync = (0, util_1.promisify)(child_process_1.exec);
+
+const execAsync = promisify(exec);
+
 class CLIManager {
-    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);
-        });
-    }
-    /**
-     * Force CLI detection for all providers or specific provider
-     * Updates status cache and reports to MCP server via Supabase
-     */
-    async forceCliDetection(userId, providerId) {
-        console.error(`[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.error(`[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;
-    }
-    /**
-     * 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] || {
+  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: ['chat'],
+          version: ['--version'],
+          auth_status: ['login', 'status'], // Correct command: codex login status
+          test_prompt: ['exec'],
+          alternate_test_prompts: [
+            ['prompt'],
+            ['ask']
+          ]
+        },
+        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,
-            lastChecked: now,
-            error: 'Provider not found'
-        };
+            error: `Detection failed: ${error.message}`,
+            last_checked: new Date()
+          };
+        }
+      }
     }
-    /**
-     * 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}`
-            };
+
+    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];
         }
-        // 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}`
-            };
+      }
+    }
+
+    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()
+        };
+      }
+
+      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);
         }
-        if (!status.authenticated) {
-            return {
-                success: false,
-                error: `${provider.name} is not authenticated. ${provider.authInstructions}`
-            };
+      }
+
+      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);
         }
-        const startTime = Date.now();
+      } else {
+        // For other providers, try command-based auth check first
         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);
-            }
-            else {
-                return {
-                    success: false,
-                    error: `${provider.name} does not support ${mode} mode`
-                };
-            }
-            const latencyMs = Date.now() - startTime;
-            return {
-                success: true,
-                content: result,
-                latencyMs
-            };
+          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);
+          }
         }
-        catch (error) {
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : 'CLI execution failed',
-                latencyMs: Date.now() - startTime
-            };
+      }
+
+      // 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}`;
+            }
+          } catch {
+            errorMessage = `Not authenticated. ${provider.auth_instructions}`;
+          }
+        } else {
+          errorMessage = `Not authenticated. ${provider.auth_instructions}`;
         }
+      }
+
+      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()
+      };
     }
-    /**
-     * 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);
+  }
+
+  async findCliPath(command) {
+    try {
+      return await which(command);
+    } catch (error) {
+      return null;
+    }
+  }
+
+  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
             }
+          }
+          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
         }
-        catch (error) {
-            return {
-                available: false,
-                authenticated: false,
-                lastChecked: new Date(),
-                error: `${provider.name} not found in PATH. ${provider.installInstructions}`
-            };
+        
+        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
+    }
+    if (providerId === 'codex_cli' && timeoutMs < 90000) {
+      timeoutMs = 90000;
+    }
+    
+    // Ensure timeoutMs is valid (not undefined, null, Infinity, or negative)
+    if (!timeoutMs || timeoutMs === Infinity || timeoutMs < 1 || timeoutMs > 300000) {
+      timeoutMs = 30000 // Default to 30 seconds
+    }
+    
+    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()
+        };
+      }
+
+      const promptVariants = [
+        provider.subcommands?.test_prompt ? [...provider.subcommands.test_prompt] : []
+      ];
+
+      if (Array.isArray(provider?.subcommands?.alternate_test_prompts)) {
+        for (const altArgs of provider.subcommands.alternate_test_prompts) {
+          promptVariants.push(Array.isArray(altArgs) ? [...altArgs] : []);
         }
-        // Check version
-        let version;
+      }
+
+      if (providerId === 'codex_cli') {
+        const execArgs = promptVariants.find(args => args.includes('exec')) || promptVariants[0];
         try {
-            const { stdout } = await execAsync(provider.versionCommand, { timeout: 10000 });
-            version = stdout.trim();
+          const content = await this.executeCodexExec(provider.command, execArgs, prompt, timeoutMs);
+          return {
+            success: true,
+            content,
+            tokens_used: this.estimateTokens(prompt + content),
+            latency_ms: Date.now() - startTime,
+            provider: providerId,
+            mode: 'args',
+            timestamp: new Date()
+          };
+        } catch (error) {
+          return {
+            success: false,
+            error: `CLI execution failed: ${error instanceof Error ? error.message : String(error)}`,
+            latency_ms: Date.now() - startTime,
+            provider: providerId,
+            mode,
+            timestamp: new Date()
+          };
         }
-        catch (error) {
+      }
+
+      let lastErrorMessage = null;
+
+      for (const promptArgs of promptVariants) {
+        const args = Array.isArray(promptArgs) ? [...promptArgs, prompt] : [prompt];
+        try {
+          const result = await this.executeCliCommand(
+            provider.command,
+            args,
+            'args',
+            timeoutMs,
+            undefined
+          );
+
+          if (!result.error) {
+            const content = this.cleanCliResponse(result.stdout || '');
             return {
-                available: false,
-                authenticated: false,
-                lastChecked: new Date(),
-                path: executablePath,
-                error: `Failed to get ${provider.name} version`
+              success: true,
+              content,
+              tokens_used: this.estimateTokens(prompt + content),
+              latency_ms: Date.now() - startTime,
+              provider: providerId,
+              mode: 'args',
+              timestamp: new Date()
             };
+          }
+
+          lastErrorMessage = result.error;
+        } catch (error) {
+          lastErrorMessage = error instanceof Error ? error.message : String(error);
         }
-        // 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
-        };
+      }
+
+      return {
+        success: false,
+        error: `CLI command failed: ${lastErrorMessage || 'Unknown error'}`,
+        latency_ms: Date.now() - startTime,
+        provider: providerId,
+        mode: 'args',
+        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()
+      };
     }
-    /**
-     * 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();
-            }
-        });
+  }
+
+  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
     }
-    /**
-     * 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();
+    
+    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: ['pipe', 'pipe', 'pipe'],
+        shell: process.platform === 'win32',
+        timeout: timeoutMs
+      });
+
+      if (child.stdin) {
+        child.stdin.end();
+      }
+
+      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}\n`);
+        child.stdin.end();
+      }
+
+      child.on('close', (code) => {
+        if (process.env.POLYDEV_CLI_DEBUG) {
+          console.log(`[CLI Debug] Command finished with code ${code}`);
         }
-        catch (error) {
-            throw new Error(`CLI command failed: ${error}`);
+
+        if (code === 0) {
+          resolve({ stdout, stderr });
+        } else {
+          const trimmedStdErr = stderr.trim();
+          const trimmedStdOut = stdout.trim();
+          const errorMessage = trimmedStdErr || trimmedStdOut || `Command exited with code ${code}`;
+          resolve({ 
+            stdout, 
+            stderr, 
+            error: errorMessage,
+            exit_code: code
+          });
         }
-    }
-    /**
-     * 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.error(`[CLI Manager] Updated database via MCP Supabase for ${providerId}: ${status.available}`);
+      });
+
+      child.on('error', (error) => {
+        if (process.env.POLYDEV_CLI_DEBUG) {
+          console.log(`[CLI Debug] Command error:`, error);
         }
-        catch (error) {
-            console.error(`[CLI Manager] Failed to update database via MCP Supabase:`, error);
+        reject(error);
+      });
+
+      let timeoutId;
+      const cleanup = () => {
+        if (timeoutId) {
+          clearTimeout(timeoutId);
+          timeoutId = null;
         }
+      };
+
+      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);
+        }
+        reject(new Error(`Command timeout after ${timeoutMs}ms`));
+      }, timeoutMs);
+
+      child.on('close', () => {
+        cleanup();
+      });
+
+      child.on('exit', () => {
+        cleanup();
+      });
+    });
+  }
+
+  async executeCodexExec(executable, commandArgs, prompt, timeoutMs) {
+    if (!executable) {
+      throw new Error('Missing Codex executable');
     }
-    /**
-     * 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'
-        };
-        return serverMap[providerId] || 'unknown-cli-bridge';
-    }
-    /**
-     * Get all CLI providers configuration
-     */
-    getProviders() {
-        return Array.from(this.providers.values());
-    }
-    /**
-     * Get provider by ID
-     */
-    getProvider(providerId) {
-        return this.providers.get(providerId);
+
+    if (!commandArgs || commandArgs.length === 0) {
+      throw new Error('Invalid Codex command configuration');
     }
-    /**
-     * 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'
-                    };
-                }
-            }
+
+    const workingDir = process.cwd();
+    const args = [
+      ...commandArgs,
+      '--sandbox',
+      'workspace-write',
+      '--skip-git-repo-check',
+      '--cd',
+      workingDir,
+      prompt
+    ];
+
+    return new Promise((resolve, reject) => {
+      const baseTmp = process.env.POLYDEV_CLI_TMPDIR || process.env.TMPDIR || os.tmpdir();
+      const tmpDir = path.join(baseTmp, 'polydev-codex');
+      try {
+        fs.mkdirSync(tmpDir, { recursive: true });
+      } catch (error) {
+        console.warn('[CLI Debug] Failed to create Codex temp dir:', error);
+      }
+
+      const child = spawn(executable, args, {
+        stdio: ['pipe', 'pipe', 'pipe'],
+        shell: process.platform === 'win32',
+        env: {
+          ...process.env,
+          TMPDIR: tmpDir,
+          TEMP: tmpDir,
+          TMP: tmpDir
         }
-        catch (error) {
-            console.error(`Interactive model detection failed for ${providerId}:`, error);
+      });
+
+      console.log(`[CLI Debug] Spawning Codex process: ${executable} ${args.join(' ')}`);
+
+      if (child.stdin) {
+        child.stdin.end();
+      }
+
+      let stdout = '';
+      let stderr = '';
+      let resolved = false;
+
+      const stop = (handler) => {
+        if (!resolved) {
+          resolved = true;
+          try { child.kill('SIGTERM'); } catch (_) {}
+          handler();
         }
-        // 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;
+      };
+
+      const timeoutHandle = setTimeout(() => {
+        stop(() => reject(new Error(`Codex exec timeout after ${timeoutMs}ms`)));
+      }, timeoutMs);
+
+      const flushIfComplete = () => {
+        const match = stdout.match(/•\s*(.+)/);
+        if (match && match[1]) {
+          clearTimeout(timeoutHandle);
+          stop(() => resolve(match[1].trim()));
         }
-        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];
+      };
+
+      child.stdout?.on('data', (data) => {
+        stdout += data.toString();
+        flushIfComplete();
+      });
+
+      child.stderr?.on('data', (data) => {
+        stderr += data.toString();
+      });
+
+      child.on('close', (code) => {
+        if (resolved) return;
+        resolved = true;
+        clearTimeout(timeoutHandle);
+
+        const trimmedStdout = stdout.trim();
+        const trimmedStderr = stderr.trim();
+
+        if (code === 0 && trimmedStdout) {
+          const match = trimmedStdout.match(/•\s*(.+)/);
+          if (match && match[1]) {
+            resolve(match[1].trim());
+            return;
+          }
+          resolve(trimmedStdout);
+        } else {
+          reject(new Error(trimmedStderr || trimmedStdout || `Codex exited with code ${code}`));
         }
-        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';
-    }
+      });
+
+      child.on('error', (error) => {
+        if (resolved) return;
+        resolved = true;
+        clearTimeout(timeoutHandle);
+        reject(error);
+      });
+    });
+  }
+
+  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);
+  }
 }
-exports.CLIManager = CLIManager;
-exports.default = CLIManager;
+
+module.exports = { CLIManager, default: CLIManager };