nothumanallowed 4.1.0 → 6.0.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "nothumanallowed",
-  "version": "4.1.0",
-  "description": "NotHumanAllowed — 38 AI agents for security, code, DevOps, data & daily ops. Ask agents directly, plan your day with 5 specialist agents, manage tasks, connect Gmail + Calendar.",
+  "version": "6.0.0",
+  "description": "NotHumanAllowed — 38 AI agents for security, code, DevOps, data & daily ops. Per-agent memory, Telegram + Discord auto-responder, proactive intelligence daemon, voice chat, plugin system.",
   "type": "module",
   "bin": {
     "nha": "./bin/nha.mjs",
@@ -31,7 +31,14 @@
     "anthropic",
     "openai",
     "gemini",
-    "deepseek"
+    "deepseek",
+    "telegram-bot",
+    "discord-bot",
+    "voice-assistant",
+    "daily-ops",
+    "gmail",
+    "calendar",
+    "proactive"
   ],
   "author": "Nicola Cucurachi <ados.labsproject@gmail.com>",
   "license": "MIT",

package/src/cli.mjs

@@ -12,10 +12,14 @@ import { cmdAsk } from './commands/ask.mjs';
 import { cmdPlan } from './commands/plan.mjs';
 import { cmdTasks } from './commands/tasks.mjs';
 import { cmdOps } from './commands/ops.mjs';
+import { cmdAutostart } from './commands/autostart.mjs';
 import { cmdChat } from './commands/chat.mjs';
 import { cmdUI } from './commands/ui.mjs';
 import { cmdGoogle } from './commands/google-auth.mjs';
+import { cmdMicrosoft } from './commands/microsoft-auth.mjs';
 import { cmdScan } from './commands/scan.mjs';
+import { cmdVoice } from './commands/voice.mjs';
+import { cmdPlugin, findPluginForCommand } from './commands/plugin.mjs';
 import { banner, info, ok, warn, fail, C, G, Y, D, W, BOLD, NC, M, B, R } from './ui.mjs';
 
 export async function main(argv) {
@@ -57,6 +61,12 @@ export async function main(argv) {
     case 'ops':
       return cmdOps(args);
 
+    case 'autostart':
+      return cmdAutostart(args);
+
+    case 'responder':
+      return cmdResponder(args);
+
     case 'chat':
       return cmdChat(args);
 
@@ -66,9 +76,21 @@ export async function main(argv) {
     case 'google':
       return cmdGoogle(args);
 
+    case 'microsoft':
+    case 'ms':
+    case 'outlook':
+      return cmdMicrosoft(args);
+
     case 'scan':
       return cmdScan(args);
 
+    case 'voice':
+      return cmdVoice(args);
+
+    case 'plugin':
+    case 'plugins':
+      return cmdPlugin(args);
+
     case 'pif':
       return cmdPif(args);
 
@@ -103,9 +125,83 @@ export async function main(argv) {
     case '-h':
       return cmdHelp();
 
-    default:
+    default: {
+      // Check if a plugin handles this command before falling through to Legion
+      const pluginMatch = await findPluginForCommand(cmd);
+      if (pluginMatch && pluginMatch.plugin.run) {
+        const { cmdPlugin: runPlugin } = await import('./commands/plugin.mjs');
+        return runPlugin(['run', cmd, ...args]);
+      }
       // Try as Legion command passthrough
       return spawnCore('legion', [cmd, ...args]);
+    }
+  }
+}
+
+// ── nha responder ─────────────────────────────────────────────────────────
+async function cmdResponder(args) {
+  const sub = args[0] || 'status';
+  const config = loadConfig();
+
+  switch (sub) {
+    case 'start': {
+      const { isRunning } = await import('./services/ops-daemon.mjs');
+      if (!isRunning()) {
+        warn('Daemon is not running. The responder runs inside the daemon.');
+        info('Start it with: nha ops start');
+        info('Or enable autostart: nha autostart enable');
+        return;
+      }
+      info('The responder starts automatically with the daemon when tokens are configured.');
+      info('Configure tokens:');
+      console.log('  nha config set telegram-bot-token YOUR_BOT_TOKEN');
+      console.log('  nha config set discord-bot-token YOUR_BOT_TOKEN');
+      info('Then restart the daemon: nha ops stop && nha ops start');
+      return;
+    }
+
+    case 'stop': {
+      info('The responder stops when the daemon stops.');
+      info('Run: nha ops stop');
+      return;
+    }
+
+    case 'status': {
+      console.log(`\n  ${BOLD}Message Responder Status${NC}\n`);
+
+      const telegramToken = config.responder?.telegram?.token;
+      const discordToken = config.responder?.discord?.token;
+      const autoRoute = config.responder?.autoRoute !== false;
+
+      console.log(`  Telegram:     ${telegramToken ? G + 'configured' + NC : D + '(not set)' + NC}`);
+      if (telegramToken) {
+        const chatIds = config.responder?.telegram?.allowedChatIds || [];
+        console.log(`    Chat filter: ${chatIds.length > 0 ? Y + chatIds.join(', ') + NC : D + 'all chats' + NC}`);
+      }
+
+      console.log(`  Discord:      ${discordToken ? G + 'configured' + NC : D + '(not set)' + NC}`);
+      if (discordToken) {
+        const channelIds = config.responder?.discord?.allowedChannelIds || [];
+        console.log(`    Channel filter: ${channelIds.length > 0 ? Y + channelIds.join(', ') + NC : D + 'all channels (mention/command only)' + NC}`);
+      }
+
+      console.log(`  Auto-route:   ${autoRoute ? G + 'keyword routing' + NC : D + 'CONDUCTOR only' + NC}`);
+
+      const { isRunning: isDaemonRunning } = await import('./services/ops-daemon.mjs');
+      console.log(`  Daemon:       ${isDaemonRunning() ? G + 'running' + NC : R + 'stopped' + NC}`);
+      console.log('');
+
+      if (!telegramToken && !discordToken) {
+        info('Configure a bot token to enable:');
+        console.log('  nha config set telegram-bot-token YOUR_TOKEN');
+        console.log('  nha config set discord-bot-token YOUR_TOKEN');
+      }
+      return;
+    }
+
+    default:
+      fail(`Unknown: nha responder ${sub}`);
+      info('Commands: start, stop, status');
   }
 }
 
@@ -228,6 +324,10 @@ function cmdConfig(args) {
       console.log('');
       info('Keys: provider, key, openai-key, gemini-key, deepseek-key, grok-key, model, timeout');
       info('      verbose, immersive, deliberation, rounds, convergence, tribunal, knowledge');
+      info('      google-client-id, google-client-secret');
+      info('      microsoft-client-id, microsoft-client-secret, microsoft-tenant');
+      info('      telegram-bot-token, discord-bot-token, responder-auto-route');
+      info('      proactive, proactive-email, proactive-meeting, proactive-patterns, proactive-deadlines');
       return;
     }
     const success = setConfigValue(key, value);
@@ -240,9 +340,8 @@ function cmdConfig(args) {
   }
 
   if (sub === 'reset') {
-    const { saveConfig } = loadConfig; // re-import
     fs.rmSync(path.join(NHA_DIR, 'config.json'), { force: true });
-    ok('Config reset to defaults');
+    ok('Config reset to defaults. Run any command to regenerate.');
     return;
   }
 
@@ -273,10 +372,48 @@ function cmdConfig(args) {
     console.log(`    ${D}(not registered — run "nha pif register")${NC}`);
   }
 
+  console.log(`\n  ${C}Integrations${NC}`);
+  console.log(`    Google:       ${config.google?.clientId ? G + 'configured' : D + '(not set)'}${NC}`);
+  console.log(`    Microsoft:    ${config.microsoft?.clientId ? G + 'configured' : D + '(not set)'}${NC}`);
+  if (config.microsoft?.tenantId && config.microsoft.tenantId !== 'common') {
+    console.log(`    MS Tenant:    ${D}${config.microsoft.tenantId}${NC}`);
+  }
+
   console.log(`\n  ${C}Features${NC}`);
   for (const [k, v] of Object.entries(config.features)) {
     console.log(`    ${k.padEnd(28)} ${v ? G + '✓' : D + '○'}${NC}`);
   }
+
+  if (config.plugins) {
+    console.log(`\n  ${C}Plugins${NC}`);
+    console.log(`    Auto-run:     ${config.plugins.autoRun ? G + 'yes' : D + 'no'}${NC}`);
+    if (config.plugins.directory) console.log(`    Directory:    ${D}${config.plugins.directory}${NC}`);
+  }
+
+  if (config.voice) {
+    console.log(`\n  ${C}Voice${NC}`);
+    console.log(`    Prefer Whisper: ${config.voice.preferWhisper ? G + 'yes' : D + 'no'}${NC}`);
+    console.log(`    Speech Synth:   ${config.voice.speechSynthesis ? G + 'yes' : D + 'no'}${NC}`);
+    if (config.voice.language) console.log(`    Language:       ${D}${config.voice.language}${NC}`);
+  }
+
+  if (config.responder) {
+    console.log(`\n  ${C}Message Responder${NC}`);
+    console.log(`    Telegram:       ${config.responder.telegram?.token ? G + 'configured' : D + '(not set)'}${NC}`);
+    console.log(`    Discord:        ${config.responder.discord?.token ? G + 'configured' : D + '(not set)'}${NC}`);
+    console.log(`    Auto-route:     ${config.responder.autoRoute !== false ? G + 'yes' : D + 'no'}${NC}`);
+  }
+
+  const proactive = config.ops?.proactive;
+  if (proactive) {
+    console.log(`\n  ${C}Proactive Intelligence${NC}`);
+    console.log(`    Enabled:        ${proactive.enabled !== false ? G + 'yes' : D + 'no'}${NC}`);
+    console.log(`    Email follow-up:${proactive.emailFollowUp !== false ? G + ' on' : D + ' off'}${NC}`);
+    console.log(`    Meeting prep:   ${proactive.meetingPrep !== false ? G + 'on' : D + 'off'}${NC}`);
+    console.log(`    Patterns:       ${proactive.patterns !== false ? G + 'on' : D + 'off'}${NC}`);
+    console.log(`    Deadlines:      ${proactive.deadlines !== false ? G + 'on' : D + 'off'}${NC}`);
+  }
+
   console.log('');
 }
 
@@ -304,6 +441,14 @@ async function cmdDoctor() {
   const extCount = EXTENSIONS.filter(e => fs.existsSync(path.join(EXTENSIONS_DIR, `${e}.mjs`))).length;
   console.log(`  Extensions:       ${D}${extCount}/${EXTENSIONS.length} installed${NC}`);
 
+  // Check plugins
+  const pluginsDir = path.join(NHA_DIR, 'plugins');
+  let pluginCount = 0;
+  if (fs.existsSync(pluginsDir)) {
+    pluginCount = fs.readdirSync(pluginsDir).filter(f => f.endsWith('.mjs')).length;
+  }
+  console.log(`  Plugins:          ${D}${pluginCount} installed${NC}`);
+
   // Check API key
   console.log(`  API Key:          ${config.llm.apiKey ? G + 'configured (' + config.llm.provider + ')' : R + 'NOT SET'}${NC}`);
 
@@ -368,26 +513,57 @@ function cmdHelp() {
   console.log(`    ui                    Open local web dashboard (http://127.0.0.1:3847)`);
   console.log(`    ui --port=4000        Custom port    ui --no-browser  Don't auto-open`);
   console.log(`    chat                  Interactive chat — manage email/calendar/tasks naturally`);
+  console.log(`    voice                 Voice-powered chat (opens browser with mic interface)`);
+  console.log(`    voice ${D}--port=3849${NC}    Custom port    voice ${D}--no-browser${NC}`);
   console.log(`    plan                  Generate daily plan (5 agents analyze your day)`);
   console.log(`    plan --refresh        Regenerate today's plan`);
   console.log(`    tasks                 List today's tasks`);
   console.log(`    tasks add "desc"      Add a task`);
   console.log(`    tasks done 3          Complete task #3`);
   console.log(`    tasks week            Week overview`);
-  console.log(`    ops start             Start background daemon (auto-alerts)`);
+  console.log(`    ops start             Start background daemon (auto-alerts + WebSocket)`);
   console.log(`    ops stop              Stop daemon`);
-  console.log(`    ops status            Daemon status\n`);
+  console.log(`    ops status            Daemon status`);
+  console.log(`    autostart enable      Auto-start daemon on login (launchd/systemd)`);
+  console.log(`    autostart disable     Remove OS autostart`);
+  console.log(`    autostart status      Check autostart configuration\n`);
+
+  console.log(`  ${C}Message Responder${NC}  ${D}(Telegram + Discord auto-reply)${NC}`);
+  console.log(`    responder status      Show responder configuration`);
+  console.log(`    config set telegram-bot-token TOKEN`);
+  console.log(`    config set discord-bot-token TOKEN`);
+  console.log(`    ${D}Routes messages to agents via keyword matching (zero LLM overhead)${NC}\n`);
+
+  console.log(`  ${C}Proactive Intelligence${NC}  ${D}(runs inside daemon)${NC}`);
+  console.log(`    ${D}Email follow-ups, meeting prep, pattern detection, deadline tracking${NC}`);
+  console.log(`    config set proactive true/false       Toggle all proactive features`);
+  console.log(`    config set proactive-email true/false  Email follow-up reminders`);
+  console.log(`    config set proactive-meeting true/false  Auto meeting briefs`);
+  console.log(`    config set proactive-deadlines true/false  Deadline alerts\n`);
 
   console.log(`  ${C}Google Integration${NC}`);
   console.log(`    google auth           Connect Gmail + Calendar`);
   console.log(`    google status         Connection status`);
   console.log(`    google revoke         Disconnect\n`);
 
+  console.log(`  ${C}Microsoft Integration${NC}  ${D}(Outlook Mail + Calendar)${NC}`);
+  console.log(`    microsoft auth        Connect Outlook + Calendar`);
+  console.log(`    microsoft status      Connection status`);
+  console.log(`    microsoft revoke      Disconnect`);
+  console.log(`    ${D}Aliases: ms, outlook${NC}\n`);
+
   console.log(`  ${C}Extensions${NC}  ${D}(downloadable agent modules)${NC}`);
   console.log(`    install <name>        Install an extension agent`);
   console.log(`    install --all         Install all ${EXTENSIONS.length} extensions`);
   console.log(`    extensions            List installed extensions\n`);
 
+  console.log(`  ${C}Plugins${NC}  ${D}(user-extensible commands)${NC}`);
+  console.log(`    plugin list           List installed & available plugins`);
+  console.log(`    plugin install <name> Download a plugin from NHA server`);
+  console.log(`    plugin run <name>     Execute a plugin`);
+  console.log(`    plugin create <name>  Scaffold a new plugin from template`);
+  console.log(`    plugin remove <name>  Remove an installed plugin\n`);
+
   console.log(`  ${C}Social Network${NC}  ${D}(NHA platform)${NC}`);
   console.log(`    pif register          Register your agent identity`);
   console.log(`    pif post              Post content`);

package/src/commands/autostart.mjs

@@ -0,0 +1,342 @@
+/**
+ * nha autostart — OS-level daemon autostart management.
+ *
+ * macOS:  launchd plist at ~/Library/LaunchAgents/com.nha.daemon.plist
+ * Linux:  systemd user service at ~/.config/systemd/user/nha-daemon.service
+ *
+ * Zero dependencies.
+ */
+
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { execSync, spawnSync } from 'child_process';
+import { NHA_DIR, DAEMON_SCRIPT } from '../constants.mjs';
+import { info, ok, fail, warn, C, G, Y, D, W, BOLD, NC, R } from '../ui.mjs';
+
+const PLATFORM = os.platform();
+const HOME = os.homedir();
+
+// ── Paths ────────────────────────────────────────────────────────────────────
+
+// DAEMON_SCRIPT is resolved relative to the installed package (via constants.mjs),
+// so it works correctly both in development and after npm install -g.
+const DAEMON_SCRIPT_ABS = DAEMON_SCRIPT;
+const NODE_BIN = process.execPath;
+
+const LAUNCHD_LABEL = 'com.nha.daemon';
+const LAUNCHD_PLIST = path.join(HOME, 'Library', 'LaunchAgents', `${LAUNCHD_LABEL}.plist`);
+const LAUNCHD_LOG_DIR = path.join(NHA_DIR, 'ops', 'daemon');
+
+const SYSTEMD_DIR = path.join(HOME, '.config', 'systemd', 'user');
+const SYSTEMD_UNIT = 'nha-daemon.service';
+const SYSTEMD_FILE = path.join(SYSTEMD_DIR, SYSTEMD_UNIT);
+
+// ── launchd (macOS) ──────────────────────────────────────────────────────────
+
+function generateLaunchdPlist() {
+  // launchd XML plist — KeepAlive restarts on crash, RunAtLoad starts on login
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${LAUNCHD_LABEL}</string>
+
+  <key>ProgramArguments</key>
+  <array>
+    <string>${NODE_BIN}</string>
+    <string>${DAEMON_SCRIPT_ABS}</string>
+    <string>--daemon-loop</string>
+  </array>
+
+  <key>RunAtLoad</key>
+  <true/>
+
+  <key>KeepAlive</key>
+  <dict>
+    <key>SuccessfulExit</key>
+    <false/>
+  </dict>
+
+  <key>ThrottleInterval</key>
+  <integer>10</integer>
+
+  <key>StandardOutPath</key>
+  <string>${path.join(LAUNCHD_LOG_DIR, 'daemon.log')}</string>
+
+  <key>StandardErrorPath</key>
+  <string>${path.join(LAUNCHD_LOG_DIR, 'daemon.log')}</string>
+
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>NHA_DAEMON</key>
+    <string>1</string>
+    <key>HOME</key>
+    <string>${HOME}</string>
+    <key>PATH</key>
+    <string>/usr/local/bin:/usr/bin:/bin:/opt/homebrew/bin:${path.dirname(NODE_BIN)}</string>
+  </dict>
+
+  <key>ProcessType</key>
+  <string>Background</string>
+
+  <key>LowPriorityIO</key>
+  <true/>
+</dict>
+</plist>
+`;
+}
+
+function launchdInstall() {
+  const agentsDir = path.join(HOME, 'Library', 'LaunchAgents');
+  fs.mkdirSync(agentsDir, { recursive: true });
+  fs.mkdirSync(LAUNCHD_LOG_DIR, { recursive: true });
+
+  fs.writeFileSync(LAUNCHD_PLIST, generateLaunchdPlist(), { mode: 0o644 });
+
+  // Load the agent (starts it immediately)
+  const result = spawnSync('launchctl', ['load', '-w', LAUNCHD_PLIST], { encoding: 'utf-8' });
+  if (result.status !== 0) {
+    const stderr = (result.stderr || '').trim();
+    // Already loaded is not a real error
+    if (!stderr.includes('already loaded') && !stderr.includes('service already loaded')) {
+      throw new Error(`launchctl load failed: ${stderr}`);
+    }
+  }
+}
+
+function launchdUninstall() {
+  if (!fs.existsSync(LAUNCHD_PLIST)) {
+    return false;
+  }
+
+  // Unload (stops the daemon)
+  spawnSync('launchctl', ['unload', '-w', LAUNCHD_PLIST], { encoding: 'utf-8' });
+
+  fs.rmSync(LAUNCHD_PLIST, { force: true });
+  return true;
+}
+
+function launchdStatus() {
+  const installed = fs.existsSync(LAUNCHD_PLIST);
+  if (!installed) {
+    return { installed: false, running: false, pid: null };
+  }
+
+  // Check if service is loaded and running
+  const result = spawnSync('launchctl', ['list'], { encoding: 'utf-8' });
+  const lines = (result.stdout || '').split('\n');
+  const match = lines.find(l => l.includes(LAUNCHD_LABEL));
+
+  if (!match) {
+    return { installed: true, running: false, pid: null };
+  }
+
+  // Format: PID Status Label
+  const parts = match.trim().split(/\s+/);
+  const pid = parts[0] === '-' ? null : parseInt(parts[0], 10);
+  const running = pid !== null && !isNaN(pid);
+
+  return { installed: true, running, pid };
+}
+
+// ── systemd (Linux) ──────────────────────────────────────────────────────────
+
+function generateSystemdUnit() {
+  return `[Unit]
+Description=NHA PAO Background Daemon
+Documentation=https://nothumanallowed.com/docs/cli
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=simple
+ExecStart=${NODE_BIN} ${DAEMON_SCRIPT_ABS} --daemon-loop
+Environment=NHA_DAEMON=1
+Environment=HOME=${HOME}
+Environment=PATH=/usr/local/bin:/usr/bin:/bin:${path.dirname(NODE_BIN)}
+
+Restart=on-failure
+RestartSec=10
+StartLimitIntervalSec=300
+StartLimitBurst=5
+
+StandardOutput=append:${path.join(LAUNCHD_LOG_DIR, 'daemon.log')}
+StandardError=append:${path.join(LAUNCHD_LOG_DIR, 'daemon.log')}
+
+# Security hardening
+NoNewPrivileges=true
+ProtectSystem=strict
+ProtectHome=read-only
+ReadWritePaths=${NHA_DIR}
+
+[Install]
+WantedBy=default.target
+`;
+}
+
+function systemdInstall() {
+  fs.mkdirSync(SYSTEMD_DIR, { recursive: true });
+  fs.mkdirSync(LAUNCHD_LOG_DIR, { recursive: true });
+
+  fs.writeFileSync(SYSTEMD_FILE, generateSystemdUnit(), { mode: 0o644 });
+
+  // Reload systemd user daemon to pick up new unit
+  spawnSync('systemctl', ['--user', 'daemon-reload'], { encoding: 'utf-8' });
+
+  // Enable (auto-start on login) and start immediately
+  const enableResult = spawnSync('systemctl', ['--user', 'enable', '--now', SYSTEMD_UNIT], {
+    encoding: 'utf-8',
+  });
+
+  if (enableResult.status !== 0) {
+    const stderr = (enableResult.stderr || '').trim();
+    throw new Error(`systemctl enable failed: ${stderr}`);
+  }
+
+  // Enable lingering so the user service runs even when not logged in (optional, best-effort)
+  spawnSync('loginctl', ['enable-linger', os.userInfo().username], { encoding: 'utf-8' });
+}
+
+function systemdUninstall() {
+  if (!fs.existsSync(SYSTEMD_FILE)) {
+    return false;
+  }
+
+  // Stop and disable
+  spawnSync('systemctl', ['--user', 'disable', '--now', SYSTEMD_UNIT], { encoding: 'utf-8' });
+
+  fs.rmSync(SYSTEMD_FILE, { force: true });
+
+  // Reload to clean up
+  spawnSync('systemctl', ['--user', 'daemon-reload'], { encoding: 'utf-8' });
+
+  return true;
+}
+
+function systemdStatus() {
+  const installed = fs.existsSync(SYSTEMD_FILE);
+  if (!installed) {
+    return { installed: false, running: false, pid: null };
+  }
+
+  const result = spawnSync('systemctl', ['--user', 'is-active', SYSTEMD_UNIT], {
+    encoding: 'utf-8',
+  });
+  const active = (result.stdout || '').trim() === 'active';
+
+  let pid = null;
+  if (active) {
+    const showResult = spawnSync('systemctl', ['--user', 'show', SYSTEMD_UNIT, '--property=MainPID'], {
+      encoding: 'utf-8',
+    });
+    const pidMatch = (showResult.stdout || '').match(/MainPID=(\d+)/);
+    if (pidMatch) pid = parseInt(pidMatch[1], 10);
+  }
+
+  return { installed: true, running: active, pid };
+}
+
+// ── Platform Dispatcher ──────────────────────────────────────────────────────
+
+function getPlatformAdapter() {
+  if (PLATFORM === 'darwin') {
+    return { install: launchdInstall, uninstall: launchdUninstall, status: launchdStatus, name: 'launchd' };
+  }
+  if (PLATFORM === 'linux') {
+    return { install: systemdInstall, uninstall: systemdUninstall, status: systemdStatus, name: 'systemd' };
+  }
+  return null;
+}
+
+// ── Command Handler ──────────────────────────────────────────────────────────
+
+export async function cmdAutostart(args) {
+  const sub = args[0] || 'status';
+  const adapter = getPlatformAdapter();
+
+  if (!adapter) {
+    fail(`Autostart is not supported on ${PLATFORM}`);
+    info('Supported platforms: macOS (launchd), Linux (systemd)');
+    return;
+  }
+
+  switch (sub) {
+    case 'enable': {
+      // Verify the daemon script exists
+      if (!fs.existsSync(DAEMON_SCRIPT_ABS)) {
+        fail(`Daemon script not found at: ${DAEMON_SCRIPT_ABS}`);
+        info('Run "nha update" to re-download core files.');
+        return;
+      }
+
+      const currentStatus = adapter.status();
+      if (currentStatus.installed && currentStatus.running) {
+        warn('Autostart is already enabled and running.');
+        return;
+      }
+
+      try {
+        adapter.install();
+        const newStatus = adapter.status();
+        ok(`Autostart enabled via ${adapter.name}`);
+        if (newStatus.running) {
+          ok(`Daemon started (PID ${newStatus.pid})`);
+        } else {
+          info('Daemon will start on next login.');
+        }
+
+        if (adapter.name === 'launchd') {
+          info(`Plist: ${LAUNCHD_PLIST}`);
+        } else {
+          info(`Unit: ${SYSTEMD_FILE}`);
+        }
+        info('The daemon auto-restarts on crash (10s cooldown).');
+      } catch (err) {
+        fail(`Failed to enable autostart: ${err.message}`);
+      }
+      return;
+    }
+
+    case 'disable': {
+      try {
+        const removed = adapter.uninstall();
+        if (removed) {
+          ok('Autostart disabled. Daemon stopped and service removed.');
+        } else {
+          warn('Autostart was not enabled.');
+        }
+      } catch (err) {
+        fail(`Failed to disable autostart: ${err.message}`);
+      }
+      return;
+    }
+
+    case 'status': {
+      const status = adapter.status();
+      console.log(`\n  ${BOLD}Autostart Status${NC}  ${D}(${adapter.name})${NC}\n`);
+      console.log(`  Installed:   ${status.installed ? G + 'yes' + NC : D + 'no' + NC}`);
+      console.log(`  Running:     ${status.running ? G + 'yes' + NC + (status.pid ? ` (PID ${status.pid})` : '') : R + 'no' + NC}`);
+
+      if (adapter.name === 'launchd') {
+        console.log(`  Plist:       ${D}${LAUNCHD_PLIST}${NC}`);
+      } else {
+        console.log(`  Unit:        ${D}${SYSTEMD_FILE}${NC}`);
+      }
+
+      console.log(`  Daemon:      ${D}${DAEMON_SCRIPT_ABS}${NC}`);
+      console.log(`  Node:        ${D}${NODE_BIN}${NC}`);
+      console.log('');
+
+      if (!status.installed) {
+        info('Enable with: nha autostart enable');
+      }
+      return;
+    }
+
+    default:
+      fail(`Unknown: nha autostart ${sub}`);
+      info('Commands: enable, disable, status');
+  }
+}