@capybara-hq/plugin-telegram 0.0.0-stage → 0.1.0-rc.1

package/dist/index.mjs

@@ -0,0 +1,1263 @@
+import { createRequire as __capybaraCreateRequire } from "node:module";
+import { fileURLToPath as __capybaraFileURLToPath } from "node:url";
+import { dirname as __capybaraPathDirname } from "node:path";
+const require = __capybaraCreateRequire(import.meta.url);
+const __capybara_filename = __capybaraFileURLToPath(import.meta.url);
+const __capybara_dirname = __capybaraPathDirname(__capybara_filename);
+
+// src/index.ts
+import { CHANNEL_EXTENSION_POINT, defineExtension } from "@capybara-hq/plugin-sdk";
+
+// src/channel.ts
+import {
+  ChannelSendError as ChannelSendError2
+} from "@capybara-hq/plugin-sdk";
+
+// src/actions.ts
+import { randomBytes } from "node:crypto";
+
+// src/config.ts
+import { secret, ui } from "@capybara-hq/plugin-sdk";
+import { z } from "zod";
+var TelegramDeployment = z.object({
+  apiUrl: ui(z.string().url().default("https://api.telegram.org"), {
+    label: { zh: "API 地址", en: "API URL" }
+  })
+});
+var TelegramConnection = z.object({
+  botToken: ui(
+    secret(
+      z.string().regex(/^\d+:[A-Za-z0-9_-]+$/, "must be a BotFather bot token such as 123456:ABC-DEF…")
+    ),
+    {
+      label: { zh: "机器人令牌", en: "Bot token" },
+      help: {
+        zh: "在 @BotFather 中创建机器人后获得，形如 123456:ABC-DEF…。",
+        en: "From @BotFather when you create the bot, such as 123456:ABC-DEF…."
+      },
+      placeholder: "123456:ABC-DEF…"
+    }
+  ),
+  webhookSecret: ui(
+    secret(
+      z.string().regex(/^[A-Za-z0-9_-]{1,256}$/, "must be 1-256 characters of A-Z, a-z, 0-9, _ and -").optional()
+    ),
+    {
+      label: { zh: "Webhook 密钥", en: "Webhook secret" },
+      help: {
+        zh: "仅 webhook 模式需要：调用 setWebhook 时作为 secret_token 传入的同一个值；长轮询留空。",
+        en: "Only needed in webhook mode: the same value you pass as secret_token to setWebhook. Leave empty for long polling."
+      }
+    }
+  )
+});
+var botIdOf = (token) => token.slice(0, token.indexOf(":"));
+var SENDER_TENANT = "global";
+var connectionTenant = (botId) => `bot${botId}`;
+
+// src/threads.ts
+var RECORD_TTL_SECONDS = 30 * 24 * 60 * 60;
+function threadStore(kv, botId) {
+  const threadKey = (chatId, messageId) => `thread/${botId}/${chatId}:${messageId}`;
+  const topicKey = (threadId) => `topic/${botId}/${threadId}`;
+  return {
+    async threadOfMessage(chatId, messageId) {
+      return await kv?.get(threadKey(chatId, messageId)) ?? void 0;
+    },
+    async recordSent(chatId, messageId, threadId) {
+      await kv?.set(threadKey(chatId, messageId), threadId, { ttlSeconds: RECORD_TTL_SECONDS });
+    },
+    async topicOf(threadId) {
+      const raw = await kv?.get(topicKey(threadId));
+      if (raw === null || raw === void 0) return void 0;
+      const n = Number(raw);
+      return Number.isSafeInteger(n) ? n : void 0;
+    },
+    async recordTopic(threadId, messageThreadId) {
+      await kv?.set(topicKey(threadId), String(messageThreadId), {
+        ttlSeconds: RECORD_TTL_SECONDS
+      });
+    }
+  };
+}
+
+// src/actions.ts
+var CALLBACK_PREFIX = "cb:";
+var TOKEN_RE = /^[A-Za-z0-9_-]{16}$/;
+var ACTION_JSON_MAX = 8e3;
+var nonEmpty = (x) => typeof x === "string" && x !== "";
+var SCOPES = /* @__PURE__ */ new Set(["once", "session", "always"]);
+function decodeCardAction(json) {
+  if (typeof json !== "string" || json.length === 0 || json.length > ACTION_JSON_MAX) return null;
+  let v;
+  try {
+    v = JSON.parse(json);
+  } catch {
+    return null;
+  }
+  if (typeof v !== "object" || v === null || Array.isArray(v)) return null;
+  const o = v;
+  if (!nonEmpty(o.cardId)) return null;
+  const cardId = o.cardId;
+  if (o.cardKind === "approval") {
+    if (o.answer !== void 0) return null;
+    if (o.action === "approve" && typeof o.scope === "string" && SCOPES.has(o.scope)) {
+      return {
+        cardKind: "approval",
+        cardId,
+        action: "approve",
+        scope: o.scope
+      };
+    }
+    if (o.action === "deny" && o.scope === void 0) {
+      return { cardKind: "approval", cardId, action: "deny" };
+    }
+    return null;
+  }
+  if (o.cardKind === "question") {
+    if (o.action !== "answer" || o.scope !== void 0) return null;
+    const a = o.answer;
+    if (typeof a !== "object" || a === null || Array.isArray(a)) return null;
+    const entries = Object.entries(a);
+    if (entries.length === 0) return null;
+    for (const [k, val] of entries) {
+      if (k === "") return null;
+      const ok = typeof val === "string" || typeof val === "boolean" || typeof val === "number" && Number.isFinite(val) || Array.isArray(val) && val.every((x) => typeof x === "string");
+      if (!ok) return null;
+    }
+    return {
+      cardKind: "question",
+      cardId,
+      action: "answer",
+      answer: a
+    };
+  }
+  return null;
+}
+function cardTokenStore(kv, botId) {
+  const key = (token) => `card/${botId}/${token}`;
+  return {
+    async put(a) {
+      if (!kv) throw new Error("no kv available for card tokens");
+      const token = randomBytes(12).toString("base64url");
+      await kv.set(key(token), JSON.stringify(a), { ttlSeconds: RECORD_TTL_SECONDS });
+      return token;
+    },
+    async take(token) {
+      if (!kv || !TOKEN_RE.test(token)) return null;
+      const raw = await kv.get(key(token));
+      return raw === null || raw === void 0 ? null : decodeCardAction(raw);
+    }
+  };
+}
+var obj = (v) => typeof v === "object" && v !== null && !Array.isArray(v) ? v : void 0;
+var int = (v) => typeof v === "number" && Number.isSafeInteger(v) ? v : void 0;
+var str = (v) => typeof v === "string" && v !== "" ? v : void 0;
+async function parseCallback(update, tokens, threads) {
+  const q = obj(obj(update)?.callback_query);
+  const id = str(q?.id);
+  const data = str(q?.data);
+  const from = obj(q?.from);
+  const message = obj(q?.message);
+  const chat = obj(message?.chat);
+  const userId = int(from?.id);
+  const chatId = int(chat?.id);
+  const messageId = int(message?.message_id);
+  if (!q || !id || !data || !from || !chat || !messageId || userId === void 0) return null;
+  if (chatId === void 0 || from.is_bot === true) return null;
+  if (!data.startsWith(CALLBACK_PREFIX) || data.length > 64) return null;
+  const chatType = chat.type;
+  const dm = chatType === "private";
+  if (!dm && chatType !== "group" && chatType !== "supergroup") return null;
+  const action = await tokens.take(data.slice(CALLBACK_PREFIX.length));
+  if (!action) return null;
+  const chatKey = String(chatId);
+  const displayName = [str(from.first_name), str(from.last_name)].filter(Boolean).join(" ").trim();
+  const threadId = dm ? void 0 : await threads.threadOfMessage(chatKey, messageId);
+  const event = {
+    type: "card_action",
+    messageId: `${chatKey}:${messageId}`,
+    eventId: id,
+    target: dm ? { chatId: chatKey, chatType: "dm" } : { chatId: chatKey, chatType: "group", ...threadId !== void 0 && { threadId } },
+    sender: {
+      externalId: String(userId),
+      tenantId: SENDER_TENANT,
+      ...displayName !== "" && { displayName }
+    },
+    action
+  };
+  return { event, callbackQueryId: id };
+}
+
+// src/api.ts
+var TelegramApiError = class extends Error {
+  name = "TelegramApiError";
+  method;
+  status;
+  errorCode;
+  description;
+  retryAfterSec;
+  migrateToChatId;
+  network;
+  constructor(method, init) {
+    super(`Telegram ${method} failed: ${detail(init)}`);
+    this.method = method;
+    this.network = init.network === true || init.timeout === true;
+    if (init.status !== void 0) this.status = init.status;
+    if (init.errorCode !== void 0) this.errorCode = init.errorCode;
+    if (init.description !== void 0) this.description = init.description;
+    if (init.retryAfterSec !== void 0) this.retryAfterSec = init.retryAfterSec;
+    if (init.migrateToChatId !== void 0) this.migrateToChatId = init.migrateToChatId;
+  }
+};
+function detail(init) {
+  if (init.timeout) return "timeout";
+  if (init.network) return "network error";
+  const code = init.errorCode !== void 0 ? String(init.errorCode) : init.status !== void 0 ? `HTTP ${init.status}` : "unknown error";
+  return init.description ? `${code} ${init.description}` : code;
+}
+var num = (v) => typeof v === "number" && Number.isFinite(v) ? v : void 0;
+function telegramApi(o) {
+  const base = o.apiUrl.replace(/\/+$/, "");
+  const timeoutMs = o.timeoutMs ?? 15e3;
+  return {
+    async call(method, params, signal) {
+      const timer = AbortSignal.timeout(timeoutMs);
+      let res;
+      let text;
+      try {
+        res = await fetch(`${base}/bot${o.token}/${method}`, {
+          method: "POST",
+          headers: { "content-type": "application/json" },
+          body: JSON.stringify(params ?? {}),
+          signal: signal ? AbortSignal.any([signal, timer]) : timer
+        });
+        text = await res.text();
+      } catch {
+        signal?.throwIfAborted();
+        throw new TelegramApiError(method, { network: true, timeout: timer.aborted });
+      }
+      let body;
+      try {
+        body = JSON.parse(text);
+      } catch {
+        body = void 0;
+      }
+      if (res.ok && body?.ok === true) return body.result;
+      const errorCode = num(body?.error_code);
+      const description = typeof body?.description === "string" ? body.description : void 0;
+      const retryAfterSec = num(body?.parameters?.retry_after);
+      const migrateToChatId = num(body?.parameters?.migrate_to_chat_id);
+      throw new TelegramApiError(method, {
+        status: res.status,
+        ...errorCode !== void 0 && { errorCode },
+        ...description !== void 0 && { description },
+        ...retryAfterSec !== void 0 && { retryAfterSec },
+        ...migrateToChatId !== void 0 && { migrateToChatId }
+      });
+    }
+  };
+}
+
+// src/cards.ts
+import {
+  questionRenderableInline,
+  renderCardAsText
+} from "@capybara-hq/plugin-sdk";
+
+// src/html.ts
+var TEXT_LIMIT = 4096;
+function escapeHtml(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+var escapeAttr = (s) => escapeHtml(s).replace(/"/g, "&quot;");
+var htmlLink = (url) => `<a href="${escapeAttr(url)}">${escapeHtml(url)}</a>`;
+var WORD_JOINER = "⁠";
+function neutraliseHtmlMentions(html) {
+  return html.replace(
+    /(<pre[\s\S]*?<\/pre>)|(<code>[\s\S]*?<\/code>)|(<a [^>]*>)|(https?:\/\/[^\s<]+)|(?<![A-Za-z0-9_])@(?=(?:<[^>]+>)*[A-Za-z0-9_])/g,
+    (m, pre, code, a, url) => pre || code || a ? m : url ? url.replace(/(?<![A-Za-z0-9_/])@(?=[A-Za-z0-9_])/g, `@${WORD_JOINER}`) : `@${WORD_JOINER}`
+  );
+}
+var HOLD = "\0";
+function balanced(s) {
+  const stack = [];
+  for (const m of s.matchAll(/<(\/?)([a-z-]+)[^>]*>/g)) {
+    if (m[1] === "") stack.push(m[2] ?? "");
+    else if (stack.pop() !== m[2]) return false;
+  }
+  return stack.length === 0;
+}
+function wrap(s, re, tag) {
+  return s.replace(re, (m, inner) => balanced(inner) ? `<${tag}>${inner}</${tag}>` : m);
+}
+function formatText(seg) {
+  let s = escapeHtml(seg);
+  s = s.replace(
+    /\*\*\*(?=\S)(.*?\S)\*\*\*/g,
+    (m, inner) => balanced(inner) ? `<b><i>${inner}</i></b>` : m
+  );
+  s = wrap(s, /~~(?=\S)(.*?\S)~~/g, "s");
+  s = wrap(s, /\*\*(?=\S)(.*?\S)\*\*/g, "b");
+  s = wrap(s, /(?<![\w])__(?=\S)(.*?\S)__(?!\w)/g, "b");
+  s = wrap(s, /(?<![\w*])\*(?=[^\s*])([^*]*?[^\s*])\*(?![\w*])/g, "i");
+  s = wrap(s, /(?<![\w_])_(?=[^\s_])([^_]*?[^\s_])_(?![\w_])/g, "i");
+  return s;
+}
+function formatSpan(seg) {
+  const held = [];
+  const hold = (v) => {
+    held.push(v);
+    return `${HOLD}${held.length - 1}${HOLD}`;
+  };
+  const link = (label, url) => hold(`<a href="${escapeAttr(url)}">${formatText(label)}</a>`);
+  const s = formatText(
+    seg.replace(
+      /(?<!!)\[([^\]\n]+)\]\((https?:\/\/(?:[^\s()]|\([^\s()]*\))+)\)/g,
+      (_m, l, u) => link(l, u)
+    ).replace(/<(https?:\/\/[^>\s]+)>/g, (_m, u) => link(u, u))
+  );
+  return s.replace(
+    new RegExp(`${HOLD}(\\d+)${HOLD}`, "g"),
+    (_m, i) => held[Number(i)] ?? ""
+  );
+}
+function inline(line) {
+  let out = "";
+  let last = 0;
+  for (const m of line.matchAll(/`([^`\n]+)`/g)) {
+    out += `${formatSpan(line.slice(last, m.index))}<code>${escapeHtml(m[1] ?? "")}</code>`;
+    last = m.index + m[0].length;
+  }
+  return out + formatSpan(line.slice(last));
+}
+function convertLine(line) {
+  const h = /^\s{0,3}#{1,6}\s+(.*?)\s*#*\s*$/.exec(line);
+  if (h) {
+    const body = (h[1] ?? "").replace(/\*\*|__/g, "");
+    return body === "" ? "" : `<b>${inline(body)}</b>`;
+  }
+  const li = /^(\s*)[-*+]\s+(.*)$/.exec(line);
+  if (li) return `${li[1]}• ${inline(li[2] ?? "")}`;
+  return inline(line);
+}
+function codeBlock(lang, lines) {
+  const body = escapeHtml(lines.join("\n"));
+  const l = lang.replace(/[^A-Za-z0-9_+#.-]/g, "");
+  return l === "" ? `<pre>${body}</pre>` : `<pre><code class="language-${l}">${body}</code></pre>`;
+}
+function markdownToTelegramHtml(md) {
+  const lines = md.replace(/\r\n?/g, "\n").replaceAll("\0", "").split("\n");
+  const out = [];
+  let fence;
+  let quote;
+  const closeQuote = () => {
+    if (quote) out.push(`<blockquote>${quote.join("\n")}</blockquote>`);
+    quote = void 0;
+  };
+  for (const line of lines) {
+    if (fence) {
+      if (/^\s*(```|~~~)\s*$/.test(line)) {
+        out.push(codeBlock(fence.lang, fence.lines));
+        fence = void 0;
+      } else fence.lines.push(line);
+      continue;
+    }
+    const open = /^\s*(?:```|~~~)\s*([^\s`]*)/.exec(line);
+    if (open) {
+      closeQuote();
+      fence = { lang: open[1] ?? "", lines: [] };
+      continue;
+    }
+    const q = /^\s{0,3}>\s?(.*)$/.exec(line);
+    if (q) {
+      quote ??= [];
+      quote.push(convertLine(q[1] ?? ""));
+      continue;
+    }
+    closeQuote();
+    out.push(convertLine(line));
+  }
+  if (fence) out.push(codeBlock(fence.lang, fence.lines));
+  closeQuote();
+  return neutraliseHtmlMentions(out.join("\n"));
+}
+function tokenise(html) {
+  const tokens = [];
+  const re = /<(\/?)([a-z-]+)[^>]*>|&(?:amp|lt|gt|quot);|[\s\S]/gu;
+  for (const m of html.matchAll(re)) {
+    if (m[2] !== void 0)
+      tokens.push({ kind: "tag", text: m[0], name: m[2], close: m[1] === "/" });
+    else
+      tokens.push({
+        kind: "text",
+        text: m[0],
+        len: m[0].startsWith("&") && m[0].length > 1 ? 1 : m[0].length
+      });
+  }
+  return tokens;
+}
+var openers = (stack) => stack.map((t) => t[0]).join("");
+var closers = (stack) => [...stack].reverse().map((t) => `</${t[1]}>`).join("");
+function visibleLength(html) {
+  let n = 0;
+  for (const t of tokenise(html)) if (t.kind === "text") n += t.len;
+  return n;
+}
+function truncateHtml(html, limit = TEXT_LIMIT) {
+  if (visibleLength(html) <= limit) return html;
+  const head = splitHtml(html, limit - 1)[0] ?? "";
+  const closing = /(?:<\/[a-z-]+>)*$/.exec(head)?.[0] ?? "";
+  return `${head.slice(0, head.length - closing.length)}…${closing}`;
+}
+function fitHtml(lead, body, limit = TEXT_LIMIT) {
+  const sep = "\n\n";
+  if (lead === "") return truncateHtml(body, limit);
+  if (body === "") return truncateHtml(lead, limit);
+  const room = limit - visibleLength(body) - sep.length;
+  if (room >= 2) return `${truncateHtml(lead, room)}${sep}${body}`;
+  return truncateHtml(body, limit);
+}
+function splitHtml(html, limit = TEXT_LIMIT) {
+  const tokens = tokenise(html);
+  const parts = [];
+  let cur = [];
+  let vis = 0;
+  let stack = [];
+  let prefix = "";
+  let cand;
+  const emit = (toks, count, at) => {
+    if (count > 0) parts.push(prefix + toks.map((t) => t.text).join("") + closers(at));
+  };
+  for (const t of tokens) {
+    if (t.kind === "tag") {
+      if (t.close) {
+        const at = stack.findLastIndex((s) => s[1] === t.name);
+        if (at >= 0) stack = stack.slice(0, at);
+      } else stack = [...stack, [t.text, t.name]];
+      cur.push(t);
+      continue;
+    }
+    if (vis + t.len > limit) {
+      if (cand && cand.vis >= limit / 2) {
+        emit(cur.slice(0, cand.i), cand.vis, cand.stack);
+        const rest = cur.slice(cand.i + 1);
+        prefix = openers(cand.stack);
+        vis = vis - cand.vis - 1;
+        cur = rest;
+      } else {
+        emit(cur, vis, stack);
+        prefix = openers(stack);
+        vis = 0;
+        cur = [];
+      }
+      cand = void 0;
+    }
+    if (/^\s$/.test(t.text)) cand = { i: cur.length, vis, stack: [...stack] };
+    cur.push(t);
+    vis += t.len;
+  }
+  emit(cur, vis, stack);
+  return parts.length > 0 ? parts : [""];
+}
+
+// src/cards.ts
+var T = {
+  zh: {
+    once: "批准一次",
+    session: "本会话批准",
+    always: "总是批准",
+    deny: "拒绝",
+    web: "在网页上查看",
+    connect: "连接",
+    bind: "绑定账号"
+  },
+  en: {
+    once: "Approve once",
+    session: "Approve for session",
+    always: "Always approve",
+    deny: "Deny",
+    web: "Open on web",
+    connect: "Connect",
+    bind: "Link account"
+  }
+};
+var LABEL_MAX = 60;
+var clip = (s) => {
+  const chars = [...s];
+  return chars.length > LABEL_MAX ? `${chars.slice(0, LABEL_MAX - 1).join("")}…` : s;
+};
+function isHttp(v) {
+  try {
+    const p = new URL(v).protocol;
+    return p === "https:" || p === "http:";
+  } catch {
+    return false;
+  }
+}
+var urlButton = (text, url) => isHttp(url) ? [{ text, url }] : [];
+function cardText(card, locale) {
+  const url = card.kind === "connect" || card.kind === "bind" ? card.url : card.webUrl;
+  const lines = renderCardAsText(card, locale).split("\n");
+  const last = lines[lines.length - 1];
+  if (lines.length > 1 && last?.endsWith(url)) {
+    lines.pop();
+    const label = markdownToTelegramHtml(last.slice(0, last.length - url.length));
+    return { body: markdownToTelegramHtml(lines.join("\n")), linkLine: `${label}${htmlLink(url)}` };
+  }
+  return { body: markdownToTelegramHtml(lines.join("\n")) };
+}
+async function callbackButton(b, text, action) {
+  try {
+    return [{ text: clip(text), callback_data: `${CALLBACK_PREFIX}${await b.tokens.put(action)}` }];
+  } catch {
+    b.log.warn("telegram: could not store a card button's action; the button is left out", {
+      cardKind: action.cardKind,
+      cardId: action.cardId
+    });
+    return [];
+  }
+}
+async function keyboard(card, locale, tokens) {
+  const t = T[locale];
+  switch (card.kind) {
+    case "approval": {
+      if (card.state !== "pending") return [urlButton(t.web, card.webUrl)];
+      const rows = [];
+      const decide = [];
+      for (const scope of card.scopes) {
+        decide.push(
+          ...await callbackButton(tokens, t[scope], {
+            cardKind: "approval",
+            cardId: card.id,
+            action: "approve",
+            scope
+          })
+        );
+      }
+      decide.push(
+        ...await callbackButton(tokens, t.deny, {
+          cardKind: "approval",
+          cardId: card.id,
+          action: "deny"
+        })
+      );
+      for (const b of decide) rows.push([b]);
+      rows.push(urlButton(t.web, card.webUrl));
+      return rows;
+    }
+    case "question": {
+      const f = card.form.fields[0];
+      const rows = [];
+      if (card.state === "pending" && f && !f.multiSelect && questionRenderableInline(card.form) && "enum" in f.schema) {
+        for (const option of f.schema.enum) {
+          rows.push(
+            await callbackButton(tokens, option, {
+              cardKind: "question",
+              cardId: card.id,
+              action: "answer",
+              answer: { [f.key]: option }
+            })
+          );
+        }
+      }
+      rows.push(urlButton(t.web, card.webUrl));
+      return rows;
+    }
+    case "connect":
+      return [urlButton(t.connect, card.url)];
+    case "bind":
+      return [urlButton(t.bind, card.url)];
+  }
+}
+var textOf = (t, locale) => typeof t === "string" ? t : t[locale];
+function cardHeadline(card, locale) {
+  switch (card.kind) {
+    case "approval":
+      return card.title;
+    case "question":
+      return textOf(card.form.title, locale);
+    case "bind":
+      return card.text;
+    case "connect":
+      return void 0;
+  }
+}
+var markup = (rows) => {
+  const kept = rows.filter((r) => r.length > 0);
+  return kept.length > 0 ? { replyMarkup: { inline_keyboard: kept } } : {};
+};
+async function renderCards(cards, locale, tokens, log) {
+  const posts = [];
+  for (const card of cards) {
+    const rows = await keyboard(card, locale, { tokens, log });
+    const { body, linkLine } = cardText(card, locale);
+    const hasUrlButton = rows.some((r) => r.some((b) => "url" in b));
+    posts.push({
+      html: body,
+      ...markup(rows),
+      ...hasUrlButton && linkLine !== void 0 && {
+        withoutUrlButtons: {
+          html: body === "" ? linkLine : `${body}
+${linkLine}`,
+          ...markup(rows.map((r) => r.filter((b) => !("url" in b))))
+        }
+      }
+    });
+  }
+  return posts;
+}
+
+// src/errors.ts
+import { ChannelSendError, isChannelSendError } from "@capybara-hq/plugin-sdk";
+function toChannelSendError(e) {
+  if (isChannelSendError(e)) return e;
+  if (!(e instanceof TelegramApiError)) {
+    return new ChannelSendError("Telegram API call failed", { retryable: true });
+  }
+  const opts = { cause: e };
+  const code = e.errorCode ?? e.status ?? 0;
+  if (e.network || code >= 500)
+    return new ChannelSendError(e.message, { retryable: true, ...opts });
+  if (code === 429) {
+    return new ChannelSendError(e.message, {
+      retryable: true,
+      ...e.retryAfterSec !== void 0 && { retryAfterMs: e.retryAfterSec * 1e3 },
+      ...opts
+    });
+  }
+  const reject = (reason) => new ChannelSendError(e.message, { retryable: false, reason, ...opts });
+  if (code === 401) return reject("auth");
+  if (code === 403) return reject("target_gone");
+  const text = (e.description ?? "").toLowerCase();
+  if (e.migrateToChatId !== void 0) return reject("target_gone");
+  if (code === 400 && text.includes("chat not found")) return reject("target_gone");
+  if (code === 400 && /too[ _]long/.test(text)) return reject("too_large");
+  return reject("rejected");
+}
+
+// src/inbound.ts
+var obj2 = (v) => typeof v === "object" && v !== null && !Array.isArray(v) ? v : void 0;
+var int2 = (v) => typeof v === "number" && Number.isSafeInteger(v) ? v : void 0;
+var str2 = (v) => typeof v === "string" ? v : void 0;
+async function fetchBotIdentity(api, signal) {
+  const me = await api.call(
+    "getMe",
+    void 0,
+    signal
+  );
+  const id = int2(me?.id);
+  if (id === void 0 || typeof me?.username !== "string" || me.username === "") {
+    throw new Error("Telegram getMe returned no bot user");
+  }
+  return { id, username: me.username };
+}
+function chatMigration(update) {
+  const message = obj2(obj2(update)?.message);
+  const migrateToChatId = int2(message?.migrate_to_chat_id);
+  if (migrateToChatId === void 0) return void 0;
+  return { chatId: int2(obj2(message?.chat)?.id), migrateToChatId };
+}
+function applyEdits(text, edits) {
+  let out = text;
+  for (const e of [...edits].sort((a, b) => b.start - a.start)) {
+    if (e.replacement !== void 0) {
+      out = out.slice(0, e.start) + e.replacement + out.slice(e.end);
+      continue;
+    }
+    let s = e.start;
+    let t = e.end;
+    while (s > 0 && (out[s - 1] === " " || out[s - 1] === "	")) s--;
+    while (t < out.length && (out[t] === " " || out[t] === "	")) t++;
+    const lineStart = s === 0 || out[s - 1] === "\n";
+    const lineEnd = t === out.length || out[t] === "\n";
+    out = out.slice(0, s) + (lineStart || lineEnd ? "" : " ") + out.slice(t);
+  }
+  return out.trim();
+}
+function readText(text, entities, bot) {
+  const handle = `@${bot.username}`.toLowerCase();
+  const edits = [];
+  let addressed = false;
+  for (const raw of Array.isArray(entities) ? entities : []) {
+    const e = obj2(raw);
+    const start = int2(e?.offset);
+    const length = int2(e?.length);
+    if (!e || start === void 0 || length === void 0 || length <= 0) continue;
+    const end = start + length;
+    if (end > text.length) continue;
+    const slice = text.slice(start, end);
+    if (e.type === "mention") {
+      if (slice.toLowerCase() === handle) {
+        addressed = true;
+        edits.push({ start, end, replacement: void 0 });
+      }
+    } else if (e.type === "text_mention") {
+      if (obj2(e.user)?.id === bot.id) {
+        addressed = true;
+        edits.push({ start, end, replacement: void 0 });
+      } else {
+        edits.push({ start, end, replacement: `@${slice}` });
+      }
+    } else if (e.type === "bot_command") {
+      const at = slice.lastIndexOf("@");
+      if (at > 0 && slice.slice(at).toLowerCase() === handle) {
+        addressed = true;
+        edits.push({ start: start + at, end, replacement: "" });
+      }
+    }
+  }
+  return { text: applyEdits(text, edits), addressed };
+}
+async function updateToInbound(update, bot, threads, tokens) {
+  if (tokens && obj2(obj2(update)?.callback_query)) {
+    return (await parseCallback(update, tokens, threads))?.event ?? null;
+  }
+  const message = obj2(obj2(update)?.message);
+  if (!message) return null;
+  const chat = obj2(message.chat);
+  const from = obj2(message.from);
+  const messageId = int2(message.message_id);
+  const chatId = int2(chat?.id);
+  const userId = int2(from?.id);
+  if (!chat || !from || !messageId || chatId === void 0 || userId === void 0) return null;
+  if (from.is_bot === true) return null;
+  const isText = typeof message.text === "string";
+  const rawText = str2(message.text) ?? str2(message.caption);
+  if (rawText === void 0) return null;
+  const { text, addressed } = readText(
+    rawText,
+    isText ? message.entities : message.caption_entities,
+    bot
+  );
+  if (text === "") return null;
+  const chatType = chat.type;
+  const dm = chatType === "private";
+  if (!dm && chatType !== "group" && chatType !== "supergroup") return null;
+  const chatKey = String(chatId);
+  const displayName = [str2(from.first_name), str2(from.last_name)].filter(Boolean).join(" ").trim();
+  const sender = {
+    externalId: String(userId),
+    tenantId: SENDER_TENANT,
+    ...displayName !== "" && { displayName }
+  };
+  const base = { type: "message", messageId: `${chatKey}:${messageId}`, sender, text };
+  if (dm) {
+    return {
+      ...base,
+      target: { chatId: chatKey, chatType: "dm" },
+      mentionsBot: true
+    };
+  }
+  const parent = obj2(message.reply_to_message);
+  const parentId = parent && !parent.forum_topic_created ? int2(parent.message_id) : void 0;
+  const replyToBot = parentId !== void 0 && obj2(parent?.from)?.id === bot.id;
+  if (!addressed && !replyToBot) return null;
+  const threadId = parentId !== void 0 ? await threads.threadOfMessage(chatKey, parentId) : void 0;
+  await threads.recordSent(chatKey, messageId, threadId ?? base.messageId);
+  const messageThreadId = int2(message.message_thread_id);
+  if (message.is_topic_message === true && messageThreadId !== void 0) {
+    await threads.recordTopic(threadId ?? base.messageId, messageThreadId);
+  }
+  const target = {
+    chatId: chatKey,
+    chatType: "group",
+    ...threadId !== void 0 && { threadId }
+  };
+  return { ...base, target, mentionsBot: true };
+}
+
+// src/wait.ts
+var pause = (ms, signal) => new Promise((resolve) => {
+  if (signal.aborted) return resolve();
+  const timer = AbortSignal.timeout(ms);
+  const done = () => {
+    signal.removeEventListener("abort", done);
+    timer.removeEventListener("abort", done);
+    resolve();
+  };
+  signal.addEventListener("abort", done, { once: true });
+  timer.addEventListener("abort", done, { once: true });
+});
+
+// src/poll.ts
+var OFFSET_TTL_SECONDS = 604800;
+var BACKOFF_CAP_MS = 3e4;
+var MAX_CONSECUTIVE_FAILURES = 5;
+var WEBHOOK_SET_ERROR = "A webhook is set for this Telegram bot; switch the connection to webhook mode or call deleteWebhook";
+var CONFLICT_ERROR = "Telegram getUpdates conflict: another client is polling this bot";
+var TOKEN_REJECTED_ERROR = "Telegram bot token rejected";
+var obj3 = (v) => typeof v === "object" && v !== null && !Array.isArray(v) ? v : void 0;
+var int3 = (v) => typeof v === "number" && Number.isSafeInteger(v) ? v : void 0;
+function backoffMs(base, attempt) {
+  const step = Math.min(BACKOFF_CAP_MS, base * 2 ** Math.min(attempt - 1, 20));
+  return Math.round(step * (0.5 + Math.random() * 0.5));
+}
+function refusal(e) {
+  if (!(e instanceof TelegramApiError)) return void 0;
+  const code = e.errorCode ?? e.status;
+  if (code === 401) return new Error(TOKEN_REJECTED_ERROR);
+  if (code === 409) {
+    return new Error(/webhook/i.test(e.description ?? "") ? WEBHOOK_SET_ERROR : CONFLICT_ERROR);
+  }
+  return void 0;
+}
+function transient(e) {
+  const code = e.errorCode ?? e.status;
+  return e.network || code === 429 || e.status !== void 0 && e.status >= 500;
+}
+var messageOf = (e) => e instanceof TelegramApiError ? e.message : "unexpected error while polling Telegram";
+async function runLongPolling(a) {
+  const { api, signal, log } = a;
+  const pollApi = a.pollApi ?? api;
+  const bot = await startup(a);
+  if (!bot) return;
+  const offsetKey = `offset/${bot.id}`;
+  let offset = await readOffset(a.kv, offsetKey, log);
+  let failures = 0;
+  let rejections = 0;
+  while (!signal.aborted) {
+    let updates;
+    try {
+      const result = await pollApi.call(
+        "getUpdates",
+        {
+          ...offset !== void 0 && { offset },
+          timeout: a.pollTimeoutSec,
+          allowed_updates: ["message", "callback_query"]
+        },
+        signal
+      );
+      updates = Array.isArray(result) ? result : [];
+      failures = 0;
+    } catch (e) {
+      if (signal.aborted) return;
+      const refused = refusal(e);
+      if (refused) throw refused;
+      if (!(e instanceof TelegramApiError) || !transient(e)) throw new Error(messageOf(e));
+      failures++;
+      if (failures >= MAX_CONSECUTIVE_FAILURES) throw new Error(e.message);
+      const wait = Math.max(backoffMs(a.backoffBaseMs, failures), (e.retryAfterSec ?? 0) * 1e3);
+      log.warn("telegram: getUpdates failed; retrying", {
+        connectionId: a.connectionId,
+        error: e.message,
+        attempt: failures,
+        waitMs: wait
+      });
+      await pause(wait, signal);
+      continue;
+    }
+    let usable = 0;
+    for (const update of updates) {
+      const updateId = int3(obj3(update)?.update_id);
+      if (updateId === void 0) continue;
+      usable++;
+      let delivered;
+      try {
+        delivered = await deliver(a, update, bot);
+      } catch (e) {
+        if (signal.aborted) return;
+        rejections++;
+        const wait = backoffMs(a.backoffBaseMs, rejections);
+        log.warn("telegram: an update was not accepted; fetching it again", {
+          connectionId: a.connectionId,
+          updateId,
+          error: e instanceof Error ? e.message : String(e),
+          waitMs: wait
+        });
+        await pause(wait, signal);
+        break;
+      }
+      if (delivered) rejections = 0;
+      offset = updateId + 1;
+      await writeOffset(a.kv, offsetKey, offset, log);
+      const callbackId = obj3(obj3(update)?.callback_query)?.id;
+      if (typeof callbackId === "string" && callbackId !== "") {
+        await answerCallback(a, callbackId);
+      }
+      if (signal.aborted) return;
+    }
+    if (updates.length > 0 && usable === 0) {
+      await pause(backoffMs(a.backoffBaseMs, 1), signal);
+    }
+  }
+}
+async function startup(a) {
+  try {
+    const bot = await fetchBotIdentity(a.api, a.signal);
+    const hook = await a.api.call(
+      "getWebhookInfo",
+      void 0,
+      a.signal
+    );
+    if (typeof hook?.url === "string" && hook.url !== "") throw new Error(WEBHOOK_SET_ERROR);
+    return bot;
+  } catch (e) {
+    if (a.signal.aborted) return void 0;
+    if (e instanceof TelegramApiError) throw refusal(e) ?? new Error(e.message);
+    throw e;
+  }
+}
+async function deliver(a, update, bot) {
+  const migration = chatMigration(update);
+  if (migration) {
+    a.log.info("telegram: a group became a supergroup; its old conversations stop", {
+      connectionId: a.connectionId,
+      ...migration
+    });
+    return false;
+  }
+  const event = await updateToInbound(update, bot, a.threads, a.tokens);
+  if (!event) return false;
+  await a.onEvent(event);
+  return true;
+}
+async function answerCallback(a, callbackQueryId) {
+  try {
+    await a.api.call("answerCallbackQuery", { callback_query_id: callbackQueryId }, a.signal);
+  } catch (e) {
+    if (a.signal.aborted) return;
+    a.log.warn("telegram: answerCallbackQuery failed", {
+      connectionId: a.connectionId,
+      error: messageOf(e)
+    });
+  }
+}
+async function readOffset(kv, key, log) {
+  if (!kv) return void 0;
+  try {
+    const raw = await kv.get(key);
+    const n = raw === null || raw === void 0 ? void 0 : Number(raw);
+    return n !== void 0 && Number.isSafeInteger(n) && n > 0 ? n : void 0;
+  } catch {
+    log.warn("telegram: could not read the stored getUpdates offset; starting without it");
+    return void 0;
+  }
+}
+async function writeOffset(kv, key, offset, log) {
+  if (!kv) return;
+  try {
+    await kv.set(key, String(offset), { ttlSeconds: OFFSET_TTL_SECONDS });
+  } catch {
+    log.warn("telegram: could not store the getUpdates offset", { offset });
+  }
+}
+
+// src/webhook.ts
+import { timingSafeEqual } from "node:crypto";
+var SECRET_HEADER = "x-telegram-bot-api-secret-token";
+var BOT_IDENTITY_TTL_SECONDS = 3600;
+var TELEGRAM_WEBHOOK_ACK = { status: 200 };
+var obj4 = (v) => typeof v === "object" && v !== null && !Array.isArray(v) ? v : void 0;
+function secretMatches(header, secret2) {
+  if (secret2 === void 0 || secret2 === "" || header === void 0) return false;
+  const got = Buffer.from(header, "utf8");
+  const want = Buffer.from(secret2, "utf8");
+  return got.length === want.length && timingSafeEqual(got, want);
+}
+async function handleTelegramWebhook(a) {
+  if (!secretMatches(a.request.headers[SECRET_HEADER], a.config.webhookSecret)) {
+    return { kind: "reject", status: 401 };
+  }
+  let update;
+  try {
+    update = JSON.parse(new TextDecoder().decode(a.request.body));
+  } catch {
+    return { kind: "reject", status: 400 };
+  }
+  const id = obj4(update)?.update_id;
+  if (typeof id !== "number" || !Number.isSafeInteger(id)) return { kind: "reject", status: 400 };
+  const event = await a.toEvent(update);
+  return { kind: "events", events: event ? [event] : [], ack: TELEGRAM_WEBHOOK_ACK };
+}
+async function webhookBotIdentity(api, kv, botId, signal) {
+  const key = `bot/${botId}`;
+  if (kv) {
+    try {
+      const raw = await kv.get(key);
+      const cached = obj4(raw ? JSON.parse(raw) : void 0);
+      if (typeof cached?.id === "number" && Number.isSafeInteger(cached.id) && typeof cached.username === "string" && cached.username !== "") {
+        return { id: cached.id, username: cached.username };
+      }
+    } catch {
+    }
+  }
+  const bot = await fetchBotIdentity(api, signal);
+  if (kv) {
+    try {
+      await kv.set(key, JSON.stringify(bot), { ttlSeconds: BOT_IDENTITY_TTL_SECONDS });
+    } catch {
+    }
+  }
+  return bot;
+}
+async function answerWebhookCallback(api, update, log, connectionId, signal) {
+  const id = obj4(obj4(update)?.callback_query)?.id;
+  if (typeof id !== "string" || id === "") return;
+  try {
+    await api.call("answerCallbackQuery", { callback_query_id: id }, signal);
+  } catch (e) {
+    if (signal.aborted) return;
+    log.warn("telegram: answerCallbackQuery failed", {
+      connectionId,
+      error: e instanceof TelegramApiError ? e.message : "unexpected error"
+    });
+  }
+}
+
+// src/channel.ts
+var MIN_EDIT_INTERVAL_MS = 3e3;
+function parseMessageId(id) {
+  const at = id.lastIndexOf(":");
+  const messageId = Number(id.slice(at + 1));
+  if (at <= 0 || !Number.isSafeInteger(messageId)) {
+    throw new ChannelSendError2("malformed Telegram message id", {
+      retryable: false,
+      reason: "rejected"
+    });
+  }
+  return { chatId: id.slice(0, at), messageId };
+}
+var tooLarge = () => new ChannelSendError2("message too long for a single Telegram message", {
+  retryable: false,
+  reason: "too_large"
+});
+var urlButtonRejected = (e) => e instanceof TelegramApiError && (e.errorCode ?? e.status) === 400 && /button URL|Wrong HTTP URL|BUTTON_URL_INVALID/i.test(e.description ?? "");
+function createTelegramChannel(o) {
+  const apiFor = (config, signal) => {
+    const c = TelegramConnection.parse(config);
+    const botId = botIdOf(c.botToken);
+    const api = telegramApi({
+      apiUrl: o.apiUrl,
+      token: c.botToken,
+      ...o.requestTimeoutMs !== void 0 && { timeoutMs: o.requestTimeoutMs }
+    });
+    return {
+      api,
+      botId,
+      call: (m, p) => api.call(m, p, signal)
+    };
+  };
+  async function render(message, locale, botId) {
+    const text = message.text.trim();
+    const cards = message.cards ?? [];
+    if (cards.length === 0) {
+      return text === "" ? [] : splitHtml(markdownToTelegramHtml(message.text)).map((html) => ({ html }));
+    }
+    const dup = cards.some((c) => cardHeadline(c, locale)?.trim() === text);
+    const lead = text === "" || dup ? "" : markdownToTelegramHtml(message.text);
+    const fit = (p, leading) => ({
+      ...p,
+      html: fitHtml(leading, p.html),
+      ...p.withoutUrlButtons && { withoutUrlButtons: fit(p.withoutUrlButtons, leading) }
+    });
+    const posts = await renderCards(cards, locale, cardTokenStore(o.kv, botId), o.log);
+    return posts.map((p, i) => fit(p, i === 0 ? lead : ""));
+  }
+  async function withUrlButtonFallback(post, attempt) {
+    try {
+      return await attempt(post);
+    } catch (e) {
+      if (!post.withoutUrlButtons || !urlButtonRejected(e)) throw e;
+      o.log.warn("telegram: Telegram rejected a card's URL button; the link is sent as text");
+      return attempt(post.withoutUrlButtons);
+    }
+  }
+  async function sendOne(api, target, post, extra) {
+    let r;
+    try {
+      r = await withUrlButtonFallback(
+        post,
+        (p) => api.call("sendMessage", {
+          chat_id: target.chatId,
+          text: p.html,
+          parse_mode: "HTML",
+          link_preview_options: { is_disabled: true },
+          ...p.replyMarkup && { reply_markup: p.replyMarkup },
+          ...extra
+        })
+      );
+    } catch (e) {
+      throw toChannelSendError(e);
+    }
+    if (typeof r?.message_id !== "number") {
+      throw new ChannelSendError2("Telegram returned no message id", {
+        retryable: false,
+        reason: "rejected"
+      });
+    }
+    return r.message_id;
+  }
+  return {
+    connectionSchema: TelegramConnection,
+    features: { cards: true, edit: true, threads: true, minEditIntervalMs: MIN_EDIT_INTERVAL_MS },
+    async verify({ config, signal }) {
+      const { call } = apiFor(config, signal);
+      const me = await call("getMe");
+      if (typeof me?.id !== "number" || !me.username) {
+        throw new Error("Telegram getMe returned no bot user");
+      }
+      if (me.can_read_all_group_messages) {
+        o.log.warn(
+          "telegram: the bot can read all group messages (privacy mode is off); only mentions and replies to the bot are forwarded",
+          { botId: me.id }
+        );
+      }
+      if (me.has_topics_enabled) {
+        o.log.warn(
+          "telegram: topic mode in private chats is not supported; turn it off in BotFather",
+          { botId: me.id }
+        );
+      }
+      return {
+        botUserId: String(me.id),
+        botName: `@${me.username}`,
+        tenantId: connectionTenant(me.id)
+      };
+    },
+    async connect({ connectionId, config, onEvent, signal }) {
+      const c = TelegramConnection.parse(config);
+      const botId = botIdOf(c.botToken);
+      const pollTimeoutSec = o.pollTimeoutSec ?? 25;
+      const api = telegramApi({
+        apiUrl: o.apiUrl,
+        token: c.botToken,
+        ...o.requestTimeoutMs !== void 0 && { timeoutMs: o.requestTimeoutMs }
+      });
+      const pollApi = telegramApi({
+        apiUrl: o.apiUrl,
+        token: c.botToken,
+        timeoutMs: pollTimeoutSec * 1e3 + 1e4
+      });
+      await runLongPolling({
+        api,
+        pollApi,
+        connectionId,
+        onEvent,
+        signal,
+        log: o.log,
+        kv: o.kv,
+        threads: threadStore(o.kv, botId),
+        tokens: cardTokenStore(o.kv, botId),
+        pollTimeoutSec,
+        backoffBaseMs: o.backoffBaseMs ?? 1e3
+      });
+    },
+    webhook: {
+      // The kernel validated `config`; parsing again only narrows its type. Nothing reaches
+      // Telegram (getMe, answerCallbackQuery) before the secret check passed.
+      async handle({ connectionId, config, request, signal }) {
+        const c = TelegramConnection.parse(config);
+        const botId = botIdOf(c.botToken);
+        const api = telegramApi({
+          apiUrl: o.apiUrl,
+          token: c.botToken,
+          ...o.requestTimeoutMs !== void 0 && { timeoutMs: o.requestTimeoutMs }
+        });
+        return handleTelegramWebhook({
+          config: c,
+          request,
+          toEvent: async (update) => {
+            const migration = chatMigration(update);
+            if (migration) {
+              o.log.info("telegram: a group became a supergroup; its old conversations stop", {
+                connectionId,
+                ...migration
+              });
+              return null;
+            }
+            const bot = await webhookBotIdentity(api, o.kv, botId, signal);
+            const event = await updateToInbound(
+              update,
+              bot,
+              threadStore(o.kv, botId),
+              cardTokenStore(o.kv, botId)
+            );
+            await answerWebhookCallback(api, update, o.log, connectionId, signal);
+            return event;
+          }
+        });
+      }
+    },
+    async send({ config, target, message, locale, signal }) {
+      const { call, botId } = apiFor(config, signal);
+      const posts = await render(message, locale, botId);
+      if (posts.length === 0) throw new ChannelSendError2("nothing to send", { retryable: false });
+      const store = threadStore(o.kv, botId);
+      const inThread = target.chatType === "group" && target.threadId !== void 0;
+      const extra = {};
+      if (inThread && target.threadId !== void 0) {
+        extra.reply_parameters = {
+          message_id: parseMessageId(target.threadId).messageId,
+          allow_sending_without_reply: true
+        };
+        const topic = await store.topicOf(target.threadId);
+        if (topic !== void 0) extra.message_thread_id = topic;
+      }
+      let last = 0;
+      for (const post of posts) {
+        last = await sendOne({ call }, target, post, extra);
+        if (inThread && target.threadId !== void 0) {
+          try {
+            await store.recordSent(target.chatId, last, target.threadId);
+          } catch {
+            o.log.warn("telegram: could not record a sent message's thread", {
+              chatId: target.chatId,
+              messageId: last
+            });
+          }
+        }
+      }
+      return { messageId: `${target.chatId}:${last}` };
+    },
+    async update({ config, messageId, message, locale, signal }) {
+      const { call, botId } = apiFor(config, signal);
+      const { chatId, messageId: id } = parseMessageId(messageId);
+      const posts = await render(message, locale, botId);
+      if (posts.length > 1) throw tooLarge();
+      const post = posts[0];
+      if (!post) throw new ChannelSendError2("nothing to send", { retryable: false });
+      try {
+        await withUrlButtonFallback(
+          post,
+          (p) => call("editMessageText", {
+            chat_id: chatId,
+            message_id: id,
+            text: p.html,
+            parse_mode: "HTML",
+            link_preview_options: { is_disabled: true },
+            ...p.replyMarkup && { reply_markup: p.replyMarkup }
+          })
+        );
+      } catch (e) {
+        if (e instanceof TelegramApiError && /message is not modified/i.test(e.description ?? "")) {
+          return;
+        }
+        throw toChannelSendError(e);
+      }
+    }
+  };
+}
+
+// src/index.ts
+var index_default = defineExtension({
+  name: "telegram",
+  version: "0.1.0-rc.1",
+  sdk: "^0.1.0-rc.4",
+  provides: [CHANNEL_EXTENSION_POINT],
+  permissions: { network: ["api.telegram.org"] },
+  config: { deployment: TelegramDeployment },
+  setup(ctx) {
+    const { apiUrl } = TelegramDeployment.parse(ctx.config ?? {});
+    ctx.provide(
+      CHANNEL_EXTENSION_POINT,
+      createTelegramChannel({ apiUrl, log: ctx.log, kv: ctx.kv })
+    );
+  }
+});
+export {
+  TelegramConnection,
+  TelegramDeployment,
+  createTelegramChannel,
+  index_default as default
+};