agent-tempo 1.0.1

package/dist/cli/daemon-command.js

@@ -0,0 +1,493 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.evaluateStartPreflight = evaluateStartPreflight;
+exports.daemon = daemon;
+exports.formatBytesAsMb = formatBytesAsMb;
+exports.formatUptime = formatUptime;
+/**
+ * Daemon CLI command handler — `agent-tempo daemon <start|stop|status|logs|install|uninstall>`.
+ *
+ * **Critical constraint**: this module must NOT import from `@temporalio/*`,
+ * `../workflows/*`, `../adapters/*`, `../spawn`, `../client`, or any module
+ * that transitively pulls in the Temporal SDK or rxjs. The daemon CLI must
+ * remain operable even when the Temporal SDK itself is broken (e.g. a
+ * `@temporalio/core-bridge` native-module build failure on an unsupported
+ * Node version — see issue #157: users were stranded with orphan processes
+ * they couldn't stop because `daemon stop` crashed before executing).
+ *
+ * Keeping this module's dep graph minimal also avoids pulling ~250MB of
+ * Temporal SDK code + workflow bundle parsing into every CLI invocation.
+ *
+ * ## Test guarantee
+ *
+ * `test/daemon-command-isolation.test.ts` spawns a child Node process that
+ * requires the compiled `dist/cli/daemon-command.js` and asserts that
+ * `require.cache` contains zero entries matching `@temporalio|rxjs|@grpc`.
+ * If you add an import here that transitively leaks Temporal deps, that
+ * test will fail.
+ */
+const fs_1 = require("fs");
+const path_1 = require("path");
+const os_1 = require("os");
+const child_process_1 = require("child_process");
+const http = __importStar(require("http"));
+const config_1 = require("../config");
+const port_file_1 = require("../http/port-file");
+const daemon_1 = require("./daemon");
+const out = __importStar(require("./output"));
+/**
+ * Pure decision function for `daemon start`. Given a scanner result and the
+ * current daemon status, computes whether to no-op, abort with orphans, or
+ * spawn. `force` bypasses the orphan check and signals that a stale pid file
+ * (if any) should be cleared before the spawn.
+ *
+ * `otherProfilePid` is the live PID (if any) of the opposite profile's
+ * daemon (dev's prod sibling, or prod's dev sibling). Including it in the
+ * known-PID set keeps cross-profile coexistence working (ADR 0014 §5.6) —
+ * starting the dev daemon must not flag the prod daemon as an orphan, and
+ * vice versa.
+ *
+ * @internal — exported for unit tests in test/daemon-start-orphan-check.test.ts.
+ */
+function evaluateStartPreflight(scanned, status, force, otherProfilePid) {
+    if (status.running && typeof status.pid === 'number') {
+        return { action: 'already-running', pid: status.pid };
+    }
+    if (!force) {
+        const orphans = (0, daemon_1.selectOrphans)(scanned, [status.pid, otherProfilePid]);
+        if (orphans.length > 0)
+            return { action: 'abort', orphans };
+    }
+    return { action: 'spawn', cleanupStalePid: force };
+}
+/** Package root is two levels up from dist/cli/ */
+const PACKAGE_ROOT = (0, path_1.resolve)(__dirname, '..', '..');
+function packagingFile(...segments) {
+    return (0, path_1.join)(PACKAGE_ROOT, 'packaging', ...segments);
+}
+async function daemon(opts) {
+    const config = (0, config_1.getConfig)(opts);
+    switch (opts.subcommand) {
+        case 'start': {
+            const status = (0, daemon_1.getDaemonStatus)();
+            // ADR 0014 §5.6 — if the OPPOSITE profile's daemon is running on this
+            // machine, exclude its PID from the orphan set. Dev + prod daemons
+            // are designed to coexist (different home dir / port / namespace).
+            // When the other profile shows weak evidence of running (port file
+            // exists but PID file doesn't / PID is unparseable), skip the orphan
+            // scan entirely — see also `stopDaemon`'s mirroring behavior.
+            const otherPid = (0, daemon_1.getOtherProfilePid)();
+            const skipOrphanScan = (0, daemon_1.isOtherProfileLikelyRunning)() && otherPid === undefined;
+            if (skipOrphanScan) {
+                out.warn('Skipping orphan-process scan — the other profile (dev/prod) appears to be running ' +
+                    'without a PID file. Re-run with `daemon start --force` if you have already verified ' +
+                    'no rogue daemon for THIS profile is present.');
+            }
+            const preflight = evaluateStartPreflight(
+            // Skip the actual OS scan when we're already-running, force is set,
+            // or we're suppressing for cross-profile safety.
+            status.running || opts.force || skipOrphanScan ? [] : (0, daemon_1.scanAgentTempoDaemons)(), status, Boolean(opts.force) || skipOrphanScan, otherPid);
+            switch (preflight.action) {
+                case 'already-running':
+                    out.success(`Daemon already running (pid ${preflight.pid})`);
+                    return;
+                case 'abort':
+                    // Piling a new daemon on top of orphans is the original #157 user-pain
+                    // scenario. User must clean up first — see troubleshooting docs.
+                    out.error(`Found ${preflight.orphans.length} orphaned agent-tempo daemon process${preflight.orphans.length === 1 ? '' : 'es'} — daemon start aborted.`);
+                    for (const p of preflight.orphans)
+                        out.log(`  pid ${p.pid}: ${p.commandLine}`);
+                    out.log('');
+                    out.log(`  ${out.dim('Emergency cleanup: see docs/troubleshooting.md → "Orphaned daemon processes"')}`);
+                    out.log(`  ${out.dim('Override (use only after confirming): agent-tempo daemon start --force')}`);
+                    process.exit(1);
+                    break;
+                case 'spawn':
+                    if (preflight.cleanupStalePid && (0, fs_1.existsSync)(daemon_1.DAEMON_PID_PATH)) {
+                        // Force path — clean up a stale pid file if present.
+                        // `getDaemonStatus` already unlinks the file when it detects a
+                        // dead pid; this handles the rarer "file exists, contents
+                        // unparseable OR fs error" branch.
+                        try {
+                            (0, fs_1.unlinkSync)(daemon_1.DAEMON_PID_PATH);
+                        }
+                        catch { /* ignore */ }
+                    }
+                    out.log('Starting daemon...');
+                    try {
+                        const pid = await (0, daemon_1.startDaemon)(config);
+                        out.success(`Daemon started (pid ${pid})`);
+                        out.log(`  ${out.dim('Logs: ' + daemon_1.DAEMON_LOG_PATH)}`);
+                    }
+                    catch (err) {
+                        out.error(err.message || String(err));
+                        process.exit(1);
+                    }
+                    break;
+            }
+            break;
+        }
+        case 'stop': {
+            if ((0, daemon_1.stopDaemon)()) {
+                out.success('Daemon stopped');
+            }
+            else {
+                out.warn('Daemon is not running');
+            }
+            break;
+        }
+        case 'status': {
+            const status = (0, daemon_1.getDaemonStatus)();
+            const scanned = (0, daemon_1.scanAgentTempoDaemons)();
+            if (status.running) {
+                out.success(`Daemon running (pid ${status.pid})`);
+                // Heartbeat diagnostic — distinguishes "pid alive AND main loop
+                // serving" from "pid alive but something hung" (#157 PR B).
+                const staleThresholdMs = daemon_1.HEARTBEAT_INTERVAL_MS * daemon_1.HEARTBEAT_STALE_MULTIPLIER;
+                if (status.heartbeatAge !== undefined && status.heartbeatAge !== null) {
+                    const ageSec = Math.round(status.heartbeatAge / 1000);
+                    if (status.heartbeatAge > staleThresholdMs) {
+                        out.warn(`  Last heartbeat: ${ageSec}s ago — STALE (threshold ${staleThresholdMs / 1000}s). The daemon's main loop may be hung.`);
+                    }
+                    else {
+                        out.log(`  ${out.dim(`Last heartbeat: ${ageSec}s ago`)}`);
+                    }
+                }
+                else if (status.heartbeatAge === null) {
+                    out.log(`  ${out.dim('Last heartbeat: (not yet written — daemon just started or pre-heartbeat version)')}`);
+                }
+                // Warn if the scanner reports extras the pid file doesn't know about —
+                // orphans from a prior crashed run that never removed its pid file, or
+                // a second daemon started by a stale concurrent CLI invocation (#157).
+                // The opposite profile's daemon (if running) also gets excluded so
+                // prod doesn't flag dev as an orphan / vice versa (ADR 0014 §5.6).
+                const extras = (0, daemon_1.selectOrphans)(scanned, [status.pid, (0, daemon_1.getOtherProfilePid)()]);
+                if (extras.length > 0) {
+                    out.warn(`Found ${extras.length} additional agent-tempo daemon process${extras.length === 1 ? '' : 'es'} not tracked by the pid file:`);
+                    for (const p of extras)
+                        out.log(`  pid ${p.pid}: ${p.commandLine}`);
+                    out.log(`  ${out.dim('See `agent-tempo daemon --help` or docs/troubleshooting.md for emergency cleanup.')}`);
+                }
+            }
+            else {
+                out.log('Daemon is not running');
+                if (scanned.length > 0) {
+                    out.warn(`Found ${scanned.length} orphaned agent-tempo daemon process${scanned.length === 1 ? '' : 'es'} (no pid file):`);
+                    for (const p of scanned)
+                        out.log(`  pid ${p.pid}: ${p.commandLine}`);
+                    out.log(`  ${out.dim('These are untracked. See docs/troubleshooting.md → "Orphaned daemon processes" for emergency cleanup.')}`);
+                }
+            }
+            break;
+        }
+        case 'stats': {
+            await daemonStats();
+            break;
+        }
+        case 'logs': {
+            if (!(0, fs_1.existsSync)(daemon_1.DAEMON_LOG_PATH)) {
+                out.warn('No daemon log file found');
+                return;
+            }
+            // Tail the log file
+            if (process.platform === 'win32') {
+                // On Windows, read the last 32KB of the log (size-capped to avoid OOM on large logs)
+                const MAX_TAIL_BYTES = 32 * 1024;
+                const stat = (0, fs_1.statSync)(daemon_1.DAEMON_LOG_PATH);
+                const fd = (0, fs_1.openSync)(daemon_1.DAEMON_LOG_PATH, 'r');
+                const readStart = Math.max(0, stat.size - MAX_TAIL_BYTES);
+                const buf = Buffer.alloc(Math.min(stat.size, MAX_TAIL_BYTES));
+                (0, fs_1.readSync)(fd, buf, 0, buf.length, readStart);
+                (0, fs_1.closeSync)(fd);
+                const chunk = buf.toString('utf8');
+                // Skip partial first line if we didn't read from the start
+                const lines = readStart > 0 ? chunk.split('\n').slice(1) : chunk.split('\n');
+                console.log(lines.slice(-50).join('\n'));
+            }
+            else {
+                // On Unix, use tail -f for live following
+                const child = (0, child_process_1.spawn)('tail', ['-f', '-n', '50', daemon_1.DAEMON_LOG_PATH], {
+                    stdio: 'inherit',
+                });
+                child.on('error', () => {
+                    // Fallback: just read the file
+                    const content = (0, fs_1.readFileSync)(daemon_1.DAEMON_LOG_PATH, 'utf8');
+                    const lines = content.split('\n');
+                    console.log(lines.slice(-50).join('\n'));
+                });
+                // Keep running until user presses Ctrl+C
+                await new Promise((resolve) => {
+                    child.on('exit', () => resolve());
+                    process.on('SIGINT', () => { child.kill(); resolve(); });
+                });
+            }
+            break;
+        }
+        case 'install':
+            await daemonInstall();
+            break;
+        case 'uninstall':
+            await daemonUninstall();
+            break;
+        default:
+            out.error('Usage: agent-tempo daemon <start|stop|status|stats|logs|install|uninstall>');
+            out.log(`\n  ${out.dim('agent-tempo daemon start [--force]')}  Start the worker daemon`);
+            out.log(`  ${out.dim('                           --force: skip orphan-process check + clear stale pid file')}`);
+            out.log(`  ${out.dim('agent-tempo daemon stop')}              Stop the worker daemon`);
+            out.log(`  ${out.dim('agent-tempo daemon status')}            Check daemon status + heartbeat + orphans`);
+            out.log(`  ${out.dim('agent-tempo daemon stats')}             Show memory + uptime + ensemble count`);
+            out.log(`  ${out.dim('agent-tempo daemon logs')}              Tail daemon log output`);
+            out.log(`  ${out.dim('agent-tempo daemon install')}           Install as a system service`);
+            out.log(`  ${out.dim('agent-tempo daemon uninstall')}         Uninstall the system service`);
+            process.exit(1);
+    }
+    // Used only to silence "config declared but never used" when a branch exits early.
+    void config;
+}
+async function daemonInstall() {
+    const platform = process.platform;
+    if (platform === 'linux') {
+        const src = packagingFile('systemd', 'agent-tempo.service');
+        const dstDir = (0, path_1.join)((0, os_1.homedir)(), '.config', 'systemd', 'user');
+        const dst = (0, path_1.join)(dstDir, 'agent-tempo.service');
+        (0, fs_1.mkdirSync)(dstDir, { recursive: true });
+        (0, fs_1.copyFileSync)(src, dst);
+        out.success(`Installed systemd --user unit: ${dst}`);
+        // Try to enable + start. User may still need `systemctl --user daemon-reload`.
+        try {
+            (0, child_process_1.execFileSync)('systemctl', ['--user', 'daemon-reload'], { stdio: 'ignore' });
+            (0, child_process_1.execFileSync)('systemctl', ['--user', 'enable', '--now', 'agent-tempo'], { stdio: 'ignore' });
+            out.log('  Enabled + started: systemctl --user enable --now agent-tempo');
+        }
+        catch {
+            out.warn('  systemctl invocation failed — run manually:');
+            out.log(`    ${out.dim('systemctl --user daemon-reload')}`);
+            out.log(`    ${out.dim('systemctl --user enable --now agent-tempo')}`);
+        }
+        return;
+    }
+    if (platform === 'darwin') {
+        const src = packagingFile('launchd', 'com.agent.tempo.plist');
+        const dstDir = (0, path_1.join)((0, os_1.homedir)(), 'Library', 'LaunchAgents');
+        const dst = (0, path_1.join)(dstDir, 'com.agent.tempo.plist');
+        (0, fs_1.mkdirSync)(dstDir, { recursive: true });
+        (0, fs_1.copyFileSync)(src, dst);
+        out.success(`Installed launchd agent: ${dst}`);
+        out.warn('  NOTE: macOS launchd integration is best-effort — feedback welcome.');
+        try {
+            (0, child_process_1.execFileSync)('launchctl', ['load', dst], { stdio: 'ignore' });
+            out.log('  Loaded: launchctl load ' + dst);
+        }
+        catch {
+            out.warn('  launchctl invocation failed — run manually:');
+            out.log(`    ${out.dim(`launchctl load ${dst}`)}`);
+        }
+        return;
+    }
+    if (platform === 'win32') {
+        const script = packagingFile('windows', 'install-task.ps1');
+        try {
+            (0, child_process_1.execFileSync)('powershell', ['-NoProfile', '-ExecutionPolicy', 'Bypass', '-File', script], { stdio: 'inherit' });
+        }
+        catch (err) {
+            out.error(`Failed to register scheduled task: ${err?.message ?? err}`);
+            process.exit(1);
+        }
+        return;
+    }
+    out.error(`Unsupported platform: ${platform}`);
+    out.log('  Supported: linux (systemd --user), darwin (launchd), win32 (Task Scheduler).');
+    process.exit(1);
+}
+async function daemonUninstall() {
+    const platform = process.platform;
+    if (platform === 'linux') {
+        // Backward-compat: clean up either the new (`agent-tempo.service`) or
+        // legacy (`agent-tempo.service`) unit so v0.x installs migrate cleanly.
+        const dirSystemd = (0, path_1.join)((0, os_1.homedir)(), '.config', 'systemd', 'user');
+        const dstNew = (0, path_1.join)(dirSystemd, 'agent-tempo.service');
+        const dstLegacy = (0, path_1.join)(dirSystemd, 'agent-tempo.service');
+        for (const svc of ['agent-tempo', 'agent-tempo']) {
+            try {
+                (0, child_process_1.execFileSync)('systemctl', ['--user', 'disable', '--now', svc], { stdio: 'ignore' });
+            }
+            catch { /* may not be running */ }
+        }
+        let removed = false;
+        try {
+            for (const dst of [dstNew, dstLegacy]) {
+                if ((0, fs_1.existsSync)(dst)) {
+                    (0, fs_1.unlinkSync)(dst);
+                    out.success(`Removed ${dst}`);
+                    removed = true;
+                }
+            }
+            if (!removed)
+                out.log('No systemd unit file found.');
+        }
+        catch (err) {
+            out.error(`Failed to remove systemd unit: ${err?.message ?? err}`);
+            process.exit(1);
+        }
+        return;
+    }
+    if (platform === 'darwin') {
+        // Backward-compat: clean up either the new (`com.agent.tempo.plist`) or
+        // legacy (`com.claude.tempo.plist`) plist so v0.x installs migrate cleanly.
+        const dstNew = (0, path_1.join)((0, os_1.homedir)(), 'Library', 'LaunchAgents', 'com.agent.tempo.plist');
+        const dstLegacy = (0, path_1.join)((0, os_1.homedir)(), 'Library', 'LaunchAgents', 'com.claude.tempo.plist');
+        let removed = false;
+        for (const dst of [dstNew, dstLegacy]) {
+            try {
+                (0, child_process_1.execFileSync)('launchctl', ['unload', dst], { stdio: 'ignore' });
+            }
+            catch { /* may not be loaded */ }
+            if ((0, fs_1.existsSync)(dst)) {
+                (0, fs_1.unlinkSync)(dst);
+                out.success(`Removed ${dst}`);
+                removed = true;
+            }
+        }
+        if (!removed)
+            out.log('No launchd plist found.');
+        return;
+    }
+    if (platform === 'win32') {
+        const script = packagingFile('windows', 'install-task.ps1');
+        try {
+            (0, child_process_1.execFileSync)('powershell', ['-NoProfile', '-ExecutionPolicy', 'Bypass', '-File', script, '-Uninstall'], { stdio: 'inherit' });
+        }
+        catch (err) {
+            out.error(`Failed to unregister scheduled task: ${err?.message ?? err}`);
+            process.exit(1);
+        }
+        return;
+    }
+    out.error(`Unsupported platform: ${platform}`);
+    process.exit(1);
+}
+/** Pretty-print a byte count as MB (rounded). Pure helper, exported for tests. */
+function formatBytesAsMb(n) {
+    if (typeof n !== 'number' || !Number.isFinite(n))
+        return 'n/a';
+    return `${Math.round(n / (1024 * 1024))} MB`;
+}
+/** Pretty-print a millisecond uptime as `Xh Ym Zs`. Pure helper, exported for tests. */
+function formatUptime(ms) {
+    if (typeof ms !== 'number' || !Number.isFinite(ms) || ms < 0)
+        return 'n/a';
+    const totalSec = Math.floor(ms / 1000);
+    const hours = Math.floor(totalSec / 3600);
+    const minutes = Math.floor((totalSec % 3600) / 60);
+    const seconds = totalSec % 60;
+    if (hours > 0)
+        return `${hours}h ${minutes}m ${seconds}s`;
+    if (minutes > 0)
+        return `${minutes}m ${seconds}s`;
+    return `${seconds}s`;
+}
+/** GET `http://127.0.0.1:<port>/v1/health` and parse the JSON body. Used by `daemon stats`. */
+function fetchHealth(port) {
+    return new Promise((resolve, reject) => {
+        const req = http.request({ hostname: '127.0.0.1', port, path: '/v1/health', method: 'GET', timeout: 3000 }, (res) => {
+            const chunks = [];
+            res.on('data', (c) => chunks.push(c));
+            res.on('end', () => {
+                if (res.statusCode !== 200) {
+                    reject(new Error(`HTTP ${res.statusCode}`));
+                    return;
+                }
+                try {
+                    resolve(JSON.parse(Buffer.concat(chunks).toString('utf8')));
+                }
+                catch (err) {
+                    reject(err);
+                }
+            });
+        });
+        req.on('error', reject);
+        req.on('timeout', () => {
+            req.destroy(new Error('request timed out after 3000ms'));
+        });
+        req.end();
+    });
+}
+/**
+ * Render the `daemon stats` payload to stdout. Filed under #336 — gives
+ * operators a one-shot way to spot daemon memory growth without tailing
+ * logs or attaching a debugger.
+ */
+async function daemonStats() {
+    // First check the daemon is even running — surface a friendlier message
+    // than a raw ECONNREFUSED if not.
+    const status = (0, daemon_1.getDaemonStatus)();
+    if (!status.running) {
+        out.warn('Daemon is not running — start it with `agent-tempo daemon start`');
+        process.exit(1);
+    }
+    const port = (0, port_file_1.readPortFile)();
+    if (port === null) {
+        out.error('Daemon port file not found at ~/.agent-tempo/daemon.port');
+        out.log(`  ${out.dim('The daemon may be from a pre-HTTP build. Restart it with `agent-tempo daemon stop && start`.')}`);
+        process.exit(1);
+    }
+    let body;
+    try {
+        body = await fetchHealth(port);
+    }
+    catch (err) {
+        out.error(`Failed to query daemon at http://127.0.0.1:${port}/v1/health: ${err instanceof Error ? err.message : err}`);
+        process.exit(1);
+    }
+    out.success(`Daemon stats (pid ${status.pid})`);
+    out.log(`  ${out.dim('Version:        ')}${typeof body.version === 'string' ? body.version : 'n/a'}`);
+    out.log(`  ${out.dim('Namespace:      ')}${typeof body.namespace === 'string' ? body.namespace : 'n/a'}`);
+    out.log(`  ${out.dim('Uptime:         ')}${formatUptime(body.uptimeMs)}`);
+    out.log(`  ${out.dim('Ensembles:      ')}${typeof body.ensembleCount === 'number' ? body.ensembleCount : 'n/a'}`);
+    out.log(`  ${out.dim('SSE subscribers:')}${typeof body.subscriberCount === 'number' ? ` ${body.subscriberCount}` : ' n/a'}`);
+    out.log('');
+    if (body.memory) {
+        out.log(`  ${out.dim('Memory (#336 diagnostic):')}`);
+        out.log(`    ${out.dim('RSS:           ')}${formatBytesAsMb(body.memory.rss)}`);
+        out.log(`    ${out.dim('Heap used:     ')}${formatBytesAsMb(body.memory.heapUsed)}`);
+        out.log(`    ${out.dim('Heap total:    ')}${formatBytesAsMb(body.memory.heapTotal)}`);
+        out.log(`    ${out.dim('External:      ')}${formatBytesAsMb(body.memory.external)}`);
+        out.log(`    ${out.dim('Array buffers: ')}${formatBytesAsMb(body.memory.arrayBuffers)}`);
+    }
+    else {
+        out.warn('Memory diagnostics not present in /v1/health response — daemon may be from a pre-#336 build.');
+    }
+}