@mmmbuto/nexuscli 0.9.5 → 0.9.7-termux

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);
   }

package/lib/server/services/cli-loader.js

@@ -1,5 +1,5 @@
 /**
- * CliLoader - Unified message loader for TRI CLI (Claude/Codex/Gemini)
+ * CliLoader - Unified message loader for TRI CLI (Claude/Codex/Gemini/Qwen)
  *
  * Loads messages on-demand from CLI history files (lazy loading).
  * Filesystem is the source of truth - no DB caching of messages.
@@ -8,6 +8,7 @@
  * - Claude: ~/.claude/projects/<workspace-slug>/<sessionId>.jsonl
  * - Codex:  ~/.codex/sessions/<sessionId>.jsonl (if available)
  * - Gemini: ~/.gemini/sessions/<sessionId>.jsonl (if available)
+ * - Qwen  : ~/.qwen/projects/<sanitized>/chats/<sessionId>.jsonl
  *
  * @version 0.4.0 - TRI CLI Support
  */
@@ -23,6 +24,7 @@ const ENGINE_PATHS = {
   claude: path.join(process.env.HOME || '', '.claude'),
   codex: path.join(process.env.HOME || '', '.codex'),
   gemini: path.join(process.env.HOME || '', '.gemini'),
+  qwen: path.join(process.env.HOME || '', '.qwen'),
 };
 
 class CliLoader {
@@ -30,15 +32,16 @@ class CliLoader {
     this.claudePath = ENGINE_PATHS.claude;
     this.codexPath = ENGINE_PATHS.codex;
     this.geminiPath = ENGINE_PATHS.gemini;
+    this.qwenPath = ENGINE_PATHS.qwen;
   }
 
   /**
    * Load messages from CLI history by session.
-   * Supports all three engines: Claude, Codex, Gemini.
+   * Supports all engines: Claude, Codex, Gemini, Qwen.
    *
    * @param {Object} params
    * @param {string} params.sessionId - Session UUID
-   * @param {string} params.engine - 'claude'|'claude-code'|'codex'|'gemini'
+   * @param {string} params.engine - 'claude'|'claude-code'|'codex'|'gemini'|'qwen'
    * @param {string} params.workspacePath - Workspace directory (required for Claude)
    * @param {number} [params.limit=30] - Max messages to return
    * @param {number} [params.before] - Timestamp cursor for pagination (ms)
@@ -76,6 +79,9 @@ class CliLoader {
       case 'gemini':
         result = await this.loadGeminiMessages({ sessionId, nativeId, limit, before, mode });
         break;
+      case 'qwen':
+        result = await this.loadQwenMessages({ sessionId, nativeId, workspacePath, limit, before, mode });
+        break;
 
       default:
         throw new Error(`Unsupported engine: ${engine}`);
@@ -94,6 +100,7 @@ class CliLoader {
     if (lower.includes('claude')) return 'claude';
     if (lower.includes('codex') || lower.includes('openai')) return 'codex';
     if (lower.includes('gemini') || lower.includes('google')) return 'gemini';
+    if (lower.includes('qwen')) return 'qwen';
     return lower;
   }
 
@@ -108,6 +115,14 @@ class CliLoader {
     return workspacePath.replace(/[\/\.]/g, '-');
   }
 
+  /**
+   * Convert workspace path to Qwen project dir (matches Qwen Storage.sanitizeCwd)
+   */
+  qwenPathToProject(workspacePath) {
+    if (!workspacePath) return 'default';
+    return workspacePath.replace(/[^a-zA-Z0-9]/g, '-');
+  }
+
   // ============================================================
   // CLAUDE - Load from ~/.claude/projects/<slug>/<sessionId>.jsonl
   // ============================================================
@@ -368,6 +383,67 @@ class CliLoader {
     return this._paginateMessages(messages, limit, before, mode);
   }
 
+  // ============================================================
+  // QWEN - Load from ~/.qwen/projects/<sanitized>/chats/<sessionId>.jsonl
+  // ============================================================
+
+  async loadQwenMessages({ sessionId, nativeId, workspacePath, limit, before, mode }) {
+    if (!workspacePath) {
+      console.warn('[CliLoader] No workspacePath for Qwen, using cwd');
+      workspacePath = process.cwd();
+    }
+
+    const project = this.qwenPathToProject(workspacePath);
+    const fileId = nativeId || sessionId;
+    const sessionFile = path.join(this.qwenPath, 'projects', project, 'chats', `${fileId}.jsonl`);
+
+    if (!fs.existsSync(sessionFile)) {
+      console.log(`[CliLoader] Qwen session file not found: ${sessionFile}`);
+      return this._emptyResult();
+    }
+
+    const rawMessages = await this._parseJsonlFile(sessionFile);
+
+    const messages = rawMessages
+      .filter(entry => entry.type === 'user' || entry.type === 'assistant')
+      .map(entry => this._normalizeQwenEntry(entry));
+
+    return this._paginateMessages(messages, limit, before, mode);
+  }
+
+  /**
+   * Normalize Qwen session entry to message shape
+   */
+  _normalizeQwenEntry(entry) {
+    const role = entry.type || 'assistant';
+    const created_at = entry.timestamp ? new Date(entry.timestamp).getTime() : Date.now();
+
+    let content = '';
+    const parts = entry.message?.parts;
+    if (Array.isArray(parts)) {
+      content = parts
+        .filter(p => p && p.text)
+        .map(p => p.text)
+        .join('\\n');
+    } else if (typeof entry.message?.content === 'string') {
+      content = entry.message.content;
+    } else if (entry.text) {
+      content = entry.text;
+    }
+
+    return {
+      id: entry.uuid || `qwen-${created_at}`,
+      role,
+      content,
+      engine: 'qwen',
+      created_at,
+      metadata: {
+        model: entry.model,
+        usage: entry.usageMetadata
+      }
+    };
+  }
+
   /**
    * Normalize Gemini session entry to message shape
    */
@@ -500,6 +576,10 @@ class CliLoader {
 
       case 'gemini':
         return path.join(this.geminiPath, 'sessions', `${sessionId}.jsonl`);
+      case 'qwen': {
+        const project = this.qwenPathToProject(workspacePath);
+        return path.join(this.qwenPath, 'projects', project, 'chats', `${sessionId}.jsonl`);
+      }
 
       default:
         return null;

package/lib/server/services/context-bridge.js

@@ -21,7 +21,8 @@ const ENGINE_LIMITS = {
   'claude': { maxTokens: 4000, preferSummary: true },
   'codex': { maxTokens: 3000, preferSummary: true, codeOnly: true },
   'deepseek': { maxTokens: 3000, preferSummary: true },
-  'gemini': { maxTokens: 6000, preferSummary: false } // Gemini has large context
+  'gemini': { maxTokens: 6000, preferSummary: false }, // Gemini has large context
+  'qwen': { maxTokens: 6000, preferSummary: false } // Qwen Coder large context
 };
 
 class ContextBridge {
@@ -152,7 +153,8 @@ class ContextBridge {
       'claude': 'Claude Code (Anthropic)',
       'codex': 'Codex (OpenAI)',
       'gemini': 'Gemini (Google)',
-      'deepseek': 'DeepSeek'
+      'deepseek': 'DeepSeek',
+      'qwen': 'Qwen Code (Alibaba)'
     };
 
     const fromName = engineNames[fromEngine] || fromEngine;