@ouro.bot/cli 0.1.0-alpha.541 → 0.1.0-alpha.542

package/changelog.json

@@ -1,6 +1,14 @@
 {
   "_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.542",
+      "changes": [
+        "BlueBubbles recovery timeouts now leave iMessage messages pending instead of marking them processed, and legacy `recovery-timeout` processed records no longer suppress retries.",
+        "Recovery turns now get a longer bounded timeout and keep their in-flight guard until the abandoned turn settles, preventing duplicate retries while preserving truthful pending recovery state.",
+        "iMessage recovery health now counts pending work by message GUID across captured inbound and mutation sidecars, preventing one missed message from being reported as multiple queued items."
+      ]
+    },
     {
       "version": "0.1.0-alpha.541",
       "changes": [

package/dist/senses/bluebubbles/index.js

@@ -170,7 +170,7 @@ const defaultDeps = {
 const BLUEBUBBLES_RUNTIME_SYNC_INTERVAL_MS = 30_000;
 const BLUEBUBBLES_RECOVERY_PASS_DELAY_MS = 1_000;
 const BLUEBUBBLES_RECOVERY_PASS_INTERVAL_MS = 30_000;
-const BLUEBUBBLES_RECOVERY_TURN_TIMEOUT_MS = 60_000;
+const BLUEBUBBLES_RECOVERY_TURN_TIMEOUT_MS = 10 * 60_000;
 const BLUEBUBBLES_CATCHUP_PAGE_SIZE = 50;
 const BLUEBUBBLES_CATCHUP_MAX_PAGES = 20;
 const BLUEBUBBLES_HEALTHY_CATCHUP_OVERLAP_MS = 90_000;
@@ -182,10 +182,6 @@ class BlueBubblesRecoveryTurnTimeoutError extends Error {
         this.name = "BlueBubblesRecoveryTurnTimeoutError";
     }
 }
-function isBlueBubblesRecoveryTurnTimeoutError(error) {
-    return error instanceof BlueBubblesRecoveryTurnTimeoutError
-        || (error instanceof Error && error.name === "BlueBubblesRecoveryTurnTimeoutError");
-}
 function resolveFriendParams(event) {
     if (event.chat.isGroup) {
         const groupKey = event.chat.chatGuid ?? event.chat.chatIdentifier ?? event.sender.externalId;
@@ -827,6 +823,7 @@ async function handleBlueBubblesNormalizedEvent(event, resolvedDeps, source, opt
         return { handled: true, notifiedAgent: false, kind: event.kind, reason: "mutation_state_only" };
     }
     let ownsInFlightMessage = false;
+    let releaseInFlightAfterTurnSettles = false;
     if (event.kind === "message") {
         if ((0, processed_log_1.hasProcessedBlueBubblesMessage)(agentName, event.chat.sessionKey, event.messageGuid)
             || (0, processed_log_1.hasProcessedBlueBubblesMessageGuid)(agentName, event.messageGuid)) {
@@ -989,6 +986,7 @@ async function handleBlueBubblesNormalizedEvent(event, resolvedDeps, source, opt
                     timeoutTimer = setTimeout(() => {
                         const reason = new BlueBubblesRecoveryTurnTimeoutError(timeoutMs);
                         recoveryTimedOut = true;
+                        releaseInFlightAfterTurnSettles = true;
                         controller.abort(reason);
                         timeoutReject?.(reason);
                         (0, runtime_1.emitNervesEvent)({
@@ -1072,7 +1070,8 @@ async function handleBlueBubblesNormalizedEvent(event, resolvedDeps, source, opt
                 });
                 /* v8 ignore start -- detached late-rejection telemetry is asserted in timeout tests, but V8 does not reliably attribute Promise.catch callbacks @preserve */
                 if (timeoutPromise) {
-                    void turnPromise.catch((error) => {
+                    void turnPromise
+                        .catch((error) => {
                         if (!recoveryTimedOut)
                             return;
                         (0, runtime_1.emitNervesEvent)({
@@ -1087,6 +1086,11 @@ async function handleBlueBubblesNormalizedEvent(event, resolvedDeps, source, opt
                                 reason: error instanceof Error ? error.message : String(error),
                             },
                         });
+                    })
+                        .finally(() => {
+                        if (releaseInFlightAfterTurnSettles && ownsInFlightMessage && event.kind === "message") {
+                            endBlueBubblesMessageInFlight(event.chat.sessionKey, event.messageGuid);
+                        }
                     });
                 }
                 /* v8 ignore stop */
@@ -1160,7 +1164,7 @@ async function handleBlueBubblesNormalizedEvent(event, resolvedDeps, source, opt
         });
     }
     finally {
-        if (ownsInFlightMessage && event.kind === "message") {
+        if (ownsInFlightMessage && event.kind === "message" && !releaseInFlightAfterTurnSettles) {
             endBlueBubblesMessageInFlight(event.chat.sessionKey, event.messageGuid);
         }
     }
@@ -1237,14 +1241,6 @@ async function handleBlueBubblesEvent(payload, deps = {}) {
     const event = await client.repairEvent(normalized);
     return handleBlueBubblesNormalizedEvent(event, resolvedDeps, "webhook");
 }
-function countPendingRecoveryCandidates(agentName) {
-    return (0, mutation_log_1.listBlueBubblesRecoveryCandidates)(agentName)
-        .filter((entry) => !(0, processed_log_1.hasProcessedBlueBubblesMessageGuid)(agentName, entry.messageGuid))
-        .length;
-}
-function countPendingCapturedInboundMessages(agentName) {
-    return listPendingCapturedInboundMessages(agentName).length;
-}
 function listPendingCapturedInboundMessages(agentName) {
     const seenMessageGuids = new Set();
     return (0, inbound_log_1.listRecordedBlueBubblesInbound)(agentName)
@@ -1256,6 +1252,30 @@ function listPendingCapturedInboundMessages(agentName) {
     })
         .filter((entry) => !(0, processed_log_1.hasProcessedBlueBubblesMessageGuid)(agentName, entry.messageGuid));
 }
+function listPendingRecoveryEntries(agentName) {
+    const pendingByGuid = new Map();
+    const add = (messageGuid, recordedAt) => {
+        if ((0, processed_log_1.hasProcessedBlueBubblesMessageGuid)(agentName, messageGuid))
+            return;
+        const previous = pendingByGuid.get(messageGuid);
+        if (!previous) {
+            pendingByGuid.set(messageGuid, recordedAt);
+            return;
+        }
+        const previousMs = Date.parse(previous);
+        const nextMs = Date.parse(recordedAt);
+        if (Number.isFinite(nextMs) && (!Number.isFinite(previousMs) || nextMs < previousMs)) {
+            pendingByGuid.set(messageGuid, recordedAt);
+        }
+    };
+    for (const entry of listPendingCapturedInboundMessages(agentName)) {
+        add(entry.messageGuid, entry.recordedAt);
+    }
+    for (const entry of (0, mutation_log_1.listBlueBubblesRecoveryCandidates)(agentName)) {
+        add(entry.messageGuid, entry.recordedAt);
+    }
+    return [...pendingByGuid].map(([messageGuid, recordedAt]) => ({ messageGuid, recordedAt }));
+}
 function parseTimestampMs(value) {
     if (!value)
         return null;
@@ -1280,18 +1300,15 @@ function formatBlueBubblesRuntimeDetail(queued, failed) {
     return "upstream reachable";
 }
 function blueBubblesPendingRecoverySnapshot(agentName, nowMs = Date.now()) {
-    const pendingRecordedAt = [
-        ...listPendingCapturedInboundMessages(agentName).map((entry) => entry.recordedAt),
-        ...(0, mutation_log_1.listBlueBubblesRecoveryCandidates)(agentName)
-            .filter((entry) => !(0, processed_log_1.hasProcessedBlueBubblesMessageGuid)(agentName, entry.messageGuid))
-            .map((entry) => entry.recordedAt),
-    ]
+    const pendingEntries = listPendingRecoveryEntries(agentName);
+    const pendingRecordedAt = pendingEntries
+        .map((entry) => entry.recordedAt)
         .map((value) => ({ value, ms: Date.parse(value) }))
         .filter((entry) => Number.isFinite(entry.ms))
         .sort((left, right) => left.ms - right.ms);
     const oldest = pendingRecordedAt[0];
     return {
-        pendingRecoveryCount: countPendingCapturedInboundMessages(agentName) + countPendingRecoveryCandidates(agentName),
+        pendingRecoveryCount: pendingEntries.length,
         oldestPendingRecoveryAt: oldest?.value,
         oldestPendingRecoveryAgeMs: oldest ? Math.max(0, nowMs - oldest.ms) : undefined,
     };
@@ -1484,14 +1501,12 @@ async function catchUpMissedBlueBubblesMessages(deps = {}, previousState, option
             result.queued = (result.queued ?? 0) + 1;
             continue;
         }
-        let repairedMessage = null;
         try {
             const repaired = await client.repairEvent(event);
             if (repaired.kind !== "message") {
                 result.skipped++;
                 continue;
             }
-            repairedMessage = repaired;
             const handled = await handleBlueBubblesNormalizedEvent(repaired, resolvedDeps, "upstream-catchup", {
                 timeoutMs: BLUEBUBBLES_RECOVERY_TURN_TIMEOUT_MS,
             });
@@ -1505,9 +1520,6 @@ async function catchUpMissedBlueBubblesMessages(deps = {}, previousState, option
         }
         catch (error) {
             result.failed++;
-            if (repairedMessage && isBlueBubblesRecoveryTurnTimeoutError(error)) {
-                (0, processed_log_1.recordProcessedBlueBubblesMessage)(agentName, repairedMessage, "upstream-catchup", "recovery-timeout");
-            }
             (0, runtime_1.emitNervesEvent)({
                 level: "warn",
                 component: "senses",
@@ -1585,14 +1597,12 @@ async function recoverCapturedBlueBubblesInboundMessages(deps = {}) {
             result.skipped++;
             continue;
         }
-        let repairedMessage = null;
         try {
             const repaired = await client.repairEvent(inboundEntryToRecoveryEvent(entry));
             if (repaired.kind !== "message") {
                 result.skipped++;
                 continue;
             }
-            repairedMessage = repaired;
             const handled = await handleBlueBubblesNormalizedEvent(repaired, resolvedDeps, entry.source, {
                 timeoutMs: BLUEBUBBLES_RECOVERY_TURN_TIMEOUT_MS,
             });
@@ -1605,9 +1615,6 @@ async function recoverCapturedBlueBubblesInboundMessages(deps = {}) {
         }
         catch (error) {
             result.failed++;
-            if (repairedMessage && isBlueBubblesRecoveryTurnTimeoutError(error)) {
-                (0, processed_log_1.recordProcessedBlueBubblesMessage)(agentName, repairedMessage, entry.source, "recovery-timeout");
-            }
             (0, runtime_1.emitNervesEvent)({
                 level: "warn",
                 component: "senses",
@@ -1635,14 +1642,12 @@ async function recoverMissedBlueBubblesMessages(deps = {}) {
             result.skipped++;
             continue;
         }
-        let repairedMessage = null;
         try {
             const repaired = await client.repairEvent(mutationEntryToEvent(candidate));
             if (repaired.kind !== "message") {
                 result.pending++;
                 continue;
             }
-            repairedMessage = repaired;
             const handled = await handleBlueBubblesNormalizedEvent(repaired, resolvedDeps, "mutation-recovery", {
                 timeoutMs: BLUEBUBBLES_RECOVERY_TURN_TIMEOUT_MS,
             });
@@ -1655,9 +1660,6 @@ async function recoverMissedBlueBubblesMessages(deps = {}) {
         }
         catch (error) {
             result.failed++;
-            if (repairedMessage && isBlueBubblesRecoveryTurnTimeoutError(error)) {
-                (0, processed_log_1.recordProcessedBlueBubblesMessage)(agentName, repairedMessage, "mutation-recovery", "recovery-timeout");
-            }
             (0, runtime_1.emitNervesEvent)({
                 level: "warn",
                 component: "senses",

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

@@ -71,22 +71,26 @@ function readAllEntries(agentName) {
         return [];
     }
 }
+function isCompletedProcessedEntry(entry) {
+    return entry.outcome !== "recovery-timeout";
+}
 function hasProcessedBlueBubblesMessage(agentName, sessionKey, messageGuid) {
     if (!messageGuid.trim())
         return false;
     const filePath = getBlueBubblesProcessedLogPath(agentName, sessionKey);
-    return readEntries(filePath).some((entry) => entry.messageGuid === messageGuid);
+    return readEntries(filePath).some((entry) => entry.messageGuid === messageGuid && isCompletedProcessedEntry(entry));
 }
 function hasProcessedBlueBubblesMessageGuid(agentName, messageGuid) {
     if (!messageGuid.trim())
         return false;
-    return readAllEntries(agentName).some((entry) => entry.messageGuid === messageGuid);
+    return readAllEntries(agentName).some((entry) => entry.messageGuid === messageGuid && isCompletedProcessedEntry(entry));
 }
 function recordProcessedBlueBubblesMessage(agentName, event, source, outcome) {
     const filePath = getBlueBubblesProcessedLogPath(agentName, event.chat.sessionKey);
     try {
         fs.mkdirSync(path.dirname(filePath), { recursive: true });
-        if (event.messageGuid.trim() && readEntries(filePath).some((entry) => entry.messageGuid === event.messageGuid)) {
+        if (event.messageGuid.trim() && readEntries(filePath).some((entry) => (entry.messageGuid === event.messageGuid
+            && isCompletedProcessedEntry(entry)))) {
             return filePath;
         }
         fs.appendFileSync(filePath, JSON.stringify({

package/package.json

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