@dual-os/telegram 0.0.0-stage → 8.0.5

package/index-hpjyc5yq.js

@@ -0,0 +1,847 @@
+// @bun
+import {
+  __exportAll
+} from "./index-68np0qzt.js";
+import {
+  TelegramClient2,
+  layer2
+} from "./index-xc47zv2c.js";
+import {
+  toLowerCase,
+  slice,
+  isEmpty,
+  split,
+  startsWith,
+  endsWith,
+  RequestInit,
+  layer4,
+  Action_exports,
+  AgentChannel_exports,
+  Plugin_exports
+} from "./index-ppnnem2q.js";
+import {
+  telegramAccessToken2,
+  TelegramUpdateV22,
+  telegramPluginBase2,
+  userKey,
+  chatKey,
+  telegramBotToken,
+  messagesChannel,
+  telegramBotPluginBase,
+  telegramPluginBase3
+} from "./index-pm1rw9n0.js";
+import {
+  pipe,
+  flow,
+  Service2,
+  toEntries,
+  fromIterable,
+  isReadonlyArrayEmpty,
+  isReadonlyArrayNonEmpty,
+  contains2,
+  map2,
+  filter2,
+  some2,
+  join,
+  effect,
+  provide,
+  succeed4,
+  void_2,
+  gen2,
+  fail5,
+  mapError,
+  timeout,
+  provideService,
+  fnUntraced,
+  fn,
+  makeUnsafe4,
+  formatIso,
+  is,
+  decodeUnknownEffect,
+  decodeEffect,
+  optionalKey,
+  Literal,
+  String3,
+  Boolean2,
+  Struct,
+  ArraySchema,
+  Union,
+  isPattern,
+  isLessThanOrEqualTo,
+  isBetween2,
+  isInt,
+  Int,
+  Natural,
+  NonEmptyString,
+  fromJsonString,
+  NumberFromString,
+  TaggedError2,
+  post,
+  acceptJson,
+  prependUrl,
+  bodyJson,
+  schemaBodyJson,
+  HttpClient,
+  mapRequest
+} from "./index-sdgqen8s.js";
+
+// dist/Telegram.js
+import { createHmac, randomUUID, timingSafeEqual } from "crypto";
+var fromTelegramApiFailure = (error) => {
+  const fields = {
+    cause: error,
+    details: {
+      operation: error.operation,
+      reason: "TelegramApiError"
+    },
+    message: error.message,
+    status: error.status
+  };
+  return error.status === 429 || error.status >= 500 ? new Action_exports.RetryableActionHandlerError(fields) : new Action_exports.ActionHandlerError(fields);
+};
+var orTelegramFailure = fn("Telegram.orTelegramFailure")(function* (effect) {
+  return yield* mapError(effect, (error) => error._tag === "TelegramApiError" ? fromTelegramApiFailure(error) : Action_exports.fromHttpClientFailure(error));
+});
+var baseUrlOf = (context) => context.auth.match({ "access-token": (b) => b.value.baseUrl ?? "https://api.telegram.org" });
+var tokenOf = (context) => context.auth.match({ "access-token": (b) => b.value.accessToken });
+var connOf = (context) => ({
+  baseUrl: baseUrlOf(context),
+  token: tokenOf(context)
+});
+var deriveSecretToken = (token, webhookUrl) => createHmac("sha256", token).update(webhookUrl).digest("hex");
+var secretTokenOf = (config, webhookUrl, token) => config.secretToken ?? deriveSecretToken(token, webhookUrl);
+var isSecretTokenValid = (request, expected) => {
+  if (expected === "")
+    return false;
+  const provided = request.headers?.["x-telegram-bot-api-secret-token"] ?? "";
+  const expectedBuf = Buffer.from(expected);
+  const providedBuf = Buffer.from(provided);
+  return expectedBuf.length === providedBuf.length && timingSafeEqual(expectedBuf, providedBuf);
+};
+var allowedUpdatesOf = (updates) => updates ?? [];
+var updateChatId = (update) => {
+  const candidates = [
+    update["message"],
+    update["edited_message"],
+    update["channel_post"],
+    update["edited_channel_post"]
+  ];
+  for (const candidate of candidates)
+    if (typeof candidate === "object" && candidate !== null) {
+      const chat = candidate.chat;
+      if (typeof chat === "object" && chat !== null) {
+        const id = chat.id;
+        if (id !== undefined && id !== null)
+          return String(id);
+      }
+    }
+  const cb = update["callback_query"];
+  if (typeof cb === "object" && cb !== null) {
+    const message = cb.message;
+    if (typeof message === "object" && message !== null) {
+      const chat = message.chat;
+      if (typeof chat === "object" && chat !== null) {
+        const id = chat.id;
+        if (id !== undefined && id !== null)
+          return String(id);
+      }
+    }
+  }
+};
+var updateUserId = (update) => {
+  const sources = [
+    update["message"],
+    update["edited_message"],
+    update["channel_post"],
+    update["edited_channel_post"],
+    update["callback_query"],
+    update["inline_query"],
+    update["pre_checkout_query"],
+    update["shipping_query"]
+  ];
+  for (const source of sources)
+    if (typeof source === "object" && source !== null) {
+      const from = source.from;
+      if (typeof from === "object" && from !== null) {
+        const id = from.id;
+        if (id !== undefined && id !== null)
+          return String(id);
+      }
+    }
+};
+var activateUpdateV2 = fnUntraced(function* (config, webhookUrl, context) {
+  const client = yield* TelegramClient2;
+  const connection = connOf(context);
+  const registrationUrl = new URL(webhookUrl);
+  registrationUrl.searchParams.set("__dual_telegram_registration", randomUUID());
+  yield* orTelegramFailure(client.setWebhook({
+    ...connection,
+    allowedUpdates: allowedUpdatesOf(config.updates),
+    secretToken: secretTokenOf(config, webhookUrl, connection.token),
+    url: registrationUrl.href
+  }));
+  return { state: {
+    lastUpdateId: null,
+    registrationUrl: registrationUrl.href
+  } };
+});
+var verifyUpdate = (input, webhookUrl, context, status) => isSecretTokenValid(input.request, secretTokenOf(input.config, webhookUrl, tokenOf(context))) ? void_2 : fail5(new Action_exports.ActionHandlerError({
+  message: "invalid Telegram secret token",
+  status
+}));
+var deactivateUpdateV2 = fnUntraced(function* (state, context) {
+  if (state?.registrationUrl === undefined)
+    return;
+  const client = yield* TelegramClient2;
+  const connection = connOf(context);
+  if ((yield* decodeUnknownEffect(Struct({ url: String3 }))(yield* orTelegramFailure(client.getWebhookInfo(connection)))).url !== state.registrationUrl)
+    return;
+  yield* orTelegramFailure(client.deleteWebhook(connection));
+});
+var parseUpdateV2 = fnUntraced(function* (input, webhookUrl, context) {
+  yield* verifyUpdate(input, webhookUrl, context, 401);
+  const body = yield* decodeUnknownEffect(TelegramUpdateV22)(input.request.body);
+  const state = {
+    ...input.state,
+    lastUpdateId: body.update_id
+  };
+  if (isReadonlyArrayNonEmpty(input.config.updates ?? []) && !some2(input.config.updates ?? [], (kind) => body[kind] !== undefined))
+    return {
+      events: [],
+      state
+    };
+  const chatId = body.chat_member?.chat.id ?? body.my_chat_member?.chat.id ?? body.message_reaction?.chat.id ?? body.message_reaction_count?.chat.id;
+  const userId = body.chat_member?.from.id ?? body.my_chat_member?.from.id ?? body.message_reaction?.user?.id;
+  if (isReadonlyArrayNonEmpty(input.config.chatIds ?? [])) {
+    const id = chatId === undefined ? updateChatId(body) : String(chatId);
+    if (id === undefined || !contains2(input.config.chatIds ?? [], id))
+      return {
+        events: [],
+        state
+      };
+  }
+  if (isReadonlyArrayNonEmpty(input.config.userIds ?? [])) {
+    const id = userId === undefined ? updateUserId(body) : String(userId);
+    if (id === undefined || !contains2(input.config.userIds ?? [], id))
+      return {
+        events: [],
+        state
+      };
+  }
+  return {
+    events: [{
+      key: `update:${body.update_id}`,
+      payload: body
+    }],
+    state
+  };
+});
+var TelegramLive2 = Plugin_exports.toLayer(telegramPluginBase2, (pluginHandlers) => pluginHandlers.group("callback", (handlers) => handlers.action("answer-inline-query", fn("@dual-os/telegram/callback.answer-inline-query")(function* (input, context) {
+  const client = yield* TelegramClient2;
+  return yield* orTelegramFailure(client.answerInlineQuery({
+    ...connOf(context),
+    ...input
+  }));
+})).action("answer-query", fn("@dual-os/telegram/callback.answer-query")(function* (input, context) {
+  const client = yield* TelegramClient2;
+  return yield* orTelegramFailure(client.answerCallbackQuery({
+    ...connOf(context),
+    ...input
+  }));
+}))).group("chat", (handlers) => handlers.action("administrators", fn("@dual-os/telegram/chat.administrators")(function* (input, context) {
+  const client = yield* TelegramClient2;
+  return yield* orTelegramFailure(client.getChatAdministrators({
+    ...connOf(context),
+    ...input
+  }));
+})).action("get", fn("@dual-os/telegram/chat.get")(function* (input, context) {
+  const client = yield* TelegramClient2;
+  return yield* orTelegramFailure(client.getChat({
+    ...connOf(context),
+    ...input
+  }));
+})).action("leave", fn("@dual-os/telegram/chat.leave")(function* (input, context) {
+  const client = yield* TelegramClient2;
+  return yield* orTelegramFailure(client.leaveChat({
+    ...connOf(context),
+    ...input
+  }));
+})).action("member", fn("@dual-os/telegram/chat.member")(function* (input, context) {
+  const client = yield* TelegramClient2;
+  return yield* orTelegramFailure(client.getChatMember({
+    ...connOf(context),
+    ...input
+  }));
+})).action("set-description", fn("@dual-os/telegram/chat.set-description")(function* (input, context) {
+  const client = yield* TelegramClient2;
+  return yield* orTelegramFailure(client.setChatDescription({
+    ...connOf(context),
+    ...input
+  }));
+})).action("set-title", fn("@dual-os/telegram/chat.set-title")(function* (input, context) {
+  const client = yield* TelegramClient2;
+  return yield* orTelegramFailure(client.setChatTitle({
+    ...connOf(context),
+    ...input
+  }));
+}))).group("file", (handlers) => handlers.action("get", fn("@dual-os/telegram/file.get")(function* (input, context) {
+  const client = yield* TelegramClient2;
+  return yield* orTelegramFailure(client.getFile({
+    ...connOf(context),
+    ...input
+  }));
+}))).group("message", (handlers) => handlers.action("delete-message", fn("@dual-os/telegram/message.delete-message")(function* (input, context) {
+  const client = yield* TelegramClient2;
+  return yield* orTelegramFailure(client.deleteMessage({
+    ...connOf(context),
+    ...input
+  }));
+})).action("edit-message-text", fn("@dual-os/telegram/message.edit-message-text")(function* (input, context) {
+  const client = yield* TelegramClient2;
+  return yield* orTelegramFailure(client.editMessageText({
+    ...connOf(context),
+    ...input
+  }));
+})).action("pin-chat-message", fn("@dual-os/telegram/message.pin-chat-message")(function* (input, context) {
+  const client = yield* TelegramClient2;
+  return yield* orTelegramFailure(client.pinChatMessage({
+    ...connOf(context),
+    ...input
+  }));
+})).action("send-animation", fn("@dual-os/telegram/message.send-animation")(function* (input, context) {
+  const client = yield* TelegramClient2;
+  return yield* orTelegramFailure(client.sendAnimation({
+    ...connOf(context),
+    ...input
+  }));
+})).action("send-audio", fn("@dual-os/telegram/message.send-audio")(function* (input, context) {
+  const client = yield* TelegramClient2;
+  return yield* orTelegramFailure(client.sendAudio({
+    ...connOf(context),
+    ...input
+  }));
+})).action("send-chat-action", fn("@dual-os/telegram/message.send-chat-action")(function* (input, context) {
+  const client = yield* TelegramClient2;
+  return yield* orTelegramFailure(client.sendChatAction({
+    ...connOf(context),
+    ...input
+  }));
+})).action("send-document", fn("@dual-os/telegram/message.send-document")(function* (input, context) {
+  const client = yield* TelegramClient2;
+  return yield* orTelegramFailure(client.sendDocument({
+    ...connOf(context),
+    ...input
+  }));
+})).action("send-location", fn("@dual-os/telegram/message.send-location")(function* (input, context) {
+  const client = yield* TelegramClient2;
+  return yield* orTelegramFailure(client.sendLocation({
+    ...connOf(context),
+    ...input
+  }));
+})).action("send-media-group", fn("@dual-os/telegram/message.send-media-group")(function* (input, context) {
+  const client = yield* TelegramClient2;
+  return yield* orTelegramFailure(client.sendMediaGroup({
+    ...connOf(context),
+    ...input
+  }));
+})).action("send-message", fn("@dual-os/telegram/message.send-message")(function* (input, context) {
+  const client = yield* TelegramClient2;
+  return yield* orTelegramFailure(client.sendMessage({
+    ...connOf(context),
+    ...input
+  }));
+})).action("send-photo", fn("@dual-os/telegram/message.send-photo")(function* (input, context) {
+  const client = yield* TelegramClient2;
+  return yield* orTelegramFailure(client.sendPhoto({
+    ...connOf(context),
+    ...input
+  }));
+})).action("send-sticker", fn("@dual-os/telegram/message.send-sticker")(function* (input, context) {
+  const client = yield* TelegramClient2;
+  return yield* orTelegramFailure(client.sendSticker({
+    ...connOf(context),
+    ...input
+  }));
+})).action("send-video", fn("@dual-os/telegram/message.send-video")(function* (input, context) {
+  const client = yield* TelegramClient2;
+  return yield* orTelegramFailure(client.sendVideo({
+    ...connOf(context),
+    ...input
+  }));
+})).action("unpin-chat-message", fn("@dual-os/telegram/message.unpin-chat-message")(function* (input, context) {
+  const client = yield* TelegramClient2;
+  return yield* orTelegramFailure(client.unpinChatMessage({
+    ...connOf(context),
+    ...input
+  }));
+}))).trigger("update", {
+  activate: (input, context) => activateUpdateV2(input.config, input.webhookUrl, context),
+  deactivate: (input, context) => deactivateUpdateV2(input.state, context),
+  parse: (input, context) => parseUpdateV2(input, input.webhookUrl, context),
+  verify: (input, context) => verifyUpdate(input, input.webhookUrl, context, 401)
+}));
+var telegramPlugin = telegramPluginBase2.pipe(Plugin_exports.provide(TelegramLive2), Plugin_exports.provide(layer2), Plugin_exports.provide(layer4));
+
+// dist/channel/telegram-bot-client.js
+var numericId = Int.check(isBetween2({
+  minimum: 1,
+  maximum: 9007199254740991
+}));
+var bot = Struct({
+  id: numericId,
+  is_bot: Literal(true),
+  username: NonEmptyString
+});
+var webhook = Struct({ url: String3 });
+var sentMessage = Struct({
+  chat: Struct({ id: Int }),
+  message_id: numericId,
+  message_thread_id: optionalKey(numericId)
+});
+var failure = Struct({
+  description: String3,
+  error_code: Int,
+  ok: Literal(false),
+  parameters: optionalKey(Struct({ retry_after: optionalKey(Natural) }))
+});
+var TelegramBotFailure = class extends TaggedError2()("TelegramBotFailure", {
+  code: AgentChannel_exports.FailureCode,
+  retryAfterSeconds: optionalKey(Natural)
+}) {
+};
+function uncertainCode(createsMessage) {
+  if (createsMessage)
+    return "unknown_completion";
+  return "unavailable";
+}
+function errorCode(status, createsMessage) {
+  if (status === 429)
+    return "rate_limited";
+  if (status === 401 || status === 403)
+    return "unauthorized";
+  if (status >= 500)
+    return uncertainCode(createsMessage);
+  return "rejected";
+}
+function retryDelay(parameters) {
+  if (parameters?.retry_after === undefined)
+    return {};
+  return { retryAfterSeconds: parameters.retry_after };
+}
+var make = gen2(function* () {
+  const transport = yield* HttpClient;
+  const client = pipe(transport, mapRequest(flow(prependUrl("https://api.telegram.org"), acceptJson)));
+  const call = fn("TelegramBotClient.call")(function* (auth, method, body, result, createsMessage = false) {
+    const request = yield* pipe(post(`/bot${auth.botToken}/${method}`), bodyJson(body), mapError(() => TelegramBotFailure.make({ code: "rejected" })));
+    const response = yield* pipe(client.execute(request), provideService(RequestInit, { redirect: "manual" }), timeout("30 seconds"), mapError(() => TelegramBotFailure.make({ code: uncertainCode(createsMessage) })));
+    const envelope = Union([Struct({
+      ok: Literal(true),
+      result
+    }), failure]);
+    const decoded = yield* pipe(schemaBodyJson(envelope)(response), timeout("30 seconds"), mapError((error) => {
+      if (response.status >= 200 && response.status < 300) {
+        if (createsMessage)
+          return TelegramBotFailure.make({ code: "unknown_completion" });
+        if (error._tag === "TimeoutError" || error._tag === "HttpClientError")
+          return TelegramBotFailure.make({ code: "unavailable" });
+      }
+      return TelegramBotFailure.make({ code: errorCode(response.status, createsMessage) });
+    }));
+    if (decoded.ok && response.status >= 200 && response.status < 300)
+      return decoded.result;
+    if (!decoded.ok) {
+      if (response.status >= 500)
+        return yield* TelegramBotFailure.make({ code: uncertainCode(createsMessage) });
+      return yield* TelegramBotFailure.make({
+        code: errorCode(decoded.error_code, createsMessage),
+        ...retryDelay(decoded.parameters)
+      });
+    }
+    return yield* TelegramBotFailure.make({ code: uncertainCode(createsMessage) });
+  });
+  return {
+    deleteMessage: (auth, body) => call(auth, "deleteMessage", body, Literal(true)),
+    deleteWebhook: (auth) => call(auth, "deleteWebhook", { drop_pending_updates: false }, Literal(true)),
+    editMessageText: (auth, body) => call(auth, "editMessageText", body, sentMessage),
+    getMe: (auth) => call(auth, "getMe", {}, bot),
+    getWebhookInfo: (auth) => call(auth, "getWebhookInfo", {}, webhook),
+    sendChatAction: (auth, body) => call(auth, "sendChatAction", body, Literal(true)),
+    sendMessage: (auth, body) => call(auth, "sendMessage", body, sentMessage, true),
+    setMessageReaction: (auth, body) => call(auth, "setMessageReaction", body, Literal(true)),
+    setWebhook: (auth, url) => call(auth, "setWebhook", {
+      allowed_updates: ["message"],
+      drop_pending_updates: false,
+      secret_token: auth.webhookSecret,
+      url
+    }, Literal(true))
+  };
+});
+var TelegramBotClient = class extends Service2()("@dual-os/telegram-bot/telegram-bot-client/TelegramBotClient") {
+  static layer = effect(this, make);
+};
+
+// dist/channel/telegram-bot-webhook.js
+import { timingSafeEqual as timingSafeEqual2 } from "crypto";
+var positiveId = Int.check(isBetween2({
+  minimum: 1,
+  maximum: 9007199254740991
+}));
+var user = Struct({
+  id: positiveId,
+  is_bot: Boolean2
+});
+var chat = Struct({
+  id: Int.check(isBetween2({
+    minimum: -9007199254740991,
+    maximum: 9007199254740991
+  })),
+  type: String3
+});
+var entity = Struct({
+  length: Natural,
+  offset: Natural,
+  type: String3,
+  user: optionalKey(user)
+});
+var message = Struct({
+  business_connection_id: optionalKey(String3),
+  chat,
+  date: Natural.check(isLessThanOrEqualTo(253402300799)),
+  entities: optionalKey(ArraySchema(entity)),
+  from: optionalKey(user),
+  forward_origin: optionalKey(Struct({ type: String3 })),
+  is_automatic_forward: optionalKey(Boolean2),
+  message_id: positiveId,
+  message_thread_id: optionalKey(positiveId),
+  reply_to_message: optionalKey(Struct({
+    chat,
+    from: optionalKey(user),
+    message_id: positiveId,
+    message_thread_id: optionalKey(positiveId)
+  })),
+  sender_chat: optionalKey(chat),
+  text: optionalKey(String3)
+});
+var addressedCommand = String3.check(isPattern(/^\/[a-z0-9_]+@[a-z0-9_]+$/u));
+var update = Struct({
+  edited_message: optionalKey(message),
+  message: optionalKey(message),
+  update_id: Natural
+});
+function verify(request, secret) {
+  const headers = filter2(toEntries(request.headers), (entry) => toLowerCase(entry[0]) === "x-telegram-bot-api-secret-token");
+  const received = headers[0]?.[1];
+  if (request.method !== "POST" || headers.length !== 1 || received === undefined)
+    return fail5(AgentChannel_exports.HandlerError.make({ code: "unauthorized" }));
+  const actual = new TextEncoder().encode(received);
+  const expected = new TextEncoder().encode(secret);
+  if (actual.byteLength !== expected.byteLength || !timingSafeEqual2(actual, expected))
+    return fail5(AgentChannel_exports.HandlerError.make({ code: "unauthorized" }));
+  return succeed4({ verified: true });
+}
+function messageKey(destination, id) {
+  return `${destination.conversationKey}/${destination.threadKey ?? "main"}/${id}`;
+}
+function chatKind(type) {
+  if (type === "private")
+    return "direct";
+  return "group";
+}
+function threadKey(id) {
+  if (id === undefined)
+    return {};
+  return { threadKey: `${id}` };
+}
+function replyKey(destination, reply) {
+  if (reply === undefined)
+    return {};
+  return { replyToMessageKey: messageKey(destination, reply.message_id) };
+}
+function inScope(conversation, settings) {
+  if (conversation.kind === "direct")
+    return settings.directMessages;
+  return isReadonlyArrayEmpty(settings.chatIds) || contains2(settings.chatIds, conversation.conversationKey) || conversation.threadKey !== undefined && contains2(settings.chatIds, `${conversation.conversationKey}/${conversation.threadKey}`);
+}
+var receive = fn("TelegramBot.receive")(function* (body, state, settings) {
+  const input = yield* pipe(decodeEffect(fromJsonString(update))(body), mapError(() => AgentChannel_exports.HandlerError.make({ code: "rejected" })));
+  const source = input.message;
+  if (source === undefined || input.edited_message !== undefined || source.from === undefined || source.from.is_bot || `${source.from.id}` === state.botId || source.sender_chat !== undefined || source.business_connection_id !== undefined || source.forward_origin !== undefined || source.is_automatic_forward === true || source.text === undefined || isEmpty(source.text) || source.chat.type !== "private" && source.chat.type !== "group" && source.chat.type !== "supergroup")
+    return [];
+  const conversation = {
+    conversationKey: `${source.chat.id}`,
+    kind: chatKind(source.chat.type),
+    ...threadKey(source.message_thread_id)
+  };
+  if (!inScope(conversation, settings))
+    return [];
+  const text = source.text;
+  const entities = source.entities ?? [];
+  const addressed = filter2(entities, (item) => item.length > 0 && item.offset + item.length <= text.length && !some2(entities, (span) => (span.type === "blockquote" || span.type === "expandable_blockquote" || span.type === "code" || span.type === "pre") && item.offset < span.offset + span.length && item.offset + item.length > span.offset));
+  const username = toLowerCase(state.botUsername);
+  const explicit = some2(addressed, (item) => {
+    const value = toLowerCase(slice(item.offset, item.offset + item.length)(text));
+    return item.type === "mention" && value === `@${username}` || item.type === "text_mention" && `${item.user?.id}` === state.botId || item.type === "bot_command" && item.offset === 0 && is(addressedCommand)(value) && endsWith(`@${username}`)(value);
+  });
+  const reply = source.reply_to_message;
+  const replyToBot = reply !== undefined && `${reply.from?.id}` === state.botId && reply.from?.is_bot === true && reply.chat.id === source.chat.id && reply.message_thread_id === source.message_thread_id;
+  const respond = conversation.kind === "direct" || explicit || replyToBot || settings.respondTo === "all_messages";
+  const stop = some2(addressed, (item) => {
+    if (item.type !== "bot_command" || item.offset !== 0)
+      return false;
+    const command = toLowerCase(slice(0, item.length)(text));
+    return command === "/stop" || command === `/stop@${username}`;
+  });
+  const identity = {
+    conversation,
+    eventKey: `${input.update_id}`,
+    senderKey: `${source.from.id}`,
+    timestamp: formatIso(makeUnsafe4(source.date * 1000))
+  };
+  if (stop && respond)
+    return [{
+      ...identity,
+      kind: "stop"
+    }];
+  return [{
+    ...identity,
+    content: {
+      text,
+      ...replyKey(conversation, reply)
+    },
+    kind: "message",
+    messageKey: messageKey(conversation, source.message_id),
+    respond
+  }];
+});
+
+// dist/channel/telegram-bot.js
+var numericKey = NumberFromString.check(isInt(), isBetween2({
+  minimum: 1,
+  maximum: 9007199254740991
+}));
+function validDestination(destination) {
+  if (!is(chatKey)(destination.conversationKey))
+    return false;
+  if (destination.threadKey !== undefined && !is(userKey)(destination.threadKey))
+    return false;
+  if (destination.kind === "direct")
+    return !startsWith("-")(destination.conversationKey);
+  return startsWith("-")(destination.conversationKey);
+}
+function checkAccess(identity, context) {
+  if (!validDestination(identity.conversation) || !inScope(identity.conversation, context.deploymentSettings) || !is(userKey)(identity.senderKey) || identity.conversation.kind === "direct" && identity.conversation.conversationKey !== identity.senderKey || identity.senderKey === split(":")(context.auth.value.botToken)[0] || context.deploymentSettings.access === "restricted" && !contains2(context.deploymentSettings.allowedSenderKeys, identity.senderKey))
+    return succeed4({ decision: "deny" });
+  return succeed4({ decision: "allow" });
+}
+function installed(command, context) {
+  if (command.installationKey !== command.state.botId || command.state.botId !== split(":")(context.auth.value.botToken)[0])
+    return fail5(AgentChannel_exports.HandlerError.make({ code: "unauthorized" }));
+  return void_2;
+}
+var activate = fn("TelegramBot.activate")(function* (command, context) {
+  const client = yield* TelegramBotClient;
+  const bot = yield* client.getMe(context.auth.value);
+  const botId = `${bot.id}`;
+  if (botId !== split(":")(context.auth.value.botToken)[0] || command.state !== undefined && (command.state.botId !== botId || command.state.ingressUrl !== command.ingressUrl))
+    return yield* AgentChannel_exports.HandlerError.make({ code: "unauthorized" });
+  const url = new URL(command.ingressUrl);
+  if (url.protocol !== "https:")
+    return yield* AgentChannel_exports.HandlerError.make({ code: "rejected" });
+  url.searchParams.set("__dual_telegram_registration", command.operationKey);
+  const state = {
+    botId,
+    botUsername: bot.username,
+    ingressUrl: command.ingressUrl,
+    registrationUrl: url.href
+  };
+  if (command.state !== undefined && command.state.registrationUrl !== state.registrationUrl)
+    return yield* AgentChannel_exports.HandlerError.make({ code: "unauthorized" });
+  if (command.state === undefined) {
+    yield* client.getWebhookInfo(context.auth.value);
+    return {
+      checkpoint: true,
+      installationKey: botId,
+      kind: "activate",
+      operationKey: command.operationKey,
+      state
+    };
+  }
+  yield* client.setWebhook(context.auth.value, state.registrationUrl);
+  if ((yield* client.getWebhookInfo(context.auth.value)).url !== state.registrationUrl)
+    return yield* AgentChannel_exports.HandlerError.make({ code: "unavailable" });
+  return {
+    installationKey: botId,
+    kind: "activate",
+    operationKey: command.operationKey,
+    state
+  };
+});
+function referenceId(destination, reference) {
+  const prefix = `${destination.conversationKey}/${destination.threadKey ?? "main"}/`;
+  if (reference === undefined || !startsWith(prefix)(reference))
+    return fail5(AgentChannel_exports.HandlerError.make({ code: "rejected" }));
+  const id = slice(prefix.length)(reference);
+  if (!is(userKey)(id))
+    return fail5(AgentChannel_exports.HandlerError.make({ code: "rejected" }));
+  return pipe(decodeEffect(numericKey)(id), mapError(() => AgentChannel_exports.HandlerError.make({ code: "rejected" })));
+}
+var topicParameters = fn("TelegramBot.topicParameters")(function* (destination) {
+  if (destination.threadKey === undefined)
+    return {};
+  return { message_thread_id: yield* pipe(decodeEffect(numericKey)(destination.threadKey), mapError(() => AgentChannel_exports.HandlerError.make({ code: "rejected" }))) };
+});
+function sameTopic(destination, id) {
+  if (id === undefined)
+    return destination.threadKey === undefined;
+  return `${id}` === destination.threadKey;
+}
+function outcomeText(operation) {
+  if (operation.kind === "present_outcome" && operation.options !== undefined)
+    return join([operation.text, ...map2(operation.options, (option, index) => `${index + 1}. ${option}`)], `
+`);
+  return operation.text;
+}
+var reactions = {
+  confused: "\uD83E\uDD14",
+  eyes: "\uD83D\uDC40",
+  heart: "\u2764",
+  hooray: "\uD83C\uDF89",
+  laugh: "\uD83D\uDE01",
+  rocket: "\uD83D\uDE80",
+  thumbs_down: "\uD83D\uDC4E",
+  thumbs_up: "\uD83D\uDC4D"
+};
+function desiredReaction(operation) {
+  if (!operation.active)
+    return [];
+  return [{
+    type: "emoji",
+    emoji: reactions[operation.reaction]
+  }];
+}
+function reactionReference(operation, activationMessageKey) {
+  if (operation.target.kind === "activation")
+    return activationMessageKey;
+  return operation.target.reference;
+}
+var performOutput = fn("TelegramBot.performOutput")(function* (command, context) {
+  const destination = command.destination;
+  if (!validDestination(destination))
+    return yield* AgentChannel_exports.HandlerError.make({ code: "rejected" });
+  const client = yield* TelegramBotClient;
+  const auth = context.auth.value;
+  const target = { chat_id: destination.conversationKey };
+  const operation = command.operation;
+  if (operation.kind === "set_activity") {
+    if (operation.activity.kind === "working") {
+      const topic = yield* topicParameters(destination);
+      yield* client.sendChatAction(auth, {
+        ...target,
+        ...topic,
+        action: "typing"
+      });
+    }
+    return command.deliveryKey;
+  }
+  if (operation.kind === "set_reaction") {
+    const id = yield* referenceId(destination, reactionReference(operation, command.activationMessageKey));
+    yield* client.setMessageReaction(auth, {
+      ...target,
+      message_id: id,
+      reaction: desiredReaction(operation)
+    });
+    return messageKey(destination, id);
+  }
+  if (operation.kind === "delete_message") {
+    const id = yield* referenceId(destination, operation.reference);
+    yield* client.deleteMessage(auth, {
+      ...target,
+      message_id: id
+    });
+    return operation.reference;
+  }
+  if (operation.kind === "update_message") {
+    if (fromIterable(operation.text).length > 4096)
+      return yield* AgentChannel_exports.HandlerError.make({ code: "rejected" });
+    const id = yield* referenceId(destination, operation.reference);
+    const edited = yield* client.editMessageText(auth, {
+      ...target,
+      message_id: id,
+      text: operation.text
+    });
+    if (`${edited.chat.id}` !== destination.conversationKey || edited.message_id !== id || !sameTopic(destination, edited.message_thread_id))
+      return yield* AgentChannel_exports.HandlerError.make({ code: "rejected" });
+    return operation.reference;
+  }
+  if (operation.kind === "present_outcome" || operation.kind === "create_message") {
+    const text = outcomeText(operation);
+    if (fromIterable(text).length > 4096)
+      return yield* AgentChannel_exports.HandlerError.make({ code: "rejected" });
+    if (isEmpty(text))
+      return command.deliveryKey;
+    const topic = yield* topicParameters(destination);
+    const sent = yield* client.sendMessage(auth, {
+      ...target,
+      ...topic,
+      text
+    });
+    if (`${sent.chat.id}` !== destination.conversationKey || !sameTopic(destination, sent.message_thread_id))
+      return yield* AgentChannel_exports.HandlerError.make({ code: "unknown_completion" });
+    return messageKey(destination, sent.message_id);
+  }
+  return yield* AgentChannel_exports.HandlerError.make({ code: "rejected" });
+});
+var execute = fn("TelegramBot.execute")(function* (command, context) {
+  if (command.kind === "activate")
+    return yield* activate(command, context);
+  yield* installed(command, context);
+  if (command.kind === "deactivate") {
+    const client = yield* TelegramBotClient;
+    if ((yield* client.getWebhookInfo(context.auth.value)).url === command.state.registrationUrl)
+      yield* client.deleteWebhook(context.auth.value);
+    return {
+      kind: "deactivate",
+      operationKey: command.operationKey
+    };
+  }
+  if (command.kind === "deliver")
+    return {
+      deliveryKey: command.deliveryKey,
+      kind: "deliver",
+      operationKey: command.operationKey,
+      providerDeliveryKey: yield* performOutput(command, context),
+      status: "succeeded"
+    };
+  if (command.kind !== "receive")
+    return yield* AgentChannel_exports.HandlerError.make({ code: "rejected" });
+  return {
+    events: yield* receive(command.request.body, command.state, context.deploymentSettings),
+    kind: "receive",
+    operationKey: command.operationKey,
+    response: {
+      body: "",
+      status: 200
+    },
+    verified: true
+  };
+}, mapError((error) => AgentChannel_exports.HandlerError.make({ code: error.code })));
+var telegramBotHandlers = Plugin_exports.toLayer(telegramBotPluginBase, (handlers) => handlers.channel("messages", {
+  checkAccess,
+  execute,
+  verify: (request, context) => verify(request, context.auth.value.webhookSecret)
+}));
+var telegramChannelLayer = telegramBotHandlers.pipe(provide(TelegramBotClient.layer), provide(layer4));
+
+// dist/plugin.js
+var plugin_exports2 = /* @__PURE__ */ __exportAll({
+  TelegramLive: () => TelegramLive2,
+  layer: () => layer2,
+  telegramAccessToken: () => telegramAccessToken2,
+  telegramPlugin: () => telegramPlugin2,
+  telegramPluginBase: () => telegramPluginBase3
+});
+var telegramPlugin2 = telegramPlugin.pipe(Plugin_exports.withAuthMethod(telegramBotToken), Plugin_exports.withAgentChannel(messagesChannel), Plugin_exports.provide(telegramChannelLayer));
+export { TelegramLive2, plugin_exports2, telegramPlugin2 };
+
+//# debugId=CF09747DEAF2115164756E2164756E21
+//# sourceMappingURL=index-hpjyc5yq.js.map