clawdbot 2026.1.4-1

package/dist/hooks/gmail.js

@@ -0,0 +1,177 @@
+import { randomBytes } from "node:crypto";
+import { DEFAULT_GATEWAY_PORT, resolveGatewayPort, } from "../config/config.js";
+export const DEFAULT_GMAIL_LABEL = "INBOX";
+export const DEFAULT_GMAIL_TOPIC = "gog-gmail-watch";
+export const DEFAULT_GMAIL_SUBSCRIPTION = "gog-gmail-watch-push";
+export const DEFAULT_GMAIL_SERVE_BIND = "127.0.0.1";
+export const DEFAULT_GMAIL_SERVE_PORT = 8788;
+export const DEFAULT_GMAIL_SERVE_PATH = "/gmail-pubsub";
+export const DEFAULT_GMAIL_MAX_BYTES = 20_000;
+export const DEFAULT_GMAIL_RENEW_MINUTES = 12 * 60;
+export const DEFAULT_HOOKS_PATH = "/hooks";
+export function generateHookToken(bytes = 24) {
+    return randomBytes(bytes).toString("hex");
+}
+export function mergeHookPresets(existing, preset) {
+    const next = new Set((existing ?? []).map((item) => item.trim()).filter(Boolean));
+    next.add(preset);
+    return Array.from(next);
+}
+export function normalizeHooksPath(raw) {
+    const base = raw?.trim() || DEFAULT_HOOKS_PATH;
+    if (base === "/")
+        return DEFAULT_HOOKS_PATH;
+    const withSlash = base.startsWith("/") ? base : `/${base}`;
+    return withSlash.replace(/\/+$/, "");
+}
+export function normalizeServePath(raw) {
+    const base = raw?.trim() || DEFAULT_GMAIL_SERVE_PATH;
+    // Tailscale funnel/serve strips the set-path prefix before proxying.
+    // To accept requests at /<path> externally, gog must listen on "/".
+    if (base === "/")
+        return "/";
+    const withSlash = base.startsWith("/") ? base : `/${base}`;
+    return withSlash.replace(/\/+$/, "");
+}
+export function buildDefaultHookUrl(hooksPath, port = DEFAULT_GATEWAY_PORT) {
+    const basePath = normalizeHooksPath(hooksPath);
+    const baseUrl = `http://127.0.0.1:${port}`;
+    return joinUrl(baseUrl, `${basePath}/gmail`);
+}
+export function resolveGmailHookRuntimeConfig(cfg, overrides) {
+    const hooks = cfg.hooks;
+    const gmail = hooks?.gmail;
+    const hookToken = overrides.hookToken ?? hooks?.token ?? "";
+    if (!hookToken) {
+        return { ok: false, error: "hooks.token missing (needed for gmail hook)" };
+    }
+    const account = overrides.account ?? gmail?.account ?? "";
+    if (!account) {
+        return { ok: false, error: "gmail account required" };
+    }
+    const topic = overrides.topic ?? gmail?.topic ?? "";
+    if (!topic) {
+        return { ok: false, error: "gmail topic required" };
+    }
+    const subscription = overrides.subscription ?? gmail?.subscription ?? DEFAULT_GMAIL_SUBSCRIPTION;
+    const pushToken = overrides.pushToken ?? gmail?.pushToken ?? "";
+    if (!pushToken) {
+        return { ok: false, error: "gmail push token required" };
+    }
+    const hookUrl = overrides.hookUrl ??
+        gmail?.hookUrl ??
+        buildDefaultHookUrl(hooks?.path, resolveGatewayPort(cfg));
+    const includeBody = overrides.includeBody ?? gmail?.includeBody ?? true;
+    const maxBytesRaw = overrides.maxBytes ?? gmail?.maxBytes;
+    const maxBytes = typeof maxBytesRaw === "number" &&
+        Number.isFinite(maxBytesRaw) &&
+        maxBytesRaw > 0
+        ? Math.floor(maxBytesRaw)
+        : DEFAULT_GMAIL_MAX_BYTES;
+    const renewEveryMinutesRaw = overrides.renewEveryMinutes ?? gmail?.renewEveryMinutes;
+    const renewEveryMinutes = typeof renewEveryMinutesRaw === "number" &&
+        Number.isFinite(renewEveryMinutesRaw) &&
+        renewEveryMinutesRaw > 0
+        ? Math.floor(renewEveryMinutesRaw)
+        : DEFAULT_GMAIL_RENEW_MINUTES;
+    const serveBind = overrides.serveBind ?? gmail?.serve?.bind ?? DEFAULT_GMAIL_SERVE_BIND;
+    const servePortRaw = overrides.servePort ?? gmail?.serve?.port;
+    const servePort = typeof servePortRaw === "number" &&
+        Number.isFinite(servePortRaw) &&
+        servePortRaw > 0
+        ? Math.floor(servePortRaw)
+        : DEFAULT_GMAIL_SERVE_PORT;
+    const servePathRaw = overrides.servePath ?? gmail?.serve?.path;
+    const hasExplicitServePath = typeof servePathRaw === "string" && servePathRaw.trim().length > 0;
+    const tailscaleMode = overrides.tailscaleMode ?? gmail?.tailscale?.mode ?? "off";
+    // When exposing the push endpoint via Tailscale, the public path is stripped
+    // before proxying; use "/" internally unless the user set a path explicitly.
+    const servePath = normalizeServePath(tailscaleMode !== "off" && !hasExplicitServePath ? "/" : servePathRaw);
+    const tailscalePathRaw = overrides.tailscalePath ?? gmail?.tailscale?.path;
+    const tailscalePath = normalizeServePath(tailscaleMode !== "off" && !tailscalePathRaw
+        ? hasExplicitServePath
+            ? servePathRaw
+            : DEFAULT_GMAIL_SERVE_PATH
+        : (tailscalePathRaw ?? servePath));
+    return {
+        ok: true,
+        value: {
+            account,
+            label: overrides.label ?? gmail?.label ?? DEFAULT_GMAIL_LABEL,
+            topic,
+            subscription,
+            pushToken,
+            hookToken,
+            hookUrl,
+            includeBody,
+            maxBytes,
+            renewEveryMinutes,
+            serve: {
+                bind: serveBind,
+                port: servePort,
+                path: servePath,
+            },
+            tailscale: {
+                mode: tailscaleMode,
+                path: tailscalePath,
+            },
+        },
+    };
+}
+export function buildGogWatchStartArgs(cfg) {
+    return [
+        "gmail",
+        "watch",
+        "start",
+        "--account",
+        cfg.account,
+        "--label",
+        cfg.label,
+        "--topic",
+        cfg.topic,
+    ];
+}
+export function buildGogWatchServeArgs(cfg) {
+    const args = [
+        "gmail",
+        "watch",
+        "serve",
+        "--account",
+        cfg.account,
+        "--bind",
+        cfg.serve.bind,
+        "--port",
+        String(cfg.serve.port),
+        "--path",
+        cfg.serve.path,
+        "--token",
+        cfg.pushToken,
+        "--hook-url",
+        cfg.hookUrl,
+        "--hook-token",
+        cfg.hookToken,
+    ];
+    if (cfg.includeBody) {
+        args.push("--include-body");
+    }
+    if (cfg.maxBytes > 0) {
+        args.push("--max-bytes", String(cfg.maxBytes));
+    }
+    return args;
+}
+export function buildTopicPath(projectId, topicName) {
+    return `projects/${projectId}/topics/${topicName}`;
+}
+export function parseTopicPath(topic) {
+    const match = topic.trim().match(/^projects\/([^/]+)\/topics\/([^/]+)$/i);
+    if (!match)
+        return null;
+    return { projectId: match[1] ?? "", topicName: match[2] ?? "" };
+}
+function joinUrl(base, path) {
+    const url = new URL(base);
+    const basePath = url.pathname.replace(/\/+$/, "");
+    const extra = path.startsWith("/") ? path : `/${path}`;
+    url.pathname = `${basePath}${extra}`;
+    return url.toString();
+}

package/dist/imessage/client.js

@@ -0,0 +1,165 @@
+import { spawn } from "node:child_process";
+import { createInterface } from "node:readline";
+import { resolveUserPath } from "../utils.js";
+export class IMessageRpcClient {
+    cliPath;
+    dbPath;
+    runtime;
+    onNotification;
+    pending = new Map();
+    closed;
+    closedResolve = null;
+    child = null;
+    reader = null;
+    nextId = 1;
+    constructor(opts = {}) {
+        this.cliPath = opts.cliPath?.trim() || "imsg";
+        this.dbPath = opts.dbPath?.trim()
+            ? resolveUserPath(opts.dbPath)
+            : undefined;
+        this.runtime = opts.runtime;
+        this.onNotification = opts.onNotification;
+        this.closed = new Promise((resolve) => {
+            this.closedResolve = resolve;
+        });
+    }
+    async start() {
+        if (this.child)
+            return;
+        const args = ["rpc"];
+        if (this.dbPath) {
+            args.push("--db", this.dbPath);
+        }
+        const child = spawn(this.cliPath, args, {
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        this.child = child;
+        this.reader = createInterface({ input: child.stdout });
+        this.reader.on("line", (line) => {
+            const trimmed = line.trim();
+            if (!trimmed)
+                return;
+            this.handleLine(trimmed);
+        });
+        child.stderr?.on("data", (chunk) => {
+            const lines = chunk.toString().split(/\r?\n/);
+            for (const line of lines) {
+                if (!line.trim())
+                    continue;
+                this.runtime?.error?.(`imsg rpc: ${line.trim()}`);
+            }
+        });
+        child.on("error", (err) => {
+            this.failAll(err instanceof Error ? err : new Error(String(err)));
+            this.closedResolve?.();
+        });
+        child.on("close", (code, signal) => {
+            if (code !== 0 && code !== null) {
+                const reason = signal ? `signal ${signal}` : `code ${code}`;
+                this.failAll(new Error(`imsg rpc exited (${reason})`));
+            }
+            else {
+                this.failAll(new Error("imsg rpc closed"));
+            }
+            this.closedResolve?.();
+        });
+    }
+    async stop() {
+        if (!this.child)
+            return;
+        this.reader?.close();
+        this.reader = null;
+        this.child.stdin?.end();
+        const child = this.child;
+        this.child = null;
+        await Promise.race([
+            this.closed,
+            new Promise((resolve) => {
+                setTimeout(() => {
+                    if (!child.killed)
+                        child.kill("SIGTERM");
+                    resolve();
+                }, 500);
+            }),
+        ]);
+    }
+    async waitForClose() {
+        await this.closed;
+    }
+    async request(method, params, opts) {
+        if (!this.child || !this.child.stdin) {
+            throw new Error("imsg rpc not running");
+        }
+        const id = this.nextId++;
+        const payload = {
+            jsonrpc: "2.0",
+            id,
+            method,
+            params: params ?? {},
+        };
+        const line = `${JSON.stringify(payload)}\n`;
+        const timeoutMs = opts?.timeoutMs ?? 10_000;
+        const response = new Promise((resolve, reject) => {
+            const key = String(id);
+            const timer = timeoutMs > 0
+                ? setTimeout(() => {
+                    this.pending.delete(key);
+                    reject(new Error(`imsg rpc timeout (${method})`));
+                }, timeoutMs)
+                : undefined;
+            this.pending.set(key, {
+                resolve: (value) => resolve(value),
+                reject,
+                timer,
+            });
+        });
+        this.child.stdin.write(line);
+        return await response;
+    }
+    handleLine(line) {
+        let parsed;
+        try {
+            parsed = JSON.parse(line);
+        }
+        catch (err) {
+            const detail = err instanceof Error ? err.message : String(err);
+            this.runtime?.error?.(`imsg rpc: failed to parse ${line}: ${detail}`);
+            return;
+        }
+        if (parsed.id !== undefined && parsed.id !== null) {
+            const key = String(parsed.id);
+            const pending = this.pending.get(key);
+            if (!pending)
+                return;
+            if (pending.timer)
+                clearTimeout(pending.timer);
+            this.pending.delete(key);
+            if (parsed.error) {
+                const msg = parsed.error.message ?? "imsg rpc error";
+                pending.reject(new Error(msg));
+                return;
+            }
+            pending.resolve(parsed.result);
+            return;
+        }
+        if (parsed.method) {
+            this.onNotification?.({
+                method: parsed.method,
+                params: parsed.params,
+            });
+        }
+    }
+    failAll(err) {
+        for (const [key, pending] of this.pending.entries()) {
+            if (pending.timer)
+                clearTimeout(pending.timer);
+            pending.reject(err);
+            this.pending.delete(key);
+        }
+    }
+}
+export async function createIMessageRpcClient(opts = {}) {
+    const client = new IMessageRpcClient(opts);
+    await client.start();
+    return client;
+}

package/dist/imessage/index.js

@@ -0,0 +1,3 @@
+export { monitorIMessageProvider } from "./monitor.js";
+export { probeIMessage } from "./probe.js";
+export { sendMessageIMessage } from "./send.js";

package/dist/imessage/monitor.js

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

@@ -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();
+    }
+}