@mmmbuto/nexuscli 0.9.7004-termux → 0.10.0

package/lib/cli/engines.js

@@ -4,105 +4,49 @@
 
 const chalk = require('chalk');
 const inquirer = require('inquirer');
-const { execSync } = require('child_process');
-const fs = require('fs');
-const path = require('path');
 
 const { isInitialized, getConfig, setConfigValue } = require('../config/manager');
-const { HOME } = require('../utils/paths');
+const { getCliTools } = require('../config/models');
+const { warnIfServerRunning } = require('../utils/restart-warning');
+const RuntimeManager = require('../server/services/runtime-manager');
 
-/**
- * Detect available engines (TRI CLI v0.4.0)
- */
-function detectEngines() {
-  const engines = {
-    claude: { available: false, path: null, version: null },
-    codex: { available: false, path: null, version: null },
-    gemini: { available: false, path: null, version: null },
-    qwen: { available: false, path: null, version: null }
-  };
-
-  // Claude
-  try {
-    const claudePath = execSync('which claude 2>/dev/null', { encoding: 'utf8' }).trim();
-    const claudeVersion = execSync('claude --version 2>/dev/null', { encoding: 'utf8' }).trim().split('\n')[0];
-    engines.claude = { available: true, path: claudePath, version: claudeVersion };
-  } catch {}
-
-  // Codex
-  try {
-    const codexPath = execSync('which codex 2>/dev/null', { encoding: 'utf8' }).trim();
-    const codexVersion = execSync('codex --version 2>/dev/null', { encoding: 'utf8' }).trim().split('\n')[0];
-    engines.codex = { available: true, path: codexPath, version: codexVersion };
-  } catch {}
-
-  // Gemini
-  try {
-    const geminiPath = execSync('which gemini 2>/dev/null', { encoding: 'utf8' }).trim();
-    const geminiVersion = execSync('gemini --version 2>/dev/null', { encoding: 'utf8' }).trim().split('\n')[0];
-    engines.gemini = { available: true, path: geminiPath, version: geminiVersion };
-  } catch {}
-
-  // Qwen
-  try {
-    const qwenPath = execSync('which qwen 2>/dev/null', { encoding: 'utf8' }).trim();
-    const qwenVersion = execSync('qwen --version 2>/dev/null', { encoding: 'utf8' }).trim().split('\n')[0];
-    engines.qwen = { available: true, path: qwenPath, version: qwenVersion };
-  } catch {}
+const runtimeManager = new RuntimeManager();
 
-  return engines;
+function formatAvailability(runtime) {
+  if (runtime.available) {
+    return chalk.green('available');
+  }
+  return chalk.gray('missing');
 }
 
 /**
  * List engines status (TRI CLI v0.4.0)
  */
-function listEngines() {
+async function listEngines() {
   const config = getConfig();
-  const detected = detectEngines();
+  const tools = getCliTools();
+  const inventory = await runtimeManager.getRuntimeInventory();
+  const inventoryByEngine = inventory.reduce((acc, runtime) => {
+    if (!acc[runtime.engine]) acc[runtime.engine] = [];
+    acc[runtime.engine].push(runtime);
+    return acc;
+  }, {});
 
   console.log(chalk.bold('╔═══════════════════════════════════════════╗'));
-  console.log(chalk.bold('║  AI Engines (TRI CLI)                     ║'));
+  console.log(chalk.bold('║  AI Engines (Runtime-Aware)               ║'));
   console.log(chalk.bold('╠═══════════════════════════════════════════╣'));
 
-  // Claude
-  const claudeEnabled = config.engines?.claude?.enabled !== false;
-  const claudeModel = config.engines?.claude?.model || 'sonnet';
-  if (detected.claude.available) {
-    const status = claudeEnabled ? chalk.green('✓ enabled') : chalk.gray('○ disabled');
-    console.log(chalk.bold(`║  Claude:  ${status} (${claudeModel})`));
-    console.log(chalk.gray(`║           ${detected.claude.version}`));
-  } else {
-    console.log(chalk.bold(`║  Claude:  ${chalk.red('✗ not installed')}`));
-  }
+  for (const [engineId, engine] of Object.entries(tools)) {
+    const enabled = config.engines?.[engineId]?.enabled === true || engineId === 'claude';
+    const defaultModel = config.engines?.[engineId]?.model || engine.models.find((m) => m.default)?.id || 'n/a';
+    const status = enabled ? chalk.green('✓ enabled') : chalk.gray('○ disabled');
+    console.log(chalk.bold(`║  ${engine.name.padEnd(8)} ${status} (${defaultModel})`));
 
-  // Codex
-  const codexEnabled = config.engines?.codex?.enabled === true;
-  if (detected.codex.available) {
-    const status = codexEnabled ? chalk.green('✓ enabled') : chalk.gray('○ disabled');
-    console.log(chalk.bold(`║  Codex:   ${status}`));
-    console.log(chalk.gray(`║           ${detected.codex.version}`));
-  } else {
-    console.log(chalk.bold(`║  Codex:   ${chalk.gray('○ not installed')}`));
-  }
-
-  // Gemini
-  const geminiEnabled = config.engines?.gemini?.enabled === true;
-  if (detected.gemini.available) {
-    const status = geminiEnabled ? chalk.green('✓ enabled') : chalk.gray('○ disabled');
-    console.log(chalk.bold(`║  Gemini:  ${status}`));
-    console.log(chalk.gray(`║           ${detected.gemini.version}`));
-  } else {
-    console.log(chalk.bold(`║  Gemini:  ${chalk.gray('○ not installed')}`));
-  }
-
-  // Qwen
-  const qwenEnabled = config.engines?.qwen?.enabled === true;
-  if (detected.qwen.available) {
-    const status = qwenEnabled ? chalk.green('✓ enabled') : chalk.gray('○ disabled');
-    console.log(chalk.bold(`║  QWEN:    ${status}`));
-    console.log(chalk.gray(`║           ${detected.qwen.version}`));
-  } else {
-    console.log(chalk.bold(`║  QWEN:    ${chalk.gray('○ not installed')}`));
+    for (const runtime of inventoryByEngine[engineId] || []) {
+      const laneLabel = runtime.laneLabel || runtime.lane;
+      const version = runtime.installedVersion || 'not installed';
+      console.log(chalk.gray(`║           ${laneLabel}: ${runtime.command} · ${formatAvailability(runtime)} · ${version}`));
+    }
   }
 
   console.log(chalk.bold('╚═══════════════════════════════════════════╝'));
@@ -112,75 +56,34 @@ function listEngines() {
  * Test an engine
  */
 async function testEngine(engine) {
-  console.log(chalk.cyan(`Testing ${engine}...`));
-
-  if (engine === 'claude') {
-    try {
-      execSync('claude --version', { stdio: 'inherit' });
-      console.log(chalk.green(`  ✓ Claude CLI is working`));
-      return true;
-    } catch {
-      console.log(chalk.red(`  ✗ Claude CLI failed`));
-      return false;
-    }
-  }
-
-  if (engine === 'codex') {
-    try {
-      execSync('codex --version', { stdio: 'inherit' });
-      console.log(chalk.green(`  ✓ Codex CLI is working`));
-      return true;
-    } catch {
-      console.log(chalk.red(`  ✗ Codex CLI not found`));
-      return false;
-    }
-  }
-
-  if (engine === 'gemini') {
-    try {
-      execSync('gemini --version', { stdio: 'inherit' });
-      console.log(chalk.green(`  ✓ Gemini CLI is working`));
-      return true;
-    } catch {
-      console.log(chalk.red(`  ✗ Gemini CLI not found`));
-      return false;
-    }
-  }
+  const inventory = await runtimeManager.getRuntimeInventory();
+  const runtimes = inventory.filter((runtime) => runtime.engine === engine);
 
-  if (engine === 'qwen') {
-    try {
-      execSync('qwen --version', { stdio: 'inherit' });
-      console.log(chalk.green(`  ✓ Qwen CLI is working`));
-      return true;
-    } catch {
-      console.log(chalk.red(`  ✗ Qwen CLI not found`));
-      return false;
-    }
+  console.log(chalk.cyan(`Testing ${engine} runtimes...`));
+  for (const runtime of runtimes) {
+    const status = runtime.available
+      ? chalk.green(`  ✓ ${runtime.lane}: ${runtime.command} (${runtime.installedVersion || 'ok'})`)
+      : chalk.red(`  ✗ ${runtime.lane}: ${runtime.command} (${runtime.error || 'missing'})`);
+    console.log(status);
   }
 
-  console.log(chalk.yellow(`  Engine ${engine} not testable`));
-  return false;
+  return runtimes.some((runtime) => runtime.available);
 }
 
 /**
  * Add/configure an engine (TRI CLI v0.4.0)
  */
 async function addEngine() {
-  const detected = detectEngines();
-
-  const choices = [];
-  if (detected.claude.available) {
-    choices.push({ name: `Claude (${detected.claude.version})`, value: 'claude' });
-  }
-  if (detected.codex.available) {
-    choices.push({ name: `Codex (${detected.codex.version})`, value: 'codex' });
-  }
-  if (detected.gemini.available) {
-    choices.push({ name: `Gemini (${detected.gemini.version})`, value: 'gemini' });
-  }
-  if (detected.qwen.available) {
-    choices.push({ name: `QWEN (${detected.qwen.version})`, value: 'qwen' });
-  }
+  const tools = getCliTools();
+  const inventory = await runtimeManager.getRuntimeInventory();
+  const choices = Object.entries(tools).map(([engineId, engine]) => {
+    const hasRuntime = inventory.some((runtime) => runtime.engine === engineId && runtime.available);
+    const status = hasRuntime ? chalk.green('available') : chalk.gray('not installed');
+    return {
+      name: `${engine.name} (${status})`,
+      value: engineId,
+    };
+  });
 
   if (choices.length === 0) {
     console.log(chalk.yellow('  No AI engines detected.'));
@@ -195,66 +98,45 @@ async function addEngine() {
     choices
   }]);
 
-  if (engine === 'claude') {
-    const { model } = await inquirer.prompt([{
+  const engineCatalog = tools[engine];
+  const runtimeChoices = inventory
+    .filter((runtime) => runtime.engine === engine)
+    .map((runtime) => ({
+      name: `${runtime.laneLabel} (${runtime.command}${runtime.available ? ` · ${runtime.installedVersion || 'available'}` : ' · missing'})`,
+      value: runtime.lane,
+      disabled: false,
+    }));
+
+  const answers = await inquirer.prompt([
+    {
       type: 'list',
-      name: 'model',
-      message: 'Default Claude model:',
-      choices: [
-        { name: 'Haiku 4.5 (Fast)', value: 'haiku' },
-        { name: 'Sonnet 4.5 (Balanced)', value: 'sonnet' },
-        { name: 'Opus 4.5 (Most Intelligent)', value: 'opus' }
-      ],
-      default: 'sonnet'
-    }]);
-
-    setConfigValue('engines.claude.enabled', true);
-    setConfigValue('engines.claude.model', model);
-    console.log(chalk.green(`  ✓ Claude configured (${model})`));
-  }
-
-  if (engine === 'codex') {
-    const { model } = await inquirer.prompt([{
+      name: 'lane',
+      message: `Default ${engineCatalog.name} lane:`,
+      choices: runtimeChoices,
+      default: 'native',
+    },
+    {
       type: 'list',
       name: 'model',
-      message: 'Default Codex model:',
-      choices: [
-        { name: 'GPT-5.2 (Next Gen)', value: 'gpt-5.2' },
-        { name: 'GPT-5.1 Codex Max (Best)', value: 'gpt-5.1-codex-max' },
-        { name: 'GPT-5.1 Codex', value: 'gpt-5.1-codex' },
-        { name: 'GPT-5.1 Codex Mini (Fast)', value: 'gpt-5.1-codex-mini' },
-        { name: 'GPT-5.1 (General)', value: 'gpt-5.1' }
-      ],
-      default: 'gpt-5.1-codex-max'
-    }]);
-
-    setConfigValue('engines.codex.enabled', true);
-    setConfigValue('engines.codex.model', model);
-    console.log(chalk.green(`  ✓ Codex configured (${model})`));
-  }
-
-  if (engine === 'gemini') {
-    setConfigValue('engines.gemini.enabled', true);
-    setConfigValue('engines.gemini.model', 'gemini-3-pro-preview');
-    console.log(chalk.green(`  ✓ Gemini configured (gemini-3-pro-preview)`));
-  }
-
-  if (engine === 'qwen') {
-    const { model } = await inquirer.prompt([{
-      type: 'list',
-      name: 'model',
-      message: 'Default Qwen model:',
-      choices: [
-        { name: 'Coder (default)', value: 'coder-model' },
-        { name: 'Vision', value: 'vision-model' }
-      ],
-      default: 'coder-model'
-    }]);
-
-    setConfigValue('engines.qwen.enabled', true);
-    setConfigValue('engines.qwen.model', model);
-    console.log(chalk.green(`  ✓ QWEN configured (${model})`));
-  }
+      message: `Default ${engineCatalog.name} model:`,
+      choices: (answers) => engineCatalog.models
+        .filter((model) => model.lane === answers.lane)
+        .map((model) => ({
+          name: model.label || model.name,
+          value: model.id,
+        })),
+      default: (answers) => engineCatalog.models.find((model) => model.lane === answers.lane && model.default)?.id
+        || engineCatalog.models.find((model) => model.lane === answers.lane)?.id,
+    }
+  ]);
+
+  const active = Array.from(new Set([...(getConfig().engines?.active || []), engine]));
+  setConfigValue('engines.active', active);
+  setConfigValue(`engines.${engine}.enabled`, true);
+  setConfigValue(`engines.${engine}.model`, answers.model);
+  setConfigValue(`engines.${engine}.lanes.${answers.lane}.enabled`, true);
+  console.log(chalk.green(`  ✓ ${engineCatalog.name} configured (${answers.model}, ${answers.lane})`));
+  warnIfServerRunning();
 }
 
 /**
@@ -272,7 +154,7 @@ async function engines(action) {
 
   // No action = list
   if (!action || action === 'list') {
-    listEngines();
+    await listEngines();
     console.log('');
     return;
   }

package/lib/cli/init.js

@@ -19,6 +19,7 @@ const pkg = require('../../package.json');
 const CLAUDE_PROJECTS = path.join(os.homedir(), '.claude', 'projects');
 const CODEX_SESSIONS = path.join(os.homedir(), '.codex', 'sessions');
 const GEMINI_SESSIONS = path.join(os.homedir(), '.gemini', 'sessions');
+const QWEN_PROJECTS = path.join(os.homedir(), '.qwen', 'projects');
 
 // Default workspace path - always ~/nexuswork (user can change during setup)
 const DEFAULT_WORKSPACE = path.join(os.homedir(), 'nexuswork');
@@ -96,6 +97,27 @@ function detectGeminiPath() {
   }
 }
 
+function detectQwenPath() {
+  const candidates = [
+    path.join(HOME, '.local', 'bin', 'qwen'),
+    path.join(process.env.PREFIX || '/usr', 'bin', 'qwen'),
+    '/usr/local/bin/qwen',
+    '/usr/bin/qwen'
+  ];
+
+  for (const p of candidates) {
+    if (fs.existsSync(p)) {
+      return p;
+    }
+  }
+
+  try {
+    return execSync('which qwen', { encoding: 'utf8' }).trim();
+  } catch {
+    return null;
+  }
+}
+
 /**
  * Detect all available AI engines (TRI CLI v0.4.0)
  */
@@ -112,6 +134,10 @@ function detectEngines() {
     gemini: {
       path: detectGeminiPath(),
       hasSessions: fs.existsSync(GEMINI_SESSIONS)
+    },
+    qwen: {
+      path: detectQwenPath(),
+      hasSessions: fs.existsSync(QWEN_PROJECTS)
     }
   };
 }
@@ -120,7 +146,7 @@ function detectEngines() {
  * Count sessions for each engine (TRI CLI v0.4.0)
  */
 function countSessions() {
-  const counts = { claude: 0, codex: 0, gemini: 0 };
+  const counts = { claude: 0, codex: 0, gemini: 0, qwen: 0 };
 
   // Count Claude sessions
   if (fs.existsSync(CLAUDE_PROJECTS)) {
@@ -155,6 +181,21 @@ function countSessions() {
     } catch {}
   }
 
+  // Count Qwen sessions
+  if (fs.existsSync(QWEN_PROJECTS)) {
+    try {
+      const projects = fs.readdirSync(QWEN_PROJECTS, { withFileTypes: true });
+      for (const project of projects) {
+        if (!project.isDirectory()) continue;
+        const chatsDir = path.join(QWEN_PROJECTS, project.name, 'chats');
+        if (!fs.existsSync(chatsDir)) continue;
+        const files = fs.readdirSync(chatsDir)
+          .filter(f => f.endsWith('.jsonl'));
+        counts.qwen += files.length;
+      }
+    } catch {}
+  }
+
   return counts;
 }
 
@@ -308,6 +349,16 @@ async function init(options) {
     console.log(chalk.gray('  ○ Gemini CLI: not installed'));
   }
 
+  // Qwen
+  if (engines.qwen.path) {
+    const sessInfo = sessionCounts.qwen > 0 ? chalk.gray(` (${sessionCounts.qwen} sessions)`) : '';
+    console.log(chalk.green(`  ✓ Qwen CLI: ${engines.qwen.path}${sessInfo}`));
+  } else if (engines.qwen.hasSessions) {
+    console.log(chalk.yellow(`  ⚠ Qwen: CLI not found but ${sessionCounts.qwen} sessions exist`));
+  } else {
+    console.log(chalk.gray('  ○ Qwen CLI: not installed'));
+  }
+
   console.log('');
 
   let answers = {};
@@ -323,6 +374,9 @@ async function init(options) {
   if (engines.gemini.path) {
     engineChoices.push({ name: 'Gemini CLI (Google)', value: 'gemini', checked: true });
   }
+  if (engines.qwen.path) {
+    engineChoices.push({ name: 'Qwen CLI (QwenLM)', value: 'qwen', checked: true });
+  }
 
   // Determine default workspace
   const existingWorkspaces = findWorkspaces();
@@ -416,7 +470,7 @@ async function init(options) {
     }
 
     // Part 4: Session scan option
-    const totalSessions = sessionCounts.claude + sessionCounts.codex + sessionCounts.gemini;
+    const totalSessions = sessionCounts.claude + sessionCounts.codex + sessionCounts.gemini + sessionCounts.qwen;
     if (totalSessions > 0) {
       console.log('');
       console.log(chalk.cyan(`Found ${totalSessions} existing AI sessions.`));

package/lib/cli/model.js

@@ -11,9 +11,12 @@ const {
 } = require('../config/manager');
 const {
   getCliTools,
-  isValidModelId,
-  getAllModels
+  isValidModelId
 } = require('../config/models');
+const { warnIfServerRunning } = require('../utils/restart-warning');
+const RuntimeManager = require('../server/services/runtime-manager');
+
+const runtimeManager = new RuntimeManager();
 
 async function modelCommand(modelId) {
   if (!isInitialized()) {
@@ -23,16 +26,19 @@ async function modelCommand(modelId) {
   }
 
   const cliTools = getCliTools();
-  const allModels = getAllModels();
 
-  const printAvailableModels = () => {
+  const printAvailableModels = async () => {
+    const inventoryMap = await runtimeManager.getRuntimeInventoryMap();
     console.log(chalk.bold('\nAvailable models:'));
     for (const [key, cli] of Object.entries(cliTools)) {
       console.log(chalk.dim(`${cli.name}:`));
       for (const model of cli.models || []) {
         const label = model.label || model.name;
         const defaultTag = model.default ? chalk.green(' (default)') : '';
-        console.log(`  ${model.id} ${chalk.gray(`- ${label}`)}${defaultTag}`);
+        const runtime = inventoryMap[model.runtimeId];
+        const laneTag = chalk.gray(`[${model.lane}]`);
+        const availability = runtime?.available ? chalk.green('available') : chalk.gray('missing');
+        console.log(`  ${model.id} ${laneTag} ${chalk.gray(`- ${label}`)} ${availability}${defaultTag}`);
       }
     }
   };
@@ -50,24 +56,28 @@ async function modelCommand(modelId) {
       console.log(chalk.dim('Usage: nexuscli model <model-id>'));
     }
 
-    printAvailableModels();
+    await printAvailableModels();
 
     return;
   }
 
   if (!isValidModelId(modelId)) {
     console.log(chalk.red(`✗ Invalid model: ${modelId}`));
-    printAvailableModels();
+    await printAvailableModels();
     process.exitCode = 1;
     return;
   }
 
+  const selection = runtimeManager.resolveRuntimeSelection({ modelId });
   // Set default model
   const success = setConfigValue('preferences.defaultModel', modelId);
+  setConfigValue(`engines.${selection.engine}.model`, modelId);
 
   if (success) {
     console.log(chalk.green('✓') + ' Default model set to: ' + chalk.cyan(modelId));
+    console.log(chalk.dim(`Lane: ${selection.lane} · Runtime: ${selection.runtimeId}`));
     console.log(chalk.dim('The frontend will now auto-select this model on load.'));
+    warnIfServerRunning('If the UI is already open, refresh or restart to apply.');
   } else {
     console.error(chalk.red('✗') + ' Failed to save config');
     process.exit(1);

package/lib/cli/start.js

@@ -11,29 +11,9 @@ const readline = require('readline');
 const { isInitialized, getConfig } = require('../config/manager');
 const { PATHS } = require('../utils/paths');
 const { isTermux, acquireWakeLock, sendNotification } = require('../utils/termux');
-
-/**
- * Check if server is already running
- */
-function isServerRunning() {
-  if (!fs.existsSync(PATHS.PID_FILE)) {
-    return false;
-  }
-
-  try {
-    const pid = parseInt(fs.readFileSync(PATHS.PID_FILE, 'utf8').trim());
-
-    // Check if process exists
-    process.kill(pid, 0);
-    return pid;
-  } catch {
-    // Process doesn't exist, clean up stale PID file
-    try {
-      fs.unlinkSync(PATHS.PID_FILE);
-    } catch {}
-    return false;
-  }
-}
+const { getServerPid } = require('../utils/server');
+const { getUpdateInfo } = require('../utils/update-check');
+const { runUpdateAndRestart } = require('../utils/update-runner');
 
 /**
  * Write PID file
@@ -169,7 +149,7 @@ async function start(options) {
   }
 
   // Check if already running
-  const runningPid = isServerRunning();
+  const runningPid = getServerPid();
   if (runningPid) {
     console.log(chalk.yellow(`Server already running (PID: ${runningPid})`));
     console.log(`Run ${chalk.cyan('nexuscli stop')} to stop it.`);
@@ -177,6 +157,39 @@ async function start(options) {
     process.exit(1);
   }
 
+  // Auto-update check (unless explicitly skipped)
+  const skipUpdateCheck = process.env.NEXUSCLI_SKIP_UPDATE_CHECK === '1';
+  if (!skipUpdateCheck) {
+    try {
+      const updateInfo = await getUpdateInfo();
+
+      if (updateInfo.updateAvailable) {
+        const latest = updateInfo.npmVersion || updateInfo.latestVersion;
+        console.log(chalk.yellow(`Update available: ${updateInfo.currentVersion} → ${latest}`));
+
+        if (process.stdin.isTTY && process.stdout.isTTY) {
+          const shouldUpdate = await askYesNo(`  Update now? ${chalk.gray('(Y/n)')} `);
+          if (shouldUpdate) {
+            const result = await runUpdateAndRestart({ restartArgs: process.argv.slice(2) });
+            if (result.ok) {
+              return;
+            }
+            console.log(chalk.yellow('  Update failed. Continuing with current version...'));
+          }
+        } else {
+          console.log(chalk.gray('  Non-interactive session: skipping update prompt.'));
+        }
+        console.log('');
+      } else if (updateInfo.githubNewer && !updateInfo.npmNewer && updateInfo.githubVersion) {
+        console.log(chalk.gray(`GitHub release ${updateInfo.githubVersion} is available (npm not updated yet).`));
+        console.log('');
+      }
+    } catch (err) {
+      console.log(chalk.gray(`Update check skipped: ${err.message}`));
+      console.log('');
+    }
+  }
+
   const config = getConfig();
   const port = options.port || config.server.port;
   config.server.port = port;

package/lib/cli/stop.js

@@ -3,11 +3,7 @@
  */
 
 const chalk = require('chalk');
-const fs = require('fs');
-
-const { PATHS } = require('../utils/paths');
-const { isTermux, releaseWakeLock, sendNotification } = require('../utils/termux');
-const { getConfig } = require('../config/manager');
+const { stopServer } = require('../utils/server');
 
 /**
  * Main stop command
@@ -15,50 +11,25 @@ const { getConfig } = require('../config/manager');
 async function stop() {
   console.log('');
 
-  // Check PID file
-  if (!fs.existsSync(PATHS.PID_FILE)) {
+  const result = stopServer();
+
+  if (!result.running) {
     console.log(chalk.yellow('No running daemon found.'));
     console.log('');
     return;
   }
 
-  try {
-    const pid = parseInt(fs.readFileSync(PATHS.PID_FILE, 'utf8').trim());
-
-    // Try to kill the process
-    try {
-      process.kill(pid, 'SIGTERM');
-      console.log(chalk.green(`  ✓ Server stopped (PID: ${pid})`));
-    } catch (err) {
-      if (err.code === 'ESRCH') {
-        console.log(chalk.yellow('  Process not found (may have already stopped)'));
-      } else {
-        throw err;
-      }
-    }
-
-    // Remove PID file
-    fs.unlinkSync(PATHS.PID_FILE);
-
-    // Release wake lock on Termux
-    const config = getConfig();
-    if (isTermux() && config.termux?.wake_lock) {
-      releaseWakeLock();
-      console.log(chalk.gray('  Wake-lock released'));
-    }
-
-    // Send notification on Termux
-    if (isTermux() && config.termux?.notifications) {
-      sendNotification('NexusCLI', 'Server stopped');
-    }
-
-    console.log('');
-
-  } catch (err) {
-    console.log(chalk.red(`  ✗ Error stopping server: ${err.message}`));
+  if (result.error) {
+    console.log(chalk.red(`  ✗ Error stopping server: ${result.error.message}`));
     console.log('');
     process.exit(1);
   }
+
+  console.log(chalk.green(`  ✓ Server stopped (PID: ${result.pid})`));
+  if (result.wakeLockReleased) {
+    console.log(chalk.gray('  Wake-lock released'));
+  }
+  console.log('');
 }
 
 module.exports = stop;