clawdbot 2026.1.4

package/dist/telegram/send.js

@@ -0,0 +1,138 @@
+// @ts-nocheck
+import { Bot, InputFile } from "grammy";
+import { formatErrorMessage } from "../infra/errors.js";
+import { mediaKindFromMime } from "../media/constants.js";
+import { loadWebMedia } from "../web/media.js";
+const PARSE_ERR_RE = /can't parse entities|parse entities|find end of the entity/i;
+function resolveToken(explicit) {
+    const token = explicit ?? process.env.TELEGRAM_BOT_TOKEN;
+    if (!token) {
+        throw new Error("TELEGRAM_BOT_TOKEN is required for Telegram sends (Bot API)");
+    }
+    return token.trim();
+}
+function normalizeChatId(to) {
+    const trimmed = to.trim();
+    if (!trimmed)
+        throw new Error("Recipient is required for Telegram sends");
+    // Common internal prefixes that sometimes leak into outbound sends.
+    // - ctx.To uses `telegram:<id>`
+    // - group sessions often use `telegram:group:<id>`
+    let normalized = trimmed.replace(/^(telegram|tg|group):/i, "").trim();
+    // Accept t.me links for public chats/channels.
+    // (Invite links like `t.me/+...` are not resolvable via Bot API.)
+    const m = /^https?:\/\/t\.me\/([A-Za-z0-9_]+)$/i.exec(normalized) ??
+        /^t\.me\/([A-Za-z0-9_]+)$/i.exec(normalized);
+    if (m?.[1])
+        normalized = `@${m[1]}`;
+    if (!normalized)
+        throw new Error("Recipient is required for Telegram sends");
+    if (normalized.startsWith("@"))
+        return normalized;
+    if (/^-?\d+$/.test(normalized))
+        return normalized;
+    // If the user passed a username without `@`, assume they meant a public chat/channel.
+    if (/^[A-Za-z0-9_]{5,}$/i.test(normalized))
+        return `@${normalized}`;
+    return normalized;
+}
+export async function sendMessageTelegram(to, text, opts = {}) {
+    const token = resolveToken(opts.token);
+    const chatId = normalizeChatId(to);
+    const bot = opts.api ? null : new Bot(token);
+    const api = opts.api ?? bot?.api;
+    const mediaUrl = opts.mediaUrl?.trim();
+    const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+    const sendWithRetry = async (fn, label) => {
+        let lastErr;
+        for (let attempt = 1; attempt <= 3; attempt++) {
+            try {
+                return await fn();
+            }
+            catch (err) {
+                lastErr = err;
+                const errText = formatErrorMessage(err);
+                const terminal = attempt === 3 ||
+                    !/429|timeout|connect|reset|closed|unavailable|temporarily/i.test(errText);
+                if (terminal)
+                    break;
+                const backoff = 400 * attempt;
+                if (opts.verbose) {
+                    console.warn(`telegram send retry ${attempt}/2 for ${label} in ${backoff}ms: ${errText}`);
+                }
+                await sleep(backoff);
+            }
+        }
+        throw lastErr ?? new Error(`Telegram send failed (${label})`);
+    };
+    const wrapChatNotFound = (err) => {
+        if (!/400: Bad Request: chat not found/i.test(formatErrorMessage(err)))
+            return err;
+        return new Error([
+            `Telegram send failed: chat not found (chat_id=${chatId}).`,
+            "Likely: bot not started in DM, bot removed from group/channel, group migrated (new -100… id), or wrong bot token.",
+            `Input was: ${JSON.stringify(to)}.`,
+        ].join(" "));
+    };
+    if (mediaUrl) {
+        const media = await loadWebMedia(mediaUrl, opts.maxBytes);
+        const kind = mediaKindFromMime(media.contentType ?? undefined);
+        const file = new InputFile(media.buffer, media.fileName ?? inferFilename(kind) ?? "file");
+        const caption = text?.trim() || undefined;
+        let result;
+        if (kind === "image") {
+            result = await sendWithRetry(() => api.sendPhoto(chatId, file, { caption }), "photo").catch((err) => {
+                throw wrapChatNotFound(err);
+            });
+        }
+        else if (kind === "video") {
+            result = await sendWithRetry(() => api.sendVideo(chatId, file, { caption }), "video").catch((err) => {
+                throw wrapChatNotFound(err);
+            });
+        }
+        else if (kind === "audio") {
+            result = await sendWithRetry(() => api.sendAudio(chatId, file, { caption }), "audio").catch((err) => {
+                throw wrapChatNotFound(err);
+            });
+        }
+        else {
+            result = await sendWithRetry(() => api.sendDocument(chatId, file, { caption }), "document").catch((err) => {
+                throw wrapChatNotFound(err);
+            });
+        }
+        const messageId = String(result?.message_id ?? "unknown");
+        return { messageId, chatId: String(result?.chat?.id ?? chatId) };
+    }
+    if (!text || !text.trim()) {
+        throw new Error("Message must be non-empty for Telegram sends");
+    }
+    const res = await sendWithRetry(() => api.sendMessage(chatId, text, { parse_mode: "Markdown" }), "message").catch(async (err) => {
+        // Telegram rejects malformed Markdown (e.g., unbalanced '_' or '*').
+        // When that happens, fall back to plain text so the message still delivers.
+        const errText = formatErrorMessage(err);
+        if (PARSE_ERR_RE.test(errText)) {
+            if (opts.verbose) {
+                console.warn(`telegram markdown parse failed, retrying as plain text: ${errText}`);
+            }
+            return await sendWithRetry(() => api.sendMessage(chatId, text), "message-plain").catch((err2) => {
+                throw wrapChatNotFound(err2);
+            });
+        }
+        throw wrapChatNotFound(err);
+    });
+    const messageId = String(res?.message_id ?? "unknown");
+    return { messageId, chatId: String(res?.chat?.id ?? chatId) };
+}
+function inferFilename(kind) {
+    switch (kind) {
+        case "image":
+            return "image.jpg";
+        case "video":
+            return "video.mp4";
+        case "audio":
+            return "audio.ogg";
+        default:
+            return "file.bin";
+    }
+}
+// @ts-nocheck

package/dist/telegram/token.js

@@ -0,0 +1,30 @@
+import fs from "node:fs";
+export function resolveTelegramToken(cfg, opts = {}) {
+    const envToken = (opts.envToken ?? process.env.TELEGRAM_BOT_TOKEN)?.trim();
+    if (envToken) {
+        return { token: envToken, source: "env" };
+    }
+    const tokenFile = cfg?.telegram?.tokenFile?.trim();
+    if (tokenFile) {
+        if (!fs.existsSync(tokenFile)) {
+            opts.logMissingFile?.(`telegram.tokenFile not found: ${tokenFile}`);
+            return { token: "", source: "none" };
+        }
+        try {
+            const token = fs.readFileSync(tokenFile, "utf-8").trim();
+            if (token) {
+                return { token, source: "tokenFile" };
+            }
+        }
+        catch (err) {
+            opts.logMissingFile?.(`telegram.tokenFile read failed: ${String(err)}`);
+            return { token: "", source: "none" };
+        }
+        return { token: "", source: "none" };
+    }
+    const configToken = cfg?.telegram?.botToken?.trim();
+    if (configToken) {
+        return { token: configToken, source: "config" };
+    }
+    return { token: "", source: "none" };
+}

package/dist/telegram/webhook-set.js

@@ -0,0 +1,12 @@
+import { Bot } from "grammy";
+export async function setTelegramWebhook(opts) {
+    const bot = new Bot(opts.token);
+    await bot.api.setWebhook(opts.url, {
+        secret_token: opts.secret,
+        drop_pending_updates: opts.dropPendingUpdates ?? false,
+    });
+}
+export async function deleteTelegramWebhook(opts) {
+    const bot = new Bot(opts.token);
+    await bot.api.deleteWebhook();
+}

package/dist/telegram/webhook.js

@@ -0,0 +1,56 @@
+import { createServer } from "node:http";
+import { webhookCallback } from "grammy";
+import { formatErrorMessage } from "../infra/errors.js";
+import { defaultRuntime } from "../runtime.js";
+import { createTelegramBot } from "./bot.js";
+export async function startTelegramWebhook(opts) {
+    const path = opts.path ?? "/telegram-webhook";
+    const healthPath = opts.healthPath ?? "/healthz";
+    const port = opts.port ?? 8787;
+    const host = opts.host ?? "0.0.0.0";
+    const runtime = opts.runtime ?? defaultRuntime;
+    const bot = createTelegramBot({
+        token: opts.token,
+        runtime,
+        proxyFetch: opts.fetch,
+    });
+    const handler = webhookCallback(bot, "http", {
+        secretToken: opts.secret,
+    });
+    const server = createServer((req, res) => {
+        if (req.url === healthPath) {
+            res.writeHead(200);
+            res.end("ok");
+            return;
+        }
+        if (req.url !== path || req.method !== "POST") {
+            res.writeHead(404);
+            res.end();
+            return;
+        }
+        const handled = handler(req, res);
+        if (handled && typeof handled.catch === "function") {
+            void handled.catch((err) => {
+                runtime.log?.(`webhook handler failed: ${formatErrorMessage(err)}`);
+                if (!res.headersSent)
+                    res.writeHead(500);
+                res.end();
+            });
+        }
+    });
+    const publicUrl = opts.publicUrl ??
+        `http://${host === "0.0.0.0" ? "localhost" : host}:${port}${path}`;
+    await bot.api.setWebhook(publicUrl, {
+        secret_token: opts.secret,
+    });
+    await new Promise((resolve) => server.listen(port, host, resolve));
+    runtime.log?.(`webhook listening on ${publicUrl}`);
+    const shutdown = () => {
+        server.close();
+        void bot.stop();
+    };
+    if (opts.abortSignal) {
+        opts.abortSignal.addEventListener("abort", shutdown, { once: true });
+    }
+    return { server, bot, stop: shutdown };
+}

package/dist/utils.js

@@ -0,0 +1,133 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { logVerbose, shouldLogVerbose } from "./globals.js";
+export async function ensureDir(dir) {
+    await fs.promises.mkdir(dir, { recursive: true });
+}
+export function assertProvider(input) {
+    if (input !== "web") {
+        throw new Error("Provider must be 'web'");
+    }
+}
+export function normalizePath(p) {
+    if (!p.startsWith("/"))
+        return `/${p}`;
+    return p;
+}
+export function withWhatsAppPrefix(number) {
+    return number.startsWith("whatsapp:") ? number : `whatsapp:${number}`;
+}
+export function normalizeE164(number) {
+    const withoutPrefix = number.replace(/^whatsapp:/, "").trim();
+    const digits = withoutPrefix.replace(/[^\d+]/g, "");
+    if (digits.startsWith("+"))
+        return `+${digits.slice(1)}`;
+    return `+${digits}`;
+}
+/**
+ * "Self-chat mode" heuristic (single phone): the gateway is logged in as the owner's own WhatsApp account,
+ * and `whatsapp.allowFrom` includes that same number. Used to avoid side-effects that make no sense when the
+ * "bot" and the human are the same WhatsApp identity (e.g. auto read receipts, @mention JID triggers).
+ */
+export function isSelfChatMode(selfE164, allowFrom) {
+    if (!selfE164)
+        return false;
+    if (!Array.isArray(allowFrom) || allowFrom.length === 0)
+        return false;
+    const normalizedSelf = normalizeE164(selfE164);
+    return allowFrom.some((n) => {
+        if (n === "*")
+            return false;
+        try {
+            return normalizeE164(String(n)) === normalizedSelf;
+        }
+        catch {
+            return false;
+        }
+    });
+}
+export function toWhatsappJid(number) {
+    const withoutPrefix = number.replace(/^whatsapp:/, "").trim();
+    if (withoutPrefix.includes("@"))
+        return withoutPrefix;
+    const e164 = normalizeE164(withoutPrefix);
+    const digits = e164.replace(/\D/g, "");
+    return `${digits}@s.whatsapp.net`;
+}
+export function jidToE164(jid) {
+    // Convert a WhatsApp JID (with optional device suffix, e.g. 1234:1@s.whatsapp.net) back to +1234.
+    const match = jid.match(/^(\d+)(?::\d+)?@s\.whatsapp\.net$/);
+    if (match) {
+        const digits = match[1];
+        return `+${digits}`;
+    }
+    // Support @lid format (WhatsApp Linked ID) - look up reverse mapping
+    const lidMatch = jid.match(/^(\d+)(?::\d+)?@lid$/);
+    if (lidMatch) {
+        const lid = lidMatch[1];
+        try {
+            const mappingPath = `${CONFIG_DIR}/credentials/lid-mapping-${lid}_reverse.json`;
+            const data = fs.readFileSync(mappingPath, "utf8");
+            const phone = JSON.parse(data);
+            if (phone)
+                return `+${phone}`;
+        }
+        catch {
+            if (shouldLogVerbose()) {
+                logVerbose(`LID mapping not found for ${lid}; skipping inbound message`);
+            }
+            // Mapping not found, fall through
+        }
+    }
+    return null;
+}
+export function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+export function resolveUserPath(input) {
+    const trimmed = input.trim();
+    if (!trimmed)
+        return trimmed;
+    if (trimmed.startsWith("~")) {
+        return path.resolve(trimmed.replace("~", os.homedir()));
+    }
+    return path.resolve(trimmed);
+}
+export function resolveHomeDir() {
+    const envHome = process.env.HOME?.trim();
+    if (envHome)
+        return envHome;
+    const envProfile = process.env.USERPROFILE?.trim();
+    if (envProfile)
+        return envProfile;
+    try {
+        const home = os.homedir();
+        return home?.trim() ? home : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function shortenHomePath(input) {
+    if (!input)
+        return input;
+    const home = resolveHomeDir();
+    if (!home)
+        return input;
+    if (input === home)
+        return "~";
+    if (input.startsWith(`${home}/`))
+        return `~${input.slice(home.length)}`;
+    return input;
+}
+export function shortenHomeInString(input) {
+    if (!input)
+        return input;
+    const home = resolveHomeDir();
+    if (!home)
+        return input;
+    return input.split(home).join("~");
+}
+// Fixed configuration root; legacy ~/.clawdbot is no longer used.
+export const CONFIG_DIR = path.join(os.homedir(), ".clawdbot");

package/dist/version.js

@@ -0,0 +1,18 @@
+import { createRequire } from "node:module";
+function readVersionFromPackageJson() {
+    try {
+        const require = createRequire(import.meta.url);
+        const pkg = require("../package.json");
+        return pkg.version ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+// Single source of truth for the current clawdbot version.
+// - Embedded/bundled builds: injected define or env var.
+// - Dev/npm builds: package.json.
+export const VERSION = (typeof __CLAWDBOT_VERSION__ === "string" && __CLAWDBOT_VERSION__) ||
+    process.env.CLAWDBOT_BUNDLED_VERSION ||
+    readVersionFromPackageJson() ||
+    "0.0.0";

package/dist/web/active-listener.js

@@ -0,0 +1,7 @@
+let currentListener = null;
+export function setActiveWebListener(listener) {
+    currentListener = listener;
+}
+export function getActiveWebListener() {
+    return currentListener;
+}