@mmmbuto/nexuscli 0.9.7004-termux → 0.10.0

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
   );
 }

package/lib/utils/update-check.js

@@ -0,0 +1,153 @@
+/**
+ * Update check utilities (npm registry) 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);
+}
+
+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 = null;
+  const latestVersion = info?.latest_version || npmVersion;
+  const npmNewer = isNewer(npmVersion, currentVersion);
+  const githubNewer = null;
+
+  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;
+  const errors = [];
+
+  try {
+    npmVersion = await fetchNpmLatest(timeoutMs);
+  } catch (err) {
+    errors.push(`npm: ${err.message}`);
+  }
+
+  if (!npmVersion) {
+    if (cache) {
+      return buildInfo(cache, { usedCache: true, error: errors.join('; ') });
+    }
+    return buildInfo(null, { usedCache: false, error: errors.join('; ') });
+  }
+
+  const info = {
+    latest_version: npmVersion,
+    npm_version: npmVersion,
+    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.7004-termux",
+  "version": "0.10.0",
   "description": "NexusCLI - TRI CLI Control Plane (Claude/Codex/Gemini/Qwen)",
   "main": "lib/server/server.js",
   "bin": {
@@ -44,20 +44,18 @@
     "frontend/dist/",
     "package.json",
     "README.md",
+    "CHANGELOG.md",
     "LICENSE"
   ],
   "engines": {
     "node": ">=18.0.0"
   },
-  "os": [
-    "linux",
-    "android"
-  ],
   "cpu": [
     "arm64",
     "x64"
   ],
   "dependencies": {
+    "@mmmbuto/pty-termux-utils": "^1.1.4",
     "bcryptjs": "^3.0.3",
     "chalk": "^4.1.2",
     "commander": "^12.1.0",
@@ -75,5 +73,8 @@
   },
   "devDependencies": {
     "jest": "^30.2.0"
+  },
+  "optionalDependencies": {
+    "@mmmbuto/node-pty-android-arm64": "~1.1.0"
   }
 }