@ouro.bot/cli 0.1.0-alpha.51 → 0.1.0-alpha.511

package/dist/heart/daemon/cli-render-doctor.js

@@ -0,0 +1,57 @@
+"use strict";
+/**
+ * Rendering for `ouro doctor` output.
+ *
+ * Pure function: takes a DoctorResult and returns a formatted string
+ * with ANSI colors, category grouping, and a summary line.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatDoctorOutput = formatDoctorOutput;
+// ── ANSI color 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";
+const TEAL = "\x1b[38;2;78;201;176m";
+function green(text) { return `${GREEN}${text}${RESET}`; }
+function red(text) { return `${RED}${text}${RESET}`; }
+function yellow(text) { return `${YELLOW}${text}${RESET}`; }
+function bold(text) { return `${BOLD}${text}${RESET}`; }
+function dim(text) { return `${DIM}${text}${RESET}`; }
+function teal(text) { return `${TEAL}${text}${RESET}`; }
+// ── Check status symbols ──
+function statusSymbol(status) {
+    switch (status) {
+        case "pass": return green("\u2714"); // checkmark
+        case "warn": return yellow("\u26A0"); // warning
+        case "fail": return red("\u2718"); // X
+    }
+}
+// ── Main formatter ──
+function formatDoctorOutput(result) {
+    const lines = [];
+    lines.push("");
+    lines.push(`  ${bold("ouro doctor")}`);
+    lines.push("");
+    for (const category of result.categories) {
+        lines.push(`  ${teal("--")} ${bold(category.name)} ${teal("-".repeat(Math.max(1, 40 - category.name.length)))}`);
+        for (const check of category.checks) {
+            const symbol = statusSymbol(check.status);
+            const detail = check.detail ? `  ${dim(check.detail)}` : "";
+            lines.push(`    ${symbol} ${check.label}${detail}`);
+        }
+        lines.push("");
+    }
+    // Summary line
+    const { passed, warnings, failed } = result.summary;
+    const parts = [
+        green(`${passed} passed`),
+        yellow(`${warnings} warning${warnings === 1 ? "" : "s"}`),
+        red(`${failed} failed`),
+    ];
+    lines.push(`  ${parts.join(dim("  |  "))}`);
+    lines.push("");
+    return lines.join("\n");
+}

package/dist/heart/daemon/cli-render.js

@@ -0,0 +1,561 @@
+"use strict";
+/**
+ * CLI output formatting and rendering helpers.
+ *
+ * Pure functions that transform data into human-readable CLI output.
+ * No side effects — callers handle writing to stdout.
+ */
+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.parseStatusPayload = parseStatusPayload;
+exports.humanizeSenseName = humanizeSenseName;
+exports.formatTable = formatTable;
+exports.formatDaemonStatusOutput = formatDaemonStatusOutput;
+exports.formatVersionOutput = formatVersionOutput;
+exports.buildStoppedStatusPayload = buildStoppedStatusPayload;
+exports.daemonUnavailableStatusOutput = daemonUnavailableStatusOutput;
+exports.isDaemonUnavailableError = isDaemonUnavailableError;
+exports.formatMcpResponse = formatMcpResponse;
+const path = __importStar(require("path"));
+const runtime_metadata_1 = require("./runtime-metadata");
+const runtime_mode_1 = require("./runtime-mode");
+const identity_1 = require("../identity");
+const daemon_tombstone_1 = require("./daemon-tombstone");
+const daemon_health_1 = require("./daemon-health");
+const agent_discovery_1 = require("./agent-discovery");
+// ── Field extractors ──
+function stringField(value) {
+    return typeof value === "string" ? value : null;
+}
+function numberField(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function booleanField(value) {
+    return typeof value === "boolean" ? value : null;
+}
+// ── Parsers ──
+function parseStatusPayload(data) {
+    if (!data || typeof data !== "object" || Array.isArray(data))
+        return null;
+    const raw = data;
+    const overview = raw.overview;
+    const senses = raw.senses;
+    const workers = raw.workers;
+    const sync = raw.sync;
+    const agents = raw.agents;
+    const providers = raw.providers;
+    if (!overview || typeof overview !== "object" || Array.isArray(overview))
+        return null;
+    if (!Array.isArray(senses) || !Array.isArray(workers))
+        return null;
+    // sync, agents, and providers are optional for backward compatibility — older daemons may omit them
+    if (sync !== undefined && !Array.isArray(sync))
+        return null;
+    if (agents !== undefined && !Array.isArray(agents))
+        return null;
+    if (providers !== undefined && !Array.isArray(providers))
+        return null;
+    const parsedOverview = {
+        daemon: stringField(overview.daemon) ?? "unknown",
+        health: stringField(overview.health) ?? "unknown",
+        socketPath: stringField(overview.socketPath) ?? "unknown",
+        outlookUrl: stringField(overview.outlookUrl) ?? "unavailable",
+        version: stringField(overview.version) ?? "unknown",
+        lastUpdated: stringField(overview.lastUpdated) ?? "unknown",
+        repoRoot: stringField(overview.repoRoot) ?? "unknown",
+        configFingerprint: stringField(overview.configFingerprint) ?? "unknown",
+        workerCount: numberField(overview.workerCount) ?? 0,
+        senseCount: numberField(overview.senseCount) ?? 0,
+        entryPath: stringField(overview.entryPath) ?? "unknown",
+        mode: stringField(overview.mode) ?? "unknown",
+    };
+    const parsedSenses = senses.map((entry) => {
+        if (!entry || typeof entry !== "object" || Array.isArray(entry))
+            return null;
+        const row = entry;
+        const agent = stringField(row.agent);
+        const sense = stringField(row.sense);
+        const status = stringField(row.status);
+        const detail = stringField(row.detail);
+        const enabled = booleanField(row.enabled);
+        if (!agent || !sense || !status || detail === null || enabled === null)
+            return null;
+        return {
+            agent,
+            sense,
+            label: stringField(row.label) ?? undefined,
+            enabled,
+            status,
+            detail,
+        };
+    });
+    const parsedWorkers = workers.map((entry) => {
+        if (!entry || typeof entry !== "object" || Array.isArray(entry))
+            return null;
+        const row = entry;
+        const agent = stringField(row.agent);
+        const worker = stringField(row.worker);
+        const status = stringField(row.status);
+        const restartCount = numberField(row.restartCount);
+        const hasPid = Object.prototype.hasOwnProperty.call(row, "pid");
+        const pid = row.pid === null ? null : numberField(row.pid);
+        const pidInvalid = !hasPid || (row.pid !== null && pid === null);
+        if (!agent || !worker || !status || restartCount === null || pidInvalid)
+            return null;
+        return {
+            agent,
+            worker,
+            status,
+            pid,
+            restartCount,
+            lastExitCode: numberField(row.lastExitCode) ?? null,
+            lastSignal: stringField(row.lastSignal) ?? null,
+            startedAt: stringField(row.startedAt) ?? null,
+            errorReason: stringField(row.errorReason) ?? null,
+            fixHint: stringField(row.fixHint) ?? null,
+        };
+    });
+    const parsedSync = (sync ?? []).map((entry) => {
+        if (!entry || typeof entry !== "object" || Array.isArray(entry))
+            return null;
+        const row = entry;
+        const agent = stringField(row.agent);
+        const enabled = booleanField(row.enabled);
+        const remote = stringField(row.remote);
+        if (!agent || enabled === null || !remote)
+            return null;
+        const parsed = { agent, enabled, remote };
+        const remoteUrl = stringField(row.remoteUrl);
+        if (remoteUrl !== null)
+            parsed.remoteUrl = remoteUrl;
+        const gitInitialized = booleanField(row.gitInitialized);
+        if (gitInitialized !== null)
+            parsed.gitInitialized = gitInitialized;
+        return parsed;
+    });
+    const parsedAgents = (agents ?? []).map((entry) => {
+        if (!entry || typeof entry !== "object" || Array.isArray(entry))
+            return null;
+        const row = entry;
+        const name = stringField(row.name);
+        const enabled = booleanField(row.enabled);
+        if (!name || enabled === null)
+            return null;
+        return { name, enabled };
+    });
+    const parsedProviders = (providers ?? []).map((entry) => {
+        if (!entry || typeof entry !== "object" || Array.isArray(entry))
+            return null;
+        const row = entry;
+        const agent = stringField(row.agent);
+        const lane = stringField(row.lane);
+        const provider = stringField(row.provider);
+        const model = stringField(row.model);
+        const source = stringField(row.source);
+        const readiness = stringField(row.readiness);
+        const credential = stringField(row.credential);
+        if (!agent || !lane || !provider || !model || !source || !readiness || !credential)
+            return null;
+        const parsed = {
+            agent,
+            lane,
+            provider,
+            model,
+            source,
+            readiness,
+            credential,
+        };
+        const detail = stringField(row.detail);
+        if (detail !== null)
+            parsed.detail = detail;
+        return parsed;
+    });
+    if (parsedSenses.some((row) => row === null) ||
+        parsedWorkers.some((row) => row === null) ||
+        parsedSync.some((row) => row === null) ||
+        parsedAgents.some((row) => row === null) ||
+        parsedProviders.some((row) => row === null))
+        return null;
+    return {
+        overview: parsedOverview,
+        senses: parsedSenses,
+        workers: parsedWorkers,
+        sync: parsedSync,
+        agents: parsedAgents,
+        providers: parsedProviders,
+    };
+}
+// ── ANSI color helpers (private) ──
+const RESET = "\x1b[0m";
+const BOLD = "\x1b[1m";
+const DIM = "\x1b[2m";
+const TEAL = "\x1b[38;2;78;201;176m";
+const GREEN = "\x1b[38;2;46;204;64m";
+const RED = "\x1b[38;2;231;76;60m";
+const YELLOW = "\x1b[38;2;230;190;50m";
+/* v8 ignore start -- cosmetic ANSI wrappers @preserve */
+function teal(text) { return `${TEAL}${text}${RESET}`; }
+function green(text) { return `${GREEN}${text}${RESET}`; }
+function red(text) { return `${RED}${text}${RESET}`; }
+function yellow(text) { return `${YELLOW}${text}${RESET}`; }
+function bold(text) { return `${BOLD}${text}${RESET}`; }
+function dim(text) { return `${DIM}${text}${RESET}`; }
+/* v8 ignore stop */
+/* v8 ignore start -- cosmetic display: status dot color mapping tested visually @preserve */
+function statusDot(status) {
+    switch (status) {
+        case "running":
+        case "ok":
+        case "interactive":
+        case "enabled":
+        case "ready":
+            return green("●");
+        case "crashed":
+        case "warn":
+        case "error":
+        case "failed":
+            return red("●");
+        case "needs_config":
+        case "not_attached":
+        case "stale":
+            return yellow("●");
+        case "disabled":
+        case "stopped":
+            return dim("○");
+        default:
+            return dim("●");
+    }
+}
+/* v8 ignore stop */
+// ── Formatters ──
+function humanizeSenseName(sense, label) {
+    if (label)
+        return label;
+    if (sense === "cli")
+        return "CLI";
+    if (sense === "bluebubbles")
+        return "BlueBubbles";
+    if (sense === "teams")
+        return "Teams";
+    return sense;
+}
+/* v8 ignore start -- utility formatter; retained for non-status table output @preserve */
+function formatTable(headers, rows) {
+    const widths = headers.map((header, index) => Math.max(header.length, ...rows.map((row) => row[index].length)));
+    const renderRow = (row) => `| ${row.map((cell, index) => (index === row.length - 1
+        ? cell
+        : cell.padEnd(widths[index]))).join(" | ")} |`;
+    const divider = `|-${widths.map((width) => "-".repeat(width)).join("-|-")}-|`;
+    return [
+        renderRow(headers),
+        divider,
+        ...rows.map(renderRow),
+    ].join("\n");
+}
+/* v8 ignore stop */
+function formatDaemonStatusOutput(response, fallback) {
+    const payload = parseStatusPayload(response.data);
+    if (!payload)
+        return fallback;
+    const ov = payload.overview;
+    const lines = [];
+    // ── Header banner ──
+    const modeTag = ov.mode === "dev" ? "dev" : "";
+    const daemonStatus = ov.daemon === "running" ? green("●") + "  " + bold("running") : red("●") + "  " + bold(ov.daemon);
+    const modeStr = modeTag ? `  ${dim(`(${modeTag})`)}` : "";
+    const bannerContent = `  ${bold(ov.version)}  ${daemonStatus}${modeStr}  `;
+    // Measure raw content width (strip ANSI for width calc)
+    const rawBanner = bannerContent.replace(/\x1b\[[0-9;]*m/g, "");
+    const bannerWidth = Math.max(rawBanner.length, 42);
+    const titleLabel = " ouroboros daemon ";
+    const topRightPad = Math.max(0, bannerWidth - titleLabel.length - 2);
+    lines.push(`  ${teal("╭─")}${teal(titleLabel)}${teal("─".repeat(topRightPad))}${teal("╮")}`);
+    lines.push(`  ${teal("│")}${bannerContent}${" ".repeat(Math.max(0, bannerWidth - rawBanner.length))}${teal("│")}`);
+    lines.push(`  ${teal("╰")}${teal("─".repeat(bannerWidth))}${teal("╯")}`);
+    lines.push("");
+    // ── Key-value overview ──
+    const kvLine = (label, value) => `  ${teal(label.padEnd(11))} ${value}`;
+    lines.push(kvLine("Socket", ov.socketPath));
+    lines.push(kvLine("Mailbox", ov.outlookUrl));
+    lines.push(kvLine("Health", `${statusDot(ov.health)} ${ov.health}`));
+    lines.push(kvLine("Updated", ov.lastUpdated));
+    lines.push("");
+    // ── Agents ──
+    // Every discovered bundle, including disabled ones. The Senses/Workers/
+    // Git Sync sections below only show enabled bundles, so without this
+    // section disabled agents would be invisible in `ouro status`.
+    if (payload.agents.length > 0) {
+        lines.push(`  ${teal("──")} ${bold("Agents")} ${teal("─".repeat(37))}`);
+        const agentNameWidth = Math.max(12, ...payload.agents.map((r) => r.name.length));
+        for (const row of payload.agents) {
+            const name = row.name.padEnd(agentNameWidth);
+            const dot = row.enabled ? green("●") : dim("○");
+            const stateText = row.enabled ? "enabled " : "disabled";
+            lines.push(`    ${name} ${dot} ${stateText}`);
+        }
+        lines.push("");
+    }
+    // ── Providers ──
+    if (payload.providers.length > 0) {
+        lines.push(`  ${teal("──")} ${bold("Providers")} ${teal("─".repeat(34))}`);
+        const agentLaneWidth = Math.max(16, ...payload.providers.map((r) => `${r.agent} ${r.lane}`.length));
+        for (const row of payload.providers) {
+            const agentLane = `${row.agent} ${row.lane}`.padEnd(agentLaneWidth);
+            const model = `${row.provider} / ${row.model}`;
+            const detail = [row.readiness, row.detail, row.source, row.credential].filter(Boolean).join("; ");
+            lines.push(`    ${agentLane} ${statusDot(row.readiness)} ${model}  ${dim(detail)}`);
+        }
+        lines.push("");
+    }
+    // ── Senses ──
+    if (payload.senses.length > 0) {
+        lines.push(`  ${teal("──")} ${bold("Senses")} ${teal("─".repeat(37))}`);
+        // Group senses by agent
+        const sensesByAgent = new Map();
+        for (const row of payload.senses) {
+            const list = sensesByAgent.get(row.agent) ?? [];
+            list.push(row);
+            sensesByAgent.set(row.agent, list);
+        }
+        // Calculate column widths for alignment
+        const allSenseNames = payload.senses.map((r) => humanizeSenseName(r.sense, r.label));
+        const nameWidth = Math.max(12, ...allSenseNames.map((n) => n.length));
+        const allStatuses = payload.senses.map((r) => r.status);
+        const statusWidth = Math.max(10, ...allStatuses.map((s) => s.length));
+        for (const [agent, rows] of sensesByAgent) {
+            lines.push(`  ${bold(agent)}`);
+            for (const row of rows) {
+                const name = humanizeSenseName(row.sense, row.label).padEnd(nameWidth);
+                const dot = row.enabled ? statusDot(row.status) : dim("○");
+                const statusText = (row.enabled ? row.status : "disabled").padEnd(statusWidth);
+                lines.push(`    ${name} ${dot} ${statusText}  ${dim(row.detail)}`);
+            }
+        }
+        lines.push("");
+    }
+    // ── Workers ──
+    if (payload.workers.length > 0) {
+        lines.push(`  ${teal("──")} ${bold("Workers")} ${teal("─".repeat(36))}`);
+        // Group workers by agent
+        const workersByAgent = new Map();
+        for (const row of payload.workers) {
+            const list = workersByAgent.get(row.agent) ?? [];
+            list.push(row);
+            workersByAgent.set(row.agent, list);
+        }
+        const allWorkerNames = payload.workers.map((r) => r.worker);
+        const workerNameWidth = Math.max(12, ...allWorkerNames.map((n) => n.length));
+        for (const [agent, rows] of workersByAgent) {
+            lines.push(`  ${bold(agent)}`);
+            for (const row of rows) {
+                const name = row.worker.padEnd(workerNameWidth);
+                const dot = statusDot(row.status);
+                const pidStr = row.pid !== null ? `pid ${row.pid}` : "";
+                const restartStr = `restarts: ${row.restartCount}`;
+                /* v8 ignore start — exit info branches tested via daemon-crash-context; v8 misreports conditional chains @preserve */
+                let exitStr = "";
+                if (row.lastExitCode !== null)
+                    exitStr = `exit=${row.lastExitCode}`;
+                if (row.lastSignal !== null)
+                    exitStr = row.lastExitCode !== null ? `exit=${row.lastExitCode} sig=${row.lastSignal}` : `sig=${row.lastSignal}`;
+                /* v8 ignore stop */
+                const details = [pidStr, restartStr, exitStr].filter(Boolean).join("  ");
+                lines.push(`    ${name} ${dot} ${row.status.padEnd(10)}  ${dim(details)}`);
+                if (row.errorReason) {
+                    lines.push(`      ${dim(`error: ${row.errorReason}`)}`);
+                }
+                if (row.fixHint) {
+                    lines.push(`      ${dim(`fix:   ${row.fixHint}`)}`);
+                }
+            }
+        }
+        lines.push("");
+    }
+    // ── Git Sync (per agent) ──
+    if (payload.sync.length > 0) {
+        lines.push(`  ${teal("──")} ${bold("Git Sync")} ${teal("─".repeat(35))}`);
+        const agentNameWidth = Math.max(12, ...payload.sync.map((r) => r.agent.length));
+        for (const row of payload.sync) {
+            const name = row.agent.padEnd(agentNameWidth);
+            // Three states for enabled rows: error (not a repo), ok (remote URL), ok (local only).
+            // Disabled rows show the usual dim dot + "disabled".
+            let dot;
+            let stateText;
+            let detail;
+            if (!row.enabled) {
+                dot = dim("○");
+                stateText = "disabled".padEnd(10);
+                detail = "";
+            }
+            else if (row.gitInitialized === false) {
+                dot = red("●");
+                stateText = "error   ".padEnd(10);
+                detail = "not a git repo — run `git init` to enable sync";
+            }
+            else if (row.remoteUrl !== undefined) {
+                dot = green("●");
+                stateText = "enabled ".padEnd(10);
+                detail = `${row.remote} → ${row.remoteUrl}`;
+            }
+            else {
+                dot = green("●");
+                stateText = "enabled ".padEnd(10);
+                detail = "local only";
+            }
+            lines.push(`    ${name} ${dot} ${stateText}  ${dim(detail)}`);
+        }
+        lines.push("");
+    }
+    return lines.join("\n");
+}
+function formatVersionOutput() {
+    const version = (0, runtime_metadata_1.getRuntimeMetadata)().version;
+    const mode = (0, runtime_mode_1.detectRuntimeMode)((0, identity_1.getRepoRoot)());
+    /* v8 ignore start — cosmetic display toggle; dev mode always true in test env */
+    return mode === "dev" ? `${version} (dev)` : version;
+    /* v8 ignore stop */
+}
+function buildStoppedStatusPayload(socketPath, syncRows = [], agentRows = []) {
+    const metadata = (0, runtime_metadata_1.getRuntimeMetadata)();
+    const repoRoot = (0, identity_1.getRepoRoot)();
+    return {
+        overview: {
+            daemon: "stopped",
+            health: "warn",
+            socketPath,
+            outlookUrl: "unavailable",
+            version: metadata.version,
+            lastUpdated: metadata.lastUpdated,
+            repoRoot: metadata.repoRoot,
+            configFingerprint: metadata.configFingerprint,
+            workerCount: 0,
+            senseCount: 0,
+            entryPath: path.join(repoRoot, "dist", "heart", "daemon", "daemon-entry.js"),
+            mode: (0, runtime_mode_1.detectRuntimeMode)(repoRoot),
+        },
+        senses: [],
+        workers: [],
+        sync: syncRows,
+        agents: agentRows,
+        providers: [],
+    };
+}
+function daemonUnavailableStatusOutput(socketPath, healthFilePath) {
+    // Read per-agent sync config and bundle list from disk so the user still
+    // sees them when the daemon is down. Best-effort: any fs error returns []
+    // and the corresponding section is omitted.
+    let syncRows = [];
+    let agentRows = [];
+    try {
+        syncRows = (0, agent_discovery_1.listBundleSyncRows)();
+    }
+    catch {
+        // listBundleSyncRows already swallows fs errors internally; this catch is a defensive
+        // safety net for environments where the fs module itself is partially mocked.
+    }
+    try {
+        agentRows = (0, agent_discovery_1.listAllBundleAgents)();
+    }
+    catch {
+        // Same defensive safety net for the bundle list.
+    }
+    /* v8 ignore start — tombstone read tested in daemon-status-tombstone.test; branch misreported @preserve */
+    const tombstone = (0, daemon_tombstone_1.readDaemonTombstone)();
+    const deathLine = tombstone
+        ? `Last death: ${tombstone.timestamp} -- ${tombstone.reason}: ${tombstone.message}`
+        : null;
+    /* v8 ignore stop */
+    const lines = [
+        formatDaemonStatusOutput({
+            ok: true,
+            summary: "daemon not running",
+            data: buildStoppedStatusPayload(socketPath, syncRows, agentRows),
+        }, "daemon not running"),
+        "",
+    ];
+    /* v8 ignore start — tombstone presence requires real daemon crash @preserve */
+    if (deathLine) {
+        lines.push(deathLine);
+        lines.push("");
+        /* v8 ignore stop */
+    }
+    // Read health file for last-known state (best-effort)
+    const resolvedHealthPath = healthFilePath ?? (0, daemon_health_1.getDefaultHealthPath)();
+    const health = (0, daemon_health_1.readHealth)(resolvedHealthPath);
+    if (health) {
+        lines.push(`Last known status: ${health.status} (pid ${health.pid}, uptime ${health.uptimeSeconds}s)`);
+        if (health.safeMode?.active) {
+            lines.push(`SAFE MODE: ${health.safeMode.reason}`);
+        }
+        if (health.degraded.length > 0) {
+            lines.push("");
+            lines.push("Degraded:");
+            for (const d of health.degraded) {
+                lines.push(`  ${d.component}: ${d.reason} (since ${d.since})`);
+            }
+        }
+        lines.push("");
+    }
+    lines.push("daemon not running; run `ouro up`");
+    return lines.join("\n");
+}
+function isDaemonUnavailableError(error) {
+    const code = typeof error === "object" && error !== null && "code" in error
+        ? String(error.code ?? "")
+        : "";
+    return code === "ENOENT" || code === "ECONNREFUSED";
+}
+function formatMcpResponse(command, response) {
+    if (command.kind === "mcp.list") {
+        const allTools = response.data;
+        if (!allTools || allTools.length === 0) {
+            return response.message ?? "no tools available from connected MCP servers";
+        }
+        const lines = [];
+        for (const entry of allTools) {
+            lines.push(`[${entry.server}]`);
+            for (const tool of entry.tools) {
+                lines.push(`  ${tool.name}: ${tool.description}`);
+            }
+        }
+        return lines.join("\n");
+    }
+    // mcp.call
+    const result = response.data;
+    if (!result) {
+        return response.message ?? "no result";
+    }
+    return result.content.map((c) => c.text).join("\n");
+}

package/dist/heart/daemon/cli-types.js

@@ -0,0 +1,8 @@
+"use strict";
+/**
+ * CLI command types and dependency interface.
+ *
+ * Extracted from daemon-cli.ts — the OuroCliCommand union and OuroCliDeps
+ * interface are the contract between parsing, execution, and default wiring.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });