@openclaw/imessage 2026.9.1-beta.1 → 2026.9.2

package/dist/{sanitize-outbound-g651fIhi.js → sanitize-outbound-Bvo4g1Mp.js}

@@ -1,15 +1,425 @@
-import { u as expandIMessageUserPath } from "./accounts-DIpGOIiN.js";
-import { normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { u as expandIMessageUserPath } from "./accounts-CCirBEIm.js";
+import { m as invalidateCachedIMessagePrivateApiStatus } from "./message-tool-api-CUoFESHj.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-DvahEY4X.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 { runCommandWithTimeout } from "openclaw/plugin-sdk/process-runtime";
 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 = 6e5;
+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/cli-output.ts
+const IMESSAGE_CLI_STDOUT_MAX_BYTES = 8388608;
+const IMESSAGE_CLI_STDERR_TAIL_BYTES = 65536;
+function parseLastJsonObject(stdout) {
+	const last = stdout.split(/\r?\n/u).findLast((line) => line.trim().length > 0)?.trim();
+	if (!last) return null;
+	try {
+		const value = JSON.parse(last);
+		return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+	} catch {
+		return null;
+	}
+}
+async function runIMessageCliJsonCommand(params) {
+	const dbPath = params.dbPath?.trim();
+	const argv = [
+		expandIMessageUserPath(params.cliPath),
+		...params.args,
+		...dbPath ? ["--db", dbPath] : [],
+		"--json"
+	];
+	const result = await runCommandWithTimeout(argv, {
+		killProcessTree: true,
+		maxOutputBytes: {
+			stdout: IMESSAGE_CLI_STDOUT_MAX_BYTES,
+			stderr: IMESSAGE_CLI_STDERR_TAIL_BYTES
+		},
+		outputCapture: {
+			stdout: "head",
+			stderr: "tail"
+		},
+		terminateOnOutputLimit: { stdout: true },
+		timeoutMs: params.timeoutMs
+	});
+	if (result.termination === "timeout") throw new Error(`iMessage action timed out after ${params.timeoutMs}ms`);
+	if (result.outputLimitExceeded || result.stdoutTruncatedBytes) throw new Error(`imsg stdout exceeded ${IMESSAGE_CLI_STDOUT_MAX_BYTES} bytes`);
+	const parsed = parseLastJsonObject(result.stdout);
+	if (result.code !== 0) {
+		const detail = typeof parsed?.error === "string" && parsed.error.trim() || result.stderr.trim() || result.stdout.trim() || `imsg exited with code ${result.code}`;
+		throw new Error(detail);
+	}
+	if (!parsed) throw new Error(`imsg returned non-JSON output: ${result.stdout.trim() || result.stderr.trim()}`);
+	if (parsed.success === false) {
+		const detail = typeof parsed.error === "string" && parsed.error.trim() ? parsed.error.trim() : "iMessage action failed";
+		throw new Error(detail);
+	}
+	return parsed;
+}
+//#endregion
+//#region extensions/imessage/src/bridge-recovery.ts
+const BRIDGE_RECOVERY_TIMEOUT_MS = 3e4;
+const recoveries = /* @__PURE__ */ new Map();
+/**
+* Re-inject the private bridge after imsg has positively identified it as
+* unresponsive. This deliberately does not retry the failed mutation: imsg may
+* still reconcile a published send, so replaying it could duplicate a message.
+*/
+function recoverIMessageBridge(cliPath) {
+	const existing = recoveries.get(cliPath);
+	if (existing) return existing;
+	const recovery = runIMessageCliJsonCommand({
+		cliPath,
+		args: ["launch"],
+		timeoutMs: BRIDGE_RECOVERY_TIMEOUT_MS
+	}).then(() => void 0).finally(() => {
+		recoveries.delete(cliPath);
+	});
+	recoveries.set(cliPath, recovery);
+	return recovery;
+}
+//#endregion
 //#region extensions/imessage/src/client.ts
 var IMessageRpcRequestError = class extends Error {
 	constructor(message, code, data) {
@@ -19,6 +429,16 @@ var IMessageRpcRequestError = class extends Error {
 		this.name = "IMessageRpcRequestError";
 	}
 };
+function isIMessageBridgeStall(error) {
+	if (!(error instanceof Error)) return false;
+	return error.message.includes("Timed out waiting for response");
+}
+const BRIDGE_STALL_GUIDANCE = "The imsg private API bridge stopped responding. Run `imsg launch` to re-inject the dylib, then `openclaw channels status --probe` to refresh capability detection.";
+function describeIMessageBridgeStall(error) {
+	if (error instanceof IMessageRpcRequestError) return new IMessageRpcRequestError(`${error.message} ${BRIDGE_STALL_GUIDANCE}`, error.code, error.data);
+	if (error instanceof Error) return new Error(`${error.message} ${BRIDGE_STALL_GUIDANCE}`, { cause: error });
+	return error;
+}
 const PUBLIC_IMESSAGE_FULL_DISK_ACCESS_ERROR = "imsg cannot access ~/Library/Messages/chat.db. Grant Full Disk Access to the Gateway/launcher process and restart Gateway.";
 const IMESSAGE_RPC_CLOSE_GRACE_MS = 500;
 function isTestEnv() {
@@ -44,7 +464,8 @@ var IMessageRpcClient = class {
 		this.stderrDecoder = new StringDecoder("utf8");
 		this.nextId = 1;
 		this.publicProcessError = null;
-		this.cliPath = expandIMessageUserPath(opts.cliPath?.trim() || "imsg");
+		this.configuredCliPath = opts.cliPath?.trim() || "imsg";
+		this.cliPath = expandIMessageUserPath(this.configuredCliPath);
 		const dbPath = opts.dbPath?.trim();
 		this.dbPath = dbPath ? opts.remoteHost?.trim() ? dbPath : resolveUserPath(dbPath) : void 0;
 		this.runtime = opts.runtime;
@@ -129,7 +550,20 @@ var IMessageRpcClient = class {
 		} catch (err) {
 			this.failTransport(err, this.child);
 		}
-		return await response;
+		try {
+			return await response;
+		} catch (err) {
+			if (isIMessageBridgeStall(err)) {
+				invalidateCachedIMessagePrivateApiStatus(this.configuredCliPath);
+				try {
+					await recoverIMessageBridge(this.configuredCliPath);
+				} catch (recoveryError) {
+					this.runtime?.error?.(`imessage: automatic bridge recovery failed: ${formatErrorMessage(recoveryError)}`);
+				}
+				throw describeIMessageBridgeStall(err);
+			}
+			throw err;
+		}
 	}
 	async stopChild(child) {
 		try {
@@ -329,107 +763,61 @@ 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);
+function restoreCodeMarkers(text, ranges, codeRanges) {
 	let rendered = "";
 	let cursor = 0;
-	for (const edit of ordered) {
-		rendered += text.slice(cursor, edit.start) + edit.text;
-		cursor = edit.end;
-	}
-	rendered += text.slice(cursor);
-	return {
-		text: rendered,
-		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 edits = codeRanges.map((range) => {
 		const end = range.start + range.length;
 		const content = text.slice(range.start, end);
 		const marker = codeDelimiter(content);
 		const padding = content.startsWith("`") || content.endsWith("`") ? " " : "";
+		rendered += text.slice(cursor, range.start) + `${marker}${padding}${content}${padding}${marker}`;
+		cursor = end;
 		return {
-			start: range.start,
 			end,
-			text: `${marker}${padding}${content}${padding}${marker}`
+			shift: rendered.length - end
 		};
-	}));
+	});
+	rendered += text.slice(cursor);
+	const mapOffset = (offset) => {
+		let low = 0;
+		let high = edits.length;
+		while (low < high) {
+			const middle = low + Math.floor((high - low) / 2);
+			const edit = edits[middle];
+			if (edit && edit.end <= offset) low = middle + 1;
+			else high = middle;
+		}
+		return offset + (edits[low - 1]?.shift ?? 0);
+	};
 	return {
-		text: edited.text,
-		ranges: ranges.map((range) => ({
-			...range,
-			start: edited.mapOffset(range.start),
-			length: edited.mapOffset(range.start + range.length) - edited.mapOffset(range.start)
-		}))
+		text: rendered,
+		ranges: ranges.map((range) => {
+			const start = mapOffset(range.start);
+			return {
+				...range,
+				start,
+				length: mapOffset(range.start + range.length) - start
+			};
+		})
 	};
 }
 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 +1281,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 { isIMessageEmailChatIdentifier as _, IMessageRpcRequestError as a, findLatestIMessageEntryForChat as c, rememberIMessageReplyCache as d, resolveIMessageCachedResourceBinding as f, chatContextFromIMessageTarget as g, DEFAULT_IMESSAGE_SEND_TIMEOUT_MS as h, extractMarkdownFormatRuns as i, isIMessageCurrentMessageInChat as l, DEFAULT_IMESSAGE_PROBE_TIMEOUT_MS as m, sanitizeIMessageFinalOutboundText as n, createIMessageRpcClient as o, resolveIMessageMessageId as p, sanitizeOutboundText as r, runIMessageCliJsonCommand as s, protectIMessageFencedRoleMarkers as t, isKnownFromMeIMessageMessageId as u, normalizeDirectChatIdentifier as v, resolveIMessageDirectChatService as y };