@intent-systems/nexus 2026.1.5-3

package/dist/imessage/monitor.js

@@ -0,0 +1,365 @@
+import { chunkText, resolveTextChunkLimit } from "../auto-reply/chunk.js";
+import { hasControlCommand } from "../auto-reply/command-detection.js";
+import { formatAgentEnvelope } from "../auto-reply/envelope.js";
+import { dispatchReplyFromConfig } from "../auto-reply/reply/dispatch-from-config.js";
+import { buildMentionRegexes, matchesMentionPatterns, } from "../auto-reply/reply/mentions.js";
+import { createReplyDispatcher } from "../auto-reply/reply/reply-dispatcher.js";
+import { loadConfig } from "../config/config.js";
+import { resolveProviderGroupPolicy, resolveProviderGroupRequireMention, } from "../config/group-policy.js";
+import { resolveStorePath, updateLastRoute } from "../config/sessions.js";
+import { danger, logVerbose, shouldLogVerbose } from "../globals.js";
+import { mediaKindFromMime } from "../media/constants.js";
+import { readProviderAllowFromStore, upsertProviderPairingRequest, } from "../pairing/pairing-store.js";
+import { resolveAgentRoute } from "../routing/resolve-route.js";
+import { createIMessageRpcClient } from "./client.js";
+import { sendMessageIMessage } from "./send.js";
+import { formatIMessageChatTarget, isAllowedIMessageSender, normalizeIMessageHandle, } from "./targets.js";
+function resolveRuntime(opts) {
+    return (opts.runtime ?? {
+        log: console.log,
+        error: console.error,
+        exit: (code) => {
+            throw new Error(`exit ${code}`);
+        },
+    });
+}
+function resolveAllowFrom(opts) {
+    const cfg = loadConfig();
+    const raw = opts.allowFrom ?? cfg.imessage?.allowFrom ?? [];
+    return raw.map((entry) => String(entry).trim()).filter(Boolean);
+}
+function resolveGroupAllowFrom(opts) {
+    const cfg = loadConfig();
+    const raw = opts.groupAllowFrom ??
+        cfg.imessage?.groupAllowFrom ??
+        (cfg.imessage?.allowFrom && cfg.imessage.allowFrom.length > 0
+            ? cfg.imessage.allowFrom
+            : []);
+    return raw.map((entry) => String(entry).trim()).filter(Boolean);
+}
+async function deliverReplies(params) {
+    const { replies, target, client, runtime, maxBytes, textLimit } = params;
+    for (const payload of replies) {
+        const mediaList = payload.mediaUrls ?? (payload.mediaUrl ? [payload.mediaUrl] : []);
+        const text = payload.text ?? "";
+        if (!text && mediaList.length === 0)
+            continue;
+        if (mediaList.length === 0) {
+            for (const chunk of chunkText(text, textLimit)) {
+                await sendMessageIMessage(target, chunk, { maxBytes, client });
+            }
+        }
+        else {
+            let first = true;
+            for (const url of mediaList) {
+                const caption = first ? text : "";
+                first = false;
+                await sendMessageIMessage(target, caption, {
+                    mediaUrl: url,
+                    maxBytes,
+                    client,
+                });
+            }
+        }
+        runtime.log?.(`imessage: delivered reply to ${target}`);
+    }
+}
+export async function monitorIMessageProvider(opts = {}) {
+    const runtime = resolveRuntime(opts);
+    const cfg = loadConfig();
+    const textLimit = resolveTextChunkLimit(cfg, "imessage");
+    const allowFrom = resolveAllowFrom(opts);
+    const groupAllowFrom = resolveGroupAllowFrom(opts);
+    const groupPolicy = cfg.imessage?.groupPolicy ?? "open";
+    const dmPolicy = cfg.imessage?.dmPolicy ?? "pairing";
+    const mentionRegexes = buildMentionRegexes(cfg);
+    const includeAttachments = opts.includeAttachments ?? cfg.imessage?.includeAttachments ?? false;
+    const mediaMaxBytes = (opts.mediaMaxMb ?? cfg.imessage?.mediaMaxMb ?? 16) * 1024 * 1024;
+    const handleMessage = async (raw) => {
+        const params = raw;
+        const message = params?.message ?? null;
+        if (!message)
+            return;
+        const senderRaw = message.sender ?? "";
+        const sender = senderRaw.trim();
+        if (!sender)
+            return;
+        if (message.is_from_me)
+            return;
+        const chatId = message.chat_id ?? undefined;
+        const chatGuid = message.chat_guid ?? undefined;
+        const chatIdentifier = message.chat_identifier ?? undefined;
+        const isGroup = Boolean(message.is_group);
+        if (isGroup && !chatId)
+            return;
+        const groupId = isGroup ? String(chatId) : undefined;
+        const storeAllowFrom = await readProviderAllowFromStore("imessage").catch(() => []);
+        const effectiveDmAllowFrom = Array.from(new Set([...allowFrom, ...storeAllowFrom]))
+            .map((v) => String(v).trim())
+            .filter(Boolean);
+        const effectiveGroupAllowFrom = Array.from(new Set([...groupAllowFrom, ...storeAllowFrom]))
+            .map((v) => String(v).trim())
+            .filter(Boolean);
+        if (isGroup) {
+            if (groupPolicy === "disabled") {
+                logVerbose("Blocked iMessage group message (groupPolicy: disabled)");
+                return;
+            }
+            if (groupPolicy === "allowlist") {
+                if (effectiveGroupAllowFrom.length === 0) {
+                    logVerbose("Blocked iMessage group message (groupPolicy: allowlist, no groupAllowFrom)");
+                    return;
+                }
+                const allowed = isAllowedIMessageSender({
+                    allowFrom: effectiveGroupAllowFrom,
+                    sender,
+                    chatId: chatId ?? undefined,
+                    chatGuid,
+                    chatIdentifier,
+                });
+                if (!allowed) {
+                    logVerbose(`Blocked iMessage sender ${sender} (not in groupAllowFrom)`);
+                    return;
+                }
+            }
+            const groupListPolicy = resolveProviderGroupPolicy({
+                cfg,
+                provider: "imessage",
+                groupId,
+            });
+            if (groupListPolicy.allowlistEnabled && !groupListPolicy.allowed) {
+                logVerbose(`imessage: skipping group message (${groupId ?? "unknown"}) not in allowlist`);
+                return;
+            }
+        }
+        const dmHasWildcard = effectiveDmAllowFrom.includes("*");
+        const dmAuthorized = dmPolicy === "open"
+            ? true
+            : dmHasWildcard ||
+                (effectiveDmAllowFrom.length > 0 &&
+                    isAllowedIMessageSender({
+                        allowFrom: effectiveDmAllowFrom,
+                        sender,
+                        chatId: chatId ?? undefined,
+                        chatGuid,
+                        chatIdentifier,
+                    }));
+        if (!isGroup) {
+            if (dmPolicy === "disabled")
+                return;
+            if (!dmAuthorized) {
+                if (dmPolicy === "pairing") {
+                    const senderId = normalizeIMessageHandle(sender);
+                    const { code } = await upsertProviderPairingRequest({
+                        provider: "imessage",
+                        id: senderId,
+                        meta: {
+                            sender: senderId,
+                            chatId: chatId ? String(chatId) : undefined,
+                        },
+                    });
+                    logVerbose(`imessage pairing request sender=${senderId} code=${code}`);
+                    try {
+                        await sendMessageIMessage(sender, [
+                            "Nexus: access not configured.",
+                            "",
+                            `Pairing code: ${code}`,
+                            "",
+                            "Ask the bot owner to approve with:",
+                            "nexus pairing approve --provider imessage <code>",
+                        ].join("\n"), {
+                            client,
+                            maxBytes: mediaMaxBytes,
+                            ...(chatId ? { chatId } : {}),
+                        });
+                    }
+                    catch (err) {
+                        logVerbose(`imessage pairing reply failed for ${senderId}: ${String(err)}`);
+                    }
+                }
+                else {
+                    logVerbose(`Blocked iMessage sender ${sender} (dmPolicy=${dmPolicy})`);
+                }
+                return;
+            }
+        }
+        const messageText = (message.text ?? "").trim();
+        const mentioned = isGroup
+            ? matchesMentionPatterns(messageText, mentionRegexes)
+            : true;
+        const requireMention = resolveProviderGroupRequireMention({
+            cfg,
+            provider: "imessage",
+            groupId,
+            requireMentionOverride: opts.requireMention,
+            overrideOrder: "before-config",
+        });
+        const canDetectMention = mentionRegexes.length > 0;
+        const commandAuthorized = isGroup
+            ? effectiveGroupAllowFrom.length > 0
+                ? isAllowedIMessageSender({
+                    allowFrom: effectiveGroupAllowFrom,
+                    sender,
+                    chatId: chatId ?? undefined,
+                    chatGuid,
+                    chatIdentifier,
+                })
+                : true
+            : dmAuthorized;
+        const shouldBypassMention = isGroup &&
+            requireMention &&
+            !mentioned &&
+            commandAuthorized &&
+            hasControlCommand(messageText);
+        if (isGroup &&
+            requireMention &&
+            canDetectMention &&
+            !mentioned &&
+            !shouldBypassMention) {
+            logVerbose(`imessage: skipping group message (no mention)`);
+            return;
+        }
+        const attachments = includeAttachments ? (message.attachments ?? []) : [];
+        const firstAttachment = attachments?.find((entry) => entry?.original_path && !entry?.missing);
+        const mediaPath = firstAttachment?.original_path ?? undefined;
+        const mediaType = firstAttachment?.mime_type ?? undefined;
+        const kind = mediaKindFromMime(mediaType ?? undefined);
+        const placeholder = kind
+            ? `<media:${kind}>`
+            : attachments?.length
+                ? "<media:attachment>"
+                : "";
+        const bodyText = messageText || placeholder;
+        if (!bodyText)
+            return;
+        const chatTarget = formatIMessageChatTarget(chatId);
+        const fromLabel = isGroup
+            ? `${message.chat_name || "iMessage Group"} id:${chatId ?? "unknown"}`
+            : `${normalizeIMessageHandle(sender)} id:${sender}`;
+        const createdAt = message.created_at
+            ? Date.parse(message.created_at)
+            : undefined;
+        const body = formatAgentEnvelope({
+            provider: "iMessage",
+            from: fromLabel,
+            timestamp: createdAt,
+            body: bodyText,
+        });
+        const route = resolveAgentRoute({
+            cfg,
+            provider: "imessage",
+            peer: {
+                kind: isGroup ? "group" : "dm",
+                id: isGroup
+                    ? String(chatId ?? "unknown")
+                    : normalizeIMessageHandle(sender),
+            },
+        });
+        const ctxPayload = {
+            Body: body,
+            From: isGroup ? `group:${chatId}` : `imessage:${sender}`,
+            To: chatTarget || `imessage:${sender}`,
+            SessionKey: route.sessionKey,
+            AccountId: route.accountId,
+            ChatType: isGroup ? "group" : "direct",
+            GroupSubject: isGroup ? (message.chat_name ?? undefined) : undefined,
+            GroupMembers: isGroup
+                ? (message.participants ?? []).filter(Boolean).join(", ")
+                : undefined,
+            SenderName: sender,
+            SenderId: sender,
+            Provider: "imessage",
+            MessageSid: message.id ? String(message.id) : undefined,
+            Timestamp: createdAt,
+            MediaPath: mediaPath,
+            MediaType: mediaType,
+            MediaUrl: mediaPath,
+            WasMentioned: mentioned,
+            CommandAuthorized: commandAuthorized,
+        };
+        if (!isGroup) {
+            const sessionCfg = cfg.session;
+            const storePath = resolveStorePath(sessionCfg?.store, {
+                agentId: route.agentId,
+            });
+            const to = chatTarget || sender;
+            if (to) {
+                await updateLastRoute({
+                    storePath,
+                    sessionKey: route.mainSessionKey,
+                    provider: "imessage",
+                    to,
+                    accountId: route.accountId,
+                });
+            }
+        }
+        if (shouldLogVerbose()) {
+            const preview = body.slice(0, 200).replace(/\n/g, "\\n");
+            logVerbose(`imessage inbound: chatId=${chatId ?? "unknown"} from=${ctxPayload.From} len=${body.length} preview="${preview}"`);
+        }
+        const dispatcher = createReplyDispatcher({
+            responsePrefix: cfg.messages?.responsePrefix,
+            deliver: async (payload) => {
+                await deliverReplies({
+                    replies: [payload],
+                    target: ctxPayload.To,
+                    client,
+                    runtime,
+                    maxBytes: mediaMaxBytes,
+                    textLimit,
+                });
+            },
+            onError: (err, info) => {
+                runtime.error?.(danger(`imessage ${info.kind} reply failed: ${String(err)}`));
+            },
+        });
+        const { queuedFinal } = await dispatchReplyFromConfig({
+            ctx: ctxPayload,
+            cfg,
+            dispatcher,
+        });
+        if (!queuedFinal)
+            return;
+    };
+    const client = await createIMessageRpcClient({
+        cliPath: opts.cliPath ?? cfg.imessage?.cliPath,
+        dbPath: opts.dbPath ?? cfg.imessage?.dbPath,
+        runtime,
+        onNotification: (msg) => {
+            if (msg.method === "message") {
+                void handleMessage(msg.params).catch((err) => {
+                    runtime.error?.(`imessage: handler failed: ${String(err)}`);
+                });
+            }
+            else if (msg.method === "error") {
+                runtime.error?.(`imessage: watch error ${JSON.stringify(msg.params)}`);
+            }
+        },
+    });
+    let subscriptionId = null;
+    const abort = opts.abortSignal;
+    const onAbort = () => {
+        if (subscriptionId) {
+            void client.request("watch.unsubscribe", {
+                subscription: subscriptionId,
+            });
+        }
+        void client.stop();
+    };
+    abort?.addEventListener("abort", onAbort, { once: true });
+    try {
+        const result = await client.request("watch.subscribe", { attachments: includeAttachments });
+        subscriptionId = result?.subscription ?? null;
+        await client.waitForClose();
+    }
+    catch (err) {
+        if (abort?.aborted)
+            return;
+        runtime.error?.(danger(`imessage: monitor failed: ${String(err)}`));
+        throw err;
+    }
+    finally {
+        abort?.removeEventListener("abort", onAbort);
+        await client.stop();
+    }
+}

package/dist/imessage/probe.js

@@ -0,0 +1,26 @@
+import { detectBinary } from "../commands/onboard-helpers.js";
+import { loadConfig } from "../config/config.js";
+import { createIMessageRpcClient } from "./client.js";
+export async function probeIMessage(timeoutMs = 2000) {
+    const cfg = loadConfig();
+    const cliPath = cfg.imessage?.cliPath?.trim() || "imsg";
+    const dbPath = cfg.imessage?.dbPath?.trim();
+    const detected = await detectBinary(cliPath);
+    if (!detected) {
+        return { ok: false, error: `imsg not found (${cliPath})` };
+    }
+    const client = await createIMessageRpcClient({
+        cliPath,
+        dbPath,
+    });
+    try {
+        await client.request("chats.list", { limit: 1 }, { timeoutMs });
+        return { ok: true };
+    }
+    catch (err) {
+        return { ok: false, error: String(err) };
+    }
+    finally {
+        await client.stop();
+    }
+}

package/dist/imessage/send.js

@@ -0,0 +1,83 @@
+import { loadConfig } from "../config/config.js";
+import { mediaKindFromMime } from "../media/constants.js";
+import { saveMediaBuffer } from "../media/store.js";
+import { loadWebMedia } from "../web/media.js";
+import { createIMessageRpcClient } from "./client.js";
+import { formatIMessageChatTarget, parseIMessageTarget, } from "./targets.js";
+function resolveCliPath(explicit) {
+    const cfg = loadConfig();
+    return explicit?.trim() || cfg.imessage?.cliPath?.trim() || "imsg";
+}
+function resolveDbPath(explicit) {
+    const cfg = loadConfig();
+    return explicit?.trim() || cfg.imessage?.dbPath?.trim() || undefined;
+}
+function resolveService(explicit) {
+    const cfg = loadConfig();
+    return (explicit || cfg.imessage?.service || "auto");
+}
+function resolveRegion(explicit) {
+    const cfg = loadConfig();
+    return explicit?.trim() || cfg.imessage?.region?.trim() || "US";
+}
+async function resolveAttachment(mediaUrl, maxBytes) {
+    const media = await loadWebMedia(mediaUrl, maxBytes);
+    const saved = await saveMediaBuffer(media.buffer, media.contentType ?? undefined, "outbound", maxBytes);
+    return { path: saved.path, contentType: saved.contentType };
+}
+export async function sendMessageIMessage(to, text, opts = {}) {
+    const cliPath = resolveCliPath(opts.cliPath);
+    const dbPath = resolveDbPath(opts.dbPath);
+    const target = parseIMessageTarget(opts.chatId ? formatIMessageChatTarget(opts.chatId) : to);
+    const service = opts.service ?? (target.kind === "handle" ? target.service : undefined);
+    const region = resolveRegion(opts.region);
+    const maxBytes = opts.maxBytes ?? 16 * 1024 * 1024;
+    let message = text ?? "";
+    let filePath;
+    if (opts.mediaUrl?.trim()) {
+        const resolved = await resolveAttachment(opts.mediaUrl.trim(), maxBytes);
+        filePath = resolved.path;
+        if (!message.trim()) {
+            const kind = mediaKindFromMime(resolved.contentType ?? undefined);
+            if (kind)
+                message = kind === "image" ? "<media:image>" : `<media:${kind}>`;
+        }
+    }
+    if (!message.trim() && !filePath) {
+        throw new Error("iMessage send requires text or media");
+    }
+    const params = {
+        text: message,
+        service: resolveService(service),
+        region,
+    };
+    if (filePath)
+        params.file = filePath;
+    if (target.kind === "chat_id") {
+        params.chat_id = target.chatId;
+    }
+    else if (target.kind === "chat_guid") {
+        params.chat_guid = target.chatGuid;
+    }
+    else if (target.kind === "chat_identifier") {
+        params.chat_identifier = target.chatIdentifier;
+    }
+    else {
+        params.to = target.to;
+    }
+    const client = opts.client ?? (await createIMessageRpcClient({ cliPath, dbPath }));
+    const shouldClose = !opts.client;
+    try {
+        const result = await client.request("send", params, {
+            timeoutMs: opts.timeoutMs,
+        });
+        return {
+            messageId: result?.ok ? "ok" : "unknown",
+        };
+    }
+    finally {
+        if (shouldClose) {
+            await client.stop();
+        }
+    }
+}

package/dist/imessage/targets.js

@@ -0,0 +1,176 @@
+import { normalizeE164 } from "../utils.js";
+const CHAT_ID_PREFIXES = ["chat_id:", "chatid:", "chat:"];
+const CHAT_GUID_PREFIXES = ["chat_guid:", "chatguid:", "guid:"];
+const CHAT_IDENTIFIER_PREFIXES = [
+    "chat_identifier:",
+    "chatidentifier:",
+    "chatident:",
+];
+const SERVICE_PREFIXES = [
+    { prefix: "imessage:", service: "imessage" },
+    { prefix: "sms:", service: "sms" },
+    { prefix: "auto:", service: "auto" },
+];
+function stripPrefix(value, prefix) {
+    return value.slice(prefix.length).trim();
+}
+export function normalizeIMessageHandle(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed)
+        return "";
+    const lowered = trimmed.toLowerCase();
+    if (lowered.startsWith("imessage:"))
+        return normalizeIMessageHandle(trimmed.slice(9));
+    if (lowered.startsWith("sms:"))
+        return normalizeIMessageHandle(trimmed.slice(4));
+    if (lowered.startsWith("auto:"))
+        return normalizeIMessageHandle(trimmed.slice(5));
+    if (trimmed.includes("@"))
+        return trimmed.toLowerCase();
+    const normalized = normalizeE164(trimmed);
+    if (normalized)
+        return normalized;
+    return trimmed.replace(/\s+/g, "");
+}
+export function parseIMessageTarget(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed)
+        throw new Error("iMessage target is required");
+    const lower = trimmed.toLowerCase();
+    for (const { prefix, service } of SERVICE_PREFIXES) {
+        if (lower.startsWith(prefix)) {
+            const remainder = stripPrefix(trimmed, prefix);
+            if (!remainder)
+                throw new Error(`${prefix} target is required`);
+            const remainderLower = remainder.toLowerCase();
+            const isChatTarget = CHAT_ID_PREFIXES.some((p) => remainderLower.startsWith(p)) ||
+                CHAT_GUID_PREFIXES.some((p) => remainderLower.startsWith(p)) ||
+                CHAT_IDENTIFIER_PREFIXES.some((p) => remainderLower.startsWith(p)) ||
+                remainderLower.startsWith("group:");
+            if (isChatTarget) {
+                return parseIMessageTarget(remainder);
+            }
+            return { kind: "handle", to: remainder, service };
+        }
+    }
+    for (const prefix of CHAT_ID_PREFIXES) {
+        if (lower.startsWith(prefix)) {
+            const value = stripPrefix(trimmed, prefix);
+            const chatId = Number.parseInt(value, 10);
+            if (!Number.isFinite(chatId)) {
+                throw new Error(`Invalid chat_id: ${value}`);
+            }
+            return { kind: "chat_id", chatId };
+        }
+    }
+    for (const prefix of CHAT_GUID_PREFIXES) {
+        if (lower.startsWith(prefix)) {
+            const value = stripPrefix(trimmed, prefix);
+            if (!value)
+                throw new Error("chat_guid is required");
+            return { kind: "chat_guid", chatGuid: value };
+        }
+    }
+    for (const prefix of CHAT_IDENTIFIER_PREFIXES) {
+        if (lower.startsWith(prefix)) {
+            const value = stripPrefix(trimmed, prefix);
+            if (!value)
+                throw new Error("chat_identifier is required");
+            return { kind: "chat_identifier", chatIdentifier: value };
+        }
+    }
+    if (lower.startsWith("group:")) {
+        const value = stripPrefix(trimmed, "group:");
+        const chatId = Number.parseInt(value, 10);
+        if (Number.isFinite(chatId)) {
+            return { kind: "chat_id", chatId };
+        }
+        if (!value)
+            throw new Error("group target is required");
+        return { kind: "chat_guid", chatGuid: value };
+    }
+    return { kind: "handle", to: trimmed, service: "auto" };
+}
+export function parseIMessageAllowTarget(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed)
+        return { kind: "handle", handle: "" };
+    const lower = trimmed.toLowerCase();
+    for (const { prefix } of SERVICE_PREFIXES) {
+        if (lower.startsWith(prefix)) {
+            const remainder = stripPrefix(trimmed, prefix);
+            if (!remainder)
+                return { kind: "handle", handle: "" };
+            return parseIMessageAllowTarget(remainder);
+        }
+    }
+    for (const prefix of CHAT_ID_PREFIXES) {
+        if (lower.startsWith(prefix)) {
+            const value = stripPrefix(trimmed, prefix);
+            const chatId = Number.parseInt(value, 10);
+            if (Number.isFinite(chatId))
+                return { kind: "chat_id", chatId };
+        }
+    }
+    for (const prefix of CHAT_GUID_PREFIXES) {
+        if (lower.startsWith(prefix)) {
+            const value = stripPrefix(trimmed, prefix);
+            if (value)
+                return { kind: "chat_guid", chatGuid: value };
+        }
+    }
+    for (const prefix of CHAT_IDENTIFIER_PREFIXES) {
+        if (lower.startsWith(prefix)) {
+            const value = stripPrefix(trimmed, prefix);
+            if (value)
+                return { kind: "chat_identifier", chatIdentifier: value };
+        }
+    }
+    if (lower.startsWith("group:")) {
+        const value = stripPrefix(trimmed, "group:");
+        const chatId = Number.parseInt(value, 10);
+        if (Number.isFinite(chatId))
+            return { kind: "chat_id", chatId };
+        if (value)
+            return { kind: "chat_guid", chatGuid: value };
+    }
+    return { kind: "handle", handle: normalizeIMessageHandle(trimmed) };
+}
+export function isAllowedIMessageSender(params) {
+    const allowFrom = params.allowFrom.map((entry) => String(entry).trim());
+    if (allowFrom.length === 0)
+        return true;
+    if (allowFrom.includes("*"))
+        return true;
+    const senderNormalized = normalizeIMessageHandle(params.sender);
+    const chatId = params.chatId ?? undefined;
+    const chatGuid = params.chatGuid?.trim();
+    const chatIdentifier = params.chatIdentifier?.trim();
+    for (const entry of allowFrom) {
+        if (!entry)
+            continue;
+        const parsed = parseIMessageAllowTarget(entry);
+        if (parsed.kind === "chat_id" && chatId !== undefined) {
+            if (parsed.chatId === chatId)
+                return true;
+        }
+        else if (parsed.kind === "chat_guid" && chatGuid) {
+            if (parsed.chatGuid === chatGuid)
+                return true;
+        }
+        else if (parsed.kind === "chat_identifier" && chatIdentifier) {
+            if (parsed.chatIdentifier === chatIdentifier)
+                return true;
+        }
+        else if (parsed.kind === "handle" && senderNormalized) {
+            if (parsed.handle === senderNormalized)
+                return true;
+        }
+    }
+    return false;
+}
+export function formatIMessageChatTarget(chatId) {
+    if (!chatId || !Number.isFinite(chatId))
+        return "";
+    return `chat_id:${chatId}`;
+}