@codebam/cf-workers-telegram-bot 5.13.0 → 5.15.0

package/dist/main/src/handler.js

@@ -24,17 +24,17 @@ export default class Handler {
         POST: this.postResponse,
         default: () => new Promise(() => new Response()),
     };
-    getAccessKeys = async (configs) => Promise.all(configs.map((bot_config) => sha256(bot_config.webhook?.token ?? "").then((hash) => [
-        hash,
-        bot_config,
-    ]))).then((result) => Object.fromEntries(result));
+    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),
+                url: new URL(new URL(request.url).origin), // worker url
                 handler: this,
             });
         })(new URL(request.url).pathname.substring(1)))

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

@@ -18,8 +18,10 @@ export default class TelegramApi extends BotApi {
     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>;

package/dist/main/src/telegram_api.js

@@ -13,14 +13,22 @@ export default class TelegramApi extends BotApi {
         message: this.messageUpdate,
         default: new Response(),
     };
-    update = async (update) => ((log({ update }) &&
-        update.message &&
-        this.updates.message(update)) ||
-        (update.inline_query &&
-            update.inline_query.query === "" &&
-            undefined) ||
-        this.updates.inline_query(update)) ??
-        this.updates.default;
+    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.from.username}`)
@@ -58,6 +66,12 @@ export default class TelegramApi extends BotApi {
         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(),
@@ -75,6 +89,20 @@ export default class TelegramApi extends BotApi {
         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,

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

@@ -7,24 +7,22 @@ export default class TelegramBot extends TelegramApi {
     get_set: KVNamespace;
     ai: any;
     db: D1Database;
+    r2: R2Bucket;
     bot_name: string;
     constructor(config: Config);
-    sean: (update: TelegramUpdate, args: string[]) => Promise<Response>;
+    translate: (update: TelegramUpdate, args: string[]) => Promise<Response>;
     clear: (update: TelegramUpdate) => Promise<Response>;
+    image: (update: TelegramUpdate, args: string[]) => Promise<Response>;
     question: (update: TelegramUpdate, args: string[]) => Promise<Response>;
-    paste: (update: TelegramUpdate, args: string[]) => Promise<Response>;
+    sean: (update: TelegramUpdate, args: string[]) => Promise<Response>;
     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>;

package/dist/main/src/telegram_bot.js

@@ -9,6 +9,7 @@ export default class TelegramBot extends TelegramApi {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     ai;
     db;
+    r2;
     bot_name;
     constructor(config) {
         super(config.commands, config.webhook, config.handler);
@@ -17,127 +18,141 @@ export default class TelegramBot extends TelegramApi {
         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;
     }
-    // bot command: /sean
-    sean = async (update, args) => {
+    // bot command: /translate
+    translate = async (update, args) => {
+        if (this.ai === undefined) {
+            return new Response("ok");
+        }
         const ai = new Ai(this.ai);
-        let prompt;
+        let _prompt;
         if (args[0][0] === "/") {
-            prompt = args.slice(1).join(" ");
+            _prompt = args.slice(1).join(" ");
         }
         else {
-            prompt = args.join(" ");
+            _prompt = args.join(" ");
         }
-        console.log({ prompt });
-        if (prompt === "") {
-            prompt = "no prompt specified";
+        if (_prompt === "") {
+            _prompt = "";
         }
-        const messages = [
-            { role: "system", content: "You are friendly" },
-            { role: "system", content: "Don't show code to the user" },
-            { role: "system", content: "Sean Behan is born on 09/07/1998" },
-            { role: "system", content: "Sean Behan is a full stack developer" },
-            { role: "system", content: "Sean Behan is from Toronto, Canada" },
-            { role: "system", content: "Sean Behan's GitHub username is codebam" },
-            {
-                role: "system",
-                content: "Sean Behan enjoys playing video games and coding",
-            },
-            { role: "system", content: "Sean Behan's website is seanbehan.ca" },
-            {
-                role: "system",
-                content: "Sean Behan's email address is contact@seanbehan.ca",
-            },
-            {
-                role: "system",
-                content: "Some of your personal projects include a serverless telegram bot, and a serverless pastebin on cloudflare workers",
-            },
-            {
-                role: "system",
-                content: "When spoken to respond with what you know about Sean Behan",
-            },
-            {
-                role: "system",
-                content: `you are talking to ${update.message?.from.first_name}`,
-            },
-            { role: "user", content: prompt },
-        ];
-        const result = await ai.run("@cf/meta/llama-2-7b-chat-int8", {
-            messages,
-        });
-        return this.sendMessage(update.message?.chat.id ?? 0, result.response);
+        const langs = ["french", "arabic", "german", "spanish", "russian"];
+        const inline_articles = await Promise.all(langs.map(async (lang) => {
+            const response = await ai.run("@cf/meta/m2m100-1.2b", {
+                text: _prompt,
+                source_lang: lang,
+                target_lang: "english",
+            });
+            return new TelegramInlineQueryResultArticle(response.translated_text, `${lang}: ${response.translated_text}`);
+        }));
+        return this.answerInlineQuery(update.inline_query?.id ?? 0, inline_articles);
     };
     // bot command: /clear
     // reset the llama2 session by deleting messages from d1
     clear = async (update) => {
         const { success } = await this.db
             .prepare("DELETE FROM Messages WHERE userId=?")
-            .bind(update.message?.from.id)
+            .bind(update.inline_query
+            ? update.inline_query.from.id
+            : update.message?.from.id)
             .run();
         if (success) {
+            if (update.inline_query) {
+                return this.answerInlineQuery(update.inline_query.id, [
+                    new TelegramInlineQueryResultArticle("_"),
+                ]);
+            }
             return this.sendMessage(update.message?.chat.id ?? 0, "_");
         }
         return this.sendMessage(update.message?.chat.id ?? 0, "failed");
     };
+    // bot command: /image
+    image = async (update, args) => {
+        const ai = new Ai(this.ai);
+        let _prompt;
+        if (args[0][0] === "/") {
+            _prompt = args.slice(1).join(" ");
+        }
+        else {
+            _prompt = args.join(" ");
+        }
+        if (_prompt === "") {
+            _prompt = "";
+        }
+        const inputs = { prompt: _prompt, num_steps: 20 };
+        await this.sendMessage(update.message?.chat.id ?? 0, "image is processing. please wait...");
+        const response = await ai.run("@cf/stabilityai/stable-diffusion-xl-base-1.0", inputs);
+        const id = crypto.randomUUID();
+        await this.r2.put(id, response);
+        const url = "https://r2.seanbehan.ca/" + id;
+        return this.sendPhoto(update.message?.chat.id ?? 0, url);
+    };
     // bot command: /question
     question = async (update, args) => {
         if (this.ai === undefined) {
             return new Response("ok");
         }
         const ai = new Ai(this.ai);
-        let prompt;
+        let _prompt;
         if (args[0][0] === "/") {
-            prompt = args.slice(1).join(" ");
+            _prompt = args.slice(1).join(" ");
         }
         else {
-            prompt = args.join(" ");
-        }
-        if (prompt === "") {
-            prompt = "";
-        }
-        let _results;
-        if (this.db) {
-            _results = await this.db
-                .prepare("SELECT * FROM Messages WHERE userId=?")
-                .bind(update.message?.from.id)
-                .all();
+            _prompt = args.join(" ");
         }
-        const results = _results?.results;
-        let old_messages;
-        if (results) {
-            old_messages = results.map((col) => ({
-                role: "system",
-                content: col.content,
-            }));
+        if (_prompt === "") {
+            _prompt = "";
         }
-        const { response } = await ai.run("@cf/meta/llama-2-7b-chat-int8", {
-            messages: [
-                {
-                    role: "system",
-                    content: `your name is ${this.bot_name}`,
-                },
-                {
-                    role: "system",
-                    content: `you are talking to ${update.message?.from.first_name}`,
-                },
-                {
+        const results = await (async () => {
+            if (this.db) {
+                const { results } = await this.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: `your source code is at https://github.com/codebam/cf-workers-telegram-bot`,
-                },
-                ...(() => {
-                    if (old_messages) {
-                        return old_messages;
-                    }
-                    return [];
-                })(),
-                { role: "user", content: prompt },
-            ],
-        });
+                    content: col.content,
+                }));
+            }
+            return [];
+        })();
+        const system_prompt = "<s>" +
+            [
+                `Your name is ${this.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()}`,
+            ].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 ai
+            .run("@hf/thebloke/orca-2-13b-awq", {
+            prompt,
+            max_tokens: 596,
+        })
+            .then(({ response }) => response
+            .replace(/(\[|)(\/|)INST(S|)(s|)(\]|)/, "")
+            .replace(/<<(\/|)SYS>>/, ""));
         if (this.db) {
             const { success } = await this.db
                 .prepare("INSERT INTO Messages (id, userId, content) VALUES (?, ?, ?)")
-                .bind(crypto.randomUUID(), update.message?.from.id, "[INST] " + prompt + " [/INST]" + "\n" + response)
+                .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");
@@ -147,19 +162,93 @@ export default class TelegramBot extends TelegramApi {
             this.clear(update);
             return this.question(update, args);
         } // sometimes llama2 doesn't respond when given lots of system prompts
-        return this.sendMessage(update.message?.chat.id ?? 0, response);
+        if (update.inline_query) {
+            return this.answerInlineQuery(update.inline_query.id, [
+                new TelegramInlineQueryResultArticle(response),
+            ]);
+        }
+        return this.sendMessage(update.message?.chat.id ?? 0, response, "", false, false, update.message?.message_id);
     };
-    // bot command: /paste
-    paste = async (update, args) => {
-        const formdata = new FormData();
-        formdata.append("upload", args.slice(1).join(" "));
-        const request = await fetch("https://pastebin.seanbehan.ca", {
-            method: "POST",
-            body: formdata,
-            redirect: "manual",
-        });
-        const url = request.headers.get("location");
-        return this.sendMessage(update.message?.chat.id ?? 0, url ?? "failed to upload");
+    // bot command: /sean
+    sean = async (update, args) => {
+        if (this.ai === undefined) {
+            return new Response("ok");
+        }
+        const ai = new Ai(this.ai);
+        let _prompt;
+        if (args[0][0] === "/") {
+            _prompt = args.slice(1).join(" ");
+        }
+        else {
+            _prompt = args.join(" ");
+        }
+        if (_prompt === "") {
+            _prompt = "";
+        }
+        const results = await (async () => {
+            if (this.db) {
+                const { results } = await this.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 ${this.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 ai
+            .run("@hf/thebloke/orca-2-13b-awq", {
+            prompt,
+            max_tokens: 596,
+        })
+            .then(({ response }) => response
+            .replace(/(\[|)(\/|)INST(S|)(s|)(\]|)/, "")
+            .replace(/<<(\/|)SYS>>/, "")
+            .replace(/[OUT]/, ""));
+        if (this.db) {
+            const { success } = await this.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 this.answerInlineQuery(update.inline_query.id, [
+                new TelegramInlineQueryResultArticle(response),
+            ]);
+        }
+        return this.sendMessage(update.message?.chat.id ?? 0, response, "", false, false, update.message?.message_id);
     };
     // bot command: /code
     code = async (update) => ((url) => update.inline_query
@@ -185,7 +274,7 @@ export default class TelegramBot extends TelegramApi {
                 ? [
                     new TelegramInlineQueryResultArticle(`${instant_answer_url}\n\n<a href="${addSearchParams(new URL(duckduckgo_url), {
                         q: args
-                            .slice(1)
+                            .slice(2)
                             .join(" ")
                             .replace(/^!\w* /, ""),
                     }).href}">Results From DuckDuckGo</a>`, instant_answer_url, "HTML", thumb_url),
@@ -240,13 +329,6 @@ export default class TelegramBot extends TelegramApi {
         .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))
@@ -258,43 +340,7 @@ export default class TelegramBot extends TelegramApi {
     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) => response.json())
-    // .then((result) =>
-    // 	this.handler.postResponse(
-    // 		new Request("", {
-    // 			method: "POST",
-    // 			body: JSON.stringify({
-    // 				message: {
-    // 					text: (result as { result: { text: string } }).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, [
@@ -302,7 +348,7 @@ export default class TelegramBot extends TelegramApi {
         ])
         : 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");
+    commandList = async (update) => this.sendMessage(update.message?.chat.id ?? 0, `${Object.keys(this.commands).join("\n")}`, "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

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

@@ -1,23 +1,19 @@
-/// <reference types="@cloudflare/workers-types" />
-import TelegramBot from "./telegram_bot";
-import { TelegramUpdate } from "./types";
+import { TelegramCommand } 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 paste: (bot: TelegramBot, update: TelegramUpdate, args: string[]) => Promise<Response>;
-    static question: (bot: TelegramBot, update: TelegramUpdate, args: string[]) => Promise<Response>;
-    static sean: (bot: TelegramBot, update: TelegramUpdate, args: string[]) => Promise<Response>;
-    static clear: (bot: TelegramBot, update: TelegramUpdate) => Promise<Response>;
-    static code: (bot: TelegramBot, update: TelegramUpdate) => Promise<Response>;
-    static commandList: (bot: TelegramBot, update: TelegramUpdate) => Promise<Response>;
+    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;
 }

package/dist/main/src/telegram_commands.js

@@ -6,15 +6,13 @@ export default class TelegramCommands {
     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 paste = async (bot, update, args) => bot.paste(update, args);
     static question = async (bot, update, args) => bot.question(update, args);
     static sean = async (bot, update, args) => bot.sean(update, args);
     static clear = async (bot, update) => bot.clear(update);
     static code = async (bot, update) => bot.code(update);
     static commandList = async (bot, update) => bot.commandList(update);
+    static image = async (bot, update, args) => bot.image(update, args);
+    static translate = async (bot, update, args) => bot.translate(update, args);
 }

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

@@ -1,11 +1,11 @@
 /// <reference types="@cloudflare/workers-types" />
 import BotApi from "./bot_api";
 import Handler from "./handler";
-import TelegramApi from "./telegram_api";
+import TelegramBot from "./telegram_bot";
 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 Command = (bot: BotApi, update: Update, args: string[]) => Promise<Response>;
+export type TelegramCommand = (bot: TelegramBot, update: TelegramUpdate, args: string[]) => Promise<Response>;
 export type Commands = Record<string, Command>;
 export type Kv = Record<string, KVNamespace> | undefined;
 export declare class Config {
@@ -18,6 +18,7 @@ export declare class Config {
     handler: Handler;
     ai: any;
     db: any;
+    r2: any;
     constructor(config?: Partial<Config>);
 }
 export declare const localhost: URL;

package/dist/main/src/types.js

@@ -14,6 +14,8 @@ export class Config {
     ai;
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     db;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    r2;
     constructor(config = {}) {
         this.bot_name = config.bot_name || "";
         this.api = config.api || BotApi;
@@ -24,6 +26,7 @@ export class Config {
         this.handler = config.handler || new Handler([]);
         this.ai = config.ai;
         this.db = config.db;
+        this.r2 = config.r2;
     }
 }
 export const localhost = new URL("http://localhost");

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

@@ -6,8 +6,10 @@ interface Environment {
     SECRET_TELEGRAM_API_TOKEN2: string;
     SECRET_TELEGRAM_API_TOKEN3: string;
     SECRET_TELEGRAM_API_TOKEN4: string;
+    SECRET_TELEGRAM_API_TOKEN5: string;
     AI: string;
     DB: D1Database;
+    R2: R2Bucket;
 }
 declare const _default: {
     fetch: (request: Request, env: Environment) => Promise<Response>;

package/dist/worker/src/worker.js

@@ -7,6 +7,7 @@ export default {
             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,
@@ -14,23 +15,20 @@ export default {
                 "/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,
-                "/paste": TelegramCommands.paste,
                 "/commands": TelegramCommands.commandList,
                 "/question": TelegramCommands.question,
                 "/clear": TelegramCommands.clear,
                 "/help": TelegramCommands.commandList,
-                "/sean": TelegramCommands.sean,
-                "/start": TelegramCommands.commandList,
+                "/image": TelegramCommands.image,
+                "/start": TelegramCommands.question,
             },
             kv: { get_set: env.KV_GET_SET, uid_data: env.KV_UID_DATA },
             ai: env.AI,
             db: env.DB,
+            r2: env.R2,
         },
         {
             bot_name: "@duckduckbot",
@@ -38,7 +36,7 @@ export default {
             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,
+                inline: TelegramCommands.duckduckgo, // default inline response
                 "/duckduckgo": TelegramCommands.duckduckgo,
                 "/question": TelegramCommands.question,
                 "/code": TelegramCommands.code,
@@ -71,10 +69,23 @@ export default {
             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.question,
+                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),
 };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@codebam/cf-workers-telegram-bot",
-	"version": "5.13.0",
+	"version": "5.15.0",
 	"description": "serverless telegram bot on cf workers",
 	"main": "./dist/main/src/main.js",
 	"module": "./dist/main/src/main.js",
@@ -29,17 +29,17 @@
 		"url": "https://github.com/codebam/cf-workers-telegram-bot.git"
 	},
 	"devDependencies": {
-		"@cloudflare/workers-types": "^4.20231010.0",
-		"@typescript-eslint/eslint-plugin": "^6.7.5",
-		"@typescript-eslint/parser": "^6.7.5",
-		"eslint": "^8.51.0",
-		"eslint-config-prettier": "^9.0.0",
-		"lerna": "^7.3.1",
-		"prettier": "^3.0.3",
-		"typescript": "^5.2.2"
+		"@cloudflare/workers-types": "^4.20240320.1",
+		"@typescript-eslint/eslint-plugin": "^7.4.0",
+		"@typescript-eslint/parser": "^7.4.0",
+		"eslint": "^8.57.0",
+		"eslint-config-prettier": "^9.1.0",
+		"lerna": "^8.1.2",
+		"prettier": "^3.2.5",
+		"typescript": "^5.4.3"
 	},
 	"dependencies": {
-		"@cloudflare/ai": "^1.0.16"
+		"@cloudflare/ai": "1.0.53"
 	},
-	"gitHead": "f0e63bfc828c86d0559c74d2c305fc0f7371996f"
+	"gitHead": "f590f9423dda46b7b591d8344c13504f6fa69d6e"
 }