@mmmbuto/nexuscli 0.9.6 → 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,13 @@ NexusCLI is a lightweight, Termux-first AI cockpit to orchestrate Claude Code, C
 
 ---
 
-## Highlights (v0.9.6)
+## 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
@@ -47,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
@@ -65,6 +71,7 @@ NexusCLI is a lightweight, Termux-first AI cockpit to orchestrate Claude Code, C
 | **Claude-compatible** | DeepSeek (deepseek-*), GLM-4.6 | DeepSeek, Z.ai |
 | **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 |
 
 ---
 
@@ -78,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
@@ -132,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.
 
 ---
@@ -144,6 +158,7 @@ nexuscli api delete <provider>        # Remove key
   - Claude Code CLI (`claude`)
   - Codex CLI (`codex`)
   - Gemini CLI (`gemini`)
+  - Qwen Code CLI (`qwen`)
 
 ---
 
@@ -177,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/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}` });

package/lib/server/routes/qwen.js

@@ -0,0 +1,240 @@
+/**
+ * Qwen Route - /api/v1/qwen
+ *
+ * Send messages to Qwen Code CLI with SSE streaming.
+ */
+
+const express = require('express');
+const QwenWrapper = require('../services/qwen-wrapper');
+const Message = require('../models/Message');
+const { v4: uuidv4 } = require('uuid');
+const sessionManager = require('../services/session-manager');
+const contextBridge = require('../services/context-bridge');
+const { resolveWorkspacePath } = require('../../utils/workspace');
+
+const router = express.Router();
+const qwenWrapper = new QwenWrapper();
+
+function ensureConversation(conversationId, workspacePath) {
+  try {
+    const stmt = require('../db').prepare(`
+      INSERT OR IGNORE INTO conversations (id, title, created_at, updated_at, metadata)
+      VALUES (?, ?, ?, ?, ?)
+    `);
+    const now = Date.now();
+    const metadata = workspacePath ? JSON.stringify({ workspace: workspacePath }) : null;
+    stmt.run(conversationId, 'New Chat', now, now, metadata);
+  } catch (err) {
+    console.warn('[Qwen] Failed to ensure conversation exists:', err.message);
+  }
+}
+
+/**
+ * POST /api/v1/qwen
+ * Body:
+ * {
+ *   conversationId?: string,
+ *   message: string,
+ *   model?: string,
+ *   workspace?: string
+ * }
+ */
+router.post('/', async (req, res) => {
+  try {
+    console.log('[Qwen] === NEW QWEN REQUEST ===');
+    console.log('[Qwen] Body:', JSON.stringify(req.body, null, 2));
+
+    const { conversationId, message, model = 'coder-model', workspace } = req.body;
+
+    if (!message) {
+      return res.status(400).json({ error: 'message required' });
+    }
+
+    const isAvailable = await qwenWrapper.isAvailable();
+    if (!isAvailable) {
+      return res.status(503).json({
+        error: 'Qwen CLI not available',
+        details: 'Please install Qwen CLI: npm install -g @mmmbuto/qwen-code-termux'
+      });
+    }
+
+    const workspacePath = resolveWorkspacePath(workspace, process.cwd());
+    if (workspace && workspacePath !== workspace) {
+      console.warn(`[Qwen] Workspace corrected: ${workspace} → ${workspacePath}`);
+    }
+
+    const frontendConversationId = conversationId || uuidv4();
+    ensureConversation(frontendConversationId, workspacePath);
+
+    const { sessionId, isNew: isNewSession } = await sessionManager.getOrCreateSession(
+      frontendConversationId,
+      'qwen',
+      workspacePath
+    );
+
+    const nativeSessionId = isNewSession ? null : sessionManager.getNativeThreadId(sessionId);
+
+    // SSE headers
+    res.setHeader('Content-Type', 'text/event-stream');
+    res.setHeader('Cache-Control', 'no-cache');
+    res.setHeader('Connection', 'keep-alive');
+    res.setHeader('X-Accel-Buffering', 'no');
+
+    res.write(`data: ${JSON.stringify({
+      type: 'message_start',
+      messageId: `user-${Date.now()}`,
+      sessionId,
+      conversationId: frontendConversationId,
+      engine: 'qwen'
+    })}\n\n`);
+
+    const lastEngine = Message.getLastEngine(frontendConversationId);
+    const isEngineBridge = lastEngine && lastEngine !== 'qwen';
+
+    let promptToSend = message;
+
+    if (isEngineBridge) {
+      const contextResult = await contextBridge.buildContext({
+        conversationId: frontendConversationId,
+        sessionId,
+        fromEngine: lastEngine,
+        toEngine: 'qwen',
+        userMessage: message
+      });
+      promptToSend = contextResult.prompt;
+
+      res.write(`data: ${JSON.stringify({
+        type: 'status',
+        category: 'system',
+        message: `Context bridged from ${lastEngine}`,
+        icon: '🔄'
+      })}\n\n`);
+    } else if (nativeSessionId) {
+      console.log(`[Qwen] Native resume: qwen --resume ${nativeSessionId}`);
+    }
+
+    // Save user message
+    try {
+      Message.create(
+        frontendConversationId,
+        'user',
+        message,
+        { workspace: workspacePath, model },
+        Date.now(),
+        'qwen'
+      );
+      sessionManager.bumpSessionActivity(sessionId, 1);
+    } catch (dbErr) {
+      console.warn('[Qwen] Failed to save user message:', dbErr.message);
+    }
+
+    if (isNewSession) {
+      const title = sessionManager.extractTitle(message);
+      sessionManager.updateSessionTitle(sessionId, title);
+    }
+
+    const result = await qwenWrapper.sendMessage({
+      prompt: promptToSend,
+      threadId: nativeSessionId,
+      model,
+      workspacePath,
+      processId: sessionId,
+      onStatus: (event) => {
+        res.write(`data: ${JSON.stringify(event)}\n\n`);
+      }
+    });
+
+    if (result.sessionId) {
+      sessionManager.setNativeThreadId(sessionId, result.sessionId);
+    }
+
+    try {
+      Message.create(
+        frontendConversationId,
+        'assistant',
+        result.text,
+        { model, usage: result.usage },
+        Date.now(),
+        'qwen'
+      );
+      sessionManager.bumpSessionActivity(sessionId, 1);
+    } catch (dbErr) {
+      console.warn('[Qwen] Failed to save assistant message:', dbErr.message);
+    }
+
+    if (contextBridge.shouldTriggerSummary(frontendConversationId, isEngineBridge)) {
+      contextBridge.triggerSummaryGeneration(frontendConversationId, '[Qwen]');
+    }
+
+    res.write(`data: ${JSON.stringify({
+      type: 'message_done',
+      content: result.text,
+      usage: result.usage,
+      sessionId,
+      conversationId: frontendConversationId,
+      engine: 'qwen',
+      model
+    })}\n\n`);
+
+    res.end();
+    console.log('[Qwen] === REQUEST COMPLETE ===');
+  } catch (error) {
+    console.error('[Qwen] Error:', error);
+    if (!res.headersSent) {
+      res.status(500).json({ error: error.message });
+    } else {
+      res.write(`data: ${JSON.stringify({
+        type: 'error',
+        error: error.message
+      })}\n\n`);
+      res.end();
+    }
+  }
+});
+
+/**
+ * GET /api/v1/qwen/status
+ */
+router.get('/status', async (_req, res) => {
+  try {
+    const isAvailable = await qwenWrapper.isAvailable();
+    res.json({
+      available: isAvailable,
+      defaultModel: qwenWrapper.getDefaultModel(),
+      models: qwenWrapper.getAvailableModels()
+    });
+  } catch (error) {
+    console.error('[Qwen] Status check error:', error);
+    res.status(500).json({ error: error.message });
+  }
+});
+
+/**
+ * GET /api/v1/qwen/models
+ */
+router.get('/models', (_req, res) => {
+  res.json({
+    models: qwenWrapper.getAvailableModels(),
+    default: qwenWrapper.getDefaultModel()
+  });
+});
+
+/**
+ * POST /api/v1/qwen/interrupt
+ */
+router.post('/interrupt', async (req, res) => {
+  try {
+    const { sessionId } = req.body;
+    if (!sessionId) {
+      return res.status(400).json({ error: 'sessionId required' });
+    }
+
+    const result = qwenWrapper.interrupt(sessionId);
+    res.json(result);
+  } catch (error) {
+    console.error('[Qwen] Interrupt error:', error);
+    res.status(500).json({ error: error.message });
+  }
+});
+
+module.exports = router;

package/lib/server/routes/sessions.js

@@ -15,11 +15,12 @@ const SESSION_DIRS = {
   claude: path.join(process.env.HOME || '', '.claude', 'projects'),
   codex: path.join(process.env.HOME || '', '.codex', 'sessions'),
   gemini: path.join(process.env.HOME || '', '.gemini', 'sessions'),
+  qwen: path.join(process.env.HOME || '', '.qwen', 'projects'),
 };
 
 /**
  * POST /api/v1/sessions/import
- * Importa tutte le sessioni native (Claude/Codex/Gemini) nel DB
+ * Importa tutte le sessioni native (Claude/Codex/Gemini/Qwen) nel DB
  */
 router.post('/import', async (_req, res) => {
   try {
@@ -280,6 +281,11 @@ function pathToSlug(workspacePath) {
   return workspacePath.replace(/[\/\.]/g, '-');
 }
 
+function qwenProjectDir(workspacePath) {
+  if (!workspacePath) return 'default';
+  return workspacePath.replace(/[^a-zA-Z0-9]/g, '-');
+}
+
 /**
  * Helper: Get the filesystem path for a session file
  */
@@ -287,6 +293,7 @@ function getSessionFilePath(sessionId, engine, workspacePath, sessionPath) {
   const normalizedEngine = engine?.toLowerCase().includes('claude') ? 'claude'
     : engine?.toLowerCase().includes('codex') ? 'codex'
     : engine?.toLowerCase().includes('gemini') ? 'gemini'
+    : engine?.toLowerCase().includes('qwen') ? 'qwen'
     : 'claude';
 
   switch (normalizedEngine) {
@@ -303,6 +310,11 @@ function getSessionFilePath(sessionId, engine, workspacePath, sessionPath) {
       return findCodexSessionFile(baseDir, nativeId);
     case 'gemini':
       return path.join(SESSION_DIRS.gemini, `${sessionId}.jsonl`);
+    case 'qwen': {
+      const project = qwenProjectDir(workspacePath);
+      const fileId = sessionPath || sessionId;
+      return path.join(SESSION_DIRS.qwen, project, 'chats', `${fileId}.jsonl`);
+    }
     default:
       return null;
   }

package/lib/server/server.js

@@ -22,6 +22,7 @@ const jobsRouter = require('./routes/jobs');
 const chatRouter = require('./routes/chat');
 const codexRouter = require('./routes/codex');
 const geminiRouter = require('./routes/gemini');
+const qwenRouter = require('./routes/qwen');
 const modelsRouter = require('./routes/models');
 const workspaceRouter = require('./routes/workspace');
 const workspacesRouter = require('./routes/workspaces');
@@ -51,7 +52,7 @@ app.get('/health', (req, res) => {
     status: 'ok',
     service: 'nexuscli-backend',
     version: pkg.version,
-    engines: ['claude', 'codex', 'gemini'],
+    engines: ['claude', 'codex', 'gemini', 'qwen'],
     port: PORT,
     timestamp: new Date().toISOString()
   });
@@ -78,6 +79,7 @@ app.use('/api/v1/jobs', authMiddleware, jobsRouter);
 app.use('/api/v1/chat', authMiddleware, chatRateLimiter, chatRouter);
 app.use('/api/v1/codex', authMiddleware, chatRateLimiter, codexRouter);
 app.use('/api/v1/gemini', authMiddleware, chatRateLimiter, geminiRouter);
+app.use('/api/v1/qwen', authMiddleware, chatRateLimiter, qwenRouter);
 app.use('/api/v1/upload', authMiddleware, uploadRouter); // File upload
 
 // STT routes
@@ -89,13 +91,14 @@ app.get('/', (req, res) => {
   res.json({
     service: 'NexusCLI Backend',
     version: pkg.version,
-    engines: ['claude', 'codex', 'gemini'],
+    engines: ['claude', 'codex', 'gemini', 'qwen'],
     endpoints: {
       health: '/health',
       models: '/api/v1/models',
       chat: '/api/v1/chat (Claude)',
       codex: '/api/v1/codex (OpenAI)',
       gemini: '/api/v1/gemini (Google)',
+      qwen: '/api/v1/qwen (Qwen)',
       conversations: '/api/v1/conversations',
       jobs: '/api/v1/jobs'
     }
@@ -154,10 +157,10 @@ async function start() {
     // Continue anyway - database will sync on first workspace mount
   }
 
-  // Import native sessions from all engines (Claude/Codex/Gemini)
+  // Import native sessions from all engines (Claude/Codex/Gemini/Qwen)
   try {
     const imported = sessionImporter.importAll();
-    console.log(`[Startup] Imported sessions → Claude:${imported.claude} Codex:${imported.codex} Gemini:${imported.gemini}`);
+    console.log(`[Startup] Imported sessions → Claude:${imported.claude} Codex:${imported.codex} Gemini:${imported.gemini} Qwen:${imported.qwen}`);
   } catch (error) {
     console.error('[Startup] ⚠️  Session import failed:', error.message);
   }