polydev-ai 1.2.14 → 1.2.15

package/lib/cliManager.ts

@@ -10,7 +10,6 @@ import * as path from 'path'
 import * as fs from 'fs'
 import * as os from 'os'
 const which = require('which')
-const shell = require('shelljs')
 
 const execAsync = promisify(exec)
 
@@ -20,8 +19,8 @@ export interface CLIProvider {
   executable: string
   versionCommand: string
   authCheckCommand: string
-  chatCommand: string
-  supportsStdin: boolean
+  chatCommand: string | string[]
+  alternateChatCommands?: Array<string | string[]>
   supportsArgs: boolean
   installInstructions: string
   authInstructions: string
@@ -45,6 +44,7 @@ export interface CLIResponse {
   error?: string
   tokensUsed?: number
   latencyMs?: number
+  mode?: 'stdin' | 'args'
 }
 
 export class CLIManager {
@@ -64,8 +64,7 @@ export class CLIManager {
         executable: 'claude',
         versionCommand: 'claude --version',
         authCheckCommand: 'claude auth status',
-        chatCommand: 'claude chat',
-        supportsStdin: true,
+        chatCommand: ['claude', 'chat'],
         supportsArgs: true,
         installInstructions: 'Install via: npm install -g @anthropic-ai/claude-code',
         authInstructions: 'Authenticate with: claude auth login'
@@ -75,12 +74,16 @@ export class CLIManager {
         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
+        authCheckCommand: 'codex auth status',
+        chatCommand: ['exec'],
+        alternateChatCommands: [
+          ['chat'],
+          ['prompt'],
+          ['ask']
+        ],
         supportsArgs: true,
-        installInstructions: 'Install via: npm install -g codex-cli',
-        authInstructions: 'Authenticate with: codex login'
+        installInstructions: 'Install Codex CLI from OpenAI',
+        authInstructions: 'Authenticate with: codex auth'
       },
       {
         id: 'gemini_cli',
@@ -88,8 +91,7 @@ export class CLIManager {
         executable: 'gemini',
         versionCommand: 'gemini --version',
         authCheckCommand: 'gemini auth status',
-        chatCommand: 'gemini chat',
-        supportsStdin: true,
+        chatCommand: ['gemini', 'chat'],
         supportsArgs: true,
         installInstructions: 'Install Gemini CLI from Google',
         authInstructions: 'Authenticate with: gemini auth login'
@@ -197,19 +199,56 @@ export class CLIManager {
       }
     }
 
+    if (providerId === 'codex_cli' && timeoutMs < 90000) {
+      timeoutMs = 90000
+    }
+
     const startTime = Date.now()
 
     try {
-      let result: string
+      const commandVariants = [
+        this.normalizeCommand(provider.chatCommand),
+        ...(provider.alternateChatCommands || []).map(cmd => this.normalizeCommand(cmd))
+      ].filter(parts => parts.length > 0)
 
-      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 {
+      if (commandVariants.length === 0) {
+        throw new Error(`${provider.name} does not have a valid chat command configured`)
+      }
+
+      if (provider.id === 'codex_cli') {
+        const execArgs = commandVariants.find(parts => parts.includes('exec')) || commandVariants[0]
+        const result = await this.executeCodexExec(provider.executable, execArgs, prompt, timeoutMs)
+        return {
+          success: true,
+          content: result,
+          latencyMs: Date.now() - startTime,
+          mode: 'args'
+        }
+      }
+
+      let result: string | undefined
+      let effectiveMode: 'stdin' | 'args' = 'args'
+      let lastError: Error | undefined
+
+      for (const commandParts of commandVariants) {
+        if (!provider.supportsArgs) {
+          lastError = new Error(`${provider.name} does not support args mode`)
+          continue
+        }
+
+        try {
+          result = await this.sendPromptViaArgs(commandParts, prompt, timeoutMs)
+          break
+        } catch (error) {
+          lastError = error instanceof Error ? error : new Error(String(error))
+        }
+      }
+
+      if (typeof result !== 'string') {
         return {
           success: false,
-          error: `${provider.name} does not support ${mode} mode`
+          error: lastError?.message || 'CLI execution failed',
+          latencyMs: Date.now() - startTime
         }
       }
 
@@ -218,7 +257,8 @@ export class CLIManager {
       return {
         success: true,
         content: result,
-        latencyMs
+        latencyMs,
+        mode: effectiveMode
       }
 
     } catch (error) {
@@ -310,67 +350,212 @@ export class CLIManager {
     }
   }
 
-  /**
-   * Send prompt via stdin mode
-   */
-  private async sendPromptViaStdin(
-    provider: CLIProvider,
+  private normalizeCommand(command: string | string[]): string[] {
+    if (Array.isArray(command)) {
+      return command.map(part => part.trim()).filter(Boolean)
+    }
+    return command.split(/\s+/).map(part => part.trim()).filter(Boolean)
+  }
+
+  private async sendPromptViaArgs(
+    commandParts: string[],
     prompt: string,
     timeoutMs: number
   ): Promise<string> {
+    if (commandParts.length === 0) {
+      throw new Error('Invalid CLI command configuration')
+    }
+
+    const [executable, ...baseArgs] = commandParts
+    const args = [...baseArgs, prompt]
+
+    if (process.env.POLYDEV_CLI_DEBUG) {
+      console.log(`[CLI Debug] Executing (args) ${executable} ${args.join(' ')}`)
+    }
+
     return new Promise((resolve, reject) => {
-      const child = spawn(provider.chatCommand, [], {
+      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'],
-        timeout: timeoutMs
+        shell: process.platform === 'win32',
+        env: {
+          ...process.env,
+          TMPDIR: tmpDir,
+          TEMP: tmpDir,
+          TMP: tmpDir
+        }
       })
 
+      console.log(`[CLI Debug] Spawning Codex process: ${executable} ${args.join(' ')}`)
+
+      // No stdin needed for exec mode; close immediately to avoid hangs.
+      if (child.stdin) {
+        child.stdin.end()
+      }
+
       let stdout = ''
       let stderr = ''
+      let finished = false
+
+      const timeoutHandle = setTimeout(() => {
+        if (!finished) {
+          finished = true
+          try {
+            child.kill('SIGTERM')
+            setTimeout(() => {
+              if (!child.killed) {
+                child.kill('SIGKILL')
+              }
+            }, 1500)
+          } catch {}
+          reject(new Error(`CLI command timeout after ${timeoutMs}ms`))
+        }
+      }, timeoutMs)
 
-      child.stdout?.on('data', (data) => {
+      child.stdout?.on('data', data => {
         stdout += data.toString()
       })
 
-      child.stderr?.on('data', (data) => {
+      child.stderr?.on('data', data => {
         stderr += data.toString()
       })
 
-      child.on('close', (code) => {
+      child.on('close', code => {
+        if (finished) return
+        finished = true
+        clearTimeout(timeoutHandle)
+
+        if (process.env.POLYDEV_CLI_DEBUG) {
+          console.log(`[CLI Debug] (args) exit code ${code}`)
+          if (stdout) console.log(`[CLI Debug] stdout: ${stdout.trim().slice(0, 500)}`)
+          if (stderr) console.log(`[CLI Debug] stderr: ${stderr.trim().slice(0, 500)}`)
+        }
+
+        const trimmedStdout = stdout.trim()
+        const trimmedStderr = stderr.trim()
+
         if (code === 0) {
-          resolve(stdout.trim())
+          resolve(trimmedStdout || trimmedStderr)
         } else {
-          reject(new Error(`CLI exited with code ${code}: ${stderr}`))
+          const message = trimmedStderr || trimmedStdout || `CLI command failed (code ${code})`
+          reject(new Error(message))
         }
       })
 
-      child.on('error', (error) => {
+      child.on('error', error => {
+        if (finished) return
+        finished = true
+        clearTimeout(timeoutHandle)
         reject(error)
       })
-
-      // Send prompt via stdin
-      if (child.stdin) {
-        child.stdin.write(prompt)
-        child.stdin.end()
-      }
     })
   }
 
-  /**
-   * Send prompt via command arguments
-   */
-  private async sendPromptViaArgs(
-    provider: CLIProvider,
+  private async executeCodexExec(
+    executable: string,
+    commandArgs: string[],
     prompt: string,
     timeoutMs: number
   ): Promise<string> {
-    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}`)
+    if (!executable) {
+      throw new Error('Missing Codex executable')
     }
+
+    if (!commandArgs || commandArgs.length === 0) {
+      throw new Error('Invalid Codex command configuration')
+    }
+
+    const workingDir = process.cwd()
+    const args = [
+      ...commandArgs,
+      '--sandbox',
+      'workspace-write',
+      '--skip-git-repo-check',
+      '--cd',
+      workingDir,
+      prompt
+    ]
+
+    return new Promise((resolve, reject) => {
+      const child = spawn(executable, args, {
+        stdio: ['pipe', 'pipe', 'pipe'],
+        shell: process.platform === 'win32'
+      })
+
+      if (child.stdin) {
+        child.stdin.end()
+      }
+
+      let stdout = ''
+      let stderr = ''
+      let resolved = false
+
+      const stop = (handler: () => void) => {
+        if (!resolved) {
+          resolved = true
+          try {
+            child.kill('SIGTERM')
+          } catch {}
+          handler()
+        }
+      }
+
+      const timeoutHandle = setTimeout(() => {
+        stop(() => reject(new Error(`Codex exec timeout after ${timeoutMs}ms`)))
+      }, timeoutMs)
+
+      const flushIfComplete = () => {
+        const bulletMatch = stdout.match(/•\s*(.+)/)
+        if (bulletMatch && bulletMatch[1]) {
+          const answer = bulletMatch[1].trim()
+          clearTimeout(timeoutHandle)
+          stop(() => resolve(answer))
+        }
+      }
+
+      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 bulletMatch = trimmedStdout.match(/•\s*(.+)/)
+          if (bulletMatch && bulletMatch[1]) {
+            resolve(bulletMatch[1].trim())
+            return
+          }
+          resolve(trimmedStdout)
+        } else {
+          reject(new Error(trimmedStderr || trimmedStdout || `Codex exited with code ${code}`))
+        }
+      })
+
+      child.on('error', error => {
+        if (resolved) return
+        resolved = true
+        clearTimeout(timeoutHandle)
+        reject(error)
+      })
+    })
   }
 
   /**

package/lib/zeroKnowledgeEncryption.js

@@ -81,7 +81,7 @@ class ZeroKnowledgeEncryption {
                     const keyData = cursor.value;
                     // Check if key needs rotation
                     if (new Date() > new Date(keyData.rotationDue)) {
-                        console.error('[ZK Encryption] Key rotation needed, generating new key');
+                        console.log('[ZK Encryption] Key rotation needed, generating new key');
                         await this.createAndStoreKey();
                     }
                     else {
@@ -214,7 +214,7 @@ class ZeroKnowledgeEncryption {
      */
     async rotateKeys() {
         await this.createAndStoreKey();
-        console.error('[ZK Encryption] Key rotation completed');
+        console.log('[ZK Encryption] Key rotation completed');
     }
     /**
      * Generate unique key ID
@@ -274,7 +274,7 @@ class ZeroKnowledgeEncryption {
         await transaction.objectStore('keys').clear();
         await transaction.objectStore('cache').clear();
         this.activeKey = null;
-        console.error('[ZK Encryption] All keys cleared');
+        console.log('[ZK Encryption] All keys cleared');
     }
 }
 exports.ZeroKnowledgeEncryption = ZeroKnowledgeEncryption;
@@ -286,4 +286,4 @@ ZeroKnowledgeEncryption.KEY_ROTATION_DAYS = 30;
 ZeroKnowledgeEncryption.DB_NAME = 'PolydevZKMemory';
 ZeroKnowledgeEncryption.DB_VERSION = 1;
 // Export singleton instance
-exports.zkEncryption = new ZeroKnowledgeEncryption();
+exports.zkEncryption = new ZeroKnowledgeEncryption();

package/mcp/manifest.json

@@ -1,6 +1,6 @@
 {
   "name": "polydev-perspectives",
-  "version": "1.2.14",
+  "version": "1.2.0",
   "description": "Agentic workflow assistant - get diverse perspectives from multiple LLMs when stuck or need enhanced reasoning",
   "author": "Polydev AI",
   "license": "MIT",
@@ -685,4 +685,4 @@
       "step_4": "Use the token in your MCP tool calls"
     }
   }
-}
+}

package/mcp/package.json

@@ -1,6 +1,6 @@
 {
   "name": "polydev-ai",
-  "version": "1.2.8",
+  "version": "1.2.6",
   "description": "Get diverse AI perspectives from multiple LLMs via MCP - supports Cline, Claude Code, and other MCP clients",
   "main": "stdio-wrapper.js",
   "bin": {
@@ -43,4 +43,4 @@
   "bugs": {
     "url": "https://github.com/backspacevenkat/polydev-website/issues"
   }
-}
+}

package/mcp/stdio-wrapper.js

@@ -3,27 +3,56 @@
 // Lightweight stdio wrapper with local CLI functionality and remote Polydev MCP server fallback
 const fs = require('fs');
 const path = require('path');
+const os = require('os');
 const { CLIManager } = require('../lib/cliManager');
 
+function ensureWritableTmpDir() {
+  const candidates = [
+    process.env.POLYDEV_TMPDIR,
+    '/tmp/polydev',
+    '/tmp',
+    path.join(os.tmpdir(), 'polydev'),
+    path.join(process.cwd(), '.polydev-tmp')
+  ].filter(Boolean);
+
+  for (const candidate of candidates) {
+    try {
+      fs.mkdirSync(candidate, { recursive: true });
+      fs.accessSync(candidate, fs.constants.W_OK);
+      return candidate;
+    } catch (error) {
+      console.warn(`[Stdio Wrapper] TMP candidate not writable (${candidate}):`, error.message);
+    }
+  }
+
+  console.error('[Stdio Wrapper] No writable TMP directory found; Codex CLI will fail.');
+  return null;
+}
+
+const writableTmp = ensureWritableTmpDir();
+if (writableTmp) {
+  process.env.TMPDIR = writableTmp;
+  process.env.TMP = writableTmp;
+  process.env.TEMP = writableTmp;
+  console.error(`[Stdio Wrapper] Using TMP directory: ${writableTmp}`);
+}
+
 class StdioMCPWrapper {
   constructor() {
     this.userToken = process.env.POLYDEV_USER_TOKEN;
-    // Don't exit immediately - wait for initialization to report error properly
-    
-    // Initialize CLI Manager for local CLI functionality (only if token exists)
-    if (this.userToken) {
-      this.cliManager = new CLIManager();
+    if (!this.userToken) {
+      console.error('POLYDEV_USER_TOKEN environment variable is required');
+      process.exit(1);
     }
     
+    // Initialize CLI Manager for local CLI functionality
+    this.cliManager = new CLIManager();
+    
     // Load manifest for tool definitions
     this.loadManifest();
     
     // Smart refresh scheduler (will be started after initialization)
     this.refreshScheduler = null;
-    
-    // Track if initial CLI detection has been done
-    this.initialDetectionDone = false;
-    this.initialDetectionPromise = null;
   }
 
   loadManifest() {
@@ -69,18 +98,6 @@ class StdioMCPWrapper {
           };
         
         case 'tools/call':
-          // Check if token is missing
-          if (!this.userToken) {
-            return {
-              jsonrpc: '2.0',
-              id,
-              error: {
-                code: -32603,
-                message: 'POLYDEV_USER_TOKEN environment variable is required. Please add it to your MCP configuration.'
-              }
-            };
-          }
-          
           // Handle CLI tools locally, forward others to remote server
           const toolName = params.name;
           if (toolName.startsWith('polydev.') && this.isCliTool(toolName)) {
@@ -230,10 +247,6 @@ class StdioMCPWrapper {
       // Update database with CLI status
       await this.updateCliStatusInDatabase(results);
       
-      // Mark initial detection as done
-      this.initialDetectionDone = true;
-      this.initialDetectionPromise = null;
-      
       return {
         success: true,
         results,
@@ -244,10 +257,6 @@ class StdioMCPWrapper {
 
     } catch (error) {
       console.error('[Stdio Wrapper] Local CLI detection error:', error);
-      // Mark as done even on error to prevent blocking
-      this.initialDetectionDone = true;
-      this.initialDetectionPromise = null;
-      
       return {
         success: false,
         error: error.message,
@@ -309,16 +318,6 @@ class StdioMCPWrapper {
     console.error(`[Stdio Wrapper] Local CLI prompt sending with perspectives`);
     
     try {
-      // Ensure initial CLI detection has completed before sending prompts
-      if (!this.initialDetectionDone && this.initialDetectionPromise) {
-        console.error('[Stdio Wrapper] Waiting for initial CLI detection to complete...');
-        await this.initialDetectionPromise;
-      } else if (!this.initialDetectionDone && !this.initialDetectionPromise) {
-        console.error('[Stdio Wrapper] Running initial CLI detection before sending prompt...');
-        this.initialDetectionPromise = this.localForceCliDetection({});
-        await this.initialDetectionPromise;
-      }
-      
       let { provider_id, prompt, mode = 'args', timeout_ms = 30000 } = args;
       
       // Ensure timeout_ms is valid (not undefined, null, Infinity, or negative)
@@ -402,18 +401,7 @@ class StdioMCPWrapper {
    */
   async getAllAvailableProviders() {
     try {
-      // Try to load from cache first to avoid re-detection
-      const cachedStatus = await this.loadLocalCliStatus();
-      let results;
-      
-      if (cachedStatus && Object.keys(cachedStatus).length > 0) {
-        console.error('[Stdio Wrapper] Using cached CLI status');
-        results = cachedStatus;
-      } else {
-        console.error('[Stdio Wrapper] No cached status, running detection');
-        results = await this.cliManager.forceCliDetection();
-      }
-      
+      const results = await this.cliManager.forceCliDetection();
       const availableProviders = [];
       
       // Priority order: claude_code > codex_cli > gemini_cli
@@ -894,7 +882,19 @@ class StdioMCPWrapper {
   }
 
   async start() {
-    console.error('[Stdio Wrapper] Starting Polydev Stdio MCP Wrapper...');
+    console.log('Starting Polydev Stdio MCP Wrapper...');
+    
+    // Run initial CLI detection on startup
+    console.error('[Stdio Wrapper] Running initial CLI detection...');
+    try {
+      await this.localForceCliDetection({});
+      console.error('[Stdio Wrapper] Initial CLI detection completed');
+    } catch (error) {
+      console.error('[Stdio Wrapper] Initial CLI detection failed:', error);
+    }
+    
+    // Start smart refresh scheduler for automatic updates
+    this.startSmartRefreshScheduler();
     
     process.stdin.setEncoding('utf8');
     let buffer = '';
@@ -919,46 +919,25 @@ class StdioMCPWrapper {
     });
 
     process.stdin.on('end', () => {
-      console.error('[Stdio Wrapper] Shutting down...');
+      console.log('Stdio MCP Wrapper shutting down...');
       this.stopSmartRefreshScheduler();
       process.exit(0);
     });
 
     // Handle process signals
     process.on('SIGINT', () => {
-      console.error('[Stdio Wrapper] Received SIGINT, shutting down...');
+      console.log('Received SIGINT, shutting down...');
       this.stopSmartRefreshScheduler();
       process.exit(0);
     });
 
     process.on('SIGTERM', () => {
-      console.error('[Stdio Wrapper] Received SIGTERM, shutting down...');
+      console.log('Received SIGTERM, shutting down...');
       this.stopSmartRefreshScheduler();
       process.exit(0);
     });
 
-    console.error('[Stdio Wrapper] Ready and listening on stdin...');
-    
-    // Run initial CLI detection AFTER stdin handler is set up
-    if (this.userToken && this.cliManager) {
-      console.error('[Stdio Wrapper] Scheduling initial CLI detection...');
-      // Run asynchronously after a short delay to not block initialization
-      setTimeout(async () => {
-        console.error('[Stdio Wrapper] Running initial CLI detection...');
-        try {
-          this.initialDetectionPromise = this.localForceCliDetection({});
-          await this.initialDetectionPromise;
-          console.error('[Stdio Wrapper] Initial CLI detection completed');
-        } catch (error) {
-          console.error('[Stdio Wrapper] Initial CLI detection failed:', error);
-        }
-        
-        // Start smart refresh scheduler for automatic updates
-        this.startSmartRefreshScheduler();
-      }, 100);
-    } else {
-      console.error('[Stdio Wrapper] No token provided - CLI detection disabled');
-    }
+    console.log('Stdio MCP Wrapper ready and listening on stdin...');
   }
 }