@ouro.bot/cli 0.1.0-alpha.92 → 0.1.0-alpha.920

package/dist/heart/daemon/startup-tui.js

@@ -0,0 +1,339 @@
+"use strict";
+/**
+ * Startup TUI — real-time progress display for `ouro up`.
+ *
+ * Replaces the old `verifyDaemonAlive()` socket poll with a richer system
+ * that shows per-agent status, waits for stability, and reports degraded
+ * agents with actionable error information.
+ *
+ * Pure functions (`renderStartupProgress`, `assessStability`) are fully
+ * testable. The polling loop (`pollDaemonStartup`) uses dependency injection
+ * for all I/O.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assessStability = assessStability;
+exports.renderStartupProgress = renderStartupProgress;
+exports.renderWaitingForDaemon = renderWaitingForDaemon;
+exports.pollDaemonStartup = pollDaemonStartup;
+exports.defaultIsProcessAlive = defaultIsProcessAlive;
+const cli_render_1 = require("./cli-render");
+const runtime_1 = require("../../nerves/runtime");
+const terminal_ui_1 = require("./terminal-ui");
+// ── Constants ──
+const SPINNER_FRAMES = "⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏";
+const STABILITY_THRESHOLD_MS = 5_000;
+const POLL_INTERVAL_MS = 500;
+const STARTUP_POLL_TIMEOUT_MS = 180_000;
+// ── ANSI helpers ──
+const RESET = "\x1b[0m";
+const BOLD = "\x1b[1m";
+const DIM = "\x1b[2m";
+const GREEN = "\x1b[38;2;46;204;64m";
+const RED = "\x1b[38;2;231;76;60m";
+const YELLOW = "\x1b[38;2;230;190;50m";
+// ── Pure functions ──
+/**
+ * Assess whether all workers have reached a terminal state (stable or crashed).
+ * A worker is "stable" when status is "running" and it has been running for
+ * at least STABILITY_THRESHOLD_MS. A worker is "definitively failed" when
+ * status is "crashed". All other states are unresolved.
+ */
+function assessStability(payload, now) {
+    const stable = [];
+    const degraded = [];
+    let allResolved = true;
+    for (const worker of payload.workers) {
+        if (isPassiveStoppedWorker(worker)) {
+            continue;
+        }
+        else if (worker.status === "crashed") {
+            degraded.push({
+                agent: worker.agent,
+                errorReason: worker.errorReason ?? "unknown error",
+                fixHint: worker.fixHint ?? "check daemon logs",
+            });
+        }
+        else if (worker.status === "running" && worker.startedAt !== null) {
+            const startedMs = new Date(worker.startedAt).getTime();
+            const runningMs = now - startedMs;
+            if (runningMs >= STABILITY_THRESHOLD_MS) {
+                stable.push(worker.agent);
+            }
+            else {
+                allResolved = false;
+            }
+        }
+        else {
+            // starting, stopped, or running with null startedAt — not yet resolved
+            allResolved = false;
+        }
+    }
+    return { resolved: allResolved, stable, degraded };
+}
+/**
+ * Build an ANSI string for in-place terminal display during polling.
+ * Uses cursor-up and line-clear escapes to overwrite previous output.
+ */
+function renderStartupProgress(payload, elapsed, prevLineCount = 0, options = {}) {
+    const isTTY = options.isTTY ?? true;
+    const frameIndex = Math.floor(elapsed / 100) % SPINNER_FRAMES.length;
+    const spinner = SPINNER_FRAMES[frameIndex];
+    const lines = [];
+    const elapsedSec = (elapsed / 1000).toFixed(1);
+    lines.push(isTTY
+        ? `${spinner} ${BOLD}waiting for agents${RESET} ${DIM}(${elapsedSec}s)${RESET}`
+        : `${spinner} waiting for agents (${elapsedSec}s)`);
+    for (const worker of payload.workers) {
+        const statusText = isTTY ? colorStatus(worker.status) : worker.status;
+        lines.push(`  ${worker.agent}/${worker.worker}: ${statusText}`);
+    }
+    return renderStartupLines(lines, prevLineCount, isTTY);
+}
+/**
+ * Render a pre-socket status line showing what the daemon is doing.
+ */
+function renderWaitingForDaemon(elapsed, latestEvent, prevLineCount = 0, options = {}) {
+    const isTTY = options.isTTY ?? true;
+    const elapsedSec = (elapsed / 1000).toFixed(1);
+    const frameIndex = Math.floor(elapsed / 100) % SPINNER_FRAMES.length;
+    const spinner = SPINNER_FRAMES[frameIndex];
+    const lines = [];
+    lines.push(isTTY
+        ? `${spinner} ${BOLD}starting background service${RESET} ${DIM}(${elapsedSec}s)${RESET}`
+        : `${spinner} starting background service (${elapsedSec}s)`);
+    if (latestEvent) {
+        const detail = `latest daemon event: ${latestEvent}`;
+        lines.push(isTTY ? `  ${DIM}${detail}${RESET}` : `  ${detail}`);
+    }
+    return renderStartupLines(lines, prevLineCount, isTTY);
+}
+/**
+ * Render the final summary after all agents have resolved.
+ */
+function renderFinalSummary(result, isTTY) {
+    const lines = [];
+    for (const agent of result.stable) {
+        lines.push(isTTY ? `  ${GREEN}\u2713${RESET} ${agent}: ${GREEN}stable${RESET}` : `  \u2713 ${agent}: stable`);
+    }
+    for (const d of result.degraded) {
+        lines.push(isTTY ? `  ${RED}\u2717${RESET} ${d.agent}: ${RED}degraded${RESET}` : `  \u2717 ${d.agent}: degraded`);
+        if (d.errorReason !== "unknown error") {
+            lines.push(isTTY ? `    ${DIM}error: ${d.errorReason}${RESET}` : `    error: ${d.errorReason}`);
+        }
+        if (d.fixHint !== "check daemon logs") {
+            lines.push(isTTY ? `    ${DIM}fix:   ${d.fixHint}${RESET}` : `    fix:   ${d.fixHint}`);
+        }
+    }
+    if (!isTTY)
+        return lines.join("\n") + "\n";
+    return lines.map((line) => `\x1b[2K${line}`).join("\n") + "\n";
+}
+// ── Polling loop ──
+/**
+ * Poll the daemon's status socket until all agents are stable or definitively
+ * failed, rendering real-time progress to the terminal.
+ *
+ * Detects daemon process death: if the spawned PID is no longer alive and the
+ * socket never came up, reports the failure immediately instead of spinning.
+ */
+async function pollDaemonStartup(deps) {
+    const startTime = deps.now();
+    const maxWaitMs = deps.maxWaitMs ?? STARTUP_POLL_TIMEOUT_MS;
+    let prevLineCount = 0;
+    const isTTY = deps.isTTY ?? true;
+    const isAlive = deps.isProcessAlive ?? defaultIsProcessAlive;
+    const shouldRender = deps.render ?? true;
+    let lastProgress = null;
+    const reportProgress = (message) => {
+        if (!deps.onProgress || message === lastProgress)
+            return;
+        lastProgress = message;
+        deps.onProgress(message);
+    };
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.startup_poll_start",
+        message: "beginning startup stability polling",
+        meta: { socketPath: deps.socketPath, daemonPid: deps.daemonPid },
+    });
+    while (true) {
+        const now = deps.now();
+        const elapsed = now - startTime;
+        let payload = null;
+        try {
+            const response = await deps.sendCommand(deps.socketPath, { kind: "daemon.status" });
+            payload = (0, cli_render_1.parseStatusPayload)(response.data);
+        }
+        catch {
+            // Socket not yet available — check if the daemon process is still alive
+            if (deps.daemonPid !== null && !isAlive(deps.daemonPid)) {
+                const latestEvent = deps.readLatestDaemonEvent?.() ?? null;
+                const errorMsg = latestEvent ?? "daemon process died during startup";
+                (0, runtime_1.emitNervesEvent)({
+                    level: "error",
+                    component: "daemon",
+                    event: "daemon.startup_process_died",
+                    message: "daemon process died before socket came up",
+                    meta: { pid: deps.daemonPid, lastEvent: latestEvent },
+                });
+                // Clear the waiting line
+                if (isTTY && prevLineCount > 0) {
+                    let clear = `\x1b[${prevLineCount}A`;
+                    for (let i = 0; i < prevLineCount; i++)
+                        clear += `\x1b[2K\n`;
+                    deps.writeRaw(clear);
+                }
+                return {
+                    stable: [],
+                    degraded: [{ agent: "daemon", errorReason: errorMsg, fixHint: "check daemon logs or run `ouro doctor`" }],
+                };
+            }
+            const latestEvent = deps.readLatestDaemonEvent?.() ?? null;
+            if (elapsed >= maxWaitMs) {
+                const errorMsg = latestEvent
+                    ? `daemon did not answer within ${(maxWaitMs / 1000).toFixed(0)}s; latest event: ${latestEvent}`
+                    : `daemon did not answer within ${(maxWaitMs / 1000).toFixed(0)}s`;
+                const result = {
+                    stable: [],
+                    degraded: [{ agent: "daemon", errorReason: errorMsg, fixHint: "check daemon logs or run `ouro doctor`" }],
+                };
+                if (shouldRender) {
+                    const summary = renderFinalSummary(result, isTTY);
+                    deps.writeRaw(summary);
+                }
+                (0, runtime_1.emitNervesEvent)({
+                    level: "error",
+                    component: "daemon",
+                    event: "daemon.startup_poll_timeout",
+                    message: "daemon startup polling timed out before the daemon answered",
+                    meta: { socketPath: deps.socketPath, daemonPid: deps.daemonPid, elapsedMs: elapsed, maxWaitMs, lastEvent: latestEvent },
+                });
+                return result;
+            }
+            // Show what the daemon is doing from its log
+            reportProgress([
+                "waiting for Ouro to answer",
+                latestEvent ? `- latest daemon event: ${latestEvent}` : "- background service is still starting",
+            ].join("\n"));
+            if (shouldRender) {
+                const output = renderWaitingForDaemon(elapsed, latestEvent, prevLineCount, { isTTY });
+                deps.writeRaw(output);
+                prevLineCount = latestEvent ? 2 : 1;
+            }
+        }
+        if (payload) {
+            reportProgress(formatStartupProgressDetail(payload));
+            if (shouldRender) {
+                const output = renderStartupProgress(payload, elapsed, prevLineCount, { isTTY });
+                deps.writeRaw(output);
+                prevLineCount = payload.workers.length + 1;
+            }
+            const assessment = assessStability(payload, now);
+            if (assessment.resolved) {
+                const result = {
+                    stable: assessment.stable,
+                    degraded: assessment.degraded,
+                };
+                if (shouldRender) {
+                    const summary = renderFinalSummary(result, isTTY);
+                    deps.writeRaw(summary);
+                }
+                (0, runtime_1.emitNervesEvent)({
+                    component: "daemon",
+                    event: "daemon.startup_poll_end",
+                    message: "startup polling complete",
+                    meta: {
+                        stableCount: result.stable.length,
+                        degradedCount: result.degraded.length,
+                        elapsedMs: elapsed,
+                    },
+                });
+                return result;
+            }
+            if (elapsed >= maxWaitMs) {
+                const result = buildTimedOutStartupResult(payload, assessment, maxWaitMs);
+                if (shouldRender) {
+                    const summary = renderFinalSummary(result, isTTY);
+                    deps.writeRaw(summary);
+                }
+                (0, runtime_1.emitNervesEvent)({
+                    level: "error",
+                    component: "daemon",
+                    event: "daemon.startup_poll_timeout",
+                    message: "daemon startup polling timed out with unresolved workers",
+                    meta: {
+                        socketPath: deps.socketPath,
+                        daemonPid: deps.daemonPid,
+                        elapsedMs: elapsed,
+                        maxWaitMs,
+                        stableCount: result.stable.length,
+                        degradedCount: result.degraded.length,
+                    },
+                });
+                return result;
+            }
+        }
+        await deps.sleep(POLL_INTERVAL_MS);
+    }
+}
+function buildTimedOutStartupResult(payload, assessment, maxWaitMs) {
+    const stable = [...assessment.stable];
+    const degraded = [...assessment.degraded];
+    const stableAgents = new Set(stable);
+    const degradedAgents = new Set();
+    for (const worker of degraded)
+        degradedAgents.add(worker.agent);
+    const seconds = (maxWaitMs / 1000).toFixed(0);
+    for (const worker of payload.workers) {
+        if (isPassiveStoppedWorker(worker))
+            continue;
+        if (stableAgents.has(worker.agent) || degradedAgents.has(worker.agent))
+            continue;
+        degraded.push({
+            agent: worker.agent,
+            errorReason: `startup timed out after ${seconds}s while worker was ${worker.status}`,
+            fixHint: worker.errorReason
+                ? worker.fixHint ?? "check daemon logs"
+                : "run `ouro status` or `ouro doctor` for current worker details; the daemon is still answering",
+        });
+    }
+    return { stable, degraded };
+}
+function isPassiveStoppedWorker(worker) {
+    return worker.autoStart === false && worker.status === "stopped";
+}
+function formatStartupWorkerLine(payload) {
+    const base = `- ${payload.agent}/${payload.worker}: ${payload.status}`;
+    if (payload.status === "crashed" && payload.errorReason) {
+        return `${base} (${payload.errorReason})`;
+    }
+    return base;
+}
+function formatStartupProgressDetail(payload) {
+    if (payload.workers.length === 0)
+        return "Ouro answered";
+    return [
+        "Ouro answered",
+        ...payload.workers.map((worker) => formatStartupWorkerLine(worker)),
+    ].join("\n");
+}
+function colorStatus(status) {
+    const statusColor = status === "running" ? GREEN
+        : status === "crashed" ? RED
+            : YELLOW;
+    return `${statusColor}${status}${RESET}`;
+}
+function renderStartupLines(lines, prevLineCount, isTTY) {
+    return (0, terminal_ui_1.renderOverwriteFrame)(lines, prevLineCount, isTTY);
+}
+/* v8 ignore start -- process liveness check: uses real process.kill(0), tested via deployment @preserve */
+function defaultIsProcessAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/* v8 ignore stop */

package/dist/heart/daemon/supercronic-supervisor.js

@@ -0,0 +1,282 @@
+"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.SupercronicSupervisor = void 0;
+const node_child_process_1 = require("node:child_process");
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const runtime_1 = require("../../nerves/runtime");
+const NAMESPACE = /^(?:habit|await):[a-z0-9](?:[a-z0-9._-]{0,62})$/u;
+const SAFE_JOB = /^[^\r\n\0]+$/u;
+const RESTART_DELAYS_MS = [1_000, 5_000, 15_000];
+function defaultDurableWrite(filePath, content, mode) {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    const temporary = `${filePath}.${process.pid}.tmp`;
+    const fd = fs.openSync(temporary, "w", mode);
+    try {
+        fs.writeFileSync(fd, content, "utf8");
+        fs.fsyncSync(fd);
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+    fs.chmodSync(temporary, mode);
+    fs.renameSync(temporary, filePath);
+    const directory = fs.openSync(path.dirname(filePath), "r");
+    try {
+        fs.fsyncSync(directory);
+    }
+    finally {
+        fs.closeSync(directory);
+    }
+}
+function defaultDeps() {
+    return {
+        mkdir: (target) => fs.mkdirSync(target, { recursive: true }),
+        readFile: (target) => fs.readFileSync(target, "utf8"),
+        durableWrite: defaultDurableWrite,
+        removeFile: (target) => { try {
+            fs.unlinkSync(target);
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+        } },
+        processAlive: (pid) => { try {
+            process.kill(pid, 0);
+            return true;
+        }
+        catch {
+            return false;
+        } },
+        processCommand: (pid) => {
+            try {
+                return fs.readFileSync(`/proc/${pid}/cmdline`, "utf8").split("\0").filter(Boolean).join(" ");
+            }
+            catch {
+                return null;
+            }
+        },
+        spawn: (binary, args) => (0, node_child_process_1.spawn)(binary, args, { stdio: ["ignore", "inherit", "inherit"] }),
+        setTimer: (callback, delayMs) => setTimeout(callback, delayMs),
+        clearTimer: (timer) => clearTimeout(timer),
+    };
+}
+class SupercronicSupervisor {
+    deps;
+    binaryPath;
+    crontabPath;
+    pidPath;
+    onFatal;
+    manifests = new Map();
+    child = null;
+    restartTimer = null;
+    restartCount = 0;
+    stopping = false;
+    constructor(options) {
+        this.binaryPath = options.binaryPath;
+        this.crontabPath = options.crontabPath;
+        this.pidPath = options.pidPath ?? `${options.crontabPath}.pid`;
+        this.deps = options.deps ?? defaultDeps();
+        this.onFatal = options.onFatal ?? ((error) => { throw error; });
+    }
+    start() {
+        if (this.child || this.restartTimer)
+            return;
+        this.deps.mkdir(path.dirname(this.crontabPath));
+        const priorPid = this.readPriorPid();
+        if (priorPid !== null && this.isPriorSupercronic(priorPid))
+            throw new Error(`Supercronic is already running with PID ${priorPid}`);
+        if (priorPid !== null)
+            this.deps.removeFile(this.pidPath);
+        this.render();
+        this.stopping = false;
+        this.spawnChild();
+        (0, runtime_1.emitNervesEvent)({ component: "daemon", event: "daemon.supercronic_state", message: "Supercronic supervisor started", meta: { crontabPath: this.crontabPath } });
+    }
+    namespace(namespace) {
+        if (!NAMESPACE.test(namespace))
+            throw new Error(`invalid Supercronic namespace: ${namespace}`);
+        return {
+            sync: (jobs) => {
+                const next = new Map();
+                for (const job of jobs) {
+                    if (!SAFE_JOB.test(job.id) || !SAFE_JOB.test(job.taskId) || !SAFE_JOB.test(job.schedule) || !SAFE_JOB.test(job.command)) {
+                        throw new Error("invalid Supercronic job");
+                    }
+                    if (next.has(job.id))
+                        throw new Error(`duplicate Supercronic job: ${job.id}`);
+                    next.set(job.id, structuredClone(job));
+                }
+                this.manifests.set(namespace, next);
+                this.render();
+                (0, runtime_1.emitNervesEvent)({ component: "daemon", event: "daemon.supercronic_state", message: "Supercronic manifest synchronized", meta: { namespace, jobCount: jobs.length } });
+            },
+            removeAll: () => {
+                this.manifests.delete(namespace);
+                this.render();
+            },
+            list: () => [...(this.manifests.get(namespace)?.values() ?? [])].map((job) => job.taskId).sort(),
+        };
+    }
+    verifyNamespace(namespace, jobs) {
+        if (!this.isHealthy())
+            return false;
+        const manifest = this.manifests.get(namespace);
+        if (!manifest || manifest.size !== jobs.length)
+            return false;
+        for (const job of jobs) {
+            const existing = manifest.get(job.id);
+            if (!existing || existing.schedule !== job.schedule || existing.command !== job.command)
+                return false;
+        }
+        try {
+            return this.deps.readFile(this.crontabPath) === this.renderedContent();
+        }
+        catch {
+            return false;
+        }
+    }
+    verificationOutput() {
+        if (!this.isHealthy())
+            return "";
+        const expected = this.renderedContent();
+        try {
+            return this.deps.readFile(this.crontabPath) === expected ? expected : "";
+        }
+        catch {
+            return "";
+        }
+    }
+    authenticatedSnapshot(namespace) {
+        if (!NAMESPACE.test(namespace))
+            throw new Error(`invalid Supercronic namespace: ${namespace}`);
+        if (!this.isHealthy() || typeof this.child?.pid !== "number")
+            throw new Error("Supercronic supervisor has no healthy child");
+        const manifest = this.manifests.get(namespace);
+        if (!manifest)
+            throw new Error(`Supercronic supervisor has no manifest for ${namespace}`);
+        const renderedCrontab = this.verificationOutput();
+        if (renderedCrontab.length === 0)
+            throw new Error("Supercronic supervisor crontab is not verified");
+        return {
+            schemaVersion: "supercronic-supervisor-snapshot-v1",
+            daemonPid: process.pid,
+            childCount: 1,
+            childPid: this.child.pid,
+            healthy: true,
+            binaryPath: this.binaryPath,
+            args: ["-split-logs", "-inotify", this.crontabPath],
+            crontabPath: this.crontabPath,
+            namespace,
+            manifest: [...manifest.values()].sort((left, right) => left.id.localeCompare(right.id)).map((job) => structuredClone(job)),
+            renderedCrontab,
+        };
+    }
+    isHealthy() {
+        return this.child !== null && typeof this.child.pid === "number" && this.deps.processAlive(this.child.pid);
+    }
+    async stop() {
+        this.stopping = true;
+        if (this.restartTimer)
+            this.deps.clearTimer(this.restartTimer);
+        this.restartTimer = null;
+        const child = this.child;
+        if (!child) {
+            this.deps.removeFile(this.pidPath);
+            return;
+        }
+        await new Promise((resolve) => {
+            let settled = false;
+            const finish = () => { if (settled)
+                return; settled = true; resolve(); };
+            child.once("exit", finish);
+            const timer = this.deps.setTimer(() => { child.kill("SIGKILL"); finish(); }, 10_000);
+            child.once("exit", () => this.deps.clearTimer(timer));
+            child.kill("SIGTERM");
+        });
+        this.child = null;
+        this.deps.removeFile(this.pidPath);
+        (0, runtime_1.emitNervesEvent)({ component: "daemon", event: "daemon.supercronic_state", message: "Supercronic supervisor stopped", meta: { crontabPath: this.crontabPath } });
+    }
+    readPriorPid() {
+        try {
+            const value = Number(this.deps.readFile(this.pidPath).trim());
+            return Number.isSafeInteger(value) && value > 0 ? value : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    isPriorSupercronic(pid) {
+        if (!this.deps.processAlive(pid))
+            return false;
+        return this.deps.processCommand(pid) === `${this.binaryPath} -split-logs -inotify ${this.crontabPath}`;
+    }
+    renderedContent() {
+        const lines = [];
+        for (const namespace of [...this.manifests.keys()].sort()) {
+            const jobs = [...this.manifests.get(namespace).values()].sort((left, right) => left.id.localeCompare(right.id));
+            for (const job of jobs)
+                lines.push(`# ouro:${namespace}:${job.id}`, `${job.schedule} ${job.command}`);
+        }
+        return lines.length > 0 ? `${lines.join("\n")}\n` : "";
+    }
+    render() {
+        this.deps.durableWrite(this.crontabPath, this.renderedContent(), 0o600);
+    }
+    spawnChild() {
+        const child = this.deps.spawn(this.binaryPath, ["-split-logs", "-inotify", this.crontabPath]);
+        if (!child.pid || child.pid <= 0)
+            throw new Error("Supercronic did not return a child PID");
+        this.child = child;
+        this.deps.durableWrite(this.pidPath, `${child.pid}\n`, 0o600);
+        child.once("exit", (code, signal) => {
+            if (this.child !== child)
+                return;
+            this.child = null;
+            this.deps.removeFile(this.pidPath);
+            if (this.stopping)
+                return;
+            if (this.restartCount >= RESTART_DELAYS_MS.length) {
+                this.onFatal(new Error(`Supercronic exited repeatedly (code=${String(code)}, signal=${String(signal)})`));
+                return;
+            }
+            const delay = RESTART_DELAYS_MS[this.restartCount++];
+            this.restartTimer = this.deps.setTimer(() => { this.restartTimer = null; this.spawnChild(); }, delay);
+        });
+    }
+}
+exports.SupercronicSupervisor = SupercronicSupervisor;