@ouro.bot/cli 0.1.0-alpha.322 → 0.1.0-alpha.324

package/changelog.json

@@ -1,6 +1,20 @@
 {
   "_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.324",
+      "changes": [
+        "fix(daemon): surface crashed worker error reasons and fix hints in `ouro status`, `ouro up --no-repair`, health-monitor alerts, and daemon-health snapshots so configuration failures point to the exact repair command instead of a bare warn/crashed state.",
+        "ci(release): verify the supported npm publish channels after release (`@ouro.bot/cli@alpha` and `ouro.bot@latest`) and remove the broken trusted-publishing `ouro.bot@alpha` dist-tag warning path."
+      ]
+    },
+    {
+      "version": "0.1.0-alpha.323",
+      "changes": [
+        "fix(bluebubbles): drain missed upstream BlueBubbles messages after an outage by querying recent messages when the upstream health probe recovers, deduping against the inbound sidecar, repairing candidates, and replaying them through the normal BlueBubbles turn path oldest-first.",
+        "fix(bluebubbles): make upstream catch-up bounded, paginated, and observable with nerves events for query start/end/skip/error, catch-up start/complete/error, runtime status updates, and explicit failure state if the bounded page limit is reached before the outage window is drained."
+      ]
+    },
     {
       "version": "0.1.0-alpha.322",
       "changes": [

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

@@ -1080,6 +1080,9 @@ async function runOuroCli(args, deps = (0, cli_defaults_1.createDefaultOuroCliDe
                 deps.writeStdout("degraded agents:");
                 for (const d of daemonResult.stability.degraded) {
                     deps.writeStdout(`  ${d.agent}: ${d.errorReason}`);
+                    if (d.fixHint) {
+                        deps.writeStdout(`    fix: ${d.fixHint}`);
+                    }
                 }
                 (0, runtime_1.emitNervesEvent)({
                     level: "warn",

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

@@ -345,6 +345,12 @@ function formatDaemonStatusOutput(response, fallback) {
                 /* v8 ignore stop */
                 const details = [pidStr, restartStr, exitStr].filter(Boolean).join("  ");
                 lines.push(`    ${name} ${dot} ${row.status.padEnd(10)}  ${dim(details)}`);
+                if (row.errorReason) {
+                    lines.push(`      ${dim(`error: ${row.errorReason}`)}`);
+                }
+                if (row.fixHint) {
+                    lines.push(`      ${dim(`fix:   ${row.fixHint}`)}`);
+                }
             }
         }
         lines.push("");

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

@@ -172,15 +172,40 @@ const daemon = new daemon_1.OuroDaemon({
 const daemonStartedAt = new Date().toISOString();
 const degradedComponents = [];
 function buildDaemonHealthState() {
+    const snapshots = processManager.listAgentSnapshots();
+    const agentDegradedComponents = snapshots
+        .filter((snapshot) => snapshot.status !== "running")
+        .map((snapshot) => {
+        const reasonParts = [
+            snapshot.errorReason ?? `${snapshot.channel} is ${snapshot.status}`,
+            snapshot.fixHint ? `Fix: ${snapshot.fixHint}` : null,
+        ].filter((part) => part !== null);
+        return {
+            component: `agent:${snapshot.name}`,
+            reason: reasonParts.join(" "),
+            since: snapshot.lastCrashAt ?? daemonStartedAt,
+        };
+    });
+    const degraded = [
+        ...degradedComponents.map((entry) => ({ ...entry })),
+        ...agentDegradedComponents,
+    ];
     return {
-        status: degradedComponents.length > 0 ? "degraded" : "ok",
+        status: degraded.length > 0 ? "degraded" : "ok",
         mode,
         pid: process.pid,
         startedAt: daemonStartedAt,
         uptimeSeconds: Math.floor(process.uptime()),
         safeMode: null,
-        degraded: degradedComponents.map((entry) => ({ ...entry })),
-        agents: {},
+        degraded,
+        agents: Object.fromEntries(snapshots.map((snapshot) => [
+            snapshot.name,
+            {
+                status: snapshot.status,
+                pid: snapshot.pid,
+                crashes: snapshot.restartCount,
+            },
+        ])),
         habits: {},
     };
 }

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

@@ -75,6 +75,10 @@ exports.HEALTH_TRACKED_EVENTS = new Set([
     "daemon.habit_fire",
     "daemon.agent_exit",
     "daemon.agent_started",
+    "daemon.agent_config_invalid",
+    "daemon.agent_config_failure",
+    "daemon.agent_entry_missing",
+    "daemon.agent_spawn_failed",
     "daemon.agent_restart_exhausted",
     "daemon.agent_permanent_failure",
     "daemon.agent_cooldown_recovery",

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

@@ -43,10 +43,17 @@ class HealthMonitor {
         const snapshots = this.processManager.listAgentSnapshots();
         const unhealthy = snapshots.filter((snapshot) => snapshot.status !== "running");
         if (unhealthy.length > 0) {
+            const unhealthySummary = unhealthy.map((item) => {
+                const detail = [
+                    item.errorReason ?? null,
+                    item.fixHint ? `fix: ${item.fixHint}` : null,
+                ].filter((part) => part !== null).join("; ");
+                return detail.length > 0 ? `${item.name} (${detail})` : item.name;
+            }).join(", ");
             results.push({
                 name: "agent-processes",
                 status: "critical",
-                message: `non-running agents: ${unhealthy.map((item) => item.name).join(", ")}`,
+                message: `non-running agents: ${unhealthySummary}`,
             });
             for (const agent of unhealthy) {
                 try {
@@ -55,7 +62,12 @@ class HealthMonitor {
                         component: "daemon",
                         event: "daemon.health_check_recovery_attempted",
                         message: "triggering recovery restart for non-running agent",
-                        meta: { agentName: agent.name, agentStatus: agent.status },
+                        meta: {
+                            agentName: agent.name,
+                            agentStatus: agent.status,
+                            errorReason: agent.errorReason ?? null,
+                            fixHint: agent.fixHint ?? null,
+                        },
                     });
                     this.onCriticalAgent(agent.name);
                 }

package/dist/senses/bluebubbles/client.js

@@ -58,6 +58,9 @@ async function parseJsonBody(response) {
         return null;
     }
 }
+function describeCaughtValue(error) {
+    return error instanceof Error ? error.message : String(error);
+}
 function buildRepairUrl(baseUrl, messageGuid, password) {
     const url = buildBlueBubblesApiUrl(baseUrl, `/api/v1/message/${encodeURIComponent(messageGuid)}`, password);
     const parsed = new URL(url);
@@ -102,6 +105,17 @@ function extractChatQueryRows(payload) {
     }
     return data.map((entry) => asRecord(entry)).filter((entry) => entry !== null);
 }
+function extractMessageQueryRows(payload) {
+    const record = asRecord(payload);
+    const data = asRecord(record?.data);
+    const rows = Array.isArray(record?.data) ? record.data
+        : Array.isArray(data?.messages) ? data.messages
+            : Array.isArray(data?.results) ? data.results
+                : Array.isArray(record?.messages) ? record.messages
+                    : Array.isArray(payload) ? payload
+                        : [];
+    return rows.map((entry) => asRecord(entry)).filter((entry) => entry !== null);
+}
 async function resolveChatGuidForIdentifier(config, channelConfig, chatIdentifier) {
     const trimmedIdentifier = chatIdentifier.trim();
     if (!trimmedIdentifier)
@@ -368,6 +382,71 @@ function createBlueBubblesClient(config = (0, config_1.getBlueBubblesConfig)(),
                 meta: { serverUrl: config.serverUrl },
             });
         },
+        async listRecentMessages(params = {}) {
+            const limit = Math.max(1, Math.min(100, Math.floor(params.limit ?? 50)));
+            const offset = Math.max(0, Math.floor(params.offset ?? 0));
+            const url = buildBlueBubblesApiUrl(config.serverUrl, "/api/v1/message/query", config.password);
+            (0, runtime_1.emitNervesEvent)({
+                component: "senses",
+                event: "senses.bluebubbles_query_recent_start",
+                message: "querying recent bluebubbles messages",
+                meta: { limit, offset },
+            });
+            const response = await fetch(url, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({
+                    limit,
+                    offset,
+                    sort: "DESC",
+                    with: ["chats", "attachments", "payloadData", "messageSummaryInfo"],
+                }),
+                signal: AbortSignal.timeout(channelConfig.requestTimeoutMs),
+            });
+            if (!response.ok) {
+                const errorText = await response.text().catch(() => "");
+                (0, runtime_1.emitNervesEvent)({
+                    level: "warn",
+                    component: "senses",
+                    event: "senses.bluebubbles_query_recent_error",
+                    message: "bluebubbles recent message query failed",
+                    meta: {
+                        status: response.status,
+                        reason: errorText || "unknown",
+                    },
+                });
+                throw new Error(`BlueBubbles recent message query failed (${response.status}): ${errorText || "unknown"}`);
+            }
+            const payload = await parseJsonBody(response);
+            const rows = extractMessageQueryRows(payload);
+            const messages = [];
+            for (const row of rows) {
+                try {
+                    messages.push((0, model_1.normalizeBlueBubblesEvent)({ type: "new-message", data: row }));
+                }
+                catch (error) {
+                    (0, runtime_1.emitNervesEvent)({
+                        level: "warn",
+                        component: "senses",
+                        event: "senses.bluebubbles_query_recent_skip",
+                        message: "skipped unusable bluebubbles recent message row",
+                        meta: {
+                            reason: describeCaughtValue(error),
+                        },
+                    });
+                }
+            }
+            (0, runtime_1.emitNervesEvent)({
+                component: "senses",
+                event: "senses.bluebubbles_query_recent_end",
+                message: "queried recent bluebubbles messages",
+                meta: {
+                    rows: rows.length,
+                    normalized: messages.length,
+                },
+            });
+            return messages;
+        },
         async repairEvent(event) {
             if (!event.requiresRepair) {
                 (0, runtime_1.emitNervesEvent)({

package/dist/senses/bluebubbles/index.js

@@ -36,6 +36,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.enrichReactionText = enrichReactionText;
 exports.createStatusBatcher = createStatusBatcher;
 exports.handleBlueBubblesEvent = handleBlueBubblesEvent;
+exports.catchUpMissedBlueBubblesMessages = catchUpMissedBlueBubblesMessages;
 exports.recoverMissedBlueBubblesMessages = recoverMissedBlueBubblesMessages;
 exports.createBlueBubblesWebhookHandler = createBlueBubblesWebhookHandler;
 exports.sendProactiveBlueBubblesMessageToSession = sendProactiveBlueBubblesMessageToSession;
@@ -135,6 +136,11 @@ const defaultDeps = {
     createServer: http.createServer,
 };
 const BLUEBUBBLES_RUNTIME_SYNC_INTERVAL_MS = 30_000;
+const BLUEBUBBLES_CATCHUP_PAGE_SIZE = 50;
+const BLUEBUBBLES_CATCHUP_MAX_PAGES = 20;
+const BLUEBUBBLES_HEALTHY_CATCHUP_OVERLAP_MS = 90_000;
+const BLUEBUBBLES_RECOVERY_CATCHUP_LOOKBACK_MS = 24 * 60 * 60 * 1000;
+const BLUEBUBBLES_FIRST_CATCHUP_LOOKBACK_MS = 10 * 60 * 1000;
 function resolveFriendParams(event) {
     if (event.chat.isGroup) {
         const groupKey = event.chat.chatGuid ?? event.chat.chatIdentifier ?? event.sender.externalId;
@@ -921,24 +927,50 @@ function countPendingRecoveryCandidates(agentName) {
         .filter((entry) => !(0, inbound_log_1.hasRecordedBlueBubblesInbound)(agentName, entry.sessionKey, entry.messageGuid))
         .length;
 }
+function parseTimestampMs(value) {
+    if (!value)
+        return null;
+    const parsed = Date.parse(value);
+    return Number.isFinite(parsed) ? parsed : null;
+}
+function resolveBlueBubblesCatchUpSince(previousState, nowMs = Date.now()) {
+    if (previousState.upstreamStatus === "error") {
+        return nowMs - BLUEBUBBLES_RECOVERY_CATCHUP_LOOKBACK_MS;
+    }
+    const lastCheckedAt = parseTimestampMs(previousState.lastCheckedAt);
+    if (lastCheckedAt !== null) {
+        return Math.max(0, lastCheckedAt - BLUEBUBBLES_HEALTHY_CATCHUP_OVERLAP_MS);
+    }
+    return nowMs - BLUEBUBBLES_FIRST_CATCHUP_LOOKBACK_MS;
+}
+function formatRecoveredCount(count) {
+    return `caught up ${count} missed message(s)`;
+}
 async function syncBlueBubblesRuntime(deps = {}) {
     const resolvedDeps = { ...defaultDeps, ...deps };
     const agentName = resolvedDeps.getAgentName();
     const client = resolvedDeps.createClient();
     const checkedAt = new Date().toISOString();
+    const previousState = (0, runtime_state_1.readBlueBubblesRuntimeState)(agentName);
     try {
         await client.checkHealth();
         const recovery = await recoverMissedBlueBubblesMessages(resolvedDeps);
+        const catchUp = await catchUpMissedBlueBubblesMessages(resolvedDeps, previousState);
+        const failed = recovery.failed + catchUp.failed;
+        const recovered = recovery.recovered + catchUp.recovered;
         (0, runtime_state_1.writeBlueBubblesRuntimeState)(agentName, {
-            upstreamStatus: recovery.pending > 0 || recovery.failed > 0 ? "error" : "ok",
-            detail: recovery.failed > 0
-                ? `recovery failures: ${recovery.failed}`
+            upstreamStatus: recovery.pending > 0 || failed > 0 ? "error" : "ok",
+            detail: failed > 0
+                ? `recovery failures: ${failed}`
                 : recovery.pending > 0
                     ? `pending recovery: ${recovery.pending}`
-                    : "upstream reachable",
+                    : catchUp.recovered > 0
+                        ? formatRecoveredCount(catchUp.recovered)
+                        : "upstream reachable",
             lastCheckedAt: checkedAt,
             pendingRecoveryCount: recovery.pending,
-            lastRecoveredAt: recovery.recovered > 0 ? checkedAt : undefined,
+            lastRecoveredAt: recovered > 0 ? checkedAt : previousState.lastRecoveredAt,
+            lastRecoveredMessageGuid: catchUp.lastRecoveredMessageGuid ?? previousState.lastRecoveredMessageGuid,
         });
     }
     catch (error) {
@@ -950,6 +982,128 @@ async function syncBlueBubblesRuntime(deps = {}) {
         });
     }
 }
+async function catchUpMissedBlueBubblesMessages(deps = {}, previousState) {
+    const resolvedDeps = { ...defaultDeps, ...deps };
+    const agentName = resolvedDeps.getAgentName();
+    const client = resolvedDeps.createClient();
+    const result = { inspected: 0, recovered: 0, skipped: 0, failed: 0 };
+    const state = previousState ?? (0, runtime_state_1.readBlueBubblesRuntimeState)(agentName);
+    const catchUpSince = resolveBlueBubblesCatchUpSince(state);
+    /* v8 ignore next -- older injected test doubles may omit the catch-up query method */
+    if (!client.listRecentMessages)
+        return result;
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.bluebubbles_catchup_start",
+        message: "bluebubbles upstream catch-up pass started",
+        meta: {
+            since: new Date(catchUpSince).toISOString(),
+            pageSize: BLUEBUBBLES_CATCHUP_PAGE_SIZE,
+            maxPages: BLUEBUBBLES_CATCHUP_MAX_PAGES,
+        },
+    });
+    const recentEvents = [];
+    for (let page = 0; page < BLUEBUBBLES_CATCHUP_MAX_PAGES; page++) {
+        let pageEvents;
+        try {
+            pageEvents = await client.listRecentMessages({
+                limit: BLUEBUBBLES_CATCHUP_PAGE_SIZE,
+                offset: page * BLUEBUBBLES_CATCHUP_PAGE_SIZE,
+            });
+        }
+        catch (error) {
+            result.failed++;
+            (0, runtime_1.emitNervesEvent)({
+                level: "warn",
+                component: "senses",
+                event: "senses.bluebubbles_catchup_error",
+                message: "bluebubbles upstream catch-up query failed",
+                meta: {
+                    offset: page * BLUEBUBBLES_CATCHUP_PAGE_SIZE,
+                    reason: error instanceof Error ? error.message : String(error),
+                },
+            });
+            break;
+        }
+        recentEvents.push(...pageEvents);
+        if (pageEvents.length < BLUEBUBBLES_CATCHUP_PAGE_SIZE)
+            break;
+        const oldestMessageTimestamp = pageEvents
+            .filter((event) => event.kind === "message")
+            .reduce((oldest, event) => Math.min(oldest, event.timestamp), Number.POSITIVE_INFINITY);
+        if (oldestMessageTimestamp <= catchUpSince)
+            break;
+        if (page === BLUEBUBBLES_CATCHUP_MAX_PAGES - 1) {
+            result.failed++;
+            (0, runtime_1.emitNervesEvent)({
+                level: "warn",
+                component: "senses",
+                event: "senses.bluebubbles_catchup_error",
+                message: "bluebubbles upstream catch-up reached the bounded page limit",
+                meta: {
+                    inspectedPages: BLUEBUBBLES_CATCHUP_MAX_PAGES,
+                    reason: "catch-up page limit reached before the outage window cutoff",
+                },
+            });
+        }
+    }
+    const seenMessageGuids = new Set();
+    const candidates = recentEvents
+        .filter((event) => event.kind === "message")
+        .filter((event) => {
+        if (seenMessageGuids.has(event.messageGuid))
+            return false;
+        seenMessageGuids.add(event.messageGuid);
+        return true;
+    })
+        .sort((left, right) => left.timestamp - right.timestamp);
+    for (const event of candidates) {
+        result.inspected++;
+        if (event.fromMe
+            || event.timestamp < catchUpSince
+            || (0, inbound_log_1.hasRecordedBlueBubblesInbound)(agentName, event.chat.sessionKey, event.messageGuid)) {
+            result.skipped++;
+            continue;
+        }
+        try {
+            const repaired = await client.repairEvent(event);
+            if (repaired.kind !== "message") {
+                result.skipped++;
+                continue;
+            }
+            const handled = await handleBlueBubblesNormalizedEvent(repaired, resolvedDeps, "upstream-catchup");
+            if (handled.reason === "already_processed") {
+                result.skipped++;
+            }
+            else {
+                result.recovered++;
+                result.lastRecoveredMessageGuid = repaired.messageGuid;
+            }
+        }
+        catch (error) {
+            result.failed++;
+            (0, runtime_1.emitNervesEvent)({
+                level: "warn",
+                component: "senses",
+                event: "senses.bluebubbles_catchup_error",
+                message: "bluebubbles upstream catch-up message failed",
+                meta: {
+                    messageGuid: event.messageGuid,
+                    reason: error instanceof Error ? error.message : String(error),
+                },
+            });
+        }
+    }
+    if (result.inspected > 0 || result.recovered > 0 || result.skipped > 0 || result.failed > 0) {
+        (0, runtime_1.emitNervesEvent)({
+            component: "senses",
+            event: "senses.bluebubbles_catchup_complete",
+            message: "bluebubbles upstream catch-up pass completed",
+            meta: { ...result },
+        });
+    }
+    return result;
+}
 async function recoverMissedBlueBubblesMessages(deps = {}) {
     const resolvedDeps = { ...defaultDeps, ...deps };
     const agentName = resolvedDeps.getAgentName();

package/package.json

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