@codebam/cf-workers-telegram-bot 7.19.0 → 7.20.0

package/dist/main/src/commands/sean.js

@@ -0,0 +1,76 @@
+import { TelegramInlineQueryResultArticle } from '../types';
+export default async (self, update, args) => {
+    if (self.ai === undefined) {
+        return new Response('ok');
+    }
+    let _prompt;
+    if (args[0][0] === '/') {
+        _prompt = args.slice(1).join(' ');
+    }
+    else {
+        _prompt = args.join(' ');
+    }
+    if (_prompt === '') {
+        _prompt = '';
+    }
+    const results = await (async () => {
+        if (self.db) {
+            const { results } = await self.db
+                .prepare('SELECT * FROM Messages WHERE userId=?')
+                .bind(update.inline_query ? update.inline_query.from.id : update.message?.from.id)
+                .all();
+            return results;
+        }
+    })();
+    const old_messages = (() => {
+        if (results) {
+            return results.map((col) => ({
+                role: 'system',
+                content: col.content,
+            }));
+        }
+        return [];
+    })();
+    const system_prompt = '<s>' +
+        [
+            `Your name is ${self.bot_name}.`,
+            `You are talking to ${update.message?.from.first_name}.`,
+            `Your source code is at https://github.com/codebam/cf-workers-telegram-bot .`,
+            `the current date is ${new Date().toString()}`,
+            'Sean Behan is a full stack developer who goes by the username codebam.',
+            'Sean Behan likes programming and video games.',
+            "Pretend to be Sean Behan but don't make things up.",
+        ].reduce((acc, cur) => {
+            return acc + cur + '\n';
+        }) +
+        old_messages.reduce((acc, cur) => {
+            return acc + cur.content + '\n';
+        }, '') +
+        '</s>';
+    const p = system_prompt + '[INST]' + _prompt + '[/INST]';
+    const prompt = p.slice(p.length - 4096, p.length);
+    const response = await self.ai
+        // @ts-expect-error model might not match
+        .run(self.chat_model, {
+        prompt,
+        max_tokens: 596,
+    })
+        /* eslint-disable  @typescript-eslint/no-explicit-any */
+        .then(({ response }) => response
+        .replace(/(\[|)(\/|)INST(S|)(s|)(\]|)/, '')
+        .replace(/<<(\/|)SYS>>/, '')
+        .replace(/[OUT]/, ''));
+    if (self.db) {
+        const { success } = await self.db
+            .prepare('INSERT INTO Messages (id, userId, content) VALUES (?, ?, ?)')
+            .bind(crypto.randomUUID(), update.inline_query ? update.inline_query.from.id : update.message?.from.id, '[INST] ' + _prompt + ' [/INST]' + '\n' + response)
+            .run();
+        if (!success) {
+            console.log('failed to insert data into d1');
+        }
+    }
+    if (update.inline_query) {
+        return self.answerInlineQuery(update.inline_query.id, [new TelegramInlineQueryResultArticle(response)]);
+    }
+    return self.sendMessage(update.message?.chat.id ?? 0, response, '', false, false, update.message?.message_id);
+};

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

@@ -0,0 +1,5 @@
+/// <reference types="@cloudflare/workers-types" />
+import TelegramBot from '../telegram_bot';
+import { TelegramUpdate } from '../types';
+declare const _default: (self: TelegramBot, update: TelegramUpdate) => Promise<Response>;
+export default _default;

package/dist/main/src/commands/start.js

@@ -0,0 +1 @@
+export default async (self, update) => self.sendMessage(update.message?.chat.id ?? 0, `Hello, send me a message to start chatting with ${self.chat_model}`);

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

@@ -0,0 +1,5 @@
+/// <reference types="@cloudflare/workers-types" />
+import TelegramBot from '../telegram_bot';
+import { TelegramUpdate } from '../types';
+declare const _default: (self: TelegramBot, update: TelegramUpdate) => Promise<Response>;
+export default _default;

package/dist/main/src/commands/toss.js

@@ -0,0 +1 @@
+export default async (self, update) => self.sendMessage(update.message?.chat.id ?? 0, Math.floor(Math.random() * 2) == 0 ? 'heads' : 'tails');

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

@@ -0,0 +1,5 @@
+/// <reference types="@cloudflare/workers-types" />
+import TelegramBot from '../telegram_bot';
+import { TelegramUpdate } from '../types';
+declare const _default: (self: TelegramBot, update: TelegramUpdate, args: string[]) => Promise<Response>;
+export default _default;

package/dist/main/src/commands/translate.js

@@ -0,0 +1,26 @@
+import { TelegramInlineQueryResultArticle } from '../types';
+export default async (self, update, args) => {
+    if (self.ai === undefined) {
+        return new Response('ok');
+    }
+    let _prompt;
+    if (args[0][0] === '/') {
+        _prompt = args.slice(1).join(' ');
+    }
+    else {
+        _prompt = args.join(' ');
+    }
+    if (_prompt === '') {
+        _prompt = '';
+    }
+    const langs = ['french'];
+    const inline_articles = await Promise.all(langs.map(async (lang) => {
+        const response = await self.ai.run('@cf/meta/m2m100-1.2b', {
+            text: _prompt,
+            source_lang: lang,
+            target_lang: 'english',
+        });
+        return new TelegramInlineQueryResultArticle(response.translated_text, response.translated_text);
+    }));
+    return self.answerInlineQuery(update.inline_query?.id ?? 0, inline_articles);
+};

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

@@ -0,0 +1,12 @@
+/// <reference types="@cloudflare/workers-types" />
+import BotApi from './bot_api';
+import { Config } from './types';
+export default class Handler {
+    configs: Partial<Config>[];
+    constructor(configs: Partial<Config>[]);
+    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: Partial<Config>[]) => Promise<Record<string, Config> | Record<string, never>>;
+    handle: (request: Request) => Promise<Response>;
+}

package/dist/main/src/handler.js

@@ -0,0 +1,40 @@
+import { sha256, log } from './libs';
+import { Config, 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} ${((request_url) => `${request_url.origin}${request_url.pathname}`)(new URL(_request?.url ?? localhost))}${key}`)));
+        if (_bot?.webhook.token) {
+            return _bot.webhook.process(new URL(_request?.url ?? localhost));
+        }
+        return this.responses.default();
+    };
+    postResponse = async (_request, _bot) => _bot?.webhook.token === ''
+        ? this.responses.default()
+        : _request
+            ? _request.json().then((update) => _bot.update(update))
+            : this.responses.default();
+    responses = {
+        GET: this.getResponse,
+        POST: this.postResponse,
+        default: () => new Promise(() => new Response()),
+    };
+    getAccessKeys = async (configs) => Promise.all(configs.map((bot_config) => sha256(bot_config.webhook?.token ?? '').then((hash) => {
+        console.log(hash);
+        return [hash, bot_config];
+    }))).then((result) => Object.fromEntries(result));
+    // handles the request
+    handle = async (request) => this.getAccessKeys(this.configs).then((access_keys) => Object.keys(this.responses).includes(request.method)
+        ? this.responses[request.method](request, ((key) => {
+            return new access_keys[key].api({
+                ...new Config(),
+                ...access_keys[key],
+                url: new URL(new URL(request.url).origin), // worker url
+                handler: this,
+            });
+        })(new URL(request.url).pathname.substring(1)))
+        : this.responses.default());
+}

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

@@ -0,0 +1,5 @@
+/// <reference types="@cloudflare/workers-types" />
+export declare const sha256: (text: string) => Promise<string>;
+export declare const log: (obj: any) => any;
+export declare const addSearchParams: (url: URL, params?: Record<string, string>) => URL;
+export declare const undefinedEmpty: <T>(obj: T) => (T & ({} | null))[];

package/dist/main/src/libs.js

@@ -0,0 +1,7 @@
+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(''));
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const log = (obj) => console.log(obj) === undefined && obj;
+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 undefinedEmpty = (obj) => (obj === undefined ? [] : [obj]);

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

@@ -0,0 +1,4 @@
+import TelegramBot from './telegram_bot';
+import * as Types from './types';
+import worker from '../../worker/src/worker';
+export { TelegramBot, Types, worker };

package/dist/main/src/main.js

@@ -0,0 +1,4 @@
+import TelegramBot from './telegram_bot';
+import * as Types from './types';
+import worker from '../../worker/src/worker';
+export { TelegramBot, Types, worker };

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

@@ -0,0 +1,34 @@
+/// <reference types="@cloudflare/workers-types" />
+import BotApi from './bot_api';
+import { Commands, TelegramInlineQueryResult, TelegramUpdate, Webhook, Update, ChatPermissions } 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>;
+    editMessageText: (chat_id: number, message_id: number, text: string) => 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>;
+    sendPhotoRaw: (chat_id: number, photo: File, caption?: string, parse_mode?: string, disable_notification?: boolean, reply_to_message_id?: number) => Promise<any>;
+    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>;
+    banChatMember: (chat_id: number | string, user_id: number, until_date?: number, revoke_messages?: boolean) => Promise<Response>;
+    restrictChatMember: (chat_id: number | string, user_id: number, permissions: ChatPermissions, use_independent_chat_permissions: boolean, until_date: number) => Promise<Response>;
+}

package/dist/main/src/telegram_api.js

@@ -0,0 +1,192 @@
+import BotApi from './bot_api';
+import { addSearchParams, log } from './libs';
+export default class TelegramApi extends BotApi {
+    constructor(commands, webhook, handler) {
+        super({ commands, webhook, handler });
+    }
+    inlineQueryUpdate = async (update) => this.executeInlineCommand(update);
+    messageUpdate = async (update) => {
+        if (update.message) {
+            await this.greetUsers(update);
+            await this.executeCommand(update);
+        }
+        return this.updates.default;
+    };
+    updates = {
+        inline_query: this.inlineQueryUpdate,
+        message: this.messageUpdate,
+        default: new Response(),
+    };
+    update = async (update) => {
+        console.log({ update });
+        if (update) {
+            if (update.inline_query) {
+                if (update.inline_query.query !== '') {
+                    return this.updates.inline_query(update);
+                }
+            }
+            else {
+                if (update.message) {
+                    return this.updates.message(update);
+                }
+            }
+        }
+        return this.updates.default;
+    };
+    // greet new users who join
+    greetUsers = async (update) => update.message?.new_chat_members
+        ? this.sendMessage(update.message.chat.id, `Welcome to ${update.message.chat.title}, @${update.message.new_chat_member?.username}`)
+        : this.updates.default;
+    getCommand = (args) => args[0]?.split('@')[0];
+    // run command passed from executeCommand
+    _executeCommand = async (update, text, args = []) => log({ execute: { text, args } })
+        ? ((text_args) => ((command) => this.commands[command]
+            ? this.commands[command]?.(this, update, [...text_args, ...args])
+            : log({
+                error: `command '${command}' does not exist, using default`,
+            }) && this.commands['default']?.(this, update, [...text_args, ...args]))(
+        // run the command
+        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) => this._executeCommand(update, update.inline_query?.query ?? '').then(async (command_response) => command_response
+        ? this._executeCommand(update, 'inline', update.inline_query?.query.trimStart().split(' ')).then((_command_response) => _command_response)
+        : 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.origin}${this.webhook.api.pathname}/answerInlineQuery`), {
+        inline_query_id: inline_query_id.toString(),
+        results: JSON.stringify(results),
+        cache_time: cache_time.toString(),
+    }).href));
+    // trigger editMessage command of BotAPI
+    editMessageText = async (chat_id, message_id, text) => fetch(log(addSearchParams(new URL(`${this.webhook.api.origin}${this.webhook.api.pathname}/editMessageText`), {
+        chat_id: chat_id.toString(),
+        message_id: message_id.toString(),
+        text,
+    }).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.origin}${this.webhook.api.pathname}/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.origin}${this.webhook.api.pathname}/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
+    sendPhotoRaw = async (chat_id, photo, caption = '', parse_mode = '', disable_notification = false, reply_to_message_id = 0) => {
+        const formdata = new FormData();
+        formdata.set('file', photo);
+        return fetch(log(addSearchParams(new URL(`${this.webhook.api.origin}${this.webhook.api.pathname}/sendPhoto`), {
+            chat_id: chat_id.toString(),
+            caption,
+            parse_mode,
+            disable_notification: disable_notification.toString(),
+            reply_to_message_id: reply_to_message_id.toString(),
+        }).href), { method: 'POST', body: formdata })
+            .then((resp) => resp.text())
+            .then(log);
+    };
+    // 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.origin}${this.webhook.api.pathname}/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.origin}${this.webhook.api.pathname}/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.origin}${this.webhook.api.pathname}/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.origin}${this.webhook.api.pathname}/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.origin}${this.webhook.api.pathname}/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.origin}${this.webhook.api.pathname}/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.origin}${this.webhook.api.pathname}/getUserProfilePhotos`), {
+        user_id: user_id.toString(),
+        offset: offset.toString(),
+        limit: limit.toString(),
+    }).href));
+    banChatMember = async (chat_id, user_id, until_date = 0, revoke_messages = false) => fetch(log(addSearchParams(new URL(`${this.webhook.api.origin}${this.webhook.api.pathname}/banChatMember`), {
+        chat_id: chat_id.toString(),
+        user_id: user_id.toString(),
+        until_date: until_date.toString(),
+        revoke_messages: revoke_messages.toString(),
+    }).href));
+    restrictChatMember = async (chat_id, user_id, permissions, use_independent_chat_permissions, until_date) => fetch(log(addSearchParams(new URL(`${this.webhook.api.origin}${this.webhook.api.pathname}/restrictChatMember`), {
+        chat_id: chat_id.toString(),
+        user_id: user_id.toString(),
+        permissions: JSON.stringify(permissions),
+        use_independent_chat_permissions: use_independent_chat_permissions.toString(),
+        until_date: until_date.toString(),
+    }).href));
+}

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

@@ -0,0 +1,20 @@
+/// <reference types="@cloudflare/workers-types" />
+import { TelegramUpdate } from './types';
+export default class TelegramBot {
+    token: string;
+    webhook: Webhook;
+    update: TelegramUpdate;
+    api: URL;
+    update_type: string;
+    constructor(token: string);
+    on(event: string, callback: () => Promise<Response>): this;
+    handle(request: Request): Promise<any>;
+    reply(message: string): Promise<void>;
+}
+declare class Webhook {
+    api: URL;
+    webhook: URL;
+    constructor(token: string, request: Request);
+    set(): Promise<Response>;
+}
+export {};

package/dist/main/src/telegram_bot.js

@@ -0,0 +1,116 @@
+import { TelegramInlineQueryResultArticle, TelegramUpdate } from './types';
+export default class TelegramBot {
+    token;
+    webhook;
+    update;
+    api;
+    update_type;
+    constructor(token) {
+        this.token = token;
+        this.webhook = new Webhook('', new Request('http://127.0.0.1'));
+        this.update = new TelegramUpdate({});
+        this.api = new URL('https://api.telegram.org/bot' + token);
+        this.update_type = '';
+    }
+    on(event, callback) {
+        if (event !== 'on') {
+            // eslint-disable-next-line
+            // @ts-ignore TS7053
+            this[event] = callback;
+        }
+        return this;
+    }
+    async handle(request) {
+        this.webhook = new Webhook(this.token, request);
+        if (request.method === 'POST') {
+            this.update = await request.json();
+        }
+        const url = new URL(request.url);
+        if (`/${this.token}` === url.pathname) {
+            switch (url.searchParams.get('command')) {
+                case 'set':
+                    return this.webhook.set();
+                default:
+                    break;
+            }
+            console.log(this.update);
+            if (this.update.message?.text) {
+                this.update_type = 'message';
+            }
+            else if (this.update.inline_query?.query) {
+                this.update_type = 'inline';
+            }
+            let command = 'default';
+            let args = [];
+            switch (this.update_type) {
+                case 'message': {
+                    // @ts-expect-error already checked above
+                    args = this.update.message.text.split(' ');
+                    break;
+                }
+                case 'inline': {
+                    // @ts-expect-error already checked above
+                    args = this.update.inline_query.query.split(' ');
+                    break;
+                }
+                default:
+                    break;
+            }
+            if (args.at(0)?.startsWith('/')) {
+                // @ts-expect-error already checked above
+                command = args.at(0).slice(1);
+            }
+            // eslint-disable-next-line
+            // @ts-ignore
+            if (!this[command] || command === 'on') {
+                command = 'default';
+            }
+            // eslint-disable-next-line
+            // @ts-ignore
+            return this[command]?.();
+        }
+        return new Response('ok');
+    }
+    async reply(message) {
+        switch (this.update_type) {
+            case 'message': {
+                const request = new URL(this.api + '/sendMessage');
+                const params = new URLSearchParams();
+                params.append('chat_id', this.update.message?.chat.id.toString() ?? '');
+                params.append('reply_to_message_id', this.update.message?.message_id.toString() ?? '');
+                params.append('text', message);
+                console.log(`${request}?${params}`);
+                await fetch(`${request}?${params}`);
+                break;
+            }
+            case 'inline': {
+                const inline_request = new URL(this.api + '/answerInlineQuery');
+                const inline_params = new URLSearchParams();
+                inline_params.append('inline_query_id', this.update.inline_query?.id.toString() ?? '');
+                inline_params.append('results', JSON.stringify([new TelegramInlineQueryResultArticle(message)]));
+                console.log(`${inline_request}?${inline_params}`);
+                await fetch(`${inline_request}?${inline_params}`);
+                break;
+            }
+            default:
+                break;
+        }
+    }
+}
+class Webhook {
+    api;
+    webhook;
+    constructor(token, request) {
+        this.api = new URL('https://api.telegram.org/bot' + token);
+        this.webhook = new URL(new URL(request.url).origin + `/${token}`);
+    }
+    async set() {
+        const url = new URL(`${this.api.origin}${this.api.pathname}/setWebhook`);
+        const params = url.searchParams;
+        params.append('url', this.webhook.toString());
+        params.append('max_connections', '100');
+        params.append('allowed_updates', JSON.stringify(['message', 'inline_query']));
+        params.append('drop_pending_updates', 'true');
+        return await fetch(`${url}?${params}`);
+    }
+}

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

@@ -0,0 +1,22 @@
+import { TelegramCommand } from './types';
+export default class TelegramCommands {
+    static ping: TelegramCommand;
+    static toss: TelegramCommand;
+    static epoch: TelegramCommand;
+    static kanye: TelegramCommand;
+    static bored: TelegramCommand;
+    static joke: TelegramCommand;
+    static dog: TelegramCommand;
+    static roll: TelegramCommand;
+    static duckduckgo: TelegramCommand;
+    static question: TelegramCommand;
+    static sean: TelegramCommand;
+    static clear: TelegramCommand;
+    static code: TelegramCommand;
+    static commandList: TelegramCommand;
+    static image: TelegramCommand;
+    static translate: TelegramCommand;
+    static start: TelegramCommand;
+    static ban: TelegramCommand;
+    static mute: TelegramCommand;
+}

package/dist/main/src/telegram_commands.js

@@ -0,0 +1,21 @@
+export default class TelegramCommands {
+    static ping = async (bot, update, args) => bot.ping(bot, update, args);
+    static toss = async (bot, update) => bot.toss(bot, update);
+    static epoch = async (bot, update) => bot.epoch(bot, update);
+    static kanye = async (bot, update) => bot.kanye(bot, update);
+    static bored = async (bot, update) => bot.bored(bot, update);
+    static joke = async (bot, update) => bot.joke(bot, update);
+    static dog = async (bot, update) => bot.dog(bot, update);
+    static roll = async (bot, update, args) => bot.roll(bot, update, args);
+    static duckduckgo = async (bot, update, args) => bot.duckduckgo(bot, update, args);
+    static question = async (bot, update, args) => bot.question(bot, update, args);
+    static sean = async (bot, update, args) => bot.sean(bot, update, args);
+    static clear = async (bot, update) => bot.clear(bot, update);
+    static code = async (bot, update) => bot.code(bot, update);
+    static commandList = async (bot, update) => bot.commandList(bot, update);
+    static image = async (bot, update, args) => bot.image(bot, update, args);
+    static translate = async (bot, update, args) => bot.translate(bot, update, args);
+    static start = async (bot, update) => bot.start(bot, update);
+    static ban = async (bot, update) => bot.ban(bot, update);
+    static mute = async (bot, update) => bot.mute(bot, 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;
+}