@mmmbuto/nexuscli 0.5.0

package/lib/cli/logs.js

@@ -0,0 +1,72 @@
+/**
+ * nexuscli logs - View server logs
+ */
+
+const chalk = require('chalk');
+const fs = require('fs');
+const { spawn } = require('child_process');
+
+const { PATHS } = require('../utils/paths');
+
+/**
+ * Main logs command
+ */
+async function logs(options) {
+  console.log('');
+
+  // Check if log file exists
+  if (!fs.existsSync(PATHS.SERVER_LOG)) {
+    console.log(chalk.yellow('No log file found.'));
+    console.log(chalk.gray(`Expected: ${PATHS.SERVER_LOG}`));
+    console.log('');
+    console.log('Server may not have been started as daemon yet.');
+    console.log(`Run ${chalk.cyan('nexuscli start --daemon')} first.`);
+    console.log('');
+    return;
+  }
+
+  const lines = parseInt(options.lines) || 50;
+
+  if (options.follow) {
+    // Follow mode (tail -f)
+    console.log(chalk.cyan(`Following logs (Ctrl+C to exit)...`));
+    console.log(chalk.gray(`File: ${PATHS.SERVER_LOG}`));
+    console.log('');
+
+    const tail = spawn('tail', ['-f', '-n', String(lines), PATHS.SERVER_LOG], {
+      stdio: 'inherit'
+    });
+
+    // Handle Ctrl+C
+    process.on('SIGINT', () => {
+      tail.kill();
+      console.log('');
+      process.exit(0);
+    });
+
+    // Wait for tail to exit
+    await new Promise((resolve) => {
+      tail.on('exit', resolve);
+    });
+  } else {
+    // Static mode (show last N lines)
+    console.log(chalk.cyan(`Last ${lines} lines:`));
+    console.log(chalk.gray(`File: ${PATHS.SERVER_LOG}`));
+    console.log('');
+
+    try {
+      const content = fs.readFileSync(PATHS.SERVER_LOG, 'utf8');
+      const allLines = content.split('\n');
+      const lastLines = allLines.slice(-lines).join('\n');
+      console.log(lastLines);
+    } catch (err) {
+      console.log(chalk.red(`Error reading logs: ${err.message}`));
+    }
+
+    console.log('');
+    console.log(chalk.gray(`Use ${chalk.white('nexuscli logs -f')} to follow live`));
+    console.log('');
+  }
+}
+
+module.exports = logs;

package/lib/cli/start.js

@@ -0,0 +1,220 @@
+/**
+ * nexuscli start - Start the server
+ */
+
+const chalk = require('chalk');
+const fs = require('fs');
+const path = require('path');
+const { spawn, execSync } = require('child_process');
+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;
+  }
+}
+
+/**
+ * Write PID file
+ */
+function writePidFile(pid) {
+  fs.writeFileSync(PATHS.PID_FILE, String(pid));
+}
+
+/**
+ * Open URL in browser (Termux-only)
+ */
+function openBrowser(url) {
+  try {
+    // Termux: use am start (Android intent) - most reliable
+    try {
+      execSync(`am start -a android.intent.action.VIEW -d "${url}"`, { stdio: 'ignore' });
+    } catch {
+      // Fallback to termux-open-url if am fails
+      const child = spawn('termux-open-url', [url], {
+        detached: true,
+        stdio: 'ignore'
+      });
+      child.unref();
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Ask yes/no question
+ */
+function askYesNo(question) {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+
+    rl.question(question, (answer) => {
+      rl.close();
+      const normalized = answer.trim().toLowerCase();
+      resolve(normalized === 'y' || normalized === 'yes' || normalized === 's' || normalized === 'si');
+    });
+  });
+}
+
+/**
+ * Start server in foreground
+ */
+function startForeground(config) {
+  const serverPath = path.join(__dirname, '..', 'server', 'server.js');
+
+  // Set environment variables from config
+  process.env.PORT = config.server.port;
+  process.env.JWT_SECRET = config.auth.jwt_secret;
+  process.env.NEXUSCLI_AUTO_SEED = '0'; // Don't auto-seed, we have config
+
+  // Acquire wake lock on Termux
+  if (isTermux() && config.termux.wake_lock) {
+    acquireWakeLock();
+    console.log(chalk.green('  ✓ Wake-lock acquired'));
+  }
+
+  // Start server
+  console.log('');
+  console.log(chalk.cyan(`Starting NexusCLI on port ${config.server.port}...`));
+  console.log('');
+
+  require(serverPath);
+}
+
+/**
+ * Start server as daemon
+ */
+function startDaemon(config) {
+  const serverPath = path.join(__dirname, '..', 'server', 'server.js');
+
+  // Ensure log directory exists
+  if (!fs.existsSync(PATHS.LOGS_DIR)) {
+    fs.mkdirSync(PATHS.LOGS_DIR, { recursive: true });
+  }
+
+  // Open log file
+  const logFile = fs.openSync(PATHS.SERVER_LOG, 'a');
+
+  // Spawn detached process
+  const child = spawn('node', [serverPath], {
+    detached: true,
+    stdio: ['ignore', logFile, logFile],
+    env: {
+      ...process.env,
+      PORT: config.server.port,
+      JWT_SECRET: config.auth.jwt_secret,
+      NEXUSCLI_AUTO_SEED: '0',
+      NEXUSCLI_DAEMON: '1'
+    }
+  });
+
+  // Write PID file
+  writePidFile(child.pid);
+
+  // Unref to allow parent to exit
+  child.unref();
+
+  // Acquire wake lock on Termux
+  if (isTermux() && config.termux.wake_lock) {
+    acquireWakeLock();
+  }
+
+  // Send notification on Termux
+  if (isTermux() && config.termux.notifications) {
+    sendNotification('NexusCLI', `Server running on port ${config.server.port}`);
+  }
+
+  return child.pid;
+}
+
+/**
+ * Main start command
+ */
+async function start(options) {
+  console.log('');
+
+  // Check if initialized
+  if (!isInitialized()) {
+    console.log(chalk.yellow('NexusCLI is not configured.'));
+    console.log(`Run ${chalk.cyan('nexuscli init')} first.`);
+    console.log('');
+    process.exit(1);
+  }
+
+  // Check if already running
+  const runningPid = isServerRunning();
+  if (runningPid) {
+    console.log(chalk.yellow(`Server already running (PID: ${runningPid})`));
+    console.log(`Run ${chalk.cyan('nexuscli stop')} to stop it.`);
+    console.log('');
+    process.exit(1);
+  }
+
+  const config = getConfig();
+  const port = options.port || config.server.port;
+  config.server.port = port;
+
+  const url = `http://localhost:${port}`;
+
+  // Foreground mode (--foreground flag)
+  if (options.foreground) {
+    startForeground(config);
+    return;
+  }
+
+  // Default: Daemon mode
+  console.log(chalk.bold('Starting NexusCLI...'));
+  console.log('');
+
+  const pid = startDaemon(config);
+
+  console.log(chalk.green(`  ✓ Server started (PID: ${pid})`));
+  console.log(chalk.gray(`  Logs: ${PATHS.SERVER_LOG}`));
+  console.log('');
+  console.log(chalk.bold(`  ${chalk.cyan(url)}`));
+  console.log('');
+
+  // Ask to open browser (unless --no-browser)
+  if (options.browser !== false) {
+    const shouldOpen = await askYesNo(`  Open browser? ${chalk.gray('(Y/n)')} `);
+
+    if (shouldOpen) {
+      const opened = openBrowser(url);
+      if (opened) {
+        console.log(chalk.green('  ✓ Browser opened'));
+      } else {
+        console.log(chalk.yellow('  Could not open browser'));
+      }
+    }
+  }
+
+  console.log('');
+}
+
+module.exports = start;

package/lib/cli/status.js

@@ -0,0 +1,187 @@
+/**
+ * nexuscli status - Show server and engine status
+ */
+
+const chalk = require('chalk');
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+const { isInitialized, getConfig } = require('../config/manager');
+const { PATHS, HOME } = require('../utils/paths');
+const { isTermux, isTermuxApiWorking } = require('../utils/termux');
+
+/**
+ * Check if server is running
+ */
+function getServerStatus() {
+  if (!fs.existsSync(PATHS.PID_FILE)) {
+    return { running: false };
+  }
+
+  try {
+    const pid = parseInt(fs.readFileSync(PATHS.PID_FILE, 'utf8').trim());
+    process.kill(pid, 0);
+
+    // Try to get uptime from /proc
+    let uptime = null;
+    try {
+      const stat = fs.statSync(`/proc/${pid}`);
+      const uptimeMs = Date.now() - stat.ctimeMs;
+      uptime = formatUptime(uptimeMs);
+    } catch {}
+
+    return { running: true, pid, uptime };
+  } catch {
+    return { running: false };
+  }
+}
+
+/**
+ * Format uptime in human readable format
+ */
+function formatUptime(ms) {
+  const seconds = Math.floor(ms / 1000);
+  const minutes = Math.floor(seconds / 60);
+  const hours = Math.floor(minutes / 60);
+  const days = Math.floor(hours / 24);
+
+  if (days > 0) return `${days}d ${hours % 24}h`;
+  if (hours > 0) return `${hours}h ${minutes % 60}m`;
+  if (minutes > 0) return `${minutes}m ${seconds % 60}s`;
+  return `${seconds}s`;
+}
+
+/**
+ * Check CLI status for an engine
+ */
+function getEngineStatus(engine) {
+  try {
+    const output = execSync(`${engine} --version 2>/dev/null`, { encoding: 'utf8' });
+    const version = output.trim().split('\n')[0];
+    return { available: true, version };
+  } catch {
+    return { available: false };
+  }
+}
+
+/**
+ * Count workspaces with sessions
+ */
+function countWorkspaces() {
+  const projectsDir = path.join(HOME, '.claude', 'projects');
+  if (!fs.existsSync(projectsDir)) {
+    return 0;
+  }
+
+  try {
+    const entries = fs.readdirSync(projectsDir, { withFileTypes: true });
+    return entries.filter(e => e.isDirectory()).length;
+  } catch {
+    return 0;
+  }
+}
+
+/**
+ * Main status command (TRI CLI v0.4.0)
+ */
+async function status() {
+  console.log('');
+
+  if (!isInitialized()) {
+    console.log(chalk.yellow('NexusCLI is not configured.'));
+    console.log(`Run ${chalk.cyan('nexuscli init')} first.`);
+    console.log('');
+    return;
+  }
+
+  const config = getConfig();
+  const serverStatus = getServerStatus();
+  const claudeStatus = getEngineStatus('claude');
+  const codexStatus = getEngineStatus('codex');
+  const geminiStatus = getEngineStatus('gemini');
+  const workspaceCount = countWorkspaces();
+
+  // Header
+  console.log(chalk.bold('╔═══════════════════════════════════════════╗'));
+  console.log(chalk.bold('║  NexusCLI Status (TRI CLI v0.4.0)         ║'));
+  console.log(chalk.bold('╠═══════════════════════════════════════════╣'));
+
+  // Server
+  if (serverStatus.running) {
+    const uptimeStr = serverStatus.uptime ? ` (${serverStatus.uptime})` : '';
+    console.log(chalk.bold(`║  Server: ${chalk.green('✓ Running')} ${chalk.gray(`PID ${serverStatus.pid}`)}${uptimeStr}`));
+  } else {
+    console.log(chalk.bold(`║  Server: ${chalk.red('✗ Stopped')}`));
+  }
+
+  console.log(chalk.bold(`║  Port:   ${chalk.white(config.server.port)}`));
+  console.log(chalk.bold('║'));
+
+  // Engines
+  console.log(chalk.bold('║  Engines:'));
+
+  // Claude
+  if (claudeStatus.available) {
+    const model = config.engines?.claude?.model || 'sonnet';
+    console.log(chalk.bold(`║    Claude: ${chalk.green('✓')} ${chalk.gray(model)}`));
+  } else {
+    console.log(chalk.bold(`║    Claude: ${chalk.red('✗')} ${chalk.gray('not found')}`));
+  }
+
+  // Codex
+  if (codexStatus.available) {
+    const enabled = config.engines?.codex?.enabled;
+    const model = config.engines?.codex?.model || 'gpt-5.1-codex-max';
+    if (enabled) {
+      console.log(chalk.bold(`║    Codex:  ${chalk.green('✓')} ${chalk.gray(model)}`));
+    } else {
+      console.log(chalk.bold(`║    Codex:  ${chalk.gray('○')} ${chalk.gray('disabled')}`));
+    }
+  } else {
+    console.log(chalk.bold(`║    Codex:  ${chalk.gray('○')} ${chalk.gray('not found')}`));
+  }
+
+  // Gemini
+  if (geminiStatus.available) {
+    const enabled = config.engines?.gemini?.enabled;
+    const model = config.engines?.gemini?.model || 'gemini-3-pro-preview';
+    if (enabled) {
+      console.log(chalk.bold(`║    Gemini: ${chalk.green('✓')} ${chalk.gray(model)}`));
+    } else {
+      console.log(chalk.bold(`║    Gemini: ${chalk.gray('○')} ${chalk.gray('disabled')}`));
+    }
+  } else {
+    console.log(chalk.bold(`║    Gemini: ${chalk.gray('○')} ${chalk.gray('not found')}`));
+  }
+
+  console.log(chalk.bold('║'));
+
+  // Workspaces
+  console.log(chalk.bold(`║  Workspaces: ${chalk.white(workspaceCount)} indexed`));
+
+  // Termux status
+  if (isTermux()) {
+    console.log(chalk.bold('║'));
+    console.log(chalk.bold('║  Termux:'));
+    console.log(chalk.bold(`║    Wake-lock:  ${config.termux?.wake_lock ? chalk.green('enabled') : chalk.gray('disabled')}`));
+    console.log(chalk.bold(`║    Boot-start: ${config.termux?.boot_start ? chalk.green('enabled') : chalk.gray('disabled')}`));
+
+    if (isTermuxApiWorking()) {
+      console.log(chalk.bold(`║    API app:    ${chalk.green('working')}`));
+    } else {
+      console.log(chalk.bold(`║    API app:    ${chalk.yellow('not detected')}`));
+    }
+  }
+
+  console.log(chalk.bold('╚═══════════════════════════════════════════╝'));
+  console.log('');
+
+  // URL if running
+  if (serverStatus.running) {
+    console.log(chalk.cyan(`  http://localhost:${config.server.port}`));
+    console.log('');
+  }
+}
+
+module.exports = status;

package/lib/cli/stop.js

@@ -0,0 +1,64 @@
+/**
+ * nexuscli stop - Stop the daemon
+ */
+
+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');
+
+/**
+ * Main stop command
+ */
+async function stop() {
+  console.log('');
+
+  // Check PID file
+  if (!fs.existsSync(PATHS.PID_FILE)) {
+    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}`));
+    console.log('');
+    process.exit(1);
+  }
+}
+
+module.exports = stop;