spectrum-ts 1.17.1 → 2.0.0

package/dist/chunk-5LT5J3NR.js

@@ -0,0 +1,695 @@
+import { createRequire as __spectrumCreateRequire } from "node:module"; const require = __spectrumCreateRequire(import.meta.url);
+import {
+  fusor
+} from "./chunk-34FQGGD7.js";
+import {
+  asGroup
+} from "./chunk-3B4QH4JG.js";
+import {
+  asVoice
+} from "./chunk-NNY6LMSC.js";
+import {
+  toVCard
+} from "./chunk-6UZFVXQF.js";
+import {
+  UnsupportedError,
+  definePlatform
+} from "./chunk-NGC4DJIX.js";
+import {
+  asAttachment,
+  asCustom,
+  asReaction,
+  asText
+} from "./chunk-2ILTJC35.js";
+
+// src/providers/telegram/config.ts
+import z from "zod";
+var TELEGRAM_PLATFORM = "telegram";
+var DEFAULT_BASE_URL = "https://api.telegram.org";
+var SECRET_TOKEN_PATTERN = /^[A-Za-z0-9_-]{1,256}$/;
+var BOT_TOKEN_PATTERN = /^\d+:[A-Za-z0-9_-]+$/;
+var configSchema = z.object({
+  /** Bot token from @BotFather (outbound API calls + media downloads). */
+  botToken: z.string().regex(BOT_TOKEN_PATTERN, "botToken must be in the form '<id>:<token>'"),
+  /**
+   * The `secret_token` passed to `setWebhook`. When present, inbound webhooks
+   * are verified against the `X-Telegram-Bot-Api-Secret-Token` header; when
+   * omitted, the check is skipped. Telegram does not HMAC-sign the body, so
+   * this shared token is the only inbound authentication.
+   */
+  webhookSecret: z.string().regex(SECRET_TOKEN_PATTERN).optional(),
+  /** Override the Bot API base URL. Defaults to `https://api.telegram.org`. */
+  baseUrl: z.url().default(DEFAULT_BASE_URL)
+});
+var botIdFromToken = (botToken) => botToken.split(":")[0] ?? "";
+
+// src/providers/telegram/client.ts
+import { createTelegramClient, getFile } from "@photon-ai/telegram-ts";
+var REQUEST_TIMEOUT_MS = 3e4;
+var TRAILING_SLASHES = /\/+$/;
+var telegramClient = (config) => createTelegramClient({ token: config.botToken, baseUrl: config.baseUrl });
+var appendFormValue = (form, key, value) => {
+  if (typeof value === "string" || value instanceof Blob) {
+    form.append(key, value);
+  } else if (value instanceof Date) {
+    form.append(key, value.toISOString());
+  } else {
+    form.append(key, JSON.stringify(value));
+  }
+};
+var toFormData = (body) => {
+  const form = new FormData();
+  for (const [key, value] of Object.entries(body)) {
+    if (value === void 0 || value === null) {
+      continue;
+    }
+    appendFormValue(form, key, value);
+  }
+  return form;
+};
+var executeSpec = async (client, spec) => {
+  const url = `/${spec.method}`;
+  if (spec.file) {
+    const file = new File(
+      [new Uint8Array(spec.file.bytes)],
+      spec.file.filename,
+      { type: spec.file.mimeType }
+    );
+    const res2 = await client.post({
+      body: { ...spec.params, [spec.file.field]: file },
+      bodySerializer: toFormData,
+      headers: { "Content-Type": null },
+      throwOnError: true,
+      url
+    });
+    return res2.data.result;
+  }
+  const res = await client.post({ body: spec.params, throwOnError: true, url });
+  return res.data.result;
+};
+var downloadFile = async (config, fileId) => {
+  const client = telegramClient(config);
+  const meta = await getFile({
+    body: { file_id: fileId },
+    client,
+    throwOnError: true
+  });
+  const filePath = meta.result?.file_path;
+  if (!filePath) {
+    throw new Error(`Telegram getFile returned no file_path for ${fileId}`);
+  }
+  const base = config.baseUrl.replace(TRAILING_SLASHES, "");
+  const res = await fetch(`${base}/file/bot${config.botToken}/${filePath}`, {
+    signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
+  });
+  if (!res.ok) {
+    throw new Error(
+      `Telegram media download failed: ${res.status} ${res.statusText}`
+    );
+  }
+  return Buffer.from(await res.arrayBuffer());
+};
+
+// src/providers/telegram/inbound/media.ts
+var DEFAULT_VIDEO_MIME = "video/mp4";
+var DEFAULT_AUDIO_MIME = "audio/mpeg";
+var DEFAULT_VOICE_MIME = "audio/ogg";
+var DEFAULT_DOC_MIME = "application/octet-stream";
+var pixelArea = (photo) => photo.file_size ?? photo.width * photo.height;
+var pickLargestPhoto = (photos) => photos.reduce(
+  (best, next) => pixelArea(next) > pixelArea(best) ? next : best
+);
+var lazyRead = (config, fileId) => () => downloadFile(config, fileId);
+var fileAttachment = (config, file, fallbackExt, fallbackMime) => asAttachment({
+  id: file.file_id,
+  name: file.file_name ?? `${file.file_unique_id}.${fallbackExt}`,
+  mimeType: file.mime_type ?? fallbackMime,
+  size: file.file_size,
+  read: lazyRead(config, file.file_id)
+});
+var stickerAttachment = (config, sticker) => {
+  let ext = "webp";
+  let mimeType = "image/webp";
+  if (sticker.is_animated) {
+    ext = "tgs";
+    mimeType = "application/x-tgsticker";
+  } else if (sticker.is_video) {
+    ext = "webm";
+    mimeType = "video/webm";
+  }
+  return asAttachment({
+    id: sticker.file_id,
+    name: `${sticker.file_unique_id}.${ext}`,
+    mimeType,
+    size: sticker.file_size,
+    read: lazyRead(config, sticker.file_id)
+  });
+};
+var mediaToContent = (msg, config) => {
+  if (msg.voice) {
+    return asVoice({
+      mimeType: msg.voice.mime_type ?? DEFAULT_VOICE_MIME,
+      duration: msg.voice.duration,
+      size: msg.voice.file_size,
+      read: lazyRead(config, msg.voice.file_id)
+    });
+  }
+  if (msg.video_note) {
+    return fileAttachment(config, msg.video_note, "mp4", DEFAULT_VIDEO_MIME);
+  }
+  if (msg.animation) {
+    return fileAttachment(config, msg.animation, "mp4", DEFAULT_VIDEO_MIME);
+  }
+  if (msg.video) {
+    return fileAttachment(config, msg.video, "mp4", DEFAULT_VIDEO_MIME);
+  }
+  if (msg.audio) {
+    return fileAttachment(config, msg.audio, "mp3", DEFAULT_AUDIO_MIME);
+  }
+  if (msg.document) {
+    return fileAttachment(config, msg.document, "bin", DEFAULT_DOC_MIME);
+  }
+  if (msg.photo && msg.photo.length > 0) {
+    return fileAttachment(
+      config,
+      pickLargestPhoto(msg.photo),
+      "jpg",
+      "image/jpeg"
+    );
+  }
+  if (msg.sticker) {
+    return stickerAttachment(config, msg.sticker);
+  }
+  return;
+};
+var messageToContent = (msg, config) => {
+  const media = mediaToContent(msg, config);
+  if (media) {
+    const caption = msg.caption?.trim();
+    return caption ? [asText(caption), media] : [media];
+  }
+  const text = msg.text;
+  if (text !== void 0 && text.length > 0) {
+    return [asText(text)];
+  }
+  return [];
+};
+
+// src/providers/telegram/inbound/messages.ts
+var MILLIS_PER_SECOND = 1e3;
+var stubMessage = (id, content) => ({ id, content });
+var senderRef = (user) => ({
+  id: String(user.id),
+  ...user.username ? { handle: user.username } : {},
+  isMe: false
+});
+var toRecordContent = (contents, messageId) => {
+  if (contents.length === 0) {
+    return;
+  }
+  if (contents.length === 1) {
+    return contents[0];
+  }
+  return asGroup({
+    items: contents.map(
+      (content, index) => stubMessage(`${messageId}:${index}`, content)
+    )
+  });
+};
+var fromMessage = (msg, config) => {
+  if (msg.from && String(msg.from.id) === botIdFromToken(config.botToken)) {
+    return;
+  }
+  const content = toRecordContent(
+    messageToContent(msg, config),
+    String(msg.message_id)
+  );
+  if (!content) {
+    return;
+  }
+  return {
+    id: String(msg.message_id),
+    content,
+    ...msg.from ? { sender: senderRef(msg.from) } : {},
+    space: { id: String(msg.chat.id) },
+    timestamp: new Date(msg.date * MILLIS_PER_SECOND)
+  };
+};
+var emojiReactions = (reactions) => reactions.filter((r) => r.type === "emoji").map((r) => r.emoji);
+var fromReaction = (reaction) => {
+  const added = emojiReactions(reaction.new_reaction);
+  if (added.length === 0) {
+    return;
+  }
+  const previous = new Set(emojiReactions(reaction.old_reaction));
+  const emoji = added.find((e) => !previous.has(e)) ?? added[0];
+  if (!emoji) {
+    return;
+  }
+  const target = stubMessage(
+    String(reaction.message_id),
+    asCustom({ telegram: "reaction-target" })
+  );
+  const actorId = reaction.user ? String(reaction.user.id) : "anonymous";
+  return {
+    id: `reaction:${reaction.chat.id}:${reaction.message_id}:${reaction.date}:${actorId}:${emoji}`,
+    content: asReaction({ emoji, target }),
+    ...reaction.user ? { sender: senderRef(reaction.user) } : {},
+    space: { id: String(reaction.chat.id) },
+    timestamp: new Date(reaction.date * MILLIS_PER_SECOND)
+  };
+};
+var handleMessages = ({
+  payload: update,
+  config
+}) => {
+  const message = update.message ?? update.channel_post;
+  if (message) {
+    return fromMessage(message, config);
+  }
+  if (update.message_reaction) {
+    return fromReaction(update.message_reaction);
+  }
+  return;
+};
+
+// src/providers/telegram/outbound/send.ts
+import {
+  editMessageText,
+  sendChatAction,
+  setMessageReaction
+} from "@photon-ai/telegram-ts";
+
+// src/providers/telegram/reactions.ts
+var ALLOWED_REACTION_EMOJI = /* @__PURE__ */ new Set([
+  "\u{1F44D}",
+  "\u{1F44E}",
+  "\u2764",
+  "\u{1F525}",
+  "\u{1F970}",
+  "\u{1F44F}",
+  "\u{1F601}",
+  "\u{1F914}",
+  "\u{1F92F}",
+  "\u{1F631}",
+  "\u{1F92C}",
+  "\u{1F622}",
+  "\u{1F389}",
+  "\u{1F929}",
+  "\u{1F92E}",
+  "\u{1F4A9}",
+  "\u{1F64F}",
+  "\u{1F44C}",
+  "\u{1F54A}",
+  "\u{1F921}",
+  "\u{1F971}",
+  "\u{1F974}",
+  "\u{1F60D}",
+  "\u{1F433}",
+  "\u2764\u200D\u{1F525}",
+  "\u{1F31A}",
+  "\u{1F32D}",
+  "\u{1F4AF}",
+  "\u{1F923}",
+  "\u26A1",
+  "\u{1F34C}",
+  "\u{1F3C6}",
+  "\u{1F494}",
+  "\u{1F928}",
+  "\u{1F610}",
+  "\u{1F353}",
+  "\u{1F37E}",
+  "\u{1F48B}",
+  "\u{1F595}",
+  "\u{1F608}",
+  "\u{1F634}",
+  "\u{1F62D}",
+  "\u{1F913}",
+  "\u{1F47B}",
+  "\u{1F468}\u200D\u{1F4BB}",
+  "\u{1F440}",
+  "\u{1F383}",
+  "\u{1F648}",
+  "\u{1F607}",
+  "\u{1F628}",
+  "\u{1F91D}",
+  "\u270D",
+  "\u{1F917}",
+  "\u{1FAE1}",
+  "\u{1F385}",
+  "\u{1F384}",
+  "\u2603",
+  "\u{1F485}",
+  "\u{1F92A}",
+  "\u{1F5FF}",
+  "\u{1F192}",
+  "\u{1F498}",
+  "\u{1F649}",
+  "\u{1F984}",
+  "\u{1F618}",
+  "\u{1F48A}",
+  "\u{1F64A}",
+  "\u{1F60E}",
+  "\u{1F47E}",
+  "\u{1F937}\u200D\u2642",
+  "\u{1F937}",
+  "\u{1F937}\u200D\u2640",
+  "\u{1F621}"
+]);
+var VARIATION_SELECTOR_16 = /️/g;
+var stripVariationSelector = (emoji) => emoji.replace(VARIATION_SELECTOR_16, "");
+var isAllowedReactionEmoji = (emoji) => ALLOWED_REACTION_EMOJI.has(stripVariationSelector(emoji));
+var normalizeReactionEmoji = (emoji) => isAllowedReactionEmoji(emoji) ? stripVariationSelector(emoji) : emoji;
+
+// src/providers/telegram/outbound/message.ts
+var VCARD_FILENAME = "contact.vcf";
+var VCARD_MIME = "text/vcard";
+var DEFAULT_VOICE_FILENAME = "voice.ogg";
+var parseMessageId = (id) => {
+  const messageId = Number(id);
+  if (!Number.isInteger(messageId) || messageId <= 0) {
+    throw new Error(
+      `Telegram message id must be a positive integer (got "${id}").`
+    );
+  }
+  return messageId;
+};
+var customToSpec = (raw) => {
+  if (typeof raw === "object" && raw !== null && typeof raw.method === "string") {
+    const value = raw;
+    const { params } = value;
+    if (params !== void 0 && (typeof params !== "object" || params === null || Array.isArray(params))) {
+      throw new Error(
+        "Telegram custom content `raw.params` must be an object when provided."
+      );
+    }
+    return {
+      method: value.method,
+      params: params ?? {}
+    };
+  }
+  throw new Error(
+    "Telegram custom content `raw` must be a `{ method, params }` Bot API call."
+  );
+};
+var attachmentSpec = async (content) => {
+  const bytes = await content.read();
+  const file = {
+    field: "document",
+    filename: content.name,
+    mimeType: content.mimeType,
+    bytes
+  };
+  if (content.mimeType.startsWith("image/")) {
+    return {
+      method: "sendPhoto",
+      params: {},
+      file: { ...file, field: "photo" }
+    };
+  }
+  if (content.mimeType.startsWith("video/")) {
+    return {
+      method: "sendVideo",
+      params: {},
+      file: { ...file, field: "video" }
+    };
+  }
+  return { method: "sendDocument", params: {}, file };
+};
+var buildSend = async (content) => {
+  switch (content.type) {
+    case "text":
+      return { method: "sendMessage", params: { text: content.text } };
+    case "richlink":
+      return { method: "sendMessage", params: { text: content.url } };
+    case "attachment":
+      return await attachmentSpec(content);
+    case "voice": {
+      const bytes = await content.read();
+      return {
+        method: "sendVoice",
+        params: content.duration === void 0 ? {} : { duration: content.duration },
+        file: {
+          field: "voice",
+          filename: content.name ?? DEFAULT_VOICE_FILENAME,
+          mimeType: content.mimeType,
+          bytes
+        }
+      };
+    }
+    case "contact": {
+      const vcf = await toVCard(content);
+      return {
+        method: "sendDocument",
+        params: {},
+        file: {
+          field: "document",
+          filename: VCARD_FILENAME,
+          mimeType: VCARD_MIME,
+          bytes: Buffer.from(vcf, "utf8")
+        }
+      };
+    }
+    case "reply": {
+      const inner = await buildSend(content.content);
+      return {
+        ...inner,
+        params: {
+          ...inner.params,
+          reply_parameters: { message_id: parseMessageId(content.target.id) }
+        }
+      };
+    }
+    case "custom":
+      return customToSpec(content.raw);
+    default:
+      throw UnsupportedError.content(content.type, TELEGRAM_PLATFORM);
+  }
+};
+
+// src/providers/telegram/outbound/send.ts
+var MILLIS_PER_SECOND2 = 1e3;
+var sendContent = async (client, space, content) => {
+  const spec = await buildSend(content);
+  const sent = await executeSpec(client, {
+    ...spec,
+    params: { chat_id: space.id, ...spec.params }
+  });
+  return {
+    id: String(sent.message_id),
+    content,
+    space: { id: space.id },
+    timestamp: new Date(sent.date * MILLIS_PER_SECOND2)
+  };
+};
+var sendGroup = async (client, space, items) => {
+  let last;
+  for (const item of items) {
+    last = await sendContent(client, space, item.content);
+  }
+  return last;
+};
+var sendReaction = async (client, space, content) => {
+  const messageId = parseMessageId(content.target.id);
+  const emoji = normalizeReactionEmoji(content.emoji);
+  if (!isAllowedReactionEmoji(emoji)) {
+    throw UnsupportedError.content(
+      "reaction",
+      TELEGRAM_PLATFORM,
+      `"${content.emoji}" is not an allowed Telegram reaction emoji.`
+    );
+  }
+  await setMessageReaction({
+    body: {
+      chat_id: space.id,
+      message_id: messageId,
+      // `emoji` is runtime-validated above; cast to photon's allowed-emoji union.
+      reaction: [{ emoji, type: "emoji" }]
+    },
+    client
+  });
+  return;
+};
+var sendTyping = async (client, space, state) => {
+  if (state === "start") {
+    await sendChatAction({
+      body: { action: "typing", chat_id: space.id },
+      client
+    });
+  }
+  return;
+};
+var sendEdit = async (client, space, content) => {
+  if (content.content.type !== "text") {
+    throw UnsupportedError.content(
+      "edit",
+      TELEGRAM_PLATFORM,
+      `only text content can be edited (got "${content.content.type}").`
+    );
+  }
+  await editMessageText({
+    body: {
+      chat_id: space.id,
+      message_id: parseMessageId(content.target.id),
+      text: content.content.text
+    },
+    client
+  });
+  return;
+};
+var send = async ({
+  space,
+  content,
+  config
+}) => {
+  const client = telegramClient(config);
+  switch (content.type) {
+    case "reaction":
+      return await sendReaction(client, space, content);
+    case "typing":
+      return await sendTyping(client, space, content.state);
+    case "edit":
+      return await sendEdit(client, space, content);
+    case "group":
+      return await sendGroup(client, space, content.items);
+    case "poll":
+    case "poll_option":
+    case "effect":
+    case "rename":
+    case "avatar":
+      throw UnsupportedError.content(content.type, TELEGRAM_PLATFORM);
+    default:
+      return await sendContent(client, space, content);
+  }
+};
+
+// src/providers/telegram/space.ts
+import z2 from "zod";
+var spaceParamsSchema = z2.object({
+  /**
+   * Target a chat directly by id. Telegram chat ids are numbers in the wire
+   * format (negative for groups/supergroups); accept either form and store as
+   * a string. For a private chat the id equals the user's id.
+   */
+  chatId: z2.union([z2.string().min(1), z2.number()]).optional()
+});
+var resolveUser = ({
+  input
+}) => Promise.resolve({ id: input.userID });
+var resolveSpace = ({
+  input
+}) => {
+  const chatId = input.params?.chatId;
+  if (chatId !== void 0) {
+    return Promise.resolve({ id: String(chatId) });
+  }
+  const [first, ...rest] = input.users;
+  if (first && rest.length === 0) {
+    return Promise.resolve({ id: first.id });
+  }
+  if (!first) {
+    throw new Error(
+      "Telegram space creation requires params.chatId or a single recipient user."
+    );
+  }
+  throw new Error(
+    "Telegram bots cannot create group chats \u2014 pass params.chatId for an existing chat, or resolve a single user (their private chat)."
+  );
+};
+
+// src/providers/telegram/verify.ts
+import { timingSafeEqual } from "crypto";
+var SECRET_TOKEN_HEADER = "x-telegram-bot-api-secret-token";
+var safeEqual = (a, b) => {
+  const left = Buffer.from(a, "utf8");
+  const right = Buffer.from(b, "utf8");
+  if (left.length === 0 || left.length !== right.length) {
+    return false;
+  }
+  return timingSafeEqual(left, right);
+};
+var verifySecret = (headers, secret) => {
+  const provided = headers[SECRET_TOKEN_HEADER];
+  if (!provided) {
+    throw new Error("Telegram webhook is missing the secret token header");
+  }
+  if (!safeEqual(provided, secret)) {
+    throw new Error("Telegram webhook secret token mismatch");
+  }
+};
+var isUpdate = (value) => typeof value === "object" && value !== null && "update_id" in value && typeof value.update_id === "number";
+var parseUpdate = (bodyText) => {
+  let json;
+  try {
+    json = JSON.parse(bodyText);
+  } catch {
+    throw new Error("Telegram webhook body is not valid JSON");
+  }
+  if (!isUpdate(json)) {
+    throw new Error("Telegram webhook payload is missing a numeric update_id");
+  }
+  return json;
+};
+var verify = (config) => (req) => {
+  if (config.webhookSecret) {
+    verifySecret(req.headers, config.webhookSecret);
+  }
+  return parseUpdate(new TextDecoder().decode(req.rawBody));
+};
+
+// src/providers/telegram/webhook.ts
+import { getWebhookInfo, setWebhook } from "@photon-ai/telegram-ts";
+var DEFAULT_SUPER_WEBHOOK_DOMAIN = "spctrm.dev";
+var webhookUrl = (slug) => {
+  const domain = process.env.SPECTRUM_SUPER_WEBHOOK ?? DEFAULT_SUPER_WEBHOOK_DOMAIN;
+  return `https://${slug}.${domain}/${TELEGRAM_PLATFORM}`;
+};
+var ensureWebhook = async (config, slug) => {
+  const client = telegramClient(config);
+  const url = webhookUrl(slug);
+  try {
+    const info = await getWebhookInfo({ client, throwOnError: true });
+    if (info.result?.url === url) {
+      return;
+    }
+    await setWebhook({
+      body: {
+        url,
+        ...config.webhookSecret ? { secret_token: config.webhookSecret } : {}
+      },
+      client,
+      throwOnError: true
+    });
+  } catch (error) {
+    throw new Error(`Telegram webhook registration failed for ${url}`, {
+      cause: error
+    });
+  }
+};
+
+// src/providers/telegram/index.ts
+var telegram = definePlatform(TELEGRAM_PLATFORM, {
+  config: configSchema,
+  lifecycle: {
+    // Annotate the return so overload selection sees the `FusorClient` brand
+    // without deferring this (context-sensitive) arrow — picks the fusor overload.
+    createClient: async ({
+      config,
+      projectConfig
+    }) => {
+      const slug = projectConfig?.slug;
+      if (slug) {
+        await ensureWebhook(config, slug);
+      }
+      return fusor(TELEGRAM_PLATFORM, verify(config));
+    }
+  },
+  user: { resolve: resolveUser },
+  space: { params: spaceParamsSchema, resolve: resolveSpace },
+  messages: handleMessages,
+  send
+});
+
+export {
+  telegram
+};