@mmmbuto/nexuscli 0.5.0

package/lib/server/services/codex-output-parser.js

@@ -0,0 +1,277 @@
+/**
+ * Output Parser for Codex CLI JSON Stream
+ * Parses `codex exec --json` JSONL output
+ *
+ * JSON Event Types from Codex:
+ * - thread.started: Thread initialization with thread_id
+ * - turn.started: Turn begins
+ * - item.started: Item in progress (command_execution with status: in_progress)
+ * - item.completed: Item finished (reasoning, agent_message, command_execution)
+ * - turn.completed: Turn finished with usage stats
+ * - turn.failed: Turn failed with error
+ *
+ * Emits SSE events:
+ * - status (category: tool, reasoning, system) -> for StatusBar
+ * - response_chunk -> text content for chat
+ * - response_done -> final text
+ * - done -> completion with usage
+ * - error -> error message
+ */
+
+class CodexOutputParser {
+  constructor() {
+    this.buffer = '';
+    this.finalResponse = '';
+    this.usage = null;
+    this.threadId = null;
+    this.pendingCommands = new Map(); // Track in-progress commands
+  }
+
+  /**
+   * Parse a chunk of stdout (may contain multiple JSON lines)
+   * @param {string} chunk - Raw stdout chunk from node-pty
+   * @returns {Array} Array of event objects for SSE
+   */
+  parse(chunk) {
+    const events = [];
+
+    // Add chunk to buffer
+    this.buffer += chunk;
+
+    // Process complete lines
+    const lines = this.buffer.split('\n');
+    this.buffer = lines.pop() || ''; // Keep incomplete last line
+
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+
+      // Skip non-JSON lines (e.g., "Reading prompt from stdin...")
+      if (!trimmed.startsWith('{')) {
+        console.log('[CodexOutputParser] Non-JSON line (ignored):', trimmed.substring(0, 80));
+        continue;
+      }
+
+      try {
+        const json = JSON.parse(trimmed);
+        const lineEvents = this.parseJsonEvent(json);
+        events.push(...lineEvents);
+      } catch (e) {
+        console.log('[CodexOutputParser] JSON parse error:', e.message, '- Line:', trimmed.substring(0, 100));
+      }
+    }
+
+    return events;
+  }
+
+  /**
+   * Parse a single JSON event from Codex
+   * @param {Object} event - Parsed JSON object
+   * @returns {Array} Events to emit
+   */
+  parseJsonEvent(event) {
+    const events = [];
+
+    switch (event.type) {
+      case 'thread.started':
+        this.threadId = event.thread_id;
+        console.log('[CodexOutputParser] Thread started:', this.threadId);
+        events.push({
+          type: 'status',
+          category: 'system',
+          message: 'Session started',
+          icon: '🚀',
+          timestamp: new Date().toISOString(),
+        });
+        break;
+
+      case 'turn.started':
+        console.log('[CodexOutputParser] Turn started');
+        break;
+
+      case 'item.started':
+        // Command execution starting
+        if (event.item?.type === 'command_execution') {
+          const cmd = event.item.command || 'Unknown command';
+          this.pendingCommands.set(event.item.id, event.item);
+
+          events.push({
+            type: 'status',
+            category: 'tool',
+            message: `Bash: ${this.truncate(cmd, 60)}`,
+            icon: '🔧',
+            timestamp: new Date().toISOString(),
+          });
+        }
+        break;
+
+      case 'item.completed':
+        if (!event.item) break;
+
+        switch (event.item.type) {
+          case 'reasoning':
+            // Reasoning/thinking
+            const reasoningText = event.item.text || '';
+            if (reasoningText.trim()) {
+              events.push({
+                type: 'status',
+                category: 'reasoning',
+                message: `Thinking: ${this.truncate(reasoningText, 50)}`,
+                icon: '🧠',
+                timestamp: new Date().toISOString(),
+              });
+            }
+            break;
+
+          case 'command_execution':
+            // Command completed
+            const cmd = event.item.command || 'command';
+            const exitCode = event.item.exit_code;
+            const status = exitCode === 0 ? 'completed' : `failed (${exitCode})`;
+
+            events.push({
+              type: 'status',
+              category: 'tool',
+              message: `Bash: ${this.truncate(cmd, 40)} - ${status}`,
+              icon: exitCode === 0 ? '✅' : '❌',
+              toolOutput: this.truncateOutput(event.item.aggregated_output),
+              timestamp: new Date().toISOString(),
+            });
+
+            this.pendingCommands.delete(event.item.id);
+            break;
+
+          case 'agent_message':
+            // Final response text
+            const text = event.item.text || '';
+            if (text.trim()) {
+              this.finalResponse = text;
+              events.push({
+                type: 'response_chunk',
+                text: text,
+                isIncremental: false,
+              });
+            }
+            break;
+
+          case 'file_read':
+            events.push({
+              type: 'status',
+              category: 'tool',
+              message: `Reading: ${this.truncate(event.item.path || '', 50)}`,
+              icon: '📖',
+              timestamp: new Date().toISOString(),
+            });
+            break;
+
+          case 'file_write':
+            events.push({
+              type: 'status',
+              category: 'tool',
+              message: `Writing: ${this.truncate(event.item.path || '', 50)}`,
+              icon: '✍️',
+              timestamp: new Date().toISOString(),
+            });
+            break;
+
+          case 'file_edit':
+            events.push({
+              type: 'status',
+              category: 'tool',
+              message: `Editing: ${this.truncate(event.item.path || '', 50)}`,
+              icon: '📝',
+              timestamp: new Date().toISOString(),
+            });
+            break;
+
+          default:
+            console.log('[CodexOutputParser] Unknown item type:', event.item.type);
+        }
+        break;
+
+      case 'turn.completed':
+        // Turn finished with usage
+        this.usage = event.usage || null;
+        console.log('[CodexOutputParser] Turn completed, usage:', JSON.stringify(this.usage));
+
+        // Emit response_done
+        events.push({
+          type: 'response_done',
+          fullText: this.finalResponse,
+        });
+
+        // Emit done with usage
+        events.push({
+          type: 'done',
+          usage: {
+            prompt_tokens: this.usage?.input_tokens || 0,
+            completion_tokens: this.usage?.output_tokens || 0,
+            total_tokens: (this.usage?.input_tokens || 0) + (this.usage?.output_tokens || 0),
+            cached_tokens: this.usage?.cached_input_tokens || 0,
+          },
+          threadId: this.threadId,
+        });
+        break;
+
+      case 'turn.failed':
+        console.error('[CodexOutputParser] Turn failed:', event.error);
+        events.push({
+          type: 'error',
+          message: event.error || 'Unknown error',
+        });
+        break;
+
+      default:
+        console.log('[CodexOutputParser] Unknown event type:', event.type);
+    }
+
+    return events;
+  }
+
+  /**
+   * Truncate string to max length
+   */
+  truncate(str, maxLen) {
+    if (!str) return '';
+    if (str.length <= maxLen) return str;
+    return str.substring(0, maxLen) + '...';
+  }
+
+  /**
+   * Truncate tool output (can be very long)
+   */
+  truncateOutput(content) {
+    if (!content) return null;
+    const str = typeof content === 'string' ? content : JSON.stringify(content);
+    if (str.length > 500) {
+      return str.substring(0, 500) + '\n... (truncated)';
+    }
+    return str;
+  }
+
+  /**
+   * Get accumulated final response
+   */
+  getFinalResponse() {
+    return this.finalResponse;
+  }
+
+  /**
+   * Get usage statistics
+   */
+  getUsage() {
+    return this.usage;
+  }
+
+  /**
+   * Reset parser state for new request
+   */
+  reset() {
+    this.buffer = '';
+    this.finalResponse = '';
+    this.usage = null;
+    this.pendingCommands.clear();
+  }
+}
+
+module.exports = CodexOutputParser;

package/lib/server/services/codex-wrapper.js

@@ -0,0 +1,224 @@
+/**
+ * Codex CLI Wrapper for NexusCLI (Termux)
+ * Uses `codex exec --json` for non-interactive JSONL output
+ *
+ * Based on NexusChat codex-cli-wrapper.js pattern
+ * Requires: codex-cli 0.62.1+ with exec subcommand
+ */
+
+const { spawn, exec } = require('child_process');
+const CodexOutputParser = require('./codex-output-parser');
+
+class CodexWrapper {
+  constructor(options = {}) {
+    this.workspaceDir = options.workspaceDir || process.cwd();
+    this.codexBin = options.codexBin || 'codex';
+
+    // Track active sessions
+    this.activeSessions = new Set();
+
+    console.log('[CodexWrapper] Initialized');
+    console.log('[CodexWrapper] Workspace:', this.workspaceDir);
+    console.log('[CodexWrapper] Binary:', this.codexBin);
+  }
+
+  /**
+   * Send message and get response with streaming events
+   * @param {Object} options - Message options
+   * @param {string} options.prompt - User prompt
+   * @param {string} options.model - Model name (e.g., gpt-5.1-codex-max)
+   * @param {string} options.sessionId - Session ID for conversation continuity
+   * @param {string} options.reasoningEffort - Reasoning level (low, medium, high, xhigh)
+   * @param {string} options.workspacePath - Working directory override
+   * @param {string[]} options.imageFiles - Array of image file paths for multimodal
+   * @param {Function} options.onStatus - Callback for status events
+   * @returns {Promise<Object>} Response with text, usage
+   */
+  async sendMessage({ prompt, model, sessionId, reasoningEffort, workspacePath, imageFiles = [], onStatus }) {
+    return new Promise((resolve, reject) => {
+      const parser = new CodexOutputParser();
+      const cwd = workspacePath || this.workspaceDir;
+
+      // Build CLI arguments
+      const args = [
+        'exec',
+        '--json',                                    // JSONL output for parsing
+        '--skip-git-repo-check',                     // Allow non-git directories
+        '--dangerously-bypass-approvals-and-sandbox', // Full access (safety via CLAUDE.md policy)
+        '-C', cwd,                                   // Working directory
+      ];
+
+      // Add model if specified
+      if (model) {
+        const baseModel = this.extractBaseModel(model);
+        args.push('-m', baseModel);
+      }
+
+      // Add reasoning effort config override
+      if (reasoningEffort) {
+        args.push('-c', `model_reasoning_effort="${reasoningEffort}"`);
+      }
+
+      // Add image files for multimodal support
+      if (imageFiles && imageFiles.length > 0) {
+        for (const imagePath of imageFiles) {
+          args.push('-i', imagePath);
+        }
+        console.log('[CodexWrapper] Attached', imageFiles.length, 'image(s)');
+      }
+
+      // Add prompt as argument (use '--' to separate from options)
+      args.push('--', prompt);
+
+      console.log('[CodexWrapper] Model:', model);
+      console.log('[CodexWrapper] Reasoning:', reasoningEffort);
+      console.log('[CodexWrapper] Session:', sessionId);
+      console.log('[CodexWrapper] CWD:', cwd);
+      console.log('[CodexWrapper] Args:', args.slice(0, 6).join(' ') + '...');
+
+      let stdout = '';
+
+      const proc = spawn(this.codexBin, args, {
+        cwd: cwd,
+        env: {
+          ...global.process.env,
+          TERM: 'xterm-256color',
+        },
+      });
+
+      proc.stdout.on('data', (data) => {
+        const str = data.toString();
+        stdout += str;
+        this.handleOutput(str, parser, onStatus);
+      });
+
+      proc.stderr.on('data', (data) => {
+        console.error('[CodexWrapper] stderr:', data.toString());
+      });
+
+      proc.on('close', (exitCode) => {
+        clearTimeout(timeout);
+        this.handleExit(exitCode, stdout, parser, prompt, resolve, reject);
+      });
+
+      // Timeout after 10 minutes
+      const timeout = setTimeout(() => {
+        console.error('[CodexWrapper] Timeout after 10 minutes');
+        proc.kill('SIGTERM');
+        reject(new Error('Codex CLI timeout'));
+      }, 600000);
+    });
+  }
+
+  /**
+   * Handle output data from CLI
+   */
+  handleOutput(data, parser, onStatus) {
+    // Clean ANSI escape codes
+    const cleanData = data
+      .replace(/\x1B\[[0-9;]*[a-zA-Z]/g, '')
+      .replace(/\x1B\[\?[0-9;]*[a-zA-Z]/g, '')
+      .replace(/\r/g, '');
+
+    // Parse and emit events
+    if (onStatus && cleanData.trim()) {
+      try {
+        const events = parser.parse(cleanData);
+        if (events.length > 0) {
+          console.log('[CodexWrapper] Parsed', events.length, 'events');
+        }
+        events.forEach(event => {
+          console.log('[CodexWrapper] → Emitting:', event.type, '-', event.category || '', '-', (event.message || event.text || '').substring(0, 50));
+          onStatus(event);
+        });
+      } catch (parseError) {
+        console.error('[CodexWrapper] Parser error:', parseError.message);
+      }
+    }
+  }
+
+  /**
+   * Handle process exit
+   */
+  handleExit(exitCode, stdout, parser, prompt, resolve, reject) {
+    console.log('[CodexWrapper] Exit code:', exitCode);
+
+    if (exitCode !== 0 && exitCode !== null) {
+      console.error('[CodexWrapper] Error output:', stdout.substring(0, 500));
+      reject(new Error(`Codex CLI error (exit ${exitCode}): ${stdout.substring(0, 200)}`));
+      return;
+    }
+
+    const finalResponse = parser.getFinalResponse();
+    const usage = parser.getUsage();
+
+    console.log('[CodexWrapper] Final response length:', finalResponse.length);
+
+    // Calculate token counts (fallback)
+    const promptTokens = usage?.input_tokens || Math.ceil(prompt.length / 4);
+    const completionTokens = usage?.output_tokens || Math.ceil(finalResponse.length / 4);
+
+    resolve({
+      text: finalResponse,
+      usage: {
+        prompt_tokens: promptTokens,
+        completion_tokens: completionTokens,
+        total_tokens: promptTokens + completionTokens,
+        cached_tokens: usage?.cached_input_tokens || 0,
+      },
+    });
+  }
+
+  /**
+   * Extract base model name (without reasoning suffix)
+   * The CLI uses model name + config override for reasoning
+   */
+  extractBaseModel(modelName) {
+    // Remove reasoning suffixes to get base model for CLI
+    return modelName
+      .replace(/-low$/, '')
+      .replace(/-medium$/, '')
+      .replace(/-high$/, '')
+      .replace(/-xhigh$/, '')
+      // Legacy suffixes
+      .replace(/-fast$/, '')
+      .replace(/-balanced$/, '')
+      .replace(/-instant$/, '');
+  }
+
+  /**
+   * Check if Codex CLI is available
+   */
+  async isAvailable() {
+    return new Promise((resolve) => {
+      exec(`${this.codexBin} --version`, (error, stdout) => {
+        if (error) {
+          console.log('[CodexWrapper] Codex CLI not available:', error.message);
+          resolve(false);
+        } else {
+          console.log('[CodexWrapper] Codex CLI version:', stdout.trim());
+          resolve(true);
+        }
+      });
+    });
+  }
+
+  /**
+   * Check if exec subcommand is available
+   */
+  async hasExecSupport() {
+    return new Promise((resolve) => {
+      exec(`${this.codexBin} exec --help`, (error, stdout) => {
+        if (error) {
+          console.log('[CodexWrapper] exec subcommand not available');
+          resolve(false);
+        } else {
+          console.log('[CodexWrapper] exec subcommand available');
+          resolve(true);
+        }
+      });
+    });
+  }
+}
+
+module.exports = CodexWrapper;