polling.ts

// src/bot/polling.ts
import { recordUsageEvent } from "../usage/db.js";
import { readBotConfig } from "./config.js";
import { getUpdates, sendMessage, deleteWebhook, setMyCommands, type TelegramUpdate } from "./telegram.js";
import {
  parseCommand,
  welcomeMessage,
  unknownMessage,
  createdMessage,
  launchMessage,
  launchUsageMessage,
} from "./commands.js";
import {
  ackCheckingLaunch,
  ackCreatingProject,
  errCreateProject,
  errLaunchGeneric,
  errLaunchNotFound,
  linkButtonLabels,
  getTokenMessage,
} from "./i18n.js";
import { buildGatewayMiniAppUrl, buildTelegramMiniAppUrl } from "./links.js";

async function createProjectViaApi(
  controlPlaneUrl: string,
  botSecret: string,
  ownerTelegramId: number,
  title: string,
) {
  const res = await fetch(`${controlPlaneUrl}/api/projects`, {
    method: "POST",
    headers: {
      "content-type": "application/json",
      "x-spawndock-bot-secret": botSecret,
    },
    body: JSON.stringify({ title, ownerTelegramId }),
  });
  if (!res.ok) throw new Error(`Create project failed: ${res.status}`);
  return (await res.json()) as any;
}

async function getLaunchInfo(controlPlaneUrl: string, botSecret: string, ownerTelegramId: number, slug: string) {
  const url = new URL(`${controlPlaneUrl}/api/projects/${slug}/launch-url`);
  url.searchParams.set("ownerTelegramId", String(ownerTelegramId));
  const res = await fetch(url, {
    headers: {
      "x-spawndock-bot-secret": botSecret,
    },
  });
  if (!res.ok) throw new Error(`Launch info failed: ${res.status}`);
  return (await res.json()) as any;
}

async function processUpdate(cfg: ReturnType<typeof readBotConfig>, update: TelegramUpdate): Promise<void> {
  const msg = update.message;
  if (!msg?.text || !msg.from) return;

  const cmd = parseCommand(msg.text);
  recordUsageEvent({
    service: "bot",
    eventType: `cmd_${cmd.tag}`,
    actorType: "telegram_user",
    actorKey: `tg:${msg.from.id}`,
  });

  if (cmd.tag === "start" || cmd.tag === "help") {
    await sendMessage(cfg.telegramBotToken, msg.chat.id, welcomeMessage());
    return;
  }

  if (cmd.tag === "get-token") {
    await sendMessage(cfg.telegramBotToken, msg.chat.id, getTokenMessage(cfg.apiToken));
    return;
  }

  if (cmd.tag === "new") {
    let data: any;
    const ackTimeout = scheduleAcknowledgement(cfg, msg.chat.id, ackCreatingProject());
    try {
      data = await createProjectViaApi(cfg.controlPlaneUrl, cfg.controlPlaneBotSecret, msg.from.id, cmd.title);
    } catch (err: any) {
      clearTimeout(ackTimeout);
      await sendMessage(cfg.telegramBotToken, msg.chat.id, errCreateProject());
      return;
    }
    clearTimeout(ackTimeout);
    const slug = data.project.slug;
    const token = data.pairingToken.token;
    const bootstrapCmd = `npx -y @spawn-dock/create --token ${token}`;
    await sendMessage(
      cfg.telegramBotToken,
      msg.chat.id,
      createdMessage(slug, bootstrapCmd),
    );
    return;
  }

  if (cmd.tag === "launch-missing") {
    await sendMessage(cfg.telegramBotToken, msg.chat.id, launchUsageMessage());
    return;
  }

  if (cmd.tag === "launch") {
    let data: any;
    const ackTimeout = scheduleAcknowledgement(cfg, msg.chat.id, ackCheckingLaunch());
    try {
      data = await getLaunchInfo(cfg.controlPlaneUrl, cfg.controlPlaneBotSecret, msg.from.id, cmd.slug);
    } catch (err: any) {
      clearTimeout(ackTimeout);
      if (String(err.message).includes("404")) {
        await sendMessage(cfg.telegramBotToken, msg.chat.id, errLaunchNotFound());
        return;
      }
      await sendMessage(cfg.telegramBotToken, msg.chat.id, errLaunchGeneric());
      return;
    }
    clearTimeout(ackTimeout);
    const previewUrl = data.launchUrl;
    const tmaUrl = buildGatewayMiniAppUrl(previewUrl, cmd.slug);
    const telegramMiniAppUrl = buildTelegramMiniAppUrl(cfg.telegramBotUsername, cfg.telegramMiniAppShortName, cmd.slug);
    const buttons = linkButtonLabels();
    await sendMessage(
      cfg.telegramBotToken,
      msg.chat.id,
      launchMessage(cmd.slug, data.status, tmaUrl, previewUrl, telegramMiniAppUrl),
      { tmaUrl, previewUrl, telegramMiniAppUrl, buttonLabels: buttons },
    );
    return;
  }

  await sendMessage(cfg.telegramBotToken, msg.chat.id, unknownMessage());
}

function scheduleAcknowledgement(
  cfg: ReturnType<typeof readBotConfig>,
  chatId: number,
  message: string,
): NodeJS.Timeout {
  return setTimeout(() => {
    void sendMessage(cfg.telegramBotToken, chatId, message).catch(() => {});
  }, 4000);
}

async function getLatestOffset(token: string): Promise<number> {
  const res = await fetch(
    `https://api.telegram.org/bot${token}/getUpdates?limit=1&offset=-1&timeout=0`,
  );
  if (!res.ok) return 0;
  const data = (await res.json()) as any;
  const updates = data.result as any[];
  if (!updates || updates.length === 0) return 0;
  return updates[updates.length - 1].update_id + 1;
}

async function main(): Promise<void> {
  const cfg = readBotConfig();
  await deleteWebhook(cfg.telegramBotToken);
  try {
    await setMyCommands(cfg.telegramBotToken);
  } catch (err: any) {
    // Do not exit: polling and typed commands still work; menu may stay stale until Telegram API succeeds.
    console.error(`setMyCommands failed (menu may be stale): ${err?.message ?? err}`);
  }

  const startOffset = await getLatestOffset(cfg.telegramBotToken);
  console.log(`SpawnDock bot polling started against ${cfg.controlPlaneUrl} (offset=${startOffset})`);

  let offset = startOffset;
  while (true) {
    try {
      const updates = await getUpdates(cfg.telegramBotToken, offset > 0 ? offset + 1 : 0, cfg.pollingTimeout);
      if (updates.length > 0) console.log(`Received ${updates.length} update(s)`);
      for (const update of updates) {
        console.log(`Update ${update.updateId}: "${update.message?.text ?? "(no text)"}" from ${update.message?.from?.id ?? "?"}`);
        try {
          await processUpdate(cfg, update);
        } catch (err: any) {
          console.error(`Error processing update ${update.updateId}: ${err.message}`);
        }
        offset = update.updateId;
      }
    } catch (err: any) {
      console.error(`Polling error: ${err.message}`);
      await new Promise((r) => setTimeout(r, 1000));
    }
  }
}

main().catch((err) => {
  console.error(`Bot fatal error: ${err.message}`);
  process.exit(1);
});