@ouro.bot/cli 0.1.0-alpha.62 → 0.1.0-alpha.637

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

@@ -0,0 +1,330 @@
+"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;
+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 (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 (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 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/task-scheduler.js

@@ -38,7 +38,8 @@ const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const identity_1 = require("../identity");
 const runtime_1 = require("../../nerves/runtime");
-const parser_1 = require("../../repertoire/tasks/parser");
+const frontmatter_1 = require("../../util/frontmatter");
+const cadence_1 = require("./cadence");
 function walkMarkdownFiles(root, readdirSync, existsSync, files) {
     if (!existsSync(root))
         return;
@@ -53,29 +54,6 @@ function walkMarkdownFiles(root, readdirSync, existsSync, files) {
         }
     }
 }
-function parseCadence(raw) {
-    if (typeof raw !== "string")
-        return null;
-    const value = raw.trim();
-    if (!value)
-        return null;
-    // Cron format (minute hour day month weekday)
-    if (/^\S+\s+\S+\s+\S+\s+\S+\s+\S+$/.test(value)) {
-        return value;
-    }
-    const cadenceMatch = /^(\d+)(m|h|d)$/.exec(value);
-    if (!cadenceMatch)
-        return null;
-    const interval = Number.parseInt(cadenceMatch[1], 10);
-    if (!Number.isFinite(interval) || interval <= 0)
-        return null;
-    const unit = cadenceMatch[2];
-    if (unit === "m")
-        return `*/${interval} * * * *`;
-    if (unit === "h")
-        return `0 */${interval} * * *`;
-    return `0 0 */${interval} * *`;
-}
 function parseScheduledAt(raw) {
     if (typeof raw !== "string")
         return null;
@@ -91,9 +69,70 @@ function parseScheduledAt(raw) {
     const month = date.getUTCMonth() + 1;
     return `${minute} ${hour} ${day} ${month} *`;
 }
-function removeRuntimeFrontmatter(frontmatter) {
-    const { _isCanonicalFilename, ...clean } = frontmatter;
-    return clean;
+/**
+ * Parse a task markdown file into the minimum scheduler-relevant projection.
+ * Inlines the previous `parseTaskFile` shape (only what the scheduler reads),
+ * so we don't depend on `src/repertoire/tasks/parser`. The shared
+ * `parseFrontmatter` util handles the YAML-ish frontmatter format.
+ */
+function parseSchedulerTask(content, filePath) {
+    (0, runtime_1.emitNervesEvent)({
+        event: "daemon.scheduler_task_parse",
+        component: "daemon",
+        message: "parsing scheduler task file",
+        meta: { filePath },
+    });
+    const lines = content.split(/\r?\n/);
+    if (lines[0]?.trim() !== "---") {
+        throw new Error("task file missing frontmatter");
+    }
+    const closing = lines.findIndex((line, index) => index > 0 && line.trim() === "---");
+    if (closing === -1) {
+        throw new Error("task file has unterminated frontmatter");
+    }
+    const rawFrontmatter = lines.slice(1, closing).join("\n");
+    const body = lines.slice(closing + 1).join("\n").trim();
+    const frontmatter = (0, frontmatter_1.parseFrontmatter)(rawFrontmatter);
+    const name = path.basename(filePath);
+    const stem = name.replace(/\.md$/i, "");
+    const rawStatus = typeof frontmatter.status === "string" ? frontmatter.status : "";
+    return { stem, status: rawStatus, frontmatter, body };
+}
+function formatFrontmatterValue(value) {
+    if (Array.isArray(value)) {
+        if (value.length === 0)
+            return ["[]"];
+        return ["", ...value.map((entry) => `- ${String(entry)}`)];
+    }
+    if (value === null)
+        return ["null"];
+    return [String(value)];
+}
+/**
+ * Render a frontmatter+body markdown file. Inlined from the previous
+ * `renderTaskFile` (in `src/repertoire/tasks/parser`) so the scheduler can
+ * update `lastRun` without depending on the task module.
+ */
+function renderSchedulerTask(frontmatter, body) {
+    const keys = Object.keys(frontmatter);
+    const lines = ["---"];
+    for (const key of keys) {
+        const rendered = formatFrontmatterValue(frontmatter[key]);
+        if (rendered.length === 1) {
+            lines.push(`${key}: ${rendered[0]}`);
+        }
+        else {
+            lines.push(`${key}:`);
+            for (const entry of rendered.slice(1)) {
+                lines.push(entry);
+            }
+        }
+    }
+    lines.push("---");
+    lines.push("");
+    lines.push(body.trim());
+    lines.push("");
+    return lines.join("\n");
 }
 class TaskDrivenScheduler {
     agents;
@@ -135,29 +174,68 @@ class TaskDrivenScheduler {
         await this.recordTaskRun(job.agent, job.taskId);
         return { ok: true, message: `triggered ${jobId}` };
     }
+    /**
+     * Discover scheduler-eligible task files across both surfaces:
+     * - legacy: `<bundle>/tasks/{one-shots,ongoing}/**\/*.md`
+     * - desk:   `<bundle>/desk/<track>/<task-slug>/task.md`
+     *
+     * Dual-read is intentional during the W6 transition: old harnesses still
+     * write to `tasks/`; new harnesses + agents write to `desk/`. The scheduler
+     * accepts both.
+     */
+    collectTaskFiles(agent) {
+        const bundleRoot = path.join(this.bundlesRoot, `${agent}.ouro`);
+        const files = [];
+        // Legacy `tasks/{one-shots,ongoing}/` collections.
+        const legacyRoot = path.join(bundleRoot, "tasks");
+        for (const collection of ["one-shots", "ongoing"]) {
+            walkMarkdownFiles(path.join(legacyRoot, collection), this.readdirSync, this.existsSync, files);
+        }
+        // New `desk/<track>/<task-slug>/task.md` shape.
+        const deskRoot = path.join(bundleRoot, "desk");
+        if (this.existsSync(deskRoot)) {
+            for (const trackEntry of this.readdirSync(deskRoot, { withFileTypes: true })) {
+                if (!trackEntry.isDirectory())
+                    continue;
+                if (trackEntry.name.startsWith("_") || trackEntry.name.startsWith("."))
+                    continue;
+                const trackDir = path.join(deskRoot, trackEntry.name);
+                for (const taskEntry of this.readdirSync(trackDir, { withFileTypes: true })) {
+                    if (!taskEntry.isDirectory())
+                        continue;
+                    if (taskEntry.name.startsWith("_") || taskEntry.name.startsWith("."))
+                        continue;
+                    const taskFile = path.join(trackDir, taskEntry.name, "task.md");
+                    if (this.existsSync(taskFile))
+                        files.push(taskFile);
+                }
+            }
+        }
+        return files;
+    }
     async reconcile() {
         const nextJobs = new Map();
         const nextTaskPaths = new Map();
         for (const agent of this.agents) {
-            const taskRoot = path.join(this.bundlesRoot, `${agent}.ouro`, "tasks");
-            const collections = ["one-shots", "ongoing", "habits"];
-            const files = [];
-            for (const collection of collections) {
-                walkMarkdownFiles(path.join(taskRoot, collection), this.readdirSync, this.existsSync, files);
-            }
+            const files = this.collectTaskFiles(agent);
             for (const filePath of files) {
                 let task;
                 try {
-                    task = (0, parser_1.parseTaskFile)(this.readFileSync(filePath, "utf-8"), filePath);
+                    task = parseSchedulerTask(this.readFileSync(filePath, "utf-8"), filePath);
                 }
                 catch {
                     continue;
                 }
-                const taskId = task.stem;
+                // Desk task files live at `desk/<track>/<task-slug>/task.md`, so the
+                // markdown basename is "task" — use the parent directory name as the
+                // stable slug. Legacy `tasks/<collection>/<stem>.md` keeps the
+                // filename stem.
+                const isDeskTask = path.basename(filePath) === "task.md";
+                const taskId = isDeskTask ? path.basename(path.dirname(filePath)) : task.stem;
                 nextTaskPaths.set(`${agent}:${taskId}`, filePath);
                 if (task.status === "done")
                     continue;
-                const cadence = parseCadence(task.frontmatter.cadence);
+                const cadence = (0, cadence_1.parseCadenceToCron)(task.frontmatter.cadence);
                 if (cadence) {
                     const id = `${agent}:${taskId}:cadence`;
                     nextJobs.set(id, {
@@ -212,18 +290,18 @@ class TaskDrivenScheduler {
         }
         let parsed;
         try {
-            parsed = (0, parser_1.parseTaskFile)(this.readFileSync(taskPath, "utf-8"), taskPath);
+            parsed = parseSchedulerTask(this.readFileSync(taskPath, "utf-8"), taskPath);
         }
         catch {
             return;
         }
         const now = this.nowIso();
-        const frontmatter = removeRuntimeFrontmatter(parsed.frontmatter);
+        const frontmatter = { ...parsed.frontmatter };
         frontmatter.lastRun = now;
         if (typeof frontmatter.updated === "string") {
             frontmatter.updated = now.slice(0, 10);
         }
-        this.writeFileSync(taskPath, (0, parser_1.renderTaskFile)(frontmatter, parsed.body), "utf-8");
+        this.writeFileSync(taskPath, renderSchedulerTask(frontmatter, parsed.body), "utf-8");
         for (const job of this.jobs.values()) {
             if (job.agent === agent && job.taskId === taskId) {
                 job.lastRun = now;