@mmmbuto/nexuscli 0.9.7004-termux → 0.10.0

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

@@ -11,7 +11,7 @@ const pty = require('../lib/pty-adapter');
 const QwenOutputParser = require('./qwen-output-parser');
 const BaseCliWrapper = require('./base-cli-wrapper');
 
-const DEFAULT_MODEL = 'coder-model';
+const DEFAULT_MODEL = 'qwen3-coder-plus';
 const CLI_TIMEOUT_MS = 600000; // 10 minutes
 
 const DANGEROUS_PATTERNS = [
@@ -85,7 +85,9 @@ class QwenWrapper extends BaseCliWrapper {
     workspacePath,
     includeDirectories = [],
     onStatus,
-    processId: processIdOverride
+    processId: processIdOverride,
+    runtimeCommand,
+    envOverrides = {}
   }) {
     return new Promise((resolve, reject) => {
       const parser = new QwenOutputParser();
@@ -125,7 +127,8 @@ class QwenWrapper extends BaseCliWrapper {
 
       let ptyProcess;
       try {
-        ptyProcess = pty.spawn(this.qwenPath, args, {
+        const command = runtimeCommand || this.qwenPath;
+        ptyProcess = pty.spawn(command, args, {
           name: 'xterm-color',
           cols: 120,
           rows: 40,
@@ -135,6 +138,7 @@ class QwenWrapper extends BaseCliWrapper {
             QWEN_CODE_MODEL: resolvedModel,
             QWEN_MODEL: resolvedModel,
             TERM: 'xterm-256color',
+            ...envOverrides,
           }
         });
       } catch (spawnError) {
@@ -227,10 +231,11 @@ class QwenWrapper extends BaseCliWrapper {
     });
   }
 
-  async isAvailable() {
+  async isAvailable(runtimeCommand) {
     return new Promise((resolve) => {
       const { exec } = require('child_process');
-      exec(`${this.qwenPath} --version`, { timeout: 5000 }, (error, stdout) => {
+      const command = runtimeCommand || this.qwenPath;
+      exec(`${command} --version`, { timeout: 5000 }, (error, stdout) => {
         if (error) {
           console.log('[QwenWrapper] CLI not available:', error.message);
           resolve(false);
@@ -249,15 +254,25 @@ class QwenWrapper extends BaseCliWrapper {
   getAvailableModels() {
     return [
       {
-        id: 'coder-model',
-        name: 'coder-model',
-        description: '🔧 Qwen Coder (default)',
+        id: 'qwen3-coder-plus',
+        name: 'qwen3-coder-plus',
+        description: 'Qwen 3 Coder Plus',
         default: true
       },
       {
-        id: 'vision-model',
-        name: 'vision-model',
-        description: '👁️ Qwen Vision'
+        id: 'qwen3-coder-next',
+        name: 'qwen3-coder-next',
+        description: 'Qwen 3 Coder Next'
+      },
+      {
+        id: 'qwen3.5-plus',
+        name: 'qwen3.5-plus',
+        description: 'Qwen 3.5 Plus'
+      },
+      {
+        id: 'qwen3-max',
+        name: 'qwen3-max',
+        description: 'Qwen 3 Max'
       }
     ];
   }

package/lib/server/services/runtime-manager.js

@@ -0,0 +1,467 @@
+const { execFile } = require('child_process');
+const { promisify } = require('util');
+const { getCliTools, getModelById, getDefaultModelId } = require('../../config/models');
+const { getConfig } = require('../../config/manager');
+
+const execFileAsync = promisify(execFile);
+
+function isTermux() {
+  return (
+    process.env.PREFIX?.includes('com.termux') ||
+    process.env.TERMUX_VERSION !== undefined
+  );
+}
+
+function getPlatformId() {
+  if (isTermux()) return 'termux';
+  if (process.platform === 'darwin') return 'macos';
+  if (process.platform === 'linux') return 'linux';
+  return process.platform;
+}
+
+function npmCommand() {
+  if (isTermux()) return 'npm';
+  return 'npm';
+}
+
+function shellJoin(commands) {
+  return commands.filter(Boolean).join(' && ');
+}
+
+function buildProviderAuth({ providerId, dbKey, envVars = [], displayName, helpUrl, assignOpenAiKey = false }) {
+  return {
+    providerId,
+    dbKey,
+    envVars,
+    displayName,
+    helpUrl,
+    assignOpenAiKey,
+  };
+}
+
+function resolveClaudeCustomProfile(model) {
+  switch (model.id) {
+    case 'deepseek-reasoner':
+    case 'deepseek-chat':
+      return {
+        env: {
+          ANTHROPIC_BASE_URL: 'https://api.deepseek.com/anthropic',
+          ANTHROPIC_MODEL: model.id,
+          ANTHROPIC_SMALL_FAST_MODEL: 'deepseek-chat',
+          API_TIMEOUT_MS: '900000',
+        },
+        providerAuth: buildProviderAuth({
+          providerId: 'deepseek',
+          dbKey: 'deepseek',
+          envVars: ['DEEPSEEK_API_KEY'],
+          displayName: 'DeepSeek',
+          helpUrl: 'https://platform.deepseek.com/api_keys',
+        }),
+      };
+    case 'glm-4.7':
+    case 'glm-5':
+      return {
+        env: {
+          ANTHROPIC_BASE_URL: 'https://api.z.ai/api/anthropic',
+          ANTHROPIC_MODEL: model.id === 'glm-5' ? 'GLM-5' : 'GLM-4.7',
+          ANTHROPIC_SMALL_FAST_MODEL: 'GLM-4.5-Air',
+          API_TIMEOUT_MS: '3000000',
+        },
+        providerAuth: buildProviderAuth({
+          providerId: 'zai',
+          dbKey: 'zai',
+          envVars: ['ZAI_API_KEY', 'ZAI_API_KEY_A', 'ZAI_API_KEY_P'],
+          displayName: 'Z.ai',
+          helpUrl: 'https://z.ai',
+        }),
+      };
+    case 'qwen3.5-plus':
+    case 'qwen3-max-2026-01-23':
+    case 'kimi-k2.5':
+      return {
+        env: {
+          ANTHROPIC_BASE_URL: 'https://coding-intl.dashscope.aliyuncs.com/apps/anthropic',
+          ANTHROPIC_MODEL: model.id,
+          ANTHROPIC_SMALL_FAST_MODEL: 'qwen3.5-plus',
+          API_TIMEOUT_MS: '3000000',
+        },
+        providerAuth: buildProviderAuth({
+          providerId: 'alibaba',
+          dbKey: 'alibaba',
+          envVars: ['ALIBABA_CODE_API_KEY'],
+          displayName: 'Alibaba Code',
+          helpUrl: 'https://dashscope.aliyun.com',
+        }),
+      };
+    case 'MiniMax-M2.7':
+      return {
+        env: {
+          ANTHROPIC_BASE_URL: 'https://api.minimax.io/anthropic',
+          ANTHROPIC_MODEL: 'MiniMax-M2.7',
+          ANTHROPIC_SMALL_FAST_MODEL: 'MiniMax-M2.7',
+          API_TIMEOUT_MS: '120000',
+        },
+        providerAuth: buildProviderAuth({
+          providerId: 'minimax',
+          dbKey: 'minimax',
+          envVars: ['MINIMAX_API_KEY'],
+          displayName: 'MiniMax',
+          helpUrl: 'https://api.minimax.io',
+        }),
+      };
+    default:
+      return { env: {}, providerAuth: null };
+  }
+}
+
+function resolveCodexCustomProfile(model) {
+  if (model.providerId === 'alibaba') {
+    const providerName = 'alibaba-code';
+    return {
+      env: {},
+      configOverrides: [
+        `model="${model.id}"`,
+        `model_provider="${providerName}"`,
+        `model_providers.${providerName}.name="Alibaba-Code"`,
+        `model_providers.${providerName}.base_url="https://coding-intl.dashscope.aliyuncs.com/v1"`,
+        `model_providers.${providerName}.env_key="ALIBABA_CODE_API_KEY"`,
+        `model_providers.${providerName}.wire_api="chat"`,
+      ],
+      providerAuth: buildProviderAuth({
+        providerId: 'alibaba',
+        dbKey: 'alibaba',
+        envVars: ['ALIBABA_CODE_API_KEY'],
+        displayName: 'Alibaba Code',
+        helpUrl: 'https://dashscope.aliyun.com',
+        assignOpenAiKey: true,
+      }),
+    };
+  }
+
+  if (model.providerId === 'zai') {
+    const providerName = 'zai';
+    return {
+      env: {},
+      configOverrides: [
+        `model="${model.id}"`,
+        `model_provider="${providerName}"`,
+        `model_providers.${providerName}.name="ZAI"`,
+        `model_providers.${providerName}.base_url="https://api.z.ai/api/coding/paas/v4"`,
+        `model_providers.${providerName}.env_key="ZAI_API_KEY"`,
+        `model_providers.${providerName}.wire_api="chat"`,
+      ],
+      providerAuth: buildProviderAuth({
+        providerId: 'zai',
+        dbKey: 'zai',
+        envVars: ['ZAI_API_KEY', 'ZAI_API_KEY_A', 'ZAI_API_KEY_P'],
+        displayName: 'Z.ai',
+        helpUrl: 'https://z.ai',
+        assignOpenAiKey: true,
+      }),
+    };
+  }
+
+  if (model.providerId === 'chutes') {
+    const providerName = 'chutes';
+    return {
+      env: {},
+      configOverrides: [
+        `model="${model.id}"`,
+        `model_provider="${providerName}"`,
+        `model_providers.${providerName}.name="Chutes"`,
+        `model_providers.${providerName}.base_url="https://llm.chutes.ai/v1"`,
+        `model_providers.${providerName}.env_key="CHUTES_API_KEY"`,
+        `model_providers.${providerName}.wire_api="chat"`,
+      ],
+      providerAuth: buildProviderAuth({
+        providerId: 'chutes',
+        dbKey: 'chutes',
+        envVars: ['CHUTES_API_KEY'],
+        displayName: 'Chutes',
+        helpUrl: 'https://chutes.ai',
+        assignOpenAiKey: true,
+      }),
+    };
+  }
+
+  return { env: {}, configOverrides: [], providerAuth: null };
+}
+
+function resolveCustomRuntimeProfile(model) {
+  if (!model?.custom) {
+    return { env: {}, configOverrides: [], providerAuth: null };
+  }
+
+  if (model.engine === 'claude') {
+    return {
+      configOverrides: [],
+      ...resolveClaudeCustomProfile(model),
+    };
+  }
+
+  if (model.engine === 'codex') {
+    return resolveCodexCustomProfile(model);
+  }
+
+  return { env: {}, configOverrides: [], providerAuth: null };
+}
+
+function getRuntimeDefaults(platformId) {
+  return {
+    claude: {
+      native: {
+        runtimeId: 'claude-native',
+        command: 'claude',
+        source: 'npm',
+        installCommand: `${npmCommand()} install -g @anthropic-ai/claude-code@latest`,
+        updateCommand: `${npmCommand()} update -g @anthropic-ai/claude-code`,
+        checkCommand: 'claude --version',
+        sharedBinary: true,
+      },
+      custom: {
+        runtimeId: 'claude-custom',
+        command: 'claude',
+        source: 'shared-cli',
+        installCommand: `${npmCommand()} install -g @anthropic-ai/claude-code@latest`,
+        updateCommand: `${npmCommand()} update -g @anthropic-ai/claude-code`,
+        checkCommand: 'claude --version',
+        sharedBinary: true,
+      },
+    },
+    codex: {
+      native: {
+        runtimeId: 'codex-native',
+        command: 'codex',
+        source: 'npm',
+        installCommand: `${npmCommand()} install -g @openai/codex@latest`,
+        updateCommand: `${npmCommand()} update -g @openai/codex`,
+        checkCommand: 'codex --version',
+      },
+      custom: {
+        runtimeId: 'codex-custom',
+        command: 'codex-lts',
+        source: platformId === 'termux' ? 'npm' : 'manual',
+        installCommand: platformId === 'termux'
+          ? `${npmCommand()} install -g @mmmbuto/codex-cli-termux@0.80.6-lts`
+          : null,
+        updateCommand: platformId === 'termux'
+          ? `${npmCommand()} update -g @mmmbuto/codex-cli-termux`
+          : null,
+        checkCommand: 'codex-lts --version',
+      },
+    },
+    gemini: {
+      native: {
+        runtimeId: 'gemini-native',
+        command: 'gemini',
+        source: 'npm',
+        installCommand: `${npmCommand()} install -g @google/gemini-cli@latest`,
+        updateCommand: `${npmCommand()} update -g @google/gemini-cli`,
+        checkCommand: 'gemini --version',
+      },
+      custom: {
+        runtimeId: 'gemini-custom',
+        command: 'gemini',
+        source: 'npm',
+        installCommand: `${npmCommand()} install -g @google/gemini-cli@latest`,
+        updateCommand: `${npmCommand()} update -g @google/gemini-cli`,
+        checkCommand: 'gemini --version',
+      },
+    },
+    qwen: {
+      native: {
+        runtimeId: 'qwen-native',
+        command: 'qwen',
+        source: platformId === 'termux' ? 'npm' : 'npm',
+        installCommand: `${npmCommand()} install -g @qwen-code/qwen-code@latest`,
+        updateCommand: `${npmCommand()} update -g @qwen-code/qwen-code`,
+        checkCommand: 'qwen --version',
+      },
+      custom: {
+        runtimeId: 'qwen-custom',
+        command: 'qwen',
+        source: platformId === 'termux' ? 'npm' : 'npm',
+        installCommand: `${npmCommand()} install -g @qwen-code/qwen-code@latest`,
+        updateCommand: `${npmCommand()} update -g @qwen-code/qwen-code`,
+        checkCommand: 'qwen --version',
+      },
+    },
+  };
+}
+
+class RuntimeManager {
+  constructor() {
+    this.platformId = getPlatformId();
+  }
+
+  getToolCatalog() {
+    return getCliTools();
+  }
+
+  getRuntimeDefinitions() {
+    const config = getConfig();
+    const defaults = getRuntimeDefaults(this.platformId);
+    const engines = this.getToolCatalog();
+
+    return Object.fromEntries(
+      Object.entries(engines).map(([engineId, engine]) => {
+        const configEngine = config.engines?.[engineId] || {};
+        const configLanes = configEngine.lanes || {};
+        const lanes = Object.fromEntries(
+          Object.entries(engine.lanes || {}).map(([laneId, lane]) => {
+            const defaultLane = defaults[engineId]?.[laneId] || {};
+            const configuredLane = configLanes[laneId] || {};
+            const command = configuredLane.command || configEngine.path || defaultLane.command;
+            const runtimeId = configuredLane.runtimeId || lane.runtimeId || defaultLane.runtimeId;
+            const enabled = configuredLane.enabled ?? configEngine.enabled ?? true;
+
+            return [laneId, {
+              engine: engineId,
+              lane: laneId,
+              laneLabel: lane.label || laneId,
+              runtimeId,
+              command,
+              enabled,
+              source: configuredLane.source || defaultLane.source || 'manual',
+              installCommand: configuredLane.installCommand || defaultLane.installCommand || null,
+              updateCommand: configuredLane.updateCommand || defaultLane.updateCommand || null,
+              checkCommand: configuredLane.checkCommand || defaultLane.checkCommand || `${command} --version`,
+              sharedBinary: configuredLane.sharedBinary ?? defaultLane.sharedBinary ?? false,
+            }];
+          })
+        );
+
+        return [engineId, lanes];
+      })
+    );
+  }
+
+  async probeCommand(command) {
+    if (!command) {
+      return { available: false, version: null, error: 'command not configured' };
+    }
+
+    try {
+      const { stdout, stderr } = await execFileAsync(command, ['--version'], {
+        timeout: 10000,
+        env: process.env,
+      });
+      return {
+        available: true,
+        version: (stdout || stderr || '').trim() || 'unknown',
+        error: null,
+      };
+    } catch (error) {
+      return {
+        available: false,
+        version: null,
+        error: error.message,
+      };
+    }
+  }
+
+  async getRuntimeInventory() {
+    const definitions = this.getRuntimeDefinitions();
+    const tools = this.getToolCatalog();
+    const inventory = [];
+
+    for (const [engineId, lanes] of Object.entries(definitions)) {
+      for (const [laneId, runtime] of Object.entries(lanes)) {
+        const probe = await this.probeCommand(runtime.command);
+        const laneModels = tools[engineId]?.models?.filter((model) => model.lane === laneId) || [];
+        inventory.push({
+          ...runtime,
+          platform: this.platformId,
+          status: probe.available ? 'available' : 'missing',
+          installedVersion: probe.version,
+          latestVersion: 'upstream',
+          available: probe.available,
+          error: probe.error,
+          models: laneModels.map((model) => ({
+            id: model.id,
+            label: model.label,
+            providerId: model.providerId,
+          })),
+          actions: [
+            runtime.installCommand ? 'install' : null,
+            runtime.updateCommand ? 'update' : null,
+            'check',
+          ].filter(Boolean),
+        });
+      }
+    }
+
+    return inventory;
+  }
+
+  async getRuntimeInventoryMap() {
+    const inventory = await this.getRuntimeInventory();
+    return Object.fromEntries(inventory.map((item) => [item.runtimeId, item]));
+  }
+
+  async getRuntimeAwareCliTools() {
+    const tools = this.getToolCatalog();
+    const inventoryMap = await this.getRuntimeInventoryMap();
+
+    return Object.fromEntries(Object.entries(tools).map(([engineId, engine]) => {
+      const models = (engine.models || []).map((model) => {
+        const runtime = inventoryMap[model.runtimeId];
+        return {
+          ...model,
+          availability: runtime?.status || 'unknown',
+          runtimeStatus: runtime?.status || 'unknown',
+          runtimeCommand: runtime?.command || null,
+          runtimeSource: runtime?.source || null,
+          available: runtime?.available ?? false,
+        };
+      });
+
+      return [engineId, {
+        ...engine,
+        models,
+      }];
+    }));
+  }
+
+  resolveModel(modelId) {
+    return getModelById(modelId) || getModelById(getDefaultModelId());
+  }
+
+  resolveRuntimeSelection({ engine, lane, runtimeId, modelId }) {
+    const model = this.resolveModel(modelId);
+    const resolvedEngine = engine || model?.engine;
+    const resolvedLane = lane || model?.lane || 'native';
+    const definitions = this.getRuntimeDefinitions();
+    const runtime = runtimeId
+      ? Object.values(definitions[resolvedEngine] || {}).find((entry) => entry.runtimeId === runtimeId)
+      : definitions[resolvedEngine]?.[resolvedLane];
+    const customProfile = resolveCustomRuntimeProfile(model);
+
+    return {
+      engine: resolvedEngine,
+      lane: resolvedLane,
+      runtimeId: runtime?.runtimeId || model?.runtimeId || null,
+      command: runtime?.command || null,
+      env: customProfile.env || {},
+      configOverrides: customProfile.configOverrides || [],
+      providerAuth: customProfile.providerAuth || null,
+      model,
+      runtime,
+    };
+  }
+
+  resolveAction(runtimeId, action) {
+    const definitions = this.getRuntimeDefinitions();
+    for (const lanes of Object.values(definitions)) {
+      for (const runtime of Object.values(lanes)) {
+        if (runtime.runtimeId !== runtimeId) continue;
+        if (action === 'install') return runtime.installCommand;
+        if (action === 'update') return runtime.updateCommand;
+        if (action === 'check') return runtime.checkCommand;
+      }
+    }
+    return null;
+  }
+}
+
+module.exports = RuntimeManager;

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

@@ -161,14 +161,19 @@ class SessionImporter {
 
   /**
    * Controlla se la sessione esiste già
+   * Returns false if sessions table doesn't exist (allows import)
    */
   sessionExists(sessionId) {
     try {
       const stmt = prepare('SELECT 1 FROM sessions WHERE id = ?');
       return !!stmt.get(sessionId);
     } catch (err) {
+      // If sessions table doesn't exist, return false to allow import
+      if (err.message && err.message.includes('no such table')) {
+        return false;
+      }
       console.warn(`[SessionImporter] exists check failed: ${err.message}`);
-      return true; // default to skip to avoid duplicates
+      return true; // default to skip to avoid duplicates on other errors
     }
   }
 

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

@@ -172,6 +172,37 @@ class SessionManager {
     return workspacePath.replace(/\/+$/, '');
   }
 
+  _buildRuntimeState(engine, options = {}) {
+    const normalizedEngine = this._normalizeEngine(engine);
+    return {
+      lane: options.lane || 'native',
+      runtimeId: options.runtimeId || `${normalizedEngine}-native`,
+      providerId: options.providerId || null,
+      modelId: options.modelId || null,
+    };
+  }
+
+  _saveSessionRuntimeState(sessionId, runtimeState = {}) {
+    try {
+      const stmt = prepare(`
+        UPDATE sessions
+        SET lane = ?, runtime_id = ?, provider_id = ?, model_id = ?, last_used_at = ?
+        WHERE id = ?
+      `);
+      stmt.run(
+        runtimeState.lane || 'native',
+        runtimeState.runtimeId || null,
+        runtimeState.providerId || null,
+        runtimeState.modelId || null,
+        Date.now(),
+        sessionId
+      );
+      saveDb();
+    } catch (error) {
+      console.warn(`[SessionManager] Failed to save runtime state for ${sessionId}:`, error.message);
+    }
+  }
+
   /**
    * Get or create session for conversation + engine
    *
@@ -187,10 +218,11 @@ class SessionManager {
    * @param {string} workspacePath - Workspace directory path
    * @returns {{ sessionId: string, isNew: boolean }}
    */
-  async getOrCreateSession(conversationId, engine, workspacePath) {
+  async getOrCreateSession(conversationId, engine, workspacePath, options = {}) {
     const normalizedEngine = this._normalizeEngine(engine);
     const normalizedPath = this._normalizePath(workspacePath);
     const cacheKey = this._getCacheKey(conversationId, normalizedEngine);
+    const runtimeState = this._buildRuntimeState(normalizedEngine, options);
 
     console.log(`[SessionManager] getOrCreateSession(${conversationId}, ${normalizedEngine}, ${normalizedPath})`);
 
@@ -223,6 +255,7 @@ class SessionManager {
         // 3. Verify session file exists on filesystem
         if (this.sessionFileExists(row.id, normalizedEngine, row.workspace_path || normalizedPath)) {
           // Valid session - update cache and return
+          this._saveSessionRuntimeState(row.id, runtimeState);
           this.sessionMap.set(cacheKey, row.id);
           this.lastAccess.set(cacheKey, Date.now());
           console.log(`[SessionManager] DB hit, verified: ${row.id}`);
@@ -245,11 +278,26 @@ class SessionManager {
     // 5. Save to DB (metadata only - file created by CLI)
     try {
       const insertStmt = prepare(`
-        INSERT INTO sessions (id, workspace_path, engine, conversation_id, title, created_at, last_used_at)
-        VALUES (?, ?, ?, ?, ?, ?, ?)
+        INSERT INTO sessions (
+          id, workspace_path, engine, conversation_id, title, created_at, last_used_at,
+          lane, runtime_id, provider_id, model_id
+        )
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
       `);
       const title = 'New Chat'; // Will be updated after first response
-      insertStmt.run(sessionId, normalizedPath, normalizedEngine, conversationId, title, now, now);
+      insertStmt.run(
+        sessionId,
+        normalizedPath,
+        normalizedEngine,
+        conversationId,
+        title,
+        now,
+        now,
+        runtimeState.lane,
+        runtimeState.runtimeId,
+        runtimeState.providerId,
+        runtimeState.modelId
+      );
       saveDb();
       console.log(`[SessionManager] Saved to DB: ${sessionId}`);
     } catch (dbErr) {
@@ -310,15 +358,6 @@ class SessionManager {
     }
   }
 
-  /**
-   * Convert workspace path to slug (matches Claude Code behavior)
-   * /path/to/dir → -path-to-dir (also converts dots to dashes)
-   */
-  _pathToSlug(workspacePath) {
-    if (!workspacePath) return '-default';
-    return workspacePath.replace(/[\/\.]/g, '-');
-  }
-
   /**
    * Delete all sessions for a conversation (cleanup)
    * Called when conversation is deleted
@@ -578,8 +617,11 @@ class SessionManager {
 const sessionManager = new SessionManager();
 
 // Periodic cache cleanup (every 10 minutes)
-setInterval(() => {
+const cleanupTimer = setInterval(() => {
   sessionManager.cleanCache();
 }, 10 * 60 * 1000);
+if (typeof cleanupTimer.unref === 'function') {
+  cleanupTimer.unref();
+}
 
 module.exports = sessionManager;