@openclaw/imessage 2026.9.3 → 2026.9.5

package/dist/{question-reactions-9tBYB1_F.js → .setup/question-reactions-lm8OxWbb.mjs}

@@ -1,5 +1,5 @@
-import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
-import { n as normalizeIMessageGuid, t as resolveIMessageReactionContext } from "./reaction-context-Br-vAJFp.js";
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { n as normalizeIMessageGuid, t as resolveIMessageReactionContext } from "./reaction-context-Br-vAJFp.mjs";
 import { createQuestionReactionTargetStore, questionGatewayRuntime } from "openclaw/plugin-sdk/question-gateway-runtime";
 //#region extensions/imessage/src/question-reactions.ts
 var question_reactions_exports = /* @__PURE__ */ __exportAll({

package/dist/{remote-file-5n5LznCa.js → .setup/remote-file-4RbwiXYh.mjs}

@@ -1,5 +1,5 @@
-import { p as resolveLocalIMessageChatDbPath } from "./accounts-CCirBEIm.js";
-import { _ as isIMessageEmailChatIdentifier, f as resolveIMessageCachedResourceBinding, g as chatContextFromIMessageTarget, p as resolveIMessageMessageId } from "./sanitize-outbound-C6UF2cvr.js";
+import { p as resolveLocalIMessageChatDbPath } from "./accounts-Dv0uksBG.mjs";
+import { _ as chatContextFromIMessageTarget, m as resolveIMessageMessageId, p as resolveIMessageCachedResourceBinding, v as isIMessageEmailChatIdentifier } from "./sanitize-outbound-o1ePXajW.mjs";
 import path from "node:path";
 import { normalizeScpRemoteHost } from "openclaw/plugin-sdk/host-runtime";
 import { createSubsystemLogger } from "openclaw/plugin-sdk/runtime-env";
@@ -100,16 +100,16 @@ function sanitizeReplyToId(rawReplyToId) {
 	}
 	return sanitized.trim().slice(0, MAX_REPLY_TO_ID_LENGTH) || void 0;
 }
-function resolveAuthorizedIMessageReplyReference(params) {
+async function resolveAuthorizedIMessageReplyReference(params) {
 	if (!createActionGate(params.account.config.actions)("reply")) return;
 	const rawReplyToId = sanitizeReplyToId(params.replyToId);
 	if (!rawReplyToId) return;
 	const chatContext = chatContextFromIMessageTarget(params.target, params.service);
-	const messageId = resolveIMessageMessageId(rawReplyToId, {
+	const messageId = await resolveIMessageMessageId(rawReplyToId, {
 		requireKnownShortId: true,
 		chatContext
 	});
-	authorizeIMessageResourceReference({
+	await authorizeIMessageResourceReference({
 		accountId: params.account.accountId,
 		chatContext,
 		cliPath: params.cliPath,
@@ -121,14 +121,14 @@ function resolveAuthorizedIMessageReplyReference(params) {
 	});
 	return messageId;
 }
-function authorizeIMessageResourceReference(params) {
+async function authorizeIMessageResourceReference(params) {
 	const cacheContext = {
 		...params.chatContext,
 		accountId: params.accountId
 	};
-	let cacheBinding = resolveIMessageCachedResourceBinding(params.messageId, cacheContext);
+	let cacheBinding = await resolveIMessageCachedResourceBinding(params.messageId, cacheContext);
 	const normalizedMessageId = normalizeIMessageMessageGuidForLookup(params.messageId);
-	if (cacheBinding === "unknown" && normalizedMessageId !== params.messageId.trim()) cacheBinding = resolveIMessageCachedResourceBinding(normalizedMessageId, cacheContext);
+	if (cacheBinding === "unknown" && normalizedMessageId !== params.messageId.trim()) cacheBinding = await resolveIMessageCachedResourceBinding(normalizedMessageId, cacheContext);
 	if (cacheBinding === "match") return;
 	if (cacheBinding === "mismatch") throw new Error("iMessage message reference belongs to a different account or conversation.");
 	const providerBinding = params.hasExclusiveLocalDatabase ? checkIMessageResourceBinding(params) : "unavailable";
@@ -199,6 +199,7 @@ trap - EXIT HUP INT TERM
 	const cleanupScript = `set -eu
 rm -rf -- ${remoteDir}
 `;
+	params.assertDirectAdapterHandoff?.();
 	try {
 		await runChecked(run, "iMessage remote temporary directory allocation", [
 			"ssh",
@@ -212,6 +213,7 @@ rm -rf -- ${remoteDir}
 			timeoutMs: params.timeoutMs,
 			signal: params.signal
 		});
+		params.assertDirectAdapterHandoff?.();
 		await runChecked(run, "iMessage remote file upload", [
 			"scp",
 			...SSH_OPTIONS,
@@ -222,6 +224,7 @@ rm -rf -- ${remoteDir}
 			timeoutMs: params.timeoutMs,
 			signal: params.signal
 		});
+		params.assertDirectAdapterHandoff?.();
 		return await params.use(remotePath);
 	} finally {
 		try {

package/dist/{sanitize-outbound-C6UF2cvr.js → .setup/sanitize-outbound-o1ePXajW.mjs}

@@ -1,9 +1,9 @@
-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 { u as expandIMessageUserPath } from "./accounts-Dv0uksBG.mjs";
+import { i as invalidateCachedIMessagePrivateApiStatus } from "./message-tool-api-DZSH-2gY.mjs";
+import { t as getIMessageRuntime } from "./runtime-Cza4CY5T.mjs";
+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.mjs";
 import { normalizeLowercaseStringOrEmpty, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { normalizeE164 } from "openclaw/plugin-sdk/account-resolution";
 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";
@@ -112,13 +112,13 @@ const imessageShortIdToUuid = /* @__PURE__ */ new Map();
 const imessageUuidToShortId = /* @__PURE__ */ new Map();
 let imessageShortIdCounter = 0;
 function openReplyCacheStore() {
-	return getIMessageRuntime().state.openSyncKeyedStore({
+	return getIMessageRuntime().state.openKeyedStore({
 		namespace: IMESSAGE_REPLY_CACHE_NAMESPACE,
 		maxEntries: IMESSAGE_REPLY_CACHE_MAX_ENTRIES
 	});
 }
 function openReplyCacheCounterStore() {
-	return getIMessageRuntime().state.openSyncKeyedStore({
+	return getIMessageRuntime().state.openKeyedStore({
 		namespace: IMESSAGE_REPLY_CACHE_COUNTER_NAMESPACE,
 		maxEntries: 1
 	});
@@ -128,49 +128,72 @@ function remainingTtlMs(timestamp) {
 	return remaining > 0 ? remaining : void 0;
 }
 let hydrated = false;
-function hydrateFromStoreOnce() {
+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(-IMESSAGE_REPLY_CACHE_MAX_ENTRIES)) {
+		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);
+		imessageUuidToShortId.set(entry.messageId, entry.shortId);
+	}
+}
+async function hydrateFromStoreOnce() {
+	if (hydrated) return;
+	hydration ??= (async () => {
+		try {
+			hydrateCounter(await openReplyCacheCounterStore().lookup(IMESSAGE_REPLY_CACHE_COUNTER_KEY));
+			const entries = await openReplyCacheStore().entries();
+			if (!hydrated) hydrateRows(entries.map(({ value }) => value));
+		} catch (err) {
+			reportPersistenceFailure("read", err);
+		} finally {
+			hydrated = true;
+		}
+	})();
+	await hydration;
+}
+function hydrateFromStoreOnceSync() {
 	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;
-		}
+		const state = getIMessageRuntime().state;
+		hydrateCounter(state.openSyncKeyedStore({
+			namespace: IMESSAGE_REPLY_CACHE_COUNTER_NAMESPACE,
+			maxEntries: 1
+		}).lookup(IMESSAGE_REPLY_CACHE_COUNTER_KEY));
+		hydrateRows(state.openSyncKeyedStore({
+			namespace: IMESSAGE_REPLY_CACHE_NAMESPACE,
+			maxEntries: IMESSAGE_REPLY_CACHE_MAX_ENTRIES
+		}).entries().map(({ value }) => value));
 	} 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) {
+async function persistReplyCacheEntry(entry) {
 	const ttlMs = remainingTtlMs(entry.timestamp);
 	if (!ttlMs) return;
 	try {
-		openReplyCacheStore().register(resolveIMessageReplyCacheEntryKey(entry.messageId), entry, { ttlMs });
+		await openReplyCacheStore().register(resolveIMessageReplyCacheEntryKey(entry.messageId), entry, { ttlMs });
 	} catch (err) {
 		reportPersistenceFailure("write", err);
 	}
 }
-function deleteReplyCacheEntry(messageId) {
+async function deleteReplyCacheEntry(messageId) {
 	try {
-		openReplyCacheStore().delete(resolveIMessageReplyCacheEntryKey(messageId));
+		await openReplyCacheStore().delete(resolveIMessageReplyCacheEntryKey(messageId));
 	} catch (err) {
 		reportPersistenceFailure("delete", err);
 	}
 }
-function persistReplyCacheCounter() {
+async function persistReplyCacheCounter(counter) {
 	try {
-		openReplyCacheCounterStore().register(IMESSAGE_REPLY_CACHE_COUNTER_KEY, { counter: imessageShortIdCounter });
+		await openReplyCacheCounterStore().register(IMESSAGE_REPLY_CACHE_COUNTER_KEY, { counter });
 	} catch (err) {
 		reportPersistenceFailure("counter", err);
 	}
@@ -189,17 +212,17 @@ function buildReplyCacheEntry(entry, messageId, shortId) {
 }
 function generateShortId() {
 	imessageShortIdCounter += 1;
-	persistReplyCacheCounter();
 	return String(imessageShortIdCounter);
 }
-function rememberIMessageReplyCache(entry) {
-	hydrateFromStoreOnce();
+async function rememberIMessageReplyCache(entry) {
+	await hydrateFromStoreOnce();
 	const messageId = entry.messageId.trim();
 	if (!messageId) return {
 		...entry,
 		shortId: ""
 	};
 	let shortId = imessageUuidToShortId.get(messageId);
+	const isNewMessage = !shortId;
 	if (!shortId) {
 		shortId = generateShortId();
 		imessageShortIdToUuid.set(shortId, messageId);
@@ -209,7 +232,6 @@ function rememberIMessageReplyCache(entry) {
 	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;
@@ -219,7 +241,6 @@ function rememberIMessageReplyCache(entry) {
 			imessageShortIdToUuid.delete(value.shortId);
 			imessageUuidToShortId.delete(key);
 		}
-		evicted = true;
 	}
 	while (imessageReplyCacheByMessageId.size > IMESSAGE_REPLY_CACHE_MAX_ENTRIES) {
 		const oldest = imessageReplyCacheByMessageId.keys().next().value;
@@ -231,10 +252,14 @@ function rememberIMessageReplyCache(entry) {
 			imessageShortIdToUuid.delete(oldEntry.shortId);
 			imessageUuidToShortId.delete(oldest);
 		}
-		evicted = true;
 	}
-	if (evicted) for (const messageIdToDelete of deletedMessageIds) deleteReplyCacheEntry(messageIdToDelete);
-	persistReplyCacheEntry(fullEntry);
+	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) {
@@ -259,10 +284,10 @@ 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) {
+async function resolveIMessageMessageId(shortOrUuid, opts) {
 	const trimmed = shortOrUuid.trim();
 	if (!trimmed) return trimmed;
-	hydrateFromStoreOnce();
+	await hydrateFromStoreOnce();
 	if (/^\d+$/.test(trimmed)) {
 		const uuid = imessageShortIdToUuid.get(trimmed);
 		if (uuid) {
@@ -284,10 +309,10 @@ function resolveIMessageMessageId(shortOrUuid, opts) {
 	if (opts?.requireFromMe && cached?.isFromMe !== true) throw buildFromMeError(trimmed, "uuid");
 	return trimmed;
 }
-function isKnownFromMeIMessageMessageId(messageId, ctx) {
+async function isKnownFromMeIMessageMessageId(messageId, ctx) {
 	const trimmed = normalizeOptionalString(messageId);
 	if (!trimmed || !ctx.accountId || !hasChatScope(ctx)) return false;
-	hydrateFromStoreOnce();
+	await hydrateFromStoreOnce();
 	const cached = imessageReplyCacheByMessageId.get(trimmed);
 	if (!cached || cached.isFromMe !== true || cached.accountId !== ctx.accountId) return false;
 	return isPositiveIMessageChatMatch(cached, ctx);
@@ -326,8 +351,11 @@ function findLatestIMessageEntryForChat(ctx) {
 	}
 	return best;
 }
-function resolveIMessageCachedResourceBinding(messageId, ctx) {
-	hydrateFromStoreOnce();
+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";
@@ -336,14 +364,22 @@ function resolveIMessageCachedResourceBinding(messageId, ctx) {
 	if (chatMatch !== "match") return chatMatch;
 	return "match";
 }
+/** @deprecated Used only by hosts without asynchronous conversation matching. */
 function isIMessageCurrentMessageInChat(params) {
+	hydrateFromStoreOnceSync();
+	return isCurrentMessageInChat(params);
+}
+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;
-	hydrateFromStoreOnce();
 	const fullMessageId = /^\d+$/.test(currentMessageId) ? imessageShortIdToUuid.get(currentMessageId) : currentMessageId;
 	if (!fullMessageId) return false;
-	return resolveIMessageCachedResourceBinding(fullMessageId, {
+	return resolveCachedResourceBinding(fullMessageId, {
 		...params.chatContext,
 		accountId: params.accountId
 	}) === "match";
@@ -1277,4 +1313,4 @@ function sanitizeOutboundText(text) {
 	return cleaned;
 }
 //#endregion
-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 };
+export { chatContextFromIMessageTarget as _, IMessageRpcRequestError as a, resolveIMessageDirectChatService as b, findLatestIMessageEntryForChat as c, isKnownFromMeIMessageMessageId as d, rememberIMessageReplyCache as f, DEFAULT_IMESSAGE_SEND_TIMEOUT_MS as g, DEFAULT_IMESSAGE_PROBE_TIMEOUT_MS as h, extractMarkdownFormatRuns as i, isIMessageCurrentMessageInChat as l, resolveIMessageMessageId as m, sanitizeIMessageFinalOutboundText as n, createIMessageRpcClient as o, resolveIMessageCachedResourceBinding as p, sanitizeOutboundText as r, runIMessageCliJsonCommand as s, protectIMessageFencedRoleMarkers as t, isIMessageCurrentMessageInChatAsync as u, isIMessageEmailChatIdentifier as v, normalizeDirectChatIdentifier as y };