Link a Telegram account to an email

// src/journeys/telegram-link-request.ts
import { hours } from "@hogsend/core";
import {
  defineJourney,
  getEmailService,
  getRedis,
  sendConnectorAction,
} from "@hogsend/engine";
import {
  buildTelegramConfirmUrl,
  mintTelegramConfirmToken,
  TelegramEvents,
} from "@hogsend/plugin-telegram";

// Loose shape check only — the binding is PROVEN by the email being delivered.
const EMAIL_RE = /^[^@\s]+@[^@\s]+\.[^@\s]+$/;

export const telegramLinkRequest = defineJourney({
  meta: {
    id: "telegram-link-request",
    name: "Telegram — Link Request (/link)",
    enabled: true,
    trigger: { event: TelegramEvents.LINK_REQUESTED }, // "telegram.link_requested"
    entryLimit: "unlimited",
    suppress: hours(0),
  },

  run: async (user, _ctx) => {
    const chatId = user.properties.chatId ? String(user.properties.chatId) : null;
    const fromId = user.properties.fromId ? String(user.properties.fromId) : null;
    if (!chatId || !fromId) return;

    const reply = (text: string) =>
      sendConnectorAction({
        connectorId: "telegram",
        action: "sendMessage",
        args: { chatId, text },
      });

    const email = user.properties.email ? String(user.properties.email) : "";
    if (!email || !EMAIL_RE.test(email)) {
      await reply("To connect your email, send:\n\n/link you@example.com");
      return;
    }

    // Anti email-bomb: the Telegram webhook has only a static secret token (no
    // per-message signature), so a forged/replayed /link could spray a victim's
    // inbox from your sending domain. Cap at 3 per rolling hour per fromId.
    const redis = getRedis();
    if (redis) {
      const rlKey = `hogsend:telegram:linkreq:rl:${fromId}`;
      const n = await redis.incr(rlKey);
      if (n === 1) await redis.expire(rlKey, 3600);
      if (n > 3) {
        await reply("You've requested a few link emails recently — check your inbox.");
        return;
      }
    }

    // Seal { telegramUserId, email } server-side under a single-use token.
    const minted = await mintTelegramConfirmToken({ telegramUserId: fromId, email });
    if (!minted.ok) {
      await reply("Linking is briefly unavailable — please try again shortly.");
      return;
    }

    const apiPublicUrl = process.env.API_PUBLIC_URL ?? "http://localhost:3002";
    const url = buildTelegramConfirmUrl({ apiPublicUrl, token: minted.token });

    // TRANSACTIONAL send — skipPreferenceCheck so the confirm link is NEVER
    // dropped by unsubscribe/frequency suppression.
    await getEmailService().send({
      template: "transactional/magic-link",
      props: { magicLinkUrl: url, expiresIn: "15 minutes" },
      to: email,
      userId: email,
      userEmail: email,
      subject: "Confirm your Telegram connection",
      category: "transactional",
      skipPreferenceCheck: true,
    });

    await reply(`📧 I've emailed a confirmation link to ${email}.\n\nIt expires in 15 minutes.`);
  },
});

// src/telegram-connect.ts — the connect page + exchange, mounted with
// createApp({ routes: registerTelegramConnectRoutes }). Domain-agnostic: served
// on the customer's own API_PUBLIC_URL against the customer's own PostHog.
import { type CreateAppOptions, ingestEvent } from "@hogsend/engine";
import {
  consumeTelegramConfirmToken,
  peekTelegramConfirmToken,
} from "@hogsend/plugin-telegram";

export const registerTelegramConnectRoutes: NonNullable<
  CreateAppOptions["routes"]
> = (app) => {
  // GET serves the dark connect page; ?tok= is read CLIENT-side, never reflected.
  app.get("/connect/telegram", (c) => {
    const { env } = c.get("container");
    return c.html(connectPageHtml(env)); // page calls posthog.identify on success
  });

  // POST is the only path that binds — a link-preview prefetch (GET) can't.
  app.post("/connect/telegram/exchange", async (c) => {
    const container = c.get("container");
    const { tok } = await c.req.json();

    // Peek (not consume): the token survives a transient failure, so a retry works.
    const binding = await peekTelegramConfirmToken(tok);
    if (!binding) return c.json({ ok: false, error: "invalid_or_used" }, 410);

    // Authoritative bind: telegram:<id> + email folded onto ONE contact. Returns
    // the canonical contact key the page hands to posthog.identify(), so the web
    // session joins the SAME person the contact's email events land on.
    const result = await ingestEvent({
      db: container.db,
      registry: container.registry,
      hatchet: container.hatchet,
      logger: container.logger,
      analytics: container.analytics,
      event: {
        event: "telegram.linked",
        userId: `telegram:${binding.telegramUserId}`,
        userEmail: binding.email,
        contactProperties: {
          // telegram is in DEEP_MERGE_KEYS, so this never clobbers richer fields
          // (username/etc.) set by inbound messages — it merges.
          telegram: {
            id: binding.telegramUserId,
            chat_id: binding.telegramUserId, // == user id for a private chat
          },
        },
        idempotencyKey: `telegram:confirm:${binding.telegramUserId}:${tok}`,
      },
    });

    // Single-use: consume only AFTER the bind ingest committed.
    await consumeTelegramConfirmToken(tok);
    return c.json({ ok: true, key: result.contactKey, telegramId: binding.telegramUserId });
  });
};

import { mintTelegramStartLink } from "@hogsend/plugin-telegram";

const minted = await mintTelegramStartLink({
  botUsername: process.env.TELEGRAM_BOT_USERNAME ?? "",
  email: contact.email,
});
// minted.url === "https://t.me/<bot>?start=<token>" — render it as a button.

// src/journeys/telegram-linked.ts
import { hours } from "@hogsend/core";
import { defineJourney, sendConnectorAction } from "@hogsend/engine";
import { TelegramEvents } from "@hogsend/plugin-telegram";

export const telegramLinked = defineJourney({
  meta: {
    id: "telegram-linked",
    name: "Telegram — Account Linked",
    enabled: true,
    trigger: { event: TelegramEvents.LINKED }, // "telegram.linked"
    entryLimit: "unlimited",
    suppress: hours(0),
  },

  run: async (user, _ctx) => {
    const chatId = user.properties.chatId ? String(user.properties.chatId) : null;
    if (!chatId) return;
    const email = user.email ?? "your email";

    // Confirm the cross-channel link back in Telegram.
    await sendConnectorAction({
      connectorId: "telegram",
      action: "sendMessage",
      args: {
        chatId,
        text:
          `✅ Linked your Telegram to ${email}.\n\n` +
          "Your community activity and email lifecycle are now one contact.",
      },
    });
  },
});