@openclaw/bluebubbles 2026.3.11 → 2026.3.13

package/src/monitor-processing.ts

@@ -38,6 +38,10 @@ import {
   resolveBlueBubblesMessageId,
   resolveReplyContextFromCache,
 } from "./monitor-reply-cache.js";
+import {
+  hasBlueBubblesSelfChatCopy,
+  rememberBlueBubblesSelfChatCopy,
+} from "./monitor-self-chat-cache.js";
 import type {
   BlueBubblesCoreRuntime,
   BlueBubblesRuntimeEnv,
@@ -47,7 +51,12 @@ import { isBlueBubblesPrivateApiEnabled } from "./probe.js";
 import { normalizeBlueBubblesReactionInput, sendBlueBubblesReaction } from "./reactions.js";
 import { normalizeSecretInputString } from "./secret-input.js";
 import { resolveChatGuidForTarget, sendMessageBlueBubbles } from "./send.js";
-import { formatBlueBubblesChatTarget, isAllowedBlueBubblesSender } from "./targets.js";
+import {
+  extractHandleFromChatGuid,
+  formatBlueBubblesChatTarget,
+  isAllowedBlueBubblesSender,
+  normalizeBlueBubblesHandle,
+} from "./targets.js";
 
 const DEFAULT_TEXT_LIMIT = 4000;
 const invalidAckReactions = new Set<string>();
@@ -80,6 +89,19 @@ function normalizeSnippet(value: string): string {
   return stripMarkdown(value).replace(/\s+/g, " ").trim().toLowerCase();
 }
 
+function isBlueBubblesSelfChatMessage(
+  message: NormalizedWebhookMessage,
+  isGroup: boolean,
+): boolean {
+  if (isGroup || !message.senderIdExplicit) {
+    return false;
+  }
+  const chatHandle =
+    (message.chatGuid ? extractHandleFromChatGuid(message.chatGuid) : null) ??
+    normalizeBlueBubblesHandle(message.chatIdentifier ?? "");
+  return Boolean(chatHandle) && chatHandle === message.senderId;
+}
+
 function prunePendingOutboundMessageIds(now = Date.now()): void {
   const cutoff = now - PENDING_OUTBOUND_MESSAGE_ID_TTL_MS;
   for (let i = pendingOutboundMessageIds.length - 1; i >= 0; i--) {
@@ -453,8 +475,27 @@ export async function processMessage(
       ? `removed ${tapbackParsed.emoji} reaction`
       : `reacted with ${tapbackParsed.emoji}`
     : text || placeholder;
+  const isSelfChatMessage = isBlueBubblesSelfChatMessage(message, isGroup);
+  const selfChatLookup = {
+    accountId: account.accountId,
+    chatGuid: message.chatGuid,
+    chatIdentifier: message.chatIdentifier,
+    chatId: message.chatId,
+    senderId: message.senderId,
+    body: rawBody,
+    timestamp: message.timestamp,
+  };
 
   const cacheMessageId = message.messageId?.trim();
+  const confirmedOutboundCacheEntry = cacheMessageId
+    ? resolveReplyContextFromCache({
+        accountId: account.accountId,
+        replyToId: cacheMessageId,
+        chatGuid: message.chatGuid,
+        chatIdentifier: message.chatIdentifier,
+        chatId: message.chatId,
+      })
+    : null;
   let messageShortId: string | undefined;
   const cacheInboundMessage = () => {
     if (!cacheMessageId) {
@@ -476,6 +517,12 @@ export async function processMessage(
   if (message.fromMe) {
     // Cache from-me messages so reply context can resolve sender/body.
     cacheInboundMessage();
+    const confirmedAssistantOutbound =
+      confirmedOutboundCacheEntry?.senderLabel === "me" &&
+      normalizeSnippet(confirmedOutboundCacheEntry.body ?? "") === normalizeSnippet(rawBody);
+    if (isSelfChatMessage && confirmedAssistantOutbound) {
+      rememberBlueBubblesSelfChatCopy(selfChatLookup);
+    }
     if (cacheMessageId) {
       const pending = consumePendingOutboundMessageId({
         accountId: account.accountId,
@@ -499,6 +546,11 @@ export async function processMessage(
     return;
   }
 
+  if (isSelfChatMessage && hasBlueBubblesSelfChatCopy(selfChatLookup)) {
+    logVerbose(core, runtime, `drop: reflected self-chat duplicate sender=${message.senderId}`);
+    return;
+  }
+
   if (!rawBody) {
     logVerbose(core, runtime, `drop: empty text sender=${message.senderId}`);
     return;

package/src/monitor-self-chat-cache.test.ts

@@ -0,0 +1,190 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import {
+  hasBlueBubblesSelfChatCopy,
+  rememberBlueBubblesSelfChatCopy,
+  resetBlueBubblesSelfChatCache,
+} from "./monitor-self-chat-cache.js";
+
+describe("BlueBubbles self-chat cache", () => {
+  const directLookup = {
+    accountId: "default",
+    chatGuid: "iMessage;-;+15551234567",
+    senderId: "+15551234567",
+  } as const;
+
+  afterEach(() => {
+    resetBlueBubblesSelfChatCache();
+    vi.useRealTimers();
+  });
+
+  it("matches repeated lookups for the same scope, timestamp, and text", () => {
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date("2026-03-07T00:00:00Z"));
+
+    rememberBlueBubblesSelfChatCopy({
+      ...directLookup,
+      body: "  hello\r\nworld  ",
+      timestamp: 123,
+    });
+
+    expect(
+      hasBlueBubblesSelfChatCopy({
+        ...directLookup,
+        body: "hello\nworld",
+        timestamp: 123,
+      }),
+    ).toBe(true);
+  });
+
+  it("canonicalizes DM scope across chatIdentifier and chatGuid", () => {
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date("2026-03-07T00:00:00Z"));
+
+    rememberBlueBubblesSelfChatCopy({
+      accountId: "default",
+      chatIdentifier: "+15551234567",
+      senderId: "+15551234567",
+      body: "hello",
+      timestamp: 123,
+    });
+
+    expect(
+      hasBlueBubblesSelfChatCopy({
+        accountId: "default",
+        chatGuid: "iMessage;-;+15551234567",
+        senderId: "+15551234567",
+        body: "hello",
+        timestamp: 123,
+      }),
+    ).toBe(true);
+
+    resetBlueBubblesSelfChatCache();
+
+    rememberBlueBubblesSelfChatCopy({
+      accountId: "default",
+      chatGuid: "iMessage;-;+15551234567",
+      senderId: "+15551234567",
+      body: "hello",
+      timestamp: 123,
+    });
+
+    expect(
+      hasBlueBubblesSelfChatCopy({
+        accountId: "default",
+        chatIdentifier: "+15551234567",
+        senderId: "+15551234567",
+        body: "hello",
+        timestamp: 123,
+      }),
+    ).toBe(true);
+  });
+
+  it("expires entries after the ttl window", () => {
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date("2026-03-07T00:00:00Z"));
+
+    rememberBlueBubblesSelfChatCopy({
+      ...directLookup,
+      body: "hello",
+      timestamp: 123,
+    });
+
+    vi.advanceTimersByTime(11_001);
+
+    expect(
+      hasBlueBubblesSelfChatCopy({
+        ...directLookup,
+        body: "hello",
+        timestamp: 123,
+      }),
+    ).toBe(false);
+  });
+
+  it("evicts older entries when the cache exceeds its cap", () => {
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date("2026-03-07T00:00:00Z"));
+
+    for (let i = 0; i < 513; i += 1) {
+      rememberBlueBubblesSelfChatCopy({
+        ...directLookup,
+        body: `message-${i}`,
+        timestamp: i,
+      });
+      vi.advanceTimersByTime(1_001);
+    }
+
+    expect(
+      hasBlueBubblesSelfChatCopy({
+        ...directLookup,
+        body: "message-0",
+        timestamp: 0,
+      }),
+    ).toBe(false);
+    expect(
+      hasBlueBubblesSelfChatCopy({
+        ...directLookup,
+        body: "message-512",
+        timestamp: 512,
+      }),
+    ).toBe(true);
+  });
+
+  it("enforces the cache cap even when cleanup is throttled", () => {
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date("2026-03-07T00:00:00Z"));
+
+    for (let i = 0; i < 513; i += 1) {
+      rememberBlueBubblesSelfChatCopy({
+        ...directLookup,
+        body: `burst-${i}`,
+        timestamp: i,
+      });
+    }
+
+    expect(
+      hasBlueBubblesSelfChatCopy({
+        ...directLookup,
+        body: "burst-0",
+        timestamp: 0,
+      }),
+    ).toBe(false);
+    expect(
+      hasBlueBubblesSelfChatCopy({
+        ...directLookup,
+        body: "burst-512",
+        timestamp: 512,
+      }),
+    ).toBe(true);
+  });
+
+  it("does not collide long texts that differ only in the middle", () => {
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date("2026-03-07T00:00:00Z"));
+
+    const prefix = "a".repeat(256);
+    const suffix = "b".repeat(256);
+    const longBodyA = `${prefix}${"x".repeat(300)}${suffix}`;
+    const longBodyB = `${prefix}${"y".repeat(300)}${suffix}`;
+
+    rememberBlueBubblesSelfChatCopy({
+      ...directLookup,
+      body: longBodyA,
+      timestamp: 123,
+    });
+
+    expect(
+      hasBlueBubblesSelfChatCopy({
+        ...directLookup,
+        body: longBodyA,
+        timestamp: 123,
+      }),
+    ).toBe(true);
+    expect(
+      hasBlueBubblesSelfChatCopy({
+        ...directLookup,
+        body: longBodyB,
+        timestamp: 123,
+      }),
+    ).toBe(false);
+  });
+});

package/src/monitor-self-chat-cache.ts

@@ -0,0 +1,127 @@
+import { createHash } from "node:crypto";
+import { extractHandleFromChatGuid, normalizeBlueBubblesHandle } from "./targets.js";
+
+type SelfChatCacheKeyParts = {
+  accountId: string;
+  chatGuid?: string;
+  chatIdentifier?: string;
+  chatId?: number;
+  senderId: string;
+};
+
+type SelfChatLookup = SelfChatCacheKeyParts & {
+  body?: string;
+  timestamp?: number;
+};
+
+const SELF_CHAT_TTL_MS = 10_000;
+const MAX_SELF_CHAT_CACHE_ENTRIES = 512;
+const CLEANUP_MIN_INTERVAL_MS = 1_000;
+const MAX_SELF_CHAT_BODY_CHARS = 32_768;
+const cache = new Map<string, number>();
+let lastCleanupAt = 0;
+
+function normalizeBody(body: string | undefined): string | null {
+  if (!body) {
+    return null;
+  }
+  const bounded =
+    body.length > MAX_SELF_CHAT_BODY_CHARS ? body.slice(0, MAX_SELF_CHAT_BODY_CHARS) : body;
+  const normalized = bounded.replace(/\r\n?/g, "\n").trim();
+  return normalized ? normalized : null;
+}
+
+function isUsableTimestamp(timestamp: number | undefined): timestamp is number {
+  return typeof timestamp === "number" && Number.isFinite(timestamp);
+}
+
+function digestText(text: string): string {
+  return createHash("sha256").update(text).digest("base64url");
+}
+
+function trimOrUndefined(value?: string | null): string | undefined {
+  const trimmed = value?.trim();
+  return trimmed ? trimmed : undefined;
+}
+
+function resolveCanonicalChatTarget(parts: SelfChatCacheKeyParts): string | null {
+  const handleFromGuid = parts.chatGuid ? extractHandleFromChatGuid(parts.chatGuid) : null;
+  if (handleFromGuid) {
+    return handleFromGuid;
+  }
+
+  const normalizedIdentifier = normalizeBlueBubblesHandle(parts.chatIdentifier ?? "");
+  if (normalizedIdentifier) {
+    return normalizedIdentifier;
+  }
+
+  return (
+    trimOrUndefined(parts.chatGuid) ??
+    trimOrUndefined(parts.chatIdentifier) ??
+    (typeof parts.chatId === "number" ? String(parts.chatId) : null)
+  );
+}
+
+function buildScope(parts: SelfChatCacheKeyParts): string {
+  const target = resolveCanonicalChatTarget(parts) ?? parts.senderId;
+  return `${parts.accountId}:${target}`;
+}
+
+function cleanupExpired(now = Date.now()): void {
+  if (
+    lastCleanupAt !== 0 &&
+    now >= lastCleanupAt &&
+    now - lastCleanupAt < CLEANUP_MIN_INTERVAL_MS
+  ) {
+    return;
+  }
+  lastCleanupAt = now;
+  for (const [key, seenAt] of cache.entries()) {
+    if (now - seenAt > SELF_CHAT_TTL_MS) {
+      cache.delete(key);
+    }
+  }
+}
+
+function enforceSizeCap(): void {
+  while (cache.size > MAX_SELF_CHAT_CACHE_ENTRIES) {
+    const oldestKey = cache.keys().next().value;
+    if (typeof oldestKey !== "string") {
+      break;
+    }
+    cache.delete(oldestKey);
+  }
+}
+
+function buildKey(lookup: SelfChatLookup): string | null {
+  const body = normalizeBody(lookup.body);
+  if (!body || !isUsableTimestamp(lookup.timestamp)) {
+    return null;
+  }
+  return `${buildScope(lookup)}:${lookup.timestamp}:${digestText(body)}`;
+}
+
+export function rememberBlueBubblesSelfChatCopy(lookup: SelfChatLookup): void {
+  cleanupExpired();
+  const key = buildKey(lookup);
+  if (!key) {
+    return;
+  }
+  cache.set(key, Date.now());
+  enforceSizeCap();
+}
+
+export function hasBlueBubblesSelfChatCopy(lookup: SelfChatLookup): boolean {
+  cleanupExpired();
+  const key = buildKey(lookup);
+  if (!key) {
+    return false;
+  }
+  const seenAt = cache.get(key);
+  return typeof seenAt === "number" && Date.now() - seenAt <= SELF_CHAT_TTL_MS;
+}
+
+export function resetBlueBubblesSelfChatCache(): void {
+  cache.clear();
+  lastCleanupAt = 0;
+}