@openclaw/imessage 2026.10.10 → 2026.11.5-beta.1

package/dist/.setup/{accounts-BH0coL46.mjs → accounts-C1Ypv3Wn.mjs}

@@ -1,7 +1,7 @@
 import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { normalizeAccountId, resolveAccountEntry } from "openclaw/plugin-sdk/account-resolution";
 import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk/account-id";
-import { accessSync, constants, readFileSync, realpathSync, statSync } from "node:fs";
+import { accessSync, constants, readFileSync, statSync } from "node:fs";
 import path from "node:path";
 import { createAccountListHelpers } from "openclaw/plugin-sdk/account-helpers";
 import { expectDefined } from "openclaw/plugin-sdk/expect-runtime";
@@ -49,7 +49,7 @@ function resolveIMessageExecutable(cliPath) {
 }
 function isMachOExecutable(filePath) {
 	try {
-		return MACH_O_MAGICS.has(readFileSync(realpathSync(filePath)).subarray(0, 4).toString("hex"));
+		return MACH_O_MAGICS.has(readFileSync(filePath).subarray(0, 4).toString("hex"));
 	} catch {
 		return false;
 	}
@@ -63,7 +63,7 @@ function isProvenLocalIMessageCliPath(params) {
 	const executable = resolveIMessageExecutable(cliPath);
 	let local = executable ? isMachOExecutable(executable) : false;
 	if (executable && !local) try {
-		const match = readFileSync(realpathSync(executable), "utf8").match(/^#![^\r\n]+\r?\n\s*exec\s+(?:"([^"]+)"|'([^']+)'|(\S+))\s+"\$@"\s*$/u);
+		const match = readFileSync(executable, "utf8").match(/^#![^\r\n]+\r?\n\s*exec\s+(?:"([^"]+)"|'([^']+)'|(\S+))\s+"\$@"\s*$/u);
 		const target = match?.[1] ?? match?.[2] ?? match?.[3];
 		local = Boolean(target && path.isAbsolute(target) && isMachOExecutable(target));
 	} catch {
@@ -148,8 +148,8 @@ async function resolveIMessageRemoteHost(params) {
 	const { logVerbose } = await import("openclaw/plugin-sdk/runtime-env");
 	if (params.remoteHost?.trim()) logVerbose("imessage: ignoring unsafe configured remoteHost value");
 	const key = cacheKey(params.cliPath);
-	if (detectedRemoteHosts.has(key)) {
-		const cached = detectedRemoteHosts.get(key);
+	const cached = detectedRemoteHosts.get(key);
+	if (cached !== void 0) {
 		if (cached === ambiguousSshWrapper) throwAmbiguousSshWrapper();
 		return cached ?? void 0;
 	}
@@ -171,7 +171,6 @@ async function resolveIMessageRemoteHost(params) {
 			detectedRemoteHosts.set(key, ambiguousSshWrapper);
 			throwAmbiguousSshWrapper();
 		}
-		if (detected) logVerbose(`imessage: detected remoteHost=${detected} from cliPath`);
 		detectedRemoteHosts.set(key, detected ?? null);
 		return detected;
 	})().finally(() => remoteHostLookups.delete(key));
@@ -211,7 +210,7 @@ function resolveIMessageAccount(params) {
 	const baseEnabled = params.cfg.channels?.imessage?.enabled !== false;
 	const merged = mergeIMessageAccountConfig(params.cfg, accountId);
 	const accountEnabled = merged.enabled !== false;
-	const configured = Boolean(merged.enabled === true || merged.cliPath?.trim() || merged.dbPath?.trim() || merged.service || merged.sendTransport || merged.region?.trim() || merged.allowFrom && merged.allowFrom.length > 0 || merged.groupAllowFrom && merged.groupAllowFrom.length > 0 || merged.dmPolicy || merged.groupPolicy || typeof merged.includeAttachments === "boolean" || merged.attachmentRoots && merged.attachmentRoots.length > 0 || merged.remoteAttachmentRoots && merged.remoteAttachmentRoots.length > 0 || typeof merged.mediaMaxMb === "number" || typeof merged.textChunkLimit === "number" || merged.groups && Object.keys(merged.groups).length > 0);
+	const configured = Boolean(merged.enabled === true || merged.cliPath?.trim() || merged.dbPath?.trim() || merged.service || merged.sendTransport || merged.region?.trim() || merged.allowFrom && merged.allowFrom.length > 0 || merged.groupAllowFrom && merged.groupAllowFrom.length > 0 || merged.dmPolicy || merged.groupPolicy || merged.includeAttachments !== void 0 || merged.attachmentRoots && merged.attachmentRoots.length > 0 || merged.remoteAttachmentRoots && merged.remoteAttachmentRoots.length > 0 || merged.mediaMaxMb !== void 0 || merged.textChunkLimit !== void 0 || merged.groups && Object.keys(merged.groups).length > 0);
 	return {
 		accountId,
 		enabled: baseEnabled && accountEnabled,

package/dist/.setup/{actions-CW7XYYF4.mjs → actions-qOuKy8To.mjs}

@@ -1,18 +1,20 @@
-import { c as parseIMessageTarget } from "./targets-CIx4BKqL.mjs";
-import { l as resolveIMessageRemoteHost, n as hasExclusiveIMessageLocalDatabase, o as resolveIMessageAccount, u as expandIMessageUserPath } from "./accounts-BH0coL46.mjs";
-import { a as setCachedIMessagePrivateApiStatus, n as getCachedIMessagePrivateApiStatus, o as IMESSAGE_ACTIONS, r as imessageRpcSupportsMethod, s as IMESSAGE_ACTION_NAMES, t as describeIMessageMessageTool } from "./message-tool-api-CxSY_rh7.mjs";
-import { a as isIMessageCurrentMessageInChatAsync, i as findLatestIMessageEntryForChat, n as createIMessageRpcClient, s as rememberIMessageReplyCache, y as chatContextFromIMessageTarget } from "./client-C3e7ZLqA.mjs";
-import { l as isAutoManagedIMessageCliPath, n as IMESSAGE_UPDATE_COMMAND, t as IMESSAGE_INSTALL_COMMAND } from "./setup-core-BWnW0czE.mjs";
-import { filterStringEntries, normalizeLowercaseStringOrEmpty, normalizeOptionalLowercaseString, normalizeStringEntries } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { l as parseIMessageTarget } from "./targets-C7CIWJ0k.mjs";
+import { l as resolveIMessageRemoteHost, n as hasExclusiveIMessageLocalDatabase, o as resolveIMessageAccount, u as expandIMessageUserPath } from "./accounts-C1Ypv3Wn.mjs";
+import { a as setCachedIMessagePrivateApiStatus, n as getCachedIMessagePrivateApiStatus, o as IMESSAGE_ACTIONS, r as imessageRpcSupportsMethod, s as IMESSAGE_ACTION_NAMES, t as describeIMessageMessageTool } from "./message-tool-api-DtZ1wKbT.mjs";
+import { i as resolveIMessageChatMatch, t as chatContextFromIMessageTarget } from "./chat-context-fTfJVqAi.mjs";
+import { n as createIMessageRpcClient } from "./client-D_BaG8sC.mjs";
+import { l as isAutoManagedIMessageCliPath, n as IMESSAGE_UPDATE_COMMAND, t as IMESSAGE_INSTALL_COMMAND } from "./setup-core-B1_P_t4T.mjs";
+import { filterStringEntries, normalizeLowercaseStringOrEmpty, normalizeOptionalLowercaseString, normalizeOptionalString, normalizeStringEntries } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { createLazyRuntimeNamedExport } from "openclaw/plugin-sdk/lazy-runtime";
 import path from "node:path";
 import { readBooleanParam } from "openclaw/plugin-sdk/boolean-param";
 import { createActionGate, jsonResult, readNonNegativeIntegerParam, readPositiveIntegerParam, readReactionParams, readStringArrayParam, readStringParam } from "openclaw/plugin-sdk/channel-actions";
 import { canonicalizeBase64 } from "openclaw/plugin-sdk/media-runtime";
 import { normalizePollInput } from "openclaw/plugin-sdk/poll-runtime";
-import { createSubsystemLogger } from "openclaw/plugin-sdk/runtime-env";
+import { createSubsystemLogger, logVerbose } from "openclaw/plugin-sdk/runtime-env";
 import { extractToolSend } from "openclaw/plugin-sdk/tool-send";
-import { asDateTimestampMs, resolveExpiresAtMsFromDurationMs } from "openclaw/plugin-sdk/number-runtime";
+import { createPluginRuntimeStore } from "openclaw/plugin-sdk/runtime-store";
+import { createHash } from "node:crypto";
 import { runCommandWithTimeout } from "openclaw/plugin-sdk/process-runtime";
 import { captureRuntimeConfigAsyncReader } from "openclaw/plugin-sdk/runtime-config-snapshot";
 import { detectBinary } from "openclaw/plugin-sdk/setup";
@@ -20,7 +22,6 @@ import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
 // extensions/imessage/src/message-action-reference.ts
 async function resolveAuthorizedIMessageActionReference(params) {
 	const options = {
-		requireKnownShortId: true,
 		chatContext: params.inputChatContext,
 		...params.requireFromMe ? { requireFromMe: true } : {}
 	};
@@ -34,10 +35,7 @@ async function resolveAuthorizedIMessageActionReference(params) {
 	await authorize(messageId, params.inputChatContext);
 	const chatGuid = await params.resolveChatGuid();
 	const chatContext = { chatGuid };
-	const resolvedMessageId = await params.resolveMessageId(messageId, {
-		requireKnownShortId: true,
-		chatContext
-	});
+	const resolvedMessageId = await params.resolveMessageId(messageId, { chatContext });
 	await authorize(resolvedMessageId, chatContext);
 	return {
 		messageId: resolvedMessageId,
@@ -54,31 +52,312 @@ function normalizeIMessageMessageId(value) {
 	const id = value?.trim();
 	return id && id !== "ok" && id !== "unknown" ? id : void 0;
 }
+// extensions/imessage/src/persistence-failure.ts
+function createPersistenceFailureReporter(cache) {
+	let reported = false;
+	return (scope, err) => {
+		if (reported) return;
+		reported = true;
+		logVerbose(`imessage ${cache}: ${scope} disabled after first failure: ${String(err)}`);
+	};
+}
+// extensions/imessage/src/runtime.ts
+const { getRuntime: getIMessageRuntime, setRuntime: setIMessageRuntime, tryGetRuntime: getOptionalIMessageRuntime } = createPluginRuntimeStore({
+	pluginId: "imessage",
+	errorMessage: "iMessage runtime not initialized"
+});
+// 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 = 216e5;
+function resolveIMessageReplyCacheEntryKey(messageId) {
+	return createHash("sha256").update(messageId, "utf8").digest("hex").slice(0, 32);
+}
+const MAX_FAILURE_RETRY_MAP_SIZE = 512;
+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) {
+	const maxBytes = 48e3;
+	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 = 432e5;
+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;
+}
+// extensions/imessage/src/monitor-reply-cache.ts
+/** Recency window for the "react to the latest message" fallback. */
+const LATEST_FALLBACK_MS = 6e5;
+const reportPersistenceFailure = createPersistenceFailureReporter("reply-cache");
+const imessageReplyCacheByMessageId = /* @__PURE__ */ new Map();
+const imessageShortIdToUuid = /* @__PURE__ */ new Map();
+let imessageShortIdCounter = 0;
+function openReplyCacheStore() {
+	return getIMessageRuntime().state.openKeyedStoreV2({
+		namespace: IMESSAGE_REPLY_CACHE_NAMESPACE,
+		maxEntries: IMESSAGE_REPLY_CACHE_MAX_ENTRIES
+	});
+}
+function openReplyCacheCounterStore() {
+	return getIMessageRuntime().state.openKeyedStoreV2({
+		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;
+let hydration;
+let persistence = Promise.resolve();
+function hydrateCounter(counter) {
+	if (counter && Number.isSafeInteger(counter.counter) && counter.counter > 0) imessageShortIdCounter = Math.max(imessageShortIdCounter, counter.counter);
+}
+function hydrateRows(entries) {
+	const cutoff = Date.now() - IMESSAGE_REPLY_CACHE_TTL_MS;
+	for (const entry of entries.filter((cached) => cached.timestamp >= cutoff).toSorted((a, b) => a.timestamp - b.timestamp).slice(-2e3)) {
+		const numeric = Number.parseInt(entry.shortId, 10);
+		if (Number.isFinite(numeric) && numeric > imessageShortIdCounter) imessageShortIdCounter = numeric;
+		imessageReplyCacheByMessageId.set(entry.messageId, entry);
+		imessageShortIdToUuid.set(entry.shortId, entry.messageId);
+	}
+}
+async function hydrateFromStoreOnce() {
+	if (hydrated) return;
+	hydration ??= (async () => {
+		try {
+			hydrateCounter(await openReplyCacheCounterStore().lookup(IMESSAGE_REPLY_CACHE_COUNTER_KEY));
+			hydrateRows((await openReplyCacheStore().entries()).map(({ value }) => value));
+		} catch (err) {
+			reportPersistenceFailure("read", err);
+		} finally {
+			hydrated = true;
+		}
+	})();
+	await hydration;
+}
+async function persistReplyCacheEntry(entry) {
+	const ttlMs = remainingTtlMs(entry.timestamp);
+	if (!ttlMs) return;
+	try {
+		await openReplyCacheStore().register(resolveIMessageReplyCacheEntryKey(entry.messageId), entry, { ttlMs });
+	} catch (err) {
+		reportPersistenceFailure("write", err);
+	}
+}
+async function deleteReplyCacheEntry(messageId) {
+	try {
+		await openReplyCacheStore().delete(resolveIMessageReplyCacheEntryKey(messageId));
+	} catch (err) {
+		reportPersistenceFailure("delete", err);
+	}
+}
+async function persistReplyCacheCounter(counter) {
+	try {
+		await openReplyCacheCounterStore().register(IMESSAGE_REPLY_CACHE_COUNTER_KEY, { counter });
+	} catch (err) {
+		reportPersistenceFailure("counter", err);
+	}
+}
+function buildReplyCacheEntry(entry, messageId, shortId) {
+	return {
+		accountId: entry.accountId,
+		messageId,
+		shortId,
+		timestamp: entry.timestamp,
+		...entry.chatGuid !== void 0 ? { chatGuid: entry.chatGuid } : {},
+		...entry.chatIdentifier !== void 0 ? { chatIdentifier: entry.chatIdentifier } : {},
+		...entry.chatId !== void 0 ? { chatId: entry.chatId } : {},
+		...entry.isFromMe !== void 0 ? { isFromMe: entry.isFromMe } : {}
+	};
+}
+async function rememberIMessageReplyCache(entry) {
+	await hydrateFromStoreOnce();
+	const messageId = entry.messageId.trim();
+	if (!messageId) return {
+		...entry,
+		shortId: ""
+	};
+	let shortId = imessageReplyCacheByMessageId.get(messageId)?.shortId;
+	const isNewMessage = !shortId;
+	if (!shortId) {
+		shortId = String(++imessageShortIdCounter);
+		imessageShortIdToUuid.set(shortId, messageId);
+	}
+	const fullEntry = buildReplyCacheEntry(entry, messageId, shortId);
+	imessageReplyCacheByMessageId.delete(messageId);
+	imessageReplyCacheByMessageId.set(messageId, fullEntry);
+	const cutoff = Date.now() - IMESSAGE_REPLY_CACHE_TTL_MS;
+	const deletedMessageIds = [];
+	const pruneUntil = (retain) => {
+		for (const [key, cached] of imessageReplyCacheByMessageId) {
+			if (retain(key, cached)) break;
+			imessageReplyCacheByMessageId.delete(key);
+			deletedMessageIds.push(key);
+			if (cached.shortId) imessageShortIdToUuid.delete(cached.shortId);
+		}
+	};
+	pruneUntil((_key, cached) => cached.timestamp >= cutoff);
+	pruneUntil((key) => !key || imessageReplyCacheByMessageId.size <= 2e3);
+	const counter = imessageShortIdCounter;
+	persistence = persistence.then(async () => {
+		if (isNewMessage) await persistReplyCacheCounter(counter);
+		for (const messageIdToDelete of deletedMessageIds) await deleteReplyCacheEntry(messageIdToDelete);
+		await persistReplyCacheEntry(fullEntry);
+	});
+	await persistence;
+	return fullEntry;
+}
+function hasChatScope(ctx) {
+	if (!ctx) return false;
+	return Boolean(normalizeOptionalString(ctx.chatGuid) || normalizeOptionalString(ctx.chatIdentifier) || typeof ctx.chatId === "number");
+}
+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}`);
+}
+async function resolveIMessageMessageId(shortOrUuid, opts) {
+	const trimmed = shortOrUuid.trim();
+	if (!trimmed) return trimmed;
+	await hydrateFromStoreOnce();
+	const inputKind = /^\d+$/.test(trimmed) ? "short" : "uuid";
+	const messageId = inputKind === "short" ? imessageShortIdToUuid.get(trimmed) : trimmed;
+	if (!messageId) {
+		if (!hasChatScope(opts?.chatContext)) throw new Error(`iMessage short message id ${describeMessageIdForError(trimmed, "short")} requires a chat scope (chatGuid / chatIdentifier / chatId or a target).`);
+		throw new Error(`iMessage short message id ${describeMessageIdForError(trimmed, "short")} is no longer available. Use MessageSidFull.`);
+	}
+	const cached = imessageReplyCacheByMessageId.get(messageId);
+	if (cached && opts?.chatContext && (inputKind === "uuid" || hasChatScope(opts.chatContext)) && resolveIMessageChatMatch(cached, opts.chatContext) === "mismatch") throw buildCrossChatError(trimmed, inputKind, cached, opts.chatContext);
+	if (opts?.requireFromMe && cached?.isFromMe !== true) throw buildFromMeError(trimmed, inputKind);
+	return messageId;
+}
+async function isKnownFromMeIMessageMessageId(messageId, ctx) {
+	const trimmed = normalizeOptionalString(messageId);
+	if (!trimmed || !ctx.accountId || !hasChatScope(ctx)) return false;
+	await hydrateFromStoreOnce();
+	const cached = imessageReplyCacheByMessageId.get(trimmed);
+	if (!cached || cached.isFromMe !== true) return false;
+	return resolveCachedResourceBinding(trimmed, {
+		...ctx,
+		accountId: ctx.accountId
+	}) === "match";
+}
+async function isKnownFromMeIMessageTarget(params) {
+	const { accountId, chatId, chatGuid, chatIdentifier } = params;
+	const ctx = {
+		accountId,
+		chatId,
+		chatGuid,
+		chatIdentifier
+	};
+	for (const messageId of params.messageIds) if (await isKnownFromMeIMessageMessageId(messageId, ctx)) return true;
+	return false;
+}
+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.`);
+}
+/** Latest recent entry with a positive same-account conversation match; never guess a chat. */
+function findLatestIMessageEntryForChat(ctx) {
+	if (!hasChatScope(ctx) || !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 (resolveIMessageChatMatch(entry, ctx) !== "match") continue;
+		if (!best || entry.timestamp > best.timestamp) best = entry;
+	}
+	return best;
+}
+async function resolveIMessageCachedResourceBinding(messageId, ctx) {
+	await hydrateFromStoreOnce();
+	return resolveCachedResourceBinding(messageId, ctx);
+}
+function resolveCachedResourceBinding(messageId, ctx) {
+	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";
+	return resolveIMessageChatMatch(entry, ctx);
+}
+async function isIMessageCurrentMessageInChatAsync(params) {
+	await hydrateFromStoreOnce();
+	return isCurrentMessageInChat(params);
+}
+function isCurrentMessageInChat(params) {
+	if (!params.accountId || !hasChatScope(params.chatContext)) return false;
+	const currentMessageId = normalizeOptionalString(String(params.currentMessageId));
+	if (!currentMessageId) return false;
+	const fullMessageId = /^\d+$/.test(currentMessageId) ? imessageShortIdToUuid.get(currentMessageId) : currentMessageId;
+	if (!fullMessageId) return false;
+	return resolveCachedResourceBinding(fullMessageId, {
+		...params.chatContext,
+		accountId: params.accountId
+	}) === "match";
+}
 // extensions/imessage/src/probe.ts
 const RPC_SUPPORT_CACHE_TTL_MS = 3e5;
 const PRIVATE_API_NEGATIVE_TTL_MS = 1e4;
 const rpcSupportCache = /* @__PURE__ */ new Map();
 function cacheIMessagePrivateApiStatus(cliPath, status) {
-	if (status.available) {
-		setCachedIMessagePrivateApiStatus(cliPath, status, 0);
-		return;
-	}
-	const expiresAt = resolveExpiresAtMsFromDurationMs(PRIVATE_API_NEGATIVE_TTL_MS);
-	if (expiresAt !== void 0) setCachedIMessagePrivateApiStatus(cliPath, status, expiresAt);
+	setCachedIMessagePrivateApiStatus(cliPath, status, status.available ? 0 : Date.now() + PRIVATE_API_NEGATIVE_TTL_MS);
 }
 function setCachedRpcSupport(cliPath, result) {
-	const expiresAt = resolveExpiresAtMsFromDurationMs(RPC_SUPPORT_CACHE_TTL_MS);
-	if (expiresAt === void 0) return;
 	rpcSupportCache.set(cliPath, {
 		result,
-		expiresAt
+		expiresAt: Date.now() + RPC_SUPPORT_CACHE_TTL_MS
 	});
 }
 async function probeRpcSupport(cliPath, timeoutMs) {
 	const cached = rpcSupportCache.get(cliPath);
 	if (cached) {
-		const now = asDateTimestampMs(Date.now());
-		if (now !== void 0 && cached.expiresAt > now) return cached.result;
+		if (cached.expiresAt > Date.now()) return cached.result;
 		rpcSupportCache.delete(cliPath);
 	}
 	try {
@@ -134,6 +413,21 @@ async function probeIMessagePrivateApi(cliPath, timeoutMs, options = {}) {
 		const cached = getCachedIMessagePrivateApiStatus(key);
 		if (cached) return cached;
 	}
+	const unavailable = (error) => {
+		const status = {
+			available: false,
+			v2Ready: false,
+			selectors: {},
+			rpcMethods: [],
+			cliCapabilities: {
+				sendRichSupportsAttachment: false,
+				pollSendSupportsNoComment: false
+			},
+			error
+		};
+		cacheIMessagePrivateApiStatus(key, status);
+		return status;
+	};
 	try {
 		const result = await runCommandWithTimeout([
 			expandIMessageUserPath(key),
@@ -142,21 +436,7 @@ async function probeIMessagePrivateApi(cliPath, timeoutMs, options = {}) {
 		], { timeoutMs });
 		const combined = `${result.stdout}\n${result.stderr}`.trim();
 		const normalized = normalizeLowercaseStringOrEmpty(combined);
-		if (result.code !== 0 && normalized.includes("unknown subcommand") && normalized.includes("status")) {
-			const status = {
-				available: false,
-				v2Ready: false,
-				selectors: {},
-				rpcMethods: [],
-				cliCapabilities: {
-					sendRichSupportsAttachment: false,
-					pollSendSupportsNoComment: false
-				},
-				error: `imsg CLI does not support the "status" subcommand. Update imsg on the Messages Mac: ${IMESSAGE_UPDATE_COMMAND}`
-			};
-			cacheIMessagePrivateApiStatus(key, status);
-			return status;
-		}
+		if (result.code !== 0 && normalized.includes("unknown subcommand") && normalized.includes("status")) return unavailable(`imsg CLI does not support the "status" subcommand. Update imsg on the Messages Mac: ${IMESSAGE_UPDATE_COMMAND}`);
 		const lines = normalizeStringEntries(result.stdout.split(/\r?\n/));
 		let payload = null;
 		for (const line of lines.toReversed()) try {
@@ -193,19 +473,7 @@ async function probeIMessagePrivateApi(cliPath, timeoutMs, options = {}) {
 		cacheIMessagePrivateApiStatus(key, status);
 		return status;
 	} catch (err) {
-		const status = {
-			available: false,
-			v2Ready: false,
-			selectors: {},
-			rpcMethods: [],
-			cliCapabilities: {
-				sendRichSupportsAttachment: false,
-				pollSendSupportsNoComment: false
-			},
-			error: String(err)
-		};
-		cacheIMessagePrivateApiStatus(key, status);
-		return status;
+		return unavailable(String(err));
 	}
 }
 async function probeIMessage(timeoutMs, opts = {}) {
@@ -257,7 +525,7 @@ async function probeIMessage(timeoutMs, opts = {}) {
 	}
 }
 // extensions/imessage/src/actions.ts
-const loadIMessageActionsRuntime = createLazyRuntimeNamedExport(() => import("./actions.runtime-B2ZHQ3TJ.mjs"), "imessageActionsRuntime");
+const loadIMessageActionsRuntime = createLazyRuntimeNamedExport(() => import("./actions.runtime-Ccg9CARL.mjs"), "imessageActionsRuntime");
 const log = createSubsystemLogger("channels/imessage");
 const providerId = "imessage";
 const SUPPORTED_ACTIONS = /* @__PURE__ */ new Set([...IMESSAGE_ACTION_NAMES, "upload-file"]);
@@ -329,32 +597,9 @@ function readMessageIdWithChatFallback(params, chatContext) {
 	if (latest?.messageId) return latest.messageId;
 	return readStringParam(params, "messageId", { required: true });
 }
-async function resolveChatGuid(params) {
-	const target = resolveIMessageActionTarget(params);
-	if (!target) throw new Error(`iMessage ${params.action} requires chatGuid, chatId, chatIdentifier, or a chat target.`);
-	if (target.kind === "chat_guid") return target.chatGuid;
-	const synthesizedIdentifier = target.kind === "handle" ? `${target.service === "sms" ? "SMS" : "iMessage"};-;${target.to}` : "";
-	const lookupTarget = target.kind === "handle" ? {
-		kind: "chat_identifier",
-		chatIdentifier: synthesizedIdentifier
-	} : target;
-	const resolved = await params.runtime.resolveChatGuidForTarget({
-		target: lookupTarget,
-		options: params.options,
-		conversationReadOrigin: params.conversationReadOrigin
-	});
-	if (resolved) return resolved;
-	if (target.kind !== "handle") throw new Error(`iMessage ${params.action} failed: chatGuid not found for ${formatUnresolvedTarget(target)}.`);
-	if (params.action === "react" || params.action === "edit" || params.action === "unsend") throw new Error(`iMessage ${params.action} requires a known chat. No registered chat for the supplied target; send a message first or pass an explicit chatGuid.`);
-	return synthesizedIdentifier;
-}
 function formatUnresolvedTarget(target) {
 	return target.kind === "chat_id" ? "chat_id:<redacted>" : "chat_identifier:<redacted>";
 }
-function buildChatContextFromActionParams(params) {
-	const target = resolveIMessageActionTarget(params);
-	return target ? chatContextFromIMessageTarget(target, params.service) : {};
-}
 function mapTapbackReaction(emoji) {
 	const value = normalizeOptionalLowercaseString(emoji)?.replace(/\ufe0f/g, "");
 	return value ? [
@@ -399,7 +644,7 @@ function decodeBase64Buffer(params, action) {
 	if (!base64Buffer) throw new Error(`iMessage ${action} requires buffer (base64) parameter.`);
 	const canonical = canonicalizeBase64(base64Buffer.replaceAll("-", "+").replaceAll("_", "/"));
 	if (!canonical) throw new Error(`iMessage ${action} buffer must be valid base64.`);
-	return Uint8Array.from(Buffer.from(canonical, "base64"));
+	return Buffer.from(canonical, "base64");
 }
 const REPLY_ATTACHMENT_PATH_PARAM_NAMES = [
 	"filePath",
@@ -408,21 +653,6 @@ const REPLY_ATTACHMENT_PATH_PARAM_NAMES = [
 	"mediaUrl",
 	"fileUrl"
 ];
-function extractReplyAttachment(params) {
-	if (readStringParam(params, "buffer")) {
-		const filename = readStringParam(params, "filename") ?? "attachment.bin";
-		return { spec: {
-			kind: "buffer",
-			buffer: decodeBase64Buffer(params, "reply attachment"),
-			filename
-		} };
-	}
-	for (const name of REPLY_ATTACHMENT_PATH_PARAM_NAMES) if (readStringParam(params, name)) return {
-		spec: null,
-		bypassParam: name
-	};
-	return null;
-}
 const EFFECT_ALIASES = {
 	slam: "com.apple.MobileSMS.expressivesend.impact",
 	impact: "com.apple.MobileSMS.expressivesend.impact",
@@ -509,20 +739,35 @@ const imessageMessageActions = {
 			timeoutMs: account.config.probeTimeoutMs
 		};
 		const attestedConversationReadOrigin = conversationReadOrigin ?? "delegated";
-		const chatGuid = async () => await resolveChatGuid({
-			action,
-			actionParams: params,
-			currentChannelId: toolContext?.currentChannelId,
-			conversationReadOrigin: attestedConversationReadOrigin,
-			runtime,
-			options: opts
-		});
+		const chatGuid = async () => {
+			const target = resolveIMessageActionTarget({
+				actionParams: params,
+				currentChannelId: toolContext?.currentChannelId
+			});
+			if (!target) throw new Error(`iMessage ${action} requires chatGuid, chatId, chatIdentifier, or a chat target.`);
+			if (target.kind === "chat_guid") return target.chatGuid;
+			const synthesizedIdentifier = target.kind === "handle" ? `${target.service === "sms" ? "SMS" : "iMessage"};-;${target.to}` : "";
+			const lookupTarget = target.kind === "handle" ? {
+				kind: "chat_identifier",
+				chatIdentifier: synthesizedIdentifier
+			} : target;
+			const resolved = await runtime.resolveChatGuidForTarget({
+				target: lookupTarget,
+				options: opts,
+				conversationReadOrigin: attestedConversationReadOrigin
+			});
+			if (resolved) return resolved;
+			if (target.kind !== "handle") throw new Error(`iMessage ${action} failed: chatGuid not found for ${formatUnresolvedTarget(target)}.`);
+			if (action === "react" || action === "edit" || action === "unsend") throw new Error(`iMessage ${action} requires a known chat. No registered chat for the supplied target; send a message first or pass an explicit chatGuid.`);
+			return synthesizedIdentifier;
+		};
 		const messageReference = async (input) => {
-			const inputChatContext = buildChatContextFromActionParams({
+			const service = account.config.service;
+			const target = resolveIMessageActionTarget({
 				actionParams: params,
-				currentChannelId: toolContext?.currentChannelId,
-				service: account.config.service
+				currentChannelId: toolContext?.currentChannelId
 			});
+			const inputChatContext = target ? chatContextFromIMessageTarget(target, service) : {};
 			return await resolveAuthorizedIMessageActionReference({
 				messageId: input?.messageId,
 				inputChatContext,
@@ -580,7 +825,7 @@ const imessageMessageActions = {
 			if (!remove && (isEmpty || !reaction)) throw new Error("iMessage react supports love, like, dislike, laugh, emphasize, and question tapbacks.");
 			const partIndex = readNonNegativeIntegerParam(params, "partIndex");
 			const reference = await messageReference();
-			const reactionsToSend = remove && !reaction ? [...TAPBACK_KINDS] : reaction ? [reaction] : [];
+			const reactionsToSend = remove && !reaction ? TAPBACK_KINDS : reaction ? [reaction] : [];
 			for (const kind of reactionsToSend) await runtime.sendReaction({
 				chatGuid: reference.chatGuid,
 				messageId: reference.messageId,
@@ -631,9 +876,16 @@ const imessageMessageActions = {
 			const text = readMessageText(params);
 			if (!text) throw new Error("iMessage reply requires text or message.");
 			const reference = await messageReference();
-			const attachment = extractReplyAttachment(params);
+			let attachment;
+			if (readStringParam(params, "buffer")) {
+				const filename = readStringParam(params, "filename") ?? "attachment.bin";
+				attachment = {
+					kind: "buffer",
+					buffer: decodeBase64Buffer(params, "reply attachment"),
+					filename
+				};
+			} else for (const name of REPLY_ATTACHMENT_PATH_PARAM_NAMES) if (readStringParam(params, name)) throw new Error(`iMessage reply rejected \`${name}\` because it did not pass through the outbound media resolver. Pass a base64 \`buffer\` + \`filename\` directly, or invoke message(action: "reply") through the runner so the resolver can validate the path against mediaLocalRoots/sandbox/size before sending.`);
 			if (attachment) {
-				if (attachment.spec === null) throw new Error(`iMessage reply rejected \`${attachment.bypassParam}\` because it did not pass through the outbound media resolver. Pass a base64 \`buffer\` + \`filename\` directly, or invoke message(action: "reply") through the runner so the resolver can validate the path against mediaLocalRoots/sandbox/size before sending.`);
 				if (!opts.remoteHost && privateApiStatus?.cliCapabilities?.sendRichSupportsAttachment !== true) throw new Error("iMessage reply with an attachment needs an imsg build that exposes `send-rich --file` (openclaw/imsg#114). Upgrade imsg, or use action 'upload-file' (with filePath/filename) or action 'send' (with media) to deliver the file plus a separate 'reply' for any text.");
 			}
 			const partIndex = readNonNegativeIntegerParam(params, "partIndex");
@@ -642,7 +894,7 @@ const imessageMessageActions = {
 				text,
 				replyToMessageId: reference.messageId,
 				partIndex,
-				attachment: attachment?.spec ?? void 0,
+				attachment,
 				options: opts
 			}), reference.chatGuid, { repliedTo: reference.messageId });
 		}
@@ -773,4 +1025,4 @@ const imessageMessageActions = {
 		throw new Error(`Action ${action} is not supported for provider ${providerId}.`);
 	}
 };
-export { normalizeIMessageMessageId as a, normalizeIMessageGuid as i, probeIMessage as n, probeIMessagePrivateApi as r, imessageMessageActions as t };
+export { setIMessageRuntime as _, rememberIMessageReplyCache as a, normalizeIMessageMessageId as b, IMESSAGE_CATCHUP_CURSOR_NAMESPACE as c, capFailureRetriesMap as d, resolveIMessageCatchupCursorKey as f, getOptionalIMessageRuntime as g, getIMessageRuntime as h, isKnownFromMeIMessageTarget as i, IMESSAGE_SENT_ECHOES_NAMESPACE as l, resolveIMessageSentEchoEntryKey as m, probeIMessage as n, resolveIMessageCachedResourceBinding as o, resolveIMessageEchoMediaKey as p, probeIMessagePrivateApi as r, resolveIMessageMessageId as s, imessageMessageActions as t, IMESSAGE_SENT_ECHOES_TTL_MS as u, createPersistenceFailureReporter as v, normalizeIMessageGuid as y };