@mmmbuto/nexuscli 0.9.5 → 0.9.6

package/README.md

@@ -27,7 +27,13 @@ NexusCLI is a lightweight, Termux-first AI cockpit to orchestrate Claude Code, C
 
 ---
 
-## Highlights (v0.9.5)
+## Highlights (v0.9.6)
+
+- **Jobs Runner Restored**: `jobs` route works again after cleanup regression
+- **Termux-Safe Execution**: no hardcoded `/bin` or `/usr/bin` paths for job tools
+- **Cleaner Errors**: job SSE errors now display correctly in UI
+
+### v0.9.5
 
 - **GPT-5.2 Codex**: Added latest frontier agentic coding model as default
 - Updated Codex model catalog to match latest OpenAI CLI
@@ -57,7 +63,7 @@ NexusCLI is a lightweight, Termux-first AI cockpit to orchestrate Claude Code, C
 |--------|--------|----------|
 | **Claude (native)** | Opus 4.5, Sonnet 4.5, Haiku 4.5 | Anthropic |
 | **Claude-compatible** | DeepSeek (deepseek-*), GLM-4.6 | DeepSeek, Z.ai |
-| **Codex** | GPT-5.1, GPT-5.1 Codex (Mini/Max) | OpenAI |
+| **Codex** | GPT-5.2 Codex, GPT-5.2, GPT-5.1 Codex (Mini/Max), GPT-5.1 | OpenAI |
 | **Gemini** | Gemini 3 Pro Preview, Gemini 3 Flash Preview | Google |
 
 ---

package/lib/server/lib/cli-wrapper.js

@@ -0,0 +1,167 @@
+const pty = require('./pty-adapter');
+const OutputParser = require('./output-parser');
+
+/**
+ * CLI Wrapper - Generic CLI tool execution (adapted from NexusChat claude-wrapper)
+ * Spawns PTY processes for any CLI tool (bash, git, docker, python, etc.)
+ * Streams output via SSE
+ */
+class CliWrapper {
+  constructor(options = {}) {
+    this.workspaceDir = options.workspaceDir || process.cwd();
+    this.activeJobs = new Map();
+    this.defaultShell = process.env.SHELL || 'bash';
+    this.defaultPython = 'python3';
+    this.defaultNode = process.execPath || 'node';
+  }
+
+  /**
+   * Execute command via PTY
+   * @param {Object} params - { jobId, tool, command, workingDir, timeout, onStatus }
+   * @returns {Promise<Object>} - { exitCode, stdout, stderr, duration }
+   */
+  async execute({ jobId, tool = 'bash', command, workingDir, timeout = 30000, onStatus }) {
+    return new Promise((resolve, reject) => {
+      const parser = new OutputParser();
+      const startTime = Date.now();
+
+      // Determine shell command
+      let shellCmd = this.defaultShell;
+      let args = ['-c', command];
+
+      // Tool-specific handling
+      if (tool === 'bash') {
+        shellCmd = this.defaultShell;
+        args = ['-c', command];
+      } else if (tool === 'python') {
+        shellCmd = this.defaultPython;
+        args = ['-c', command];
+      } else if (tool === 'node') {
+        shellCmd = this.defaultNode;
+        args = ['-e', command];
+      } else {
+        // Generic: assume tool is in PATH
+        shellCmd = tool;
+        args = command.split(' ');
+      }
+
+      console.log(`[CliWrapper] Executing: ${tool} - ${command.substring(0, 50)}...`);
+      console.log(`[CliWrapper] Working dir: ${workingDir || this.workspaceDir}`);
+
+      // Spawn PTY process
+      let ptyProcess;
+      try {
+        ptyProcess = pty.spawn(shellCmd, args, {
+        name: 'xterm-color',
+        cols: 80,
+        rows: 30,
+        cwd: workingDir || this.workspaceDir,
+        env: process.env,
+      });
+      } catch (err) {
+        return reject(err);
+      }
+
+      this.activeJobs.set(jobId, ptyProcess);
+
+      let stdout = '';
+      let stderr = '';
+
+      // Handle timeout
+      const timer = setTimeout(() => {
+        console.log(`[CliWrapper] Job ${jobId} timeout`);
+        ptyProcess.kill('SIGTERM');
+
+        if (onStatus) {
+          onStatus({
+            type: 'error',
+            error: 'Command timeout exceeded',
+            timeout
+          });
+        }
+      }, timeout);
+
+      // Handle process errors
+      if (typeof ptyProcess.on === 'function') {
+        ptyProcess.on('error', (err) => {
+          console.error('[CliWrapper] Spawn error:', err);
+          reject(err);
+        });
+      } else if (typeof ptyProcess.onError === 'function') {
+        ptyProcess.onError((err) => {
+          console.error('[CliWrapper] Spawn error:', err);
+          reject(err);
+        });
+      }
+
+      // Handle output
+      ptyProcess.onData((data) => {
+        stdout += data;
+
+        // Parse output and emit status events
+        if (onStatus) {
+          try {
+            const events = parser.parse(data);
+            events.forEach(event => {
+              onStatus(event);
+            });
+          } catch (parseError) {
+            console.error('[CliWrapper] Parser error:', parseError);
+          }
+        }
+      });
+
+      // Handle exit
+      ptyProcess.onExit(({ exitCode }) => {
+        clearTimeout(timer);
+        this.activeJobs.delete(jobId);
+
+        const duration = Date.now() - startTime;
+
+        // Clean ANSI escape codes
+        const cleanStdout = stdout
+          .replace(/\x1B\[[0-9;]*[a-zA-Z]/g, '')  // ANSI codes
+          .replace(/\x1B\[\?[0-9;]*[a-zA-Z]/g, '') // Private modes
+          .trim();
+
+        console.log(`[CliWrapper] Job ${jobId} exit: ${exitCode} (${duration}ms)`);
+
+        if (exitCode !== 0) {
+          // Extract stderr (if any)
+          stderr = cleanStdout; // In PTY mode, stderr is mixed with stdout
+        }
+
+        resolve({
+          exitCode,
+          stdout: cleanStdout,
+          stderr,
+          duration
+        });
+      });
+    });
+  }
+
+  /**
+   * Kill running job
+   * @param {string} jobId - Job ID
+   */
+  kill(jobId) {
+    const ptyProcess = this.activeJobs.get(jobId);
+    if (ptyProcess) {
+      ptyProcess.kill('SIGTERM');
+      this.activeJobs.delete(jobId);
+      console.log(`[CliWrapper] Killed job ${jobId}`);
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Get active job count
+   */
+  getActiveJobCount() {
+    return this.activeJobs.size;
+  }
+}
+
+module.exports = CliWrapper;

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

@@ -0,0 +1,132 @@
+/**
+ * OutputParser - Parse CLI stdout/stderr into structured events
+ * Adapted from NexusChat output-parser.js
+ */
+class OutputParser {
+  constructor() {
+    this.state = 'idle';
+    this.buffer = '';
+    this.lineBuffer = '';
+  }
+
+  /**
+   * Regex patterns for detecting CLI output markers
+   */
+  static PATTERNS = {
+    // Tool execution patterns (generic)
+    toolExecution: /(?:Running|Executing)\s+(\w+)(?:\s+(?:command|tool))?:\s*(.+)/i,
+
+    // Common CLI patterns
+    errorPattern: /(?:Error|ERROR|Failed|FAILED|Exception):\s*(.+)/i,
+    warningPattern: /(?:Warning|WARNING|warn):\s*(.+)/i,
+
+    // ANSI escape codes
+    ansiCodes: /\x1B\[[0-9;]*[a-zA-Z]/g,
+    ansiPrivate: /\x1B\[\?[0-9;]*[a-zA-Z]/g,
+  };
+
+  /**
+   * Parse chunk of stdout and return array of events
+   * @param {string} chunk - Raw stdout chunk from PTY
+   * @returns {Array} Array of event objects
+   */
+  parse(chunk) {
+    const events = [];
+
+    // Add to buffer
+    this.buffer += chunk;
+    this.lineBuffer += chunk;
+
+    // Process line by line
+    const lines = this.lineBuffer.split('\n');
+    this.lineBuffer = lines.pop(); // Keep incomplete line
+
+    for (const line of lines) {
+      const lineEvents = this.parseLine(line);
+      events.push(...lineEvents);
+    }
+
+    // Also emit raw output chunks
+    const cleanChunk = this.cleanAnsi(chunk);
+    if (cleanChunk && cleanChunk.trim()) {
+      events.push({
+        type: 'output_chunk',
+        stream: 'stdout',
+        text: cleanChunk,
+        isIncremental: true,
+      });
+    }
+
+    return events;
+  }
+
+  /**
+   * Parse single line
+   * @param {string} line - Single line of output
+   * @returns {Array} Events from this line
+   */
+  parseLine(line) {
+    const events = [];
+    const cleanLine = this.cleanAnsi(line);
+
+    // Check for tool execution
+    const toolMatch = cleanLine.match(OutputParser.PATTERNS.toolExecution);
+    if (toolMatch) {
+      const [, tool, command] = toolMatch;
+      events.push({
+        type: 'status',
+        category: 'tool',
+        tool,
+        message: `${tool}: ${command.substring(0, 60)}${command.length > 60 ? '...' : ''}`,
+        icon: '🔧',
+        timestamp: new Date().toISOString(),
+      });
+    }
+
+    // Check for errors
+    if (OutputParser.PATTERNS.errorPattern.test(cleanLine)) {
+      const [, errorMsg] = cleanLine.match(OutputParser.PATTERNS.errorPattern);
+      events.push({
+        type: 'status',
+        category: 'warning',
+        message: `Error: ${errorMsg}`,
+        icon: '⚠️',
+        timestamp: new Date().toISOString(),
+      });
+    }
+
+    // Check for warnings
+    if (OutputParser.PATTERNS.warningPattern.test(cleanLine)) {
+      const [, warnMsg] = cleanLine.match(OutputParser.PATTERNS.warningPattern);
+      events.push({
+        type: 'status',
+        category: 'warning',
+        message: `Warning: ${warnMsg}`,
+        icon: '⚠️',
+        timestamp: new Date().toISOString(),
+      });
+    }
+
+    return events;
+  }
+
+  /**
+   * Clean ANSI escape codes from text
+   */
+  cleanAnsi(text) {
+    return text
+      .replace(OutputParser.PATTERNS.ansiCodes, '')
+      .replace(OutputParser.PATTERNS.ansiPrivate, '');
+  }
+
+  /**
+   * Reset parser state
+   */
+  reset() {
+    this.state = 'idle';
+    this.buffer = '';
+    this.lineBuffer = '';
+  }
+}
+
+module.exports = OutputParser;

package/lib/server/lib/pty-adapter.js

@@ -0,0 +1,81 @@
+/**
+ * PTY Adapter for NexusCLI (Termux)
+ * Provides node-pty-like interface using child_process.spawn
+ * Termux-only: no native node-pty compilation needed
+ *
+ * @version 0.5.0 - Added stdin support for interrupt (ESC key)
+ */
+
+const { spawn: cpSpawn } = require('child_process');
+
+/**
+ * Spawn a process with node-pty-like interface
+ * @param {string} command - Command to spawn
+ * @param {string[]} args - Arguments
+ * @param {Object} options - Spawn options (cwd, env)
+ * @returns {Object} PTY-like interface with onData, onExit, kill
+ */
+function spawn(command, args, options = {}) {
+  const proc = cpSpawn(command, args, {
+    cwd: options.cwd,
+    env: options.env,
+    shell: false,
+    stdio: ['pipe', 'pipe', 'pipe'],  // stdin enabled for interrupt support
+  });
+
+  const dataHandlers = [];
+  const exitHandlers = [];
+  const errorHandlers = [];
+
+  proc.stdout.on('data', (buf) => {
+    const data = buf.toString();
+    console.log('[PTY-Adapter] stdout:', data.substring(0, 200));
+    dataHandlers.forEach((fn) => fn(data));
+  });
+
+  proc.stderr.on('data', (buf) => {
+    const data = buf.toString();
+    console.log('[PTY-Adapter] stderr:', data.substring(0, 200));
+    dataHandlers.forEach((fn) => fn(data));
+  });
+
+  proc.on('close', (code) => {
+    exitHandlers.forEach((fn) => fn({ exitCode: code ?? 0 }));
+  });
+
+  proc.on('error', (err) => {
+    console.error('[PTY-Adapter] Error:', err.message);
+    errorHandlers.forEach((fn) => fn(err));
+  });
+
+  return {
+    onData: (fn) => dataHandlers.push(fn),
+    onExit: (fn) => exitHandlers.push(fn),
+    onError: (fn) => errorHandlers.push(fn),
+    write: (data) => proc.stdin?.writable && proc.stdin.write(data),
+    /**
+     * Send ESC key (0x1B) to interrupt CLI
+     * Used to gracefully stop Claude/Gemini CLI execution
+     * @returns {boolean} true if ESC was sent successfully
+     */
+    sendEsc: () => {
+      if (proc.stdin?.writable) {
+        proc.stdin.write('\x1B');
+        return true;
+      }
+      return false;
+    },
+    kill: (signal = 'SIGTERM') => proc.kill(signal),
+    pid: proc.pid,
+  };
+}
+
+/**
+ * Check if native PTY is available
+ * Always returns false on Termux (we use spawn adapter)
+ */
+function isPtyAvailable() {
+  return false;
+}
+
+module.exports = { spawn, isPtyAvailable };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mmmbuto/nexuscli",
-  "version": "0.9.5",
+  "version": "0.9.6",
   "description": "NexusCLI - TRI CLI Control Plane (Claude/Codex/Gemini)",
   "main": "lib/server/server.js",
   "bin": {