clawdbot 2026.1.4-1 → 2026.1.5

package/dist/imessage/monitor.js

@@ -1,272 +0,0 @@
-import { chunkText, resolveTextChunkLimit } from "../auto-reply/chunk.js";
-import { formatAgentEnvelope } from "../auto-reply/envelope.js";
-import { getReplyFromConfig } from "../auto-reply/reply.js";
-import { loadConfig } from "../config/config.js";
-import { resolveStorePath, updateLastRoute } from "../config/sessions.js";
-import { danger, logVerbose, shouldLogVerbose } from "../globals.js";
-import { mediaKindFromMime } from "../media/constants.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 resolveMentionRegexes(cfg) {
-    return (cfg.routing?.groupChat?.mentionPatterns
-        ?.map((pattern) => {
-        try {
-            return new RegExp(pattern, "i");
-        }
-        catch {
-            return null;
-        }
-    })
-        .filter((val) => Boolean(val)) ?? []);
-}
-function resolveGroupRequireMention(cfg, opts, chatId) {
-    if (typeof opts.requireMention === "boolean")
-        return opts.requireMention;
-    const groupId = chatId != null ? String(chatId) : undefined;
-    if (groupId) {
-        const groupConfig = cfg.imessage?.groups?.[groupId];
-        if (typeof groupConfig?.requireMention === "boolean") {
-            return groupConfig.requireMention;
-        }
-    }
-    const groupDefault = cfg.imessage?.groups?.["*"]?.requireMention;
-    if (typeof groupDefault === "boolean")
-        return groupDefault;
-    return true;
-}
-function isMentioned(text, regexes) {
-    if (!text)
-        return false;
-    const cleaned = text
-        .replace(/[\u200b-\u200f\u202a-\u202e\u2060-\u206f]/g, "")
-        .toLowerCase();
-    return regexes.some((re) => re.test(cleaned));
-}
-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 mentionRegexes = resolveMentionRegexes(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;
-        if (!isAllowedIMessageSender({
-            allowFrom,
-            sender,
-            chatId: chatId ?? undefined,
-            chatGuid,
-            chatIdentifier,
-        })) {
-            logVerbose(`Blocked iMessage sender ${sender} (not in allowFrom)`);
-            return;
-        }
-        const messageText = (message.text ?? "").trim();
-        const mentioned = isGroup ? isMentioned(messageText, mentionRegexes) : true;
-        const requireMention = resolveGroupRequireMention(cfg, opts, chatId);
-        if (isGroup && requireMention && !mentioned) {
-            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({
-            surface: "iMessage",
-            from: fromLabel,
-            timestamp: createdAt,
-            body: bodyText,
-        });
-        const ctxPayload = {
-            Body: body,
-            From: isGroup ? `group:${chatId}` : `imessage:${sender}`,
-            To: chatTarget || `imessage:${sender}`,
-            ChatType: isGroup ? "group" : "direct",
-            GroupSubject: isGroup ? (message.chat_name ?? undefined) : undefined,
-            GroupMembers: isGroup
-                ? (message.participants ?? []).filter(Boolean).join(", ")
-                : undefined,
-            SenderName: sender,
-            Surface: "imessage",
-            MessageSid: message.id ? String(message.id) : undefined,
-            Timestamp: createdAt,
-            MediaPath: mediaPath,
-            MediaType: mediaType,
-            MediaUrl: mediaPath,
-            WasMentioned: mentioned,
-        };
-        if (!isGroup) {
-            const sessionCfg = cfg.session;
-            const mainKey = (sessionCfg?.mainKey ?? "main").trim() || "main";
-            const storePath = resolveStorePath(sessionCfg?.store);
-            const to = chatTarget || sender;
-            if (to) {
-                await updateLastRoute({
-                    storePath,
-                    sessionKey: mainKey,
-                    channel: "imessage",
-                    to,
-                });
-            }
-        }
-        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}"`);
-        }
-        let blockSendChain = Promise.resolve();
-        const sendBlockReply = (payload) => {
-            if (!payload?.text &&
-                !payload?.mediaUrl &&
-                !(payload?.mediaUrls?.length ?? 0)) {
-                return;
-            }
-            blockSendChain = blockSendChain
-                .then(async () => {
-                await deliverReplies({
-                    replies: [payload],
-                    target: ctxPayload.To,
-                    client,
-                    runtime,
-                    maxBytes: mediaMaxBytes,
-                    textLimit,
-                });
-            })
-                .catch((err) => {
-                runtime.error?.(danger(`imessage block reply failed: ${String(err)}`));
-            });
-        };
-        const replyResult = await getReplyFromConfig(ctxPayload, { onBlockReply: sendBlockReply }, cfg);
-        const replies = replyResult
-            ? Array.isArray(replyResult)
-                ? replyResult
-                : [replyResult]
-            : [];
-        await blockSendChain;
-        if (replies.length === 0)
-            return;
-        await deliverReplies({
-            replies,
-            target: ctxPayload.To,
-            client,
-            runtime,
-            maxBytes: mediaMaxBytes,
-            textLimit,
-        });
-    };
-    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

@@ -1,26 +0,0 @@
-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

@@ -1,83 +0,0 @@
-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

@@ -1,176 +0,0 @@
-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}`;
-}

package/dist/sessions/send-policy.js

@@ -1,68 +0,0 @@
-export function normalizeSendPolicy(raw) {
-    const value = raw?.trim().toLowerCase();
-    if (value === "allow")
-        return "allow";
-    if (value === "deny")
-        return "deny";
-    return undefined;
-}
-function normalizeMatchValue(raw) {
-    const value = raw?.trim().toLowerCase();
-    return value ? value : undefined;
-}
-function deriveSurfaceFromKey(key) {
-    if (!key)
-        return undefined;
-    const parts = key.split(":").filter(Boolean);
-    if (parts.length >= 3 && (parts[1] === "group" || parts[1] === "channel")) {
-        return normalizeMatchValue(parts[0]);
-    }
-    return undefined;
-}
-function deriveChatTypeFromKey(key) {
-    if (!key)
-        return undefined;
-    if (key.startsWith("group:") || key.includes(":group:"))
-        return "group";
-    if (key.includes(":channel:"))
-        return "room";
-    return undefined;
-}
-export function resolveSendPolicy(params) {
-    const override = normalizeSendPolicy(params.entry?.sendPolicy);
-    if (override)
-        return override;
-    const policy = params.cfg.session?.sendPolicy;
-    if (!policy)
-        return "allow";
-    const surface = normalizeMatchValue(params.surface) ??
-        normalizeMatchValue(params.entry?.surface) ??
-        normalizeMatchValue(params.entry?.lastChannel) ??
-        deriveSurfaceFromKey(params.sessionKey);
-    const chatType = normalizeMatchValue(params.chatType ?? params.entry?.chatType) ??
-        normalizeMatchValue(deriveChatTypeFromKey(params.sessionKey));
-    const sessionKey = params.sessionKey ?? "";
-    let allowedMatch = false;
-    for (const rule of policy.rules ?? []) {
-        if (!rule)
-            continue;
-        const action = normalizeSendPolicy(rule.action) ?? "allow";
-        const match = rule.match ?? {};
-        const matchSurface = normalizeMatchValue(match.surface);
-        const matchChatType = normalizeMatchValue(match.chatType);
-        const matchPrefix = normalizeMatchValue(match.keyPrefix);
-        if (matchSurface && matchSurface !== surface)
-            continue;
-        if (matchChatType && matchChatType !== chatType)
-            continue;
-        if (matchPrefix && !sessionKey.startsWith(matchPrefix))
-            continue;
-        if (action === "deny")
-            return "deny";
-        allowedMatch = true;
-    }
-    if (allowedMatch)
-        return "allow";
-    const fallback = normalizeSendPolicy(policy.default);
-    return fallback ?? "allow";
-}