bagr

Author: mvolfik

.vscode/settings.json

@@ -1,6 +1,6 @@
 {
   "deno.enable": true,
-  "deno.unstable": false,
+  "deno.unstable": [],
   "[typescript]": {
     "editor.defaultFormatter": "esbenp.prettier-vscode"
   }

server.deno.ts

@@ -5,48 +5,50 @@ import { serveDir } from "https://deno.land/std@0.190.0/http/file_server.ts";
 import {
   handleRequest as handleTgRequest,
   handleTgWeb,
+  RequestEvent,
   init as tgBotInit,
   webhookPath as tgWebhookPath,
 } from "./tgbot.deno.ts";
 
 const indexContent = new TextDecoder().decode(
-  await Deno.readFile("index.html"),
+  await Deno.readFile("index.html")
 );
-const indxContent = new TextDecoder().decode(
-  await Deno.readFile("indx.html"),
-);
-
-async function handleHttp(conn: Deno.Conn) {
-  for await (const e of Deno.serveHttp(conn)) {
-    const start = performance.now();
-
-    const mockEvent: Deno.RequestEvent = {
-      request: e.request,
-      async respondWith(r) {
-        const resp = await r;
-        const end = performance.now();
-        console.log(
-          `${
-            new Date().toISOString()
-          } ${resp.status} ${e.request.method} ${e.request.url} ${
-            (end - start).toFixed(1)
-          }ms`,
-        );
-        return await e.respondWith(resp);
-      },
-    };
-
-    handleEvent(mockEvent)
-      .then(async (response) => {
-        if (response !== null) {
-          await mockEvent.respondWith(response);
-        }
-      })
-      .catch((err) => console.error(err));
-  }
+const indxContent = new TextDecoder().decode(await Deno.readFile("indx.html"));
+
+async function handleHttp(request: Request): Promise<Response> {
+  const start = performance.now();
+
+  let resolve: (value: Response) => void;
+  const responsePromise = new Promise<Response>((res) => {
+    resolve = res;
+  });
+
+  const mockEvent: RequestEvent = {
+    request,
+    async respondWith(r) {
+      const resp = await r;
+      const end = performance.now();
+      console.log(
+        `${new Date().toISOString()} ${resp.status} ${request.method} ${
+          request.url
+        } ${(end - start).toFixed(1)}ms`
+      );
+      resolve(resp);
+    },
+  };
+
+  handleEvent(mockEvent)
+    .then(async (response) => {
+      if (response !== null) {
+        await mockEvent.respondWith(response);
+      }
+    })
+    .catch((err) => console.error(err));
+
+  return await responsePromise;
 }
 
-async function handleEvent(e: Deno.RequestEvent): Promise<Response | null> {
+async function handleEvent(e: RequestEvent): Promise<Response | null> {
   const url = new URL(e.request.url);
   if (url.pathname === tgWebhookPath) {
     await handleTgRequest(e);
@@ -56,24 +58,16 @@ async function handleEvent(e: Deno.RequestEvent): Promise<Response | null> {
   if (url.pathname === "/" || url.pathname === "/index.html") {
     return Math.random() < 0.01
       ? new Response(indxContent, {
-        headers: {
-          "content-type": "text/html; charset=utf-8",
-        },
-        status: 418,
-      })
+          headers: {
+            "content-type": "text/html; charset=utf-8",
+          },
+          status: 418,
+        })
       : new Response(indexContent, {
-        headers: {
-          "content-type": "text/html; charset=utf-8",
-        },
-      });
-  }
-
-  if (url.pathname === "/postele.html") {
-    return new Response(posteleContent, {
-      headers: {
-        "content-type": "text/html; charset=utf-8",
-      },
-    });
+          headers: {
+            "content-type": "text/html; charset=utf-8",
+          },
+        });
   }
 
   if (url.pathname === "/about") {
@@ -117,6 +111,4 @@ async function handleEvent(e: Deno.RequestEvent): Promise<Response | null> {
 
 await tgBotInit();
 
-for await (const conn of Deno.listen({ port: 8000 })) {
-  handleHttp(conn).catch((err) => console.error(err));
-}
+Deno.serve({ port: 8000 }, handleHttp);

tgbot.deno.ts

@@ -1,3 +1,4 @@
+// deno-lint-ignore-file no-explicit-any
 // The authors disclaim copyright to this source code (they are ashamed to
 // admit they wrote it)
 
@@ -14,9 +15,15 @@ const MAIN_CHAT_ID = parseInt(Deno.env.get("TG_MAIN_CHAT_ID")!);
 const DOMAIN = Deno.env.get("DOMAIN")!;
 const STICEKR_SET_NAME = Deno.env.get("STICKER_SET_NAME")!;
 const STICEKR_SET_OWNER = parseInt(Deno.env.get("STICKER_SET_OWNER")!);
+const PRINTER_TOKEN = Deno.env.get("PRINTER_TOKEN")!;
 
 export const webhookPath = "/tg-webhook";
 
+export type RequestEvent = {
+  request: Request;
+  respondWith(r: Response): Promise<void>;
+};
+
 function genRandomToken(bytes: number) {
   return btoa(
     String.fromCharCode(...crypto.getRandomValues(new Uint8Array(bytes)))
@@ -57,7 +64,7 @@ async function tgCall(
   // Apply rate limiting before making the request
   await rateLimitedDelay();
 
-  let req = await fetch(`https://api.telegram.org/bot${token}/${endpoint}`, {
+  const req = await fetch(`https://api.telegram.org/bot${token}/${endpoint}`, {
     method: "POST",
     headers: {
       "Content-Type": "application/json",
@@ -66,7 +73,7 @@ async function tgCall(
   });
 
   try {
-    let resp = await req.json();
+    const resp = await req.json();
 
     // Handle rate limiting with exponential backoff
     if (!resp.ok && resp.error_code === 429 && retryCount < maxRetries) {
@@ -91,7 +98,7 @@ async function tgCall(
       console.log("Req to", endpoint, "with", options, "failed:", resp);
     }
     return resp;
-  } catch (e) {
+  } catch {
     // Handle network errors with exponential backoff
     if (retryCount < maxRetries) {
       const delay = baseDelay * Math.pow(2, retryCount);
@@ -294,7 +301,7 @@ export async function init() {
   postGeohash();
 }
 
-export async function handleRequest(e: Deno.RequestEvent) {
+export async function handleRequest(e: RequestEvent) {
   if (
     e.request.method.toUpperCase() !== "POST" ||
     e.request.headers.get("X-Telegram-Bot-Api-Secret-Token") !== webhookUrlToken
@@ -330,7 +337,7 @@ async function processTgUpdate(data: any) {
     for await (const data of handleTgUpdate(dato)) {
       for await (const dato of handleTgUpdate(data)) {
         for await (const data of handleTgUpdate(dato)) {
-          for await (const dato of handleTgUpdate(data)) {
+          for await (const _ of handleTgUpdate(data)) {
             tgCall({ text: "🔥" });
           }
         }
@@ -529,6 +536,29 @@ Be grateful for your abilities and your incredible success and your considerable
     yield* handleLogo(data, text.slice(6));
   }
 
+  const trig = "/řekni_tomovi";
+  if (text.startsWith(trig) && data.message.chat.id === MAIN_CHAT_ID) {
+    const response = await fetch("https://printomat.slama.dev/submit", {
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded",
+      },
+      body: new URLSearchParams({
+        message: `${data.message.from} říká: ${text.slice(trig.length).trim()}`,
+        image: "",
+        token: PRINTER_TOKEN,
+      }).toString(),
+      method: "POST",
+    });
+    const txt = await response.text();
+    await tgCall({
+      chat_id: data.message.chat.id,
+      reply_to_message_id: data.message.message_id,
+      text: `Tom říká (${response.status}): ${
+        /<p>(.*?)<\/p>/.exec(txt)?.[1] ?? txt
+      }`,
+    });
+  }
+
   if (
     text.toLowerCase() === "sticker this" &&
     data.message.chat.id === MAIN_CHAT_ID
@@ -750,17 +780,16 @@ async function generateLogos(text: string, filename: string) {
   const texted = LOGO_TEMPLATE.replace("TEMPLATETEXT", text.trim());
   await Deno.writeTextFile(`./static/persistent/logos/${filename}.svg`, texted);
   return (
-    await Deno.run({
-      cmd: [
-        "inkscape",
+    await new Deno.Command("inkscape", {
+      args: [
         `./static/persistent/logos/${filename}.svg`,
         "-o",
         `./static/persistent/logos/${filename}.png`,
         "-w",
         LOGO_RENDER_SIZE.toString(),
       ],
       stderr: "null",
-    }).status()
+    }).spawn().status
   ).code;
 }
 
@@ -879,13 +908,13 @@ async function* reportProcessResult(
   exitCode: number
 ) {
   const outPath = `${tempDir}/${id}.out`;
-  const fileProc = Deno.run({
-    cmd: ["file", "-ib", outPath],
+  const fileProc = new Deno.Command("file", {
+    args: ["-ib", outPath],
     stdout: "piped",
-  });
+  }).spawn();
+  const out = await fileProc.output();
   // need to await the status to not create zombie processes
-  await fileProc.status();
-  const mime = decoder.decode(await fileProc.output());
+  const mime = decoder.decode(out.stdout);
   contentTypes.set(id, mime);
   const isText =
     mime.startsWith("text/") || mime.startsWith("application/json");
@@ -920,17 +949,15 @@ async function handleCallbackQuery(data: any) {
   if (cbData.startsWith("kill:")) {
     const proc = runningProcesses.get(cbData.slice(5));
     if (proc === undefined) return;
-    const killProc = Deno.run({
-      cmd: ["rkill", "-9", proc.pid.toString()],
-    });
-    await killProc.status();
+    const killProc = new Deno.Command("rkill", {
+      args: ["-9", proc.pid.toString()],
+    }).spawn();
+    await killProc.status;
     return;
   }
 }
 
-export async function handleTgWeb(
-  e: Deno.RequestEvent
-): Promise<Response | null> {
+export async function handleTgWeb(e: RequestEvent): Promise<Response | null> {
   const url = new URL(e.request.url);
   const path = url.pathname.slice(7);
   const ct = contentTypes.get(path);