@openclaw/imessage 2026.10.10 → 2026.11.5-beta.1

package/dist/.setup/chat-context-fTfJVqAi.mjs

@@ -0,0 +1,77 @@
+import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { normalizeE164 } from "openclaw/plugin-sdk/account-resolution";
+// 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) : EMAIL_HANDLE_PATTERN.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 comparisons = [
+		compareChatSelector(cached.chatGuid, current.chatGuid),
+		compareChatSelector(cached.chatIdentifier, current.chatIdentifier),
+		compareOptional(cached.chatId, current.chatId),
+		compareChatSelector(cached.chatGuid, current.chatIdentifier, true),
+		compareChatSelector(cached.chatIdentifier, current.chatGuid, true)
+	].filter((comparison) => comparison !== void 0);
+	if (comparisons.length === 0) return "unknown";
+	return comparisons.every(Boolean) ? "match" : "mismatch";
+}
+export { resolveIMessageDirectChatService as a, resolveIMessageChatMatch as i, isIMessageEmailChatIdentifier as n, normalizeDirectChatIdentifier as r, chatContextFromIMessageTarget as t };

package/dist/.setup/chat-lookup-xtPsOBkl.mjs

@@ -0,0 +1,50 @@
+import { r as normalizeDirectChatIdentifier } from "./chat-context-fTfJVqAi.mjs";
+import { n as createIMessageRpcClient } from "./client-D_BaG8sC.mjs";
+import { isRecord, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { parseStrictInteger } from "openclaw/plugin-sdk/number-runtime";
+// extensions/imessage/src/chat-lookup.ts
+const CHAT_LIST_CACHE_TTL_MS = 3e4;
+const chatListCache = /* @__PURE__ */ new Map();
+function numberFromUnknown(value) {
+	return typeof value === "number" && Number.isFinite(value) ? value : parseStrictInteger(value);
+}
+function findChat(chats, target) {
+	if (target.kind === "chat_id") return chats.find((chat) => chat.id === target.chatId) ?? null;
+	if (target.kind === "chat_guid") return chats.find((chat) => chat.guid === target.chatGuid) ?? null;
+	const wanted = normalizeDirectChatIdentifier(target.chatIdentifier);
+	for (const chat of chats) {
+		const { identifier, guid } = chat;
+		if (identifier === target.chatIdentifier || guid === target.chatIdentifier || identifier && normalizeDirectChatIdentifier(identifier) === wanted || normalizeDirectChatIdentifier(guid) === wanted) return chat;
+	}
+	return null;
+}
+async function resolveIMessageChat(params) {
+	const { cliPath, dbPath, remoteHost } = params.options;
+	const key = `${cliPath}\0${dbPath ?? ""}\0${remoteHost ?? ""}`;
+	const cached = chatListCache.get(key);
+	if (cached && cached.expiresAt > Date.now()) return findChat(cached.list, params.target);
+	chatListCache.delete(key);
+	const client = await createIMessageRpcClient(params.options);
+	try {
+		const result = await client.request("chats.list", { limit: 1e3 }, { timeoutMs: params.options.timeoutMs });
+		const list = [];
+		for (const chat of isRecord(result) && Array.isArray(result.chats) ? result.chats : []) {
+			if (!isRecord(chat)) continue;
+			const id = numberFromUnknown(chat.id);
+			const guid = normalizeOptionalString(chat.guid);
+			if (id !== void 0 && guid) list.push({
+				id,
+				guid,
+				identifier: normalizeOptionalString(chat.identifier)
+			});
+		}
+		chatListCache.set(key, {
+			list,
+			expiresAt: Date.now() + CHAT_LIST_CACHE_TTL_MS
+		});
+		return findChat(list, params.target);
+	} finally {
+		await client.stop();
+	}
+}
+export { resolveIMessageChat };

package/dist/.setup/client-D_BaG8sC.mjs

@@ -0,0 +1,367 @@
+import { u as expandIMessageUserPath } from "./accounts-C1Ypv3Wn.mjs";
+import { i as invalidateCachedIMessagePrivateApiStatus } from "./message-tool-api-DtZ1wKbT.mjs";
+import { asNullableRecord, isRecord, normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/string-coerce-runtime";
+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 { captureChannelReadAuthority, captureEffectAuthority } from "openclaw/plugin-sdk/fetch-runtime";
+import { raceWithTimeout } from "openclaw/plugin-sdk/time-runtime";
+// extensions/imessage/src/constants.ts
+const DEFAULT_IMESSAGE_PROBE_TIMEOUT_MS = 1e4;
+const DEFAULT_IMESSAGE_SEND_TIMEOUT_MS = 18e4;
+// 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 {
+		return asNullableRecord(JSON.parse(last));
+	} 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;
+}
+// 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;
+}
+// extensions/imessage/src/process-diagnostics.ts
+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.";
+function normalizeIMessageFullDiskAccessError(message) {
+	const normalized = normalizeLowercaseStringOrEmpty(message);
+	return normalized.includes("full disk access") && normalized.includes("chat.db") ? PUBLIC_IMESSAGE_FULL_DISK_ACCESS_ERROR : void 0;
+}
+// extensions/imessage/src/client.ts
+const IMSG_APPLE_FRAMEWORK_STDERR_PATTERN = /^(?:\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\.\d+ imsg\[\d+:\d+\] )?Could not fetch group for change type \d+ with identifier [^:]+:ABGroup, making it a delete change type\.$/u;
+var IMessageRpcRequestError = class extends Error {
+	constructor(message, code, data) {
+		super(message);
+		this.code = code;
+		this.data = data;
+		this.name = "IMessageRpcRequestError";
+	}
+};
+function isIMessageBridgeStall(error) {
+	if (error instanceof IMessageRpcRequestError && isRecord(error.data)) {
+		const { transport, detail } = error.data;
+		if (transport === "bridge_v2" && typeof detail === "string" && detail.startsWith("The bridge response deadline expired.")) return true;
+	}
+	return error instanceof Error && 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 IMESSAGE_RPC_CLOSE_GRACE_MS = 500;
+function isTestEnv() {
+	const vitest = normalizeLowercaseStringOrEmpty(process.env.VITEST);
+	return Boolean(vitest);
+}
+function createLfLineFramer(onLine) {
+	const decoder = new StringDecoder("utf8");
+	let buffer = "";
+	return {
+		write(chunk) {
+			buffer += typeof chunk === "string" ? chunk : decoder.write(chunk);
+			let newlineIndex = buffer.indexOf("\n");
+			while (newlineIndex !== -1) {
+				const line = buffer.slice(0, newlineIndex);
+				buffer = buffer.slice(newlineIndex + 1);
+				onLine(line);
+				newlineIndex = buffer.indexOf("\n");
+			}
+		},
+		flush() {
+			buffer += decoder.end();
+			if (!buffer) return;
+			const line = buffer;
+			buffer = "";
+			onLine(line);
+		}
+	};
+}
+var IMessageRpcClient = class {
+	constructor(opts = {}) {
+		this.pending = /* @__PURE__ */ new Map();
+		this.terminalResolve = null;
+		this.reapedResolve = null;
+		this.child = null;
+		this.stopPromise = null;
+		this.stdoutFramer = createLfLineFramer((line) => this.handleStdoutLine(line));
+		this.stderrFramer = createLfLineFramer((line) => this.handleStderrLine(line));
+		this.nextId = 1;
+		this.publicProcessError = null;
+		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;
+		this.onNotification = opts.onNotification;
+		this.terminal = new Promise((resolve) => {
+			this.terminalResolve = resolve;
+		});
+		this.reaped = new Promise((resolve) => {
+			this.reapedResolve = resolve;
+		});
+	}
+	async start() {
+		if (this.child) return;
+		if (isTestEnv()) throw new Error("Refusing to start imsg rpc in test environment; mock iMessage RPC client");
+		const args = ["rpc", "--json"];
+		if (this.dbPath) args.push("--db", this.dbPath);
+		const child = spawn(this.cliPath, args, { stdio: [
+			"pipe",
+			"pipe",
+			"pipe"
+		] });
+		this.child = child;
+		for (const [stream, framer] of [[child.stdout, this.stdoutFramer], [child.stderr, this.stderrFramer]]) stream.on("data", (chunk) => {
+			if (this.child === child) framer.write(chunk);
+		});
+		const failFromProcessError = (err) => this.failTransport(err, child);
+		child.on("error", failFromProcessError);
+		for (const stream of [
+			child.stdin,
+			child.stdout,
+			child.stderr
+		]) {
+			stream.on("error", failFromProcessError);
+			stream.once("close", () => {
+				const error = stream.errored;
+				if (error) failFromProcessError(error);
+			});
+		}
+		child.on("close", (code, signal) => {
+			if (this.child === child) {
+				this.stdoutFramer.flush();
+				this.stderrFramer.flush();
+				this.child = null;
+			}
+			this.finish(this.buildCloseError(code, signal));
+			const resolve = this.reapedResolve;
+			this.reapedResolve = null;
+			resolve?.();
+		});
+	}
+	async stop() {
+		if (this.stopPromise) return await this.stopPromise;
+		const child = this.child;
+		if (!child) return;
+		this.stopPromise = this.stopChild(child);
+		return await this.stopPromise;
+	}
+	async waitForClose() {
+		throw await this.terminal;
+	}
+	async request(method, params, opts) {
+		const child = this.child;
+		const stdin = child?.stdin;
+		const assertReadAuthority = captureChannelReadAuthority();
+		return captureEffectAuthority().initiate(() => {
+			if (child !== this.child || stdin !== this.child?.stdin) throw new Error("imsg rpc process changed before request initiation");
+			assertReadAuthority?.();
+			opts?.assertCurrent?.();
+			return this.initiateRequest(method, params, opts);
+		});
+	}
+	async initiateRequest(method, params, opts) {
+		if (!this.child || !this.child.stdin) throw new Error("imsg rpc not running");
+		const id = this.nextId++;
+		const line = `${JSON.stringify({
+			jsonrpc: "2.0",
+			id,
+			method,
+			params: params ?? {}
+		})}\n`;
+		const timeoutMs = opts?.timeoutMs ?? 1e4;
+		const key = String(id);
+		const pendingResponse = new Promise((resolve, reject) => {
+			this.pending.set(key, {
+				resolve: (value) => resolve(value),
+				reject
+			});
+		});
+		const response = timeoutMs > 0 ? raceWithTimeout(pendingResponse, timeoutMs, () => {
+			this.pending.delete(key);
+			throw new Error(`imsg rpc timeout (${method})`);
+		}) : pendingResponse;
+		try {
+			this.child.stdin.write(line, (err) => {
+				if (err) this.failTransport(err, this.child);
+			});
+		} catch (err) {
+			this.failTransport(err, this.child);
+		}
+		try {
+			return await response;
+		} catch (err) {
+			if (isIMessageBridgeStall(err)) {
+				invalidateCachedIMessagePrivateApiStatus(this.configuredCliPath);
+				try {
+					await recoverIMessageBridge(this.configuredCliPath);
+				} catch (recoveryError) {
+					this.runtime?.error?.(normalizeIMessageFullDiskAccessError(formatErrorMessage(recoveryError)) ?? `imessage: automatic bridge recovery failed. ${BRIDGE_STALL_GUIDANCE}`);
+				}
+				throw describeIMessageBridgeStall(err);
+			}
+			throw err;
+		}
+	}
+	async stopChild(child) {
+		try {
+			child.stdin.end();
+		} catch (err) {
+			this.failTransport(err, child);
+		}
+		if (await this.waitForReap(IMESSAGE_RPC_CLOSE_GRACE_MS)) return;
+		this.signalChild(child, "SIGTERM");
+		if (await this.waitForReap(IMESSAGE_RPC_CLOSE_GRACE_MS)) return;
+		this.signalChild(child, "SIGKILL");
+		if (!await this.waitForReap(IMESSAGE_RPC_CLOSE_GRACE_MS)) throw new Error("imsg rpc did not exit after SIGKILL");
+	}
+	async waitForReap(timeoutMs) {
+		if (!this.reapedResolve) return true;
+		return await raceWithTimeout(this.reaped.then(() => true), timeoutMs, () => false);
+	}
+	signalChild(child, signal) {
+		try {
+			child.kill(signal);
+		} catch {}
+	}
+	failTransport(err, child) {
+		if (!this.finish(err instanceof Error ? err : new Error(String(err)))) return;
+		if (child) this.signalChild(child, "SIGTERM");
+	}
+	handleStdoutLine(line) {
+		const trimmed = line.trim();
+		if (!trimmed) return;
+		this.handleLine(trimmed);
+	}
+	handleStderrLine(line) {
+		const trimmed = line.trim();
+		if (!trimmed) return;
+		this.recordProcessDiagnostic(trimmed);
+		if (IMSG_APPLE_FRAMEWORK_STDERR_PATTERN.test(trimmed)) return;
+		this.runtime?.error?.(normalizeIMessageFullDiskAccessError(trimmed) ?? "imsg rpc: stderr diagnostic received");
+	}
+	handleLine(line) {
+		let parsed;
+		try {
+			parsed = JSON.parse(line);
+		} catch {
+			this.recordProcessDiagnostic(line);
+			this.runtime?.error?.("imsg rpc: failed to parse JSON response");
+			return;
+		}
+		if (parsed.id !== void 0 && parsed.id !== null) {
+			const key = String(parsed.id);
+			const pending = this.pending.get(key);
+			if (!pending) return;
+			this.pending.delete(key);
+			if (parsed.error) {
+				const baseMessage = parsed.error.message ?? "imsg rpc error";
+				const details = parsed.error.data;
+				const code = parsed.error.code;
+				const suffixes = [];
+				if (typeof code === "number") suffixes.push(`code=${code}`);
+				if (details !== void 0) {
+					const detailText = typeof details === "string" ? details : JSON.stringify(details, null, 2);
+					if (detailText) suffixes.push(detailText);
+				}
+				const msg = suffixes.length > 0 ? `${baseMessage}: ${suffixes.join(" ")}` : baseMessage;
+				pending.reject(new IMessageRpcRequestError(msg, typeof code === "number" ? code : void 0, details));
+				return;
+			}
+			pending.resolve(parsed.result);
+			return;
+		}
+		if (parsed.method) this.onNotification?.({
+			method: parsed.method,
+			params: parsed.params
+		});
+	}
+	recordProcessDiagnostic(line) {
+		this.publicProcessError ??= normalizeIMessageFullDiskAccessError(line) ?? null;
+	}
+	buildCloseError(code, signal) {
+		if (this.publicProcessError) return new Error(this.publicProcessError);
+		if (code !== 0 && code !== null) {
+			const reason = signal ? `signal ${signal}` : `code ${code}`;
+			return /* @__PURE__ */ new Error(`imsg rpc exited (${reason})`);
+		}
+		return /* @__PURE__ */ new Error("imsg rpc closed");
+	}
+	finish(err) {
+		const resolve = this.terminalResolve;
+		if (!resolve) return false;
+		this.terminalResolve = null;
+		for (const [key, pending] of this.pending.entries()) {
+			pending.reject(err);
+			this.pending.delete(key);
+		}
+		resolve(err);
+		return true;
+	}
+};
+async function createIMessageRpcClient(opts = {}) {
+	const client = new IMessageRpcClient(opts);
+	await client.start();
+	return client;
+}
+export { DEFAULT_IMESSAGE_PROBE_TIMEOUT_MS as a, runIMessageCliJsonCommand as i, createIMessageRpcClient as n, DEFAULT_IMESSAGE_SEND_TIMEOUT_MS as o, normalizeIMessageFullDiskAccessError as r, IMessageRpcRequestError as t };

package/dist/.setup/{config-schema-DRkdRC21.mjs → config-schema-BjkQV5P5.mjs}

@@ -1,7 +1,7 @@
 import { createChannelConfigUiHints } from "openclaw/plugin-sdk/channel-core";
 import { ChannelDeliveryStreamingConfigSchema, ChannelSendReadReceiptsSchema, ExecutableTokenSchema, buildChannelAccountSchemaParts, buildChannelConfigSchema, buildChannelReactionShape, buildGroupEntrySchema, isSafeScpRemoteHost, isValidInboundPathRootPattern, refineChannelDmPolicy } from "openclaw/plugin-sdk/channel-config-schema";
 import { z } from "zod";
-// extensions/imessage/src/config-ui-hints.ts
+// extensions/imessage/src/config-schema.ts
 const iMessageChannelConfigUiHints = {
 	"": {
 		label: "iMessage",
@@ -35,7 +35,6 @@ const iMessageChannelConfigUiHints = {
 		help: "Preferred imsg RPC send transport for normal outbound replies. \"auto\" uses the IMCore bridge when available, \"bridge\" requires it, and \"applescript\" forces Messages automation."
 	}
 };
-// extensions/imessage/src/config-schema.ts
 const IMessageActionSchema = z.object({
 	reactions: z.boolean().optional(),
 	edit: z.boolean().optional(),

package/dist/.setup/{conversation-bindings-vZFn6sN2.mjs → conversation-bindings-8DjxoIYU.mjs}

@@ -1,4 +1,5 @@
-import { createAccountScopedConversationBindingManager, createAccountScopedConversationBindingManagerV2, resetAccountScopedConversationBindingsForTests } from "openclaw/plugin-sdk/thread-bindings-runtime";
+import { createAccountScopedConversationBindingManager, createAccountScopedConversationBindingManagerV2 } from "openclaw/plugin-sdk/thread-bindings-runtime";
+import { warnPluginSdkDeprecation } from "openclaw/plugin-sdk/thread-bindings-session-runtime";
 // extensions/imessage/src/conversation-bindings.ts
 const IMESSAGE_CONVERSATION_BINDINGS_STATE_KEY = Symbol.for("openclaw.imessageConversationBindingsState");
 function toSessionBindingTargetKind(raw) {
@@ -7,8 +8,13 @@ function toSessionBindingTargetKind(raw) {
 function toIMessageTargetKind(raw) {
 	return raw === "subagent" ? "subagent" : "acp";
 }
-/** @deprecated Use createIMessageConversationBindingManagerV2; final compatibility day: 2026-12-31. */
+/** @deprecated Use createIMessageConversationBindingManagerV2; final compatibility day: 2026-12-31. Removal in the first January 2027 stable release. */
 function createIMessageConversationBindingManager(params) {
+	warnPluginSdkDeprecation({
+		family: "conversation-bindings",
+		method: "createIMessageConversationBindingManager",
+		replacement: "createIMessageConversationBindingManagerV2"
+	});
 	return createAccountScopedConversationBindingManager({
 		channel: "imessage",
 		cfg: params.cfg,
@@ -29,7 +35,4 @@ function createIMessageConversationBindingManagerV2(params) {
 		toSessionBindingTargetKind
 	});
 }
-const testing = { resetIMessageConversationBindingsForTests() {
-	resetAccountScopedConversationBindingsForTests({ stateKey: IMESSAGE_CONVERSATION_BINDINGS_STATE_KEY });
-} };
-export { createIMessageConversationBindingManagerV2 as n, testing as r, createIMessageConversationBindingManager as t };
+export { createIMessageConversationBindingManagerV2 as n, createIMessageConversationBindingManager as t };

package/dist/.setup/{media-contract-CoixpXRX.mjs → media-contract-BErFBKV9.mjs}

@@ -1,4 +1,4 @@
-import { o as resolveIMessageAccount } from "./accounts-BH0coL46.mjs";
+import { o as resolveIMessageAccount } from "./accounts-C1Ypv3Wn.mjs";
 import { mergeInboundPathRoots } from "openclaw/plugin-sdk/channel-inbound";
 // extensions/imessage/src/media-contract.ts
 const DEFAULT_IMESSAGE_ATTACHMENT_ROOTS = ["/Users/*/Library/Messages/Attachments"];

package/dist/.setup/{message-tool-api-CxSY_rh7.mjs → message-tool-api-DtZ1wKbT.mjs}

@@ -1,8 +1,7 @@
-import { n as inferIMessageTargetChatType } from "./targets-CIx4BKqL.mjs";
-import { c as getCachedIMessageRemoteHost, o as resolveIMessageAccount } from "./accounts-BH0coL46.mjs";
+import { r as inferIMessageTargetChatType } from "./targets-C7CIWJ0k.mjs";
+import { c as getCachedIMessageRemoteHost, o as resolveIMessageAccount } from "./accounts-C1Ypv3Wn.mjs";
 import { createActionGate } from "openclaw/plugin-sdk/channel-actions";
 import { Type } from "typebox";
-import { asDateTimestampMs } from "openclaw/plugin-sdk/number-runtime";
 // extensions/imessage/src/actions-contract.ts
 const IMESSAGE_ACTIONS = {
 	react: { gate: "reactions" },
@@ -57,8 +56,7 @@ function getCachedIMessagePrivateApiStatus(cliPath) {
 	const entry = bridgeStatusCache.get(key);
 	if (!entry) return;
 	if (entry.expiresAt === 0) return entry.status;
-	const now = asDateTimestampMs(Date.now());
-	if (now === void 0 || entry.expiresAt <= now) {
+	if (entry.expiresAt <= Date.now()) {
 		bridgeStatusCache.delete(key);
 		return;
 	}
@@ -68,7 +66,6 @@ function invalidateCachedIMessagePrivateApiStatus(cliPath) {
 	bridgeStatusCache.delete(normalizeCliPath(cliPath));
 }
 function setCachedIMessagePrivateApiStatus(cliPath, status, expiresAt = 0) {
-	if (expiresAt !== 0 && asDateTimestampMs(expiresAt) === void 0) return;
 	bridgeStatusCache.set(normalizeCliPath(cliPath), {
 		status,
 		expiresAt

package/dist/.setup/{remote-file-CCgMYZ-u.mjs → remote-file-DpK3GQFD.mjs}

@@ -1,25 +1,18 @@
-import { p as resolveLocalIMessageChatDbPath } from "./accounts-BH0coL46.mjs";
-import { b as isIMessageEmailChatIdentifier, c as resolveIMessageCachedResourceBinding, l as resolveIMessageMessageId, y as chatContextFromIMessageTarget } from "./client-C3e7ZLqA.mjs";
+import { p as resolveLocalIMessageChatDbPath } from "./accounts-C1Ypv3Wn.mjs";
+import { n as isIMessageEmailChatIdentifier, t as chatContextFromIMessageTarget } from "./chat-context-fTfJVqAi.mjs";
+import { o as resolveIMessageCachedResourceBinding, s as resolveIMessageMessageId } from "./actions-qOuKy8To.mjs";
 import path from "node:path";
 import { normalizeScpRemoteHost } from "openclaw/plugin-sdk/host-runtime";
 import { createActionGate } from "openclaw/plugin-sdk/channel-actions";
 import { createSubsystemLogger, logVerbose } from "openclaw/plugin-sdk/runtime-env";
 import { randomUUID } from "node:crypto";
-import { resolveRuntimeWorkerUrl, runCommandWithTimeout } from "openclaw/plugin-sdk/process-runtime";
+import { createPluginRuntimeProcessEntrypoint, resolveRuntimeWorkerUrl, runCommandWithTimeout } from "openclaw/plugin-sdk/process-runtime";
 import { sanitizeTempFileName } from "openclaw/plugin-sdk/temp-path";
 import { openSqliteWorkerStore } from "openclaw/plugin-sdk/sqlite-runtime";
 // extensions/imessage/src/chat-db.ts
 function openIMessageChatDbReader(databasePath) {
 	return openSqliteWorkerStore({
-		moduleUrl: resolveRuntimeWorkerUrl({
-			currentModuleUrl: import.meta.url,
-			sourceWorkerName: "chat-db.worker",
-			distWorkerPath: "extensions/imessage/src/chat-db.worker.js",
-			package: {
-				name: "@openclaw/imessage",
-				distWorkerPath: "src/chat-db.worker.js"
-			}
-		}),
+		moduleUrl: resolveRuntimeWorkerUrl(createPluginRuntimeProcessEntrypoint("iMessageChatDb", import.meta.url)),
 		databasePath,
 		existingOnly: true,
 		input: void 0
@@ -152,10 +145,7 @@ async function resolveAuthorizedIMessageReplyReference(params) {
 	const rawReplyToId = sanitizeReplyToId(params.replyToId);
 	if (!rawReplyToId) return;
 	const chatContext = chatContextFromIMessageTarget(params.target, params.service);
-	const messageId = await resolveIMessageMessageId(rawReplyToId, {
-		requireKnownShortId: true,
-		chatContext
-	});
+	const messageId = await resolveIMessageMessageId(rawReplyToId, { chatContext });
 	await authorizeIMessageResourceReference({
 		accountId: params.account.accountId,
 		chatContext,
@@ -245,8 +235,7 @@ rm -rf -- ${remoteDir}
 			"sh -s"
 		], {
 			input: createScript,
-			timeoutMs: params.timeoutMs,
-			signal: params.signal
+			timeoutMs: params.timeoutMs
 		});
 		params.assertDirectAdapterHandoff?.();
 		await runChecked("iMessage remote file upload", [
@@ -255,10 +244,7 @@ rm -rf -- ${remoteDir}
 			"--",
 			params.localPath,
 			`${remoteHost}:${remotePath}`
-		], {
-			timeoutMs: params.timeoutMs,
-			signal: params.signal
-		});
+		], { timeoutMs: params.timeoutMs });
 		params.assertDirectAdapterHandoff?.();
 		return await params.use(remotePath);
 	} finally {