neoagent 2.4.1-beta.19 → 2.4.1-beta.21

package/lib/manager.js

@@ -62,29 +62,86 @@ const COLORS = process.stdout.isTTY
       green: '\x1b[1;32m',
       yellow: '\x1b[1;33m',
       blue: '\x1b[1;34m',
+      magenta: '\x1b[1;35m',
       cyan: '\x1b[1;36m',
       dim: '\x1b[2m'
     }
-  : { reset: '', bold: '', red: '', green: '', yellow: '', blue: '', cyan: '', dim: '' };
+  : { reset: '', bold: '', red: '', green: '', yellow: '', blue: '', magenta: '', cyan: '', dim: '' };
+
+const CLI_INTERACTIVE = process.stdout.isTTY;
+const installActionItems = [];
 
 function logInfo(msg) {
-  console.log(`  ${COLORS.blue}->${COLORS.reset} ${msg}`);
+  const mark = CLI_INTERACTIVE ? `${COLORS.blue}◇${COLORS.reset}` : '->';
+  console.log(`  ${mark} ${msg}`);
 }
 
 function logOk(msg) {
-  console.log(`  ${COLORS.green}ok${COLORS.reset} ${msg}`);
+  const mark = CLI_INTERACTIVE ? `${COLORS.green}◆${COLORS.reset}` : 'ok';
+  console.log(`  ${mark} ${msg}`);
 }
 
 function logWarn(msg) {
-  console.warn(`  ${COLORS.yellow}warn${COLORS.reset} ${msg}`);
+  const mark = CLI_INTERACTIVE ? `${COLORS.yellow}▲${COLORS.reset}` : 'warn';
+  console.warn(`  ${mark} ${msg}`);
 }
 
 function logErr(msg) {
-  console.error(`  ${COLORS.red}err${COLORS.reset} ${msg}`);
+  const mark = CLI_INTERACTIVE ? `${COLORS.red}✕${COLORS.reset}` : 'err';
+  console.error(`  ${mark} ${msg}`);
 }
 
 function heading(text) {
-  console.log(`\n${COLORS.bold}${text}${COLORS.reset}`);
+  if (!CLI_INTERACTIVE) {
+    console.log(`\n${text}`);
+    return;
+  }
+  console.log(`\n${COLORS.bold}${COLORS.cyan}${text}${COLORS.reset}`);
+}
+
+function cliBanner(title = APP_NAME, subtitle = 'local agent control') {
+  if (!CLI_INTERACTIVE) return;
+  const c = COLORS;
+  const width = 38;
+  const stripAnsi = (text) => String(text).replace(/\x1b\[[0-9;]*m/g, '');
+  const boxLine = (content) => {
+    const padding = Math.max(0, width - stripAnsi(content).length);
+    console.log(`  ${c.cyan}│${c.reset} ${content}${' '.repeat(padding)} ${c.cyan}│${c.reset}`);
+  };
+  console.log('');
+  console.log(`  ${c.cyan}╭────────────────────────────────────────╮${c.reset}`);
+  boxLine(`${c.bold}${c.magenta}NeoAgent${c.reset} ${c.dim}arcade ops console${c.reset}`);
+  boxLine(`${c.bold}${title}${c.reset} ${c.dim}${subtitle}${c.reset}`);
+  console.log(`  ${c.cyan}╰────────────────────────────────────────╯${c.reset}`);
+}
+
+function cliSection(text) {
+  if (CLI_INTERACTIVE) {
+    console.log(`${COLORS.dim}  ──${COLORS.reset} ${COLORS.bold}${text}${COLORS.reset}`);
+  } else {
+    console.log(text);
+  }
+}
+
+function statusLine(ok, label, value, hint = '') {
+  const mark = ok ? (CLI_INTERACTIVE ? `${COLORS.green}●${COLORS.reset}` : 'ok') : (CLI_INTERACTIVE ? `${COLORS.yellow}●${COLORS.reset}` : 'warn');
+  const padded = String(label).padEnd(9);
+  const suffix = hint ? ` ${COLORS.dim}${hint}${COLORS.reset}` : '';
+  console.log(`  ${mark} ${padded} ${value}${suffix}`);
+}
+
+function rememberInstallAction(message) {
+  if (!installActionItems.includes(message)) {
+    installActionItems.push(message);
+  }
+}
+
+function printInstallActionItems() {
+  if (installActionItems.length === 0) return;
+  heading('Post-install actions');
+  for (const item of installActionItems) {
+    logWarn(item);
+  }
 }
 
 function detectPlatform() {
@@ -477,6 +534,43 @@ async function askSecret(question, currentValue = '') {
   });
 }
 
+function defaultEnvLines(current = {}) {
+  const defaultVmBaseImageUrl = getDefaultVmBaseImageUrl();
+  const port = current.PORT || '3333';
+  const publicUrl = current.PUBLIC_URL || '';
+  const secureCookies = current.SECURE_COOKIES ||
+    (String(publicUrl || '').trim().startsWith('https://') ? 'true' : 'false');
+  const trustProxy = current.TRUST_PROXY || secureCookies;
+  return [
+    'NODE_ENV=production',
+    `PORT=${port}`,
+    publicUrl ? `PUBLIC_URL=${publicUrl}` : '',
+    `SECURE_COOKIES=${String(secureCookies || '').trim().toLowerCase() === 'true' ? 'true' : 'false'}`,
+    `TRUST_PROXY=${String(trustProxy || '').trim().toLowerCase() === 'true' ? 'true' : 'false'}`,
+    `SESSION_SECRET=${current.SESSION_SECRET || randomSecret()}`,
+    `NEOAGENT_PROFILE=${current.NEOAGENT_PROFILE || 'prod'}`,
+    `NEOAGENT_DEPLOYMENT_MODE=${parseDeploymentMode(current.NEOAGENT_DEPLOYMENT_MODE || 'self_hosted')}`,
+    `NEOAGENT_RELEASE_CHANNEL=${parseReleaseChannel(current.NEOAGENT_RELEASE_CHANNEL || 'stable') || 'stable'}`,
+    `NEOAGENT_VM_BASE_IMAGE_URL=${current.NEOAGENT_VM_BASE_IMAGE_URL || defaultVmBaseImageUrl}`,
+    `NEOAGENT_VM_MEMORY_MB=${current.NEOAGENT_VM_MEMORY_MB || '4096'}`,
+    `NEOAGENT_VM_CPUS=${current.NEOAGENT_VM_CPUS || '2'}`,
+    `NEOAGENT_VM_GUEST_TOKEN=${current.NEOAGENT_VM_GUEST_TOKEN || randomSecret()}`,
+    current.XAI_BASE_URL ? `XAI_BASE_URL=${current.XAI_BASE_URL}` : 'XAI_BASE_URL=https://api.x.ai/v1',
+    current.OLLAMA_URL ? `OLLAMA_URL=${current.OLLAMA_URL}` : 'OLLAMA_URL=http://localhost:11434',
+    current.DEEPGRAM_BASE_URL ? `DEEPGRAM_BASE_URL=${current.DEEPGRAM_BASE_URL}` : 'DEEPGRAM_BASE_URL=https://api.deepgram.com',
+    current.DEEPGRAM_MODEL ? `DEEPGRAM_MODEL=${current.DEEPGRAM_MODEL}` : 'DEEPGRAM_MODEL=nova-3',
+    current.DEEPGRAM_LANGUAGE ? `DEEPGRAM_LANGUAGE=${current.DEEPGRAM_LANGUAGE}` : 'DEEPGRAM_LANGUAGE=multi',
+  ].filter(Boolean);
+}
+
+function writeDefaultEnvFile() {
+  ensureRuntimeDirs();
+  const current = Object.fromEntries(parseEnv(readEnvFileRaw()).entries());
+  fs.writeFileSync(ENV_FILE, `${defaultEnvLines(current).join('\n')}\n`, { mode: 0o600 });
+  logOk(`Wrote default config to ${ENV_FILE}`);
+  rememberInstallAction('Add provider keys with `neoagent setup`, `neoagent env set KEY VALUE`, or the login commands when you are ready.');
+}
+
 async function cmdSetup() {
   heading('Environment Setup');
   ensureRuntimeDirs();
@@ -1193,6 +1287,50 @@ function installDependencies() {
   logOk('Dependencies installed');
 }
 
+function assertSupportedNodeRuntime() {
+  const major = Number(String(process.versions.node || '').split('.')[0]);
+  if (!Number.isInteger(major) || major < 20) {
+    throw new Error(`NeoAgent requires Node.js 20 or newer. Current runtime is ${process.versions.node || 'unknown'}.`);
+  }
+  logOk(`Node.js ${process.versions.node}`);
+}
+
+function installPreflight() {
+  heading('Installer preflight');
+  ensureRuntimeDirs();
+  assertSupportedNodeRuntime();
+
+  if (!commandExists('npm')) {
+    throw new Error('npm was not found in PATH. Install Node.js 20+ with npm, then run `neoagent install` again.');
+  }
+  const npmVersion = runQuiet('npm', ['--version']);
+  logOk(`npm ${npmVersion.status === 0 ? npmVersion.stdout.trim() : '(version unknown)'}`);
+
+  const platform = detectPlatform();
+  if (platform === 'other') {
+    rememberInstallAction('Automatic service installation is available on macOS and Linux. This machine will use a detached process fallback.');
+  } else {
+    logOk(`platform ${platform}`);
+  }
+
+  if (platform === 'macos' && !commandExists('launchctl')) {
+    rememberInstallAction('launchctl was not found, so the installer will use a detached process fallback instead of a login service.');
+  }
+  if (platform === 'linux' && !commandExists('systemctl')) {
+    rememberInstallAction('systemctl was not found, so the installer will use a detached process fallback instead of a user service.');
+  }
+
+  const port = loadEnvPort();
+  const portOwner = commandExists('lsof')
+    ? runQuiet('lsof', ['-nP', '-iTCP:' + port, '-sTCP:LISTEN'])
+    : null;
+  if (portOwner && portOwner.status === 0 && portOwner.stdout.trim()) {
+    logInfo(`Port ${port} already has a listener; install will keep existing processes unless service start replaces them.`);
+  } else {
+    logOk(`port ${port} available`);
+  }
+}
+
 function buildBundledWebClientIfPossible({ required = false } = {}) {
   heading('Web Client');
   return buildWebClient({
@@ -1281,7 +1419,7 @@ function startFallback() {
   logOk(`Started detached process (pid ${child.pid})`);
 }
 
-async function ensureQemuInstalled() {
+async function ensureQemuInstalled({ required = false } = {}) {
   heading('Ensure QEMU Installed');
   const platform = detectPlatform();
   
@@ -1295,35 +1433,54 @@ async function ensureQemuInstalled() {
 
   logInfo('QEMU components not found. Attempting to install...');
 
-  if (platform === 'macos') {
-    if (!commandExists('brew')) {
-      throw new Error('Homebrew is required to install QEMU on macOS. Please install it first: https://brew.sh/');
-    }
-    logInfo('Running "brew install qemu"...');
-    runOrThrow('brew', ['install', 'qemu']);
-  } else if (platform === 'linux') {
-    const isArm = process.arch === 'arm64' || process.arch === 'aarch64';
-    if (commandExists('apt-get')) {
-      const pkgs = ['qemu-utils'];
-      if (isArm) {
-        pkgs.push('qemu-system-arm');
+  try {
+    if (platform === 'macos') {
+      if (!commandExists('brew')) {
+        const message = 'Homebrew is required for automatic QEMU install on macOS. Install Homebrew from https://brew.sh/ and run `neoagent install` again.';
+        if (required) throw new Error(message);
+        logWarn('Homebrew not found; VM features will stay unavailable until QEMU is installed.');
+        rememberInstallAction(message);
+        return false;
+      }
+      logInfo('Running "brew install qemu"...');
+      runOrThrow('brew', ['install', 'qemu']);
+    } else if (platform === 'linux') {
+      const isArm = process.arch === 'arm64' || process.arch === 'aarch64';
+      if (commandExists('apt-get')) {
+        const pkgs = ['qemu-utils'];
+        if (isArm) {
+          pkgs.push('qemu-system-arm');
+        } else {
+          pkgs.push('qemu-system-x86');
+        }
+        logInfo(`Running "sudo apt-get update && sudo apt-get install -y ${pkgs.join(' ')}"...`);
+        runOrThrow('sudo', ['apt-get', 'update']);
+        runOrThrow('sudo', ['apt-get', 'install', '-y', ...pkgs]);
+      } else if (commandExists('dnf')) {
+        logInfo('Running "sudo dnf install -y qemu-kvm qemu-img"...');
+        runOrThrow('sudo', ['dnf', 'install', '-y', 'qemu-kvm', 'qemu-img']);
+      } else if (commandExists('yum')) {
+        logInfo('Running "sudo yum install -y qemu-kvm qemu-img"...');
+        runOrThrow('sudo', ['yum', 'install', '-y', 'qemu-kvm', 'qemu-img']);
       } else {
-        pkgs.push('qemu-system-x86');
+        const message = 'Unsupported Linux package manager for automatic QEMU install. Install qemu-system and qemu-utils, then run `neoagent install` again.';
+        if (required) throw new Error(message);
+        logWarn('Could not find apt-get, dnf, or yum for QEMU installation.');
+        rememberInstallAction(message);
+        return false;
       }
-      logInfo(`Running "sudo apt-get update && sudo apt-get install -y ${pkgs.join(' ')}"...`);
-      runOrThrow('sudo', ['apt-get', 'update']);
-      runOrThrow('sudo', ['apt-get', 'install', '-y', ...pkgs]);
-    } else if (commandExists('dnf')) {
-      logInfo('Running "sudo dnf install -y qemu-kvm qemu-img"...');
-      runOrThrow('sudo', ['dnf', 'install', '-y', 'qemu-kvm', 'qemu-img']);
-    } else if (commandExists('yum')) {
-      logInfo('Running "sudo yum install -y qemu-kvm qemu-img"...');
-      runOrThrow('sudo', ['yum', 'install', '-y', 'qemu-kvm', 'qemu-img']);
     } else {
-      throw new Error('Unsupported Linux distribution. Please install qemu-system and qemu-utils manually.');
+      const message = 'Unsupported platform for automatic QEMU installation. Install QEMU manually if you need VM-isolated runtime features.';
+      if (required) throw new Error(message);
+      logWarn('Skipping QEMU auto-install on this platform.');
+      rememberInstallAction(message);
+      return false;
     }
-  } else {
-    throw new Error('Unsupported platform for automatic QEMU installation. Please install QEMU manually.');
+  } catch (err) {
+    if (required) throw err;
+    logWarn(`QEMU install did not complete: ${err.message}`);
+    rememberInstallAction('Install QEMU manually or rerun `neoagent install` after your package manager is ready.');
+    return false;
   }
 
   const verifiedSystem = commandExists('qemu-system-x86_64') || commandExists('qemu-system-aarch64');
@@ -1331,8 +1488,13 @@ async function ensureQemuInstalled() {
 
   if (verifiedSystem && verifiedImg) {
     logOk('QEMU installed successfully');
+    return true;
   } else {
-    throw new Error('QEMU installation failed or components not found in PATH after install.');
+    const message = 'QEMU installation finished but required binaries were not found in PATH.';
+    if (required) throw new Error(message);
+    logWarn(message);
+    rememberInstallAction('Ensure qemu-system and qemu-img are available in PATH, then run `neoagent install` again.');
+    return false;
   }
 }
 
@@ -1341,7 +1503,7 @@ function ensureYtDlpInstalled() {
   if (commandExists('yt-dlp')) {
     const ver = runQuiet('yt-dlp', ['--version']);
     logOk(`yt-dlp ${ver.status === 0 ? ver.stdout.trim() : '(version unknown)'}`);
-    return;
+    return true;
   }
 
   logInfo('yt-dlp not found. Attempting to install...');
@@ -1349,16 +1511,19 @@ function ensureYtDlpInstalled() {
 
   if (platform === 'macos') {
     if (!commandExists('brew')) {
-      logWarn('Homebrew not found — skipping yt-dlp install. Install manually: brew install yt-dlp');
-      return;
+      logWarn('Homebrew not found; skipping yt-dlp auto-install.');
+      rememberInstallAction('Install yt-dlp with `brew install yt-dlp` if you need video/audio extraction.');
+      return false;
     }
     try {
       runOrThrow('brew', ['install', 'yt-dlp']);
       logOk('yt-dlp installed via Homebrew');
+      return true;
     } catch {
-      logWarn('yt-dlp install failed. Install manually: brew install yt-dlp');
+      logWarn('yt-dlp install failed.');
+      rememberInstallAction('Install yt-dlp with `brew install yt-dlp` if you need video/audio extraction.');
+      return false;
     }
-    return;
   }
 
   if (platform === 'linux') {
@@ -1366,7 +1531,7 @@ function ensureYtDlpInstalled() {
       try {
         runOrThrow('pipx', ['install', 'yt-dlp']);
         logOk('yt-dlp installed via pipx');
-        return;
+        return true;
       } catch {
         // fall through to pip3
       }
@@ -1375,24 +1540,39 @@ function ensureYtDlpInstalled() {
       try {
         runOrThrow('pip3', ['install', '--user', 'yt-dlp']);
         logOk('yt-dlp installed via pip3');
-        return;
+        return true;
       } catch {
         // fall through to warn
       }
     }
-    logWarn('Could not install yt-dlp automatically. Install manually: pipx install yt-dlp');
+    logWarn('Could not install yt-dlp automatically.');
+    rememberInstallAction('Install yt-dlp with `pipx install yt-dlp` or your OS package manager if you need video/audio extraction.');
+    return false;
   }
+  rememberInstallAction('Install yt-dlp manually if you need video/audio extraction.');
+  return false;
 }
 
 async function cmdInstall() {
+  installActionItems.length = 0;
+  cliBanner(`Install ${APP_NAME}`, 'guided bootstrap');
   heading(`Install ${APP_NAME}`);
+  installPreflight();
+
   if (!fs.existsSync(ENV_FILE)) {
-    logWarn('.env not found; starting setup');
-    await cmdSetup();
+    if (process.stdin.isTTY) {
+      logWarn('.env not found; starting guided setup');
+      await cmdSetup();
+    } else {
+      logWarn('.env not found and stdin is not interactive; writing a secure default config');
+      writeDefaultEnvFile();
+    }
+  } else {
+    logOk(`Using config ${ENV_FILE}`);
   }
 
   installDependencies();
-  await ensureQemuInstalled();
+  await ensureQemuInstalled({ required: false });
   ensureYtDlpInstalled();
   buildBundledWebClientIfPossible({ required: true });
 
@@ -1407,19 +1587,25 @@ async function cmdInstall() {
 
   const port = loadEnvPort();
   logOk(`Running on http://localhost:${port}`);
+  printInstallActionItems();
+  heading('Ready');
+  logInfo(`Open http://localhost:${port} or run \`neoagent status\` for a health check.`);
 }
 
 function cmdStart() {
+  cliBanner(`Start ${APP_NAME}`, 'boot sequence');
   heading(`Start ${APP_NAME}`);
   const platform = detectPlatform();
 
   if (platform === 'macos' && fs.existsSync(PLIST_DST)) {
+    logInfo('Handing launch to launchd');
     installMacService();
     logOk('launchd start requested');
     return;
   }
 
   if (platform === 'linux' && fs.existsSync(SYSTEMD_UNIT)) {
+    logInfo('Handing launch to systemd');
     runOrThrow('systemctl', ['--user', 'start', 'neoagent']);
     runOrThrow('systemctl', ['--user', 'is-active', '--quiet', 'neoagent']);
     logOk('systemd start requested');
@@ -1512,54 +1698,68 @@ function cmdUninstall() {
 }
 
 async function cmdStatus() {
+  cliBanner(`${APP_NAME} Status`, 'systems sweep');
   heading(`${APP_NAME} Status`);
   const port = loadEnvPort();
   const running = await isPortOpen(port);
   const releaseChannel = currentReleaseChannel();
   const platform = detectPlatform();
 
-  if (running) {
-    logOk(`server   http://localhost:${port}`);
-  } else {
-    logWarn(`server   not reachable on port ${port}`);
-  }
+  cliSection('Runtime');
+  statusLine(
+    running,
+    'server',
+    running ? `http://localhost:${port}` : `not reachable on port ${port}`,
+  );
 
   if (platform === 'macos' && fs.existsSync(PLIST_DST)) {
     const svcRes = runQuiet('launchctl', ['list', SERVICE_LABEL]);
-    if (svcRes.status === 0 && svcRes.stdout.trim()) {
-      logOk(`service  launchd (${SERVICE_LABEL})`);
-    } else {
-      logWarn(`service  launchd unit not loaded — run: neoagent install`);
-    }
+    statusLine(
+      svcRes.status === 0 && Boolean(svcRes.stdout.trim()),
+      'service',
+      svcRes.status === 0 && svcRes.stdout.trim()
+        ? `launchd (${SERVICE_LABEL})`
+        : 'launchd unit not loaded',
+      svcRes.status === 0 && svcRes.stdout.trim() ? '' : 'run: neoagent install',
+    );
   } else if (platform === 'linux' && fs.existsSync(SYSTEMD_UNIT)) {
     const svcRes = runQuiet('systemctl', ['--user', 'is-active', 'neoagent']);
-    if (svcRes.status === 0 && svcRes.stdout.trim() === 'active') {
-      logOk('service  systemd (neoagent)');
-    } else {
-      logWarn('service  systemd unit not active — run: neoagent install');
-    }
+    statusLine(
+      svcRes.status === 0 && svcRes.stdout.trim() === 'active',
+      'service',
+      svcRes.status === 0 && svcRes.stdout.trim() === 'active'
+        ? 'systemd (neoagent)'
+        : 'systemd unit not active',
+      svcRes.status === 0 && svcRes.stdout.trim() === 'active' ? '' : 'run: neoagent install',
+    );
   }
 
-  if (fs.existsSync(ENV_FILE)) {
-    logOk(`config   ${ENV_FILE}`);
-  } else {
-    logWarn(`config   .env not found — run: neoagent setup`);
-  }
+  cliSection('Assets');
+  statusLine(
+    fs.existsSync(ENV_FILE),
+    'config',
+    fs.existsSync(ENV_FILE) ? ENV_FILE : '.env not found',
+    fs.existsSync(ENV_FILE) ? '' : 'run: neoagent setup',
+  );
 
-  if (hasBundledWebClient(WEB_CLIENT_DIR)) {
-    logOk('web      bundled Flutter client present');
-  } else {
-    logWarn('web      no bundled client — run: neoagent rebuild-web');
-  }
+  statusLine(
+    hasBundledWebClient(WEB_CLIENT_DIR),
+    'web',
+    hasBundledWebClient(WEB_CLIENT_DIR)
+      ? 'bundled Flutter client present'
+      : 'no bundled client',
+    hasBundledWebClient(WEB_CLIENT_DIR) ? '' : 'run: neoagent rebuild-web',
+  );
 
   console.log('');
-  console.log(`  install  ${APP_DIR}`);
-  console.log(`  version  ${currentInstalledVersionLabel()}`);
-  console.log(`  channel  ${releaseChannelSummary(releaseChannel)}`);
+  cliSection('Build');
+  console.log(`  install   ${APP_DIR}`);
+  console.log(`  version   ${currentInstalledVersionLabel()}`);
+  console.log(`  channel   ${releaseChannelSummary(releaseChannel)}`);
 
   const processes = listNeoAgentServerProcesses();
   if (processes.length > 0) {
-    console.log(`  pids     ${processes.map((proc) => proc.pid).join(', ')}`);
+    console.log(`  pids      ${processes.map((proc) => proc.pid).join(', ')}`);
     if (processes.length > 1) {
       logWarn(`multiple NeoAgent processes detected (${processes.length})`);
     }
@@ -1729,14 +1929,15 @@ function printHelp() {
 
   function row(cmd, desc) {
     const padded = `  neoagent ${cmd}`.padEnd(W);
-    console.log(`${padded}${c.dim}${desc}${c.reset}`);
+    const arrow = CLI_INTERACTIVE ? `${c.cyan}›${c.reset} ` : '';
+    console.log(`${padded}${arrow}${c.dim}${desc}${c.reset}`);
   }
 
-  console.log(`\n${c.bold}neoagent${c.reset}  —  manage your NeoAgent server\n`);
-  console.log(`${c.bold}Usage${c.reset}  neoagent <command> [args]\n`);
+  cliBanner('neoagent', 'command deck');
+  console.log(`\n${c.bold}Usage${c.reset}  neoagent <command> [args]\n`);
 
-  console.log(`${c.bold}Lifecycle${c.reset}`);
-  row('install',              'First-time install and service setup');
+  cliSection('Lifecycle');
+  row('install',              'Guided bootstrap, dependencies, config, service');
   row('start',               'Start the server');
   row('stop',                'Stop the server');
   row('restart',             'Stop, then start');
@@ -1745,7 +1946,7 @@ function printHelp() {
   row('uninstall',           'Remove the system service');
   console.log('');
 
-  console.log(`${c.bold}Configuration${c.reset}`);
+  cliSection('Configuration');
   row('setup',               'Interactive configuration wizard');
   row('env list',            'List all variables (secrets masked)');
   row('env get KEY',         'Print a single variable');
@@ -1755,7 +1956,7 @@ function printHelp() {
   row('channel stable|beta', 'Switch release channel');
   console.log('');
 
-  console.log(`${c.bold}Updates & Auth${c.reset}`);
+  cliSection('Updates & Auth');
   row('update',              'Update to latest on current channel');
   row('update stable|beta',  'Update and switch channel');
   row('login github-copilot','Authenticate GitHub Copilot');
@@ -1764,7 +1965,7 @@ function printHelp() {
   row('login grok-oauth',    'Authenticate Grok (xAI OAuth)');
   console.log('');
 
-  console.log(`${c.bold}Maintenance${c.reset}`);
+  cliSection('Maintenance');
   row('migrate',             'Migrate from another agent installation');
   row('migrate dry-run',     'Preview what would be migrated');
   row('rebuild-web',         'Rebuild the bundled Flutter web client');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "neoagent",
-  "version": "2.4.1-beta.19",
+  "version": "2.4.1-beta.21",
   "description": "Proactive personal AI agent with no limits",
   "license": "AGPL-3.0-only",
   "main": "server/index.js",
@@ -38,7 +38,18 @@
     "flutter:run:web": "cd flutter_app && flutter run -d chrome --dart-define=NEOAGENT_WEB_BUILD_ID=$(node ../scripts/web_build_id.js)",
     "flutter:build:web": "cd flutter_app && flutter build web --output ../server/public --dart-define=NEOAGENT_BACKEND_URL=${NEOAGENT_BACKEND_URL:-} --dart-define=NEOAGENT_WEB_BUILD_ID=$(node ../scripts/web_build_id.js)",
     "manage": "node bin/neoagent.js",
-    "test": "node --test",
+    "test": "npm run test:backend",
+    "test:unit": "node --test --test-reporter=spec test/backend/unit/*.test.js",
+    "test:integration": "node --test --test-reporter=spec test/integration/*.test.js",
+    "test:security": "node --test --test-reporter=spec test/security/*.test.js",
+    "test:contract": "node --test --test-reporter=spec test/contract/*.test.js",
+    "test:e2e": "node --test --test-reporter=spec test/e2e/*.test.js",
+    "test:ws": "node --test --test-reporter=spec test/websocket/*.test.js",
+    "test:backend": "npm run test:unit && npm run test:integration && npm run test:security && npm run test:contract && npm run test:e2e && npm run test:ws",
+    "test:load": "node test/load/auth_load.js",
+    "flutter:test": "cd flutter_app && flutter test ../test/flutter/unit ../test/flutter/widget",
+    "flutter:test:unit": "cd flutter_app && flutter test ../test/flutter/unit",
+    "flutter:test:widget": "cd flutter_app && flutter test ../test/flutter/widget",
     "benchmark:tokens": "node scripts/benchmark-token-cost.js",
     "release": "npx semantic-release"
   },
@@ -104,7 +115,10 @@
   "devDependencies": {
     "@docusaurus/core": "3.10.0",
     "@docusaurus/preset-classic": "3.10.0",
+    "autocannon": "^7.15.0",
     "react": "18.3.1",
-    "react-dom": "18.3.1"
+    "react-dom": "18.3.1",
+    "socket.io-client": "^4.8.3",
+    "supertest": "^7.2.2"
   }
 }

package/server/config/origins.js

@@ -35,7 +35,9 @@ function isAllowedOrigin(origin, options = {}) {
 
 function validateOrigin(origin, callback, options = {}) {
   if (isAllowedOrigin(origin, options)) return callback(null, true);
-  return callback(new Error(`Origin not allowed: ${origin || 'unknown'}`));
+  const error = new Error(`Origin not allowed: ${origin || 'unknown'}`);
+  error.statusCode = 403;
+  return callback(error);
 }
 
 module.exports = {