@agentlang/agentmanager 0.0.3

package/scripts/agentmanager.mjs

@@ -0,0 +1,1126 @@
+#!/usr/bin/env node
+/**
+ * CLI: configure daemon env, install launchd (macOS), systemd (Linux), or Task Scheduler
+ * (Windows) entry, start monolith.
+ * Usage: agentmanager --start-daemon  (alias: --start-demon)
+ */
+import { spawn, spawnSync, execSync } from 'node:child_process';
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  writeFileSync,
+  chmodSync,
+} from 'node:fs';
+import { createInterface } from 'node:readline/promises';
+import { stdin as input, stdout as output } from 'node:process';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import os from 'node:os';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+function readPackageVersion() {
+  try {
+    const pkgPath = join(__dirname, '..', 'package.json');
+    const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));
+    return typeof pkg.version === 'string' ? pkg.version : '0.0.0';
+  } catch {
+    return '0.0.0';
+  }
+}
+
+const PKG_VERSION = readPackageVersion();
+
+/** @returns {boolean} */
+function colorEnabled() {
+  if (process.env.NO_COLOR != null && process.env.NO_COLOR !== '') return false;
+  if (process.env.FORCE_COLOR === '0') return false;
+  if (process.env.FORCE_COLOR === '1' || process.env.FORCE_COLOR === '2')
+    return true;
+  return output.isTTY === true;
+}
+
+const ansi = colorEnabled()
+  ? {
+      reset: '\u001b[0m',
+      bold: '\u001b[1m',
+      dim: '\u001b[2m',
+      italic: '\u001b[3m',
+      red: '\u001b[31m',
+      green: '\u001b[32m',
+      yellow: '\u001b[33m',
+      blue: '\u001b[34m',
+      magenta: '\u001b[35m',
+      cyan: '\u001b[36m',
+      white: '\u001b[37m',
+      gray: '\u001b[90m',
+      bgBlue: '\u001b[44m',
+      bgMagenta: '\u001b[45m',
+    }
+  : {
+      reset: '',
+      bold: '',
+      dim: '',
+      italic: '',
+      red: '',
+      green: '',
+      yellow: '',
+      blue: '',
+      magenta: '',
+      cyan: '',
+      white: '',
+      gray: '',
+      bgBlue: '',
+      bgMagenta: '',
+    };
+
+/**
+ * @param {string} s
+ * @param {...string} codes
+ */
+function paint(s, ...codes) {
+  return `${codes.join('')}${s}${ansi.reset}`;
+}
+
+function printCliVersionLine() {
+  output.write(
+    paint('agentmanager', ansi.bold, ansi.magenta) +
+      paint(' v', ansi.dim) +
+      paint(PKG_VERSION, ansi.cyan, ansi.bold) +
+      '\n',
+  );
+}
+
+/** @param {string} key */
+function isSensitiveEnvKey(key) {
+  const u = key.toUpperCase();
+  return (
+    u.includes('SECRET') ||
+    u.includes('PASSWORD') ||
+    u.includes('API_KEY') ||
+    /(^|_)KEY($|_)/.test(u) ||
+    u.includes('TOKEN')
+  );
+}
+
+/**
+ * @param {string} key
+ * @param {string} value
+ */
+function formatHintForDisplay(key, value) {
+  if (value === '') return '';
+  if (!isSensitiveEnvKey(key)) return value;
+  if (value.length <= 6) return '••••';
+  return `${value.slice(0, 3)}…${value.slice(-2)}`;
+}
+
+const SERVICE_LABEL = 'io.agentlang.agentmanager.monolith';
+const SYSTEMD_UNIT = 'agentmanager-monolith.service';
+const WINDOWS_TASK_NAME = 'AgentManagerMonolith';
+
+/** Interactive wizard only covers these; `daemon.env` is rewritten to this set only. */
+const DAEMON_WIZARD_VARS = [
+  {
+    key: 'PORT',
+    description:
+      'HTTP port the monolith listens on (overrides default when set).',
+  },
+  {
+    key: 'OPENAI_API_KEY',
+    description: 'OpenAI API key for models used by Fabric / craft flows.',
+  },
+  {
+    key: 'ANTHROPIC_API_KEY',
+    description: 'Anthropic API key for Claude when that provider is used.',
+  },
+  {
+    key: 'AWS_REGION',
+    description: 'Default AWS region for the SDK (S3, Cognito, SES, etc.).',
+  },
+  {
+    key: 'AWS_ACCESS_KEY',
+    description: 'AWS access key ID (programmatic IAM access).',
+  },
+  {
+    key: 'AWS_SECRET_KEY',
+    description: 'AWS secret access key (paired with AWS_ACCESS_KEY).',
+  },
+  {
+    key: 'AWS_COGNITO_CLIENT_ID',
+    description: 'Amazon Cognito app client ID used for auth integration.',
+  },
+  {
+    key: 'AWS_COGNITO_USER_POOL_ID',
+    description: 'Amazon Cognito user pool ID for your user directory.',
+  },
+  {
+    key: 'SES_FROM_EMAIL',
+    description:
+      "Verified 'From' address in SES for escalation / notification mail.",
+  },
+  {
+    key: 'SES_TO_EMAIL',
+    description: 'Recipient address for escalation or notification emails.',
+  },
+  {
+    key: 'FABRIC_ESCALATION_TO_EMAIL',
+    description:
+      'Set true or false: whether Fabric sends escalation emails via SES.',
+  },
+];
+
+function configDir() {
+  return process.env.XDG_CONFIG_HOME || join(os.homedir(), '.config');
+}
+
+function appStateDir() {
+  const d = join(configDir(), 'agentmanager');
+  mkdirSync(d, { recursive: true });
+  return d;
+}
+
+function daemonEnvPath() {
+  return join(appStateDir(), 'daemon.env');
+}
+
+function repoRootPathFile() {
+  return join(appStateDir(), 'repo-root.txt');
+}
+
+function logDir() {
+  const d = join(appStateDir(), 'logs');
+  mkdirSync(d, { recursive: true });
+  return d;
+}
+
+function monolithStdoutLogPath() {
+  return join(logDir(), 'monolith.stdout.log');
+}
+
+function monolithStderrLogPath() {
+  return join(logDir(), 'monolith.stderr.log');
+}
+
+/** @param {'stdout' | 'stderr'} which */
+function cmdTailMonolithLog(which) {
+  const logPath =
+    which === 'stderr' ? monolithStderrLogPath() : monolithStdoutLogPath();
+  if (!existsSync(logPath)) {
+    writeFileSync(logPath, '', 'utf8');
+  }
+  const label = which === 'stderr' ? 'stderr' : 'stdout';
+  output.write(
+    paint('↳ ', ansi.cyan, ansi.bold) +
+      paint(`Following monolith.${label}.log`, ansi.bold) +
+      paint('  ', ansi.dim) +
+      paint('tail -f', ansi.gray) +
+      '\n' +
+      paint('  ', ansi.dim) +
+      paint(logPath, ansi.yellow) +
+      '\n' +
+      paint('  Ctrl+C to stop\n\n', ansi.dim),
+  );
+  const child = spawn('tail', ['-f', logPath], { stdio: 'inherit' });
+  const onSigint = () => {
+    child.kill('SIGTERM');
+    process.exit(0);
+  };
+  process.once('SIGINT', onSigint);
+  child.on('error', (err) => {
+    const e = /** @type {NodeJS.ErrnoException} */ (err);
+    if (e.code === 'ENOENT') {
+      output.write(
+        paint('✗ ', ansi.red, ansi.bold) +
+          paint(
+            '`tail` not found. Install coreutils or run from a shell that provides tail.\n',
+            ansi.red,
+          ),
+      );
+      process.exit(1);
+    }
+    throw err;
+  });
+  child.on('close', (code, signal) => {
+    process.removeListener('SIGINT', onSigint);
+    if (signal) process.exit(0);
+    process.exit(code === null ? 1 : code);
+  });
+}
+
+function runnerScriptPath() {
+  return join(__dirname, 'monolith-daemon-run.sh');
+}
+
+function runnerNodeScriptPath() {
+  return join(__dirname, 'monolith-daemon-run.mjs');
+}
+
+/** @param {string} s */
+function xmlEscape(s) {
+  return s.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+}
+
+/**
+ * PATH recorded when running `agentmanager --start-daemon` so launchd/systemd/Task Scheduler
+ * can find `pm2`, `npx`, etc. (GUI daemons use a minimal PATH by default).
+ */
+function daemonServicePathEnv() {
+  const isWin = os.platform() === 'win32';
+  const sep = isWin ? ';' : ':';
+  const fallback = isWin
+    ? 'C:\\Program Files\\nodejs;C:\\Program Files (x86)\\nodejs'
+    : '/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin';
+  const raw = process.env.PATH;
+  let base =
+    typeof raw === 'string' && raw.trim() !== '' ? raw.trim() : fallback;
+  const nodeDir = dirname(process.execPath);
+  if (nodeDir && !base.split(sep).includes(nodeDir)) {
+    base = `${nodeDir}${sep}${base}`;
+  }
+  return base;
+}
+
+/** @param {string} s */
+function systemdEnvValueEscape(s) {
+  return s.replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/\$/g, '$$');
+}
+
+/** Path token for unit file (quote when needed). */
+function systemdPathToken(p) {
+  if (/[\s"'\\]/.test(p))
+    return `"${p.replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`;
+  return p;
+}
+
+/** Directory layout for this monorepo (clone or npm pack contents). */
+function isValidMonorepoRoot(dir) {
+  const pkgPath = join(dir, 'package.json');
+  const nestPath = join(dir, 'nest-cli.json');
+  if (!existsSync(pkgPath) || !existsSync(nestPath)) return false;
+  try {
+    const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));
+    return !!(pkg.scripts && pkg.scripts['start:monolith']);
+  } catch {
+    return false;
+  }
+}
+
+function findRepoRoot(startDir = process.cwd()) {
+  let dir = resolve(startDir);
+  for (;;) {
+    if (isValidMonorepoRoot(dir)) return dir;
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+
+/** When installed with `npm i -g`, the package root is next to `scripts/`. */
+function resolveGlobalInstallMonorepoRoot() {
+  const candidate = resolve(join(__dirname, '..'));
+  return isValidMonorepoRoot(candidate) ? candidate : null;
+}
+
+function resolveRepoRoot(argv) {
+  const i = argv.indexOf('--repo-root');
+  if (i !== -1 && argv[i + 1]) return resolve(argv[i + 1]);
+  const env = process.env.AGENTMANAGER_MONO_ROOT;
+  if (env) return resolve(env);
+  const fromFile = existsSync(repoRootPathFile())
+    ? readFileSync(repoRootPathFile(), 'utf8').trim()
+    : '';
+  if (fromFile && isValidMonorepoRoot(fromFile)) return resolve(fromFile);
+  const fromCwd = findRepoRoot();
+  if (fromCwd) return fromCwd;
+  return resolveGlobalInstallMonorepoRoot();
+}
+
+/** @param {string} content */
+function parseDotenvValues(content) {
+  const out = {};
+  for (const line of content.split('\n')) {
+    const m = line.match(
+      /^\s*(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.*)$/,
+    );
+    if (!m) continue;
+    let v = m[2].trim();
+    if (
+      (v.startsWith('"') && v.endsWith('"')) ||
+      (v.startsWith("'") && v.endsWith("'"))
+    ) {
+      v = v.slice(1, -1);
+    }
+    out[m[1]] = v;
+  }
+  return out;
+}
+
+/** @param {Record<string, string>} obj */
+function serializeDotenv(obj) {
+  const keys = Object.keys(obj).sort();
+  const lines = [];
+  for (const k of keys) {
+    const v = obj[k];
+    if (v === undefined || v === '') continue;
+    const needsQuote = /[\s#"']|=/.test(v) || v !== String(v);
+    if (needsQuote)
+      lines.push(
+        `${k}="${String(v).replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`,
+      );
+    else lines.push(`${k}=${v}`);
+  }
+  return lines.join('\n') + (lines.length ? '\n' : '');
+}
+
+/**
+ * @param {typeof DAEMON_WIZARD_VARS} entries
+ * @param {Record<string, string>} existingDaemon
+ * @param {Record<string, string>} dotenvFromRepo
+ * @returns {Promise<Record<string, string>>}
+ */
+async function promptWizardVars(entries, existingDaemon, dotenvFromRepo) {
+  const rl = createInterface({ input, output });
+  /** @type {Record<string, string>} */
+  const result = {};
+  const total = entries.length;
+
+  try {
+    output.write('\n');
+    output.write(
+      paint('── Environment ──', ansi.bold, ansi.cyan) +
+        paint(`  ${total} variables`, ansi.dim) +
+        '\n',
+    );
+    output.write(
+      paint(
+        'Enter keeps saved value; leave empty to skip when nothing saved yet.',
+        ansi.dim,
+      ) + '\n\n',
+    );
+
+    let i = 0;
+    for (const { key, description } of entries) {
+      i += 1;
+      const fromExisting = existingDaemon[key];
+      const fromRepo = dotenvFromRepo[key];
+      const rawHint = fromExisting ?? fromRepo ?? '';
+      const shownHint =
+        rawHint !== '' ? formatHintForDisplay(key, rawHint) : '';
+      const display =
+        shownHint !== ''
+          ? ` ${paint(`[${shownHint}]`, ansi.yellow, ansi.dim)}`
+          : '';
+
+      output.write(
+        paint(`[${i}/${total}]`, ansi.gray, ansi.dim) +
+          ' ' +
+          paint(key, ansi.bold, ansi.magenta) +
+          ' ' +
+          paint('(optional)', ansi.cyan, ansi.dim) +
+          '\n',
+      );
+      output.write(paint(`    ${description}`, ansi.dim, ansi.white) + '\n');
+      const promptLine =
+        paint('    › ', ansi.green, ansi.bold) +
+        paint(key, ansi.bold, ansi.cyan) +
+        paint(' =', ansi.dim) +
+        display +
+        paint(' ', ansi.reset);
+      const ans = await rl.question(promptLine);
+      const t = ans.trim();
+      if (t === '') {
+        if (fromExisting !== undefined) result[key] = fromExisting;
+        continue;
+      }
+      result[key] = t;
+    }
+    output.write('\n');
+  } finally {
+    rl.close();
+  }
+  return result;
+}
+
+function ensureRunnerExecutable() {
+  if (os.platform() === 'win32') return;
+  const p = runnerScriptPath();
+  if (existsSync(p)) chmodSync(p, 0o755);
+}
+
+/** Escape for `set "VAR=value"` in a .cmd file (double percent). */
+function cmdSetValueEscape(s) {
+  return s.replace(/%/g, '%%');
+}
+
+function writeWindowsLauncherCmd({
+  repoRoot,
+  envFile,
+  nodeExecPath,
+  pathEnv,
+  runnerMjs,
+  stdoutLog,
+  stderrLog,
+}) {
+  const launcherPath = join(appStateDir(), 'monolith-daemon-launcher.cmd');
+  const lines = [
+    '@echo off',
+    'setlocal',
+    `set "AGENTMANAGER_MONO_ROOT=${cmdSetValueEscape(repoRoot)}"`,
+    `set "AGENTMANAGER_MONO_ENV_FILE=${cmdSetValueEscape(envFile)}"`,
+    `set "AGENTMANAGER_MONO_NODE_EXEC=${cmdSetValueEscape(nodeExecPath)}"`,
+    `set "AGENTMANAGER_MONO_PATH=${cmdSetValueEscape(pathEnv)}"`,
+    `set "AGENTMANAGER_MONO_OUTLOG=${cmdSetValueEscape(stdoutLog)}"`,
+    `set "AGENTMANAGER_MONO_ERRLOG=${cmdSetValueEscape(stderrLog)}"`,
+    `set "AGENTMANAGER_MONO_RUNNER=${cmdSetValueEscape(runnerMjs)}"`,
+    'cd /d "%AGENTMANAGER_MONO_ROOT%"',
+    '"%AGENTMANAGER_MONO_NODE_EXEC%" "%AGENTMANAGER_MONO_RUNNER%" >>"%AGENTMANAGER_MONO_OUTLOG%" 2>>"%AGENTMANAGER_MONO_ERRLOG%"',
+  ];
+  writeFileSync(launcherPath, `${lines.join('\r\n')}\r\n`, 'utf8');
+  return launcherPath;
+}
+
+function writeWindowsScheduledTaskXml(launcherCmdPath) {
+  const xmlPath = join(appStateDir(), 'monolith-daemon-task.xml');
+  const cmd = xmlEscape(launcherCmdPath);
+  const xml = `<?xml version="1.0" encoding="UTF-16"?>
+<Task version="1.2" xmlns="http://schemas.microsoft.com/windows/2004/02/mit/task">
+  <RegistrationInfo>
+    <Description>AgentManager monolith (agentmanager CLI)</Description>
+  </RegistrationInfo>
+  <Triggers>
+    <LogonTrigger>
+      <Enabled>true</Enabled>
+    </LogonTrigger>
+  </Triggers>
+  <Principals>
+    <Principal id="Author">
+      <LogonType>InteractiveToken</LogonType>
+      <RunLevel>LeastPrivilege</RunLevel>
+    </Principal>
+  </Principals>
+  <Settings>
+    <MultipleInstancesPolicy>IgnoreNew</MultipleInstancesPolicy>
+    <DisallowStartIfOnBatteries>false</DisallowStartIfOnBatteries>
+    <StopIfGoingOnBatteries>false</StopIfGoingOnBatteries>
+    <AllowHardTerminate>true</AllowHardTerminate>
+    <StartWhenAvailable>true</StartWhenAvailable>
+    <RunOnlyIfNetworkAvailable>false</RunOnlyIfNetworkAvailable>
+    <Enabled>true</Enabled>
+    <ExecutionTimeLimit>PT0S</ExecutionTimeLimit>
+    <RestartOnFailure>
+      <Interval>PT1M</Interval>
+      <Count>3</Count>
+    </RestartOnFailure>
+  </Settings>
+  <Actions Context="Author">
+    <Exec>
+      <Command>${cmd}</Command>
+    </Exec>
+  </Actions>
+</Task>
+`;
+  writeFileSync(xmlPath, `\uFEFF${xml}`, 'utf16le');
+  return xmlPath;
+}
+
+/** @returns {number} exit code, 0 = success */
+function registerWindowsScheduledTask(xmlPath) {
+  spawnSync('schtasks', ['/End', '/TN', WINDOWS_TASK_NAME], { stdio: 'pipe' });
+  spawnSync('schtasks', ['/Delete', '/TN', WINDOWS_TASK_NAME, '/F'], {
+    stdio: 'pipe',
+  });
+  const r = spawnSync(
+    'schtasks',
+    ['/Create', '/TN', WINDOWS_TASK_NAME, '/XML', xmlPath, '/F'],
+    { stdio: 'inherit' },
+  );
+  return r.status ?? 1;
+}
+
+function printManualDaemonRun(repoRoot, envFile) {
+  if (os.platform() === 'win32') {
+    const runner = runnerNodeScriptPath();
+    const node = process.execPath;
+    output.write(
+      paint('  ', ansi.dim) +
+        paint(
+          `set "AGENTMANAGER_MONO_ROOT=${repoRoot}" & set "AGENTMANAGER_MONO_ENV_FILE=${envFile}" & set "AGENTMANAGER_MONO_NODE_EXEC=${node}" & "${node}" "${runner}"`,
+          ansi.cyan,
+        ) +
+        '\n',
+    );
+  } else {
+    output.write(
+      paint('  ', ansi.dim) +
+        paint(
+          `AGENTMANAGER_MONO_ROOT=${repoRoot} AGENTMANAGER_MONO_ENV_FILE=${envFile} ${runnerScriptPath()}`,
+          ansi.cyan,
+        ) +
+        '\n',
+    );
+  }
+}
+
+function prepareMonolithBundle(repoRoot) {
+  output.write(
+    paint('▸ ', ansi.cyan, ansi.bold) +
+      paint('integrations:prepare-db', ansi.bold) +
+      paint(' …\n', ansi.dim),
+  );
+  const r1 = spawnSync('npm', ['run', 'integrations:prepare-db'], {
+    cwd: repoRoot,
+    stdio: 'inherit',
+    shell: os.platform() === 'win32',
+  });
+  if (r1.status !== 0) process.exit(r1.status ?? 1);
+  output.write(
+    paint('✓ ', ansi.green, ansi.bold) +
+      paint('prepare-db', ansi.green) +
+      paint(' done\n', ansi.dim),
+  );
+  output.write(
+    paint('▸ ', ansi.cyan, ansi.bold) +
+      paint('build:monolith', ansi.bold) +
+      paint(' …\n', ansi.dim),
+  );
+  const r2 = spawnSync('npm', ['run', 'build:monolith'], {
+    cwd: repoRoot,
+    stdio: 'inherit',
+    shell: os.platform() === 'win32',
+  });
+  if (r2.status !== 0) process.exit(r2.status ?? 1);
+  output.write(
+    paint('✓ ', ansi.green, ansi.bold) +
+      paint('monolith build', ansi.green) +
+      paint(' done\n', ansi.dim),
+  );
+}
+
+function writeLaunchdPlist({
+  repoRoot,
+  envFile,
+  runner,
+  stdoutLog,
+  stderrLog,
+  nodeExecPath,
+  pathEnv,
+}) {
+  const plistPath = launchdPlistPath();
+  mkdirSync(dirname(plistPath), { recursive: true });
+  const xml = `<?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>${SERVICE_LABEL}</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${xmlEscape(runner)}</string>
+  </array>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>AGENTMANAGER_MONO_ROOT</key>
+    <string>${xmlEscape(repoRoot)}</string>
+    <key>AGENTMANAGER_MONO_ENV_FILE</key>
+    <string>${xmlEscape(envFile)}</string>
+    <key>AGENTMANAGER_MONO_NODE_EXEC</key>
+    <string>${xmlEscape(nodeExecPath)}</string>
+    <key>AGENTMANAGER_MONO_PATH</key>
+    <string>${xmlEscape(pathEnv)}</string>
+  </dict>
+  <key>WorkingDirectory</key>
+  <string>${xmlEscape(repoRoot)}</string>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <true/>
+  <key>StandardOutPath</key>
+  <string>${xmlEscape(stdoutLog)}</string>
+  <key>StandardErrorPath</key>
+  <string>${xmlEscape(stderrLog)}</string>
+</dict>
+</plist>
+`;
+  writeFileSync(plistPath, xml, 'utf8');
+  return plistPath;
+}
+
+function writeSystemdUserUnit({
+  repoRoot,
+  envFile,
+  runner,
+  stdoutLog,
+  stderrLog,
+  nodeExecPath,
+  pathEnv,
+}) {
+  const unitDir = join(configDir(), 'systemd/user');
+  mkdirSync(unitDir, { recursive: true });
+  const unitPath = join(unitDir, SYSTEMD_UNIT);
+  const body = `[Unit]
+Description=AgentManager monolith (agentmanager)
+After=network-online.target
+
+[Service]
+Type=simple
+Environment="AGENTMANAGER_MONO_ROOT=${systemdEnvValueEscape(repoRoot)}"
+Environment="AGENTMANAGER_MONO_ENV_FILE=${systemdEnvValueEscape(envFile)}"
+Environment="AGENTMANAGER_MONO_NODE_EXEC=${systemdEnvValueEscape(nodeExecPath)}"
+Environment="AGENTMANAGER_MONO_PATH=${systemdEnvValueEscape(pathEnv)}"
+WorkingDirectory=${systemdPathToken(repoRoot)}
+ExecStart=${systemdPathToken(runner)}
+Restart=on-failure
+RestartSec=5
+StandardOutput=append:${systemdPathToken(stdoutLog)}
+StandardError=append:${systemdPathToken(stderrLog)}
+
+[Install]
+WantedBy=default.target
+`;
+  writeFileSync(unitPath, body, 'utf8');
+  return unitPath;
+}
+
+function launchdPlistPath() {
+  return join(os.homedir(), 'Library/LaunchAgents', `${SERVICE_LABEL}.plist`);
+}
+
+function launchctlUnload() {
+  const uid =
+    typeof process.getuid === 'function'
+      ? String(process.getuid())
+      : execSync('id -u', { encoding: 'utf8' }).trim();
+  const plist = launchdPlistPath();
+  if (existsSync(plist)) {
+    spawnSync('launchctl', ['bootout', `gui/${uid}`, plist], { stdio: 'pipe' });
+  }
+  spawnSync('launchctl', ['unload', '-w', plist], { stdio: 'pipe' });
+}
+
+function launchctlLoad(plistPath) {
+  const uid =
+    process.getuid?.() ?? execSync('id -u', { encoding: 'utf8' }).trim();
+  launchctlUnload();
+  const r = spawnSync('launchctl', ['bootstrap', `gui/${uid}`, plistPath], {
+    stdio: 'inherit',
+  });
+  if (r.status !== 0) {
+    const r2 = spawnSync('launchctl', ['load', '-w', plistPath], {
+      stdio: 'inherit',
+    });
+    if (r2.status !== 0) process.exit(r2.status ?? 1);
+  }
+}
+
+function systemctlUser(args) {
+  const r = spawnSync('systemctl', ['--user', ...args], { stdio: 'inherit' });
+  return r.status ?? 1;
+}
+
+async function cmdStartDaemon(argv) {
+  const repoRoot = resolveRepoRoot(argv);
+  if (!repoRoot) {
+    output.write(
+      paint('✗ ', ansi.red, ansi.bold) +
+        paint(
+          'Could not find repo root. Pass --repo-root /path/to/repo, set AGENTMANAGER_MONO_ROOT, run from a clone, or reinstall the npm package so apps/ and nest-cli.json exist next to the CLI.\n',
+          ansi.red,
+        ) +
+        '\n',
+    );
+    process.exit(1);
+  }
+
+  const envFile = daemonEnvPath();
+  const existingDaemon = existsSync(envFile)
+    ? parseDotenvValues(readFileSync(envFile, 'utf8'))
+    : {};
+  const dotenvRepo = existsSync(join(repoRoot, '.env'))
+    ? parseDotenvValues(readFileSync(join(repoRoot, '.env'), 'utf8'))
+    : {};
+
+  output.write('\n');
+  const bar = '═'.repeat(56);
+  output.write(
+    paint(`╔${bar}╗\n`, ansi.magenta, ansi.bold) +
+      paint('║', ansi.magenta, ansi.bold) +
+      '  ' +
+      paint('AgentManager', ansi.bold, ansi.white) +
+      paint(' — ', ansi.dim) +
+      paint('daemon setup', ansi.cyan, ansi.bold) +
+      ' '.repeat(27) +
+      paint('║\n', ansi.magenta, ansi.bold) +
+      paint('║', ansi.magenta, ansi.bold) +
+      '  ' +
+      paint('Monolith environment & launch', ansi.dim, ansi.cyan) +
+      ' '.repeat(25) +
+      paint('║\n', ansi.magenta, ansi.bold) +
+      paint(`╚${bar}╝\n`, ansi.magenta, ansi.bold),
+  );
+  output.write(
+    '\n' +
+      paint('  repo ', ansi.dim) +
+      paint(repoRoot, ansi.yellow) +
+      '\n' +
+      paint('  env  ', ansi.dim) +
+      paint(envFile, ansi.cyan) +
+      '\n\n',
+  );
+
+  const values = await promptWizardVars(
+    DAEMON_WIZARD_VARS,
+    existingDaemon,
+    dotenvRepo,
+  );
+  const serialized = serializeDotenv(values);
+  writeFileSync(envFile, serialized, 'utf8');
+  try {
+    chmodSync(envFile, 0o600);
+  } catch {
+    /* ignore */
+  }
+  output.write(
+    paint('✓ ', ansi.green, ansi.bold) +
+      paint('Saved ', ansi.green) +
+      paint(envFile, ansi.cyan, ansi.bold) +
+      '\n',
+  );
+  writeFileSync(repoRootPathFile(), `${repoRoot}\n`, 'utf8');
+
+  ensureRunnerExecutable();
+  output.write(
+    '\n' +
+      paint('── ', ansi.blue, ansi.bold) +
+      paint('Build', ansi.bold, ansi.white) +
+      paint(' ──\n', ansi.blue, ansi.bold),
+  );
+  prepareMonolithBundle(repoRoot);
+
+  const runnerSh = runnerScriptPath();
+  const runnerMjs = runnerNodeScriptPath();
+  const platform = os.platform();
+  if (platform === 'win32') {
+    if (!existsSync(runnerMjs)) {
+      output.write(
+        paint('✗ ', ansi.red, ansi.bold) +
+          paint(`Runner script missing: ${runnerMjs}\n`, ansi.red),
+      );
+      process.exit(1);
+    }
+  } else if (!existsSync(runnerSh)) {
+    output.write(
+      paint('✗ ', ansi.red, ansi.bold) +
+        paint(`Runner script missing: ${runnerSh}\n`, ansi.red),
+    );
+    process.exit(1);
+  }
+
+  const outLog = join(logDir(), 'monolith.stdout.log');
+  const errLog = join(logDir(), 'monolith.stderr.log');
+  const nodeExecPath = process.execPath;
+  const pathEnv = daemonServicePathEnv();
+
+  if (platform === 'darwin') {
+    const plist = writeLaunchdPlist({
+      repoRoot,
+      envFile,
+      runner: runnerSh,
+      stdoutLog: outLog,
+      stderrLog: errLog,
+      nodeExecPath,
+      pathEnv,
+    });
+    launchctlLoad(plist);
+    output.write(
+      '\n' +
+        paint('✓ ', ansi.green, ansi.bold) +
+        paint('launchd loaded', ansi.green) +
+        '\n' +
+        paint('  ', ansi.dim) +
+        paint(plist, ansi.cyan) +
+        '\n' +
+        paint('  logs ', ansi.dim) +
+        paint(outLog, ansi.yellow) +
+        paint('  ', ansi.dim) +
+        paint(errLog, ansi.yellow) +
+        '\n',
+    );
+  } else if (platform === 'linux') {
+    let hasSystemctl = false;
+    try {
+      execSync('command -v systemctl', { stdio: 'pipe' });
+      hasSystemctl = true;
+    } catch {
+      hasSystemctl = false;
+    }
+    if (!hasSystemctl) {
+      output.write(
+        paint('✗ ', ansi.red, ansi.bold) +
+          paint(
+            'systemctl not found. Install a systemd user session or run manually:\n',
+            ansi.yellow,
+          ),
+      );
+      printManualDaemonRun(repoRoot, envFile);
+      process.exit(1);
+    }
+    const unit = writeSystemdUserUnit({
+      repoRoot,
+      envFile,
+      runner: runnerSh,
+      stdoutLog: outLog,
+      stderrLog: errLog,
+      nodeExecPath,
+      pathEnv,
+    });
+    systemctlUser(['daemon-reload']);
+    systemctlUser(['enable', '--now', SYSTEMD_UNIT]);
+    output.write(
+      '\n' +
+        paint('✓ ', ansi.green, ansi.bold) +
+        paint('systemd user unit enabled', ansi.green) +
+        '\n' +
+        paint('  ', ansi.dim) +
+        paint(unit, ansi.cyan) +
+        '\n' +
+        paint('  logs ', ansi.dim) +
+        paint(outLog, ansi.yellow) +
+        paint('  ', ansi.dim) +
+        paint(errLog, ansi.yellow) +
+        '\n',
+    );
+  } else if (platform === 'win32') {
+    const launcher = writeWindowsLauncherCmd({
+      repoRoot,
+      envFile,
+      nodeExecPath,
+      pathEnv,
+      runnerMjs,
+      stdoutLog: outLog,
+      stderrLog: errLog,
+    });
+    const xmlPath = writeWindowsScheduledTaskXml(launcher);
+    const code = registerWindowsScheduledTask(xmlPath);
+    if (code !== 0) {
+      output.write(
+        paint('✗ ', ansi.red, ansi.bold) +
+          paint('schtasks failed. Run manually from cmd.exe:\n', ansi.yellow),
+      );
+      printManualDaemonRun(repoRoot, envFile);
+      process.exit(1);
+    }
+    const rRun = spawnSync('schtasks', ['/Run', '/TN', WINDOWS_TASK_NAME], {
+      stdio: 'inherit',
+    });
+    if (rRun.status !== 0) {
+      output.write(
+        paint('! ', ansi.yellow, ansi.bold) +
+          paint(
+            'Task registered but schtasks /Run failed; it will start at next logon.\n',
+            ansi.yellow,
+          ),
+      );
+    }
+    output.write(
+      '\n' +
+        paint('✓ ', ansi.green, ansi.bold) +
+        paint('Scheduled Task registered', ansi.green) +
+        '\n' +
+        paint('  ', ansi.dim) +
+        paint(WINDOWS_TASK_NAME, ansi.cyan) +
+        '\n' +
+        paint('  launcher ', ansi.dim) +
+        paint(launcher, ansi.cyan) +
+        '\n' +
+        paint('  ', ansi.dim) +
+        paint(xmlPath, ansi.gray) +
+        '\n' +
+        paint('  logs ', ansi.dim) +
+        paint(outLog, ansi.yellow) +
+        paint('  ', ansi.dim) +
+        paint(errLog, ansi.yellow) +
+        '\n',
+    );
+  } else {
+    output.write(
+      paint('! ', ansi.yellow, ansi.bold) +
+        paint(`${platform}: `, ansi.yellow) +
+        paint(
+          'no launchd/systemd/Task Scheduler template. Run manually:\n',
+          ansi.dim,
+        ),
+    );
+    printManualDaemonRun(repoRoot, envFile);
+  }
+}
+
+function cmdStopDaemon() {
+  const platform = os.platform();
+  if (platform === 'darwin') {
+    launchctlUnload();
+    output.write(
+      paint('■ ', ansi.yellow, ansi.bold) +
+        paint('launchd unload attempted for ', ansi.yellow) +
+        paint(SERVICE_LABEL, ansi.cyan) +
+        '\n',
+    );
+  } else if (platform === 'linux') {
+    systemctlUser(['disable', '--now', SYSTEMD_UNIT]);
+    output.write(
+      paint('■ ', ansi.yellow, ansi.bold) +
+        paint('systemd user service stopped: ', ansi.yellow) +
+        paint(SYSTEMD_UNIT, ansi.cyan) +
+        '\n',
+    );
+  } else if (platform === 'win32') {
+    spawnSync('schtasks', ['/End', '/TN', WINDOWS_TASK_NAME], {
+      stdio: 'pipe',
+    });
+    spawnSync('schtasks', ['/Delete', '/TN', WINDOWS_TASK_NAME, '/F'], {
+      stdio: 'pipe',
+    });
+    output.write(
+      paint('■ ', ansi.yellow, ansi.bold) +
+        paint('Scheduled task end/delete attempted: ', ansi.yellow) +
+        paint(WINDOWS_TASK_NAME, ansi.cyan) +
+        '\n',
+    );
+  } else {
+    output.write(
+      paint('✗ ', ansi.red, ansi.bold) +
+        paint('stop-daemon: unsupported platform\n', ansi.red),
+    );
+  }
+}
+
+function cmdDaemonStatus() {
+  const platform = os.platform();
+  if (platform === 'darwin') {
+    const uid =
+      typeof process.getuid === 'function'
+        ? String(process.getuid())
+        : execSync('id -u', { encoding: 'utf8' }).trim();
+    spawnSync('launchctl', ['print', `gui/${uid}/${SERVICE_LABEL}`], {
+      stdio: 'inherit',
+    });
+  } else if (platform === 'linux') {
+    systemctlUser(['status', SYSTEMD_UNIT]);
+  } else if (platform === 'win32') {
+    spawnSync(
+      'schtasks',
+      ['/Query', '/TN', WINDOWS_TASK_NAME, '/V', '/FO', 'LIST'],
+      { stdio: 'inherit' },
+    );
+  } else {
+    output.write(
+      paint('✗ ', ansi.red, ansi.bold) +
+        paint('daemon-status: unsupported platform\n', ansi.red),
+    );
+  }
+}
+
+function printHelp() {
+  const stateHint = join(configDir(), 'agentmanager');
+  output.write(
+    '\n' +
+      paint('AgentManager', ansi.bold, ansi.magenta) +
+      paint(' — ', ansi.dim) +
+      paint('craft, deploy, and manage AI employees\n\n', ansi.cyan) +
+      '  ' +
+      paint('--start-daemon', ansi.green, ansi.bold) +
+      paint(
+        '     Interactive env wizard, build, install & start the monolith daemon\n',
+        ansi.dim,
+      ) +
+      '  ' +
+      paint('--stop-daemon', ansi.yellow, ansi.bold) +
+      paint(
+        '      Stop launchd / systemd user service / Windows Scheduled Task\n',
+        ansi.dim,
+      ) +
+      '  ' +
+      paint('--daemon-status', ansi.blue, ansi.bold) +
+      paint('    Service status ', ansi.dim) +
+      paint('(launchctl / systemctl --user / schtasks)\n', ansi.gray) +
+      '  ' +
+      paint('-v, --version', ansi.gray, ansi.bold) +
+      paint('   Print package version and exit\n', ansi.dim) +
+      '  ' +
+      paint('--logs', ansi.green, ansi.bold) +
+      paint('            ', ansi.reset) +
+      paint('tail -f monolith ', ansi.dim) +
+      paint('stdout', ansi.green) +
+      paint('.log\n', ansi.dim) +
+      '  ' +
+      paint('--errors', ansi.red, ansi.bold) +
+      paint('         ', ansi.reset) +
+      paint('tail -f monolith ', ansi.dim) +
+      paint('stderr', ansi.red) +
+      paint('.log\n', ansi.dim) +
+      '  ' +
+      paint('--repo-root PATH', ansi.cyan, ansi.bold) +
+      paint('   Monorepo root ', ansi.dim) +
+      paint(
+        `(default: cwd, ${join(stateHint, 'repo-root.txt')}, or npm global package dir)\n`,
+        ansi.gray,
+      ) +
+      '\n' +
+      paint('Config ', ansi.dim) +
+      paint(join(stateHint, 'daemon.env'), ansi.yellow) +
+      '\n' +
+      paint('Logs ', ansi.dim) +
+      paint(join(stateHint, 'logs', 'monolith.stdout.log'), ansi.green) +
+      paint(' · ', ansi.dim) +
+      paint(join(stateHint, 'logs', 'monolith.stderr.log'), ansi.red) +
+      '\n' +
+      paint('NO_COLOR=1 ', ansi.dim) +
+      paint('disables ANSI colors.\n', ansi.gray) +
+      '\n',
+  );
+}
+
+function main() {
+  const argv = process.argv.slice(2);
+  if (argv.includes('--version') || argv.includes('-v')) {
+    output.write(`${PKG_VERSION}\n`);
+    return;
+  }
+  printCliVersionLine();
+  if (argv.includes('--start-daemon') || argv.includes('--start-daemon=true')) {
+    cmdStartDaemon(argv).catch((e) => {
+      console.error(paint(String(e?.stack ?? e), ansi.red));
+      process.exit(1);
+    });
+    return;
+  }
+  if (argv.includes('--stop-daemon')) {
+    cmdStopDaemon();
+    return;
+  }
+  if (argv.includes('--daemon-status')) {
+    cmdDaemonStatus();
+    return;
+  }
+  if (argv.includes('--logs')) {
+    cmdTailMonolithLog('stdout');
+    return;
+  }
+  if (argv.includes('--errors')) {
+    cmdTailMonolithLog('stderr');
+    return;
+  }
+  if (argv.includes('-h') || argv.includes('--help') || argv.length === 0) {
+    printHelp();
+    return;
+  }
+  output.write(
+    paint('✗ ', ansi.red, ansi.bold) +
+      paint(`Unknown arguments: ${argv.join(' ')}\n`, ansi.red),
+  );
+  printHelp();
+  process.exit(1);
+}
+
+main();