@mmmbuto/nexuscli 0.9.8 → 0.9.9

package/README.md

@@ -22,22 +22,22 @@ NexusCLI is a lightweight, Termux-first AI cockpit that orchestrates Claude Code
 
 <p align="center">
   <img src="docs/assets/screenshots/nexuscli-multilang-preview.png" width="45%" />
-  <img src="docs/assets/screenshots/nexuscli-mobile-terminal.png" width="45%" />
+  <img src="docs/assets/screenshots/nexuscli-mobile-glm.png" width="45%" />
 </p>
 
 ---
 
-## Highlights (v0.9.8)
+## Highlights (v0.9.9)
 
-- **QWEN CLI**: Integrated Qwen Code CLI with `coder-model` and `vision-model`
-- **Statusbar Realtime**: Qwen tool events streamed live in the UI
-- **Light Theme**: Higher contrast + correct mobile statusbar colors
-- **GLM-4.7**: Updated Z.ai model integration for Claude-compatible routing
+- **Auto-update**: Update check on start (npm + GitHub) with interactive prompt
+- **Update command**: `nexuscli update` / `nexuscli upgrade` (stop → update → restart)
+- **Live default model**: UI refreshes config on focus/interval without restart
+- **Restart warnings**: CLI warns when changes require stop/start
 
-### Stable (v0.9.8)
+### Stable (v0.9.9)
 
-- Jobs runner restored with Termux-safe execution
-- Cleaner job SSE errors in UI
+- Update check is cached and non-blocking for normal startup
+- GitHub-only releases show a notice without prompting
 
 ## Features
 
@@ -124,10 +124,14 @@ nexuscli start
 | `nexuscli logs` | View server logs |
 | `nexuscli users` | Users |
 | `nexuscli setup-termux` | Termux helpers (services, paths) |
+| `nexuscli update` | Update NexusCLI and restart server |
+| `nexuscli upgrade` | Alias for update |
 | `nexuscli uninstall` | Remove NexusCLI |
 
 ---
 
+> **Note**: On `nexuscli start`, an update check runs (cached) and will prompt in interactive shells.
+
 ## API Keys
 
 Configure API keys for additional providers:
@@ -164,7 +168,7 @@ NexusCLI is designed primarily for **Termux** on Android devices.
 ### Stack
 
 - **Termux** - primary runtime environment
-- **tmux** - session management
+- **tmux (optional)** - session management (user-managed)
 - **Node.js + SSE** - lightweight backend
 - **React** - minimal UI
 
@@ -180,6 +184,24 @@ It is a **research and learning tool**.
 
 ---
 
+## Battery / Keep-Alive (Android)
+
+Android can kill background processes aggressively. NexusCLI does not keep
+engine CLIs alive in background; it spawns them on demand and resumes sessions.
+
+**Keep NexusCLI alive (when you need it running):**
+- Disable battery optimization for Termux (Android Settings → Battery → Unrestricted).
+- Enable wake-lock + notifications (via `nexuscli config`).
+- Install Termux:Boot to auto-restart after reboot or app kill.
+- Keep a persistent notification (Termux:API helps prevent background kill).
+
+**Reduce battery usage (when you don’t need it always-on):**
+- Stop the server when idle: `nexuscli stop`.
+- Disable wake-lock and notifications when not needed.
+- Prefer lighter models and lower reasoning settings.
+
+---
+
 ## API Endpoints
 
 | Endpoint | Engine | Description |

package/bin/nexuscli.js

@@ -22,6 +22,7 @@ const workspacesCommand = require('../lib/cli/workspaces');
 const usersCommand = require('../lib/cli/users');
 const uninstallCommand = require('../lib/cli/uninstall');
 const setupTermuxCommand = require('../lib/cli/setup-termux');
+const updateCommand = require('../lib/cli/update');
 const { modelCommand } = require('../lib/cli/model');
 
 program
@@ -122,6 +123,17 @@ program
   .description('Prepare for uninstallation (optional data removal)')
   .action(uninstallCommand);
 
+// nexuscli update / upgrade
+program
+  .command('update')
+  .description('Update NexusCLI and restart server')
+  .action(updateCommand);
+
+program
+  .command('upgrade')
+  .description('Alias for update')
+  .action(updateCommand);
+
 // Parse arguments
 program.parse();
 

package/lib/cli/config.js

@@ -13,6 +13,7 @@ const {
   getConfigKeys
 } = require('../config/manager');
 const { PATHS } = require('../utils/paths');
+const { warnIfServerRunning } = require('../utils/restart-warning');
 
 /**
  * List all config values
@@ -123,6 +124,7 @@ async function config(action, key, value) {
 
     if (setConfigValue(key, value)) {
       console.log(chalk.green(`  ✓ ${key} = ${value}`));
+      warnIfServerRunning();
     } else {
       console.log(chalk.red(`  ✗ Failed to set ${key}`));
     }
@@ -168,6 +170,7 @@ async function config(action, key, value) {
     setConfigValue('termux.notifications', answers.notifications);
 
     console.log(chalk.green('  ✓ Configuration updated'));
+    warnIfServerRunning();
     console.log('');
     return;
   }

package/lib/cli/engines.js

@@ -10,6 +10,7 @@ const path = require('path');
 
 const { isInitialized, getConfig, setConfigValue } = require('../config/manager');
 const { HOME } = require('../utils/paths');
+const { warnIfServerRunning } = require('../utils/restart-warning');
 
 /**
  * Detect available engines (TRI CLI v0.4.0)
@@ -211,6 +212,7 @@ async function addEngine() {
     setConfigValue('engines.claude.enabled', true);
     setConfigValue('engines.claude.model', model);
     console.log(chalk.green(`  ✓ Claude configured (${model})`));
+    warnIfServerRunning();
   }
 
   if (engine === 'codex') {
@@ -231,12 +233,14 @@ async function addEngine() {
     setConfigValue('engines.codex.enabled', true);
     setConfigValue('engines.codex.model', model);
     console.log(chalk.green(`  ✓ Codex configured (${model})`));
+    warnIfServerRunning();
   }
 
   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)`));
+    warnIfServerRunning();
   }
 
   if (engine === 'qwen') {
@@ -254,6 +258,7 @@ async function addEngine() {
     setConfigValue('engines.qwen.enabled', true);
     setConfigValue('engines.qwen.model', model);
     console.log(chalk.green(`  ✓ QWEN configured (${model})`));
+    warnIfServerRunning();
   }
 }
 

package/lib/cli/model.js

@@ -14,6 +14,7 @@ const {
   isValidModelId,
   getAllModels
 } = require('../config/models');
+const { warnIfServerRunning } = require('../utils/restart-warning');
 
 async function modelCommand(modelId) {
   if (!isInitialized()) {
@@ -68,6 +69,7 @@ async function modelCommand(modelId) {
   if (success) {
     console.log(chalk.green('✓') + ' Default model set to: ' + chalk.cyan(modelId));
     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;

package/lib/cli/update.js

@@ -0,0 +1,28 @@
+/**
+ * nexuscli update - Update NexusCLI and restart
+ */
+
+const chalk = require('chalk');
+const { getUpdateInfo } = require('../utils/update-check');
+const { runUpdateAndRestart } = require('../utils/update-runner');
+
+async function updateCommand() {
+  console.log('');
+
+  try {
+    const info = await getUpdateInfo({ force: true });
+    if (info.latestVersion) {
+      console.log(chalk.bold(`Current: ${info.currentVersion}`));
+      console.log(chalk.bold(`Latest:  ${info.latestVersion}`));
+    }
+  } catch {}
+
+  const result = await runUpdateAndRestart({ restartArgs: ['start'] });
+  if (!result.ok) {
+    process.exit(1);
+  }
+
+  process.exit(result.restartExitCode ?? 0);
+}
+
+module.exports = updateCommand;

package/lib/cli/workspaces.js

@@ -15,6 +15,7 @@ const path = require('path');
 const os = require('os');
 const chalk = require('chalk');
 const { getConfig, setConfigValue, getConfigValue } = require('../config/manager');
+const { warnIfServerRunning } = require('../utils/restart-warning');
 
 // Directories to scan for sessions
 const SCAN_ROOTS = [
@@ -124,6 +125,7 @@ function setDefault(workspacePath) {
   }
 
   console.log(chalk.green(`\n✅ Default workspace set to: ${collapsed}\n`));
+  warnIfServerRunning();
 }
 
 /**
@@ -159,6 +161,7 @@ function addWorkspace(workspacePath) {
   setConfigValue('workspaces.paths', paths);
 
   console.log(chalk.green(`\n✅ Added workspace: ${collapsed}\n`));
+  warnIfServerRunning();
 }
 
 /**
@@ -195,6 +198,7 @@ function removeWorkspace(workspacePath) {
   }
 
   console.log(chalk.green(`\n✅ Removed workspace: ${collapsed}\n`));
+  warnIfServerRunning();
 }
 
 /**

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/update-check.js

@@ -0,0 +1,173 @@
+/**
+ * Update check utilities (npm + GitHub) with simple caching
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { PATHS, ensureDirectories } = require('./paths');
+const pkg = require('../../package.json');
+
+const CACHE_FILE = path.join(PATHS.DATA_DIR, 'version.json');
+const CHECK_INTERVAL_MS = 20 * 60 * 60 * 1000;
+const DEFAULT_TIMEOUT_MS = 4000;
+
+function normalizeVersion(raw) {
+  if (!raw || typeof raw !== 'string') return null;
+  const match = raw.trim().match(/(\d+\.\d+\.\d+)/);
+  return match ? match[1] : null;
+}
+
+function parseSemver(v) {
+  if (!v) return null;
+  const parts = v.trim().split('.');
+  if (parts.length < 3) return null;
+  const major = Number(parts[0]);
+  const minor = Number(parts[1]);
+  const patch = Number(parts[2]);
+  if (![major, minor, patch].every(Number.isFinite)) return null;
+  return [major, minor, patch];
+}
+
+function compareSemver(a, b) {
+  const av = parseSemver(a);
+  const bv = parseSemver(b);
+  if (!av || !bv) return null;
+  for (let i = 0; i < 3; i++) {
+    if (av[i] > bv[i]) return 1;
+    if (av[i] < bv[i]) return -1;
+  }
+  return 0;
+}
+
+function isNewer(latest, current) {
+  const cmp = compareSemver(latest, current);
+  if (cmp === null) return null;
+  return cmp === 1;
+}
+
+function readCache() {
+  if (!fs.existsSync(CACHE_FILE)) return null;
+  try {
+    const content = fs.readFileSync(CACHE_FILE, 'utf8');
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+
+function writeCache(info) {
+  ensureDirectories();
+  try {
+    fs.writeFileSync(CACHE_FILE, JSON.stringify(info, null, 2), 'utf8');
+  } catch {}
+}
+
+async function fetchJson(url, options = {}, timeoutMs = DEFAULT_TIMEOUT_MS) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  const res = await fetch(url, { ...options, signal: controller.signal });
+  clearTimeout(timer);
+  if (!res.ok) {
+    throw new Error(`HTTP ${res.status}`);
+  }
+  return res.json();
+}
+
+async function fetchNpmLatest(timeoutMs) {
+  const registryUrl = `https://registry.npmjs.org/${encodeURIComponent(pkg.name)}`;
+  const data = await fetchJson(registryUrl, { headers: { 'Accept': 'application/json' } }, timeoutMs);
+  const distTags = data['dist-tags'] || {};
+  return normalizeVersion(distTags.latest || distTags.stable);
+}
+
+async function fetchGithubLatest(timeoutMs) {
+  const url = 'https://api.github.com/repos/DioNanos/nexuscli/releases/latest';
+  const data = await fetchJson(url, {
+    headers: {
+      'User-Agent': 'nexuscli',
+      'Accept': 'application/vnd.github+json'
+    }
+  }, timeoutMs);
+  return normalizeVersion(data.tag_name);
+}
+
+function pickLatest(a, b) {
+  if (a && !b) return a;
+  if (b && !a) return b;
+  if (!a && !b) return null;
+  const cmp = compareSemver(a, b);
+  if (cmp === null) return a || b;
+  return cmp >= 0 ? a : b;
+}
+
+function buildInfo(info, { usedCache = false, error = null } = {}) {
+  const currentVersion = pkg.version;
+  const npmVersion = info?.npm_version || null;
+  const githubVersion = info?.github_version || null;
+  const latestVersion = info?.latest_version || pickLatest(npmVersion, githubVersion);
+  const npmNewer = isNewer(npmVersion, currentVersion);
+  const githubNewer = isNewer(githubVersion, currentVersion);
+
+  return {
+    currentVersion,
+    npmVersion,
+    githubVersion,
+    latestVersion,
+    npmNewer,
+    githubNewer,
+    updateAvailable: npmNewer === true,
+    usedCache,
+    error
+  };
+}
+
+async function getUpdateInfo({ force = false, timeoutMs = DEFAULT_TIMEOUT_MS } = {}) {
+  const cache = readCache();
+  const lastCheckedAt = cache?.last_checked_at ? Date.parse(cache.last_checked_at) : null;
+  const cacheFresh = lastCheckedAt && (Date.now() - lastCheckedAt) < CHECK_INTERVAL_MS;
+
+  if (!force && cache && cacheFresh) {
+    return buildInfo(cache, { usedCache: true });
+  }
+
+  let npmVersion = null;
+  let githubVersion = null;
+  const errors = [];
+
+  try {
+    npmVersion = await fetchNpmLatest(timeoutMs);
+  } catch (err) {
+    errors.push(`npm: ${err.message}`);
+  }
+
+  try {
+    githubVersion = await fetchGithubLatest(timeoutMs);
+  } catch (err) {
+    errors.push(`github: ${err.message}`);
+  }
+
+  if (!npmVersion && !githubVersion) {
+    if (cache) {
+      return buildInfo(cache, { usedCache: true, error: errors.join('; ') });
+    }
+    return buildInfo(null, { usedCache: false, error: errors.join('; ') });
+  }
+
+  const latestVersion = pickLatest(npmVersion, githubVersion);
+  const info = {
+    latest_version: latestVersion,
+    npm_version: npmVersion,
+    github_version: githubVersion,
+    last_checked_at: new Date().toISOString()
+  };
+
+  writeCache(info);
+  return buildInfo(info, { usedCache: false });
+}
+
+module.exports = {
+  getUpdateInfo,
+  normalizeVersion,
+  compareSemver,
+  isNewer
+};

package/lib/utils/update-runner.js

@@ -0,0 +1,62 @@
+/**
+ * Update + restart helpers
+ */
+
+const { spawn, spawnSync } = require('child_process');
+const chalk = require('chalk');
+const pkg = require('../../package.json');
+const { getServerPid, stopServer } = require('./server');
+
+function runUpdateCommand() {
+  console.log(chalk.cyan(`Running npm update for ${pkg.name}...`));
+  const result = spawnSync('npm', ['update', '-g', pkg.name], { stdio: 'inherit' });
+
+  if (result.error) {
+    console.log(chalk.red(`Update failed: ${result.error.message}`));
+    return false;
+  }
+
+  if (typeof result.status === 'number' && result.status !== 0) {
+    console.log(chalk.red(`Update exited with code ${result.status}`));
+    return false;
+  }
+
+  return true;
+}
+
+function restartCli(restartArgs = []) {
+  const args = restartArgs.length > 0 ? restartArgs : ['start'];
+  const env = { ...process.env, NEXUSCLI_SKIP_UPDATE_CHECK: '1' };
+
+  return new Promise((resolve) => {
+    const child = spawn('nexuscli', args, { stdio: 'inherit', env });
+    child.on('exit', (code) => resolve(code ?? 0));
+  });
+}
+
+async function runUpdateAndRestart({ restartArgs = [] } = {}) {
+  const runningPid = getServerPid();
+  if (runningPid) {
+    console.log(chalk.yellow(`Stopping NexusCLI (PID: ${runningPid})...`));
+    const stopResult = stopServer();
+    if (stopResult.error) {
+      console.log(chalk.red(`Failed to stop server: ${stopResult.error.message}`));
+      return { ok: false, error: stopResult.error };
+    }
+  }
+
+  const updated = runUpdateCommand();
+  if (!updated) {
+    return { ok: false, error: new Error('Update failed') };
+  }
+
+  console.log(chalk.green('✓ Update complete. Restarting NexusCLI...'));
+  const restartExitCode = await restartCli(restartArgs);
+  return { ok: true, restartExitCode };
+}
+
+module.exports = {
+  runUpdateCommand,
+  restartCli,
+  runUpdateAndRestart
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mmmbuto/nexuscli",
-  "version": "0.9.8",
+  "version": "0.9.9",
   "description": "NexusCLI - TRI CLI Control Plane (Claude/Codex/Gemini/Qwen)",
   "main": "lib/server/server.js",
   "bin": {