index.js

const path = require("path");
const { Telegraf } = require("telegraf");
const TelegrafI18n = require("telegraf-i18n");
const TelegrafLocalSession = require("telegraf-session-local");

const express = require("express");
const apiMetrics = require("prometheus-api-metrics");
const Prometheus = require("prom-client");
const metrics = {
  updatesTotal: new Prometheus.Counter({
    name: "telegram_bot_updates_received_total",
    help: "Total number of updates received from the Telegram Bot API",
    labelNames: ["update_type"],
  }),
  startTotal: new Prometheus.Counter({
    name: "telegram_bot_started_total",
    help: "Total number of /start command received from the Telegram Bot API",
    labelNames: ["chat_type"],
  }),
  keyboardsRemovedTotal: new Prometheus.Counter({
    name: "telegram_bot_keyboards_removed_total",
    help: "Total times added to group chat to remove a stuck keyboard",
    labelNames: [],
  }),
};

// Prepare i18n
const i18n = new TelegrafI18n({
  defaultLanguage: "en",
  allowMissing: true,
  directory: path.resolve(__dirname, "locales"),
});

// Prepare sessions
const LocalSession = new TelegrafLocalSession({
  storage: TelegrafLocalSession.storageMemory,
});

// Create bot and load middlewares
const botToken = process.env.BOT_TOKEN;
const bot = new Telegraf(botToken);
bot.context.botID = parseInt(botToken.split(":")[0]);
bot.use(i18n.middleware());
bot.use(LocalSession.middleware());

// Count the updates

bot.use(async (ctx, next) => {
  metrics.updatesTotal.inc({
    update_type: ctx.updateType,
  });
  return next();
});

bot.start((ctx) => {
  // 1-1 CHAT HANDLING
  if (ctx.update.message.chat.type === "private") {
    ctx.replyWithHTML(ctx.i18n.t("start") + ctx.i18n.t("help"));
  }

  // GROUP CHAT HANDLING
  else {
    // TODO
    // console.debug(ctx.update.message.chat);
  }
  metrics.startTotal.inc({
    chat_type: ctx.update.message.chat.type ?? "unknown",
  });
});

bot.on("new_chat_members", (ctx) => {
  // Only proceed if the bot itself is one of the added chat members
  const newMembers = ctx.update.message.new_chat_members;

  if (newMembers.find((e) => e.id === ctx.botID) === undefined) {
    console.warn(
      "Received new_chat_members update, but did not find this bot in the list of added members."
    );
    return;
  }

  console.log(
    `Was added to group#${ctx.chat.id}. Attempting to delete stuck inline buttons`
  );

  // Purge all the inline buttons
  deleteInlineButtons(ctx);

  //console.debug(ctx.botID, newMembers);
});

bot.command("deletekeyboard", (ctx) => {
  deleteInlineButtons(ctx);
});

bot.help((ctx) => ctx.replyWithHTML(ctx.i18n.t("help")));

/*
-----------------------------------------------------------
    Helper Functions
-----------------------------------------------------------
*/

async function deleteInlineButtons(ctx, leaveAfterDeleting = true) {
  try {
    // Send a new message with an inline keyboard to overwrite any current keyboards
    const mockKeyboardMsg = await ctx.reply(
      ctx.i18n.t("start_removing_keyboard"),
      {
        reply_markup: {
          resize_keyboard: true,
          keyboard: [
            [
              {
                text: ctx.i18n.t("removing_keyboard_btn_placeholder"),
              },
            ],
          ],
        },
      }
    );

    // attempt to delete it again
    await ctx.deleteMessage(mockKeyboardMsg.message_id);

    // send a new message to delete the just sent keyboard
    await ctx.reply(ctx.i18n.t("done_removing_keyboard"), {
      reply_markup: {
        remove_keyboard: true,
      },
    });

    // Log metric
    metrics.keyboardsRemovedTotal.inc();
  } catch (error) {
    console.error(
      Date.now(),
      " Failed to remove a keyboard in chat ",
      ctx.update.message.chat.id,
      ". Error:\n",
      error
    );
  }

  try {
    if (leaveAfterDeleting) await ctx.leaveChat();
  } catch (error) {
    /* Whatever, screw it.*/
  }
}

// Start the bot
console.log(
  `Starting longPolling (chat_id of bot: ${
    process.env.BOT_TOKEN.split(":")[0]
  })...`
);
bot.launch();

// If enabled, start to expose metrics via http server
if (["true", "1"].includes(process.env.EXPOSE_METRICS?.trim()?.toLowerCase())) {
  const app = express();
  app.use(apiMetrics());
  const port = process.env.PORT ?? 3000;
  const host = process.env.HOST ?? "0.0.0.0";
  app.listen(port, host, () => {
    console.log(`Exposing metrics on port ${port}`);
  });
}