@mmmbuto/nexuscli 0.9.7005-termux → 0.10.0

package/lib/server/routes/runtimes.js

@@ -0,0 +1,68 @@
+const express = require('express');
+const RuntimeManager = require('../services/runtime-manager');
+const { createJob } = require('../services/job-runner');
+
+const router = express.Router();
+const runtimeManager = new RuntimeManager();
+
+router.get('/', async (_req, res) => {
+  try {
+    const inventory = await runtimeManager.getRuntimeInventory();
+    res.json({
+      platform: runtimeManager.platformId,
+      runtimes: inventory,
+    });
+  } catch (error) {
+    console.error('[Runtimes] Inventory error:', error);
+    res.status(500).json({ error: 'Failed to fetch runtime inventory' });
+  }
+});
+
+router.post('/check', async (_req, res) => {
+  try {
+    const inventory = await runtimeManager.getRuntimeInventory();
+    res.json({
+      platform: runtimeManager.platformId,
+      runtimes: inventory,
+      checkedAt: new Date().toISOString(),
+    });
+  } catch (error) {
+    console.error('[Runtimes] Check error:', error);
+    res.status(500).json({ error: 'Failed to check runtimes' });
+  }
+});
+
+function queueRuntimeAction(req, res, action) {
+  const { runtimeId } = req.body || {};
+
+  if (!runtimeId) {
+    return res.status(400).json({ error: 'runtimeId required' });
+  }
+
+  const command = runtimeManager.resolveAction(runtimeId, action);
+  if (!command) {
+    return res.status(400).json({ error: `No ${action} command configured for ${runtimeId}` });
+  }
+
+  const job = createJob({
+    tool: 'bash',
+    command,
+    timeout: action === 'check' ? 15000 : 180000,
+    metadata: {
+      runtimeId,
+      action,
+      platform: runtimeManager.platformId,
+    },
+  });
+
+  return res.status(202).json({
+    ...job,
+    runtimeId,
+    action,
+  });
+}
+
+router.post('/install', (req, res) => queueRuntimeAction(req, res, 'install'));
+router.post('/update', (req, res) => queueRuntimeAction(req, res, 'update'));
+
+module.exports = router;

package/lib/server/server.js

@@ -24,6 +24,7 @@ const codexRouter = require('./routes/codex');
 const geminiRouter = require('./routes/gemini');
 const qwenRouter = require('./routes/qwen');
 const modelsRouter = require('./routes/models');
+const runtimesRouter = require('./routes/runtimes');
 const workspaceRouter = require('./routes/workspace');
 const workspacesRouter = require('./routes/workspaces');
 const sessionsRouter = require('./routes/sessions');
@@ -67,6 +68,7 @@ app.use(express.static(frontendDist));
 app.use('/api/v1/auth', authRouter);
 app.use('/api/v1/models', modelsRouter);
 app.use('/api/v1/config', configRouter);
+app.use('/api/v1/runtimes', authMiddleware, runtimesRouter);
 app.use('/api/v1/workspace', workspaceRouter);
 app.use('/api/v1', wakeLockRouter); // Wake lock endpoints (public for app visibility handling)
 app.use('/api/v1/workspaces', authMiddleware, workspacesRouter);
@@ -95,6 +97,7 @@ app.get('/', (req, res) => {
     endpoints: {
       health: '/health',
       models: '/api/v1/models',
+      runtimes: '/api/v1/runtimes',
       chat: '/api/v1/chat (Claude)',
       codex: '/api/v1/codex (OpenAI)',
       gemini: '/api/v1/gemini (Google)',

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

@@ -9,7 +9,7 @@ const { getApiKey } = require('../db');
  * Wrapper for Claude Code CLI (local installation)
  *
  * Features:
- * - Uses local Claude Code installation (/home/dag/.claude/local/claude)
+ * - Uses a local Claude Code installation discovered from PATH/common locations
  * - OAuth authentication (handled by CLI)
  * - Real-time status streaming via onStatus callback
  * - Session management with conversation ID
@@ -134,6 +134,23 @@ class ClaudeWrapper extends BaseCliWrapper {
     }
   }
 
+  resolveProviderToken(providerAuth) {
+    if (!providerAuth) return null;
+
+    const envVars = providerAuth.envVars || [];
+    for (const envVar of envVars) {
+      if (process.env[envVar]) {
+        return process.env[envVar];
+      }
+    }
+
+    if (providerAuth.dbKey) {
+      return getApiKey(providerAuth.dbKey);
+    }
+
+    return null;
+  }
+
   /**
    * Send message to Claude Code CLI
    *
@@ -145,7 +162,16 @@ class ClaudeWrapper extends BaseCliWrapper {
    * @param {Function} params.onStatus - Callback for status events (tool use, thinking)
    * @returns {Promise<{text: string, usage: Object}>}
    */
-  async sendMessage({ prompt, conversationId, model = 'sonnet', workspacePath, onStatus }) {
+  async sendMessage({
+    prompt,
+    conversationId,
+    model = 'sonnet',
+    workspacePath,
+    onStatus,
+    runtimeCommand,
+    envOverrides = {},
+    providerAuth = null
+  }) {
     return new Promise((resolve, reject) => {
       const parser = new OutputParser();
       // Prevent double-settling when PTY fires both error and exit events
@@ -164,9 +190,11 @@ class ClaudeWrapper extends BaseCliWrapper {
       const isExistingSession = this.isExistingSession(conversationId);
 
       // Detect alternative models early (needed for args construction)
-      const isDeepSeek = model.startsWith('deepseek-');
-      const isGLM = model === 'glm-4-6';
-      const isAlternativeModel = isDeepSeek || isGLM;
+      const isAlternativeModel = Boolean(
+        providerAuth ||
+        envOverrides.ANTHROPIC_BASE_URL ||
+        envOverrides.ANTHROPIC_MODEL
+      );
 
       // Build Claude Code CLI args
       const args = [
@@ -176,8 +204,8 @@ class ClaudeWrapper extends BaseCliWrapper {
         '--output-format', 'stream-json', // JSON streaming events
       ];
 
-      // Only pass --model for native Claude models
-      // Alternative models (DeepSeek, GLM) use ANTHROPIC_MODEL env var
+      // Only pass --model for native Claude models.
+      // Custom lanes route through ANTHROPIC_* env overrides instead.
       if (!isAlternativeModel) {
         args.push('--model', model);
       }
@@ -197,46 +225,27 @@ class ClaudeWrapper extends BaseCliWrapper {
       // Termux compatibility: make sure ripgrep path exists before spawn
       this.ensureRipgrepForTermux();
 
-      // Build environment - configure API for alternative models
-      const spawnEnv = { ...process.env };
-
-      if (isDeepSeek) {
-        // Get API key from database (priority) or fallback to env var
-        const deepseekKey = getApiKey('deepseek') || process.env.DEEPSEEK_API_KEY;
+      const spawnEnv = { ...process.env, ...envOverrides };
 
-        if (!deepseekKey) {
-          const errorMsg = `DeepSeek API key not configured!\n\n` +
-            `Run this command to add your API key:\n` +
-            `  nexuscli api set deepseek YOUR_API_KEY\n\n` +
-            `Get your key at: https://platform.deepseek.com/api_keys`;
-
-          console.error(`[ClaudeWrapper] ❌ ${errorMsg}`);
-
-          if (onStatus) {
-            onStatus({
-              type: 'error',
-              category: 'config',
-              message: errorMsg
-            });
-          }
+      if (isAlternativeModel) {
+        if (!spawnEnv.ANTHROPIC_MODEL) {
+          spawnEnv.ANTHROPIC_MODEL = model;
+        }
 
-          return reject(new Error(errorMsg));
+        if (!spawnEnv.ANTHROPIC_AUTH_TOKEN) {
+          spawnEnv.ANTHROPIC_AUTH_TOKEN = this.resolveProviderToken(providerAuth);
         }
 
-        // DeepSeek uses Anthropic-compatible API at different endpoint
-        spawnEnv.ANTHROPIC_BASE_URL = 'https://api.deepseek.com/anthropic';
-        spawnEnv.ANTHROPIC_AUTH_TOKEN = deepseekKey;
-        spawnEnv.ANTHROPIC_MODEL = model; // Pass model name to API
-        console.log(`[ClaudeWrapper] DeepSeek detected - using api.deepseek.com/anthropic`);
-      } else if (isGLM) {
-        // Get API key from database (priority) or fallback to env var
-        const glmKey = getApiKey('zai') || process.env.ZAI_API_KEY;
-
-        if (!glmKey) {
-          const errorMsg = `Z.ai API key not configured for GLM-4.6!\n\n` +
+        if (!spawnEnv.ANTHROPIC_AUTH_TOKEN) {
+          const providerLabel = providerAuth?.displayName || 'custom provider';
+          const providerKeyHint = providerAuth?.dbKey
+            ? `  nexuscli api set ${providerAuth.dbKey} YOUR_API_KEY\n\n`
+            : '';
+          const helpUrl = providerAuth?.helpUrl || 'your provider dashboard';
+          const errorMsg = `${providerLabel} API key not configured!\n\n` +
             `Run this command to add your API key:\n` +
-            `  nexuscli api set zai YOUR_API_KEY\n\n` +
-            `Get your key at: https://z.ai`;
+            providerKeyHint +
+            `Get your key at: ${helpUrl}`;
 
           console.error(`[ClaudeWrapper] ❌ ${errorMsg}`);
 
@@ -250,29 +259,22 @@ class ClaudeWrapper extends BaseCliWrapper {
 
           return reject(new Error(errorMsg));
         }
-
-        // GLM-4.6 uses Z.ai Anthropic-compatible API
-        spawnEnv.ANTHROPIC_BASE_URL = 'https://api.z.ai/api/anthropic';
-        spawnEnv.ANTHROPIC_AUTH_TOKEN = glmKey;
-        spawnEnv.ANTHROPIC_MODEL = 'GLM-4.6'; // Z.ai model name
-        spawnEnv.API_TIMEOUT_MS = '3000000'; // 50 minutes timeout
-        console.log(`[ClaudeWrapper] GLM-4.6 detected - using Z.ai API with extended timeout`);
       }
 
-      console.log(`[ClaudeWrapper] Model: ${model}${isDeepSeek ? ' (DeepSeek API)' : isGLM ? ' (Z.ai API)' : ''}`);
+      console.log(`[ClaudeWrapper] Model: ${model}${isAlternativeModel ? ' (custom provider)' : ''}`);
       console.log(`[ClaudeWrapper] Session: ${conversationId} (${isExistingSession ? 'RESUME' : 'NEW'})`);
       console.log(`[ClaudeWrapper] Working dir: ${cwd}`);
 
       // Spawn Claude Code CLI with PTY
       // On Termux, invoke node directly with the cli.js script for better compatibility
-      let command = this.claudePath;
+      let command = runtimeCommand || this.claudePath;
       let spawnArgs = args;
 
-      if (!pty.isPtyAvailable() && this.claudePath.endsWith('/claude')) {
+      if (!pty.isPtyAvailable() && command && command.endsWith('/claude')) {
         // Resolve symlink to actual cli.js and invoke with node
         const fs = require('fs');
         try {
-          const realPath = fs.realpathSync(this.claudePath);
+          const realPath = fs.realpathSync(command);
           if (realPath.endsWith('.js')) {
             command = process.execPath; // node binary
             spawnArgs = [realPath, ...args];
@@ -357,15 +359,11 @@ class ClaudeWrapper extends BaseCliWrapper {
       let stdout = '';
 
       // Dynamic timeout based on model
-      let timeoutMs = 600000; // 10 minutes default
-      let timeoutLabel = '10 minutes';
-      if (isGLM) {
-        timeoutMs = 3600000; // 60 minutes for GLM-4.6 (slow responses)
-        timeoutLabel = '60 minutes';
-      } else if (isDeepSeek) {
-        timeoutMs = 900000; // 15 minutes for DeepSeek
-        timeoutLabel = '15 minutes';
-      }
+      const configuredTimeout = Number.parseInt(spawnEnv.API_TIMEOUT_MS || '', 10);
+      const timeoutMs = Number.isFinite(configuredTimeout) && configuredTimeout > 0
+        ? configuredTimeout
+        : 600000;
+      const timeoutLabel = `${Math.ceil(timeoutMs / 60000)} minutes`;
 
       const timeout = setTimeout(() => {
         console.error(`[ClaudeWrapper] Timeout after ${timeoutLabel}`);

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

@@ -11,6 +11,7 @@
 const { spawn, exec } = require('child_process');
 const CodexOutputParser = require('./codex-output-parser');
 const BaseCliWrapper = require('./base-cli-wrapper');
+const { getApiKey } = require('../db');
 
 class CodexWrapper extends BaseCliWrapper {
   constructor(options = {}) {
@@ -23,6 +24,23 @@ class CodexWrapper extends BaseCliWrapper {
     console.log('[CodexWrapper] Binary:', this.codexBin);
   }
 
+  resolveProviderToken(providerAuth) {
+    if (!providerAuth) return null;
+
+    const envVars = providerAuth.envVars || [];
+    for (const envVar of envVars) {
+      if (process.env[envVar]) {
+        return process.env[envVar];
+      }
+    }
+
+    if (providerAuth.dbKey) {
+      return getApiKey(providerAuth.dbKey);
+    }
+
+    return null;
+  }
+
   /**
    * Send message and get response with streaming events
    * @param {Object} options - Message options
@@ -35,7 +53,20 @@ class CodexWrapper extends BaseCliWrapper {
    * @param {Function} options.onStatus - Callback for status events
    * @returns {Promise<Object>} Response with text, usage, threadId
    */
-  async sendMessage({ prompt, model, threadId, reasoningEffort, workspacePath, imageFiles = [], onStatus, processId: processIdOverride }) {
+  async sendMessage({
+    prompt,
+    model,
+    threadId,
+    reasoningEffort,
+    workspacePath,
+    imageFiles = [],
+    onStatus,
+    processId: processIdOverride,
+    runtimeCommand,
+    envOverrides = {},
+    configOverrides = [],
+    providerAuth = null
+  }) {
     return new Promise((resolve, reject) => {
       const parser = new CodexOutputParser();
       const cwd = workspacePath || this.workspaceDir;
@@ -59,6 +90,14 @@ class CodexWrapper extends BaseCliWrapper {
         args.push('-c', `model_reasoning_effort="${reasoningEffort}"`);
       }
 
+      if (!threadId && Array.isArray(configOverrides)) {
+        for (const override of configOverrides) {
+          if (override) {
+            args.push('-c', override);
+          }
+        }
+      }
+
       // Add image files for multimodal support (only for new sessions)
       if (imageFiles && imageFiles.length > 0 && !threadId) {
         for (const imagePath of imageFiles) {
@@ -84,12 +123,40 @@ class CodexWrapper extends BaseCliWrapper {
 
       let stdout = '';
 
-      const proc = spawn(this.codexBin, args, {
+      const command = runtimeCommand || this.codexBin;
+      const spawnEnv = {
+        ...global.process.env,
+        TERM: 'xterm-256color',
+        ...envOverrides,
+      };
+      const providerToken = this.resolveProviderToken(providerAuth);
+      if (providerAuth && !providerToken) {
+        const providerLabel = providerAuth.displayName || 'custom provider';
+        const providerKeyHint = providerAuth.dbKey
+          ? `  nexuscli api set ${providerAuth.dbKey} YOUR_API_KEY\n\n`
+          : '';
+        const helpUrl = providerAuth.helpUrl || 'your provider dashboard';
+        return reject(new Error(
+          `${providerLabel} API key not configured!\n\n` +
+          `Run this command to add your API key:\n` +
+          providerKeyHint +
+          `Get your key at: ${helpUrl}`
+        ));
+      }
+      if (providerToken) {
+        if (providerAuth?.assignOpenAiKey) {
+          spawnEnv.OPENAI_API_KEY = providerToken;
+        }
+        for (const envVar of providerAuth?.envVars || []) {
+          if (!spawnEnv[envVar]) {
+            spawnEnv[envVar] = providerToken;
+          }
+        }
+      }
+
+      const proc = spawn(command, args, {
         cwd: cwd,
-        env: {
-          ...global.process.env,
-          TERM: 'xterm-256color',
-        },
+        env: spawnEnv,
       });
 
       // Register process for interrupt capability
@@ -208,9 +275,10 @@ class CodexWrapper extends BaseCliWrapper {
   /**
    * Check if Codex CLI is available
    */
-  async isAvailable() {
+  async isAvailable(runtimeCommand) {
     return new Promise((resolve) => {
-      exec(`${this.codexBin} --version`, (error, stdout) => {
+      const command = runtimeCommand || this.codexBin;
+      exec(`${command} --version`, (error, stdout) => {
         if (error) {
           console.log('[CodexWrapper] Codex CLI not available:', error.message);
           resolve(false);
@@ -225,9 +293,10 @@ class CodexWrapper extends BaseCliWrapper {
   /**
    * Check if exec subcommand is available
    */
-  async hasExecSupport() {
+  async hasExecSupport(runtimeCommand) {
     return new Promise((resolve) => {
-      exec(`${this.codexBin} exec --help`, (error, stdout) => {
+      const command = runtimeCommand || this.codexBin;
+      exec(`${command} exec --help`, (error, stdout) => {
         if (error) {
           console.log('[CodexWrapper] exec subcommand not available');
           resolve(false);

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

@@ -111,7 +111,9 @@ class GeminiWrapper extends BaseCliWrapper {
     model = DEFAULT_MODEL,
     workspacePath,
     onStatus,
-    processId: processIdOverride
+    processId: processIdOverride,
+    runtimeCommand,
+    envOverrides = {}
   }) {
     return new Promise((resolve, reject) => {
       const parser = new GeminiOutputParser();
@@ -143,7 +145,8 @@ class GeminiWrapper extends BaseCliWrapper {
       // Spawn Gemini CLI with PTY
       let ptyProcess;
       try {
-        ptyProcess = pty.spawn(this.geminiPath, args, {
+        const command = runtimeCommand || this.geminiPath;
+        ptyProcess = pty.spawn(command, args, {
           name: 'xterm-color',
           cols: 120,
           rows: 40,
@@ -151,6 +154,7 @@ class GeminiWrapper extends BaseCliWrapper {
           env: {
             ...process.env,
             TERM: 'xterm-256color',
+            ...envOverrides,
           }
         });
       } catch (spawnError) {
@@ -281,10 +285,11 @@ class GeminiWrapper extends BaseCliWrapper {
    * Check if Gemini CLI is available
    * @returns {Promise<boolean>}
    */
-  async isAvailable() {
+  async isAvailable(runtimeCommand) {
     return new Promise((resolve) => {
       const { exec } = require('child_process');
-      exec(`${this.geminiPath} --version`, { timeout: 5000 }, (error, stdout) => {
+      const command = runtimeCommand || this.geminiPath;
+      exec(`${command} --version`, { timeout: 5000 }, (error, stdout) => {
         if (error) {
           console.log('[GeminiWrapper] CLI not available:', error.message);
           resolve(false);

package/lib/server/services/job-runner.js

@@ -0,0 +1,156 @@
+const { v4: uuidv4 } = require('uuid');
+const CliWrapper = require('../lib/cli-wrapper');
+const db = require('../db');
+
+const cliWrapper = new CliWrapper({
+  workspaceDir: process.cwd()
+});
+
+function ensureSseMap() {
+  if (!global.sseConnections) {
+    global.sseConnections = new Map();
+  }
+}
+
+function emitSSE(jobId, event) {
+  ensureSseMap();
+  const res = global.sseConnections.get(jobId);
+  if (!res) return;
+
+  try {
+    res.write(`data: ${JSON.stringify(event)}\n\n`);
+  } catch (error) {
+    console.error(`[Jobs] SSE write error for job ${jobId}:`, error);
+    global.sseConnections.delete(jobId);
+  }
+}
+
+async function executeJob(jobId, { tool, command, workingDir, timeout }) {
+  console.log(`[Jobs] Executing job ${jobId}`);
+
+  let stmt = db.prepare(`
+    UPDATE jobs
+    SET status = ?, started_at = ?
+    WHERE id = ?
+  `);
+  stmt.run('executing', Date.now(), jobId);
+
+  emitSSE(jobId, {
+    type: 'status',
+    category: 'executing',
+    message: 'Executing on localhost...',
+    icon: '▶',
+    timestamp: new Date().toISOString()
+  });
+
+  try {
+    const result = await cliWrapper.execute({
+      jobId,
+      tool,
+      command,
+      workingDir,
+      timeout,
+      onStatus: (event) => emitSSE(jobId, event)
+    });
+
+    stmt = db.prepare(`
+      UPDATE jobs
+      SET status = ?, exit_code = ?, stdout = ?, stderr = ?,
+          duration = ?, completed_at = ?
+      WHERE id = ?
+    `);
+
+    const status = result.exitCode === 0 ? 'completed' : 'failed';
+    stmt.run(
+      status,
+      result.exitCode,
+      result.stdout,
+      result.stderr,
+      result.duration,
+      Date.now(),
+      jobId
+    );
+
+    emitSSE(jobId, {
+      type: 'response_done',
+      exitCode: result.exitCode,
+      duration: result.duration
+    });
+    emitSSE(jobId, { type: 'done' });
+  } catch (error) {
+    console.error(`[Jobs] Job ${jobId} error:`, error);
+
+    stmt = db.prepare(`
+      UPDATE jobs
+      SET status = ?, stderr = ?, completed_at = ?
+      WHERE id = ?
+    `);
+    stmt.run('failed', error.message, Date.now(), jobId);
+
+    emitSSE(jobId, {
+      type: 'error',
+      error: error.message
+    });
+    emitSSE(jobId, { type: 'done' });
+  }
+}
+
+function createJob({
+  conversationId = null,
+  messageId = null,
+  nodeId = 'localhost',
+  tool = 'bash',
+  command,
+  workingDir,
+  timeout = 30000,
+  metadata = null,
+}) {
+  const jobId = uuidv4();
+  const now = Date.now();
+
+  const decoratedCommand = metadata ? `${command}\n# ${JSON.stringify(metadata)}` : command;
+
+  const stmt = db.prepare(`
+    INSERT INTO jobs (
+      id, conversation_id, message_id, node_id, tool, command,
+      status, created_at
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+  `);
+
+  stmt.run(
+    jobId,
+    conversationId,
+    messageId,
+    nodeId,
+    tool,
+    decoratedCommand,
+    'queued',
+    now
+  );
+
+  setImmediate(() => {
+    executeJob(jobId, { tool, command, workingDir, timeout });
+  });
+
+  return {
+    jobId,
+    nodeId,
+    tool,
+    command,
+    status: 'queued',
+    createdAt: now,
+    streamEndpoint: `/api/v1/jobs/${jobId}/stream`
+  };
+}
+
+function killJob(jobId) {
+  return cliWrapper.kill(jobId);
+}
+
+module.exports = {
+  createJob,
+  executeJob,
+  emitSSE,
+  ensureSseMap,
+  killJob,
+};