@ouro.bot/cli 0.1.0-alpha.42 → 0.1.0-alpha.420

package/dist/heart/daemon/hooks/bundle-meta.js

@@ -37,6 +37,115 @@ exports.bundleMetaHook = bundleMetaHook;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const runtime_1 = require("../../../nerves/runtime");
+/**
+ * Migrate bundle from schema 1 to schema 2:
+ * - Move state/{episodes,obligations,cares,intentions}/* to arc/{name}/*
+ * - Move the old psyche note store to diary/
+ * Idempotent: skips missing sources; on collision, newer mtime wins.
+ */
+function migrateToSchema2(agentRoot) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.bundle_migration_start",
+        message: "migrating bundle to schema 2",
+        meta: { agentRoot },
+    });
+    // Migrate arc entities
+    for (const name of ["episodes", "obligations", "cares", "intentions"]) {
+        const src = path.join(agentRoot, "state", name);
+        const dest = path.join(agentRoot, "arc", name);
+        migrateDirectory(src, dest);
+    }
+    // Migrate diary from the old pre-diary bundle layout.
+    const legacyDiarySrc = path.join(agentRoot, "psyche", "mem" + "ory");
+    const diaryDest = path.join(agentRoot, "diary");
+    migrateDirectory(legacyDiarySrc, diaryDest);
+    // Update bundle .gitignore
+    updateBundleGitignore(agentRoot);
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.bundle_migration_end",
+        message: "bundle migration to schema 2 complete",
+        meta: { agentRoot },
+    });
+}
+/**
+ * Ensure bundle .gitignore has state/ ignored and does NOT ignore arc/, diary/, journal/.
+ */
+function updateBundleGitignore(agentRoot) {
+    const gitignorePath = path.join(agentRoot, ".gitignore");
+    let lines = [];
+    try {
+        if (fs.existsSync(gitignorePath)) {
+            lines = fs.readFileSync(gitignorePath, "utf-8").split("\n");
+        }
+    }
+    catch {
+        // If we can't read, start fresh
+    }
+    // Remove arc/, diary/, journal/ from ignore (they should be tracked)
+    const toRemove = new Set(["arc/", "diary/", "journal/"]);
+    lines = lines.filter((line) => !toRemove.has(line.trim()));
+    // Ensure state/ is in the ignore list
+    const hasState = lines.some((line) => line.trim() === "state/");
+    if (!hasState) {
+        lines.push("state/");
+    }
+    // Write back, trimming trailing empty lines and ensuring trailing newline
+    const content = lines.join("\n").replace(/\n+$/, "") + "\n";
+    try {
+        fs.writeFileSync(gitignorePath, content, "utf-8");
+    }
+    catch {
+        // Non-blocking: if we can't write .gitignore, migration still succeeds
+    }
+}
+/**
+ * Recursively copy files from src to dest.
+ * Creates destination directories as needed. Skips if source doesn't exist.
+ * When both source and destination exist, compares mtimes: newer file wins.
+ * Logs a warning either way when a collision is detected.
+ */
+function migrateDirectory(src, dest) {
+    if (!fs.existsSync(src))
+        return;
+    fs.mkdirSync(dest, { recursive: true });
+    const entries = fs.readdirSync(src, { withFileTypes: true });
+    for (const entry of entries) {
+        const srcPath = path.join(src, entry.name);
+        const destPath = path.join(dest, entry.name);
+        if (entry.isDirectory()) {
+            migrateDirectory(srcPath, destPath);
+        }
+        else if (!fs.existsSync(destPath)) {
+            fs.copyFileSync(srcPath, destPath);
+        }
+        else {
+            // Collision: both source and destination exist — compare mtimes
+            const srcMtime = fs.statSync(srcPath).mtimeMs;
+            const destMtime = fs.statSync(destPath).mtimeMs;
+            if (srcMtime > destMtime) {
+                fs.copyFileSync(srcPath, destPath);
+                (0, runtime_1.emitNervesEvent)({
+                    level: "warn",
+                    component: "daemon",
+                    event: "daemon.bundle_migration_collision",
+                    message: `migration collision: source newer, overwriting destination`,
+                    meta: { srcPath, destPath, srcMtime, destMtime },
+                });
+            }
+            else {
+                (0, runtime_1.emitNervesEvent)({
+                    level: "warn",
+                    component: "daemon",
+                    event: "daemon.bundle_migration_collision",
+                    message: `migration collision: destination newer or equal, keeping destination`,
+                    meta: { srcPath, destPath, srcMtime, destMtime },
+                });
+            }
+        }
+    }
+}
 async function bundleMetaHook(ctx) {
     (0, runtime_1.emitNervesEvent)({
         component: "daemon",
@@ -56,9 +165,14 @@ async function bundleMetaHook(ctx) {
         // Malformed JSON -- treat as missing, will overwrite with fresh
         existing = undefined;
     }
+    // Run schema-2 migration if needed
+    const currentSchema = existing?.bundleSchemaVersion ?? 1;
+    if (currentSchema < 2) {
+        migrateToSchema2(ctx.agentRoot);
+    }
     const updated = {
         runtimeVersion: ctx.currentVersion,
-        bundleSchemaVersion: existing?.bundleSchemaVersion ?? 1,
+        bundleSchemaVersion: currentSchema < 2 ? 2 : currentSchema,
         lastUpdated: new Date().toISOString(),
     };
     // Save old runtimeVersion as previousRuntimeVersion (if there was one)

package/dist/heart/daemon/http-health-probe.js

@@ -0,0 +1,80 @@
+"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.createHttpHealthProbe = createHttpHealthProbe;
+const http = __importStar(require("node:http"));
+function createHttpHealthProbe(name, port, timeoutMs = 5000) {
+    return {
+        name,
+        check: () => new Promise((resolve) => {
+            const req = http.get({
+                hostname: "127.0.0.1",
+                port,
+                path: "/health",
+                timeout: timeoutMs,
+            }, (res) => {
+                let body = "";
+                res.on("data", (chunk) => {
+                    body += chunk.toString();
+                });
+                res.on("end", () => {
+                    if (res.statusCode !== 200) {
+                        resolve({ ok: false, detail: `HTTP ${res.statusCode}` });
+                        return;
+                    }
+                    try {
+                        const parsed = JSON.parse(body);
+                        if (parsed.status === "ok") {
+                            resolve({ ok: true });
+                        }
+                        else {
+                            resolve({ ok: false, detail: `unexpected status: ${String(parsed.status)}` });
+                        }
+                    }
+                    catch {
+                        resolve({ ok: false, detail: "invalid JSON response" });
+                    }
+                });
+            });
+            req.on("timeout", () => {
+                req.destroy();
+                resolve({ ok: false, detail: "timeout" });
+            });
+            req.on("error", (err) => {
+                resolve({ ok: false, detail: err.message });
+            });
+        }),
+    };
+}

package/dist/heart/daemon/inner-status.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildInnerStatusOutput = buildInnerStatusOutput;
+const runtime_1 = require("../../nerves/runtime");
+function formatRelativeTime(elapsedMs) {
+    const minutes = Math.floor(elapsedMs / (60 * 1000));
+    if (minutes < 1)
+        return "just now";
+    if (minutes === 1)
+        return "1 minute ago";
+    if (minutes < 60)
+        return `${minutes} minutes ago`;
+    const hours = Math.floor(minutes / 60);
+    if (hours === 1)
+        return "1 hour ago";
+    return `${hours} hours ago`;
+}
+function formatCadence(cadenceMs) {
+    const minutes = Math.round(cadenceMs / (60 * 1000));
+    if (minutes >= 60) {
+        const hours = Math.round(minutes / 60);
+        return `${hours}h`;
+    }
+    return `${minutes}m`;
+}
+function buildInnerStatusOutput(input) {
+    const { agentName, runtimeState, journalFiles, heartbeat, attentionCount, now } = input;
+    const lines = [];
+    lines.push(`inner dialog status: ${agentName}`);
+    // Last turn
+    if (runtimeState?.lastCompletedAt) {
+        const lastMs = new Date(runtimeState.lastCompletedAt).getTime();
+        const elapsed = now - lastMs;
+        const relativeTime = formatRelativeTime(elapsed);
+        const reasonSuffix = runtimeState.reason ? ` (${runtimeState.reason})` : "";
+        lines.push(`  last turn: ${relativeTime}${reasonSuffix}`);
+    }
+    else {
+        lines.push("  last turn: unknown");
+    }
+    // Status
+    if (runtimeState) {
+        const reasonSuffix = runtimeState.status === "running" && runtimeState.reason ? ` (${runtimeState.reason})` : "";
+        lines.push(`  status: ${runtimeState.status}${reasonSuffix}`);
+    }
+    else {
+        lines.push("  status: unknown");
+    }
+    // Heartbeat health
+    if (heartbeat && heartbeat.lastCompletedAt !== null) {
+        const elapsed = now - heartbeat.lastCompletedAt;
+        const threshold = heartbeat.cadenceMs * 1.5;
+        const health = elapsed < threshold ? "healthy" : "overdue";
+        const cadenceStr = formatCadence(heartbeat.cadenceMs);
+        const sinceStr = formatRelativeTime(elapsed);
+        lines.push(`  heartbeat: ${health} (cadence ${cadenceStr}, ${sinceStr})`);
+    }
+    else {
+        lines.push("  heartbeat: unknown");
+    }
+    // Journal
+    if (journalFiles.length === 0) {
+        lines.push("  journal: (empty)");
+    }
+    else {
+        lines.push("  journal:");
+        const sorted = [...journalFiles].sort((a, b) => b.mtimeMs - a.mtimeMs);
+        for (const file of sorted) {
+            const elapsed = now - file.mtimeMs;
+            const relativeTime = formatRelativeTime(elapsed);
+            lines.push(`    - ${file.name} (${relativeTime})`);
+        }
+    }
+    // Attention
+    const thoughtWord = attentionCount === 1 ? "thought" : "thoughts";
+    lines.push(`  attention: ${attentionCount} held ${thoughtWord}`);
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.inner_status_read",
+        message: "inner dialog status read",
+        meta: {
+            agentName,
+            status: runtimeState?.status ?? "unknown",
+            journalCount: journalFiles.length,
+            attentionCount,
+        },
+    });
+    return lines.join("\n");
+}

package/dist/heart/daemon/interactive-repair.js

@@ -0,0 +1,307 @@
+"use strict";
+/**
+ * Interactive repair flow for degraded agents detected during `ouro up`.
+ *
+ * Examines each degraded agent's errorReason and fixHint to detect common
+ * issue patterns and prompt the user for repair actions.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasRunnableInteractiveRepair = hasRunnableInteractiveRepair;
+exports.isAffirmativeAnswer = isAffirmativeAnswer;
+exports.runInteractiveRepair = runInteractiveRepair;
+const runtime_1 = require("../../nerves/runtime");
+const identity_1 = require("../identity");
+function isCredentialIssue(degraded) {
+    const reason = degraded.errorReason.toLowerCase();
+    const hint = degraded.fixHint.toLowerCase();
+    return reason.includes("credentials") || hint.includes("ouro auth");
+}
+function isVaultUnlockIssue(degraded) {
+    const text = `${degraded.errorReason}\n${degraded.fixHint}`.toLowerCase();
+    return /ouro vault unlock|credential vault is locked|vault(?: is)? locked/.test(text);
+}
+function isConfigError(degraded) {
+    return degraded.fixHint.length > 0 && !isVaultUnlockIssue(degraded) && !isCredentialIssue(degraded);
+}
+function hasRunnableInteractiveRepair(degraded) {
+    if (degraded.issue?.actions.some((action) => typedActionToRunnable(degraded, action) !== undefined)) {
+        return true;
+    }
+    return isVaultUnlockIssue(degraded) || isCredentialIssue(degraded);
+}
+function isAgentProvider(value) {
+    return Object.prototype.hasOwnProperty.call(identity_1.PROVIDER_CREDENTIALS, value);
+}
+function extractProviderFromFixHint(fixHint) {
+    const provider = fixHint.match(/--provider\s+([a-z0-9-]+)/)?.[1]
+        ?? fixHint.match(/providers\.([a-z0-9-]+)/)?.[1];
+    if (!provider || !isAgentProvider(provider))
+        return undefined;
+    return provider;
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function cleanExtractedCommand(command) {
+    const cleaned = command?.trim().replace(/[`'",;:.)]+$/g, "").trim();
+    return cleaned && cleaned.length > 0 ? cleaned : undefined;
+}
+function extractRepairCommand(fixHint, commandPrefix) {
+    const escapedPrefix = escapeRegExp(commandPrefix);
+    const commandBody = `${escapedPrefix}(?=\\s|$)[^\`'"]*`;
+    const quoted = fixHint.match(new RegExp(`[\`'"](${commandBody})[\`'"]`, "i"))?.[1];
+    const unquoted = fixHint.match(new RegExp(`(${escapedPrefix}(?=\\s|$)[^\\n,;.]+)`, "i"))?.[1];
+    return cleanExtractedCommand(quoted) ?? cleanExtractedCommand(unquoted);
+}
+function authCommandFor(degraded) {
+    const command = extractRepairCommand(degraded.fixHint, "ouro auth");
+    return command && command.length > 0 ? command : `ouro auth --agent ${degraded.agent}`;
+}
+function vaultUnlockCommandFor(degraded) {
+    const command = extractRepairCommand(degraded.fixHint, "ouro vault unlock");
+    return command && command.length > 0 ? command : `ouro vault unlock --agent ${degraded.agent}`;
+}
+function isAffirmativeAnswer(answer) {
+    return /^(y|yes)$/i.test(answer.trim());
+}
+function uniqueCommands(commands) {
+    const seen = new Set();
+    const unique = [];
+    commands.forEach((command) => {
+        if (!command)
+            return;
+        if (seen.has(command))
+            return;
+        seen.add(command);
+        unique.push(command);
+    });
+    return unique;
+}
+function fallbackCommandsFor(degraded, primaryCommand) {
+    const issueCommands = degraded.issue?.actions.map((action) => action.command) ?? [];
+    return uniqueCommands([
+        primaryCommand,
+        ...issueCommands,
+        extractRepairCommand(degraded.fixHint, "ouro vault replace"),
+        extractRepairCommand(degraded.fixHint, "ouro vault recover"),
+        extractRepairCommand(degraded.fixHint, "ouro use"),
+    ]);
+}
+function renderRepairChoices(prefix, commands) {
+    return commands.map((command, index) => `  ${index === 0 ? prefix : "or"}: ${command}`);
+}
+function renderRepairQueueSummaryLines(degraded) {
+    const repairable = degraded
+        .map((entry) => ({ entry, action: runnableRepairActionFor(entry) }))
+        .filter((item) => item.action !== undefined);
+    if (repairable.length < 2)
+        return [];
+    const lines = [
+        "Repair queue",
+        `${repairable.length} agents need attention before startup can finish.`,
+        "",
+    ];
+    repairable.forEach(({ entry, action }, index) => {
+        lines.push(`${entry.agent} - ${action.label}`);
+        lines.push(`  ${action.command}`);
+        if (index < repairable.length - 1)
+            lines.push("");
+    });
+    return lines;
+}
+function renderActionPromptLines(agent, action) {
+    const lines = [
+        `${agent}`,
+        `  needs: ${action.label}`,
+        `  run:   ${action.command}`,
+    ];
+    if (action.kind === "vault-unlock") {
+        lines.push("  note:  use the saved vault unlock secret");
+    }
+    return lines;
+}
+function renderDeferredRepair(agent, commands) {
+    return [
+        `Leaving ${agent} for later.`,
+        ...renderRepairChoices("next", commands),
+    ].join("\n");
+}
+function renderManualRepairHint(agent, fixHint) {
+    return [
+        `${agent}`,
+        "  needs manual attention",
+        `  next: ${fixHint}`,
+    ].join("\n");
+}
+function renderUnknownRepair(agent, errorReason) {
+    return [
+        `${agent}`,
+        `  ${errorReason}`,
+    ].join("\n");
+}
+function writeDeclinedRepair(degraded, command, deps) {
+    deps.writeStdout(renderDeferredRepair(degraded.agent, fallbackCommandsFor(degraded, command)));
+}
+function runnableRepairActionFor(degraded) {
+    const typedAction = degraded.issue?.actions
+        .map((action) => typedActionToRunnable(degraded, action))
+        .find((action) => action !== undefined);
+    if (typedAction)
+        return typedAction;
+    if (isVaultUnlockIssue(degraded)) {
+        return { kind: "vault-unlock", label: "vault unlock", command: vaultUnlockCommandFor(degraded) };
+    }
+    if (isCredentialIssue(degraded)) {
+        return {
+            kind: "provider-auth",
+            label: "provider auth",
+            command: authCommandFor(degraded),
+            provider: extractProviderFromFixHint(degraded.fixHint),
+        };
+    }
+    return undefined;
+}
+function typedActionToRunnable(degraded, action) {
+    if (action.executable === false || action.command.includes("<"))
+        return undefined;
+    if (action.kind === "vault-unlock") {
+        return { kind: "vault-unlock", label: "vault unlock", command: action.command };
+    }
+    if (action.kind === "provider-auth") {
+        return {
+            kind: "provider-auth",
+            label: "provider auth",
+            command: action.command || `ouro auth --agent ${degraded.agent}`,
+            provider: action.provider,
+        };
+    }
+    return undefined;
+}
+function writeRepairQueueSummary(degraded, deps) {
+    const lines = renderRepairQueueSummaryLines(degraded);
+    if (lines.length > 0)
+        deps.writeStdout(lines.join("\n"));
+}
+async function attemptVaultUnlock(entry, action, deps) {
+    deps.writeStdout(renderActionPromptLines(entry.agent, action).join("\n"));
+    const answer = await deps.promptInput(`Unlock ${entry.agent}'s vault now? [y/N] `);
+    if (!isAffirmativeAnswer(answer)) {
+        writeDeclinedRepair(entry, action.command, deps);
+        return { succeeded: false, attempted: false };
+    }
+    try {
+        if (!deps.runVaultUnlock) {
+            deps.writeStdout(renderManualRepairHint(entry.agent, entry.fixHint));
+            return { succeeded: false, attempted: false };
+        }
+        await deps.runVaultUnlock(entry.agent);
+        return { succeeded: true, attempted: true };
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        deps.writeStdout(`Vault unlock did not finish for ${entry.agent}.\n  ${msg}`);
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "daemon",
+            event: "daemon.interactive_repair_vault_unlock_error",
+            message: `vault unlock failed for ${entry.agent}`,
+            meta: { agent: entry.agent, error: msg },
+        });
+        return { succeeded: false, attempted: true };
+    }
+}
+async function attemptProviderAuth(entry, action, deps) {
+    deps.writeStdout(renderActionPromptLines(entry.agent, action).join("\n"));
+    const answer = await deps.promptInput(`Open the auth flow for ${entry.agent} now? [y/N] `);
+    if (!isAffirmativeAnswer(answer)) {
+        writeDeclinedRepair(entry, action.command, deps);
+        return { succeeded: false, attempted: false };
+    }
+    try {
+        if (action.provider) {
+            await deps.runAuthFlow(entry.agent, action.provider);
+        }
+        else {
+            await deps.runAuthFlow(entry.agent);
+        }
+        return { succeeded: true, attempted: true };
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        deps.writeStdout(`Auth did not finish for ${entry.agent}.\n  ${msg}`);
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "daemon",
+            event: "daemon.interactive_repair_auth_error",
+            message: `auth flow failed for ${entry.agent}`,
+            meta: { agent: entry.agent, error: msg },
+        });
+        return { succeeded: false, attempted: true };
+    }
+}
+async function processEntry(entry, deps) {
+    let current = entry;
+    while (current) {
+        const action = runnableRepairActionFor(current);
+        let outcome;
+        if (action?.kind === "vault-unlock") {
+            outcome = await attemptVaultUnlock(current, action, deps);
+        }
+        else if (action?.kind === "provider-auth") {
+            outcome = await attemptProviderAuth(current, action, deps);
+        }
+        else if (isConfigError(current)) {
+            deps.writeStdout(renderManualRepairHint(current.agent, current.fixHint));
+            return { attempted: false };
+        }
+        else {
+            deps.writeStdout(renderUnknownRepair(current.agent, current.errorReason));
+            return { attempted: false };
+        }
+        if (!outcome.succeeded || !deps.recheckAgent) {
+            return { attempted: outcome.attempted };
+        }
+        // Re-evaluate the agent after successful repair
+        const recheckResult = await deps.recheckAgent(current.agent);
+        if (recheckResult === null) {
+            deps.writeStdout(`${current.agent} recovered.`);
+            return { attempted: true };
+        }
+        // Agent still degraded with a new error -- loop to present the new action
+        current = recheckResult;
+    }
+    /* v8 ignore next -- unreachable: loop always returns from within @preserve */
+    return { attempted: false };
+}
+async function runInteractiveRepair(degraded, deps) {
+    (0, runtime_1.emitNervesEvent)({
+        level: "info",
+        component: "daemon",
+        event: "daemon.interactive_repair_start",
+        message: "interactive repair flow started",
+        meta: { degradedCount: degraded.length },
+    });
+    if (degraded.length === 0) {
+        return { repairsAttempted: false };
+    }
+    let repairsAttempted = false;
+    if (!deps.skipQueueSummary) {
+        writeRepairQueueSummary(degraded, deps);
+    }
+    for (const entry of degraded) {
+        const result = await processEntry(entry, deps);
+        if (result.attempted)
+            repairsAttempted = true;
+    }
+    if (repairsAttempted) {
+        deps.writeStdout("Repair flow complete.");
+    }
+    (0, runtime_1.emitNervesEvent)({
+        level: "info",
+        component: "daemon",
+        event: "daemon.interactive_repair_end",
+        message: "interactive repair flow completed",
+        meta: { repairsAttempted },
+    });
+    return { repairsAttempted };
+}