@mmmbuto/nexuscli 0.9.7005-termux → 0.10.0

package/lib/server/tests/runtime-manager.test.js

@@ -0,0 +1,46 @@
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+describe('RuntimeManager', () => {
+  let RuntimeManager;
+
+  beforeEach(() => {
+    process.env.HOME = fs.mkdtempSync(path.join(os.tmpdir(), 'nexuscli-home-'));
+    jest.resetModules();
+    RuntimeManager = require('../services/runtime-manager');
+  });
+
+  test('resolves Claude custom provider env for Alibaba-backed models', () => {
+    const runtimeManager = new RuntimeManager();
+    const selection = runtimeManager.resolveRuntimeSelection({ modelId: 'qwen3-max-2026-01-23' });
+
+    expect(selection.engine).toBe('claude');
+    expect(selection.lane).toBe('custom');
+    expect(selection.runtimeId).toBe('claude-custom');
+    expect(selection.env.ANTHROPIC_BASE_URL).toBe('https://coding-intl.dashscope.aliyuncs.com/apps/anthropic');
+    expect(selection.env.ANTHROPIC_MODEL).toBe('qwen3-max-2026-01-23');
+    expect(selection.providerAuth).toMatchObject({
+      providerId: 'alibaba',
+      dbKey: 'alibaba',
+      envVars: ['ALIBABA_CODE_API_KEY'],
+    });
+  });
+
+  test('resolves Codex custom provider config overrides for Chutes', () => {
+    const runtimeManager = new RuntimeManager();
+    const selection = runtimeManager.resolveRuntimeSelection({ modelId: 'deepseek-ai/DeepSeek-V3.2-TEE' });
+
+    expect(selection.engine).toBe('codex');
+    expect(selection.lane).toBe('custom');
+    expect(selection.runtimeId).toBe('codex-custom');
+    expect(selection.configOverrides).toContain('model_provider="chutes"');
+    expect(selection.configOverrides).toContain('model_providers.chutes.base_url="https://llm.chutes.ai/v1"');
+    expect(selection.providerAuth).toMatchObject({
+      providerId: 'chutes',
+      dbKey: 'chutes',
+      envVars: ['CHUTES_API_KEY'],
+      assignOpenAiKey: true,
+    });
+  });
+});

package/lib/server/tests/runtime-persistence.test.js

@@ -0,0 +1,97 @@
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+describe('Runtime-aware persistence', () => {
+  let initDb;
+  let prepare;
+  let getDb;
+  let Message;
+  let Conversation;
+  let sessionManager;
+
+  beforeEach(async () => {
+    process.env.HOME = fs.mkdtempSync(path.join(os.tmpdir(), 'nexuscli-home-'));
+    jest.resetModules();
+    ({ initDb, prepare, getDb } = require('../db'));
+    await initDb();
+    Message = require('../models/Message');
+    Conversation = require('../models/Conversation');
+    sessionManager = require('../services/session-manager');
+  });
+
+  afterEach(() => {
+    try {
+      const db = getDb();
+      if (db && typeof db.close === 'function') {
+        db.close();
+      }
+    } catch (_) {
+      // ignore cleanup errors
+    }
+  });
+
+  test('Conversation.create seeds native runtime metadata in sessions', () => {
+    const conversation = Conversation.create('Runtime test', '/tmp/runtime-test');
+    const row = prepare('SELECT engine, lane, runtime_id, provider_id, model_id FROM sessions WHERE id = ?').get(conversation.id);
+
+    expect(row).toMatchObject({
+      engine: 'claude',
+      lane: 'native',
+      runtime_id: 'claude-native',
+      provider_id: 'anthropic',
+      model_id: 'sonnet',
+    });
+  });
+
+  test('Message.create persists lane/runtime/provider/model metadata', () => {
+    const conversation = Conversation.create('Message runtime', '/tmp/runtime-test');
+    const message = Message.create(
+      conversation.id,
+      'user',
+      'hello',
+      { workspace: '/tmp/runtime-test' },
+      Date.now(),
+      'codex',
+      {
+        lane: 'custom',
+        runtimeId: 'codex-custom',
+        providerId: 'alibaba',
+        modelId: 'qwen3-coder-plus',
+      }
+    );
+
+    const row = prepare('SELECT engine, lane, runtime_id, provider_id, model_id FROM messages WHERE id = ?').get(message.id);
+    expect(row).toMatchObject({
+      engine: 'codex',
+      lane: 'custom',
+      runtime_id: 'codex-custom',
+      provider_id: 'alibaba',
+      model_id: 'qwen3-coder-plus',
+    });
+  });
+
+  test('SessionManager persists runtime metadata for new sessions', async () => {
+    const result = await sessionManager.getOrCreateSession(
+      'conv-runtime',
+      'codex',
+      '/tmp/runtime-test',
+      {
+        lane: 'custom',
+        runtimeId: 'codex-custom',
+        providerId: 'chutes',
+        modelId: 'deepseek-ai/DeepSeek-V3.2-TEE',
+      }
+    );
+
+    expect(result.isNew).toBe(true);
+    const row = prepare('SELECT engine, lane, runtime_id, provider_id, model_id FROM sessions WHERE id = ?').get(result.sessionId);
+    expect(row).toMatchObject({
+      engine: 'codex',
+      lane: 'custom',
+      runtime_id: 'codex-custom',
+      provider_id: 'chutes',
+      model_id: 'deepseek-ai/DeepSeek-V3.2-TEE',
+    });
+  });
+});

package/lib/setup/postinstall-pty-check.js

@@ -0,0 +1,183 @@
+/**
+ * PTY Dependency Check for NexusCLI Post-Install
+ * Detects platform and installs appropriate PTY provider
+ */
+
+const { execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+const colors = {
+  green: (s) => `\x1b[32m${s}\x1b[0m`,
+  yellow: (s) => `\x1b[33m${s}\x1b[0m`,
+  red: (s) => `\x1b[31m${s}\x1b[0m`,
+  cyan: (s) => `\x1b[36m${s}\x1b[0m`,
+  gray: (s) => `\x1b[90m${s}\x1b[0m`
+};
+
+function log(msg) { console.log(msg); }
+function success(msg) { console.log(colors.green(`  ✓ ${msg}`)); }
+function warn(msg) { console.log(colors.yellow(`  ⚠ ${msg}`)); }
+function error(msg) { console.log(colors.red(`  ✗ ${msg}`)); }
+
+/**
+ * Detect platform
+ */
+function detectPlatform() {
+  const isTermux =
+    process.platform === 'android' ||
+    process.env.PREFIX?.includes('com.termux') ||
+    process.env.TERMUX_VERSION !== undefined;
+  
+  const isLinuxArm64 = process.platform === 'linux' && process.arch === 'arm64';
+  
+  if (isTermux) return 'termux';
+  if (isLinuxArm64) return 'linux-arm64';
+  return 'other';
+}
+
+/**
+ * Check if npm package is installed
+ */
+function isNpmPackageInstalled(packageName) {
+  try {
+    const nodeModulesPath = path.join(__dirname, '..', '..', 'node_modules', packageName);
+    return fs.existsSync(nodeModulesPath);
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Check if pty.node exists (native module)
+ */
+function checkPtyNode() {
+  try {
+    const nodeModulesPath = path.join(__dirname, '..', '..', 'node_modules');
+    
+    // Check @mmmbuto/node-pty-android-arm64
+    const androidPtyPath = path.join(nodeModulesPath, '@mmmbuto', 'node-pty-android-arm64', 'build', 'Release', 'pty.node');
+    if (fs.existsSync(androidPtyPath)) {
+      return { found: true, provider: '@mmmbuto/node-pty-android-arm64', path: androidPtyPath };
+    }
+    
+    // Check @lydell/node-pty-linux-arm64
+    const linuxPtyPath = path.join(nodeModulesPath, '@lydell', 'node-pty-linux-arm64', 'build', 'Release', 'pty.node');
+    if (fs.existsSync(linuxPtyPath)) {
+      return { found: true, provider: '@lydell/node-pty-linux-arm64', path: linuxPtyPath };
+    }
+    
+    return { found: false };
+  } catch {
+    return { found: false };
+  }
+}
+
+/**
+ * Install PTY provider
+ */
+function installPtyProvider(provider) {
+  try {
+    log(`  Installing ${provider}...`);
+    
+    const npmCmd = process.env.npm_execpath || 'npm';
+    execSync(`${npmCmd} install ${provider}`, { 
+      stdio: 'inherit',
+      cwd: path.join(__dirname, '..', '..')
+    });
+    
+    success(`${provider} installed`);
+    return true;
+  } catch (err) {
+    warn(`${provider} installation failed: ${err.message}`);
+    return false;
+  }
+}
+
+/**
+ * Main PTY check function
+ */
+function checkPtyDependencies() {
+  console.log('');
+  console.log(colors.cyan('Checking PTY dependencies:'));
+  
+  const platform = detectPlatform();
+  let targetProvider = null;
+  
+  // Determine target provider based on platform
+  if (platform === 'termux') {
+    targetProvider = '@mmmbuto/node-pty-android-arm64';
+  } else if (platform === 'linux-arm64') {
+    targetProvider = '@lydell/node-pty-linux-arm64';
+  } else {
+    log(colors.gray('  Skipped: Unsupported platform for PTY (not Termux/Linux ARM64)'));
+    log(colors.gray('  PTY will use fallback adapter (child_process)'));
+    return;
+  }
+  
+  // Check if PTY native module exists
+  const ptyCheck = checkPtyNode();
+  
+  if (ptyCheck.found) {
+    success(`Native PTY found: ${ptyCheck.provider}`);
+  } else {
+    // Check if package is installed but pty.node is missing
+    if (isNpmPackageInstalled(targetProvider)) {
+      warn(`${targetProvider} installed but pty.node missing - may need rebuild`);
+      warn(`  Run: npm rebuild ${targetProvider}`);
+    } else {
+      warn(`${targetProvider} not installed`);
+    }
+    
+    // Try to install
+    const installed = installPtyProvider(targetProvider);
+    if (installed) {
+      // Verify installation
+      const verify = checkPtyNode();
+      if (verify.found) {
+        success(`Native PTY verified: ${verify.provider}`);
+      } else {
+        warn(`PTY package installed but pty.node not found`);
+        warn(`  You may need to rebuild: npm rebuild ${targetProvider}`);
+      }
+    } else {
+      warn(`Cannot install ${targetProvider} - PTY will use fallback`);
+    }
+  }
+  
+  console.log('');
+}
+
+
+/**
+ * Check if pty-termux-utils is installed and has .cjs files
+ */
+function checkPtyTermuxUtils() {
+  try {
+    const ptyUtilsPath = path.join(__dirname, '..', '..', 'node_modules', '@mmmbuto', 'pty-termux-utils');
+    
+    if (!fs.existsSync(ptyUtilsPath)) {
+      warn('@mmmbuto/pty-termux-utils not installed');
+      warn('  This is required for PTY support');
+      warn('  Run: npm install @mmmbuto/pty-termux-utils');
+      return false;
+    }
+    
+    const indexCjsPath = path.join(ptyUtilsPath, 'dist', 'index.cjs');
+    if (fs.existsSync(indexCjsPath)) {
+      success('@mmmbuto/pty-termux-utils installed with CJS support');
+      return true;
+    } else {
+      warn('@mmmbuto/pty-termux-utils installed but .cjs files missing');
+      warn('  Run: cd node_modules/@mmmbuto/pty-termux-utils && npm run build:cjs');
+      return false;
+    }
+  } catch (err) {
+    warn('Error checking @mmmbuto/pty-termux-utils: ' + err.message);
+    return false;
+  }
+}
+
+module.exports = { checkPtyDependencies ,
+  checkPtyTermuxUtils
+};

package/lib/setup/postinstall.js

@@ -1,19 +1,26 @@
 #!/usr/bin/env node
 /**
  * NexusCLI Post-Install Script
- * Termux-only: auto-run wizard if not configured
+ * Cross-platform npm-first bootstrap with Termux-specific extras
  */
 
+
+const { checkPtyDependencies, checkPtyTermuxUtils } = require('./postinstall-pty-check');
 const { execSync, spawn } = require('child_process');
 const fs = require('fs');
 const path = require('path');
 const pkg = require('../../package.json');
 
+function detectTermux() {
+  return (
+    process.platform === 'android' ||
+    process.env.PREFIX?.includes('com.termux') ||
+    process.env.TERMUX_VERSION !== undefined
+  );
+}
+
 // Check if running in Termux
-const isTermux =
-  process.env.PREFIX?.includes('com.termux') ||
-  fs.existsSync('/data/data/com.termux') ||
-  process.env.TERMUX_VERSION !== undefined;
+const isTermux = detectTermux();
 
 // ANSI colors (chalk-free for postinstall)
 const colors = {
@@ -22,7 +29,7 @@ const colors = {
   red: (s) => `\x1b[31m${s}\x1b[0m`,
   cyan: (s) => `\x1b[36m${s}\x1b[0m`,
   bold: (s) => `\x1b[1m${s}\x1b[0m`,
-  gray: (s) => `\x1b[90m${s}\x1b[0m`
+  gray: (s) => `\x1b[90m${s}\x1b[0m`,
 };
 
 function log(msg) {
@@ -109,41 +116,40 @@ function installPackage(pkg) {
 async function main() {
   console.log('');
 
-  // ============================================
-  // TERMUX CHECK - CRITICAL
-  // ============================================
-  if (!isTermux) {
-    console.log(colors.bold('╔═══════════════════════════════════════════════════╗'));
-    console.log(colors.bold('║  ') + colors.red('NOT COMPATIBLE') + colors.bold('                                ║'));
-    console.log(colors.bold('╚═══════════════════════════════════════════════════╝'));
-    console.log('');
-    console.log(colors.yellow('  NexusCLI is designed for Termux on Android only.'));
-    console.log(colors.yellow('  Linux/macOS/Windows support is not available in this version.'));
-    console.log('');
-    console.log(colors.gray('  For more information: https://npmjs.com/package/@mmmbuto/nexuscli'));
-    console.log('');
-    process.exit(1);
-  }
-
-  // ============================================
-  // TERMUX INSTALLATION
-  // ============================================
   const versionLabel = `📱 NexusCLI TRI CLI v${pkg.version}`;
   const padding = Math.max(0, 45 - versionLabel.length);
   console.log(colors.bold('╔═══════════════════════════════════════════════════╗'));
   console.log(colors.bold(`║  ${versionLabel}${' '.repeat(padding)}║`));
-  console.log(colors.bold('║     Claude • Codex • Gemini                       ║'));
+  console.log(colors.bold('║     Claude • Codex • Gemini • Qwen                ║'));
   console.log(colors.bold('╚═══════════════════════════════════════════════════╝'));
   console.log('');
 
+  if (!isTermux) {
+    console.log(colors.cyan('Detected desktop/server platform.'));
+    console.log(colors.yellow('  NexusCLI will use npm-first desktop mode with child_process fallback.'));
+    console.log('');
+  }
+
   // Required packages
   // - ripgrep is needed by Claude CLI (vendor lookup expects it on Termux)
   const packages = ['termux-api', 'termux-tools', 'ripgrep'];
 
-  log(colors.cyan('Installing Termux packages:'));
-  for (const pkg of packages) {
-    installPackage(pkg);
+  if (isTermux) {
+    log(colors.cyan('Installing Termux packages:'));
+    for (const pkg of packages) {
+      installPackage(pkg);
+    }
+    console.log('');
+  } else {
+    log(colors.cyan('Skipping Termux package install on this platform'));
+    console.log('');
   }
+
+  // Check PTY dependencies
+  checkPtyDependencies();
+
+  // Check pty-termux-utils
+  checkPtyTermuxUtils();
   console.log('');
 
   // Create directories
@@ -153,10 +159,13 @@ async function main() {
     path.join(HOME, '.nexuscli', 'data'),
     path.join(HOME, '.nexuscli', 'logs'),
     path.join(HOME, '.nexuscli', 'engines'),
-    path.join(HOME, '.nexuscli', 'certs'),
-    path.join(HOME, '.termux', 'boot')
+    path.join(HOME, '.nexuscli', 'certs')
   ];
 
+  if (isTermux) {
+    dirs.push(path.join(HOME, '.termux', 'boot'));
+  }
+
   log(colors.cyan('Creating directories:'));
   for (const dir of dirs) {
     try {
@@ -192,20 +201,22 @@ async function main() {
   console.log('');
 
   // Check Termux:API app
-  log(colors.cyan('Checking Termux apps:'));
-  try {
-    execSync('termux-battery-status', { timeout: 5000, stdio: 'ignore' });
-    success('Termux:API app working');
-  } catch {
-    warn('Termux:API app not detected');
-    console.log('      Install from F-Droid for notifications & wake-lock');
+  if (isTermux) {
+    log(colors.cyan('Checking Termux apps:'));
+    try {
+      execSync('termux-battery-status', { timeout: 5000, stdio: 'ignore' });
+      success('Termux:API app working');
+    } catch {
+      warn('Termux:API app not detected');
+      console.log('      Install from F-Droid for notifications & wake-lock');
+    }
+    console.log('');
   }
-  console.log('');
 
   // ============================================
   // AUTO-RUN WIZARD IF NOT CONFIGURED
   // ============================================
-  if (!isConfigured()) {
+  if (isTermux && !isConfigured()) {
     console.log(colors.bold('╔═══════════════════════════════════════════════════╗'));
     console.log(colors.bold('║  First time setup - Running wizard...             ║'));
     console.log(colors.bold('╚═══════════════════════════════════════════════════╝'));
@@ -223,7 +234,7 @@ async function main() {
       console.log(`  Run ${colors.cyan('nexuscli init')} to complete setup manually`);
       console.log('');
     }
-  } else {
+  } else if (isTermux) {
     // Already configured
     console.log(colors.bold('╔═══════════════════════════════════════════════════╗'));
     console.log(colors.bold('║  ✅ NexusCLI updated!                              ║'));
@@ -235,6 +246,14 @@ async function main() {
     console.log('    • Termux:API   - notifications & wake-lock');
     console.log('    • Termux:Boot  - auto-start on device boot');
     console.log('');
+  } else {
+    console.log(colors.bold('╔═══════════════════════════════════════════════════╗'));
+    console.log(colors.bold('║  ✅ NexusCLI ready for Linux/macOS                ║'));
+    console.log(colors.bold('╚═══════════════════════════════════════════════════╝'));
+    console.log('');
+    console.log(`  Run ${colors.cyan('nexuscli start')} to launch the server`);
+    console.log(`  Run ${colors.cyan('nexuscli init')} for interactive setup if needed`);
+    console.log('');
   }
 }
 

package/lib/utils/restart-warning.js

@@ -0,0 +1,18 @@
+/**
+ * CLI warning helper for settings that require restart
+ */
+
+const chalk = require('chalk');
+const { getServerPid } = require('./server');
+
+function warnIfServerRunning(message) {
+  const pid = getServerPid();
+  if (!pid) return false;
+  const note = message || 'Changes will apply after restart (nexuscli stop && nexuscli start).';
+  console.log(chalk.yellow(`  ⚠ Server running (PID: ${pid}). ${note}`));
+  return true;
+}
+
+module.exports = {
+  warnIfServerRunning
+};

package/lib/utils/server.js

@@ -0,0 +1,88 @@
+/**
+ * Server control helpers (PID-based)
+ */
+
+const fs = require('fs');
+const { PATHS } = require('./paths');
+const { isTermux, releaseWakeLock, sendNotification } = require('./termux');
+const { getConfig } = require('../config/manager');
+
+/**
+ * Get running server PID (cleans stale PID file)
+ */
+function getServerPid() {
+  if (!fs.existsSync(PATHS.PID_FILE)) {
+    return null;
+  }
+
+  try {
+    const pid = parseInt(fs.readFileSync(PATHS.PID_FILE, 'utf8').trim(), 10);
+    if (!Number.isFinite(pid)) {
+      fs.unlinkSync(PATHS.PID_FILE);
+      return null;
+    }
+
+    // Check if process exists
+    process.kill(pid, 0);
+    return pid;
+  } catch {
+    // Process doesn't exist or PID invalid - cleanup
+    try {
+      fs.unlinkSync(PATHS.PID_FILE);
+    } catch {}
+    return null;
+  }
+}
+
+/**
+ * Check if server is running
+ */
+function isServerRunning() {
+  return getServerPid() !== null;
+}
+
+/**
+ * Stop the server if running
+ */
+function stopServer() {
+  const pid = getServerPid();
+  if (!pid) {
+    return { running: false };
+  }
+
+  try {
+    process.kill(pid, 'SIGTERM');
+  } catch (err) {
+    if (err.code !== 'ESRCH') {
+      return { running: true, pid, error: err };
+    }
+  }
+
+  // Remove PID file
+  try {
+    fs.unlinkSync(PATHS.PID_FILE);
+  } catch {}
+
+  // Release wake lock + notification (Termux)
+  const config = getConfig();
+  const wakeLockReleased = isTermux() && config.termux?.wake_lock
+    ? releaseWakeLock()
+    : false;
+  const notificationSent = isTermux() && config.termux?.notifications
+    ? sendNotification('NexusCLI', 'Server stopped')
+    : false;
+
+  return {
+    running: true,
+    pid,
+    stopped: true,
+    wakeLockReleased,
+    notificationSent
+  };
+}
+
+module.exports = {
+  getServerPid,
+  isServerRunning,
+  stopServer
+};

package/lib/utils/termux.js

@@ -11,8 +11,8 @@ const { execSync, spawn } = require('child_process');
  */
 function isTermux() {
   return (
+    process.platform === 'android' ||
     process.env.PREFIX?.includes('com.termux') ||
-    fs.existsSync('/data/data/com.termux') ||
     process.env.TERMUX_VERSION !== undefined
   );
 }