Link a Telegram account to an email

import { hours } from "@hogsend/core";
import {
  defineJourney,
  getEmailService,
  sendConnectorAction,
} from "@hogsend/engine";
import { TelegramEvents, telegramColdConnect } 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;
    }

    // Mint a server-sealed confirm token. The cold-connect primitive owns the
    // anti email-bomb throttle now (per-user + per-email Redis-INCR windows,
    // fail-closed), so a forged/replayed /link can't spray a victim's inbox, and
    // a Redis fault returns { ok:false } so we never send a link we can't honor.
    const minted = await telegramColdConnect.mintConfirm({
      platformUserId: fromId,
      email,
    });
    if (!minted.ok) {
      if (minted.reason === "rate_limited") {
        await reply(
          "You've requested a few link emails recently — check your inbox, " +
            "or try again in a little while.",
        );
        return;
      }
      await reply("Linking is briefly unavailable — please try again shortly.");
      return;
    }

    const apiPublicUrl = process.env.API_PUBLIC_URL ?? "http://localhost:3002";
    const url = telegramColdConnect.confirmUrl({
      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\n` +
        "Open it to finish connecting — it expires in 15 minutes.",
    );
  },
});

import { createApp, createHogsendClient } from "@hogsend/engine";
import { telegramColdConnect } from "@hogsend/plugin-telegram";

const client = createHogsendClient({ journeys, email: { templates } });

const app = createApp(client, {
  webhookSources,
  // GET /connect/telegram (the Studio-styled page) + POST .../exchange (the
  // sealed-token bind). The basePath is derived from connectorId, so the
  // confirm links already in flight keep resolving.
  routes: [telegramColdConnect.routes],
});

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.",
      },
    });
  },
});