@codebam/cf-workers-telegram-bot 6.5.0 → 7.3.0

package/README.md

@@ -6,15 +6,16 @@
 
 serverless telegram bot on cf workers
 
-The original `worker.js` is the content of Nikhil John's
-https://github.com/nikhiljohn10/telegram-bot-worker which is licensed with MIT.
-My modifications are licensed under the Apache license.
+To get continuous conversation with AI working make sure you add a database
+to your wrangler.toml and initailize it with the schema.sql
 
-The first bot configuration is fully featured, and responds to all received
-messages with llama2 if a command isn't found.
+```sh
+npm i @codebam/cf-workers-telegram-bot
+```
 
-To get continuous conversation with llama2 working make sure you add a database
-to your wrangler.toml and initailize it with the schema.sql
+See `worker.ts` and follow the instructions below.
+
+---
 
 To use the deploy button:
 
@@ -45,19 +46,4 @@ To fork this repo and use wrangler:
 
 ## Getting started with cf-workers-telegram-bot
 
-Once you've deployed the bot you can get your Webhook command URL by doing any
-of the following.
-
-- sha256sum(SECRET_TELEGRAM_API_TOKEN) is the path to your webhook commands and
-  should be put at the end of your worker URL to access commands such as
-  setting your webhook
-- Use `echo -n yoursecretkey | sha256sum` to get the path
-- Open the Cloudflare Worker Logs under **Workers > cf-workers-telegram-bot
-  > Logs > Begin log stream** and make a GET request (open it in your browser)
-  to your Worker URL and look at the logs to see your Access URL
-- Run `wrangler tail --format pretty` from inside your git repository and make
-  a GET request to your Worker URL
-
-Example URL for setting the Webhook and dropping pending updates:
-
-`https://cf-workers-telegram-bot.codebam.workers.dev/a948904f2f0f479b8f8197694b30184b0d2ed1c1cd2a1ec0fb85d299a192a447?command=set`
+Once you've deployed the bot you can get your Webhook command URL by calling `await bot.webhook.set()`

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

@@ -1,11 +1,4 @@
-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 };
+export { TelegramBot, Types, worker };

package/dist/main/src/main.js

@@ -1,11 +1,4 @@
-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 };
+export { TelegramBot, Types, worker };

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

@@ -1,34 +1,20 @@
 /// <reference types="@cloudflare/workers-types" />
-import TelegramApi from './telegram_api';
-import { Config, Kv, TelegramUpdate } from './types';
-export default class TelegramBot extends TelegramApi {
-    translate: (self: TelegramBot, update: TelegramUpdate, args: string[]) => Promise<Response>;
-    clear: (self: TelegramBot, update: TelegramUpdate) => Promise<Response>;
-    image: (self: TelegramBot, update: TelegramUpdate, args: string[]) => Promise<Response>;
-    question: (self: TelegramBot, update: TelegramUpdate, args: string[]) => Promise<Response>;
-    sean: (self: TelegramBot, update: TelegramUpdate, args: string[]) => Promise<Response>;
-    code: (self: TelegramBot, update: TelegramUpdate) => Promise<Response>;
-    duckduckgo: (self: TelegramBot, update: TelegramUpdate, args: string[]) => Promise<Response>;
-    kanye: (self: TelegramBot, update: TelegramUpdate) => Promise<Response>;
-    joke: (self: TelegramBot, update: TelegramUpdate) => Promise<Response>;
-    dog: (self: TelegramBot, update: TelegramUpdate) => Promise<Response>;
-    bored: (self: TelegramBot, update: TelegramUpdate) => Promise<Response>;
-    epoch: (self: TelegramBot, update: TelegramUpdate) => Promise<Response>;
-    roll: (self: TelegramBot, update: TelegramUpdate, args: string[]) => Promise<Response>;
-    commandList: (self: TelegramBot, update: TelegramUpdate) => Promise<Response>;
-    toss: (self: TelegramBot, update: TelegramUpdate) => Promise<Response>;
-    ping: (self: TelegramBot, update: TelegramUpdate, args: string[]) => Promise<Response>;
-    getChatInfo: (self: TelegramBot, update: TelegramUpdate) => Promise<Response>;
-    start: (self: TelegramBot, update: TelegramUpdate) => Promise<Response>;
-    ban: (self: TelegramBot, update: TelegramUpdate) => Promise<Response>;
-    mute: (self: TelegramBot, update: TelegramUpdate) => Promise<Response>;
-    url: URL;
-    kv: Kv;
-    get_set: KVNamespace;
-    ai: Ai;
-    db: D1Database;
-    r2: R2Bucket;
-    bot_name: string;
-    chat_model: string;
-    constructor(config: Config);
+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

@@ -1,82 +1,114 @@
-import TelegramApi from './telegram_api';
-import translate from './commands/translate';
-import clear from './commands/clear';
-import image from './commands/image';
-import question from './commands/question';
-import sean from './commands/sean';
-import code from './commands/code';
-import duckduckgo from './commands/duckduckgo';
-import kanye from './commands/kanye';
-import joke from './commands/joke';
-import dog from './commands/dog';
-import bored from './commands/bored';
-import epoch from './commands/epoch';
-import roll from './commands/roll';
-import commandlist from './commands/commandlist';
-import toss from './commands/toss';
-import ping from './commands/ping';
-import getchatinfo from './commands/getchatinfo';
-import start from './commands/start';
-import ban from './commands/ban';
-import mute from './commands/mute';
-export default class TelegramBot extends TelegramApi {
-    translate;
-    clear;
-    image;
-    question;
-    sean;
-    code;
-    duckduckgo;
-    kanye;
-    joke;
-    dog;
-    bored;
-    epoch;
-    roll;
-    commandList;
-    toss;
-    ping;
-    getChatInfo;
-    start;
-    ban;
-    mute;
-    url;
-    kv;
-    get_set;
-    ai;
-    db;
-    r2;
-    bot_name;
-    chat_model;
-    constructor(config) {
-        super(config.commands, config.webhook, config.handler);
-        this.translate = translate;
-        this.clear = clear;
-        this.image = image;
-        this.question = question;
-        this.sean = sean;
-        this.code = code;
-        this.duckduckgo = duckduckgo;
-        this.kanye = kanye;
-        this.joke = joke;
-        this.dog = dog;
-        this.bored = bored;
-        this.epoch = epoch;
-        this.roll = roll;
-        this.commandList = commandlist;
-        this.toss = toss;
-        this.ping = ping;
-        this.getChatInfo = getchatinfo;
-        this.start = start;
-        this.ban = ban;
-        this.mute = mute;
-        this.url = config.url;
-        this.kv = config.kv;
-        this.get_set = config.kv?.get_set;
-        this.ai = config.ai;
-        this.db = config.db;
-        this.r2 = config.r2;
-        this.bot_name = config.bot_name;
-        this.chat_model = config.chat_model;
+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) {
+        // 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 = '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/types.d.ts

@@ -1,9 +1,5 @@
-import Webhook from './webhook';
-import Command from './types/Command';
 import TelegramCommand from './types/TelegramCommand';
-import Commands from './types/Commands';
 import Kv from './types/Kv';
-import Config from './types/Config';
 import localhost from './types/localhost';
 import WebhookCommands from './types/WebhookCommands';
 import Joke from './types/Joke';
@@ -27,4 +23,4 @@ import TelegramInlineQueryResultArticle from './types/TelegramInlineQueryResultA
 import DDGQueryResponse from './types/DDGQueryResponse';
 import ChatPermissions from './types/ChatPermissions';
 import Kanye from './types/Kanye';
-export { Webhook, Command, TelegramCommand, Commands, Kv, Config, localhost, WebhookCommands, Joke, Bored, Balance, TelegramFrom, TelegramChat, TelegramUser, TelegramMessageEntity, TelegramPhotoSize, TelegramMessage, TelegramInputMessageContent, TelegramInlineQuery, Update, TelegramUpdate, PartialTelegramUpdate, TelegramInlineQueryType, TelegramInlineQueryResult, TelegramInlineQueryResultPhoto, TelegramInlineQueryResultArticle, DDGQueryResponse, ChatPermissions, Kanye, };
+export { TelegramCommand, Kv, localhost, WebhookCommands, Joke, Bored, Balance, TelegramFrom, TelegramChat, TelegramUser, TelegramMessageEntity, TelegramPhotoSize, TelegramMessage, TelegramInputMessageContent, TelegramInlineQuery, Update, TelegramUpdate, PartialTelegramUpdate, TelegramInlineQueryType, TelegramInlineQueryResult, TelegramInlineQueryResultPhoto, TelegramInlineQueryResultArticle, DDGQueryResponse, ChatPermissions, Kanye, };

package/dist/main/src/types.js

@@ -1,5 +1,3 @@
-import Webhook from './webhook';
-import Config from './types/Config';
 import localhost from './types/localhost';
 import WebhookCommands from './types/WebhookCommands';
 import Update from './types/Update';
@@ -7,4 +5,4 @@ import TelegramUpdate from './types/TelegramUpdate';
 import TelegramInlineQueryResult from './types/TelegramInlineQueryResult';
 import TelegramInlineQueryResultPhoto from './types/TelegramInlineQueryResultPhoto';
 import TelegramInlineQueryResultArticle from './types/TelegramInlineQueryResultArticle';
-export { Webhook, Config, localhost, WebhookCommands, Update, TelegramUpdate, TelegramInlineQueryResult, TelegramInlineQueryResultPhoto, TelegramInlineQueryResultArticle, };
+export { localhost, WebhookCommands, Update, TelegramUpdate, TelegramInlineQueryResult, TelegramInlineQueryResultPhoto, TelegramInlineQueryResultArticle, };

package/dist/worker/src/worker.js

@@ -1,94 +1,81 @@
-import { TelegramCommands, Handler, TelegramWebhook, TelegramBot } from '../../main/src/main';
+import TelegramBot from '../../main/src/telegram_bot';
 export default {
-    fetch: async (request, env) => new Handler([
-        {
-            bot_name: '@TuxRobot',
-            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: {
-                default: TelegramCommands.question,
-                inline: TelegramCommands.question,
-                '/ping': TelegramCommands.ping,
-                '/toss': TelegramCommands.toss,
-                '/epoch': TelegramCommands.epoch,
-                '/kanye': TelegramCommands.kanye,
-                '/bored': TelegramCommands.bored,
-                '/joke': TelegramCommands.joke,
-                '/dog': TelegramCommands.dog,
-                '/roll': TelegramCommands.roll,
-                '/duckduckgo': TelegramCommands.duckduckgo,
-                '/code': TelegramCommands.code,
-                '/commands': TelegramCommands.commandList,
-                '/question': TelegramCommands.question,
-                '/clear': TelegramCommands.clear,
-                '/help': TelegramCommands.commandList,
-                '/image': TelegramCommands.image,
-                '/start': TelegramCommands.start,
-                '/ban': TelegramCommands.ban,
-                '/mute': TelegramCommands.mute,
-            },
-            kv: { get_set: env.KV_GET_SET, uid_data: env.KV_UID_DATA },
-            ai: env.AI,
-            db: env.DB,
-            r2: env.R2,
-            chat_model: env.CHAT_MODEL,
-        },
-        {
-            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: {
-                default: TelegramCommands.duckduckgo,
-                inline: TelegramCommands.duckduckgo, // default inline response
-                '/duckduckgo': TelegramCommands.duckduckgo,
-                '/question': TelegramCommands.question,
-                '/code': TelegramCommands.code,
-                '/commands': TelegramCommands.commandList,
-                '/help': TelegramCommands.commandList,
-                '/start': TelegramCommands.commandList,
-            },
-            ai: env.AI,
-            db: env.DB,
-        },
-        {
-            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: {
-                default: TelegramCommands.duckduckgo,
-                inline: TelegramCommands.duckduckgo,
-                '/duckduckgo': TelegramCommands.duckduckgo,
-                '/question': TelegramCommands.question,
-                '/code': TelegramCommands.code,
-                '/commands': TelegramCommands.commandList,
-                '/help': TelegramCommands.commandList,
-                '/start': TelegramCommands.commandList,
-            },
-            ai: env.AI,
-            db: env.DB,
-        },
-        {
-            bot_name: '@SeanB_robot',
-            api: TelegramBot,
-            webhook: new TelegramWebhook(new URL(`https://api.telegram.org/bot${env.SECRET_TELEGRAM_API_TOKEN4}`), env.SECRET_TELEGRAM_API_TOKEN4, new URL(new URL(request.url).origin)),
-            commands: {
-                default: TelegramCommands.sean,
-                '/clear': TelegramCommands.clear,
-                '/start': TelegramCommands.commandList,
-            },
-            ai: env.AI,
-            db: env.DB,
-        },
-        {
-            bot_name: '@TranslatePartyBot',
-            api: TelegramBot,
-            webhook: new TelegramWebhook(new URL(`https://api.telegram.org/bot${env.SECRET_TELEGRAM_API_TOKEN5}`), env.SECRET_TELEGRAM_API_TOKEN5, new URL(new URL(request.url).origin)),
-            commands: {
-                default: TelegramCommands.translate,
-                inline: TelegramCommands.translate,
-                '/start': TelegramCommands.commandList,
-            },
-            ai: env.AI,
-        },
-    ]).handle(request),
+    fetch: async (request, env) => {
+        const bot = new TelegramBot(env.SECRET_TELEGRAM_API_TOKEN);
+        await bot
+            .on('default', async function () {
+            switch (bot.update_type) {
+                case 'message': {
+                    const messages = [
+                        { role: 'system', content: 'You are a friendly assistant' },
+                        {
+                            role: 'user',
+                            content: bot.update.message?.text?.toString() ?? '',
+                        },
+                    ];
+                    const response = await env.AI.run('@cf/meta/llama-3-8b-instruct', { messages });
+                    if ('response' in response) {
+                        await bot.reply(response.response ?? '');
+                    }
+                    break;
+                }
+                case 'inline': {
+                    const inline_messages = [
+                        { role: 'system', content: 'You are a friendly assistant' },
+                        {
+                            role: 'user',
+                            content: bot.update.inline_query?.query.toString() ?? '',
+                        },
+                    ];
+                    const inline_response = await env.AI.run('@cf/meta/llama-3-8b-instruct', { messages: inline_messages, max_tokens: 50 });
+                    if ('response' in inline_response) {
+                        await bot.reply(inline_response.response ?? '');
+                    }
+                    break;
+                }
+                default:
+                    break;
+            }
+            return new Response('ok');
+        })
+            .handle(request.clone());
+        const bot2 = new TelegramBot(env.SECRET_TELEGRAM_API_TOKEN2);
+        await bot2
+            .on('default', async function () {
+            switch (bot2.update_type) {
+                case 'message': {
+                    await bot2.reply('https://duckduckgo.com/?q=' + encodeURIComponent(bot.update.message?.text?.toString() ?? ''));
+                    break;
+                }
+                case 'inline': {
+                    await bot2.reply('https://duckduckgo.com/?q=' + encodeURIComponent(bot.update.inline_query?.query ?? ''));
+                    break;
+                }
+                default:
+                    break;
+            }
+            return new Response('ok');
+        })
+            .handle(request.clone());
+        const bot3 = new TelegramBot(env.SECRET_TELEGRAM_API_TOKEN3);
+        await bot3
+            .on('default', async function () {
+            switch (bot3.update_type) {
+                case 'inline': {
+                    const { translated_text } = await env.AI.run('@cf/meta/m2m100-1.2b', {
+                        text: bot3.update.inline_query?.query.toString() ?? '',
+                        source_lang: 'french',
+                        target_lang: 'english',
+                    });
+                    await bot3.reply(translated_text ?? '');
+                    break;
+                }
+                default:
+                    break;
+            }
+            return new Response('ok');
+        })
+            .handle(request.clone());
+        return new Response('ok');
+    },
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codebam/cf-workers-telegram-bot",
-  "version": "6.5.0",
+  "version": "7.3.0",
   "description": "serverless telegram bot on cf workers",
   "main": "./dist/main/src/main.js",
   "module": "./dist/main/src/main.js",
@@ -41,5 +41,5 @@
     "typescript": "^5.4.5",
     "typescript-eslint": "^7.8.0"
   },
-  "gitHead": "843a4525d055dce257c124a0f0a15b8f552b1a47"
+  "gitHead": "55015e53958e69fc128e0b1e8116abb249291b0f"
 }

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

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

package/dist/main/src/bot_api.js

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

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

@@ -1,5 +0,0 @@
-/// <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/ban.js

@@ -1,8 +0,0 @@
-export default async (self, update) => {
-    const chat_id = update.message?.reply_to_message?.chat.id;
-    const user_id = update.message?.reply_to_message?.from.id;
-    if (chat_id && user_id) {
-        return self.banChatMember(chat_id, user_id, 0, true);
-    }
-    return new Response('ok');
-};

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

@@ -1,5 +0,0 @@
-/// <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/bored.js

@@ -1,7 +0,0 @@
-import { TelegramInlineQueryResultArticle } from '../types';
-export default async (self, update) => fetch('https://boredapi.com/api/activity/')
-    .then((response) => response.json())
-    .then((json) => json)
-    .then((bored_response) => update.inline_query
-    ? self.answerInlineQuery(update.inline_query.id, [new TelegramInlineQueryResultArticle(bored_response.activity)], 0)
-    : self.sendMessage(update.message?.chat.id ?? 0, bored_response.activity));

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

@@ -1,5 +0,0 @@
-/// <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/clear.js

@@ -1,14 +0,0 @@
-import { TelegramInlineQueryResultArticle } from '../types';
-export default async (self, update) => {
-    const { success } = await self.db
-        .prepare('DELETE FROM Messages WHERE userId=?')
-        .bind(update.inline_query ? update.inline_query.from.id : update.message?.from.id)
-        .run();
-    if (success) {
-        if (update.inline_query) {
-            return self.answerInlineQuery(update.inline_query.id, [new TelegramInlineQueryResultArticle('_')]);
-        }
-        return self.sendMessage(update.message?.chat.id ?? 0, '_');
-    }
-    return self.sendMessage(update.message?.chat.id ?? 0, 'failed');
-};

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

@@ -1,5 +0,0 @@
-/// <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;