@ouro.bot/cli 0.1.0-alpha.301 → 0.1.0-alpha.302

package/changelog.json

@@ -2,9 +2,9 @@
   "_note": "This changelog is maintained as part of the PR/version-bump workflow. Agent-curated, not auto-generated. Agents read this file directly via read_file to understand what changed between versions.",
   "versions": [
     {
-      "version": "0.1.0-alpha.301",
+      "version": "0.1.0-alpha.302",
       "changes": [
-        "fix(daemon): add an injectable `statusWriter` seam to `DaemonProcessManager` so human-visible config-failure lines still default to stderr in production, but tests can route or silence them intentionally. Status-writer failures are now swallowed with a `daemon.status_writer_error` nerves event instead of breaking agent startup bookkeeping. `process-manager.test.ts` now passes a no-op writer in the snapshot-focused config-check tests that were leaking expected fixture noise into the full coverage log, and adds a regression test proving a throwing status writer does not prevent the crashed snapshot/fix hint from being recorded."
+        "feat(cli): add `ouro doctor` system health check command. New command runs 6 diagnostic categories — daemon (socket existence + responsiveness), agents (bundle discovery, agent.json validation for version/humanFacing/agentFacing/enabled), senses (BlueBubbles and Teams config presence and well-formedness), habits (launchd plist discovery, degraded state), security (secrets.json permissions, credential leak detection in agent.json), and disk (log size thresholds at 100MB warn / 500MB critical, bundle root existence). Output is a colored checklist with per-category grouping and a summary line. Works without daemon running — daemon checks fail gracefully while all other categories still execute, making it useful for cold diagnostics. 3 new files (doctor.ts, doctor-types.ts, cli-render-doctor.ts), 3 modified (cli-types.ts, cli-parse.ts, cli-exec.ts), 4 test files with 61 tests at 100% coverage on new code."
       ]
     },
     {

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

@@ -68,6 +68,8 @@ const cli_parse_1 = require("./cli-parse");
 const cli_parse_2 = require("./cli-parse");
 const cli_render_1 = require("./cli-render");
 const cli_defaults_1 = require("./cli-defaults");
+const doctor_1 = require("./doctor");
+const cli_render_doctor_1 = require("./cli-render-doctor");
 // ── ensureDaemonRunning ──
 async function ensureDaemonRunning(deps) {
     const alive = await deps.checkSocketAlive(deps.socketPath);
@@ -1912,6 +1914,32 @@ async function runOuroCli(args, deps = (0, cli_defaults_1.createDefaultOuroCliDe
         deps.writeStdout(message);
         return message;
     }
+    // ── doctor (local, no daemon socket needed) ──
+    if (command.kind === "doctor") {
+        const doctorDeps = {
+            /* v8 ignore start -- thin fs wrappers tested via doctor.test.ts with injected deps @preserve */
+            existsSync: (p) => fs.existsSync(p),
+            readFileSync: (p) => fs.readFileSync(p, "utf-8"),
+            readdirSync: (p) => fs.readdirSync(p),
+            statSync: (p) => fs.statSync(p),
+            /* v8 ignore stop */
+            checkSocketAlive: deps.checkSocketAlive,
+            socketPath: deps.socketPath,
+            bundlesRoot: deps.bundlesRoot ?? (0, identity_1.getAgentBundlesRoot)(),
+            secretsRoot: deps.secretsRoot ?? path.join(os.homedir(), ".agentsecrets"),
+            homedir: os.homedir(),
+        };
+        const doctorResult = await (0, doctor_1.runDoctorChecks)(doctorDeps);
+        const output = (0, cli_render_doctor_1.formatDoctorOutput)(doctorResult);
+        deps.writeStdout(output);
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.doctor_run",
+            message: "ouro doctor completed",
+            meta: { passed: doctorResult.summary.passed, warnings: doctorResult.summary.warnings, failed: doctorResult.summary.failed },
+        });
+        return output;
+    }
     const daemonCommand = toDaemonCommand(command);
     let response;
     try {

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

@@ -78,6 +78,7 @@ function usage() {
         "  ouro mcp call <server> <tool> [--args '{...}']",
         "  ouro rollback [<version>]",
         "  ouro versions",
+        "  ouro doctor",
     ].join("\n");
 }
 // ── Per-group parsers ──
@@ -802,6 +803,8 @@ function parseOuroCommand(args) {
         return parseMcpServeCommand(args.slice(1));
     if (head === "setup")
         return parseSetupCommand(args.slice(1));
+    if (head === "doctor")
+        return { kind: "doctor" };
     if (head === "bluebubbles")
         return parseBlueBubblesCommand(args.slice(1));
     throw new Error(`Unknown command '${args.join(" ")}'.\n${usage()}`);

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/doctor-types.js

@@ -0,0 +1,8 @@
+"use strict";
+/**
+ * Type definitions for the `ouro doctor` system health check.
+ *
+ * Describes the structure of health check results: individual checks,
+ * grouped categories, and the aggregated result.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/heart/daemon/doctor.js

@@ -0,0 +1,322 @@
+"use strict";
+/**
+ * System health check ("ouro doctor") — runs all diagnostic categories
+ * and aggregates results into a structured DoctorResult.
+ *
+ * Each category checker is isolated: if one throws, it produces a single
+ * "fail" check and the remaining categories still run.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkDaemon = checkDaemon;
+exports.checkAgents = checkAgents;
+exports.checkSenses = checkSenses;
+exports.checkHabits = checkHabits;
+exports.checkSecurity = checkSecurity;
+exports.checkDisk = checkDisk;
+exports.runDoctorChecks = runDoctorChecks;
+const runtime_1 = require("../../nerves/runtime");
+// ── Category checkers ──
+async function checkDaemon(deps) {
+    const checks = [];
+    const socketExists = deps.existsSync(deps.socketPath);
+    checks.push({
+        label: "daemon socket exists",
+        status: socketExists ? "pass" : "fail",
+        detail: socketExists ? deps.socketPath : `not found at ${deps.socketPath}`,
+    });
+    if (socketExists) {
+        const alive = await deps.checkSocketAlive(deps.socketPath);
+        checks.push({
+            label: "daemon is responsive",
+            status: alive ? "pass" : "fail",
+            detail: alive ? "socket responded" : "socket exists but daemon unresponsive",
+        });
+    }
+    else {
+        checks.push({
+            label: "daemon is responsive",
+            status: "fail",
+            detail: "skipped — socket missing",
+        });
+    }
+    return { name: "Daemon", checks };
+}
+/** Discover all *.ouro directories under bundlesRoot. */
+function discoverAgents(deps) {
+    if (!deps.existsSync(deps.bundlesRoot))
+        return [];
+    return deps.readdirSync(deps.bundlesRoot).filter((name) => name.endsWith(".ouro"));
+}
+function checkAgents(deps) {
+    const checks = [];
+    if (!deps.existsSync(deps.bundlesRoot)) {
+        checks.push({ label: "bundles directory", status: "fail", detail: `${deps.bundlesRoot} not found` });
+        return { name: "Agents", checks };
+    }
+    const agents = discoverAgents(deps);
+    if (agents.length === 0) {
+        checks.push({ label: "agent bundles", status: "warn", detail: "no *.ouro bundles found" });
+        return { name: "Agents", checks };
+    }
+    for (const agentDir of agents) {
+        const agentPath = `${deps.bundlesRoot}/${agentDir}`;
+        const configPath = `${agentPath}/agent.json`;
+        if (!deps.existsSync(configPath)) {
+            checks.push({ label: `${agentDir}/agent.json`, status: "fail", detail: "missing" });
+            continue;
+        }
+        let config;
+        try {
+            config = JSON.parse(deps.readFileSync(configPath));
+        }
+        catch {
+            checks.push({ label: `${agentDir}/agent.json`, status: "fail", detail: "unparseable JSON" });
+            continue;
+        }
+        const missing = [];
+        if (!config.version)
+            missing.push("version");
+        if (!config.humanFacing || typeof config.humanFacing !== "object") {
+            missing.push("humanFacing");
+        }
+        else {
+            const hf = config.humanFacing;
+            if (!hf.provider)
+                missing.push("humanFacing.provider");
+            if (!hf.model)
+                missing.push("humanFacing.model");
+        }
+        if (!config.agentFacing || typeof config.agentFacing !== "object") {
+            missing.push("agentFacing");
+        }
+        else {
+            const af = config.agentFacing;
+            if (!af.provider)
+                missing.push("agentFacing.provider");
+            if (!af.model)
+                missing.push("agentFacing.model");
+        }
+        if (missing.length > 0) {
+            checks.push({ label: `${agentDir}/agent.json`, status: "warn", detail: `missing fields: ${missing.join(", ")}` });
+        }
+        else {
+            checks.push({ label: `${agentDir}/agent.json`, status: "pass", detail: "valid" });
+        }
+    }
+    return { name: "Agents", checks };
+}
+function checkSenses(deps) {
+    const checks = [];
+    const agents = discoverAgents(deps);
+    for (const agentDir of agents) {
+        const configPath = `${deps.bundlesRoot}/${agentDir}/agent.json`;
+        if (!deps.existsSync(configPath))
+            continue;
+        let config;
+        try {
+            config = JSON.parse(deps.readFileSync(configPath));
+        }
+        catch {
+            checks.push({ label: `${agentDir} senses`, status: "fail", detail: "agent.json unparseable" });
+            continue;
+        }
+        if (!config.senses || typeof config.senses !== "object") {
+            checks.push({ label: `${agentDir} senses`, status: "warn", detail: "no senses config block" });
+            continue;
+        }
+        const senses = config.senses;
+        const senseNames = ["cli", "teams", "bluebubbles"];
+        for (const sense of senseNames) {
+            if (!(sense in senses))
+                continue;
+            const entry = senses[sense];
+            if (!entry || typeof entry !== "object") {
+                checks.push({ label: `${agentDir} ${sense}`, status: "fail", detail: "malformed sense entry" });
+                continue;
+            }
+            const senseObj = entry;
+            if (typeof senseObj.enabled !== "boolean") {
+                checks.push({ label: `${agentDir} ${sense}`, status: "warn", detail: "missing enabled boolean" });
+            }
+            else {
+                checks.push({
+                    label: `${agentDir} ${sense}`,
+                    status: "pass",
+                    detail: senseObj.enabled ? "enabled" : "disabled",
+                });
+            }
+        }
+    }
+    if (checks.length === 0) {
+        checks.push({ label: "senses", status: "warn", detail: "no agents with senses config found" });
+    }
+    return { name: "Senses", checks };
+}
+function checkHabits(deps) {
+    const checks = [];
+    const agents = discoverAgents(deps);
+    for (const agentDir of agents) {
+        const agentName = agentDir.replace(/\.ouro$/, "");
+        const habitsDir = `${deps.bundlesRoot}/${agentDir}/habits`;
+        if (!deps.existsSync(habitsDir)) {
+            checks.push({ label: `${agentDir} habits dir`, status: "warn", detail: "no habits directory" });
+            continue;
+        }
+        checks.push({ label: `${agentDir} habits dir`, status: "pass", detail: habitsDir });
+        // Check for launchd plists on macOS
+        const launchAgentsDir = `${deps.homedir}/Library/LaunchAgents`;
+        if (deps.existsSync(launchAgentsDir)) {
+            const plists = deps.readdirSync(launchAgentsDir).filter((f) => f.startsWith(`bot.ouro.${agentName}.`) && f.endsWith(".plist"));
+            if (plists.length > 0) {
+                checks.push({ label: `${agentDir} launchd plists`, status: "pass", detail: `${plists.length} plist(s)` });
+            }
+            else {
+                checks.push({ label: `${agentDir} launchd plists`, status: "fail", detail: "no matching plists in LaunchAgents" });
+            }
+        }
+    }
+    if (checks.length === 0) {
+        checks.push({ label: "habits", status: "warn", detail: "no agents found" });
+    }
+    return { name: "Habits", checks };
+}
+function checkSecurity(deps) {
+    const checks = [];
+    const agents = discoverAgents(deps);
+    for (const agentDir of agents) {
+        const agentName = agentDir.replace(/\.ouro$/, "");
+        const secretsPath = `${deps.secretsRoot}/${agentName}/secrets.json`;
+        if (!deps.existsSync(secretsPath)) {
+            checks.push({ label: `${agentDir} secrets.json`, status: "fail", detail: "missing" });
+            continue;
+        }
+        // Check file permissions
+        const stat = deps.statSync(secretsPath);
+        const worldReadable = (stat.mode & 0o004) !== 0;
+        if (worldReadable) {
+            checks.push({ label: `${agentDir} secrets.json perms`, status: "warn", detail: "world-readable — consider chmod 600" });
+        }
+        else {
+            checks.push({ label: `${agentDir} secrets.json perms`, status: "pass", detail: "not world-readable" });
+        }
+        // Check agent.json for leaked credential keys
+        const configPath = `${deps.bundlesRoot}/${agentDir}/agent.json`;
+        if (deps.existsSync(configPath)) {
+            try {
+                const raw = deps.readFileSync(configPath);
+                const sensitiveKeys = ["apiKey", "token", "secret", "password"];
+                const found = sensitiveKeys.filter((key) => raw.includes(`"${key}"`));
+                if (found.length > 0) {
+                    checks.push({ label: `${agentDir} credential leak`, status: "warn", detail: `agent.json contains keys: ${found.join(", ")}` });
+                }
+                else {
+                    checks.push({ label: `${agentDir} credential leak`, status: "pass", detail: "no credential keys in agent.json" });
+                }
+            }
+            catch {
+                checks.push({ label: `${agentDir} credential leak`, status: "fail", detail: "could not read agent.json" });
+            }
+        }
+    }
+    if (checks.length === 0) {
+        checks.push({ label: "security", status: "warn", detail: "no agents found" });
+    }
+    return { name: "Security", checks };
+}
+function checkDisk(deps) {
+    const checks = [];
+    // Check daemon logs directory
+    const logsDir = `${deps.homedir}/.ouro-cli/logs`;
+    if (!deps.existsSync(logsDir)) {
+        checks.push({ label: "daemon logs dir", status: "warn", detail: `${logsDir} not found` });
+    }
+    else {
+        let totalSize = 0;
+        try {
+            const files = deps.readdirSync(logsDir);
+            for (const file of files) {
+                try {
+                    const stat = deps.statSync(`${logsDir}/${file}`);
+                    totalSize += stat.size;
+                }
+                catch {
+                    // skip unreadable files
+                }
+            }
+        }
+        catch {
+            // readdirSync failure handled below
+        }
+        const sizeMB = totalSize / (1024 * 1024);
+        if (sizeMB > 500) {
+            checks.push({ label: "daemon log size", status: "fail", detail: `${sizeMB.toFixed(1)}MB — exceeds 500MB limit` });
+        }
+        else if (sizeMB > 100) {
+            checks.push({ label: "daemon log size", status: "warn", detail: `${sizeMB.toFixed(1)}MB — consider pruning with \`ouro logs prune\`` });
+        }
+        else {
+            checks.push({ label: "daemon log size", status: "pass", detail: `${sizeMB.toFixed(1)}MB` });
+        }
+    }
+    // Check AgentBundles root
+    if (deps.existsSync(deps.bundlesRoot)) {
+        checks.push({ label: "bundles root", status: "pass", detail: deps.bundlesRoot });
+    }
+    else {
+        checks.push({ label: "bundles root", status: "warn", detail: `${deps.bundlesRoot} not found` });
+    }
+    return { name: "Disk", checks };
+}
+// ── Orchestrator ──
+function computeSummary(categories) {
+    let passed = 0;
+    let warnings = 0;
+    let failed = 0;
+    for (const cat of categories) {
+        for (const check of cat.checks) {
+            /* v8 ignore next 3 -- all three branches tested; v8 misreports compound if/else-if chain @preserve */
+            if (check.status === "pass")
+                passed++;
+            else if (check.status === "warn")
+                warnings++;
+            else
+                failed++;
+        }
+    }
+    return { passed, warnings, failed };
+}
+const CATEGORY_CHECKERS = [
+    { name: "Daemon", fn: checkDaemon },
+    { name: "Agents", fn: checkAgents },
+    { name: "Senses", fn: checkSenses },
+    { name: "Habits", fn: checkHabits },
+    { name: "Security", fn: checkSecurity },
+    { name: "Disk", fn: checkDisk },
+];
+async function runDoctorChecks(deps) {
+    const categories = [];
+    for (const checker of CATEGORY_CHECKERS) {
+        try {
+            const category = await Promise.resolve(checker.fn(deps));
+            categories.push(category);
+        }
+        catch (error) {
+            (0, runtime_1.emitNervesEvent)({
+                level: "warn",
+                component: "daemon",
+                event: "daemon.doctor_check_error",
+                message: `doctor check ${checker.name} failed`,
+                meta: { category: checker.name, error: error instanceof Error ? error.message : String(error) },
+            });
+            categories.push({
+                name: checker.name,
+                checks: [{
+                        label: checker.name.toLowerCase(),
+                        status: "fail",
+                        detail: `check crashed: ${error instanceof Error ? error.message : String(error)}`,
+                    }],
+            });
+        }
+    }
+    return { categories, summary: computeSummary(categories) };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ouro.bot/cli",
-  "version": "0.1.0-alpha.301",
+  "version": "0.1.0-alpha.302",
   "main": "dist/heart/daemon/ouro-entry.js",
   "bin": {
     "cli": "dist/heart/daemon/ouro-bot-entry.js",