@mmmbuto/nexuscli 0.9.6 → 0.9.7-termux

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;

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

@@ -0,0 +1,289 @@
+/**
+ * QwenOutputParser - Parse Qwen CLI stream-json output
+ *
+ * Qwen Code stream-json emits JSONL lines with message envelopes:
+ * - system (subtype: init)
+ * - assistant (message.content blocks)
+ * - user (tool_result blocks)
+ * - stream_event (partial deltas when enabled)
+ * - result (usage + status)
+ *
+ * Emits normalized events for SSE streaming:
+ * - status: { type: 'status', category: 'tool'|'system', message, icon }
+ * - response_chunk: { type: 'response_chunk', text, isIncremental }
+ * - response_done: { type: 'response_done', fullText }
+ * - done: { type: 'done', usage, status }
+ * - error: { type: 'error', message }
+ */
+
+class QwenOutputParser {
+  constructor() {
+    this.buffer = '';
+    this.finalResponse = '';
+    this.usage = null;
+    this.sessionId = null;
+    this.model = null;
+    this.receivedPartial = false;
+  }
+
+  /**
+   * Parse stdout chunk (may contain multiple JSON lines)
+   * @param {string} chunk
+   * @returns {Array}
+   */
+  parse(chunk) {
+    const events = [];
+
+    this.buffer += chunk;
+    const lines = this.buffer.split('\n');
+    this.buffer = lines.pop() || '';
+
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+
+      if (!trimmed.startsWith('{')) {
+        continue;
+      }
+
+      try {
+        const json = JSON.parse(trimmed);
+        const lineEvents = this._parseJsonEvent(json);
+        events.push(...lineEvents);
+      } catch (e) {
+        console.warn('[QwenOutputParser] JSON parse error:', e.message, '- Line:', trimmed.substring(0, 80));
+      }
+    }
+
+    return events;
+  }
+
+  _parseJsonEvent(event) {
+    const events = [];
+
+    switch (event.type) {
+      case 'system': {
+        if (event.subtype === 'init') {
+          this.sessionId = event.session_id || event.sessionId || this.sessionId;
+          this.model = event.model || event.data?.model || this.model;
+          events.push({
+            type: 'status',
+            category: 'system',
+            message: 'Session initialized',
+            icon: '🚀',
+            sessionId: this.sessionId,
+            model: this.model,
+            timestamp: event.timestamp || new Date().toISOString(),
+          });
+        }
+        break;
+      }
+
+      case 'assistant': {
+        const contentBlocks = event.message?.content;
+        const text = this._extractText(contentBlocks);
+        if (text) {
+          if (!this.receivedPartial) {
+            this.finalResponse += text;
+            events.push({
+              type: 'response_chunk',
+              text,
+              isIncremental: false,
+            });
+          } else if (!this.finalResponse) {
+            // Fallback if partials were emitted but response was empty
+            this.finalResponse = text;
+          }
+        }
+        this._emitToolUseFromBlocks(contentBlocks, events);
+        break;
+      }
+
+      case 'user': {
+        const contentBlocks = event.message?.content;
+        this._emitToolResultFromBlocks(contentBlocks, events);
+        break;
+      }
+
+      case 'stream_event': {
+        const stream = event.event || {};
+        if (stream.type === 'content_block_delta' && stream.delta?.type === 'text_delta') {
+          const text = stream.delta.text || '';
+          if (text) {
+            this.receivedPartial = true;
+            this.finalResponse += text;
+            events.push({
+              type: 'response_chunk',
+              text,
+              isIncremental: true,
+            });
+          }
+        }
+        if (stream.type === 'content_block_start' && stream.content_block?.type === 'tool_use') {
+          events.push(this._formatToolUseEvent(stream.content_block));
+        }
+        break;
+      }
+
+      case 'result': {
+        if (event.is_error) {
+          const message = event.error?.message || event.error || 'Unknown error';
+          events.push({ type: 'error', message });
+          break;
+        }
+
+        this.usage = event.usage || null;
+        const fullText = this.finalResponse || event.result || '';
+
+        events.push({
+          type: 'response_done',
+          fullText,
+        });
+
+        const promptTokens = this.usage?.input_tokens || 0;
+        const completionTokens = this.usage?.output_tokens || 0;
+        const totalTokens = this.usage?.total_tokens || (promptTokens + completionTokens);
+
+        events.push({
+          type: 'done',
+          status: 'success',
+          usage: {
+            prompt_tokens: promptTokens,
+            completion_tokens: completionTokens,
+            total_tokens: totalTokens,
+          },
+          duration_ms: event.duration_ms || 0,
+          sessionId: this.sessionId,
+        });
+        break;
+      }
+
+      default:
+        // Ignore other event types
+        break;
+    }
+
+    return events;
+  }
+
+  _extractText(contentBlocks) {
+    if (!contentBlocks) return '';
+    if (typeof contentBlocks === 'string') return contentBlocks;
+    if (!Array.isArray(contentBlocks)) return '';
+
+    return contentBlocks
+      .filter((block) => block?.type === 'text' && block.text)
+      .map((block) => block.text)
+      .join('');
+  }
+
+  _emitToolUseFromBlocks(contentBlocks, events) {
+    if (!Array.isArray(contentBlocks)) return;
+    for (const block of contentBlocks) {
+      if (block?.type === 'tool_use') {
+        events.push(this._formatToolUseEvent(block));
+      }
+    }
+  }
+
+  _emitToolResultFromBlocks(contentBlocks, events) {
+    if (!Array.isArray(contentBlocks)) return;
+    for (const block of contentBlocks) {
+      if (block?.type === 'tool_result') {
+        const success = !block.is_error;
+        events.push({
+          type: 'status',
+          category: 'tool',
+          message: success ? 'Tool completed' : 'Tool failed',
+          icon: success ? '✅' : '❌',
+          toolOutput: this._truncateOutput(block.content),
+          timestamp: new Date().toISOString(),
+        });
+      }
+    }
+  }
+
+  _formatToolUseEvent(block) {
+    const tool = block?.name || block?.tool || block?.function?.name || 'Tool';
+    const input = block?.input || block?.parameters || block?.args || block?.function?.arguments || {};
+    let message = tool;
+
+    switch (tool) {
+      case 'shell':
+      case 'run_shell_command':
+      case 'execute_command':
+        message = `Shell: ${this._truncate(block.command || input.command || '', 60)}`;
+        break;
+      case 'read_file':
+      case 'read_many_files':
+      case 'read':
+        message = `Reading: ${this._truncate(block.path || input.path || input.file_path || '', 50)}`;
+        break;
+      case 'write_file':
+      case 'write':
+        message = `Writing: ${this._truncate(block.path || input.path || input.file_path || '', 50)}`;
+        break;
+      case 'edit_file':
+      case 'edit':
+        message = `Editing: ${this._truncate(block.path || input.path || input.file_path || '', 50)}`;
+        break;
+      case 'search_files':
+      case 'grep':
+      case 'find_files':
+        message = `Searching: ${this._truncate(block.pattern || input.pattern || input.query || '', 40)}`;
+        break;
+      case 'list_directory':
+      case 'list_dir':
+      case 'ls':
+        message = `Listing: ${this._truncate(block.path || input.path || input.dir_path || '.', 50)}`;
+        break;
+      case 'web_search':
+      case 'google_search':
+      case 'search':
+        message = `Web search: ${this._truncate(block.query || input.query || '', 40)}`;
+        break;
+      case 'web_fetch':
+      case 'fetch_url':
+        message = `Fetch: ${this._truncate(block.url || input.url || '', 60)}`;
+        break;
+      default:
+        message = `Tool: ${tool}`;
+        break;
+    }
+
+    return {
+      type: 'status',
+      category: 'tool',
+      message,
+      icon: '🛠️',
+    };
+  }
+
+  _truncate(text, maxLen = 60) {
+    if (!text) return '';
+    const str = String(text);
+    if (str.length <= maxLen) return str;
+    return str.substring(0, maxLen) + '...';
+  }
+
+  _truncateOutput(output, maxLen = 200) {
+    if (!output) return '';
+    const text = typeof output === 'string' ? output : JSON.stringify(output);
+    if (text.length <= maxLen) return text;
+    return text.substring(0, maxLen) + '...';
+  }
+
+  getFinalResponse() {
+    return this.finalResponse || '';
+  }
+
+  getUsage() {
+    return this.usage;
+  }
+
+  getSessionId() {
+    return this.sessionId;
+  }
+}
+
+module.exports = QwenOutputParser;

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

@@ -0,0 +1,251 @@
+/**
+ * QwenWrapper - Wrapper for Qwen Code CLI (qwen command)
+ *
+ * Executes Qwen CLI with PTY adapter for Termux.
+ * Uses stream-json output for structured parsing.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const pty = require('../lib/pty-adapter');
+const QwenOutputParser = require('./qwen-output-parser');
+const BaseCliWrapper = require('./base-cli-wrapper');
+
+const DEFAULT_MODEL = 'coder-model';
+const CLI_TIMEOUT_MS = 600000; // 10 minutes
+
+const DANGEROUS_PATTERNS = [
+  /pkill\s+(-\d+\s+)?node/i,
+  /killall\s+(-\d+\s+)?node/i,
+  /kill\s+-9/i,
+  /rm\s+-rf\s+[\/~]/i,
+  /shutdown/i,
+  /reboot/i,
+  /systemctl\s+(stop|restart|disable)/i,
+  /service\s+\w+\s+(stop|restart)/i,
+  />\s*\/dev\/sd/i,
+  /mkfs/i,
+  /dd\s+if=.*of=\/dev/i,
+];
+
+class QwenWrapper extends BaseCliWrapper {
+  constructor(options = {}) {
+    super();
+    this.qwenPath = this._resolveQwenPath(options.qwenPath);
+    this.workspaceDir = options.workspaceDir || process.cwd();
+
+    console.log(`[QwenWrapper] Initialized with binary: ${this.qwenPath}`);
+  }
+
+  _isDangerousCommand(command) {
+    if (!command) return false;
+    for (const pattern of DANGEROUS_PATTERNS) {
+      if (pattern.test(command)) return true;
+    }
+    return false;
+  }
+
+  _resolveQwenPath(overridePath) {
+    if (overridePath && fs.existsSync(overridePath)) return overridePath;
+
+    const candidates = [
+      path.join(process.env.HOME || '', '.local/bin/qwen'),
+      path.join(process.env.PREFIX || '', 'bin/qwen'),
+      '/usr/local/bin/qwen',
+      '/usr/bin/qwen',
+      'qwen',
+    ];
+
+    for (const candidate of candidates) {
+      try {
+        if (candidate === 'qwen' || fs.existsSync(candidate)) {
+          return candidate;
+        }
+      } catch (_) {
+        // ignore
+      }
+    }
+
+    return 'qwen';
+  }
+
+  /**
+   * Send a message to Qwen CLI
+   * @param {Object} params
+   * @param {string} params.prompt
+   * @param {string} params.threadId - Native Qwen session ID for resume
+   * @param {string} params.model
+   * @param {string} params.workspacePath
+   * @param {Function} params.onStatus
+   */
+  async sendMessage({
+    prompt,
+    threadId,
+    model = DEFAULT_MODEL,
+    workspacePath,
+    onStatus,
+    processId: processIdOverride
+  }) {
+    return new Promise((resolve, reject) => {
+      const parser = new QwenOutputParser();
+      let promiseSettled = false;
+
+      const cwd = workspacePath || this.workspaceDir;
+
+      const args = [
+        '-y',
+        '-m', model,
+        '-o', 'stream-json',
+        '--include-partial-messages',
+      ];
+
+      if (threadId) {
+        args.push('--resume', threadId);
+      }
+
+      args.push(prompt);
+
+      console.log(`[QwenWrapper] Model: ${model}`);
+      console.log(`[QwenWrapper] ThreadId: ${threadId || '(new session)'}`);
+      console.log(`[QwenWrapper] CWD: ${cwd}`);
+      console.log(`[QwenWrapper] Prompt length: ${prompt.length}`);
+
+      let ptyProcess;
+      try {
+        ptyProcess = pty.spawn(this.qwenPath, args, {
+          name: 'xterm-color',
+          cols: 120,
+          rows: 40,
+          cwd,
+          env: {
+            ...process.env,
+            TERM: 'xterm-256color',
+          }
+        });
+      } catch (spawnError) {
+        return reject(new Error(`Failed to spawn Qwen CLI: ${spawnError.message}`));
+      }
+
+      const processId = processIdOverride || threadId || `qwen-${Date.now()}`;
+      this.registerProcess(processId, ptyProcess, 'pty');
+
+      let stdout = '';
+
+      ptyProcess.onData((data) => {
+        stdout += data;
+
+        const cleanData = data
+          .replace(/\x1B\[[0-9;]*[a-zA-Z]/g, '')
+          .replace(/\x1B\[\?[0-9;]*[a-zA-Z]/g, '')
+          .replace(/\r/g, '');
+
+        if (onStatus && cleanData.trim()) {
+          try {
+            const events = parser.parse(cleanData);
+            events.forEach(event => {
+              if (event.type === 'status' && event.message) {
+                const msg = event.message;
+                if (msg.startsWith('Shell:') || msg.includes('Shell:')) {
+                  const shellCmd = msg.replace(/^Shell:\s*/, '');
+                  if (this._isDangerousCommand(shellCmd)) {
+                    console.warn(`[QwenWrapper] ⚠️  DANGEROUS COMMAND DETECTED: ${shellCmd.substring(0, 100)}`);
+                  }
+                }
+              }
+              onStatus(event);
+            });
+          } catch (parseError) {
+            console.error('[QwenWrapper] Parser error:', parseError.message);
+          }
+        }
+      });
+
+      ptyProcess.onExit(({ exitCode }) => {
+        this.unregisterProcess(processId);
+
+        if (promiseSettled) return;
+        promiseSettled = true;
+
+        if (exitCode !== 0 && exitCode !== null) {
+          reject(new Error(`Qwen CLI error (exit ${exitCode}): ${stdout.substring(0, 200)}`));
+          return;
+        }
+
+        const finalResponse = parser.getFinalResponse();
+        const usage = parser.getUsage();
+
+        const promptTokens = usage?.input_tokens || Math.ceil(prompt.length / 4);
+        const completionTokens = usage?.output_tokens || Math.ceil(finalResponse.length / 4);
+
+        if (!finalResponse.trim()) {
+          return reject(new Error('Qwen CLI returned empty response. Check CLI logs.'));
+        }
+
+        resolve({
+          text: finalResponse,
+          sessionId: parser.getSessionId(),
+          usage: {
+            prompt_tokens: promptTokens,
+            completion_tokens: completionTokens,
+            total_tokens: promptTokens + completionTokens,
+          }
+        });
+      });
+
+      if (ptyProcess.onError) {
+        ptyProcess.onError((error) => {
+          if (promiseSettled) return;
+          promiseSettled = true;
+          reject(new Error(`Qwen CLI PTY error: ${error.message}`));
+        });
+      }
+
+      const timeout = setTimeout(() => {
+        if (!promiseSettled) {
+          promiseSettled = true;
+          try { ptyProcess.kill(); } catch (_) {}
+          reject(new Error('Qwen CLI timeout (10 minutes)'));
+        }
+      }, CLI_TIMEOUT_MS);
+
+      ptyProcess.onExit(() => clearTimeout(timeout));
+    });
+  }
+
+  async isAvailable() {
+    return new Promise((resolve) => {
+      const { exec } = require('child_process');
+      exec(`${this.qwenPath} --version`, { timeout: 5000 }, (error, stdout) => {
+        if (error) {
+          console.log('[QwenWrapper] CLI not available:', error.message);
+          resolve(false);
+        } else {
+          console.log('[QwenWrapper] CLI available:', stdout.trim().substring(0, 50));
+          resolve(true);
+        }
+      });
+    });
+  }
+
+  getDefaultModel() {
+    return DEFAULT_MODEL;
+  }
+
+  getAvailableModels() {
+    return [
+      {
+        id: 'coder-model',
+        name: 'coder-model',
+        description: '🔧 Qwen Coder (default)',
+        default: true
+      },
+      {
+        id: 'vision-model',
+        name: 'vision-model',
+        description: '👁️ Qwen Vision'
+      }
+    ];
+  }
+}
+
+module.exports = QwenWrapper;