@ouro.bot/cli 0.1.0-alpha.297 → 0.1.0-alpha.299

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

@@ -723,6 +723,19 @@ async function runOuroCli(args, deps = (0, cli_defaults_1.createDefaultOuroCliDe
         message: "ouro CLI command invoked",
         meta: { kind: command.kind },
     });
+    if (command.kind === "bluebubbles.replay") {
+        const { replayBlueBubblesMessage, formatBlueBubblesReplayText } = await Promise.resolve().then(() => __importStar(require("../../senses/bluebubbles/replay")));
+        const replay = await replayBlueBubblesMessage({
+            agentName: command.agent,
+            messageGuid: command.messageGuid,
+            eventType: command.eventType,
+        });
+        const text = command.json
+            ? JSON.stringify(replay, null, 2)
+            : formatBlueBubblesReplayText(replay);
+        deps.writeStdout(text);
+        return text;
+    }
     if (command.kind === "daemon.up") {
         // ── dev mode cleanup: delete dev-config.json so the wrapper stops dispatching to dev repo ──
         /* v8 ignore start -- dev-config cleanup: requires real filesystem state @preserve */

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

@@ -56,6 +56,7 @@ function usage() {
         "  ouro habit list [--agent <name>]",
         "  ouro habit create [--agent <name>] <name> [--cadence <interval>]",
         "  ouro link <agent> --friend <id> --provider <provider> --external-id <external-id>",
+        "  ouro bluebubbles replay --agent <name> --message-guid <guid> [--event-type new-message|updated-message] [--json]",
         "  ouro task board [<status>] [--agent <name>]",
         "  ouro task create <title> [--type <type>] [--agent <name>]",
         "  ouro task update <id> <status> [--agent <name>]",
@@ -636,6 +637,49 @@ function parseSetupCommand(args) {
         throw new Error("setup requires --agent <name>");
     return { kind: "setup", tool, agent };
 }
+function parseBlueBubblesCommand(args) {
+    const subcommand = args[0];
+    if (subcommand !== "replay") {
+        throw new Error(`Usage\n${usage()}`);
+    }
+    let agent;
+    let messageGuid;
+    let eventType = "new-message";
+    let json = false;
+    for (let i = 1; i < args.length; i += 1) {
+        if (args[i] === "--agent" && args[i + 1]) {
+            agent = args[++i];
+            continue;
+        }
+        if (args[i] === "--message-guid" && args[i + 1]) {
+            messageGuid = args[++i];
+            continue;
+        }
+        if (args[i] === "--event-type" && args[i + 1]) {
+            const candidate = args[++i];
+            if (candidate !== "new-message" && candidate !== "updated-message") {
+                throw new Error("bluebubbles replay --event-type must be new-message or updated-message");
+            }
+            eventType = candidate;
+            continue;
+        }
+        if (args[i] === "--json") {
+            json = true;
+            continue;
+        }
+    }
+    if (!agent)
+        throw new Error("bluebubbles replay requires --agent <name>");
+    if (!messageGuid)
+        throw new Error("bluebubbles replay requires --message-guid <guid>");
+    return {
+        kind: "bluebubbles.replay",
+        agent,
+        messageGuid,
+        eventType,
+        ...(json ? { json: true } : {}),
+    };
+}
 // ── Main dispatch ──
 function parseOuroCommand(args) {
     const [head, second] = args;
@@ -758,5 +802,7 @@ function parseOuroCommand(args) {
         return parseMcpServeCommand(args.slice(1));
     if (head === "setup")
         return parseSetupCommand(args.slice(1));
+    if (head === "bluebubbles")
+        return parseBlueBubblesCommand(args.slice(1));
     throw new Error(`Unknown command '${args.join(" ")}'.\n${usage()}`);
 }

package/dist/heart/daemon/daemon-entry.js

@@ -140,6 +140,13 @@ const healthMonitor = new health_monitor_1.HealthMonitor({
             meta: { message },
         });
     },
+    /* v8 ignore next 3 -- wiring: delegates to processManager.restartAgent which has full unit tests @preserve */
+    onCriticalAgent: (agentName) => {
+        try {
+            processManager.restartAgent(agentName);
+        }
+        catch { /* recovery is best-effort */ }
+    },
 });
 const daemon = new daemon_1.OuroDaemon({
     socketPath,
@@ -199,6 +206,7 @@ void daemon.start().then(() => {
         scheduler.watchForChanges();
         habitSchedulers.push(scheduler);
     }
+    healthMonitor.startPeriodicChecks(60_000);
     /* v8 ignore start -- startup failure + signal handlers: call process.exit, untestable in vitest @preserve */
 }).catch(async (err) => {
     const error = err instanceof Error ? err : new Error(String(err));
@@ -229,6 +237,7 @@ process.on("SIGINT", () => {
         s.stopWatching();
         s.stop();
     }
+    healthMonitor.stopPeriodicChecks();
     setTimeout(() => process.exit(1), 5_000).unref();
     void daemon.stop().then(() => process.exit(0));
 });
@@ -239,6 +248,7 @@ process.on("SIGTERM", () => {
         s.stopWatching();
         s.stop();
     }
+    healthMonitor.stopPeriodicChecks();
     setTimeout(() => process.exit(1), 5_000).unref();
     void daemon.stop().then(() => process.exit(0));
 });

package/dist/heart/daemon/health-monitor.js

@@ -7,11 +7,34 @@ class HealthMonitor {
     scheduler;
     alertSink;
     diskUsagePercent;
+    onCriticalAgent;
+    intervalHandle = null;
     constructor(options) {
         this.processManager = options.processManager;
         this.scheduler = options.scheduler;
         this.alertSink = options.alertSink ?? (() => undefined);
         this.diskUsagePercent = options.diskUsagePercent ?? (() => 0);
+        this.onCriticalAgent = options.onCriticalAgent ?? (() => undefined);
+    }
+    startPeriodicChecks(intervalMs) {
+        if (this.intervalHandle !== null)
+            return;
+        (0, runtime_1.emitNervesEvent)({
+            level: "info",
+            component: "daemon",
+            event: "daemon.health_check_scheduled",
+            message: "periodic health checks started",
+            meta: { intervalMs },
+        });
+        this.intervalHandle = setInterval(() => {
+            void this.runChecks();
+        }, intervalMs);
+    }
+    stopPeriodicChecks() {
+        if (this.intervalHandle === null)
+            return;
+        clearInterval(this.intervalHandle);
+        this.intervalHandle = null;
     }
     async runChecks() {
         const results = [];
@@ -23,6 +46,21 @@ class HealthMonitor {
                 status: "critical",
                 message: `non-running agents: ${unhealthy.map((item) => item.name).join(", ")}`,
             });
+            for (const agent of unhealthy) {
+                try {
+                    (0, runtime_1.emitNervesEvent)({
+                        level: "warn",
+                        component: "daemon",
+                        event: "daemon.health_check_recovery_attempted",
+                        message: "triggering recovery restart for non-running agent",
+                        meta: { agentName: agent.name, agentStatus: agent.status },
+                    });
+                    this.onCriticalAgent(agent.name);
+                }
+                catch {
+                    // Recovery is best-effort -- callback errors must not crash runChecks
+                }
+            }
         }
         else {
             results.push({ name: "agent-processes", status: "ok", message: "all managed agents running" });

package/dist/senses/bluebubbles/inbound-log.js

@@ -68,6 +68,9 @@ function recordBlueBubblesInbound(agentName, event, source) {
     const filePath = getBlueBubblesInboundLogPath(agentName, event.chat.sessionKey);
     try {
         fs.mkdirSync(path.dirname(filePath), { recursive: true });
+        if (event.messageGuid.trim() && readEntries(filePath).some((entry) => entry.messageGuid === event.messageGuid)) {
+            return filePath;
+        }
         fs.appendFileSync(filePath, JSON.stringify({
             recordedAt: new Date(event.timestamp).toISOString(),
             messageGuid: event.messageGuid,

package/dist/senses/bluebubbles/index.js

@@ -656,9 +656,11 @@ async function handleBlueBubblesNormalizedEvent(event, resolvedDeps, source) {
             }
             // Record EARLY to prevent duplicate processing. BB webhooks can retry
             // before the first turn completes — recording after the turn is too late.
-            (0, inbound_log_1.recordBlueBubblesInbound)(agentName, event, source);
-            if (source !== "webhook" && sessionLikelyContainsMessage(event, existing?.messages ?? sessionMessages)) {
-                (0, inbound_log_1.recordBlueBubblesInbound)(agentName, event, "recovery-bootstrap");
+            const inboundSource = source !== "webhook" && sessionLikelyContainsMessage(event, existing?.messages ?? sessionMessages)
+                ? "recovery-bootstrap"
+                : source;
+            (0, inbound_log_1.recordBlueBubblesInbound)(agentName, event, inboundSource);
+            if (inboundSource === "recovery-bootstrap") {
                 (0, runtime_1.emitNervesEvent)({
                     component: "senses",
                     event: "senses.bluebubbles_recovery_skip",
@@ -813,9 +815,6 @@ async function handleBlueBubblesNormalizedEvent(event, resolvedDeps, source) {
                         text: result.gateResult.autoReply,
                     });
                 }
-                if (event.kind === "message") {
-                    (0, inbound_log_1.recordBlueBubblesInbound)(resolvedDeps.getAgentName(), event, source);
-                }
                 return {
                     handled: true,
                     notifiedAgent: false,
@@ -824,9 +823,6 @@ async function handleBlueBubblesNormalizedEvent(event, resolvedDeps, source) {
             }
             // Gate allowed — flush the agent's reply
             await callbacks.flush();
-            if (event.kind === "message") {
-                (0, inbound_log_1.recordBlueBubblesInbound)(resolvedDeps.getAgentName(), event, source);
-            }
             (0, runtime_1.emitNervesEvent)({
                 component: "senses",
                 event: "senses.bluebubbles_turn_end",
@@ -859,7 +855,28 @@ async function handleBlueBubblesNormalizedEvent(event, resolvedDeps, source) {
 async function handleBlueBubblesEvent(payload, deps = {}) {
     const resolvedDeps = { ...defaultDeps, ...deps };
     const client = resolvedDeps.createClient();
-    const normalized = (0, model_1.normalizeBlueBubblesEvent)(payload);
+    let normalized;
+    try {
+        normalized = (0, model_1.normalizeBlueBubblesEvent)(payload);
+    }
+    catch (error) {
+        if (error instanceof model_1.BlueBubblesIgnoredEventError) {
+            (0, runtime_1.emitNervesEvent)({
+                component: "senses",
+                event: "senses.bluebubbles_event_skipped",
+                message: "skipped ignorable bluebubbles event",
+                meta: {
+                    eventType: error.eventType,
+                },
+            });
+            return {
+                handled: true,
+                notifiedAgent: false,
+                reason: "ignored",
+            };
+        }
+        throw error;
+    }
     // Pre-repair dedup: if we've already processed this messageGuid, skip the
     // repair+hydrate path entirely. Applies to BOTH `kind: "message"` AND
     // `kind: "mutation"` events — BlueBubbles often sends a `new-message`

package/dist/senses/bluebubbles/model.js

@@ -1,9 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.BlueBubblesIgnoredEventError = void 0;
 exports.normalizeBlueBubblesEvent = normalizeBlueBubblesEvent;
 const runtime_1 = require("../../nerves/runtime");
 const render_1 = require("../../heart/attachments/render");
 const types_1 = require("../../heart/attachments/types");
+const IGNORABLE_GUIDLESS_EVENT_TYPES = new Set([
+    "chat-read-status-changed",
+]);
+class BlueBubblesIgnoredEventError extends Error {
+    eventType;
+    constructor(eventType, message) {
+        super(message);
+        this.name = "BlueBubblesIgnoredEventError";
+        this.eventType = eventType;
+    }
+}
+exports.BlueBubblesIgnoredEventError = BlueBubblesIgnoredEventError;
 function asRecord(value) {
     return value && typeof value === "object" && !Array.isArray(value)
         ? value
@@ -203,6 +216,9 @@ function normalizeBlueBubblesEvent(payload) {
             message: "ignored bluebubbles payload without guid",
             meta: { eventType },
         });
+        if (IGNORABLE_GUIDLESS_EVENT_TYPES.has(eventType)) {
+            throw new BlueBubblesIgnoredEventError(eventType, `Ignored BlueBubbles event '${eventType}' without data.guid`);
+        }
         throw new Error("BlueBubbles payload is missing data.guid");
     }
     const threadOriginatorGuid = readString(data, "threadOriginatorGuid")?.trim() || undefined;

package/dist/senses/bluebubbles/replay.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.replayBlueBubblesMessage = replayBlueBubblesMessage;
+exports.formatBlueBubblesReplayText = formatBlueBubblesReplayText;
+const render_1 = require("../../heart/attachments/render");
+const types_1 = require("../../heart/attachments/types");
+const identity_1 = require("../../heart/identity");
+const runtime_1 = require("../../nerves/runtime");
+const client_1 = require("./client");
+const model_1 = require("./model");
+function buildReplayHint(probeEventType, event) {
+    if (probeEventType === "updated-message"
+        && event.kind === "mutation"
+        && (event.mutationType === "read" || event.mutationType === "delivery")) {
+        return "replay resolved to a state-only mutation; rerun with --event-type new-message to inspect the original message payload.";
+    }
+    return undefined;
+}
+async function replayBlueBubblesMessage(params, deps = {}) {
+    const agentName = params.agentName.trim();
+    const messageGuid = params.messageGuid.trim();
+    const eventType = params.eventType ?? "new-message";
+    if (!agentName) {
+        throw new Error("bluebubbles replay requires agentName");
+    }
+    if (!messageGuid) {
+        throw new Error("bluebubbles replay requires messageGuid");
+    }
+    const setReplayAgentName = deps.setAgentName ?? identity_1.setAgentName;
+    const resetReplayIdentity = deps.resetIdentity ?? identity_1.resetIdentity;
+    const normalizeEvent = deps.normalizeEvent ?? model_1.normalizeBlueBubblesEvent;
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.bluebubbles_replay_start",
+        message: "starting bluebubbles historical replay",
+        meta: {
+            agentName,
+            messageGuid,
+            eventType,
+        },
+    });
+    setReplayAgentName(agentName);
+    try {
+        const client = deps.createClient ? deps.createClient() : (0, client_1.createBlueBubblesClient)();
+        const probe = normalizeEvent({
+            type: eventType,
+            data: {
+                guid: messageGuid,
+                hasPayloadData: true,
+            },
+        });
+        const event = await client.repairEvent(probe);
+        const attachmentRecords = event.kind === "message"
+            ? event.attachments
+                .filter((attachment) => typeof attachment.guid === "string" && attachment.guid.trim().length > 0)
+                .map((attachment) => (0, types_1.buildBlueBubblesAttachmentRecord)(attachment))
+            : [];
+        const result = {
+            probe: {
+                agentName,
+                messageGuid,
+                eventType,
+            },
+            event,
+            attachmentIds: attachmentRecords.map((attachment) => attachment.id),
+            attachmentBlock: (0, render_1.renderAttachmentBlock)(attachmentRecords),
+            ...(buildReplayHint(eventType, event) ? { hint: buildReplayHint(eventType, event) } : {}),
+        };
+        (0, runtime_1.emitNervesEvent)({
+            component: "senses",
+            event: "senses.bluebubbles_replay_end",
+            message: "completed bluebubbles historical replay",
+            meta: {
+                agentName,
+                messageGuid,
+                eventType,
+                kind: event.kind,
+                attachmentCount: attachmentRecords.length,
+            },
+        });
+        return result;
+    }
+    catch (error) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "senses",
+            event: "senses.bluebubbles_replay_error",
+            message: "bluebubbles historical replay failed",
+            meta: {
+                agentName,
+                messageGuid,
+                eventType,
+                reason: error instanceof Error ? error.message : String(error),
+            },
+        });
+        throw error;
+    }
+    finally {
+        resetReplayIdentity();
+    }
+}
+function formatBlueBubblesReplayText(result) {
+    const lines = [
+        `probe: ${result.probe.eventType}`,
+        `agent: ${result.probe.agentName}`,
+        `message_guid: ${result.probe.messageGuid}`,
+        `result_kind: ${result.event.kind}`,
+        `session: ${result.event.chat.sessionKey}`,
+    ];
+    if (result.event.kind === "mutation") {
+        lines.push(`mutation_type: ${result.event.mutationType}`);
+    }
+    if (result.event.kind === "message" && result.event.inputPartsForAgent?.length) {
+        lines.push(`input_parts_for_agent: ${result.event.inputPartsForAgent.length}`);
+    }
+    if (result.event.repairNotice?.trim()) {
+        lines.push(`repair_notice: ${result.event.repairNotice.trim()}`);
+    }
+    if (result.attachmentBlock && !result.event.textForAgent.includes(result.attachmentBlock)) {
+        lines.push(result.attachmentBlock);
+    }
+    lines.push("[text_for_agent]");
+    lines.push(result.event.textForAgent || "(empty)");
+    if (result.hint) {
+        lines.push("[hint]");
+        lines.push(result.hint);
+    }
+    return lines.join("\n");
+}

package/package.json

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