@stravica-ai/digital-operator-pa 0.1.0

package/dist/engineering-pa-workspace/src/install-daemon.mjs

@@ -0,0 +1,573 @@
+#!/usr/bin/env node
+
+/**
+ * install-daemon.mjs — Install the workspace server as a supervised daemon
+ *
+ * Supervises the workspace server via the host's native service manager so it
+ * auto-starts at login and auto-restarts on crash. This is distinct from the
+ * scheduler tool (cron/launchd-calendar/systemd-timer/schtasks), which is
+ * time-triggered. A daemon is continuous-supervision and needs KeepAlive /
+ * Restart=always / RunAtLoad semantics that cron doesn't express.
+ *
+ * The daemon invokes `node server.mjs --no-timeout --port N --no-open`
+ * directly — it deliberately bypasses ws.mjs to avoid double-fork detach,
+ * which would make the supervisor think the service died on every start.
+ *
+ * Usage:
+ *   node install-daemon.mjs install [--port N] [--dry-run]
+ *   node install-daemon.mjs uninstall [--dry-run]
+ *   node install-daemon.mjs status
+ *   node install-daemon.mjs --help
+ *
+ * Exit codes:
+ *   0 — OK
+ *   1 — Usage error
+ *   2 — Platform unsupported or logical failure
+ *   3 — Transport / IO failure (launchctl/systemctl call failed)
+ */
+
+import { execSync } from 'node:child_process';
+import { readFileSync, writeFileSync, mkdirSync, existsSync, unlinkSync, realpathSync } from 'node:fs';
+import { homedir, platform } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// Resolve the operator repo root. In v2 this package is installed at
+// node_modules/@stravica-ai/engineering-pa-workspace/, so walking up three
+// __dirname levels lands inside node_modules/, not at the operator repo
+// root. Precedence:
+//   1. DAVE_REPO_ROOT or PA_REPO_ROOT env (explicit override)
+//   2. Walk up from process.cwd() looking for .git or pnpm-workspace.yaml
+//   3. Fall back to process.cwd() (best-effort; lets dry-run work in odd
+//      checkouts)
+function findRepoRoot(start) {
+  let d = start;
+  while (d && d !== resolve(d, '..')) {
+    if (existsSync(join(d, '.git')) || existsSync(join(d, 'pnpm-workspace.yaml'))) return d;
+    d = resolve(d, '..');
+  }
+  return null;
+}
+
+const envRoot = process.env.DAVE_REPO_ROOT || process.env.PA_REPO_ROOT;
+const REPO_ROOT = envRoot ? resolve(envRoot) : (findRepoRoot(process.cwd()) || process.cwd());
+const SERVER_SCRIPT = join(__dirname, 'server.mjs');
+const PREFS_FILE = join(REPO_ROOT, 'operator', 'config', 'preferences.json');
+
+const LABEL = 'com.dave.workspace';
+const UNIT_NAME = 'dave-workspace.service';
+
+// --- Log paths (platform-specific) --------------------------------------
+
+function defaultLogPaths() {
+  const plat = platform();
+  if (plat === 'darwin') {
+    const dir = join(homedir(), 'Library', 'Logs');
+    return { dir, out: join(dir, 'dave-workspace.log'), err: join(dir, 'dave-workspace.err.log') };
+  }
+  if (plat === 'linux') {
+    const dir = join(homedir(), '.local', 'state', 'dave');
+    return { dir, out: join(dir, 'workspace.log'), err: join(dir, 'workspace.err.log') };
+  }
+  return { dir: null, out: null, err: null };
+}
+
+// --- Port resolution ----------------------------------------------------
+
+/**
+ * Resolve the workspace port at install time. Precedence:
+ *   1. CLI --port flag
+ *   2. operator/config/preferences.json workspacePort
+ *   3. default 4200
+ * @param {string|undefined} flagPort
+ * @returns {number}
+ */
+export function resolvePort(flagPort) {
+  if (flagPort !== undefined && flagPort !== null) {
+    const parsed = parseInt(String(flagPort), 10);
+    if (Number.isNaN(parsed) || parsed < 1 || parsed > 65535) {
+      throw Object.assign(new Error(`Invalid port "${flagPort}". Must be 1-65535.`), { exitCode: 1 });
+    }
+    return parsed;
+  }
+  try {
+    const prefs = JSON.parse(readFileSync(PREFS_FILE, 'utf-8'));
+    if (prefs.workspacePort) return prefs.workspacePort;
+  } catch { /* fall through to default */ }
+  return 4200;
+}
+
+// --- XML / plist builders -----------------------------------------------
+
+/**
+ * XML-escape a string for safe embedding in plist values.
+ * @param {string} s
+ */
+function xmlEscape(s) {
+  return String(s)
+    .replace(/&/g, '&amp;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;');
+}
+
+/**
+ * Build the launchd plist XML for the workspace daemon. Pure function.
+ *
+ * ProgramArguments invokes server.mjs directly (NOT ws.mjs) because ws.mjs
+ * double-forks and detaches — launchd would see the immediate parent exit
+ * and interpret it as a crash, triggering a restart loop.
+ *
+ * KeepAlive is a bare boolean: restart unconditionally on exit. ThrottleInterval
+ * caps the restart rate so a persistent crash can't burn CPU in a tight loop.
+ *
+ * @param {object} opts
+ * @param {string} opts.nodePath - Absolute path to node executable
+ * @param {string} opts.serverScript - Absolute path to server.mjs
+ * @param {string} opts.repoRoot - Absolute repo root for WorkingDirectory
+ * @param {number} opts.port - Port to bind
+ * @param {string} opts.stdoutPath - Path to stdout log
+ * @param {string} opts.stderrPath - Path to stderr log
+ * @returns {string}
+ */
+export function buildLaunchdPlist(opts) {
+  const { nodePath, serverScript, repoRoot, port, stdoutPath, stderrPath } = opts;
+  const programArgs = [
+    nodePath,
+    serverScript,
+    '--no-timeout',
+    '--port', String(port),
+    '--no-open',
+  ];
+  const argsXml = programArgs.map((p) => `    <string>${xmlEscape(p)}</string>`).join('\n');
+
+  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>${LABEL}</string>
+  <key>ProgramArguments</key>
+  <array>
+${argsXml}
+  </array>
+  <key>WorkingDirectory</key>
+  <string>${xmlEscape(repoRoot)}</string>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>DAVE_ROOT</key>
+    <string>${xmlEscape(repoRoot)}</string>
+    <key>PATH</key>
+    <string>${xmlEscape(process.env.PATH || '/usr/local/bin:/usr/bin:/bin')}</string>
+  </dict>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <true/>
+  <key>ThrottleInterval</key>
+  <integer>10</integer>
+  <key>StandardOutPath</key>
+  <string>${xmlEscape(stdoutPath)}</string>
+  <key>StandardErrorPath</key>
+  <string>${xmlEscape(stderrPath)}</string>
+  <key>ProcessType</key>
+  <string>Background</string>
+</dict>
+</plist>
+`;
+}
+
+/**
+ * Build the systemd user service unit for the workspace daemon. Pure function.
+ *
+ * Same rationale as launchd: ExecStart invokes server.mjs directly (not ws.mjs),
+ * because ws.mjs detaches and systemd would see Type=simple's main process exit
+ * and assume the service died. Restart=always + RestartSec=5 mirrors launchd's
+ * KeepAlive+ThrottleInterval.
+ *
+ * @param {object} opts
+ * @param {string} opts.nodePath
+ * @param {string} opts.serverScript
+ * @param {string} opts.repoRoot
+ * @param {number} opts.port
+ * @param {string} opts.stdoutPath
+ * @param {string} opts.stderrPath
+ * @returns {string}
+ */
+export function buildSystemdUnit(opts) {
+  const { nodePath, serverScript, repoRoot, port, stdoutPath, stderrPath } = opts;
+  return `[Unit]
+Description=Dave workspace server (supervised daemon)
+After=network.target
+
+[Service]
+Type=simple
+WorkingDirectory=${repoRoot}
+Environment=DAVE_ROOT=${repoRoot}
+ExecStart=${nodePath} ${serverScript} --no-timeout --port ${port} --no-open
+Restart=always
+RestartSec=5
+StandardOutput=append:${stdoutPath}
+StandardError=append:${stderrPath}
+
+[Install]
+WantedBy=default.target
+`;
+}
+
+// --- Paths --------------------------------------------------------------
+
+function launchdPlistPath() {
+  return join(homedir(), 'Library', 'LaunchAgents', `${LABEL}.plist`);
+}
+
+function systemdUnitPath() {
+  return join(homedir(), '.config', 'systemd', 'user', UNIT_NAME);
+}
+
+// --- Darwin (launchd) ---------------------------------------------------
+
+function darwinInstall({ port, dryRun }) {
+  const logs = defaultLogPaths();
+  const opts = {
+    nodePath: process.execPath,
+    serverScript: SERVER_SCRIPT,
+    repoRoot: REPO_ROOT,
+    port,
+    stdoutPath: logs.out,
+    stderrPath: logs.err,
+  };
+  const plist = buildLaunchdPlist(opts);
+  const plistPath = launchdPlistPath();
+
+  if (dryRun) {
+    console.log(`# Would write plist to: ${plistPath}`);
+    console.log(`# Log dir: ${logs.dir}`);
+    console.log(`# Would run: launchctl unload -w ${plistPath} (ignoring errors)`);
+    console.log(`# Would run: launchctl load -w ${plistPath}`);
+    console.log('# --- plist contents ---');
+    console.log(plist);
+    return 0;
+  }
+
+  mkdirSync(dirname(plistPath), { recursive: true });
+  mkdirSync(logs.dir, { recursive: true });
+  writeFileSync(plistPath, plist, 'utf8');
+  console.log(`Wrote plist: ${plistPath}`);
+
+  // Unload if present (ignore failure — it may not be loaded)
+  try {
+    execSync(`launchctl unload -w ${shellQuote(plistPath)}`, { stdio: 'pipe' });
+  } catch { /* not previously loaded */ }
+
+  try {
+    execSync(`launchctl load -w ${shellQuote(plistPath)}`, { stdio: 'pipe' });
+  } catch (err) {
+    throw Object.assign(new Error(`launchctl load failed: ${err.message}`), { exitCode: 3 });
+  }
+
+  console.log(`Loaded service: ${LABEL}`);
+  console.log(`Logs: ${logs.out}`);
+  console.log(`       ${logs.err}`);
+  console.log(`URL: http://127.0.0.1:${port}/`);
+  return 0;
+}
+
+function darwinUninstall({ dryRun }) {
+  const plistPath = launchdPlistPath();
+  if (dryRun) {
+    console.log(`# Would run: launchctl unload -w ${plistPath}`);
+    console.log(`# Would remove: ${plistPath}`);
+    return 0;
+  }
+
+  if (existsSync(plistPath)) {
+    try {
+      execSync(`launchctl unload -w ${shellQuote(plistPath)}`, { stdio: 'pipe' });
+    } catch { /* not loaded — fine */ }
+    try {
+      unlinkSync(plistPath);
+      console.log(`Removed plist: ${plistPath}`);
+    } catch (err) {
+      throw Object.assign(new Error(`Could not remove plist: ${err.message}`), { exitCode: 3 });
+    }
+  } else {
+    console.log(`No plist found at ${plistPath} — nothing to remove.`);
+  }
+  console.log(`Unloaded: ${LABEL}`);
+  return 0;
+}
+
+function darwinStatus() {
+  const plistPath = launchdPlistPath();
+  const plistExists = existsSync(plistPath);
+  console.log(`Plist: ${plistPath} (${plistExists ? 'present' : 'absent'})`);
+
+  let listing = '';
+  try {
+    listing = execSync(`launchctl list ${LABEL}`, { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
+  } catch {
+    console.log(`Service ${LABEL}: not loaded.`);
+    return plistExists ? 2 : 0;
+  }
+
+  // launchctl list <label> returns a plist-ish dict. Extract PID line if any.
+  const pidMatch = listing.match(/"PID"\s*=\s*(\d+)/);
+  if (pidMatch) {
+    console.log(`Service ${LABEL}: running (PID ${pidMatch[1]}).`);
+    return 0;
+  }
+  const exitMatch = listing.match(/"LastExitStatus"\s*=\s*(-?\d+)/);
+  console.log(`Service ${LABEL}: loaded but not running${exitMatch ? ` (last exit: ${exitMatch[1]})` : ''}.`);
+  return 2;
+}
+
+// --- Linux (systemd --user) --------------------------------------------
+
+function linuxInstall({ port, dryRun }) {
+  const logs = defaultLogPaths();
+  const opts = {
+    nodePath: process.execPath,
+    serverScript: SERVER_SCRIPT,
+    repoRoot: REPO_ROOT,
+    port,
+    stdoutPath: logs.out,
+    stderrPath: logs.err,
+  };
+  const unit = buildSystemdUnit(opts);
+  const unitPath = systemdUnitPath();
+
+  if (dryRun) {
+    console.log(`# Would write unit to: ${unitPath}`);
+    console.log(`# Log dir: ${logs.dir}`);
+    console.log('# Would run: systemctl --user daemon-reload');
+    console.log(`# Would run: systemctl --user enable --now ${UNIT_NAME}`);
+    console.log('# --- unit contents ---');
+    console.log(unit);
+    return 0;
+  }
+
+  mkdirSync(dirname(unitPath), { recursive: true });
+  mkdirSync(logs.dir, { recursive: true });
+  writeFileSync(unitPath, unit, 'utf8');
+  console.log(`Wrote unit: ${unitPath}`);
+
+  try {
+    execSync('systemctl --user daemon-reload', { stdio: 'pipe' });
+    execSync(`systemctl --user enable --now ${UNIT_NAME}`, { stdio: 'pipe' });
+  } catch (err) {
+    throw Object.assign(new Error(`systemctl failed: ${err.message}`), { exitCode: 3 });
+  }
+
+  console.log(`Enabled + started: ${UNIT_NAME}`);
+  console.log(`Logs: ${logs.out}`);
+  console.log(`       ${logs.err}`);
+  console.log(`URL: http://127.0.0.1:${port}/`);
+  return 0;
+}
+
+function linuxUninstall({ dryRun }) {
+  const unitPath = systemdUnitPath();
+  if (dryRun) {
+    console.log(`# Would run: systemctl --user disable --now ${UNIT_NAME}`);
+    console.log('# Would run: systemctl --user daemon-reload');
+    console.log(`# Would remove: ${unitPath}`);
+    return 0;
+  }
+
+  try {
+    execSync(`systemctl --user disable --now ${UNIT_NAME}`, { stdio: 'pipe' });
+  } catch { /* not installed — fine */ }
+
+  if (existsSync(unitPath)) {
+    try {
+      unlinkSync(unitPath);
+      console.log(`Removed unit: ${unitPath}`);
+    } catch (err) {
+      throw Object.assign(new Error(`Could not remove unit: ${err.message}`), { exitCode: 3 });
+    }
+  } else {
+    console.log(`No unit file at ${unitPath} — nothing to remove.`);
+  }
+
+  try {
+    execSync('systemctl --user daemon-reload', { stdio: 'pipe' });
+  } catch { /* non-fatal */ }
+
+  console.log(`Disabled: ${UNIT_NAME}`);
+  return 0;
+}
+
+function linuxStatus() {
+  const unitPath = systemdUnitPath();
+  const unitExists = existsSync(unitPath);
+  console.log(`Unit: ${unitPath} (${unitExists ? 'present' : 'absent'})`);
+
+  try {
+    const active = execSync(`systemctl --user is-active ${UNIT_NAME}`, { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] }).trim();
+    console.log(`Service ${UNIT_NAME}: ${active}`);
+    return active === 'active' ? 0 : 2;
+  } catch {
+    console.log(`Service ${UNIT_NAME}: not active or not installed.`);
+    return unitExists ? 2 : 0;
+  }
+}
+
+// --- Windows stub -------------------------------------------------------
+
+function windowsNotSupported() {
+  console.error('Error: Windows service installation is not yet implemented.');
+  console.error('Open an issue on Stravica/dave if you need this, or run the');
+  console.error('workspace manually with: pa workspace start (or node node_modules/@stravica-ai/engineering-pa-workspace/src/ws.mjs start)');
+  return 2;
+}
+
+// --- Platform dispatcher -------------------------------------------------
+
+/**
+ * Route to the correct backend for the host platform.
+ * Exported so tests can exercise the routing independently of real OS calls.
+ * @param {string} plat - platform() return value
+ * @returns {string} - 'darwin' | 'linux' | 'win32' | 'unsupported'
+ */
+export function routePlatform(plat) {
+  if (plat === 'darwin') return 'darwin';
+  if (plat === 'linux') return 'linux';
+  if (plat === 'win32') return 'win32';
+  return 'unsupported';
+}
+
+// --- Shell quoting ------------------------------------------------------
+
+/**
+ * Quote a path for inclusion in a shell command. launchctl/systemctl invocations
+ * go through the shell via execSync, so paths with spaces need quoting.
+ * @param {string} s
+ */
+function shellQuote(s) {
+  if (!/[^A-Za-z0-9_\-./]/.test(s)) return s;
+  return `'${String(s).replace(/'/g, `'\\''`)}'`;
+}
+
+// --- CLI ----------------------------------------------------------------
+
+const USAGE = `Usage: node install-daemon.mjs <command> [options]
+
+Commands:
+  install   [--port N] [--dry-run]   Install + start the workspace daemon
+  uninstall [--dry-run]              Stop + remove the daemon
+  status                              Show daemon status
+  --help, -h                          Show this help
+
+Options:
+  --port N     Override the port (default: reads operator/config/preferences.json, falls back to 4200)
+  --dry-run    Print what would happen; do not write files or invoke the service manager
+
+Exit codes:
+  0   OK
+  1   Usage error
+  2   Unsupported platform / logical failure
+  3   Transport failure (launchctl/systemctl call)
+`;
+
+function parseArgs(argv) {
+  const out = { command: null, port: undefined, dryRun: false };
+  const args = argv.slice();
+  while (args.length > 0) {
+    const a = args.shift();
+    if (a === '--help' || a === '-h') { out.command = 'help'; continue; }
+    if (a === '--dry-run') { out.dryRun = true; continue; }
+    if (a === '--port') { out.port = args.shift(); continue; }
+    if (out.command === null) { out.command = a; continue; }
+    throw Object.assign(new Error(`Unexpected argument: ${a}`), { exitCode: 1 });
+  }
+  return out;
+}
+
+export async function main(argv) {
+  let parsed;
+  try {
+    parsed = parseArgs(argv);
+  } catch (err) {
+    console.error(`Error: ${err.message}`);
+    console.error(USAGE);
+    return err.exitCode || 1;
+  }
+
+  if (parsed.command === 'help' || parsed.command === null) {
+    console.log(USAGE);
+    return parsed.command === null ? 1 : 0;
+  }
+
+  let port = null;
+  if (parsed.command === 'install') {
+    try {
+      port = resolvePort(parsed.port);
+    } catch (err) {
+      console.error(`Error: ${err.message}`);
+      return err.exitCode || 1;
+    }
+  }
+  const plat = routePlatform(platform());
+
+  if (plat === 'unsupported') {
+    console.error(`Error: Platform ${platform()} is not supported.`);
+    return 2;
+  }
+  if (plat === 'win32') {
+    if (parsed.command === 'install' || parsed.command === 'uninstall' || parsed.command === 'status') {
+      return windowsNotSupported();
+    }
+  }
+
+  switch (parsed.command) {
+    case 'install':
+      if (plat === 'darwin') return darwinInstall({ port, dryRun: parsed.dryRun });
+      if (plat === 'linux') return linuxInstall({ port, dryRun: parsed.dryRun });
+      break;
+    case 'uninstall':
+      if (plat === 'darwin') return darwinUninstall({ dryRun: parsed.dryRun });
+      if (plat === 'linux') return linuxUninstall({ dryRun: parsed.dryRun });
+      break;
+    case 'status':
+      if (plat === 'darwin') return darwinStatus();
+      if (plat === 'linux') return linuxStatus();
+      break;
+    default:
+      console.error(`Error: Unknown command '${parsed.command}'.`);
+      console.error(USAGE);
+      return 1;
+  }
+  return 1;
+}
+
+// --- Entry point --------------------------------------------------------
+//
+// Under pnpm's hoisted layout, `import.meta.url` realpath-resolves through
+// `.pnpm/...` while `process.argv[1]` keeps the symlinked path. A naive
+// equality check would always be false and the CLI would silently no-op.
+// Realpath both sides so the comparison reflects file identity. If argv[1]
+// is unset or unresolvable (e.g. imported by tests), treat as not-main.
+
+const isMainModule = (() => {
+  if (!process.argv[1]) return false;
+  try {
+    return import.meta.url === pathToFileURL(realpathSync(process.argv[1])).href;
+  } catch {
+    return false;
+  }
+})();
+
+if (isMainModule) {
+  try {
+    const code = await main(process.argv.slice(2));
+    process.exit(code);
+  } catch (err) {
+    console.error(`Error: ${err.message}`);
+    process.exit(err.exitCode || 3);
+  }
+}