nubot-lite 0.1.0 → 0.1.2

package/template/worker/src/nubot/channels.ts

@@ -0,0 +1,159 @@
+// Conexiones: las cuentas de WhatsApp, Instagram y Facebook de la empresa, conectadas por Zernio.
+// El panel pide un enlace, la persona entra con su cuenta de Meta en Zernio y vuelve al CRM ya conectada.
+
+import { Hono, type Context } from "hono";
+import {
+  channelByAccount,
+  connectState,
+  connectUrl,
+  deleteAccount,
+  findAccount,
+  listChannels,
+  PLATFORM_NAMES,
+  readConnectState,
+  saveChannel,
+  syncWebhook,
+  ZernioError,
+  type ChannelRow,
+  type Platform,
+} from "../channels/accounts";
+import type { NubotEnv } from "./index";
+import { PANEL_CHANNEL_TYPE } from "./mappers";
+
+type Ctx = Context<NubotEnv>;
+
+/** La pantalla del panel de cada red. Messenger es la página de Facebook. */
+const PANEL_PAGE: Record<Platform, string> = { whatsapp: "whatsapp", instagram: "instagram", facebook: "messenger" };
+
+const origin = (c: Ctx) => new URL(c.req.url).origin;
+
+const onlyAdmin = (c: Ctx) =>
+  c.get("user").role === "admin" ? null : c.json({ message: "Solo un administrador puede cambiar las conexiones.", statusCode: 403 }, 403);
+
+const explain = (err: unknown) => (err instanceof ZernioError ? err.message : "Algo falló al hablar con Zernio. Vuelve a intentar.");
+
+/** Un canal en la forma del panel. Su id es el de la cuenta en Zernio, el mismo que llevan las conversaciones. */
+function toPanelChannel(row: ChannelRow) {
+  const name = row.name ?? PLATFORM_NAMES[row.platform];
+  return {
+    id: row.zernio_account_id,
+    name: row.username && row.platform === "instagram" ? `@${row.username}` : name,
+    type: PANEL_CHANNEL_TYPE[row.platform],
+    providerId: row.zernio_account_id,
+    isActive: row.active === 1,
+    connectionMethod: "zernio",
+    // El panel considera conectada una página con este campo; el token real lo guarda Zernio.
+    accessTokenEncrypted: row.active === 1 ? "zernio" : null,
+    credentials: {
+      name,
+      username: row.username,
+      profilePictureUrl: row.picture,
+      pageName: name,
+      pagePicture: row.picture,
+    },
+    config: { webhookSubscribed: row.active === 1 },
+    createdAt: new Date(row.created_at).toISOString(),
+    updatedAt: new Date(row.updated_at).toISOString(),
+    deletedAt: row.active === 1 ? null : new Date(row.updated_at).toISOString(),
+  };
+}
+
+// ---------- La vuelta desde Zernio (sin sesión: la trae el navegador) ----------
+
+export const channelsPublic = new Hono<NubotEnv>();
+
+channelsPublic.get("/channels/zernio/callback", async (c) => {
+  const platform = await readConnectState(c.env, c.req.query("state"));
+  if (!platform) return c.redirect("/conexiones?error=" + encodeURIComponent("El enlace para conectar venció. Vuelve a intentarlo."));
+  const page = `/conexiones/${PANEL_PAGE[platform]}`;
+  const fail = (message: string) => c.redirect(`${page}?error=${encodeURIComponent(message)}`);
+
+  const accountId = c.req.query("accountId");
+  if (c.req.query("error") || !accountId) {
+    return fail(c.req.query("error_message") ?? "No se completó la conexión con Meta. Vuelve a intentarlo.");
+  }
+  try {
+    const account = await findAccount(c.env, platform, accountId);
+    await saveChannel(c.env, {
+      platform,
+      accountId,
+      name: account?.displayName ?? c.req.query("username") ?? null,
+      username: account?.username ?? c.req.query("username") ?? null,
+      picture: account?.profilePicture ?? null,
+    });
+    await syncWebhook(c.env, origin(c));
+  } catch (err) {
+    return fail(explain(err));
+  }
+  return c.redirect(`${page}/${encodeURIComponent(accountId)}?success=true`);
+});
+
+// ---------- Con sesión ----------
+
+export const channels = new Hono<NubotEnv>();
+
+channels.get("/channels", async (c) => {
+  const rows = await listChannels(c.env, c.req.query("withDeleted") === "true");
+  return c.json(rows.map(toPanelChannel));
+});
+
+/** El enlace de Zernio para conectar. Si algo falla, el «enlace» es la misma pantalla con el aviso. */
+async function authUrl(c: Ctx, platform: Platform) {
+  const denied = onlyAdmin(c);
+  if (denied) return denied;
+  const back = new URL("/api/v1/channels/zernio/callback", origin(c));
+  back.searchParams.set("state", await connectState(c.env, platform));
+  try {
+    return c.json({ url: await connectUrl(c.env, platform, back.toString()) });
+  } catch (err) {
+    return c.json({ url: `/conexiones/${PANEL_PAGE[platform]}?error=${encodeURIComponent(explain(err))}` });
+  }
+}
+
+channels.post("/channels/instagram/auth/url", (c) => authUrl(c, "instagram"));
+channels.post("/channels/messenger/auth/url", (c) => authUrl(c, "facebook"));
+
+/**
+ * Desconecta: el CRM deja de recibir sus mensajes y las conversaciones se quedan. Instagram y Facebook
+ * además se sueltan en Zernio (dejan de cobrarse); el número de WhatsApp no, porque registrarlo de nuevo con Meta es delicado.
+ */
+async function disconnect(c: Ctx, accountId: string | undefined) {
+  const denied = onlyAdmin(c);
+  if (denied) return denied;
+  const row = accountId ? await channelByAccount(c.env, accountId) : null;
+  if (!row) return c.json({ success: false, message: "Esa conexión no existe." }, 404);
+  try {
+    if (row.platform !== "whatsapp") await deleteAccount(c.env, row.zernio_account_id);
+    await c.env.DB.prepare("UPDATE channels SET active = 0, updated_at = ? WHERE id = ?").bind(Date.now(), row.id).run();
+    await syncWebhook(c.env, origin(c));
+  } catch (err) {
+    return c.json({ success: false, message: explain(err) }, 502);
+  }
+  return c.json({ success: true, message: `${PLATFORM_NAMES[row.platform]} desconectado.` });
+}
+
+channels.post("/channels/instagram/auth/disconnect", async (c) => disconnect(c, (await c.req.json<{ channelId?: string }>()).channelId));
+channels.post("/channels/messenger/auth/disconnect", async (c) => disconnect(c, (await c.req.json<{ channelId?: string }>()).channelId));
+channels.delete("/channels/:id", (c) => disconnect(c, c.req.param("id")));
+
+channels.get("/channels/:id", async (c) => {
+  const row = await channelByAccount(c.env, c.req.param("id"));
+  if (!row) return c.json({ message: "Esa conexión no existe.", statusCode: 404 }, 404);
+  return c.json(toPanelChannel(row));
+});
+
+/** Pregunta a Zernio si la cuenta sigue conectada y con permiso. */
+channels.post("/channels/:id/test", async (c) => {
+  const row = await channelByAccount(c.env, c.req.param("id"));
+  if (!row) return c.json({ success: false, message: "Esa conexión no existe." }, 404);
+  try {
+    const account = await findAccount(c.env, row.platform, row.zernio_account_id);
+    if (!account) return c.json({ success: false, message: "Zernio ya no tiene esta cuenta. Conéctala otra vez." });
+    if (account.needsReconnection || account.isActive === false) {
+      return c.json({ success: false, message: "Meta pide volver a conectar esta cuenta. Desconéctala y conéctala otra vez." });
+    }
+    return c.json({ success: true, message: `${PLATFORM_NAMES[row.platform]} conectado y recibiendo mensajes.`, channel: toPanelChannel(row) });
+  } catch (err) {
+    return c.json({ success: false, message: explain(err) });
+  }
+});