@intent-systems/nexus 2026.1.5-3

package/dist/telegram/download.js

@@ -0,0 +1,34 @@
+import { detectMime } from "../media/mime.js";
+import { saveMediaBuffer } from "../media/store.js";
+export async function getTelegramFile(token, fileId) {
+    const res = await fetch(`https://api.telegram.org/bot${token}/getFile?file_id=${encodeURIComponent(fileId)}`);
+    if (!res.ok) {
+        throw new Error(`getFile failed: ${res.status} ${res.statusText}`);
+    }
+    const json = (await res.json());
+    if (!json.ok || !json.result?.file_path) {
+        throw new Error("getFile returned no file_path");
+    }
+    return json.result;
+}
+export async function downloadTelegramFile(token, info, maxBytes) {
+    if (!info.file_path)
+        throw new Error("file_path missing");
+    const url = `https://api.telegram.org/file/bot${token}/${info.file_path}`;
+    const res = await fetch(url);
+    if (!res.ok || !res.body) {
+        throw new Error(`Failed to download telegram file: HTTP ${res.status}`);
+    }
+    const array = Buffer.from(await res.arrayBuffer());
+    const mime = await detectMime({
+        buffer: array,
+        headerMime: res.headers.get("content-type"),
+        filePath: info.file_path,
+    });
+    // save with inbound subdir
+    const saved = await saveMediaBuffer(array, mime, "inbound", maxBytes);
+    // Ensure extension matches mime if possible
+    if (!saved.contentType && mime)
+        saved.contentType = mime;
+    return saved;
+}

package/dist/telegram/index.js

@@ -0,0 +1,4 @@
+export { createTelegramBot, createTelegramWebhookCallback } from "./bot.js";
+export { monitorTelegramProvider } from "./monitor.js";
+export { sendMessageTelegram } from "./send.js";
+export { startTelegramWebhook } from "./webhook.js";

package/dist/telegram/monitor.js

@@ -0,0 +1,47 @@
+import { loadConfig } from "../config/config.js";
+import { createTelegramBot } from "./bot.js";
+import { makeProxyFetch } from "./proxy.js";
+import { resolveTelegramToken } from "./token.js";
+import { startTelegramWebhook } from "./webhook.js";
+export async function monitorTelegramProvider(opts = {}) {
+    const { token } = resolveTelegramToken(loadConfig(), {
+        envToken: opts.token,
+    });
+    if (!token) {
+        throw new Error("TELEGRAM_BOT_TOKEN or telegram.botToken/tokenFile is required for Telegram gateway");
+    }
+    const proxyFetch = opts.proxyFetch ??
+        (loadConfig().telegram?.proxy
+            ? makeProxyFetch(loadConfig().telegram?.proxy)
+            : undefined);
+    const bot = createTelegramBot({
+        token,
+        runtime: opts.runtime,
+        proxyFetch,
+    });
+    if (opts.useWebhook) {
+        await startTelegramWebhook({
+            token,
+            path: opts.webhookPath,
+            port: opts.webhookPort,
+            secret: opts.webhookSecret,
+            runtime: opts.runtime,
+            fetch: proxyFetch,
+            abortSignal: opts.abortSignal,
+            publicUrl: opts.webhookUrl,
+        });
+        return;
+    }
+    // Long polling
+    const stopOnAbort = () => {
+        if (opts.abortSignal?.aborted)
+            void bot.stop();
+    };
+    opts.abortSignal?.addEventListener("abort", stopOnAbort, { once: true });
+    try {
+        await bot.start();
+    }
+    finally {
+        opts.abortSignal?.removeEventListener("abort", stopOnAbort);
+    }
+}

package/dist/telegram/pairing-store.js

@@ -0,0 +1,77 @@
+import { addProviderAllowFromStoreEntry, approveProviderPairingCode, listProviderPairingRequests, readProviderAllowFromStore, upsertProviderPairingRequest, } from "../pairing/pairing-store.js";
+const PROVIDER = "telegram";
+export async function readTelegramAllowFromStore(env = process.env) {
+    return readProviderAllowFromStore(PROVIDER, env);
+}
+export async function addTelegramAllowFromStoreEntry(params) {
+    return addProviderAllowFromStoreEntry({
+        provider: PROVIDER,
+        entry: params.entry,
+        env: params.env,
+    });
+}
+export async function listTelegramPairingRequests(env = process.env) {
+    const list = await listProviderPairingRequests(PROVIDER, env);
+    return list.map((r) => ({
+        chatId: r.id,
+        code: r.code,
+        createdAt: r.createdAt,
+        lastSeenAt: r.lastSeenAt,
+        username: r.meta?.username,
+        firstName: r.meta?.firstName,
+        lastName: r.meta?.lastName,
+    }));
+}
+export async function upsertTelegramPairingRequest(params) {
+    return upsertProviderPairingRequest({
+        provider: PROVIDER,
+        id: String(params.chatId),
+        env: params.env,
+        meta: {
+            username: params.username,
+            firstName: params.firstName,
+            lastName: params.lastName,
+        },
+    });
+}
+export async function approveTelegramPairingCode(params) {
+    const res = await approveProviderPairingCode({
+        provider: PROVIDER,
+        code: params.code,
+        env: params.env,
+    });
+    if (!res)
+        return null;
+    const entry = res.entry
+        ? {
+            chatId: res.entry.id,
+            code: res.entry.code,
+            createdAt: res.entry.createdAt,
+            lastSeenAt: res.entry.lastSeenAt,
+            username: res.entry.meta?.username,
+            firstName: res.entry.meta?.firstName,
+            lastName: res.entry.meta?.lastName,
+        }
+        : undefined;
+    return { chatId: res.id, entry };
+}
+export async function resolveTelegramEffectiveAllowFrom(params) {
+    const env = params.env ?? process.env;
+    const cfgAllowFrom = (params.cfg.telegram?.allowFrom ?? [])
+        .map((v) => String(v).trim())
+        .filter(Boolean)
+        .map((v) => v.replace(/^(telegram|tg):/i, ""))
+        .filter((v) => v !== "*");
+    const cfgGroupAllowFrom = (params.cfg.telegram?.groupAllowFrom ?? [])
+        .map((v) => String(v).trim())
+        .filter(Boolean)
+        .map((v) => v.replace(/^(telegram|tg):/i, ""))
+        .filter((v) => v !== "*");
+    const storeAllowFrom = await readTelegramAllowFromStore(env);
+    const dm = Array.from(new Set([...cfgAllowFrom, ...storeAllowFrom]));
+    const group = Array.from(new Set([
+        ...(cfgGroupAllowFrom.length > 0 ? cfgGroupAllowFrom : cfgAllowFrom),
+        ...storeAllowFrom,
+    ]));
+    return { dm, group };
+}

package/dist/telegram/probe.js

@@ -0,0 +1,63 @@
+import { makeProxyFetch } from "./proxy.js";
+const TELEGRAM_API_BASE = "https://api.telegram.org";
+async function fetchWithTimeout(url, timeoutMs, fetcher) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        return await fetcher(url, { signal: controller.signal });
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+export async function probeTelegram(token, timeoutMs, proxyUrl) {
+    const started = Date.now();
+    const fetcher = proxyUrl ? makeProxyFetch(proxyUrl) : fetch;
+    const base = `${TELEGRAM_API_BASE}/bot${token}`;
+    const result = {
+        ok: false,
+        status: null,
+        error: null,
+        elapsedMs: 0,
+    };
+    try {
+        const meRes = await fetchWithTimeout(`${base}/getMe`, timeoutMs, fetcher);
+        const meJson = (await meRes.json());
+        if (!meRes.ok || !meJson?.ok) {
+            result.status = meRes.status;
+            result.error = meJson?.description ?? `getMe failed (${meRes.status})`;
+            return { ...result, elapsedMs: Date.now() - started };
+        }
+        result.bot = {
+            id: meJson.result?.id ?? null,
+            username: meJson.result?.username ?? null,
+        };
+        // Try to fetch webhook info, but don't fail health if it errors.
+        try {
+            const webhookRes = await fetchWithTimeout(`${base}/getWebhookInfo`, timeoutMs, fetcher);
+            const webhookJson = (await webhookRes.json());
+            if (webhookRes.ok && webhookJson?.ok) {
+                result.webhook = {
+                    url: webhookJson.result?.url ?? null,
+                    hasCustomCert: webhookJson.result?.has_custom_certificate ?? null,
+                };
+            }
+        }
+        catch {
+            // ignore webhook errors for probe
+        }
+        result.ok = true;
+        result.status = null;
+        result.error = null;
+        result.elapsedMs = Date.now() - started;
+        return result;
+    }
+    catch (err) {
+        return {
+            ...result,
+            status: err instanceof Response ? err.status : result.status,
+            error: err instanceof Error ? err.message : String(err),
+            elapsedMs: Date.now() - started,
+        };
+    }
+}

package/dist/telegram/proxy.js

@@ -0,0 +1,9 @@
+// @ts-nocheck
+import { ProxyAgent } from "undici";
+export function makeProxyFetch(proxyUrl) {
+    const agent = new ProxyAgent(proxyUrl);
+    return (input, init) => {
+        const base = init ? { ...init } : {};
+        return fetch(input, { ...base, dispatcher: agent });
+    };
+}

package/dist/telegram/reaction-level.js

@@ -0,0 +1,45 @@
+/**
+ * Resolve the effective reaction level and its implications.
+ */
+export function resolveTelegramReactionLevel(params) {
+    const channelConfig = "channels" in params.cfg
+        ? params.cfg.channels?.telegram
+        : undefined;
+    const telegramCfg = channelConfig ?? params.cfg.telegram;
+    const level = (telegramCfg?.reactionLevel ?? "ack");
+    switch (level) {
+        case "off":
+            return {
+                level,
+                ackEnabled: false,
+                agentReactionsEnabled: false,
+            };
+        case "ack":
+            return {
+                level,
+                ackEnabled: true,
+                agentReactionsEnabled: false,
+            };
+        case "minimal":
+            return {
+                level,
+                ackEnabled: false,
+                agentReactionsEnabled: true,
+                agentReactionGuidance: "minimal",
+            };
+        case "extensive":
+            return {
+                level,
+                ackEnabled: false,
+                agentReactionsEnabled: true,
+                agentReactionGuidance: "extensive",
+            };
+        default:
+            // Fallback to ack behavior
+            return {
+                level: "ack",
+                ackEnabled: true,
+                agentReactionsEnabled: false,
+            };
+    }
+}

package/dist/telegram/send.js

@@ -0,0 +1,151 @@
+// @ts-nocheck
+import { Bot, InputFile } from "grammy";
+import { formatErrorMessage } from "../infra/errors.js";
+import { mediaKindFromMime } from "../media/constants.js";
+import { isGifMedia } from "../media/mime.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 isGif = isGifMedia({
+            contentType: media.contentType,
+            fileName: media.fileName,
+        });
+        const fileName = media.fileName ??
+            (isGif ? "animation.gif" : inferFilename(kind)) ??
+            "file";
+        const file = new InputFile(media.buffer, fileName);
+        const caption = text?.trim() || undefined;
+        let result;
+        if (isGif) {
+            result = await sendWithRetry(() => api.sendAnimation(chatId, file, { caption }), "animation").catch((err) => {
+                throw wrapChatNotFound(err);
+            });
+        }
+        else 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/sent-message-cache.js

@@ -0,0 +1,65 @@
+/**
+ * In-memory cache of sent message IDs per chat.
+ * Used to identify bot's own messages for reaction filtering ("own" mode).
+ */
+const TTL_MS = 6 * 60 * 60 * 1000;
+const MAX_MESSAGES_PER_CHAT = 200;
+const sentByChat = new Map();
+function normalizeChatId(chatId) {
+    return String(chatId);
+}
+function normalizeMessageId(messageId) {
+    const parsed = typeof messageId === "number" ? messageId : Number(messageId);
+    return Number.isFinite(parsed) ? parsed : null;
+}
+function pruneChatCache(chatId, now) {
+    const entry = sentByChat.get(chatId);
+    if (!entry)
+        return;
+    for (const [id, ts] of entry) {
+        if (now - ts > TTL_MS)
+            entry.delete(id);
+    }
+    if (entry.size > MAX_MESSAGES_PER_CHAT) {
+        const sorted = [...entry.entries()].sort((a, b) => a[1] - b[1]);
+        const removeCount = entry.size - MAX_MESSAGES_PER_CHAT;
+        for (let i = 0; i < removeCount; i += 1) {
+            entry.delete(sorted[i]?.[0] ?? -1);
+        }
+    }
+    if (entry.size === 0)
+        sentByChat.delete(chatId);
+}
+export function recordSentMessage(chatId, messageId) {
+    const normalizedChatId = normalizeChatId(chatId);
+    const normalizedMessageId = normalizeMessageId(messageId);
+    if (normalizedMessageId == null)
+        return;
+    const now = Date.now();
+    const entry = sentByChat.get(normalizedChatId) ?? new Map();
+    entry.set(normalizedMessageId, now);
+    sentByChat.set(normalizedChatId, entry);
+    pruneChatCache(normalizedChatId, now);
+}
+export function wasSentByBot(chatId, messageId) {
+    const normalizedChatId = normalizeChatId(chatId);
+    const normalizedMessageId = normalizeMessageId(messageId);
+    if (normalizedMessageId == null)
+        return false;
+    const entry = sentByChat.get(normalizedChatId);
+    if (!entry)
+        return false;
+    const ts = entry.get(normalizedMessageId);
+    if (!ts)
+        return false;
+    if (Date.now() - ts > TTL_MS) {
+        entry.delete(normalizedMessageId);
+        if (entry.size === 0)
+            sentByChat.delete(normalizedChatId);
+        return false;
+    }
+    return true;
+}
+export function clearSentMessageCache() {
+    sentByChat.clear();
+}

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/update-offset-store.js

@@ -0,0 +1,61 @@
+import crypto from "node:crypto";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { resolveStateDir } from "../config/paths.js";
+const STORE_VERSION = 1;
+function normalizeAccountId(accountId) {
+    const trimmed = accountId?.trim();
+    if (!trimmed)
+        return "default";
+    return trimmed.replace(/[^a-z0-9._-]+/gi, "_");
+}
+function resolveTelegramUpdateOffsetPath(accountId, env = process.env) {
+    const stateDir = resolveStateDir(env, os.homedir);
+    const normalized = normalizeAccountId(accountId);
+    return path.join(stateDir, "telegram", `update-offset-${normalized}.json`);
+}
+function safeParseState(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        if (parsed?.version !== STORE_VERSION)
+            return null;
+        if (parsed.lastUpdateId !== null &&
+            typeof parsed.lastUpdateId !== "number") {
+            return null;
+        }
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+export async function readTelegramUpdateOffset(params) {
+    const filePath = resolveTelegramUpdateOffsetPath(params.accountId, params.env);
+    try {
+        const raw = await fs.readFile(filePath, "utf-8");
+        const parsed = safeParseState(raw);
+        return parsed?.lastUpdateId ?? null;
+    }
+    catch (err) {
+        const code = err.code;
+        if (code === "ENOENT")
+            return null;
+        return null;
+    }
+}
+export async function writeTelegramUpdateOffset(params) {
+    const filePath = resolveTelegramUpdateOffsetPath(params.accountId, params.env);
+    const dir = path.dirname(filePath);
+    await fs.mkdir(dir, { recursive: true, mode: 0o700 });
+    const tmp = path.join(dir, `${path.basename(filePath)}.${crypto.randomUUID()}.tmp`);
+    const payload = {
+        version: STORE_VERSION,
+        lastUpdateId: params.updateId,
+    };
+    await fs.writeFile(tmp, `${JSON.stringify(payload, null, 2)}\n`, {
+        encoding: "utf-8",
+    });
+    await fs.chmod(tmp, 0o600);
+    await fs.rename(tmp, filePath);
+}

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 };
+}