@codebam/cf-workers-telegram-bot 3.42.0 → 3.45.0

package/dist/main/src/bot_api.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="@cloudflare/workers-types" />
+import Handler from "./handler";
+import { Commands, Config, Update, Webhook } from "./types";
+export default class BotApi {
+    commands: Commands;
+    webhook: Config["webhook"];
+    handler: Handler;
+    update: (update: Update) => Promise<Response>;
+    constructor(commands: Commands, webhook: Webhook, handler: Handler);
+}

package/dist/main/src/bot_api.js

@@ -0,0 +1,11 @@
+export default class BotApi {
+    commands;
+    webhook;
+    handler;
+    update;
+    constructor(commands, webhook, handler) {
+        this.commands = commands;
+        this.webhook = webhook;
+        this.handler = handler;
+    }
+}

package/dist/main/src/handler.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="@cloudflare/workers-types" />
+import BotApi from "./bot_api";
+import { PartialConfig } from "./types";
+export default class Handler {
+    configs: PartialConfig[];
+    constructor(configs: PartialConfig[]);
+    getResponse: (_request?: Request, _bot?: BotApi) => Promise<Response>;
+    postResponse: (_request?: Request, _bot?: BotApi) => Promise<Response>;
+    responses: Record<string, (_request?: Request, _bot?: BotApi) => Promise<Response>>;
+    getAccessKeys: (configs: PartialConfig[]) => Promise<Record<string, any> | Record<string, never>>;
+    handle: (request: Request) => Promise<Response>;
+}

package/dist/main/src/handler.js

@@ -0,0 +1,51 @@
+import BotApi from "./bot_api";
+import { sha256, log } from "./libs";
+import { Config, Webhook, localhost, } from "./types";
+export default class Handler {
+    configs;
+    constructor(configs) {
+        this.configs = configs;
+    }
+    getResponse = async (_request, _bot) => {
+        this.getAccessKeys(this.configs).then((access_keys) => Object.keys(access_keys).forEach((key) => log(`${access_keys[key].bot_name} ${new URL(_request?.url ?? localhost).href}${key}`)));
+        if (_bot?.webhook.token) {
+            return _bot.webhook.process(new URL(_request?.url ?? localhost));
+        }
+        return this.responses.default();
+    };
+    postResponse = async (_request, _bot) => {
+        const bot = _bot ??
+            new BotApi({}, new Webhook(localhost, "", localhost), new Handler([new Config()]));
+        if (bot.webhook.token) {
+            const request = _request ?? new Request("");
+            return (request
+                .json()
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                .then((update) => bot.update(update)));
+        }
+        return this.responses.default();
+    };
+    responses = {
+        GET: this.getResponse,
+        POST: this.postResponse,
+        default: () => new Promise(() => new Response()),
+    };
+    getAccessKeys = async (configs
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    ) => Promise.all(configs.map((bot_config) => sha256(bot_config.webhook?.token ?? "").then((hash) => [
+        hash,
+        bot_config,
+    ]))).then((result) => Object.fromEntries(result));
+    // handles the request
+    handle = async (request) => this.getAccessKeys(this.configs).then((access_keys) => {
+        if (Object.keys(this.responses).includes(request.method)) {
+            return this.responses[request.method](request, new access_keys[new URL(request.url).pathname.substring(1)].api({
+                ...new Config(),
+                url: new URL(new URL(request.url).origin),
+                handler: this,
+                ...access_keys[new URL(request.url).pathname.substring(1)],
+            }));
+        }
+        return this.responses.default();
+    });
+}

package/dist/main/src/libs.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="@cloudflare/workers-types" />
+export declare const sha256: (text: string) => Promise<string>;
+export declare const prettyJSON: (obj: unknown) => string;
+export declare const JSONResponse: (obj: unknown, status?: number) => Response;
+export declare const log: (obj: any) => any;
+export declare const preTagString: (str: string) => string;
+export declare const addSearchParams: (url: URL, params?: Record<string, string>) => URL;
+export declare const responseToJSON: (response: Response) => Promise<Record<string, unknown>>;
+export declare const undefinedEmpty: <T>(obj: T) => T[];
+export declare const fetch_json: (url: URL) => Promise<Response>;

package/dist/main/src/libs.js

@@ -0,0 +1,30 @@
+export const sha256 = async (text) => crypto.subtle
+    .digest("SHA-256", new TextEncoder().encode(text))
+    .then((array_buffer) => Array.from(new Uint8Array(array_buffer))
+    .map((b) => b.toString(16).padStart(2, "0"))
+    .join(""));
+// format json with line indents and newlines
+export const prettyJSON = (obj) => JSON.stringify(obj, null, 2);
+// Generate JSON response
+export const JSONResponse = (obj, status = 200) => new Response(prettyJSON(obj), {
+    status: status,
+    headers: {
+        "content-type": "application/json",
+    },
+});
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const log = (obj) => console.log(obj) === undefined && obj;
+export const preTagString = (str) => `<pre>${str}</pre>`;
+export const addSearchParams = (url, params = {}) => new URL(`${url.origin}${url.pathname}?${new URLSearchParams(Object.entries(Object.fromEntries([
+    ...Array.from(url.searchParams.entries()),
+    ...Object.entries(params),
+]))).toString()}`);
+export const responseToJSON = async (response) => response
+    .clone()
+    .text()
+    .then((text) => JSON.parse(text))
+    .catch(() => log({ error: "Failed to parse JSON of response" }));
+export const undefinedEmpty = (obj) => (obj === undefined && []) || [obj];
+export const fetch_json = async (url) => fetch(url.href)
+    .then((response) => responseToJSON(response))
+    .then((json) => JSONResponse(json));

package/dist/main/src/main.d.ts

@@ -0,0 +1,11 @@
+import BotApi from "./bot_api";
+import Handler from "./handler";
+import * as Libs from "./libs";
+import TelegramApi from "./telegram_api";
+import TelegramBot from "./telegram_bot";
+import TelegramCommands from "./telegram_commands";
+import TelegramWebhook from "./telegram_webhook";
+import * as Types from "./types";
+import Webhook from "./webhook";
+import worker from "../../worker/src/worker";
+export { BotApi, Handler, Libs, TelegramApi, TelegramBot, TelegramCommands, TelegramWebhook, Types, Webhook, worker, };

package/dist/main/src/main.js

@@ -0,0 +1,11 @@
+import BotApi from "./bot_api";
+import Handler from "./handler";
+import * as Libs from "./libs";
+import TelegramApi from "./telegram_api";
+import TelegramBot from "./telegram_bot";
+import TelegramCommands from "./telegram_commands";
+import TelegramWebhook from "./telegram_webhook";
+import * as Types from "./types";
+import Webhook from "./webhook";
+import worker from "../../worker/src/worker";
+export { BotApi, Handler, Libs, TelegramApi, TelegramBot, TelegramCommands, TelegramWebhook, Types, Webhook, worker, };

package/dist/main/src/telegram_api.d.ts

@@ -0,0 +1,30 @@
+/// <reference types="@cloudflare/workers-types" />
+import BotApi from "./bot_api";
+import { Commands, TelegramInlineQueryResult, TelegramUpdate, Webhook, Update } from "./types";
+import Handler from "./handler";
+export default class TelegramApi extends BotApi {
+    constructor(commands: Commands, webhook: Webhook, handler: Handler);
+    inlineQueryUpdate: (update: TelegramUpdate) => Promise<Response>;
+    messageUpdate: (update: TelegramUpdate) => Promise<Response>;
+    updates: {
+        inline_query: (update: TelegramUpdate) => Promise<Response>;
+        message: (update: TelegramUpdate) => Promise<Response>;
+        default: Response;
+    };
+    update: (update: Update) => Promise<Response>;
+    greetUsers: (update: TelegramUpdate) => Promise<Response>;
+    getCommand: (args: string[]) => string;
+    _executeCommand: (update: TelegramUpdate, text: string, args?: string[]) => Promise<any>;
+    executeInlineCommand: (update: TelegramUpdate) => Promise<Response>;
+    executeCommand: (update: TelegramUpdate) => Promise<Response>;
+    answerInlineQuery: (inline_query_id: number, results: TelegramInlineQueryResult[], cache_time?: number) => Promise<Response>;
+    sendMessage: (chat_id: number, text: string, parse_mode?: string, disable_web_page_preview?: boolean, disable_notification?: boolean, reply_to_message_id?: number) => Promise<Response>;
+    forwardMessage: (chat_id: number, from_chat_id: number, disable_notification: boolean | undefined, message_id: number) => Promise<Response>;
+    sendPhoto: (chat_id: number, photo: string, caption?: string, parse_mode?: string, disable_notification?: boolean, reply_to_message_id?: number) => Promise<Response>;
+    sendVideo: (chat_id: number, video: Blob, duration?: number, width?: number, height?: number, thumb?: string, caption?: string, parse_mode?: string, supports_streaming?: boolean, disable_notification?: boolean, reply_to_message_id?: number) => Promise<Response>;
+    sendAnimation: (chat_id: number, animation: Blob, duration?: number, width?: number, height?: number, thumb?: string, caption?: string, parse_mode?: string, disable_notification?: boolean, reply_to_message_id?: number) => Promise<Response>;
+    sendLocation: (chat_id: number, latitude: number, longitude: number, live_period?: number, disable_notification?: boolean, reply_to_message_id?: number) => Promise<Response>;
+    sendPoll: (chat_id: number, question: string, options: string[], is_anonymous?: boolean, type?: string, allows_multiple_answers?: boolean, correct_option_id?: number, explanation?: string, explanation_parse_mode?: string, open_period?: number, close_date?: number, is_closed?: boolean, disable_notification?: boolean, reply_to_message_id?: number) => Promise<Response>;
+    sendDice: (chat_id: number, emoji?: string, disable_notification?: boolean, reply_to_message_id?: number) => Promise<Response>;
+    getUserProfilePhotos: (user_id: number, offset?: number, limit?: number) => Promise<Response>;
+}

package/dist/main/src/telegram_api.js

@@ -0,0 +1,153 @@
+import BotApi from "./bot_api";
+import { addSearchParams, log, responseToJSON } from "./libs";
+export default class TelegramApi extends BotApi {
+    constructor(commands, webhook, handler) {
+        super(commands, webhook, handler);
+    }
+    inlineQueryUpdate = async (update) => this.executeInlineCommand(update).then(async (response) => (await responseToJSON(response)) && response);
+    messageUpdate = async (update) => {
+        if (typeof (update.message?.text ?? false) === "string") {
+            return await this.executeCommand(update).then(async () => await this.greetUsers(update));
+        }
+        return this.updates.default;
+    };
+    updates = {
+        inline_query: this.inlineQueryUpdate,
+        message: this.messageUpdate,
+        default: new Response(),
+    };
+    update = async (update) => (log({ update }) &&
+        update.message !== undefined &&
+        (await this.updates.message(update))) ||
+        (update.inline_query !== undefined &&
+            update.inline_query.query !== "" &&
+            (await this.updates.inline_query(update))) ||
+        this.updates.default;
+    // greet new users who join
+    greetUsers = async (update) => {
+        if (update.message?.new_chat_members !== undefined) {
+            return this.sendMessage(update.message.chat.id, `Welcome to ${update.message.chat.title}, ${update.message.from.username}`);
+        }
+        return this.updates.default;
+    };
+    getCommand = (args) => args[0]?.split("@")[0];
+    // run command passed from executeCommand
+    _executeCommand = async (update, text, args = []) => (log({ execute: { text, args } }) &&
+        (async (text_args) => ((command) => ((this.commands[command] ||
+            log({
+                error: `command '${command}' does not exist`,
+            })) &&
+            this.commands[command]?.(this, update, [...text_args, ...args])) ||
+            // run the command
+            this.updates.default)(this.getCommand(text_args)))(
+        // get the command to run
+        text
+            .trimStart()
+            .replace(/^([^\s]*\s)\s*/gm, "$1")
+            .split(" "))) ??
+        this.updates.default;
+    // execute the inline custom bot commands from bot configurations
+    executeInlineCommand = async (update) => ((await this._executeCommand(update, update.inline_query?.query ?? "")) &&
+        (await this._executeCommand(update, "inline", update.inline_query?.query.trimStart().split(" ")))) ??
+        this.updates.default;
+    // execute the custom bot commands from bot configurations
+    executeCommand = async (update) => this._executeCommand(update, update.message?.text ?? "") ||
+        this.updates.default;
+    // trigger answerInlineQuery command of BotAPI
+    answerInlineQuery = async (inline_query_id, results, cache_time = 0) => fetch(log(addSearchParams(new URL(`${this.webhook.api.href}/answerInlineQuery`), {
+        inline_query_id: inline_query_id.toString(),
+        results: JSON.stringify(results),
+        cache_time: cache_time.toString(),
+    }).href));
+    // trigger sendMessage command of BotAPI
+    sendMessage = async (chat_id, text, parse_mode = "", disable_web_page_preview = false, disable_notification = false, reply_to_message_id = 0) => fetch(log(addSearchParams(new URL(`${this.webhook.api.href}/sendMessage`), {
+        chat_id: chat_id.toString(),
+        text,
+        parse_mode: parse_mode,
+        disable_web_page_preview: disable_web_page_preview.toString(),
+        disable_notification: disable_notification.toString(),
+        reply_to_message_id: reply_to_message_id.toString(),
+    }).href));
+    // trigger forwardMessage command of BotAPI
+    forwardMessage = async (chat_id, from_chat_id, disable_notification = false, message_id) => fetch(log(addSearchParams(new URL(`${this.webhook.api.href}/sendMessage`), {
+        chat_id: chat_id.toString(),
+        from_chat_id: from_chat_id.toString(),
+        message_id: message_id.toString(),
+        disable_notification: disable_notification.toString(),
+    }).href));
+    // trigger sendPhoto command of BotAPI
+    sendPhoto = async (chat_id, photo, caption = "", parse_mode = "", disable_notification = false, reply_to_message_id = 0) => fetch(log(addSearchParams(new URL(`${this.webhook.api.href}/sendPhoto`), {
+        chat_id: chat_id.toString(),
+        photo,
+        caption,
+        parse_mode,
+        disable_notification: disable_notification.toString(),
+        reply_to_message_id: reply_to_message_id.toString(),
+    }).href));
+    // trigger sendVideo command of BotAPI
+    sendVideo = async (chat_id, video, duration = 0, width = 0, height = 0, thumb = "", caption = "", parse_mode = "", supports_streaming = false, disable_notification = false, reply_to_message_id = 0) => fetch(log(addSearchParams(new URL(`${this.webhook.api.href}/sendVideo`), {
+        chat_id: chat_id.toString(),
+        video: JSON.stringify(video),
+        duration: duration.toString(),
+        width: width.toString(),
+        height: height.toString(),
+        thumb: thumb,
+        caption: caption,
+        parse_mode: parse_mode,
+        supports_streaming: supports_streaming.toString(),
+        disable_notification: disable_notification.toString(),
+        reply_to_message_id: reply_to_message_id.toString(),
+    }).href));
+    // trigger sendAnimation command of BotAPI
+    sendAnimation = async (chat_id, animation, duration = 0, width = 0, height = 0, thumb = "", caption = "", parse_mode = "", disable_notification = false, reply_to_message_id = 0) => fetch(log(addSearchParams(new URL(`${this.webhook.api.href}/sendAnimation`), {
+        chat_id: chat_id.toString(),
+        animation: JSON.stringify(animation),
+        duration: duration.toString(),
+        width: width.toString(),
+        height: height.toString(),
+        thumb,
+        caption,
+        parse_mode,
+        disable_notification: disable_notification.toString(),
+        reply_to_message_id: reply_to_message_id.toString(),
+    }).href));
+    // trigger sendLocation command of BotAPI
+    sendLocation = async (chat_id, latitude, longitude, live_period = 0, disable_notification = false, reply_to_message_id = 0) => fetch(log(addSearchParams(new URL(`${this.webhook.api.href}/sendLocation`), {
+        chat_id: chat_id.toString(),
+        latitude: latitude.toString(),
+        longitude: longitude.toString(),
+        live_period: live_period.toString(),
+        disable_notification: disable_notification.toString(),
+        reply_to_message_id: reply_to_message_id.toString(),
+    }).href));
+    // trigger senPoll command of BotAPI
+    sendPoll = async (chat_id, question, options, is_anonymous = false, type = "", allows_multiple_answers = false, correct_option_id = 0, explanation = "", explanation_parse_mode = "", open_period = 0, close_date = 0, is_closed = false, disable_notification = false, reply_to_message_id = 0) => fetch(log(addSearchParams(new URL(`${this.webhook.api.href}/sendPoll`), {
+        chat_id: chat_id.toString(),
+        question,
+        options: options.toString(),
+        is_anonymous: is_anonymous.toString(),
+        type,
+        allows_multiple_answers: allows_multiple_answers.toString(),
+        correct_option_id: correct_option_id.toString(),
+        explanation: explanation,
+        explanation_parse_mode: explanation_parse_mode,
+        open_period: open_period.toString(),
+        close_date: close_date.toString(),
+        is_closed: is_closed.toString(),
+        disable_notification: disable_notification.toString(),
+        reply_to_message_id: reply_to_message_id.toString(),
+    }).href));
+    // trigger senDice command of BotAPI
+    sendDice = async (chat_id, emoji = "", disable_notification = false, reply_to_message_id = 0) => fetch(log(addSearchParams(new URL(`${this.webhook.api.href}/sendDice`), {
+        chat_id: chat_id.toString(),
+        emoji,
+        disable_notification: disable_notification.toString(),
+        reply_to_message_id: reply_to_message_id.toString(),
+    }).href));
+    // bot api command to get user profile photos
+    getUserProfilePhotos = async (user_id, offset = 0, limit = 0) => fetch(log(addSearchParams(new URL(`${this.webhook.api.href}/getUserProfilePhotos`), {
+        user_id: user_id.toString(),
+        offset: offset.toString(),
+        limit: limit.toString(),
+    }).href));
+}

package/dist/main/src/telegram_bot.d.ts

@@ -0,0 +1,26 @@
+/// <reference types="@cloudflare/workers-types" />
+import TelegramApi from "./telegram_api";
+import { TelegramUpdate, Config, Kv } from "./types";
+export default class TelegramBot extends TelegramApi {
+    url: URL;
+    kv: Kv;
+    get_set: KVNamespace;
+    constructor(config: Config);
+    code: (update: TelegramUpdate) => Promise<Response>;
+    duckduckgo: (update: TelegramUpdate, args: string[]) => Promise<Response>;
+    kanye: (update: TelegramUpdate) => Promise<Response>;
+    joke: (update: TelegramUpdate) => Promise<Response>;
+    dog: (update: TelegramUpdate) => Promise<Response>;
+    cat: (update: TelegramUpdate) => Promise<Response>;
+    bored: (update: TelegramUpdate) => Promise<Response>;
+    epoch: (update: TelegramUpdate) => Promise<Response>;
+    _get: (update: TelegramUpdate, args: string[]) => Promise<Response>;
+    _set: (update: TelegramUpdate, args: string[]) => Promise<Response>;
+    _average: (numbers: number[]) => number;
+    recursion: (update: TelegramUpdate) => Promise<Response>;
+    roll: (update: TelegramUpdate, args: string[]) => Promise<Response>;
+    commandList: (update: TelegramUpdate) => Promise<Response>;
+    toss: (update: TelegramUpdate) => Promise<Response>;
+    ping: (update: TelegramUpdate, args: string[]) => Promise<Response>;
+    getChatInfo: (update: TelegramUpdate) => Promise<Response>;
+}

package/dist/main/src/telegram_bot.js

@@ -0,0 +1,152 @@
+import { preTagString, prettyJSON, addSearchParams, responseToJSON, } from "./libs";
+import TelegramApi from "./telegram_api";
+import { TelegramInlineQueryResultArticle, TelegramInlineQueryResultPhoto, } from "./types";
+export default class TelegramBot extends TelegramApi {
+    url;
+    kv;
+    get_set;
+    constructor(config) {
+        super(config.commands, config.webhook, config.handler);
+        this.url = config.url;
+        this.kv = config.kv;
+        this.get_set = config.kv?.get_set;
+    }
+    // bot command: /code
+    code = async (update) => ((url) => (update.inline_query &&
+        this.answerInlineQuery(update.inline_query.id, [
+            new TelegramInlineQueryResultArticle(url),
+        ])) ??
+        this.sendMessage(update.message?.chat.id ?? 0, url))("https://github.com/codebam/cf-workers-telegram-bot");
+    // bot command: /duckduckgo
+    duckduckgo = async (update, args) => ((query) => ((duckduckgo_url) => (update.inline_query &&
+        query === "" &&
+        this.answerInlineQuery(update.inline_query.id, [
+            new TelegramInlineQueryResultArticle("https://duckduckgo.com"),
+        ])) ||
+        (update.inline_query &&
+            fetch(addSearchParams(new URL("https://api.duckduckgo.com"), {
+                q: query,
+                format: "json",
+                t: "telegram_bot",
+                no_redirect: "1",
+            }).href).then((response) => response
+                .json()
+                .then((results) => results)
+                .then((ddg_response) => ((instant_answer_url, thumb_url, default_thumb_url = "https://duckduckgo.com/assets/icons/meta/DDG-icon_256x256.png") => this.answerInlineQuery(update.inline_query?.id ?? 0, (instant_answer_url !== "" && [
+                new TelegramInlineQueryResultArticle(`${instant_answer_url}\n\n<a href="${addSearchParams(new URL(duckduckgo_url), {
+                    q: args
+                        .slice(1)
+                        .join(" ")
+                        .replace(/^!\w* /, ""),
+                }).href}">Results From DuckDuckGo</a>`, instant_answer_url, "HTML", thumb_url),
+                new TelegramInlineQueryResultArticle(duckduckgo_url, duckduckgo_url, "", default_thumb_url),
+            ]) || [
+                new TelegramInlineQueryResultArticle(duckduckgo_url, duckduckgo_url, "", default_thumb_url),
+            ], 3600 // 1 hour
+            ))(ddg_response.Redirect || ddg_response.AbstractURL, (ddg_response.Redirect === "" &&
+                `https://duckduckgo.com${(ddg_response.Image !== "" && ddg_response.Image) ||
+                    (ddg_response.RelatedTopics.length !== 0 &&
+                        ddg_response.RelatedTopics[0].Icon.URL !== "" &&
+                        ddg_response.RelatedTopics[0].Icon.URL) ||
+                    "/i/f96d4798.png"}`) ||
+                "")))) ||
+        this.sendMessage(update.message?.chat.id ?? 0, duckduckgo_url))((query === "" && "https://duckduckgo.com") ||
+        addSearchParams(new URL("https://duckduckgo.com"), {
+            q: query,
+        }).href))(args.slice(1).join(" "));
+    // bot command: /kanye
+    kanye = async (update) => fetch("https://api.kanye.rest")
+        .then((response) => responseToJSON(response))
+        .then((json) => ((message) => (update.inline_query !== undefined &&
+        this.answerInlineQuery(update.inline_query.id, [
+            new TelegramInlineQueryResultArticle(message),
+        ])) ||
+        this.sendMessage(update.message?.chat.id ?? 0, message))(`Kanye says... ${json.quote}`))
+        .catch(() => new Response("Failed to parse JSON"));
+    // bot command: /joke
+    joke = async (update) => fetch("https://v2.jokeapi.dev/joke/Any?safe-mode")
+        .then((response) => responseToJSON(response))
+        .then((joke) => joke)
+        .then((joke_response) => ((message) => (update.inline_query &&
+        this.answerInlineQuery(update.inline_query.id, [
+            new TelegramInlineQueryResultArticle(message, joke_response.joke ?? joke_response.setup, "HTML"),
+        ], 0)) ??
+        this.sendMessage(update.message?.chat.id ?? 0, message, "HTML"))(joke_response.joke ??
+        `${joke_response.setup}\n\n<tg-spoiler>${joke_response.delivery}</tg-spoiler>`));
+    // bot command: /dog
+    dog = async (update) => fetch("https://shibe.online/api/shibes")
+        .then((response) => response.json())
+        .then((json) => json)
+        .then((shibe_response) => (update.inline_query &&
+        this.answerInlineQuery(update.inline_query.id, [new TelegramInlineQueryResultPhoto(shibe_response[0])], 0)) ??
+        this.sendPhoto(update.message?.chat.id ?? 0, shibe_response[0]));
+    // bot command: /cat
+    cat = async (update) => fetch("https://meow.senither.com/v1/random")
+        .then((response) => response.json())
+        .then((json) => json)
+        .then((json) => (update.inline_query &&
+        this.answerInlineQuery(update.inline_query.id, [new TelegramInlineQueryResultPhoto(json.data.url)], 0)) ??
+        this.sendPhoto(update.message?.chat.id ?? 0, json.data.url));
+    // bot command: /bored
+    bored = async (update) => fetch("https://boredapi.com/api/activity/")
+        .then((response) => responseToJSON(response))
+        .then((json) => json)
+        .then((bored_response) => (update.inline_query &&
+        this.answerInlineQuery(update.inline_query.id, [new TelegramInlineQueryResultArticle(bored_response.activity)], 0)) ??
+        this.sendMessage(update.message?.chat.id ?? 0, bored_response.activity));
+    // bot command: /epoch
+    epoch = async (update) => ((seconds) => (update.inline_query &&
+        this.answerInlineQuery(update.inline_query.id, [new TelegramInlineQueryResultArticle(seconds)], 0)) ??
+        this.sendMessage(update.message?.chat.id ?? 0, seconds))(Math.floor(Date.now() / 1000).toString());
+    // bot command: /get
+    _get = async (update, args) => ((key) => this.get_set
+        .get(key)
+        .then((value) => (update.inline_query &&
+        this.answerInlineQuery(update.inline_query.id, [new TelegramInlineQueryResultArticle(value ?? "")], 0)) ??
+        this.sendMessage(update.message?.chat.id ?? 0, value ?? "")))(args[1]);
+    // bot command: /set
+    _set = async (update, args) => {
+        const key = args[1];
+        const value = args.slice(2).join(" ");
+        const message = `set ${key} to ${value}`;
+        this.get_set.put(key, value).then(() => {
+            if (update.inline_query) {
+                return this.answerInlineQuery(update.inline_query.id, [new TelegramInlineQueryResultArticle(message)], 0);
+            }
+            return this.sendMessage(update.message?.chat.id ?? 0, message);
+        });
+        return new Response();
+    };
+    _average = (numbers) => parseFloat((numbers.reduce((prev, cur) => prev + cur, 0) / numbers.length || 0).toFixed(2));
+    // bot command: /recursion
+    recursion = async (update) => this.sendMessage(update.message?.chat.id ?? 0, "/recursion");
+    // .then((response) => responseToJSON(response))
+    // .then((result: { ok: boolean; result: { text: string } }) =>
+    //   this.handler.postResponse(
+    //     new Request("", {
+    //       method: "POST",
+    //       body: JSON.stringify({
+    //         message: {
+    //           text: result.result.text,
+    //           chat: { id: update.message.chat.id },
+    //         },
+    //       }),
+    //     }),
+    //     this
+    //   )
+    // );
+    // bot command: /roll
+    roll = async (update, args) => ((outcome, message) => (update.inline_query &&
+        this.answerInlineQuery(update.inline_query.id, [
+            new TelegramInlineQueryResultArticle(message(update.inline_query.from.username, update.inline_query.from.first_name, outcome)),
+        ])) ??
+        this.sendMessage(update.message?.chat.id ?? 0, message(update.message?.from.username ?? "", update.message?.from.first_name ?? "", outcome)))(Math.floor(Math.random() * (parseInt(args[1]) || 6 - 1 + 1) + 1), (username, first_name, outcome) => `${first_name ?? username} rolled a ${parseInt(args[1]) || 6} sided die. it landed on ${outcome}`);
+    // bot command: /commandList
+    commandList = async (update) => this.sendMessage(update.message?.chat.id ?? 0, `<pre>${JSON.stringify(Object.keys(this.commands))}</pre>`, "HTML");
+    // bot command: /toss
+    toss = async (update) => this.sendMessage(update.message?.chat.id ?? 0, Math.floor(Math.random() * 2) == 0 ? "heads" : "tails");
+    // bot command: /ping
+    ping = async (update, args) => this.sendMessage(update.message?.chat.id ?? 0, args.length === 1 ? "pong" : args.slice(1).join(" "));
+    // bot command: /chatInfo
+    getChatInfo = async (update) => this.sendMessage(update.message?.chat.id ?? 0, preTagString(prettyJSON(update.message?.chat ?? 0)), "HTML");
+}

package/dist/main/src/telegram_commands.d.ts

@@ -0,0 +1,19 @@
+/// <reference types="@cloudflare/workers-types" />
+import TelegramBot from "./telegram_bot";
+import { TelegramUpdate } from "./types";
+export default class TelegramCommands {
+    static ping: (bot: TelegramBot, update: TelegramUpdate, args: string[]) => Promise<Response>;
+    static toss: (bot: TelegramBot, update: TelegramUpdate) => Promise<Response>;
+    static epoch: (bot: TelegramBot, update: TelegramUpdate) => Promise<Response>;
+    static kanye: (bot: TelegramBot, update: TelegramUpdate) => Promise<Response>;
+    static bored: (bot: TelegramBot, update: TelegramUpdate) => Promise<Response>;
+    static joke: (bot: TelegramBot, update: TelegramUpdate) => Promise<Response>;
+    static dog: (bot: TelegramBot, update: TelegramUpdate) => Promise<Response>;
+    static cat: (bot: TelegramBot, update: TelegramUpdate) => Promise<Response>;
+    static roll: (bot: TelegramBot, update: TelegramUpdate, args: string[]) => Promise<Response>;
+    static _get: (bot: TelegramBot, update: TelegramUpdate, args: string[]) => Promise<Response>;
+    static _set: (bot: TelegramBot, update: TelegramUpdate, args: string[]) => Promise<Response>;
+    static duckduckgo: (bot: TelegramBot, update: TelegramUpdate, args: string[]) => Promise<Response>;
+    static code: (bot: TelegramBot, update: TelegramUpdate) => Promise<Response>;
+    static commandList: (bot: TelegramBot, update: TelegramUpdate) => Promise<Response>;
+}

package/dist/main/src/telegram_commands.js

@@ -0,0 +1,16 @@
+export default class TelegramCommands {
+    static ping = async (bot, update, args) => bot.ping(update, args);
+    static toss = async (bot, update) => bot.toss(update);
+    static epoch = async (bot, update) => bot.epoch(update);
+    static kanye = async (bot, update) => bot.kanye(update);
+    static bored = async (bot, update) => bot.bored(update);
+    static joke = async (bot, update) => bot.joke(update);
+    static dog = async (bot, update) => bot.dog(update);
+    static cat = async (bot, update) => bot.cat(update);
+    static roll = async (bot, update, args) => bot.roll(update, args);
+    static _get = async (bot, update, args) => bot._get(update, args);
+    static _set = async (bot, update, args) => bot._set(update, args);
+    static duckduckgo = async (bot, update, args) => bot.duckduckgo(update, args);
+    static code = async (bot, update) => bot.code(update);
+    static commandList = async (bot, update) => bot.commandList(update);
+}

package/dist/main/src/telegram_webhook.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="@cloudflare/workers-types" />
+import Webhook from "./webhook";
+import { WebhookCommands } from "./types";
+export default class TelegramWebhook extends Webhook {
+    constructor(api: URL, token: string, url: URL);
+    set: (drop_pending_updates?: boolean) => Promise<Response>;
+    get: () => Promise<Response>;
+    delete: () => Promise<Response>;
+    commands: WebhookCommands;
+}

package/dist/main/src/telegram_webhook.js

@@ -0,0 +1,21 @@
+import Webhook from "./webhook";
+import { sha256, addSearchParams, fetch_json } from "./libs";
+export default class TelegramWebhook extends Webhook {
+    constructor(api, token, url) {
+        super(api, token, url);
+    }
+    set = async (drop_pending_updates = true) => sha256(this.token).then((access_key) => fetch_json(addSearchParams(new URL(`${this.api.origin}/setWebhook`), {
+        url: new URL(`${this.url.href}${access_key}`).href,
+        max_connections: "100",
+        allowed_updates: JSON.stringify(["message", "inline_query"]),
+        drop_pending_updates: drop_pending_updates.toString(),
+    })));
+    get = async () => fetch_json(new URL(`${this.api.href}/getWebhookInfo`));
+    delete = async () => fetch_json(new URL(`${this.api.href}/deleteWebhook`));
+    commands = {
+        ...this.commands,
+        set: this.set,
+        get: this.get,
+        delete: this.delete,
+    };
+}

package/dist/main/src/types.d.ts

@@ -0,0 +1,220 @@
+/// <reference types="@cloudflare/workers-types" />
+import BotApi from "./bot_api";
+import Handler from "./handler";
+import TelegramApi from "./telegram_api";
+import Webhook from "./webhook";
+export { Webhook };
+export type Command = (bot: BotApi, update: Update, args?: string[]) => Promise<Response>;
+export type TelegramCommand = (bot: TelegramApi, update: TelegramUpdate, args?: string[]) => Promise<Response>;
+export type Commands = Record<string, Command>;
+export type Kv = Record<string, KVNamespace> | undefined;
+export declare class Config {
+    bot_name: string;
+    api: object;
+    webhook: Webhook;
+    commands: Record<string, Command>;
+    kv: Kv | undefined;
+    url: URL;
+    handler: Handler | undefined;
+    constructor(config?: PartialConfig);
+}
+export type PartialConfig = {
+    bot_name?: string;
+    api?: object;
+    webhook?: Webhook;
+    commands?: Record<string, Command>;
+    kv?: Kv | undefined;
+    url?: URL;
+    handler?: Handler;
+};
+export declare const localhost: URL;
+export declare class WebhookCommands {
+    [key: string]: () => Promise<Response>;
+}
+export type Joke = {
+    error: boolean;
+    category: string;
+    type: string;
+    setup?: string;
+    delivery?: string;
+    joke?: string;
+    flags: {
+        nsfw: boolean;
+        religious: boolean;
+        political: boolean;
+        racist: boolean;
+        sexist: boolean;
+        explicit: boolean;
+    };
+    id: number;
+    safe: boolean;
+    lang: string;
+};
+export type Bored = {
+    activity: string;
+    type: string;
+    participants: number;
+    price: number;
+    link: string;
+    key: string;
+    accessibility: 0;
+};
+export type Balance = Record<string, {
+    final_balance: number;
+    n_tx: number;
+    total_received: number;
+}>;
+export type TelegramFrom = {
+    first_name: string;
+    id: number;
+    is_bot: boolean;
+    language_code: string;
+    username: string;
+};
+export type TelegramChat = {
+    id: number;
+    type: string;
+    title?: string;
+    username?: string;
+    first_name?: string;
+    last_name?: string;
+    bio?: string;
+    has_private_forwards: boolean;
+    description?: string;
+    invite_link?: string;
+    pinned_message?: TelegramMessage;
+    slow_mode_delay?: number;
+    message_auto_delete_time?: number;
+    has_protected_content?: boolean;
+    sticker_set_name?: string;
+    can_set_sticker_set?: boolean;
+    linked_chat_id?: number;
+};
+export type TelegramUser = {
+    id: number;
+    is_bot: boolean;
+    first_name: string;
+    last_name?: string;
+    username?: string;
+    language_code?: string;
+    can_join_groups?: boolean;
+    can_read_all_group_messages?: boolean;
+    supports_inline_queries: boolean;
+};
+export type TelegramMessageEntity = {
+    type: string;
+    offset: number;
+    length: number;
+    url?: string;
+    user?: TelegramUser;
+    language?: string;
+};
+export type TelegramPhotoSize = {
+    file_id: string;
+    file_unique_id: string;
+    width: number;
+    height: number;
+    file_size?: number;
+};
+export type TelegramMessage = {
+    message_id: number;
+    from: TelegramFrom;
+    sender_chat?: TelegramChat;
+    date: number;
+    chat: TelegramChat;
+    forward_from?: TelegramUser;
+    forward_from_chat?: TelegramChat;
+    forward_from_message_id?: number;
+    forward_signature?: string;
+    forward_sender_name?: string;
+    forward_date?: number;
+    is_automatic_forward?: boolean;
+    reply_to_message?: TelegramMessage;
+    via_bot?: TelegramUser;
+    edit_date?: number;
+    has_protected_content?: boolean;
+    media_group_id?: string;
+    author_signature?: string;
+    text?: string;
+    entities?: TelegramMessageEntity[];
+    photo?: TelegramPhotoSize[];
+    caption?: string;
+    caption_entities?: TelegramMessageEntity[];
+    new_chat_members?: TelegramUser[];
+    left_chat_member?: TelegramUser;
+    new_chat_title?: string;
+    delete_chat_photo?: boolean;
+    group_chat_created?: boolean;
+    supergroup_chat_created?: boolean;
+    channel_chat_created?: boolean;
+    migrate_to_chat_id?: number;
+    migrate_from_chat_id?: number;
+    pinned_message?: TelegramMessage;
+    connected_website?: string;
+};
+export type TelegramInputMessageContent = {
+    message_text: string;
+    parse_mode: string;
+};
+export type TelegramInlineQuery = {
+    chat_type: "sender" | "private" | "group" | "supergroup" | "channel";
+    from: TelegramFrom;
+    id: number;
+    offset: string;
+    query: string;
+};
+export declare class Update {
+    [key: string]: unknown;
+}
+export declare class TelegramUpdate extends Update {
+    update_id: number;
+    message?: TelegramMessage;
+    edited_message?: TelegramMessage;
+    channel_post?: TelegramMessage;
+    edited_channel_post?: TelegramMessage;
+    inline_query?: TelegramInlineQuery;
+    constructor(update: PartialTelegramUpdate);
+}
+export type PartialTelegramUpdate = {
+    update_id?: number;
+    message?: TelegramMessage;
+    edited_message?: TelegramMessage;
+    channel_post?: TelegramMessage;
+    edited_channel_post?: TelegramMessage;
+    inline_query?: TelegramInlineQuery;
+};
+export type TelegramInlineQueryType = "article" | "photo" | "gif" | "mpeg4_gif" | "video" | "audio" | "voice" | "document" | "location" | "venue" | "contact" | "game" | "sticker";
+export declare class TelegramInlineQueryResult {
+    type: TelegramInlineQueryType;
+    id: string;
+    constructor(type: TelegramInlineQueryType);
+}
+export declare class TelegramInlineQueryResultPhoto extends TelegramInlineQueryResult {
+    photo_url: string;
+    thumb_url: string;
+    photo_width?: number;
+    photo_height?: number;
+    title?: string;
+    description?: string;
+    caption?: string;
+    parse_mode?: string;
+    caption_entities?: string;
+    constructor(photo: string);
+}
+export declare class TelegramInlineQueryResultArticle extends TelegramInlineQueryResult {
+    title: string;
+    input_message_content: TelegramInputMessageContent;
+    thumb_url: string;
+    constructor(content: string, title?: string, parse_mode?: string, thumb_url?: string);
+}
+export type DDGQueryResponse = {
+    AbstractSource: string;
+    AbstractURL: string;
+    Redirect: string;
+    Image: string;
+    RelatedTopics: {
+        Icon: {
+            URL: string;
+        };
+    }[];
+};

package/dist/main/src/types.js

@@ -0,0 +1,100 @@
+import Webhook from "./webhook";
+export { Webhook };
+export class Config {
+    bot_name;
+    api;
+    webhook;
+    commands;
+    kv;
+    url;
+    handler;
+    constructor(config = {}) {
+        this.bot_name = config.bot_name || "";
+        this.api = config.api || {};
+        this.webhook = config.webhook || new Webhook(localhost, "", localhost);
+        this.commands = config.commands || {};
+        this.kv = config.kv;
+        this.url = config.url || new URL(localhost);
+        this.handler = config.handler;
+    }
+}
+export const localhost = new URL("http://localhost");
+export class WebhookCommands {
+}
+export class Update {
+}
+export class TelegramUpdate extends Update {
+    update_id;
+    message;
+    edited_message;
+    channel_post;
+    edited_channel_post;
+    inline_query;
+    // chosen_inline_result?: TelegramChosenInlineResult;
+    // callback_query?: TelegramCallbackQuery;
+    // shipping_query?: TelegramShippingQuery;
+    // pre_checkout_query?: TelegramPreCheckoutQuery;
+    // poll?: TelegramPoll;
+    // poll_answer?: TelegramPollAnswer;
+    // my_chat_member?: TelegramChatMemberUpdated;
+    // chat_member?: TelegramChatMemberUpdated;
+    // chat_join_request: TelegramChatJoinRequest;
+    constructor(update) {
+        super();
+        this.update_id = update.update_id || 0;
+        this.message = update.message;
+        this.edited_message = update.edited_message;
+        this.channel_post = update.channel_post;
+        this.edited_channel_post = update.edited_channel_post;
+        this.inline_query = update.inline_query;
+        // chosen_inline_result = update.chosen_inline_result;
+        // callback_query = update.callback_query;
+        // shipping_query = update.shipping_query;
+        // pre_checkout_query = update.pre_checkout_query;
+        // poll = update.poll;
+        // poll_answer = update.poll_answer;
+        // my_chat_member = update.my_chat_member;
+        // chat_member = update.chat_member;
+        // chat_join_request = update.chat_join_request;
+    }
+}
+export class TelegramInlineQueryResult {
+    type;
+    id;
+    constructor(type) {
+        this.type = type;
+        this.id = crypto.randomUUID();
+    }
+}
+export class TelegramInlineQueryResultPhoto extends TelegramInlineQueryResult {
+    photo_url; // must be a jpg
+    thumb_url;
+    photo_width;
+    photo_height;
+    title;
+    description;
+    caption;
+    parse_mode;
+    caption_entities;
+    // reply_markup?: TelegramInlineKeyboardMarkup;
+    // input_message_content?: TelegramInputMessageContent;
+    constructor(photo) {
+        super("photo");
+        this.photo_url = photo;
+        this.thumb_url = photo;
+    }
+}
+export class TelegramInlineQueryResultArticle extends TelegramInlineQueryResult {
+    title;
+    input_message_content;
+    thumb_url;
+    constructor(content, title = content, parse_mode = "", thumb_url = "") {
+        super("article");
+        this.title = title;
+        this.input_message_content = {
+            message_text: content.toString(),
+            parse_mode,
+        };
+        this.thumb_url = thumb_url;
+    }
+}

package/dist/main/src/webhook.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="@cloudflare/workers-types" />
+import { WebhookCommands } from "./types";
+export default class Webhook {
+    api: URL;
+    token: string;
+    url: URL;
+    commands: WebhookCommands;
+    constructor(api: URL, token: string, url: URL);
+    process: (url: URL) => Promise<Response>;
+}

package/dist/main/src/webhook.js

@@ -0,0 +1,17 @@
+import { JSONResponse } from "./libs";
+export default class Webhook {
+    api;
+    token;
+    url;
+    commands;
+    constructor(api, token, url) {
+        this.api = api;
+        this.token = token;
+        this.url = url;
+        this.commands = {
+            default: () => new Promise(() => JSONResponse({ error: "Invalid command" }, 400)),
+        };
+    }
+    process = async (url) => this.commands[url.searchParams.get("command") ?? ""]?.() ??
+        this.commands.default;
+}

package/dist/worker/src/worker.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="@cloudflare/workers-types" />
+interface Environment {
+    SECRET_TELEGRAM_API_TOKEN: string;
+    KV_GET_SET: KVNamespace;
+    KV_UID_DATA: KVNamespace;
+    SECRET_TELEGRAM_API_TOKEN2: string;
+    SECRET_TELEGRAM_API_TOKEN3: string;
+}
+declare const _default: {
+    fetch: (request: Request, env: Environment) => Promise<Response>;
+};
+export default _default;

package/dist/worker/src/worker.js

@@ -0,0 +1,53 @@
+import { TelegramCommands, Handler, TelegramWebhook, TelegramBot, } from "../../main/src/main";
+export default {
+    fetch: async (request, env) => new Handler([
+        {
+            bot_name: "cf-workers-telegram-bot",
+            api: TelegramBot,
+            webhook: new TelegramWebhook(new URL(`https://api.telegram.org/bot${env.SECRET_TELEGRAM_API_TOKEN}`), env.SECRET_TELEGRAM_API_TOKEN, new URL(new URL(request.url).origin)),
+            commands: {
+                "/ping": TelegramCommands.ping,
+                "/toss": TelegramCommands.toss,
+                "/epoch": TelegramCommands.epoch,
+                "/kanye": TelegramCommands.kanye,
+                "/bored": TelegramCommands.bored,
+                "/joke": TelegramCommands.joke,
+                "/dog": TelegramCommands.dog,
+                "/cat": TelegramCommands.cat,
+                "/roll": TelegramCommands.roll,
+                "/get": TelegramCommands._get,
+                "/set": TelegramCommands._set,
+                "/duckduckgo": TelegramCommands.duckduckgo,
+                "/code": TelegramCommands.code,
+                "/commands": TelegramCommands.commandList,
+                "/help": TelegramCommands.commandList,
+                "/start": TelegramCommands.commandList,
+            },
+            kv: { get_set: env.KV_GET_SET, uid_data: env.KV_UID_DATA },
+        },
+        {
+            bot_name: "@duckduckbot",
+            api: TelegramBot,
+            webhook: new TelegramWebhook(new URL(`https://api.telegram.org/bot${env.SECRET_TELEGRAM_API_TOKEN2}`), env.SECRET_TELEGRAM_API_TOKEN2, new URL(new URL(request.url).origin)),
+            commands: {
+                inline: TelegramCommands.duckduckgo,
+                "/duckduckgo": TelegramCommands.duckduckgo,
+                "/code": TelegramCommands.code,
+                "/commands": TelegramCommands.commandList,
+                "/start": TelegramCommands.commandList,
+            },
+        },
+        {
+            bot_name: "@ddggbot",
+            api: TelegramBot,
+            webhook: new TelegramWebhook(new URL(`https://api.telegram.org/bot${env.SECRET_TELEGRAM_API_TOKEN3}`), env.SECRET_TELEGRAM_API_TOKEN3, new URL(new URL(request.url).origin)),
+            commands: {
+                inline: TelegramCommands.duckduckgo,
+                "/duckduckgo": TelegramCommands.duckduckgo,
+                "/code": TelegramCommands.code,
+                "/commands": TelegramCommands.commandList,
+                "/start": TelegramCommands.commandList,
+            },
+        },
+    ]).handle(request),
+};

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@codebam/cf-workers-telegram-bot",
-	"version": "3.42.0",
+	"version": "3.45.0",
 	"description": "serverless telegram bot on cf workers",
 	"main": "./dist/main/src/main.js",
 	"module": "./dist/main/src/main.js",
@@ -29,7 +29,7 @@
 		"url": "https://github.com/codebam/cf-workers-telegram-bot.git"
 	},
 	"dependencies": {
-		"worker": "^3.41.0"
+		"worker": "^3.44.0"
 	},
 	"devDependencies": {
 		"@cloudflare/workers-types": "^4.20230215.0",
@@ -39,5 +39,5 @@
 		"prettier": "^2.8.4",
 		"typescript": "^4.9.5"
 	},
-	"gitHead": "fdcb8030fee21b99df261eb4197370d87862f662"
+	"gitHead": "be956bd06e29a9fea3daf4d85153533544188c0c"
 }