clawdbot 2026.1.4-1

package/dist/web/inbound.js

@@ -0,0 +1,481 @@
+import { DisconnectReason, downloadMediaMessage, extractMessageContent, getContentType, isJidGroup, normalizeMessageContent, } from "@whiskeysockets/baileys";
+import { loadConfig } from "../config/config.js";
+import { logVerbose, shouldLogVerbose } from "../globals.js";
+import { createSubsystemLogger, getChildLogger } from "../logging.js";
+import { saveMediaBuffer } from "../media/store.js";
+import { isSelfChatMode, jidToE164, normalizeE164, toWhatsappJid, } from "../utils.js";
+import { createWaSocket, getStatusCode, waitForWaConnection, } from "./session.js";
+export async function monitorWebInbox(options) {
+    const inboundLogger = getChildLogger({ module: "web-inbound" });
+    const inboundConsoleLog = createSubsystemLogger("gateway/providers/whatsapp").child("inbound");
+    const sock = await createWaSocket(false, options.verbose);
+    await waitForWaConnection(sock);
+    let onCloseResolve = null;
+    const onClose = new Promise((resolve) => {
+        onCloseResolve = resolve;
+    });
+    const resolveClose = (reason) => {
+        if (!onCloseResolve)
+            return;
+        const resolver = onCloseResolve;
+        onCloseResolve = null;
+        resolver(reason);
+    };
+    try {
+        // Advertise that the gateway is online right after connecting.
+        await sock.sendPresenceUpdate("available");
+        if (shouldLogVerbose())
+            logVerbose("Sent global 'available' presence on connect");
+    }
+    catch (err) {
+        logVerbose(`Failed to send 'available' presence on connect: ${String(err)}`);
+    }
+    const selfJid = sock.user?.id;
+    const selfE164 = selfJid ? jidToE164(selfJid) : null;
+    const seen = new Set();
+    const groupMetaCache = new Map();
+    const GROUP_META_TTL_MS = 5 * 60 * 1000; // 5 minutes
+    const getGroupMeta = async (jid) => {
+        const cached = groupMetaCache.get(jid);
+        if (cached && cached.expires > Date.now())
+            return cached;
+        try {
+            const meta = await sock.groupMetadata(jid);
+            const participants = meta.participants
+                ?.map((p) => jidToE164(p.id) ?? p.id)
+                .filter(Boolean) ?? [];
+            const entry = {
+                subject: meta.subject,
+                participants,
+                expires: Date.now() + GROUP_META_TTL_MS,
+            };
+            groupMetaCache.set(jid, entry);
+            return entry;
+        }
+        catch (err) {
+            logVerbose(`Failed to fetch group metadata for ${jid}: ${String(err)}`);
+            return { expires: Date.now() + GROUP_META_TTL_MS };
+        }
+    };
+    const handleMessagesUpsert = async (upsert) => {
+        if (upsert.type !== "notify")
+            return;
+        for (const msg of upsert.messages ?? []) {
+            const id = msg.key?.id ?? undefined;
+            // De-dupe on message id; Baileys can emit retries.
+            if (id && seen.has(id))
+                continue;
+            if (id)
+                seen.add(id);
+            // Note: not filtering fromMe here - echo detection happens in auto-reply layer
+            const remoteJid = msg.key?.remoteJid;
+            if (!remoteJid)
+                continue;
+            // Ignore status/broadcast traffic; we only care about direct chats.
+            if (remoteJid.endsWith("@status") || remoteJid.endsWith("@broadcast"))
+                continue;
+            const group = isJidGroup(remoteJid);
+            const participantJid = msg.key?.participant ?? undefined;
+            const senderE164 = participantJid ? jidToE164(participantJid) : null;
+            const from = group ? remoteJid : jidToE164(remoteJid);
+            // Skip if we still can't resolve an id to key conversation
+            if (!from)
+                continue;
+            let groupSubject;
+            let groupParticipants;
+            if (group) {
+                const meta = await getGroupMeta(remoteJid);
+                groupSubject = meta.subject;
+                groupParticipants = meta.participants;
+            }
+            // Filter unauthorized senders early to prevent wasted processing
+            // and potential session corruption from Bad MAC errors
+            const cfg = loadConfig();
+            const configuredAllowFrom = cfg.whatsapp?.allowFrom;
+            // Without user config, default to self-only DM access so the owner can talk to themselves
+            const defaultAllowFrom = (!configuredAllowFrom || configuredAllowFrom.length === 0) && selfE164
+                ? [selfE164]
+                : undefined;
+            const allowFrom = configuredAllowFrom && configuredAllowFrom.length > 0
+                ? configuredAllowFrom
+                : defaultAllowFrom;
+            const isSamePhone = from === selfE164;
+            const isSelfChat = isSelfChatMode(selfE164, configuredAllowFrom);
+            const allowlistEnabled = !group && Array.isArray(allowFrom) && allowFrom.length > 0;
+            if (!isSamePhone && allowlistEnabled) {
+                const candidate = from;
+                const allowedList = allowFrom.map(normalizeE164);
+                if (!allowFrom.includes("*") && !allowedList.includes(candidate)) {
+                    logVerbose(`Blocked unauthorized sender ${candidate} (not in allowFrom list)`);
+                    continue; // Skip processing entirely
+                }
+            }
+            if (id && !isSelfChat) {
+                const participant = msg.key?.participant;
+                try {
+                    await sock.readMessages([
+                        { remoteJid, id, participant, fromMe: false },
+                    ]);
+                    if (shouldLogVerbose()) {
+                        const suffix = participant ? ` (participant ${participant})` : "";
+                        logVerbose(`Marked message ${id} as read for ${remoteJid}${suffix}`);
+                    }
+                }
+                catch (err) {
+                    logVerbose(`Failed to mark message ${id} read: ${String(err)}`);
+                }
+            }
+            else if (id && isSelfChat && shouldLogVerbose()) {
+                // Self-chat mode: never auto-send read receipts (blue ticks) on behalf of the owner.
+                logVerbose(`Self-chat mode: skipping read receipt for ${id}`);
+            }
+            let body = extractText(msg.message ?? undefined);
+            if (!body) {
+                body = extractMediaPlaceholder(msg.message ?? undefined);
+                if (!body)
+                    continue;
+            }
+            const replyContext = describeReplyContext(msg.message);
+            let mediaPath;
+            let mediaType;
+            try {
+                const inboundMedia = await downloadInboundMedia(msg, sock);
+                if (inboundMedia) {
+                    const saved = await saveMediaBuffer(inboundMedia.buffer, inboundMedia.mimetype);
+                    mediaPath = saved.path;
+                    mediaType = inboundMedia.mimetype;
+                }
+            }
+            catch (err) {
+                logVerbose(`Inbound media download failed: ${String(err)}`);
+            }
+            const chatJid = remoteJid;
+            const sendComposing = async () => {
+                try {
+                    await sock.sendPresenceUpdate("composing", chatJid);
+                }
+                catch (err) {
+                    logVerbose(`Presence update failed: ${String(err)}`);
+                }
+            };
+            const reply = async (text) => {
+                await sock.sendMessage(chatJid, { text });
+            };
+            const sendMedia = async (payload) => {
+                await sock.sendMessage(chatJid, payload);
+            };
+            const timestamp = msg.messageTimestamp
+                ? Number(msg.messageTimestamp) * 1000
+                : undefined;
+            const mentionedJids = extractMentionedJids(msg.message);
+            const senderName = msg.pushName ?? undefined;
+            inboundLogger.info({
+                from,
+                to: selfE164 ?? "me",
+                body,
+                mediaPath,
+                mediaType,
+                timestamp,
+            }, "inbound message");
+            try {
+                const task = Promise.resolve(options.onMessage({
+                    id,
+                    from,
+                    conversationId: from,
+                    to: selfE164 ?? "me",
+                    body,
+                    pushName: senderName,
+                    timestamp,
+                    chatType: group ? "group" : "direct",
+                    chatId: remoteJid,
+                    senderJid: participantJid,
+                    senderE164: senderE164 ?? undefined,
+                    senderName,
+                    replyToId: replyContext?.id,
+                    replyToBody: replyContext?.body,
+                    replyToSender: replyContext?.sender,
+                    groupSubject,
+                    groupParticipants,
+                    mentionedJids: mentionedJids ?? undefined,
+                    selfJid,
+                    selfE164,
+                    sendComposing,
+                    reply,
+                    sendMedia,
+                    mediaPath,
+                    mediaType,
+                }));
+                void task.catch((err) => {
+                    inboundLogger.error({ error: String(err) }, "failed handling inbound web message");
+                    inboundConsoleLog.error(`Failed handling inbound web message: ${String(err)}`);
+                });
+            }
+            catch (err) {
+                inboundLogger.error({ error: String(err) }, "failed handling inbound web message");
+                inboundConsoleLog.error(`Failed handling inbound web message: ${String(err)}`);
+            }
+        }
+    };
+    sock.ev.on("messages.upsert", handleMessagesUpsert);
+    const handleConnectionUpdate = (update) => {
+        try {
+            if (update.connection === "close") {
+                const status = getStatusCode(update.lastDisconnect?.error);
+                resolveClose({
+                    status,
+                    isLoggedOut: status === DisconnectReason.loggedOut,
+                    error: update.lastDisconnect?.error,
+                });
+            }
+        }
+        catch (err) {
+            inboundLogger.error({ error: String(err) }, "connection.update handler error");
+            resolveClose({
+                status: undefined,
+                isLoggedOut: false,
+                error: err,
+            });
+        }
+    };
+    sock.ev.on("connection.update", handleConnectionUpdate);
+    return {
+        close: async () => {
+            try {
+                const ev = sock.ev;
+                const messagesUpsertHandler = handleMessagesUpsert;
+                const connectionUpdateHandler = handleConnectionUpdate;
+                if (typeof ev.off === "function") {
+                    ev.off("messages.upsert", messagesUpsertHandler);
+                    ev.off("connection.update", connectionUpdateHandler);
+                }
+                else if (typeof ev.removeListener === "function") {
+                    ev.removeListener("messages.upsert", messagesUpsertHandler);
+                    ev.removeListener("connection.update", connectionUpdateHandler);
+                }
+                sock.ws?.close();
+            }
+            catch (err) {
+                logVerbose(`Socket close failed: ${String(err)}`);
+            }
+        },
+        onClose,
+        signalClose: (reason) => {
+            resolveClose(reason ?? { status: undefined, isLoggedOut: false, error: "closed" });
+        },
+        /**
+         * Send a message through this connection's socket.
+         * Used by IPC to avoid creating new connections.
+         */
+        sendMessage: async (to, text, mediaBuffer, mediaType, options) => {
+            const jid = toWhatsappJid(to);
+            let payload;
+            if (mediaBuffer && mediaType) {
+                if (mediaType.startsWith("image/")) {
+                    payload = {
+                        image: mediaBuffer,
+                        caption: text || undefined,
+                        mimetype: mediaType,
+                    };
+                }
+                else if (mediaType.startsWith("audio/")) {
+                    payload = {
+                        audio: mediaBuffer,
+                        ptt: true,
+                        mimetype: mediaType,
+                    };
+                }
+                else if (mediaType.startsWith("video/")) {
+                    const gifPlayback = options?.gifPlayback;
+                    payload = {
+                        video: mediaBuffer,
+                        caption: text || undefined,
+                        mimetype: mediaType,
+                        ...(gifPlayback ? { gifPlayback: true } : {}),
+                    };
+                }
+                else {
+                    payload = {
+                        document: mediaBuffer,
+                        fileName: "file",
+                        caption: text || undefined,
+                        mimetype: mediaType,
+                    };
+                }
+            }
+            else {
+                payload = { text };
+            }
+            const result = await sock.sendMessage(jid, payload);
+            return { messageId: result?.key?.id ?? "unknown" };
+        },
+        /**
+         * Send typing indicator ("composing") to a chat.
+         * Used after IPC send to show more messages are coming.
+         */
+        sendComposingTo: async (to) => {
+            const jid = toWhatsappJid(to);
+            await sock.sendPresenceUpdate("composing", jid);
+        },
+    };
+}
+function unwrapMessage(message) {
+    const normalized = normalizeMessageContent(message);
+    return normalized;
+}
+function extractContextInfo(message) {
+    if (!message)
+        return undefined;
+    const contentType = getContentType(message);
+    const candidate = contentType
+        ? message[contentType]
+        : undefined;
+    const contextInfo = candidate && typeof candidate === "object" && "contextInfo" in candidate
+        ? candidate.contextInfo
+        : undefined;
+    if (contextInfo)
+        return contextInfo;
+    const fallback = message.extendedTextMessage?.contextInfo ??
+        message.imageMessage?.contextInfo ??
+        message.videoMessage?.contextInfo ??
+        message.documentMessage?.contextInfo ??
+        message.audioMessage?.contextInfo ??
+        message.stickerMessage?.contextInfo ??
+        message.buttonsResponseMessage?.contextInfo ??
+        message.listResponseMessage?.contextInfo ??
+        message.templateButtonReplyMessage?.contextInfo ??
+        message.interactiveResponseMessage?.contextInfo ??
+        message.buttonsMessage?.contextInfo ??
+        message.listMessage?.contextInfo;
+    if (fallback)
+        return fallback;
+    for (const value of Object.values(message)) {
+        if (!value || typeof value !== "object")
+            continue;
+        if (!("contextInfo" in value))
+            continue;
+        const candidateContext = value
+            .contextInfo;
+        if (candidateContext)
+            return candidateContext;
+    }
+    return undefined;
+}
+function extractMentionedJids(rawMessage) {
+    const message = unwrapMessage(rawMessage);
+    if (!message)
+        return undefined;
+    const candidates = [
+        message.extendedTextMessage?.contextInfo?.mentionedJid,
+        message.extendedTextMessage?.contextInfo?.quotedMessage?.extendedTextMessage
+            ?.contextInfo?.mentionedJid,
+        message.imageMessage?.contextInfo?.mentionedJid,
+        message.videoMessage?.contextInfo?.mentionedJid,
+        message.documentMessage?.contextInfo?.mentionedJid,
+        message.audioMessage?.contextInfo?.mentionedJid,
+        message.stickerMessage?.contextInfo?.mentionedJid,
+        message.buttonsResponseMessage?.contextInfo?.mentionedJid,
+        message.listResponseMessage?.contextInfo?.mentionedJid,
+    ];
+    const flattened = candidates.flatMap((arr) => arr ?? []).filter(Boolean);
+    if (flattened.length === 0)
+        return undefined;
+    // De-dupe
+    return Array.from(new Set(flattened));
+}
+export function extractText(rawMessage) {
+    const message = unwrapMessage(rawMessage);
+    if (!message)
+        return undefined;
+    const extracted = extractMessageContent(message);
+    const candidates = [
+        message,
+        extracted && extracted !== message ? extracted : undefined,
+    ];
+    for (const candidate of candidates) {
+        if (!candidate)
+            continue;
+        if (typeof candidate.conversation === "string" &&
+            candidate.conversation.trim()) {
+            return candidate.conversation.trim();
+        }
+        const extended = candidate.extendedTextMessage?.text;
+        if (extended?.trim())
+            return extended.trim();
+        const caption = candidate.imageMessage?.caption ??
+            candidate.videoMessage?.caption ??
+            candidate.documentMessage?.caption;
+        if (caption?.trim())
+            return caption.trim();
+    }
+    return undefined;
+}
+export function extractMediaPlaceholder(rawMessage) {
+    const message = unwrapMessage(rawMessage);
+    if (!message)
+        return undefined;
+    if (message.imageMessage)
+        return "<media:image>";
+    if (message.videoMessage)
+        return "<media:video>";
+    if (message.audioMessage)
+        return "<media:audio>";
+    if (message.documentMessage)
+        return "<media:document>";
+    if (message.stickerMessage)
+        return "<media:sticker>";
+    return undefined;
+}
+function describeReplyContext(rawMessage) {
+    const message = unwrapMessage(rawMessage);
+    if (!message)
+        return null;
+    const contextInfo = extractContextInfo(message);
+    const quoted = normalizeMessageContent(contextInfo?.quotedMessage);
+    if (!quoted)
+        return null;
+    const body = extractText(quoted) ?? extractMediaPlaceholder(quoted);
+    if (!body) {
+        const quotedType = quoted ? getContentType(quoted) : undefined;
+        logVerbose(`Quoted message missing extractable body${quotedType ? ` (type ${quotedType})` : ""}`);
+        return null;
+    }
+    const senderJid = contextInfo?.participant ?? undefined;
+    const senderE164 = senderJid
+        ? (jidToE164(senderJid) ?? senderJid)
+        : undefined;
+    const sender = senderE164 ?? "unknown sender";
+    return {
+        id: contextInfo?.stanzaId ? String(contextInfo.stanzaId) : undefined,
+        body,
+        sender,
+    };
+}
+async function downloadInboundMedia(msg, sock) {
+    const message = unwrapMessage(msg.message);
+    if (!message)
+        return undefined;
+    const mimetype = message.imageMessage?.mimetype ??
+        message.videoMessage?.mimetype ??
+        message.documentMessage?.mimetype ??
+        message.audioMessage?.mimetype ??
+        message.stickerMessage?.mimetype ??
+        undefined;
+    if (!message.imageMessage &&
+        !message.videoMessage &&
+        !message.documentMessage &&
+        !message.audioMessage &&
+        !message.stickerMessage) {
+        return undefined;
+    }
+    try {
+        const buffer = (await downloadMediaMessage(msg, "buffer", {}, {
+            reuploadRequest: sock.updateMediaMessage,
+            logger: sock.logger,
+        }));
+        return { buffer, mimetype };
+    }
+    catch (err) {
+        logVerbose(`downloadMediaMessage failed: ${String(err)}`);
+        return undefined;
+    }
+}

package/dist/web/login-qr.js

@@ -0,0 +1,204 @@
+import { randomUUID } from "node:crypto";
+import { DisconnectReason } from "@whiskeysockets/baileys";
+import { danger, info, success } from "../globals.js";
+import { logInfo } from "../logger.js";
+import { defaultRuntime } from "../runtime.js";
+import { renderQrPngBase64 } from "./qr-image.js";
+import { createWaSocket, formatError, getStatusCode, logoutWeb, readWebSelfId, waitForWaConnection, webAuthExists, } from "./session.js";
+const ACTIVE_LOGIN_TTL_MS = 3 * 60_000;
+let activeLogin = null;
+function closeSocket(sock) {
+    try {
+        sock.ws?.close();
+    }
+    catch {
+        // ignore
+    }
+}
+async function resetActiveLogin(reason) {
+    if (activeLogin) {
+        closeSocket(activeLogin.sock);
+        activeLogin = null;
+    }
+    if (reason) {
+        logInfo(reason);
+    }
+}
+function isLoginFresh(login) {
+    return Date.now() - login.startedAt < ACTIVE_LOGIN_TTL_MS;
+}
+function attachLoginWaiter(login) {
+    login.waitPromise = waitForWaConnection(login.sock)
+        .then(() => {
+        if (activeLogin?.id === login.id) {
+            activeLogin.connected = true;
+        }
+    })
+        .catch((err) => {
+        if (activeLogin?.id === login.id) {
+            activeLogin.error = formatError(err);
+            activeLogin.errorStatus = getStatusCode(err);
+        }
+    });
+}
+async function restartLoginSocket(login, runtime) {
+    if (login.restartAttempted)
+        return false;
+    login.restartAttempted = true;
+    runtime.log(info("WhatsApp asked for a restart after pairing (code 515); retrying connection once…"));
+    closeSocket(login.sock);
+    try {
+        const sock = await createWaSocket(false, login.verbose);
+        login.sock = sock;
+        login.connected = false;
+        login.error = undefined;
+        login.errorStatus = undefined;
+        attachLoginWaiter(login);
+        return true;
+    }
+    catch (err) {
+        login.error = formatError(err);
+        login.errorStatus = getStatusCode(err);
+        return false;
+    }
+}
+export async function startWebLoginWithQr(opts = {}) {
+    const runtime = opts.runtime ?? defaultRuntime;
+    const hasWeb = await webAuthExists();
+    const selfId = readWebSelfId();
+    if (hasWeb && !opts.force) {
+        const who = selfId.e164 ?? selfId.jid ?? "unknown";
+        return {
+            message: `WhatsApp is already linked (${who}). Say “relink” if you want a fresh QR.`,
+        };
+    }
+    if (activeLogin && isLoginFresh(activeLogin) && activeLogin.qrDataUrl) {
+        return {
+            qrDataUrl: activeLogin.qrDataUrl,
+            message: "QR already active. Scan it in WhatsApp → Linked Devices.",
+        };
+    }
+    await resetActiveLogin();
+    let resolveQr = null;
+    let rejectQr = null;
+    const qrPromise = new Promise((resolve, reject) => {
+        resolveQr = resolve;
+        rejectQr = reject;
+    });
+    const qrTimer = setTimeout(() => {
+        rejectQr?.(new Error("Timed out waiting for WhatsApp QR"));
+    }, Math.max(opts.timeoutMs ?? 30_000, 5000));
+    let sock;
+    try {
+        sock = await createWaSocket(false, Boolean(opts.verbose), {
+            onQr: (qr) => {
+                if (!activeLogin || activeLogin.qr)
+                    return;
+                activeLogin.qr = qr;
+                clearTimeout(qrTimer);
+                runtime.log(info("WhatsApp QR received."));
+                resolveQr?.(qr);
+            },
+        });
+    }
+    catch (err) {
+        clearTimeout(qrTimer);
+        await resetActiveLogin();
+        return {
+            message: `Failed to start WhatsApp login: ${String(err)}`,
+        };
+    }
+    const login = {
+        id: randomUUID(),
+        sock,
+        startedAt: Date.now(),
+        connected: false,
+        waitPromise: Promise.resolve(),
+        restartAttempted: false,
+        verbose: Boolean(opts.verbose),
+    };
+    activeLogin = login;
+    attachLoginWaiter(login);
+    let qr;
+    try {
+        qr = await qrPromise;
+    }
+    catch (err) {
+        clearTimeout(qrTimer);
+        await resetActiveLogin();
+        return {
+            message: `Failed to get QR: ${String(err)}`,
+        };
+    }
+    const base64 = await renderQrPngBase64(qr);
+    login.qrDataUrl = `data:image/png;base64,${base64}`;
+    return {
+        qrDataUrl: login.qrDataUrl,
+        message: "Scan this QR in WhatsApp → Linked Devices.",
+    };
+}
+export async function waitForWebLogin(opts = {}) {
+    const runtime = opts.runtime ?? defaultRuntime;
+    if (!activeLogin) {
+        return {
+            connected: false,
+            message: "No active WhatsApp login in progress.",
+        };
+    }
+    const login = activeLogin;
+    if (!isLoginFresh(login)) {
+        await resetActiveLogin();
+        return {
+            connected: false,
+            message: "The login QR expired. Ask me to generate a new one.",
+        };
+    }
+    const timeoutMs = Math.max(opts.timeoutMs ?? 120_000, 1000);
+    const deadline = Date.now() + timeoutMs;
+    while (true) {
+        const remaining = deadline - Date.now();
+        if (remaining <= 0) {
+            return {
+                connected: false,
+                message: "Still waiting for the QR scan. Let me know when you’ve scanned it.",
+            };
+        }
+        const timeout = new Promise((resolve) => setTimeout(() => resolve("timeout"), remaining));
+        const result = await Promise.race([
+            login.waitPromise.then(() => "done"),
+            timeout,
+        ]);
+        if (result === "timeout") {
+            return {
+                connected: false,
+                message: "Still waiting for the QR scan. Let me know when you’ve scanned it.",
+            };
+        }
+        if (login.error) {
+            if (login.errorStatus === DisconnectReason.loggedOut) {
+                await logoutWeb(runtime);
+                const message = "WhatsApp reported the session is logged out. Cleared cached web session; please scan a new QR.";
+                await resetActiveLogin(message);
+                runtime.log(danger(message));
+                return { connected: false, message };
+            }
+            if (login.errorStatus === 515) {
+                const restarted = await restartLoginSocket(login, runtime);
+                if (restarted && isLoginFresh(login)) {
+                    continue;
+                }
+            }
+            const message = `WhatsApp login failed: ${login.error}`;
+            await resetActiveLogin(message);
+            runtime.log(danger(message));
+            return { connected: false, message };
+        }
+        if (login.connected) {
+            const message = "✅ Linked! WhatsApp is ready.";
+            runtime.log(success(message));
+            await resetActiveLogin();
+            return { connected: true, message };
+        }
+        return { connected: false, message: "Login ended without a connection." };
+    }
+}