@ouro.bot/cli 0.1.0-alpha.5 → 0.1.0-alpha.500

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

@@ -0,0 +1,216 @@
+"use strict";
+/**
+ * Agentic repair flow for degraded agents detected during `ouro up`.
+ *
+ * Runs known local repair prompts first, then offers AI-assisted diagnosis
+ * when no local repair was attempted and a working LLM provider is available.
+ * This is a lightweight integration: one diagnostic LLM call, not a chat loop.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAgenticDiagnosisProviderRuntime = createAgenticDiagnosisProviderRuntime;
+exports.runAgenticRepair = runAgenticRepair;
+const runtime_1 = require("../../nerves/runtime");
+const interactive_repair_1 = require("./interactive-repair");
+const provider_ping_1 = require("../provider-ping");
+const readiness_repair_1 = require("./readiness-repair");
+function buildSystemPrompt(degraded) {
+    const agentList = degraded
+        .map((d) => `- ${d.agent}: error="${d.errorReason}", hint="${d.fixHint}"`)
+        .join("\n");
+    return [
+        "You are a diagnostic assistant for the Ouroboros agent daemon.",
+        "The daemon detected degraded agents during startup.",
+        "Analyze the errors below and provide a concise diagnosis with suggested fixes.",
+        "",
+        "Degraded agents:",
+        agentList,
+        "",
+        "Keep your response brief and actionable. Focus on the most likely root cause",
+        "and the simplest fix the user can apply.",
+    ].join("\n");
+}
+function buildUserMessage(degraded, logsTail) {
+    const agentDetails = degraded
+        .map((d) => `Agent: ${d.agent}\n  Error: ${d.errorReason}\n  Fix hint: ${d.fixHint}`)
+        .join("\n\n");
+    return [
+        "Here are the degraded agents and recent daemon logs:",
+        "",
+        agentDetails,
+        "",
+        "Recent daemon logs:",
+        logsTail,
+        "",
+        "What is the most likely cause and how should I fix it?",
+    ].join("\n");
+}
+function makeInteractiveRepairDeps(deps) {
+    return {
+        promptInput: deps.promptInput,
+        writeStdout: deps.writeStdout,
+        /* v8 ignore next -- fallback no-op: tests always inject runAuthFlow; default is for production @preserve */
+        runAuthFlow: deps.runAuthFlow ?? (async () => undefined),
+        runVaultUnlock: deps.runVaultUnlock,
+        skipQueueSummary: deps.skipQueueSummary,
+        isTTY: deps.isTTY,
+        stdoutColumns: deps.stdoutColumns,
+    };
+}
+async function runDeterministicRepair(degraded, deps) {
+    return deps.runInteractiveRepair(degraded, makeInteractiveRepairDeps(deps));
+}
+function discoveredProviderModel(provider) {
+    const model = provider.providerConfig.model?.trim();
+    return model ? model : undefined;
+}
+function createAgenticDiagnosisProviderRuntime(provider) {
+    const config = {
+        ...provider.providerConfig,
+        ...provider.credentials,
+    };
+    return (0, provider_ping_1.createProviderRuntimeForConfig)(provider.provider, config, {
+        model: discoveredProviderModel(provider),
+    });
+}
+async function tryAgenticDiagnosis(degraded, provider, deps) {
+    const logsTail = deps.readDaemonLogsTail();
+    const runtime = deps.createProviderRuntime(provider);
+    const systemPrompt = buildSystemPrompt(degraded);
+    const userMessage = buildUserMessage(degraded, logsTail);
+    const messages = [
+        { role: "system", content: systemPrompt },
+        { role: "user", content: userMessage },
+    ];
+    /* v8 ignore start -- no-op callbacks: satisfy interface contract, never invoked by diagnostic call @preserve */
+    const noopCallbacks = {
+        onModelStart: () => { },
+        onModelStreamStart: () => { },
+        onTextChunk: () => { },
+        onReasoningChunk: () => { },
+        onToolStart: () => { },
+        onToolEnd: () => { },
+        onError: () => { },
+    };
+    /* v8 ignore stop */
+    const result = await runtime.streamTurn({
+        messages,
+        activeTools: [],
+        callbacks: noopCallbacks,
+    });
+    if (result.content) {
+        deps.writeStdout("");
+        deps.writeStdout("--- AI Diagnosis ---");
+        deps.writeStdout(result.content);
+        deps.writeStdout("--- End Diagnosis ---");
+        deps.writeStdout("");
+    }
+    return true;
+}
+async function runAgenticRepair(degraded, deps) {
+    (0, runtime_1.emitNervesEvent)({
+        level: "info",
+        component: "daemon",
+        event: "daemon.agentic_repair_start",
+        message: "agentic repair flow started",
+        meta: { degradedCount: degraded.length },
+    });
+    if (degraded.length === 0) {
+        return { repairsAttempted: false, usedAgentic: false };
+    }
+    const hasLocalRepair = degraded.some(interactive_repair_1.hasRunnableInteractiveRepair);
+    const hasKnownTypedRepair = degraded.some((entry) => (0, readiness_repair_1.isKnownReadinessIssue)(entry.issue));
+    if (hasLocalRepair) {
+        const interactiveResult = await runDeterministicRepair(degraded, deps);
+        if (interactiveResult.repairsAttempted) {
+            return { repairsAttempted: true, usedAgentic: false };
+        }
+        if (hasKnownTypedRepair) {
+            return { repairsAttempted: false, usedAgentic: false };
+        }
+    }
+    else if (hasKnownTypedRepair) {
+        return { repairsAttempted: false, usedAgentic: false };
+    }
+    // Try to discover a working provider for agentic diagnosis
+    let discoveredProvider = null;
+    try {
+        discoveredProvider = await deps.discoverWorkingProvider(degraded[0].agent);
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "daemon",
+            event: "daemon.agentic_repair_discovery_error",
+            message: `provider discovery failed during agentic repair: ${msg}`,
+            meta: { error: msg },
+        });
+    }
+    if (!discoveredProvider) {
+        // No working provider — fall back to deterministic repair
+        (0, runtime_1.emitNervesEvent)({
+            level: "info",
+            component: "daemon",
+            event: "daemon.agentic_repair_no_provider",
+            message: "no working provider found, falling back to deterministic repair",
+            meta: {},
+        });
+        if (hasLocalRepair) {
+            return { repairsAttempted: false, usedAgentic: false };
+        }
+        const interactiveResult = await runDeterministicRepair(degraded, deps);
+        return { repairsAttempted: interactiveResult.repairsAttempted, usedAgentic: false };
+    }
+    // Offer agentic diagnosis
+    const answer = await deps.promptInput("would you like AI-assisted diagnosis? [y/n] ");
+    if (!(0, interactive_repair_1.isAffirmativeAnswer)(answer)) {
+        // User declined — fall back to deterministic repair
+        (0, runtime_1.emitNervesEvent)({
+            level: "info",
+            component: "daemon",
+            event: "daemon.agentic_repair_declined",
+            message: "user declined agentic diagnosis",
+            meta: {},
+        });
+        if (hasLocalRepair) {
+            return { repairsAttempted: false, usedAgentic: false };
+        }
+        const interactiveResult = await runDeterministicRepair(degraded, deps);
+        return { repairsAttempted: interactiveResult.repairsAttempted, usedAgentic: false };
+    }
+    // User accepted — run agentic diagnosis then fall through to deterministic repair
+    let usedAgentic = false;
+    try {
+        usedAgentic = await tryAgenticDiagnosis(degraded, discoveredProvider, deps);
+        (0, runtime_1.emitNervesEvent)({
+            level: "info",
+            component: "daemon",
+            event: "daemon.agentic_repair_diagnosis_complete",
+            message: "agentic diagnosis completed, proceeding to deterministic repair",
+            meta: { provider: discoveredProvider.provider },
+        });
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        deps.writeStdout(`AI diagnosis failed: ${msg}`);
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "daemon",
+            event: "daemon.agentic_repair_diagnosis_error",
+            message: `agentic diagnosis failed: ${msg}`,
+            meta: { error: msg, provider: discoveredProvider.provider },
+        });
+    }
+    // Always fall through to deterministic repair for actionable fixes
+    const interactiveResult = hasLocalRepair
+        ? { repairsAttempted: false }
+        : await runDeterministicRepair(degraded, deps);
+    (0, runtime_1.emitNervesEvent)({
+        level: "info",
+        component: "daemon",
+        event: "daemon.agentic_repair_end",
+        message: "agentic repair flow completed",
+        meta: { usedAgentic, repairsAttempted: interactiveResult.repairsAttempted },
+    });
+    return { repairsAttempted: interactiveResult.repairsAttempted, usedAgentic };
+}

package/dist/heart/daemon/bluebubbles-health-diagnostics.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stringifyBlueBubblesHealthError = stringifyBlueBubblesHealthError;
+exports.redactBlueBubblesHealthDetailForNerves = redactBlueBubblesHealthDetailForNerves;
+exports.formatBlueBubblesHealthcheckFailure = formatBlueBubblesHealthcheckFailure;
+exports.probeBlueBubblesHealth = probeBlueBubblesHealth;
+const runtime_1 = require("../../nerves/runtime");
+const error_classification_1 = require("../providers/error-classification");
+function buildBlueBubblesApiUrl(baseUrl, endpoint, password) {
+    const root = baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
+    const url = new URL(endpoint.replace(/^\//, ""), root);
+    url.searchParams.set("password", password);
+    return url.toString();
+}
+function stringifyBlueBubblesHealthError(error) {
+    if (error instanceof Error) {
+        const message = error.message.trim();
+        if (message)
+            return message;
+        return error.name || "unknown";
+    }
+    const value = String(error).trim();
+    return value || "unknown";
+}
+function redactBlueBubblesHealthDetailForNerves(detail) {
+    return detail
+        .replace(/\bbluebubbles\.password\b/gi, "bluebubbles credential")
+        .replace(/\bpassword\b/gi, "credential");
+}
+function blueBubblesHealthStatus(error) {
+    return error instanceof Error && typeof error.status === "number"
+        ? error.status
+        : null;
+}
+function blueBubblesHealthClassification(error) {
+    return error instanceof Error ? (0, error_classification_1.classifyHttpError)(error) : "unknown";
+}
+function formatBlueBubblesHealthcheckFailure(serverUrlInput, error) {
+    const serverUrl = serverUrlInput.trim() || "configured BlueBubbles server";
+    const rawReason = stringifyBlueBubblesHealthError(error);
+    const status = blueBubblesHealthStatus(error);
+    if (!(error instanceof Error)) {
+        return `BlueBubbles health check failed at ${serverUrl}. Check \`bluebubbles.serverUrl\`, confirm the BlueBubbles app/API is running, and inspect daemon logs. Raw error: ${rawReason}`;
+    }
+    switch (blueBubblesHealthClassification(error)) {
+        case "network-error":
+            return `Cannot reach BlueBubbles at ${serverUrl}. Check \`bluebubbles.serverUrl\`, confirm the BlueBubbles app/API is running, and verify this machine can reach it. Raw error: ${rawReason}`;
+        case "auth-failure":
+            return `BlueBubbles auth failed at ${serverUrl} (HTTP ${status}). Check this machine's BlueBubbles attachment with \`ouro connect bluebubbles --agent <agent>\` and confirm the server accepts the password. Raw error: ${rawReason}`;
+        case "server-error":
+            return `BlueBubbles upstream returned HTTP ${status} at ${serverUrl}. Check the BlueBubbles app/server logs and confirm the upstream API is healthy. Raw error: ${rawReason}`;
+        default:
+            return `BlueBubbles health check failed at ${serverUrl}${status === null ? "" : ` (HTTP ${status})`}. Check \`bluebubbles.serverUrl\`, the BlueBubbles server configuration, and daemon logs. Raw error: ${rawReason}`;
+    }
+}
+async function probeBlueBubblesHealth(input) {
+    try {
+        const url = buildBlueBubblesApiUrl(input.serverUrl, "/api/v1/message/count", input.password);
+        const response = await input.fetchImpl(url, {
+            method: "GET",
+            signal: AbortSignal.timeout(input.requestTimeoutMs),
+        });
+        if (!response.ok) {
+            const errorText = await response.text().catch(() => "");
+            const error = new Error(errorText || "unknown");
+            error.status = response.status;
+            throw error;
+        }
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.bluebubbles_health_probe_checked",
+            message: "checked bluebubbles upstream health",
+            meta: {
+                serverUrl: input.serverUrl,
+                ok: true,
+                status: response.status,
+            },
+        });
+        return {
+            ok: true,
+            detail: "upstream reachable",
+            reason: null,
+            status: response.status,
+            classification: null,
+        };
+    }
+    catch (error) {
+        const detail = formatBlueBubblesHealthcheckFailure(input.serverUrl, error);
+        const reason = stringifyBlueBubblesHealthError(error);
+        const status = blueBubblesHealthStatus(error);
+        const classification = blueBubblesHealthClassification(error);
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "daemon",
+            event: "daemon.bluebubbles_health_probe_checked",
+            message: "checked bluebubbles upstream health",
+            meta: {
+                serverUrl: input.serverUrl,
+                ok: false,
+                status,
+                reason,
+                classification,
+                detail: redactBlueBubblesHealthDetailForNerves(detail),
+            },
+        });
+        return {
+            ok: false,
+            detail,
+            reason,
+            status,
+            classification,
+        };
+    }
+}
+/* v8 ignore start -- module load observability event */
+(0, runtime_1.emitNervesEvent)({
+    component: "daemon",
+    event: "daemon.bluebubbles_health_diagnostics_loaded",
+    message: "bluebubbles health diagnostics loaded",
+    meta: {},
+});
+/* v8 ignore stop */

package/dist/heart/daemon/cadence.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_CADENCE_MS = void 0;
+exports.parseCadenceToCron = parseCadenceToCron;
+exports.parseCadenceToMs = parseCadenceToMs;
+const runtime_1 = require("../../nerves/runtime");
+exports.DEFAULT_CADENCE_MS = 30 * 60 * 1000; // 30 minutes
+/**
+ * Parse a cadence shorthand (e.g. "30m", "2h", "1d") into a cron string.
+ * Also accepts raw cron strings (5 space-separated fields) and passes them through.
+ * Returns null for invalid input.
+ */
+function parseCadenceToCron(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;
+    (0, runtime_1.emitNervesEvent)({
+        event: "daemon.cadence_parsed",
+        component: "daemon",
+        message: "parsed cadence shorthand to cron",
+        meta: { raw: value, interval, unit: cadenceMatch[2] },
+    });
+    const unit = cadenceMatch[2];
+    if (unit === "m")
+        return `*/${interval} * * * *`;
+    if (unit === "h")
+        return `0 */${interval} * * *`;
+    return `0 0 */${interval} * *`;
+}
+/**
+ * Parse a cadence shorthand (e.g. "30m", "2h", "1d") into milliseconds.
+ * Returns null for invalid input.
+ */
+function parseCadenceToMs(raw) {
+    if (typeof raw !== "string")
+        return null;
+    const value = raw.trim();
+    if (!value)
+        return null;
+    const match = /^(\d+)(m|h|d)$/.exec(value);
+    if (!match)
+        return null;
+    const interval = Number.parseInt(match[1], 10);
+    if (!Number.isFinite(interval) || interval <= 0)
+        return null;
+    (0, runtime_1.emitNervesEvent)({
+        event: "daemon.cadence_parsed_ms",
+        component: "daemon",
+        message: "parsed cadence shorthand to milliseconds",
+        meta: { raw: value, interval, unit: match[2] },
+    });
+    const unit = match[2];
+    if (unit === "m")
+        return interval * 60 * 1000;
+    if (unit === "h")
+        return interval * 60 * 60 * 1000;
+    return interval * 24 * 60 * 60 * 1000;
+}