@mmmbuto/nexuscli 0.9.5 → 0.9.7-termux

package/README.md

@@ -8,7 +8,7 @@
 
 ## Overview
 
-NexusCLI is a lightweight, Termux-first AI cockpit to orchestrate Claude Code, Codex CLI, and Gemini CLI from a single web/terminal UI. It supports live interrupts, native session resume, and voice input with HTTPS auto-setup for remote devices.
+NexusCLI is a lightweight, Termux-first AI cockpit to orchestrate Claude Code, Codex CLI, Gemini CLI, and Qwen Code CLI from a single web/terminal UI. It supports live interrupts, native session resume, and voice input with HTTPS auto-setup for remote devices.
 
 ---
 
@@ -27,7 +27,19 @@ NexusCLI is a lightweight, Termux-first AI cockpit to orchestrate Claude Code, C
 
 ---
 
-## Highlights (v0.9.5)
+## Highlights (v0.9.7-termux, testing)
+
+- **QWEN Engine**: Integrated Qwen Code CLI with streaming statusbar events
+- **QWEN Models**: `coder-model` and `vision-model` available in UI
+- **Session Import**: Qwen sessions indexed alongside Claude/Codex/Gemini
+
+### 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
@@ -41,7 +53,7 @@ NexusCLI is a lightweight, Termux-first AI cockpit to orchestrate Claude Code, C
 
 ## Features
 
-- Multi-engine support (Claude, Codex, Gemini)
+- Multi-engine support (Claude, Codex, Gemini, Qwen)
 - Session continuity with explicit workspace selection
 - SSE streaming responses
 - Model selector with think-mode toggle and default model preference
@@ -57,8 +69,9 @@ 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 |
+| **Qwen** | coder-model, vision-model | Alibaba |
 
 ---
 
@@ -72,6 +85,13 @@ npm install -g @mmmbuto/nexuscli
 npm install -g github:DioNanos/nexuscli
 ```
 
+### Release Channels
+
+```bash
+# Testing channel
+npm install -g @mmmbuto/nexuscli@testing
+```
+
 ## Setup
 
 ```bash
@@ -126,7 +146,7 @@ nexuscli api set openrouter <key>     # Future: Multi-provider gateway
 nexuscli api delete <provider>        # Remove key
 ```
 
-> **Note**: Claude/Codex/Gemini keys are managed by their respective CLIs.
+> **Note**: Claude/Codex/Gemini/Qwen keys are managed by their respective CLIs.
 > OpenAI key enables voice input via Whisper. HTTPS auto-generated for remote mic access.
 
 ---
@@ -138,6 +158,7 @@ nexuscli api delete <provider>        # Remove key
   - Claude Code CLI (`claude`)
   - Codex CLI (`codex`)
   - Gemini CLI (`gemini`)
+  - Qwen Code CLI (`qwen`)
 
 ---
 
@@ -171,9 +192,11 @@ It is a **research and learning tool**.
 | `POST /api/v1/chat` | Claude | SSE streaming chat |
 | `POST /api/v1/codex` | Codex | SSE streaming chat |
 | `POST /api/v1/gemini` | Gemini | SSE streaming chat |
+| `POST /api/v1/qwen` | Qwen | SSE streaming chat |
 | `POST /api/v1/chat/interrupt` | Claude | Stop running generation |
 | `POST /api/v1/codex/interrupt` | Codex | Stop running generation |
 | `POST /api/v1/gemini/interrupt` | Gemini | Stop running generation |
+| `POST /api/v1/qwen/interrupt` | Qwen | Stop running generation |
 | `GET /api/v1/models` | All | List available models |
 | `GET /api/v1/config` | - | Get user preferences (default model) |
 | `GET /health` | - | Health check |

package/lib/cli/engines.js

@@ -18,7 +18,8 @@ function detectEngines() {
   const engines = {
     claude: { available: false, path: null, version: null },
     codex: { available: false, path: null, version: null },
-    gemini: { available: false, path: null, version: null }
+    gemini: { available: false, path: null, version: null },
+    qwen: { available: false, path: null, version: null }
   };
 
   // Claude
@@ -42,6 +43,13 @@ function detectEngines() {
     engines.gemini = { available: true, path: geminiPath, version: geminiVersion };
   } catch {}
 
+  // Qwen
+  try {
+    const qwenPath = execSync('which qwen 2>/dev/null', { encoding: 'utf8' }).trim();
+    const qwenVersion = execSync('qwen --version 2>/dev/null', { encoding: 'utf8' }).trim().split('\n')[0];
+    engines.qwen = { available: true, path: qwenPath, version: qwenVersion };
+  } catch {}
+
   return engines;
 }
 
@@ -87,6 +95,16 @@ function listEngines() {
     console.log(chalk.bold(`║  Gemini:  ${chalk.gray('○ not installed')}`));
   }
 
+  // Qwen
+  const qwenEnabled = config.engines?.qwen?.enabled === true;
+  if (detected.qwen.available) {
+    const status = qwenEnabled ? chalk.green('✓ enabled') : chalk.gray('○ disabled');
+    console.log(chalk.bold(`║  QWEN:    ${status}`));
+    console.log(chalk.gray(`║           ${detected.qwen.version}`));
+  } else {
+    console.log(chalk.bold(`║  QWEN:    ${chalk.gray('○ not installed')}`));
+  }
+
   console.log(chalk.bold('╚═══════════════════════════════════════════╝'));
 }
 
@@ -129,6 +147,17 @@ async function testEngine(engine) {
     }
   }
 
+  if (engine === 'qwen') {
+    try {
+      execSync('qwen --version', { stdio: 'inherit' });
+      console.log(chalk.green(`  ✓ Qwen CLI is working`));
+      return true;
+    } catch {
+      console.log(chalk.red(`  ✗ Qwen CLI not found`));
+      return false;
+    }
+  }
+
   console.log(chalk.yellow(`  Engine ${engine} not testable`));
   return false;
 }
@@ -149,10 +178,13 @@ async function addEngine() {
   if (detected.gemini.available) {
     choices.push({ name: `Gemini (${detected.gemini.version})`, value: 'gemini' });
   }
+  if (detected.qwen.available) {
+    choices.push({ name: `QWEN (${detected.qwen.version})`, value: 'qwen' });
+  }
 
   if (choices.length === 0) {
     console.log(chalk.yellow('  No AI engines detected.'));
-    console.log(chalk.gray('  Install: claude, codex, or gemini CLI'));
+    console.log(chalk.gray('  Install: claude, codex, gemini, or qwen CLI'));
     return;
   }
 
@@ -206,6 +238,23 @@ async function addEngine() {
     setConfigValue('engines.gemini.model', 'gemini-3-pro-preview');
     console.log(chalk.green(`  ✓ Gemini configured (gemini-3-pro-preview)`));
   }
+
+  if (engine === 'qwen') {
+    const { model } = await inquirer.prompt([{
+      type: 'list',
+      name: 'model',
+      message: 'Default Qwen model:',
+      choices: [
+        { name: 'Coder (default)', value: 'coder-model' },
+        { name: 'Vision', value: 'vision-model' }
+      ],
+      default: 'coder-model'
+    }]);
+
+    setConfigValue('engines.qwen.enabled', true);
+    setConfigValue('engines.qwen.model', model);
+    console.log(chalk.green(`  ✓ QWEN configured (${model})`));
+  }
 }
 
 /**

package/lib/config/manager.js

@@ -32,6 +32,11 @@ const DEFAULT_CONFIG = {
     codex: {
       enabled: false,
       path: null
+    },
+    qwen: {
+      enabled: false,
+      path: null,
+      model: 'coder-model'
     }
   },
   workspaces: {

package/lib/config/models.js

@@ -164,6 +164,34 @@ function getCliTools() {
         }
       ]
     }
+    ,
+
+    // ============================================================
+    // QWEN - Qwen Code CLI (Termux fork)
+    // ============================================================
+    'qwen': {
+      name: 'QWEN',
+      icon: 'Cpu',
+      enabled: true,
+      endpoint: '/api/v1/qwen',
+      models: [
+        {
+          id: 'coder-model',
+          name: 'coder-model',
+          label: 'Qwen Coder',
+          description: '🔧 Default Qwen Coder model',
+          category: 'qwen',
+          default: true
+        },
+        {
+          id: 'vision-model',
+          name: 'vision-model',
+          label: 'Qwen Vision',
+          description: '👁️ Vision-capable model',
+          category: 'qwen'
+        }
+      ]
+    }
   };
 }
 

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/lib/server/middleware/rate-limit.js

@@ -10,7 +10,7 @@ const rateLimit = require('express-rate-limit');
 /**
  * Chat endpoints rate limiter
  * - 10 requests per minute per user
- * - Applies to: /api/v1/chat, /api/v1/codex, /api/v1/gemini
+ * - Applies to: /api/v1/chat, /api/v1/codex, /api/v1/gemini, /api/v1/qwen
  */
 const chatRateLimiter = rateLimit({
   windowMs: 60 * 1000, // 1 minute window

package/lib/server/models/Message.js

@@ -13,7 +13,7 @@ class Message {
    * @param {string} content - Message content (markdown)
    * @param {Object} metadata - Optional metadata
    * @param {number} createdAt - Optional timestamp override
-   * @param {string} engine - Engine used ('claude' | 'codex')
+   * @param {string} engine - Engine used ('claude' | 'codex' | 'gemini' | 'qwen')
    * @returns {Object} Created message
    */
   static create(conversationId, role, content, metadata = null, createdAt = Date.now(), engine = 'claude') {

package/lib/server/routes/models.js

@@ -10,6 +10,7 @@ const { getCliTools } = require('../../config/models');
  * - Claude: Opus 4.5, Sonnet 4.5, Haiku 4.5
  * - Codex: GPT-5.1 variants
  * - Gemini: Gemini 3 Pro Preview, Gemini 3 Flash Preview
+ * - Qwen: coder-model, vision-model
  */
 router.get('/', (req, res) => {
   try {
@@ -35,6 +36,7 @@ router.get('/:engine', (req, res) => {
     if (normalizedEngine.includes('claude')) normalizedEngine = 'claude';
     if (normalizedEngine.includes('codex') || normalizedEngine.includes('openai')) normalizedEngine = 'codex';
     if (normalizedEngine.includes('gemini') || normalizedEngine.includes('google')) normalizedEngine = 'gemini';
+    if (normalizedEngine.includes('qwen')) normalizedEngine = 'qwen';
 
     if (!cliTools[normalizedEngine]) {
       return res.status(404).json({ error: `Engine not found: ${engine}` });