@mmmbuto/nexuscli 0.9.5 → 0.9.7-001-termux

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,263 @@
+/**
+ * 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,
+    includeDirectories = [],
+    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 (includeDirectories && includeDirectories.length > 0) {
+        includeDirectories.forEach((dir) => {
+          if (dir) {
+            args.push('--include-directories', dir);
+          }
+        });
+      }
+
+      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}`);
+      if (includeDirectories && includeDirectories.length > 0) {
+        console.log(`[QwenWrapper] Include dirs: ${includeDirectories.join(', ')}`);
+      }
+
+      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;

package/lib/server/services/session-importer.js

@@ -5,6 +5,7 @@
  *  - Claude: ~/.claude/projects/<slug>/<sessionId>.jsonl
  *  - Codex : ~/.codex/sessions/<sessionId>.jsonl
  *  - Gemini: ~/.gemini/sessions/<sessionId>.jsonl
+ *  - Qwen  : ~/.qwen/projects/<sanitized>/chats/<sessionId>.jsonl
  *
  * Note:
  *  - Usa FILESYSTEM come source of truth: non legge contenuti, solo metadati.
@@ -22,19 +23,21 @@ const HOME = process.env.HOME || '';
 const CLAUDE_PROJECTS = path.join(HOME, '.claude', 'projects');
 const CODEX_SESSIONS = path.join(HOME, '.codex', 'sessions');
 const GEMINI_SESSIONS = path.join(HOME, '.gemini', 'sessions');
+const QWEN_PROJECTS = path.join(HOME, '.qwen', 'projects');
 
 class SessionImporter {
   constructor() {}
 
   /**
    * Importa tutte le sessioni per tutti gli engine
-   * @returns {{claude:number, codex:number, gemini:number}}
+   * @returns {{claude:number, codex:number, gemini:number, qwen:number}}
    */
   importAll() {
     const claude = this.importClaudeSessions();
     const codex = this.importCodexSessions();
     const gemini = this.importGeminiSessions();
-    return { claude, codex, gemini };
+    const qwen = this.importQwenSessions();
+    return { claude, codex, gemini, qwen };
   }
 
   /**
@@ -110,6 +113,36 @@ class SessionImporter {
     return imported;
   }
 
+  /**
+   * Qwen: ~/.qwen/projects/<sanitized>/chats/<sessionId>.jsonl
+   */
+  importQwenSessions() {
+    let imported = 0;
+    if (!fs.existsSync(QWEN_PROJECTS)) return imported;
+
+    const projects = fs.readdirSync(QWEN_PROJECTS);
+    for (const project of projects) {
+      const projectDir = path.join(QWEN_PROJECTS, project);
+      if (!fs.statSync(projectDir).isDirectory()) continue;
+
+      const chatsDir = path.join(projectDir, 'chats');
+      if (!fs.existsSync(chatsDir)) continue;
+
+      const files = fs.readdirSync(chatsDir).filter(f => f.endsWith('.jsonl'));
+      for (const file of files) {
+        const sessionId = file.replace('.jsonl', '');
+        if (this.sessionExists(sessionId)) continue;
+
+        this.insertSession(sessionId, 'qwen', '', null);
+        imported++;
+      }
+    }
+
+    if (imported > 0) saveDb();
+    console.log(`[SessionImporter] Qwen imported: ${imported}`);
+    return imported;
+  }
+
   /**
    * Inserisce riga minima in sessions
    */