@openclaw/imessage 2026.8.1-beta.3 → 2026.8.1

package/dist/{sanitize-outbound-DaLmdkbf.js → sanitize-outbound-Du-r1lNQ.js}

@@ -1,15 +1,352 @@
-import { u as expandIMessageUserPath } from "./accounts-D00Njxg2.js";
-import { normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { u as expandIMessageUserPath } from "./accounts-CCirBEIm.js";
+import { t as getIMessageRuntime } from "./runtime-Cza4CY5T.js";
+import { a as IMESSAGE_REPLY_CACHE_NAMESPACE, f as resolveIMessageReplyCacheEntryKey, i as IMESSAGE_REPLY_CACHE_MAX_ENTRIES, n as IMESSAGE_REPLY_CACHE_COUNTER_KEY, o as IMESSAGE_REPLY_CACHE_TTL_MS, r as IMESSAGE_REPLY_CACHE_COUNTER_NAMESPACE } from "./state-contract-4TK_cDDb.js";
+import { normalizeE164 } from "openclaw/plugin-sdk/account-resolution";
+import { normalizeLowercaseStringOrEmpty, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { logVerbose } from "openclaw/plugin-sdk/runtime-env";
 import { resolveUserPath } from "openclaw/plugin-sdk/text-utility-runtime";
 import { spawn } from "node:child_process";
 import { StringDecoder } from "node:string_decoder";
 import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
 import { FormatCapabilityProfile, findCodeRegions, isInsideCode, markdownToIR, renderMarkdownWithAttributedRanges, sanitizeAssistantVisibleText, stripMarkdown, tokenizeHtmlTags } from "openclaw/plugin-sdk/text-chunking";
+//#region extensions/imessage/src/chat-context.ts
+const EMAIL_HANDLE_PATTERN = /^[^\s@]+@[^\s@]+$/u;
+function parseDirectChatIdentity(raw) {
+	const trimmed = raw.trim();
+	const parts = trimmed.split(";");
+	if (parts.length === 3 && parts[1] === "-" && parts[2]) {
+		const service = parts[0]?.toLowerCase();
+		if (service === "imessage" || service === "sms" || service === "any") {
+			const identifier = parts[2];
+			return {
+				service,
+				identifier: EMAIL_HANDLE_PATTERN.test(identifier) ? identifier.toLowerCase() : identifier
+			};
+		}
+	}
+	if (parts.length !== 1) return;
+	if (trimmed.startsWith("+") || EMAIL_HANDLE_PATTERN.test(trimmed)) return { identifier: trimmed.toLowerCase() };
+}
+function resolveIMessageDirectChatService(configuredService, chatGuid) {
+	if (configuredService === "imessage" || configuredService === "sms") return configuredService;
+	const observedService = chatGuid ? parseDirectChatIdentity(chatGuid)?.service : void 0;
+	return observedService === "imessage" || observedService === "sms" ? observedService : void 0;
+}
+function isIMessageEmailChatIdentifier(raw) {
+	const identity = parseDirectChatIdentity(raw);
+	return Boolean(identity && EMAIL_HANDLE_PATTERN.test(identity.identifier));
+}
+/**
+* Strip the `iMessage;-;` / `SMS;-;` / `any;-;` service prefix that Messages
+* uses for direct chats. Different layers report direct DMs in different
+* forms, so raw comparison would falsely treat one DM as different chats.
+*/
+function normalizeDirectChatIdentifier(raw) {
+	const trimmed = raw.trim();
+	return parseDirectChatIdentity(trimmed)?.identifier ?? trimmed;
+}
+function chatContextFromIMessageTarget(target, effectiveService) {
+	if (target.kind === "chat_id") return { chatId: target.chatId };
+	if (target.kind === "chat_guid") return { chatGuid: target.chatGuid };
+	if (target.kind === "chat_identifier") return { chatIdentifier: target.chatIdentifier };
+	const trimmedHandle = target.to.trim();
+	const canonicalHandle = trimmedHandle.startsWith("+") ? normalizeE164(trimmedHandle) : /^[^\s@]+@[^\s@]+$/u.test(trimmedHandle) ? trimmedHandle.toLowerCase() : void 0;
+	if (!canonicalHandle) return {};
+	const service = target.service === "auto" ? effectiveService : target.service;
+	if (service !== "imessage" && service !== "sms") return {};
+	return { chatIdentifier: `${service === "sms" ? "SMS" : "iMessage"};-;${canonicalHandle}` };
+}
+function compareOptional(left, right) {
+	return left === void 0 || right === void 0 ? void 0 : left === right;
+}
+function compareChatSelector(cachedRaw, currentRaw, crossKind = false) {
+	const cached = normalizeOptionalString(cachedRaw);
+	const current = normalizeOptionalString(currentRaw);
+	if (!cached || !current) return;
+	if (cached === current) return true;
+	const cachedDirect = parseDirectChatIdentity(cached);
+	const currentDirect = parseDirectChatIdentity(current);
+	if (!cachedDirect || !currentDirect) return crossKind ? void 0 : false;
+	if (cachedDirect.identifier !== currentDirect.identifier) return false;
+	if (cachedDirect.service === "any") return true;
+	if (!cachedDirect.service || !currentDirect.service) return;
+	return cachedDirect.service === currentDirect.service;
+}
+function resolveIMessageChatMatch(cached, current) {
+	const cachedChatGuid = normalizeOptionalString(cached.chatGuid);
+	const currentChatGuid = normalizeOptionalString(current.chatGuid);
+	const cachedChatIdentifier = normalizeOptionalString(cached.chatIdentifier);
+	const currentChatIdentifier = normalizeOptionalString(current.chatIdentifier);
+	const comparisons = [
+		compareChatSelector(cachedChatGuid, currentChatGuid),
+		compareChatSelector(cachedChatIdentifier, currentChatIdentifier),
+		compareOptional(cached.chatId, current.chatId),
+		compareChatSelector(cachedChatGuid, currentChatIdentifier, true),
+		compareChatSelector(cachedChatIdentifier, currentChatGuid, true)
+	].filter((comparison) => comparison !== void 0);
+	if (comparisons.length === 0) return "unknown";
+	return comparisons.every(Boolean) ? "match" : "mismatch";
+}
+function isPositiveIMessageChatMatch(cached, current) {
+	return resolveIMessageChatMatch(cached, current) === "match";
+}
+//#endregion
 //#region extensions/imessage/src/constants.ts
 /** Default timeout for iMessage probe/RPC operations (10 seconds). */
 const DEFAULT_IMESSAGE_PROBE_TIMEOUT_MS = 1e4;
 const DEFAULT_IMESSAGE_SEND_TIMEOUT_MS = 18e4;
 //#endregion
+//#region extensions/imessage/src/monitor-reply-cache.ts
+/** Recency window for the "react to the latest message" fallback. */
+const LATEST_FALLBACK_MS = 600 * 1e3;
+let persistenceFailureLogged = false;
+function reportPersistenceFailure(scope, err) {
+	if (persistenceFailureLogged) return;
+	persistenceFailureLogged = true;
+	logVerbose(`imessage reply-cache: ${scope} disabled after first failure: ${String(err)}`);
+}
+const imessageReplyCacheByMessageId = /* @__PURE__ */ new Map();
+const imessageShortIdToUuid = /* @__PURE__ */ new Map();
+const imessageUuidToShortId = /* @__PURE__ */ new Map();
+let imessageShortIdCounter = 0;
+function openReplyCacheStore() {
+	return getIMessageRuntime().state.openSyncKeyedStore({
+		namespace: IMESSAGE_REPLY_CACHE_NAMESPACE,
+		maxEntries: IMESSAGE_REPLY_CACHE_MAX_ENTRIES
+	});
+}
+function openReplyCacheCounterStore() {
+	return getIMessageRuntime().state.openSyncKeyedStore({
+		namespace: IMESSAGE_REPLY_CACHE_COUNTER_NAMESPACE,
+		maxEntries: 1
+	});
+}
+function remainingTtlMs(timestamp) {
+	const remaining = IMESSAGE_REPLY_CACHE_TTL_MS - Math.max(0, Date.now() - timestamp);
+	return remaining > 0 ? remaining : void 0;
+}
+let hydrated = false;
+function hydrateFromStoreOnce() {
+	if (hydrated) return;
+	hydrated = true;
+	const cutoff = Date.now() - IMESSAGE_REPLY_CACHE_TTL_MS;
+	let entries;
+	try {
+		const counter = openReplyCacheCounterStore().lookup(IMESSAGE_REPLY_CACHE_COUNTER_KEY);
+		if (counter && Number.isSafeInteger(counter.counter) && counter.counter > 0) imessageShortIdCounter = Math.max(imessageShortIdCounter, counter.counter);
+		entries = openReplyCacheStore().entries().map(({ value }) => value).filter((entry) => entry.timestamp >= cutoff).toSorted((a, b) => a.timestamp - b.timestamp).slice(-IMESSAGE_REPLY_CACHE_MAX_ENTRIES);
+		for (const entry of entries) {
+			const numeric = Number.parseInt(entry.shortId, 10);
+			if (Number.isFinite(numeric) && numeric > imessageShortIdCounter) imessageShortIdCounter = numeric;
+		}
+	} catch (err) {
+		reportPersistenceFailure("read", err);
+		return;
+	}
+	if (entries.length === 0) return;
+	for (const entry of entries) {
+		imessageReplyCacheByMessageId.set(entry.messageId, entry);
+		imessageShortIdToUuid.set(entry.shortId, entry.messageId);
+		imessageUuidToShortId.set(entry.messageId, entry.shortId);
+	}
+}
+function persistReplyCacheEntry(entry) {
+	const ttlMs = remainingTtlMs(entry.timestamp);
+	if (!ttlMs) return;
+	try {
+		openReplyCacheStore().register(resolveIMessageReplyCacheEntryKey(entry.messageId), entry, { ttlMs });
+	} catch (err) {
+		reportPersistenceFailure("write", err);
+	}
+}
+function deleteReplyCacheEntry(messageId) {
+	try {
+		openReplyCacheStore().delete(resolveIMessageReplyCacheEntryKey(messageId));
+	} catch (err) {
+		reportPersistenceFailure("delete", err);
+	}
+}
+function persistReplyCacheCounter() {
+	try {
+		openReplyCacheCounterStore().register(IMESSAGE_REPLY_CACHE_COUNTER_KEY, { counter: imessageShortIdCounter });
+	} catch (err) {
+		reportPersistenceFailure("counter", err);
+	}
+}
+function buildReplyCacheEntry(entry, messageId, shortId) {
+	return {
+		accountId: entry.accountId,
+		messageId,
+		shortId,
+		timestamp: entry.timestamp,
+		...typeof entry.chatGuid === "string" ? { chatGuid: entry.chatGuid } : {},
+		...typeof entry.chatIdentifier === "string" ? { chatIdentifier: entry.chatIdentifier } : {},
+		...typeof entry.chatId === "number" ? { chatId: entry.chatId } : {},
+		...typeof entry.isFromMe === "boolean" ? { isFromMe: entry.isFromMe } : {}
+	};
+}
+function generateShortId() {
+	imessageShortIdCounter += 1;
+	persistReplyCacheCounter();
+	return String(imessageShortIdCounter);
+}
+function rememberIMessageReplyCache(entry) {
+	hydrateFromStoreOnce();
+	const messageId = entry.messageId.trim();
+	if (!messageId) return {
+		...entry,
+		shortId: ""
+	};
+	let shortId = imessageUuidToShortId.get(messageId);
+	if (!shortId) {
+		shortId = generateShortId();
+		imessageShortIdToUuid.set(shortId, messageId);
+		imessageUuidToShortId.set(messageId, shortId);
+	}
+	const fullEntry = buildReplyCacheEntry(entry, messageId, shortId);
+	imessageReplyCacheByMessageId.delete(messageId);
+	imessageReplyCacheByMessageId.set(messageId, fullEntry);
+	const cutoff = Date.now() - IMESSAGE_REPLY_CACHE_TTL_MS;
+	let evicted = false;
+	const deletedMessageIds = [];
+	for (const [key, value] of imessageReplyCacheByMessageId) {
+		if (value.timestamp >= cutoff) break;
+		imessageReplyCacheByMessageId.delete(key);
+		deletedMessageIds.push(key);
+		if (value.shortId) {
+			imessageShortIdToUuid.delete(value.shortId);
+			imessageUuidToShortId.delete(key);
+		}
+		evicted = true;
+	}
+	while (imessageReplyCacheByMessageId.size > IMESSAGE_REPLY_CACHE_MAX_ENTRIES) {
+		const oldest = imessageReplyCacheByMessageId.keys().next().value;
+		if (!oldest) break;
+		const oldEntry = imessageReplyCacheByMessageId.get(oldest);
+		imessageReplyCacheByMessageId.delete(oldest);
+		deletedMessageIds.push(oldest);
+		if (oldEntry?.shortId) {
+			imessageShortIdToUuid.delete(oldEntry.shortId);
+			imessageUuidToShortId.delete(oldest);
+		}
+		evicted = true;
+	}
+	if (evicted) for (const messageIdToDelete of deletedMessageIds) deleteReplyCacheEntry(messageIdToDelete);
+	persistReplyCacheEntry(fullEntry);
+	return fullEntry;
+}
+function hasChatScope(ctx) {
+	if (!ctx) return false;
+	return Boolean(normalizeOptionalString(ctx.chatGuid) || normalizeOptionalString(ctx.chatIdentifier) || typeof ctx.chatId === "number");
+}
+function isCrossChatMismatch(cached, ctx) {
+	return resolveIMessageChatMatch(cached, ctx) === "mismatch";
+}
+function describeChatForError(values) {
+	const parts = [];
+	if (normalizeOptionalString(values.chatGuid)) parts.push("chatGuid=<redacted>");
+	if (normalizeOptionalString(values.chatIdentifier)) parts.push("chatIdentifier=<redacted>");
+	if (typeof values.chatId === "number") parts.push("chatId=<redacted>");
+	return parts.length === 0 ? "<unknown chat>" : parts.join(", ");
+}
+function describeMessageIdForError(inputId, inputKind) {
+	if (inputKind === "short") return `<short:${inputId.length}-digit>`;
+	return `<uuid:${inputId.slice(0, 8)}...>`;
+}
+function buildCrossChatError(inputId, inputKind, cached, ctx) {
+	const remediation = inputKind === "short" ? "Use a message ID from the current chat target; MessageSidFull from another chat is rejected." : "Retry with the correct chat target.";
+	return /* @__PURE__ */ new Error(`iMessage message id ${describeMessageIdForError(inputId, inputKind)} belongs to a different chat (${describeChatForError(cached)}) than the current call target (${describeChatForError(ctx)}). ${remediation}`);
+}
+function resolveIMessageMessageId(shortOrUuid, opts) {
+	const trimmed = shortOrUuid.trim();
+	if (!trimmed) return trimmed;
+	hydrateFromStoreOnce();
+	if (/^\d+$/.test(trimmed)) {
+		const uuid = imessageShortIdToUuid.get(trimmed);
+		if (uuid) {
+			const cached = imessageReplyCacheByMessageId.get(uuid);
+			if (opts?.chatContext && hasChatScope(opts.chatContext)) {
+				if (cached && isCrossChatMismatch(cached, opts.chatContext)) throw buildCrossChatError(trimmed, "short", cached, opts.chatContext);
+			}
+			if (opts?.requireFromMe && cached?.isFromMe !== true) throw buildFromMeError(trimmed, "short");
+			return uuid;
+		}
+		if (opts?.requireKnownShortId && !hasChatScope(opts.chatContext)) throw new Error(`iMessage short message id ${describeMessageIdForError(trimmed, "short")} requires a chat scope (chatGuid / chatIdentifier / chatId or a target).`);
+		if (opts?.requireKnownShortId) throw new Error(`iMessage short message id ${describeMessageIdForError(trimmed, "short")} is no longer available. Use MessageSidFull.`);
+		return trimmed;
+	}
+	const cached = imessageReplyCacheByMessageId.get(trimmed);
+	if (opts?.chatContext) {
+		if (cached && isCrossChatMismatch(cached, opts.chatContext)) throw buildCrossChatError(trimmed, "uuid", cached, opts.chatContext);
+	}
+	if (opts?.requireFromMe && cached?.isFromMe !== true) throw buildFromMeError(trimmed, "uuid");
+	return trimmed;
+}
+function isKnownFromMeIMessageMessageId(messageId, ctx) {
+	const trimmed = normalizeOptionalString(messageId);
+	if (!trimmed || !ctx.accountId || !hasChatScope(ctx)) return false;
+	hydrateFromStoreOnce();
+	const cached = imessageReplyCacheByMessageId.get(trimmed);
+	if (!cached || cached.isFromMe !== true || cached.accountId !== ctx.accountId) return false;
+	return isPositiveIMessageChatMatch(cached, ctx);
+}
+function buildFromMeError(inputId, inputKind) {
+	return /* @__PURE__ */ new Error(`iMessage message id ${describeMessageIdForError(inputId, inputKind)} is not one this agent sent. edit and unsend can only target messages the gateway delivered itself; messages received from other participants cannot be modified.`);
+}
+/**
+* Return the most recent cached entry whose chat scope matches the supplied
+* context. Used as a fallback when an agent calls a per-message action (e.g.
+* `react`) without specifying a `messageId` — the natural intent is "react
+* to the message I just received in this chat."
+*
+* Strict semantics for safety:
+*  - Caller must supply a chat scope. We refuse to "guess" the active chat.
+*  - Cached entry must positively match on at least one identifier kind
+*    (chatGuid, chatIdentifier, chatId, or normalized direct-DM fingerprint).
+*    We do NOT fall through on "no overlapping identifier" — that's how a
+*    cached entry from a foreign chat could be returned when the caller's
+*    context didn't share any identifier kind with the cache.
+*  - Caller must supply an accountId; we never cross account boundaries.
+*  - We only consider entries newer than `LATEST_FALLBACK_MS`. The intent
+*    of "react to the latest" is "the message I just received," not
+*    "anything in this chat from any time."
+*/
+function findLatestIMessageEntryForChat(ctx) {
+	if (!hasChatScope(ctx)) return;
+	if (!ctx.accountId) return;
+	const cutoff = Date.now() - LATEST_FALLBACK_MS;
+	let best;
+	for (const entry of imessageReplyCacheByMessageId.values()) {
+		if (entry.accountId !== ctx.accountId) continue;
+		if (entry.timestamp < cutoff) continue;
+		if (!isPositiveIMessageChatMatch(entry, ctx)) continue;
+		if (!best || entry.timestamp > best.timestamp) best = entry;
+	}
+	return best;
+}
+function resolveIMessageCachedResourceBinding(messageId, ctx) {
+	hydrateFromStoreOnce();
+	const entry = imessageReplyCacheByMessageId.get(messageId.trim());
+	if (!entry) return "unknown";
+	if (Date.now() - entry.timestamp > 216e5) return "unknown";
+	if (entry.accountId !== ctx.accountId) return "mismatch";
+	const chatMatch = resolveIMessageChatMatch(entry, ctx);
+	if (chatMatch !== "match") return chatMatch;
+	return "match";
+}
+function isIMessageCurrentMessageInChat(params) {
+	if (!params.accountId || !hasChatScope(params.chatContext)) return false;
+	const currentMessageId = normalizeOptionalString(String(params.currentMessageId));
+	if (!currentMessageId) return false;
+	hydrateFromStoreOnce();
+	const fullMessageId = /^\d+$/.test(currentMessageId) ? imessageShortIdToUuid.get(currentMessageId) : currentMessageId;
+	if (!fullMessageId) return false;
+	return resolveIMessageCachedResourceBinding(fullMessageId, {
+		...params.chatContext,
+		accountId: params.accountId
+	}) === "match";
+}
+//#endregion
 //#region extensions/imessage/src/client.ts
 var IMessageRpcRequestError = class extends Error {
 	constructor(message, code, data) {
@@ -329,35 +666,6 @@ function codeDelimiter(content) {
 	const longestRun = Math.max(0, ...[...content.matchAll(/`+/gu)].map((match) => match[0].length));
 	return "`".repeat(longestRun + 1);
 }
-function protectDunderIdentifiers(input) {
-	const protections = [];
-	let markdown = "";
-	let cursor = 0;
-	for (const match of input.matchAll(/__[\p{L}_][\p{L}\p{N}_]*__/gu)) {
-		const identifier = match[0];
-		const start = match.index ?? 0;
-		const end = start + identifier.length;
-		const before = input[start - 1];
-		const beforeBefore = input[start - 2];
-		const after = input[end];
-		const member = before === ".";
-		const call = after === "(";
-		const functionArgument = before === "(" && /[\p{L}\p{N}_]/u.test(beforeBefore ?? "");
-		if (!member && !call && !functionArgument && !(after === "[")) continue;
-		let token = `OCdunder${protections.length}token`;
-		while (input.includes(token)) token += "x";
-		markdown += input.slice(cursor, start) + token;
-		protections.push({
-			token,
-			identifier
-		});
-		cursor = end;
-	}
-	return {
-		markdown: markdown + input.slice(cursor),
-		protections
-	};
-}
 function applyTextEdits(text, edits) {
 	const ordered = edits.toSorted((left, right) => left.start - right.start);
 	let rendered = "";
@@ -372,26 +680,6 @@ function applyTextEdits(text, edits) {
 		mapOffset: (offset) => offset + ordered.reduce((delta, edit) => delta + (edit.end <= offset ? edit.text.length - edit.end + edit.start : 0), 0)
 	};
 }
-function restoreDunderIdentifiers(text, ranges, codeRanges, protections) {
-	const edited = applyTextEdits(text, protections.flatMap((protection) => {
-		const start = text.indexOf(protection.token);
-		return start === -1 ? [] : [{
-			start,
-			end: start + protection.token.length,
-			text: protection.identifier
-		}];
-	}));
-	const mapRange = (range) => ({
-		...range,
-		start: edited.mapOffset(range.start),
-		length: edited.mapOffset(range.start + range.length) - edited.mapOffset(range.start)
-	});
-	return {
-		text: edited.text,
-		ranges: ranges.map(mapRange),
-		codeRanges: codeRanges.map(mapRange)
-	};
-}
 function restoreCodeMarkers(text, ranges, codeRanges) {
 	const edited = applyTextEdits(text, codeRanges.map((range) => {
 		const end = range.start + range.length;
@@ -414,22 +702,21 @@ function restoreCodeMarkers(text, ranges, codeRanges) {
 	};
 }
 function extractMarkdownFormatRuns(input) {
-	const protectedDunders = protectDunderIdentifiers(input);
-	const ir = markdownToIR(protectedDunders.markdown, {
+	const ir = markdownToIR(input, {
 		autolink: false,
 		enableHtmlUnderline: true,
 		headingStyle: "rich",
 		linkify: false,
+		preserveDunderIdentifiers: true,
 		preserveSourceBlockSpacing: true
 	});
 	const rendered = renderMarkdownWithAttributedRanges(ir, { styleMap: IMESSAGE_STYLE_MAP }, IMESSAGE_FORMAT_PROFILE);
 	const code = renderMarkdownWithAttributedRanges(ir, { styleMap: { code: "code" } }, IMESSAGE_CODE_PROFILE);
-	const dunders = restoreDunderIdentifiers(rendered.text, rendered.ranges.map(({ start, length, style }) => ({
+	return restoreCodeMarkers(rendered.text, rendered.ranges.map(({ start, length, style }) => ({
 		start,
 		length,
 		styles: [style]
-	})), code.ranges, protectedDunders.protections);
-	return restoreCodeMarkers(dunders.text, dunders.ranges, dunders.codeRanges);
+	})), code.ranges);
 }
 //#endregion
 //#region extensions/imessage/src/monitor/sanitize-outbound.ts
@@ -893,4 +1180,4 @@ function sanitizeOutboundText(text) {
 	return cleaned;
 }
 //#endregion
-export { IMessageRpcRequestError as a, DEFAULT_IMESSAGE_SEND_TIMEOUT_MS as c, extractMarkdownFormatRuns as i, sanitizeIMessageFinalOutboundText as n, createIMessageRpcClient as o, sanitizeOutboundText as r, DEFAULT_IMESSAGE_PROBE_TIMEOUT_MS as s, protectIMessageFencedRoleMarkers as t };
+export { normalizeDirectChatIdentifier as _, IMessageRpcRequestError as a, isIMessageCurrentMessageInChat as c, resolveIMessageCachedResourceBinding as d, resolveIMessageMessageId as f, isIMessageEmailChatIdentifier as g, chatContextFromIMessageTarget as h, extractMarkdownFormatRuns as i, isKnownFromMeIMessageMessageId as l, DEFAULT_IMESSAGE_SEND_TIMEOUT_MS as m, sanitizeIMessageFinalOutboundText as n, createIMessageRpcClient as o, DEFAULT_IMESSAGE_PROBE_TIMEOUT_MS as p, sanitizeOutboundText as r, findLatestIMessageEntryForChat as s, protectIMessageFencedRoleMarkers as t, rememberIMessageReplyCache as u, resolveIMessageDirectChatService as v };

package/dist/{send-Dake4Awx.js → send-mgWPKqSV.js}

@@ -1,21 +1,21 @@
-import { d as resolveIMessageChatDbLookupPath, l as resolveIMessageRemoteHost, n as hasExclusiveIMessageLocalDatabase, o as resolveIMessageAccount } from "./accounts-D00Njxg2.js";
-import { l as parseIMessageTarget, n as formatIMessageChatTarget, s as normalizeIMessageHandle } from "./message-tool-api-TZiNYA17.js";
-import { c as rememberIMessageReplyCache, h as chatContextFromIMessageTarget, p as getOptionalIMessageRuntime, v as resolveIMessageDirectChatService } from "./monitor-reply-cache-BdeUQaHO.js";
-import { a as IMessageRpcRequestError, n as sanitizeIMessageFinalOutboundText, o as createIMessageRpcClient, t as protectIMessageFencedRoleMarkers } from "./sanitize-outbound-DaLmdkbf.js";
-import { _ as imessageApprovalAuth, g as getIMessageApprovalApprovers } from "./group-policy-Ca3c5KES.js";
-import { a as rememberPersistedIMessageEcho, r as forgetPersistedIMessageEchoKey } from "./persisted-echo-cache-DGxy-J4t.js";
-import { d as normalizeConversationKey, f as normalizeIMessageGuid, i as registerIMessageApprovalReactionTarget, l as enumerateApprovalTargetKeys, s as buildIMessageApprovalConversationKeyForInbound, u as enumerateConversationKeyForms } from "./approval-reactions-BME5eA6T.js";
-import { i as runIMessageCliJsonCommand, r as resolveAuthorizedIMessageReplyReference, t as withIMessageRemoteFile } from "./remote-file-CDuk0joc.js";
+import { d as resolveIMessageChatDbLookupPath, l as resolveIMessageRemoteHost, n as hasExclusiveIMessageLocalDatabase, o as resolveIMessageAccount } from "./accounts-CCirBEIm.js";
+import { l as parseIMessageTarget, n as formatIMessageChatTarget, s as normalizeIMessageHandle } from "./message-tool-api-CvIgJpOo.js";
+import { a as IMessageRpcRequestError, h as chatContextFromIMessageTarget, n as sanitizeIMessageFinalOutboundText, o as createIMessageRpcClient, t as protectIMessageFencedRoleMarkers, u as rememberIMessageReplyCache, v as resolveIMessageDirectChatService } from "./sanitize-outbound-Du-r1lNQ.js";
+import { l as getIMessageApprovalApprovers, u as imessageApprovalAuth } from "./group-policy-Dvc-BcWo.js";
+import { n as getOptionalIMessageRuntime, t as getIMessageRuntime } from "./runtime-Cza4CY5T.js";
+import { c as IMESSAGE_SENT_ECHOES_TTL_MS, d as resolveIMessageEchoMediaKey, p as resolveIMessageSentEchoEntryKey, s as IMESSAGE_SENT_ECHOES_NAMESPACE } from "./state-contract-4TK_cDDb.js";
+import { d as normalizeConversationKey, f as normalizeIMessageGuid, i as registerIMessageApprovalReactionTarget, l as enumerateApprovalTargetKeys, s as buildIMessageApprovalConversationKeyForInbound, u as enumerateConversationKeyForms } from "./approval-reactions-LL5yn1Rc.js";
+import { i as runIMessageCliJsonCommand, r as resolveAuthorizedIMessageReplyReference, t as withIMessageRemoteFile } from "./remote-file-6mCj2ZBy.js";
 import { createMessageReceiptFromOutboundResults } from "openclaw/plugin-sdk/channel-outbound";
 import { createLazyRuntimeSurface } from "openclaw/plugin-sdk/lazy-runtime";
 import { accessSync, constants } from "node:fs";
 import { basename } from "node:path";
 import { asOptionalRecord, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
-import { sleep } from "openclaw/plugin-sdk/runtime-env";
+import { logVerbose, sleep } from "openclaw/plugin-sdk/runtime-env";
+import { extractOriginalFilename, kindFromMime, resolveOutboundAttachmentFromUrl } from "openclaw/plugin-sdk/media-runtime";
 import { asDateTimestampMs } from "openclaw/plugin-sdk/number-runtime";
 import { PlatformMessageNotDispatchedError, isApprovalNotFoundError } from "openclaw/plugin-sdk/error-runtime";
 import { addApprovalReactionHintToText, createApprovalReactionTargetStore, listApprovalReactionBindings } from "openclaw/plugin-sdk/approval-reaction-runtime";
-import { extractOriginalFilename, kindFromMime, resolveOutboundAttachmentFromUrl } from "openclaw/plugin-sdk/media-runtime";
 import { convertMarkdownTables, stripInlineDirectiveTagsForDelivery } from "openclaw/plugin-sdk/text-chunking";
 import { createChannelPartialDeliveryError } from "openclaw/plugin-sdk/channel-inbound";
 import { openNodeSqliteDatabase } from "openclaw/plugin-sdk/sqlite-runtime";
@@ -453,6 +453,127 @@ const iMessageApprovalPollTargets = {
 	clearForTest: clearIMessageApprovalPollTargetsForTest
 };
 //#endregion
+//#region extensions/imessage/src/monitor/echo-text-corruption.ts
+function isLeadingEchoTextCorruptionMarker(code) {
+	return code === 0 || code === 65279 || code === 65533 || code === 65534 || code === 65535;
+}
+function stripLeadingEchoTextCorruptionMarkers(text) {
+	let offset = 0;
+	while (offset < text.length && isLeadingEchoTextCorruptionMarker(text.charCodeAt(offset))) offset += 1;
+	return offset === 0 ? text : text.slice(offset);
+}
+//#endregion
+//#region extensions/imessage/src/monitor/persisted-echo-cache.ts
+function normalizeText(text) {
+	if (!text) return;
+	return stripLeadingEchoTextCorruptionMarkers(text.replace(/\r\n?/g, "\n").trim()).trim() || void 0;
+}
+function normalizeMessageId(messageId) {
+	const normalized = messageId?.trim();
+	if (!normalized || normalized === "ok" || normalized === "unknown") return;
+	return normalized;
+}
+let mirror = null;
+let persistenceFailureLogged = false;
+function reportFailure(scope, err) {
+	if (persistenceFailureLogged) return;
+	persistenceFailureLogged = true;
+	logVerbose(`imessage echo-cache: ${scope} disabled after first failure: ${String(err)}`);
+}
+function normalizeMedia(media) {
+	if (!resolveIMessageEchoMediaKey(media)) return;
+	const contentType = media?.contentType?.trim().toLowerCase() || void 0;
+	const kind = media?.kind ?? void 0;
+	return {
+		...kind ? { kind } : {},
+		...contentType ? { contentType } : {}
+	};
+}
+function openPersistedEchoStore() {
+	return getIMessageRuntime().state.openSyncKeyedStore({
+		namespace: IMESSAGE_SENT_ECHOES_NAMESPACE,
+		maxEntries: 256
+	});
+}
+function remainingTtlMs(timestamp) {
+	const remaining = IMESSAGE_SENT_ECHOES_TTL_MS - Math.max(0, Date.now() - timestamp);
+	return remaining > 0 ? remaining : void 0;
+}
+function resolveEntryTtlMs(entry, ttlMs) {
+	if (typeof ttlMs === "number" && Number.isFinite(ttlMs) && ttlMs > 0) return ttlMs;
+	return remainingTtlMs(entry.timestamp);
+}
+function isLiveEntry(entry, now = Date.now()) {
+	const cutoff = now - IMESSAGE_SENT_ECHOES_TTL_MS;
+	return entry.timestamp >= cutoff && (entry.expiresAt == null || entry.expiresAt > now);
+}
+function loadMirrorFromStore() {
+	try {
+		mirror = openPersistedEchoStore().entries().map(({ value }) => value).filter((entry) => isLiveEntry(entry)).toSorted((a, b) => a.timestamp - b.timestamp).slice(-256);
+	} catch (err) {
+		reportFailure("read", err);
+		mirror = [];
+	}
+}
+function readRecentEntries() {
+	loadMirrorFromStore();
+	return mirror ?? [];
+}
+function persistEntry(entry, ttlMs) {
+	const effectiveTtlMs = resolveEntryTtlMs(entry, ttlMs);
+	if (!effectiveTtlMs) return;
+	const key = resolveIMessageSentEchoEntryKey(entry);
+	try {
+		openPersistedEchoStore().register(key, entry, { ttlMs: effectiveTtlMs });
+	} catch (err) {
+		reportFailure("write", err);
+		return;
+	}
+	return key;
+}
+function rememberPersistedIMessageEcho(params) {
+	const text = normalizeText(params.text);
+	const media = normalizeMedia(params.media);
+	const messageId = normalizeMessageId(params.messageId);
+	const entry = {
+		scope: params.scope,
+		timestamp: Date.now(),
+		...text ? { text } : {},
+		...media ? { media } : {},
+		...messageId ? { messageId } : {},
+		...params.pending ? { pending: true } : {}
+	};
+	if (typeof params.ttlMs === "number" && Number.isFinite(params.ttlMs) && params.ttlMs > 0) entry.expiresAt = entry.timestamp + params.ttlMs;
+	if (!entry.text && !entry.media && !entry.messageId) return;
+	loadMirrorFromStore();
+	const key = persistEntry(entry, params.ttlMs);
+	mirror = [...mirror ?? [], entry].filter((candidate) => isLiveEntry(candidate)).slice(-256);
+	return key;
+}
+function forgetPersistedIMessageEchoKey(key) {
+	if (!key) return;
+	try {
+		openPersistedEchoStore().delete(key);
+	} catch (err) {
+		reportFailure("delete", err);
+	}
+	mirror = (mirror ?? []).filter((entry) => resolveIMessageSentEchoEntryKey(entry) !== key);
+}
+function hasPersistedIMessageEcho(params) {
+	const text = normalizeText(params.text);
+	const mediaKey = resolveIMessageEchoMediaKey(params.media);
+	const messageId = normalizeMessageId(params.messageId);
+	if (!text && !mediaKey && !messageId) return false;
+	for (const entry of readRecentEntries()) {
+		if (entry.scope !== params.scope) continue;
+		if (messageId && entry.messageId === messageId) return true;
+		const hasConflictingMessageIds = Boolean(messageId && entry.messageId && messageId !== entry.messageId);
+		if (text && (!hasConflictingMessageIds || params.skipIdShortCircuit) && entry.text === text && (!entry.pending || params.includePendingText)) return true;
+		if (mediaKey && !hasConflictingMessageIds && resolveIMessageEchoMediaKey(entry.media) === mediaKey && (!entry.pending || params.includePendingText)) return true;
+	}
+	return false;
+}
+//#endregion
 //#region extensions/imessage/src/send.ts
 const MIN_PENDING_PERSISTED_ECHO_TTL_MS = 6e4;
 const PENDING_PERSISTED_ECHO_GRACE_MS = 5e3;
@@ -1173,4 +1294,4 @@ async function sendMessageIMessage(to, text, opts) {
 	}
 }
 //#endregion
-export { maybeResolveIMessageApprovalPollVote as a, mapSentPollOptionsToDecisions as i, buildApprovalPollOptions as n, iMessageApprovalControlBindings as o, iMessageApprovalPollTargets as r, sendMessageIMessage as t };
+export { iMessageApprovalPollTargets as a, iMessageApprovalControlBindings as c, buildApprovalPollOptions as i, hasPersistedIMessageEcho as n, mapSentPollOptionsToDecisions as o, stripLeadingEchoTextCorruptionMarkers as r, maybeResolveIMessageApprovalPollVote as s, sendMessageIMessage as t };

package/dist/state-contract-4TK_cDDb.js

@@ -0,0 +1,56 @@
+import { createHash } from "node:crypto";
+//#region extensions/imessage/src/state-contract.ts
+const IMESSAGE_REPLY_CACHE_NAMESPACE = "imessage.reply-cache";
+const IMESSAGE_REPLY_CACHE_MAX_ENTRIES = 2e3;
+const IMESSAGE_REPLY_CACHE_COUNTER_NAMESPACE = "imessage.reply-cache-counter";
+const IMESSAGE_REPLY_CACHE_COUNTER_KEY = "short-id-counter";
+const IMESSAGE_REPLY_CACHE_TTL_MS = 360 * 60 * 1e3;
+function resolveIMessageReplyCacheEntryKey(messageId) {
+	return createHash("sha256").update(messageId, "utf8").digest("hex").slice(0, 32);
+}
+const MAX_FAILURE_RETRY_MAP_SIZE = 512;
+const MAX_FAILURE_RETRY_MAP_JSON_BYTES = 48e3;
+const textEncoder = new TextEncoder();
+const IMESSAGE_CATCHUP_CURSOR_NAMESPACE = "imessage.catchup-cursors";
+function resolveIMessageCatchupCursorKey(accountId) {
+	return createHash("sha256").update(accountId, "utf8").digest("hex").slice(0, 32);
+}
+/**
+* Bound the retry map so a pathological storm of unique failing GUIDs
+* cannot grow the cursor value without limit. Keeps the `maxSize` entries
+* with the highest counts (closest to give-up) when over the bound.
+*/
+function capFailureRetriesMap(map, maxSize = MAX_FAILURE_RETRY_MAP_SIZE, maxBytes = MAX_FAILURE_RETRY_MAP_JSON_BYTES) {
+	const entries = Object.entries(map);
+	if (entries.length <= maxSize && textEncoder.encode(JSON.stringify(map)).byteLength <= maxBytes) return map;
+	entries.sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]));
+	const capped = {};
+	for (const [guid, count] of entries.slice(0, maxSize)) {
+		capped[guid] = count;
+		if (textEncoder.encode(JSON.stringify(capped)).byteLength > maxBytes) {
+			delete capped[guid];
+			break;
+		}
+	}
+	return capped;
+}
+const IMESSAGE_SENT_ECHOES_TTL_MS = 720 * 60 * 1e3;
+const IMESSAGE_SENT_ECHOES_NAMESPACE = "imessage.sent-echoes";
+function resolveIMessageSentEchoEntryKey(entry) {
+	return createHash("sha256").update(JSON.stringify([
+		entry.scope,
+		entry.text ?? "",
+		resolveIMessageEchoMediaKey(entry.media) ?? "",
+		entry.messageId ?? "",
+		entry.timestamp
+	])).digest("hex").slice(0, 32);
+}
+function resolveIMessageEchoMediaKey(media) {
+	const contentType = media?.contentType?.trim().toLowerCase() || void 0;
+	const kind = media?.kind && media.kind !== "unknown" ? media.kind : void 0;
+	if (kind) return `kind:${kind}`;
+	const normalizedContentType = contentType?.split(";", 1)[0]?.trim();
+	return normalizedContentType ? `mime:${normalizedContentType}` : void 0;
+}
+//#endregion
+export { IMESSAGE_REPLY_CACHE_NAMESPACE as a, IMESSAGE_SENT_ECHOES_TTL_MS as c, resolveIMessageEchoMediaKey as d, resolveIMessageReplyCacheEntryKey as f, IMESSAGE_REPLY_CACHE_MAX_ENTRIES as i, capFailureRetriesMap as l, IMESSAGE_REPLY_CACHE_COUNTER_KEY as n, IMESSAGE_REPLY_CACHE_TTL_MS as o, resolveIMessageSentEchoEntryKey as p, IMESSAGE_REPLY_CACHE_COUNTER_NAMESPACE as r, IMESSAGE_SENT_ECHOES_NAMESPACE as s, IMESSAGE_CATCHUP_CURSOR_NAMESPACE as t, resolveIMessageCatchupCursorKey as u };