@ouro.bot/cli 0.1.0-alpha.207 → 0.1.0-alpha.208

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

@@ -0,0 +1,316 @@
+"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");
+// ── 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;
+    if (!overview || typeof overview !== "object" || Array.isArray(overview))
+        return null;
+    if (!Array.isArray(senses) || !Array.isArray(workers))
+        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,
+        };
+    });
+    if (parsedSenses.some((row) => row === null) || parsedWorkers.some((row) => row === null))
+        return null;
+    return {
+        overview: parsedOverview,
+        senses: parsedSenses,
+        workers: parsedWorkers,
+    };
+}
+// ── 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;
+}
+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");
+}
+function formatDaemonStatusOutput(response, fallback) {
+    const payload = parseStatusPayload(response.data);
+    if (!payload)
+        return fallback;
+    const overviewRows = [
+        ["Daemon", payload.overview.daemon],
+        ["Socket", payload.overview.socketPath],
+        ["Version", payload.overview.version],
+        ["Last Updated", payload.overview.lastUpdated],
+        ["Outlook", payload.overview.outlookUrl],
+        ["Entry Path", payload.overview.entryPath],
+        ["Mode", payload.overview.mode],
+        ["Workers", String(payload.overview.workerCount)],
+        ["Senses", String(payload.overview.senseCount)],
+        ["Health", payload.overview.health],
+    ];
+    const senseRows = payload.senses.map((row) => [
+        row.agent,
+        humanizeSenseName(row.sense, row.label),
+        row.enabled ? "ON" : "OFF",
+        row.status,
+        row.detail,
+    ]);
+    const workerRows = payload.workers.map((row) => {
+        /* v8 ignore start — exit info branches tested via daemon-crash-context; v8 misreports conditional chains @preserve */
+        let exitInfo = "n/a";
+        if (row.lastExitCode !== null)
+            exitInfo = `code=${row.lastExitCode}`;
+        if (row.lastSignal !== null)
+            exitInfo = row.lastExitCode !== null ? `code=${row.lastExitCode} sig=${row.lastSignal}` : `sig=${row.lastSignal}`;
+        /* v8 ignore stop */
+        return [
+            row.agent,
+            row.worker,
+            row.status,
+            row.pid === null ? "n/a" : String(row.pid),
+            String(row.restartCount),
+            exitInfo,
+        ];
+    });
+    return [
+        "Overview",
+        formatTable(["Item", "Value"], overviewRows),
+        "",
+        "Senses",
+        formatTable(["Agent", "Sense", "Enabled", "State", "Detail"], senseRows),
+        "",
+        "Workers",
+        formatTable(["Agent", "Worker", "State", "PID", "Restarts", "Last Exit"], workerRows),
+    ].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) {
+    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: [],
+    };
+}
+function daemonUnavailableStatusOutput(socketPath, healthFilePath) {
+    /* 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),
+        }, "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 });