nubot-lite 0.1.0 → 0.1.2

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

@@ -1,122 +1,127 @@
-// API con las rutas y las formas de datos que usa el panel de Nubot, montada en /api/v1.
-// Solo cubre lo que Nubot Lite tiene; lo demás responde 404 y el panel lo muestra bloqueado.
-
-import { Hono } from "hono";
-import { createMiddleware } from "hono/factory";
-import type { Env } from "../env";
-import { hashPassword, verifyPassword, MIN_PASSWORD } from "../auth/password";
-import { sameSecret } from "../auth/session";
-import { newId } from "../inbox/store";
-import { verifyAccessToken } from "./jwt";
-import { clearRefresh, loadUser, ORG_ID, refreshUserId, sessionResponse, toPanelUser, type UserRow } from "./session";
-import { account } from "./account";
-import { agents } from "./agents";
-import { contacts } from "./contacts";
-import { funnels } from "./funnels";
-import { products } from "./products";
-import { invitationsPublic, team } from "./team";
-import { templates } from "./templates";
-import { inbox } from "./inbox";
-import { uploads } from "./uploads";
-import { rememberPublicOrigin } from "../media/files";
-
-export type NubotEnv = { Bindings: Env; Variables: { user: UserRow } };
-
-export const nubot = new Hono<NubotEnv>();
-
-nubot.onError((err, c) => {
-  console.error(err);
-  return c.json({ message: "Algo salió mal en el servidor. Intenta de nuevo.", statusCode: 500 }, 500);
-});
-
-/** El panel consulta esto para mostrar si hay conexión con el servidor. */
-nubot.get("/health", (c) => c.json({ status: "ok" }));
-
-// ---------- Sesión ----------
-
-nubot.post("/auth/login", async (c) => {
-  const body = await c.req.json<{ email?: string; password?: string }>().catch(() => ({}) as { email?: string; password?: string });
-  const row = await c.env.DB.prepare("SELECT id, email, name, role, password_hash FROM users WHERE email = ?")
-    .bind(body.email?.trim().toLowerCase() ?? "")
-    .first<UserRow & { password_hash: string }>();
-  if (!row || !body.password || !(await verifyPassword(body.password, row.password_hash))) {
-    return c.json({ message: "El correo o la contraseña no coinciden.", statusCode: 401 }, 401);
-  }
-  const now = Date.now();
-  await c.env.DB.prepare("UPDATE users SET last_login_at = ? WHERE id = ?").bind(now, row.id).run();
-  c.executionCtx.waitUntil(rememberPublicOrigin(c.env, new URL(c.req.url).origin));
-  return sessionResponse(c, { ...row, last_login_at: now });
-});
-
-nubot.post("/auth/refresh", async (c) => {
-  const userId = await refreshUserId(c);
-  const user = userId ? await loadUser(c.env, userId) : null;
-  if (!user) {
-    clearRefresh(c);
-    return c.json({ message: "La sesión venció. Vuelve a iniciar sesión.", statusCode: 401 }, 401);
-  }
-  return sessionResponse(c, user);
-});
-
-nubot.post("/auth/logout", (c) => {
-  clearRefresh(c);
-  return c.json({ ok: true });
-});
-
-/** En Lite no hay cuentas corporativas: todo se entra con correo y contraseña. */
-nubot.get("/auth/check-domain", (c) => c.json({ isEnterprise: false, passwordLoginAllowed: true }));
-
-nubot.get("/auth/lite-state", async (c) => {
-  const row = await c.env.DB.prepare("SELECT COUNT(*) AS n FROM users").first<{ n: number }>();
-  return c.json({ setupRequired: (row?.n ?? 0) === 0 });
-});
-
-/** Crea el primer administrador con la llave de admin del instalador. */
-nubot.post("/auth/lite-setup", async (c) => {
-  const body = await c.req.json<{ adminToken?: string; email?: string; name?: string; password?: string }>();
-  if (!sameSecret(body.adminToken, c.env.ADMIN_TOKEN)) return c.json({ message: "La llave de admin no es correcta." }, 401);
-  const count = await c.env.DB.prepare("SELECT COUNT(*) AS n FROM users").first<{ n: number }>();
-  if ((count?.n ?? 0) > 0) return c.json({ message: "El administrador ya fue creado. Inicia sesión." }, 409);
-  const email = body.email?.trim().toLowerCase();
-  const name = body.name?.trim();
-  if (!email || !name) return c.json({ message: "Escribe tu nombre y tu correo." }, 400);
-  if (!body.password || body.password.length < MIN_PASSWORD) {
-    return c.json({ message: `La contraseña necesita al menos ${MIN_PASSWORD} caracteres.` }, 400);
-  }
-  const user: UserRow = { id: newId(), email, name, role: "admin", last_login_at: Date.now() };
-  await c.env.DB.prepare(
-    "INSERT INTO users (id, email, name, password_hash, role, created_at, last_login_at) VALUES (?, ?, ?, ?, 'admin', ?, ?)",
-  )
-    .bind(user.id, email, name, await hashPassword(body.password), user.last_login_at, user.last_login_at)
-    .run();
-  return sessionResponse(c, user, 201);
-});
-
-nubot.route("/", invitationsPublic);
-
-// ---------- Lo demás pide sesión ----------
-
-nubot.use("*", createMiddleware<NubotEnv>(async (c, next) => {
-  const token = c.req.header("Authorization")?.replace(/^Bearer /, "");
-  const userId = await verifyAccessToken(c.env.SESSION_SECRET, token);
-  const user = userId ? await loadUser(c.env, userId) : null;
-  if (!user) return c.json({ message: "Inicia sesión para continuar.", statusCode: 401 }, 401);
-  c.set("user", user);
-  await next();
-}));
-
-nubot.get("/users/me", (c) => c.json(toPanelUser(c.get("user"))));
-nubot.patch("/users/me/status", (c) => c.json({ ok: true }));
-nubot.patch("/users/me/preferences", (c) => c.json({ ok: true }));
-
-nubot.route("/", account);
-nubot.route("/", inbox);
-nubot.route("/", contacts);
-nubot.route("/", uploads);
-nubot.route("/", funnels);
-nubot.route("/", agents);
-nubot.route("/", products);
-nubot.route("/", team);
-nubot.route("/", templates);
-
-nubot.notFound((c) => c.json({ message: "Esta función está disponible en Nubot.", statusCode: 404, organizationId: ORG_ID }, 404));
+// API con las rutas y las formas de datos que usa el panel de Nubot, montada en /api/v1.
+// Solo cubre lo que Nubot Lite tiene; lo demás responde 404 y el panel lo muestra bloqueado.
+
+import { Hono } from "hono";
+import { createMiddleware } from "hono/factory";
+import type { Env } from "../env";
+import { hashPassword, verifyPassword, MIN_PASSWORD } from "../auth/password";
+import { sameSecret } from "../auth/session";
+import { newId } from "../inbox/store";
+import { verifyAccessToken } from "./jwt";
+import { clearRefresh, loadUser, ORG_ID, refreshUserId, sessionResponse, toPanelUser, type UserRow } from "./session";
+import { account } from "./account";
+import { channels, channelsPublic } from "./channels";
+import { agents } from "./agents";
+import { aiUsage } from "./ai-usage";
+import { contacts } from "./contacts";
+import { funnels } from "./funnels";
+import { products } from "./products";
+import { invitationsPublic, team } from "./team";
+import { templates } from "./templates";
+import { inbox } from "./inbox";
+import { uploads } from "./uploads";
+import { rememberPublicOrigin } from "../media/files";
+
+export type NubotEnv = { Bindings: Env; Variables: { user: UserRow } };
+
+export const nubot = new Hono<NubotEnv>();
+
+nubot.onError((err, c) => {
+  console.error(err);
+  return c.json({ message: "Algo salió mal en el servidor. Intenta de nuevo.", statusCode: 500 }, 500);
+});
+
+/** El panel consulta esto para mostrar si hay conexión con el servidor. */
+nubot.get("/health", (c) => c.json({ status: "ok" }));
+
+// ---------- Sesión ----------
+
+nubot.post("/auth/login", async (c) => {
+  const body = await c.req.json<{ email?: string; password?: string }>().catch(() => ({}) as { email?: string; password?: string });
+  const row = await c.env.DB.prepare("SELECT id, email, name, role, password_hash FROM users WHERE email = ?")
+    .bind(body.email?.trim().toLowerCase() ?? "")
+    .first<UserRow & { password_hash: string }>();
+  if (!row || !body.password || !(await verifyPassword(body.password, row.password_hash))) {
+    return c.json({ message: "El correo o la contraseña no coinciden.", statusCode: 401 }, 401);
+  }
+  const now = Date.now();
+  await c.env.DB.prepare("UPDATE users SET last_login_at = ? WHERE id = ?").bind(now, row.id).run();
+  c.executionCtx.waitUntil(rememberPublicOrigin(c.env, new URL(c.req.url).origin));
+  return sessionResponse(c, { ...row, last_login_at: now });
+});
+
+nubot.post("/auth/refresh", async (c) => {
+  const userId = await refreshUserId(c);
+  const user = userId ? await loadUser(c.env, userId) : null;
+  if (!user) {
+    clearRefresh(c);
+    return c.json({ message: "La sesión venció. Vuelve a iniciar sesión.", statusCode: 401 }, 401);
+  }
+  return sessionResponse(c, user);
+});
+
+nubot.post("/auth/logout", (c) => {
+  clearRefresh(c);
+  return c.json({ ok: true });
+});
+
+/** En Lite no hay cuentas corporativas: todo se entra con correo y contraseña. */
+nubot.get("/auth/check-domain", (c) => c.json({ isEnterprise: false, passwordLoginAllowed: true }));
+
+nubot.get("/auth/lite-state", async (c) => {
+  const row = await c.env.DB.prepare("SELECT COUNT(*) AS n FROM users").first<{ n: number }>();
+  return c.json({ setupRequired: (row?.n ?? 0) === 0 });
+});
+
+/** Crea el primer administrador con la llave de admin del instalador. */
+nubot.post("/auth/lite-setup", async (c) => {
+  const body = await c.req.json<{ adminToken?: string; email?: string; name?: string; password?: string }>();
+  if (!sameSecret(body.adminToken, c.env.ADMIN_TOKEN)) return c.json({ message: "La llave de admin no es correcta." }, 401);
+  const count = await c.env.DB.prepare("SELECT COUNT(*) AS n FROM users").first<{ n: number }>();
+  if ((count?.n ?? 0) > 0) return c.json({ message: "El administrador ya fue creado. Inicia sesión." }, 409);
+  const email = body.email?.trim().toLowerCase();
+  const name = body.name?.trim();
+  if (!email || !name) return c.json({ message: "Escribe tu nombre y tu correo." }, 400);
+  if (!body.password || body.password.length < MIN_PASSWORD) {
+    return c.json({ message: `La contraseña necesita al menos ${MIN_PASSWORD} caracteres.` }, 400);
+  }
+  const user: UserRow = { id: newId(), email, name, role: "admin", last_login_at: Date.now() };
+  await c.env.DB.prepare(
+    "INSERT INTO users (id, email, name, password_hash, role, created_at, last_login_at) VALUES (?, ?, ?, ?, 'admin', ?, ?)",
+  )
+    .bind(user.id, email, name, await hashPassword(body.password), user.last_login_at, user.last_login_at)
+    .run();
+  return sessionResponse(c, user, 201);
+});
+
+nubot.route("/", invitationsPublic);
+nubot.route("/", channelsPublic);
+
+// ---------- Lo demás pide sesión ----------
+
+nubot.use("*", createMiddleware<NubotEnv>(async (c, next) => {
+  const token = c.req.header("Authorization")?.replace(/^Bearer /, "");
+  const userId = await verifyAccessToken(c.env.SESSION_SECRET, token);
+  const user = userId ? await loadUser(c.env, userId) : null;
+  if (!user) return c.json({ message: "Inicia sesión para continuar.", statusCode: 401 }, 401);
+  c.set("user", user);
+  await next();
+}));
+
+nubot.get("/users/me", (c) => c.json(toPanelUser(c.get("user"))));
+nubot.patch("/users/me/status", (c) => c.json({ ok: true }));
+nubot.patch("/users/me/preferences", (c) => c.json({ ok: true }));
+
+nubot.route("/", account);
+nubot.route("/", channels);
+nubot.route("/", inbox);
+nubot.route("/", contacts);
+nubot.route("/", uploads);
+nubot.route("/", funnels);
+nubot.route("/", aiUsage);
+nubot.route("/", agents);
+nubot.route("/", products);
+nubot.route("/", team);
+nubot.route("/", templates);
+
+nubot.notFound((c) => c.json({ message: "Esta función está disponible en Nubot.", statusCode: 404, organizationId: ORG_ID }, 404));

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

@@ -3,8 +3,11 @@
 import type { Env } from "../env";
 import { publicLink, type StoredAttachment } from "../media/files";
 import { ORG_ID } from "./session";
+import { isPlatform, PLATFORM_NAMES, type Platform } from "../channels/accounts";
+
+/** El tipo de canal con el que el panel elige el ícono. Messenger va por la página de Facebook. */
+export const PANEL_CHANNEL_TYPE: Record<Platform, string> = { whatsapp: "WHATSAPP", instagram: "INSTAGRAM", facebook: "FACEBOOK" };
 
-export const CHANNEL_ID = "whatsapp";
 export const AGENT_ID = "lite-agent";
 
 /** Los enlaces de archivos que ve el panel duran un día; el panel pide otro si vence. */
@@ -13,6 +16,7 @@ export const PANEL_LINK_TTL_MS = 24 * 60 * 60 * 1000;
 export interface ConversationRecord {
   id: string;
   contact_id: string;
+  channel: string;
   status: "ai" | "human" | "closed";
   assigned_user_id: string | null;
   funnel_id: string | null;
@@ -56,6 +60,7 @@ const iso = (ms: number | null | undefined) => (ms ? new Date(ms).toISOString()
 
 export const CONVERSATION_COLUMNS = [
   "id",
+  "channel",
   "contact_id",
   "status",
   "assigned_user_id",
@@ -91,7 +96,7 @@ export function toTicket(c: ConversationRecord) {
     id: c.id,
     orgId: ORG_ID,
     contactId: c.contact_id,
-    channelId: CHANNEL_ID,
+    channelId: c.zernio_account_id,
     status: ticketStatus(c),
     assignedAgentId: c.status === "ai" ? null : c.assigned_user_id,
     aiAgentId: c.status === "ai" ? AGENT_ID : null,
@@ -124,8 +129,10 @@ export function toContact(c: ContactRecord, tags: string[] = []) {
   };
 }
 
-export function channel(accountId?: string | null) {
-  return { id: CHANNEL_ID, name: "WhatsApp", type: "WHATSAPP", providerId: accountId ?? "", isActive: true, config: {} };
+/** El canal de una conversación en la forma del panel. Su id es el de la cuenta en Zernio. */
+export function channel(platform: string, accountId?: string | null) {
+  const p = isPlatform(platform) ? platform : "whatsapp";
+  return { id: accountId ?? p, name: PLATFORM_NAMES[p], type: PANEL_CHANNEL_TYPE[p], providerId: accountId ?? "", isActive: true, config: {} };
 }
 
 const SENDER: Record<MessageRecord["sender_type"], string> = {
@@ -220,7 +227,7 @@ export async function toConversations(env: Env, rows: ConversationRecord[], orig
       return {
         ticket: toTicket(c),
         contact: contact ? toContact(contact, tagsByContact.get(c.contact_id)) : null,
-        channel: channel(c.zernio_account_id),
+        channel: channel(c.channel, c.zernio_account_id),
         lastMessage: last ? await toMessage(env, last, origin) : undefined,
         messages: [],
       };

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

@@ -0,0 +1,13 @@
+import { Hono } from "hono";
+import type { AppEnv } from "../http";
+import { isPlatform, saveChannel } from "../channels/accounts";
+
+export const channelsAdmin = new Hono<AppEnv>();
+
+/** `npx nubot-lite whatsapp` registra aquí el número que eligió, para que el panel lo muestre en Conexiones. */
+channelsAdmin.put("/", async (c) => {
+  const body = await c.req.json<{ platform?: string; accountId?: string; name?: string }>();
+  if (!isPlatform(body.platform) || !body.accountId) return c.json({ error: "Faltan platform y accountId." }, 400);
+  const row = await saveChannel(c.env, { platform: body.platform, accountId: body.accountId, name: body.name ?? null });
+  return c.json({ id: row.id, platform: row.platform, accountId: row.zernio_account_id });
+});

package/template/worker/src/routes/system.ts

@@ -1,100 +1,110 @@
-import { Hono } from "hono";
-import Anthropic from "@anthropic-ai/sdk";
-import type { AppEnv } from "../http";
-import { newId } from "../inbox/store";
-import { loadAgentSettings } from "../agent/settings";
-import { publicOrigin } from "../media/files";
-
-export const system = new Hono<AppEnv>();
-
-type Check = { name: string; ok: boolean; detail: string };
-
-/** Revisa todo lo que necesita la instalación. Lo usa `npx nubot-lite doctor`. */
-system.get("/health", async (c) => {
-  const checks: Check[] = [];
-  const settings = await loadAgentSettings(c.env);
-
-  try {
-    const users = await c.env.DB.prepare("SELECT COUNT(*) AS n FROM users").first<{ n: number }>();
-    checks.push({ name: "Base de datos", ok: true, detail: users?.n ? `${users.n} usuario(s)` : "Falta crear el administrador desde el panel" });
-  } catch (err) {
-    checks.push({ name: "Base de datos", ok: false, detail: `No responde o faltan migraciones: ${String(err)}` });
-  }
-
-  try {
-    await c.env.FILES.put("doctor/check", "ok", { expirationTtl: 60 });
-    checks.push({ name: "Archivos (KV)", ok: (await c.env.FILES.get("doctor/check")) === "ok", detail: "Se puede guardar y leer" });
-  } catch (err) {
-    checks.push({ name: "Archivos (KV)", ok: false, detail: String(err) });
-  }
-
-  if (!c.env.ANTHROPIC_API_KEY) {
-    checks.push({ name: "Claude", ok: false, detail: "Falta conectar el agente. Corre: npx nubot-lite claude" });
-  } else {
-    try {
-      const model = await new Anthropic({ apiKey: c.env.ANTHROPIC_API_KEY }).models.retrieve(settings.model);
-      checks.push({ name: "Claude", ok: true, detail: `La llave funciona y el modelo ${model.id} está disponible` });
-    } catch (err) {
-      const detail = err instanceof Anthropic.AuthenticationError ? "La llave de Anthropic no es válida" : err instanceof Anthropic.NotFoundError ? `El modelo ${settings.model} no está disponible para esta llave` : String(err);
-      checks.push({ name: "Claude", ok: false, detail });
-    }
-  }
-
-  if (!c.env.ZERNIO_API_KEY) {
-    const detail = "Falta conectar WhatsApp. Corre: npx nubot-lite whatsapp";
-    checks.push({ name: "Zernio", ok: false, detail }, { name: "Webhook en Zernio", ok: false, detail });
-  } else {
-    checks.push(await zernioCheck(c.env), await webhookCheck(c.env, `${new URL(c.req.url).origin}/webhooks/zernio`));
-  }
-
-  checks.push({ name: "Notas de voz", ok: !!c.env.AI, detail: c.env.AI ? "Workers AI disponible" : "Sin Workers AI: las notas de voz no se transcriben" });
-  const origin = await publicOrigin(c.env);
-  checks.push({ name: "Webhook", ok: !!origin, detail: origin ? `Zernio ya escribió a ${origin}` : "Todavía no llegó ningún mensaje de WhatsApp" });
-
-  return c.json({ ok: checks.every((x) => x.ok), checks });
-});
-
-const unreachable = (err: unknown) => `No pude conectar con Zernio: ${err instanceof Error ? err.message : String(err)}`;
-
-/** La llave de Zernio y el número conectado. El número de prueba compartido no está entre las cuentas: sale en sus números. */
-async function zernioCheck(env: AppEnv["Bindings"]): Promise<Check> {
-  try {
-    const headers = { Authorization: `Bearer ${env.ZERNIO_API_KEY}` };
-    const res = await fetch(`${env.ZERNIO_API_BASE}/v1/accounts?platform=whatsapp`, { headers });
-    if (!res.ok) return { name: "Zernio", ok: false, detail: `La API key de Zernio no funciona (${res.status}). Corre otra vez: npx nubot-lite whatsapp` };
-    const { accounts = [] } = (await res.json().catch(() => ({}))) as { accounts?: { username?: string; displayName?: string }[] };
-    const names = accounts.map((a) => a.displayName ?? a.username ?? "WhatsApp");
-    const numbers = await fetch(`${env.ZERNIO_API_BASE}/v1/phone-numbers`, { headers }).catch(() => null);
-    const { sandbox } = numbers?.ok ? ((await numbers.json().catch(() => ({}))) as { sandbox?: { phoneNumber?: string } }) : {};
-    if (sandbox?.phoneNumber) names.push(`número de prueba ${sandbox.phoneNumber}`);
-    return names.length
-      ? { name: "Zernio", ok: true, detail: `WhatsApp conectado: ${names.join(", ")}` }
-      : { name: "Zernio", ok: false, detail: "La llave funciona pero no hay un número de WhatsApp conectado en Zernio" };
-  } catch (err) {
-    return { name: "Zernio", ok: false, detail: unreachable(err) };
-  }
-}
-
-async function webhookCheck(env: AppEnv["Bindings"], expected: string): Promise<Check> {
-  try {
-    const res = await fetch(`${env.ZERNIO_API_BASE}/v1/webhooks/settings`, { headers: { Authorization: `Bearer ${env.ZERNIO_API_KEY}` } });
-    const body = (await res.json().catch(() => ({}))) as { webhooks?: { url: string; isActive?: boolean }[] };
-    const found = (body.webhooks ?? []).find((w) => w.url === expected);
-    return {
-      name: "Webhook en Zernio",
-      ok: !!found?.isActive,
-      detail: found ? (found.isActive ? `Registrado: ${expected}` : "Registrado pero desactivado") : `Falta registrar ${expected}. Corre: npx nubot-lite whatsapp`,
-    };
-  } catch (err) {
-    return { name: "Webhook en Zernio", ok: false, detail: unreachable(err) };
-  }
-}
-
-/** Conversación de prueba con el agente real. Cuerpo: { messages: ["hola", "¿tienen depas en Surco?"] } */
-system.post("/agent/test", async (c) => {
-  const { messages } = await c.req.json<{ messages?: string[] }>();
-  const turns = (messages ?? []).map((m) => String(m).trim()).filter(Boolean).slice(0, 10);
-  if (!turns.length) return c.json({ error: "Manda al menos un mensaje de cliente." }, 400);
-  const stub = c.env.CONVERSATION.get(c.env.CONVERSATION.idFromName(`prueba:${newId()}`));
-  return c.json(await stub.sandbox(turns));
-});
+import { Hono } from "hono";
+import Anthropic from "@anthropic-ai/sdk";
+import type { AppEnv } from "../http";
+import { newId } from "../inbox/store";
+import { loadAgentSettings } from "../agent/settings";
+import { publicOrigin } from "../media/files";
+import { listChannels, PLATFORM_NAMES } from "../channels/accounts";
+
+export const system = new Hono<AppEnv>();
+
+type Check = { name: string; ok: boolean; detail: string };
+
+/** Revisa todo lo que necesita la instalación. Lo usa `npx nubot-lite doctor`. */
+system.get("/health", async (c) => {
+  const checks: Check[] = [];
+  const settings = await loadAgentSettings(c.env);
+
+  try {
+    const users = await c.env.DB.prepare("SELECT COUNT(*) AS n FROM users").first<{ n: number }>();
+    checks.push({ name: "Base de datos", ok: true, detail: users?.n ? `${users.n} usuario(s)` : "Falta crear el administrador desde el panel" });
+  } catch (err) {
+    checks.push({ name: "Base de datos", ok: false, detail: `No responde o faltan migraciones: ${String(err)}` });
+  }
+
+  try {
+    await c.env.FILES.put("doctor/check", "ok", { expirationTtl: 60 });
+    checks.push({ name: "Archivos (KV)", ok: (await c.env.FILES.get("doctor/check")) === "ok", detail: "Se puede guardar y leer" });
+  } catch (err) {
+    checks.push({ name: "Archivos (KV)", ok: false, detail: String(err) });
+  }
+
+  if (!c.env.ANTHROPIC_API_KEY) {
+    checks.push({ name: "Claude", ok: false, detail: "Falta conectar el agente. Corre: npx nubot-lite claude" });
+  } else {
+    try {
+      const model = await new Anthropic({ apiKey: c.env.ANTHROPIC_API_KEY }).models.retrieve(settings.model);
+      checks.push({ name: "Claude", ok: true, detail: `La llave funciona y el modelo ${model.id} está disponible` });
+    } catch (err) {
+      const detail = err instanceof Anthropic.AuthenticationError ? "La llave de Anthropic no es válida" : err instanceof Anthropic.NotFoundError ? `El modelo ${settings.model} no está disponible para esta llave` : String(err);
+      checks.push({ name: "Claude", ok: false, detail });
+    }
+  }
+
+  if (!c.env.ZERNIO_API_KEY) {
+    const detail = "Falta conectar WhatsApp. Corre: npx nubot-lite whatsapp";
+    checks.push({ name: "Zernio", ok: false, detail }, { name: "Webhook en Zernio", ok: false, detail });
+  } else {
+    checks.push(await zernioCheck(c.env), await webhookCheck(c.env, `${new URL(c.req.url).origin}/webhooks/zernio`));
+  }
+
+  const connected = await listChannels(c.env);
+  checks.push({
+    name: "Canales",
+    ok: connected.length > 0,
+    detail: connected.length
+      ? connected.map((ch) => `${PLATFORM_NAMES[ch.platform]}${ch.username ? ` @${ch.username}` : ch.name && ch.name !== PLATFORM_NAMES[ch.platform] ? ` (${ch.name})` : ""}`).join(", ")
+      : "Ningún canal conectado. Corre: npx nubot-lite whatsapp",
+  });
+
+  checks.push({ name: "Notas de voz", ok: !!c.env.AI, detail: c.env.AI ? "Workers AI disponible" : "Sin Workers AI: las notas de voz no se transcriben" });
+  const origin = await publicOrigin(c.env);
+  checks.push({ name: "Webhook", ok: !!origin, detail: origin ? `Zernio ya escribió a ${origin}` : "Todavía no llegó ningún mensaje de WhatsApp" });
+
+  return c.json({ ok: checks.every((x) => x.ok), checks });
+});
+
+const unreachable = (err: unknown) => `No pude conectar con Zernio: ${err instanceof Error ? err.message : String(err)}`;
+
+/** La llave de Zernio y el número conectado. El número de prueba compartido no está entre las cuentas: sale en sus números. */
+async function zernioCheck(env: AppEnv["Bindings"]): Promise<Check> {
+  try {
+    const headers = { Authorization: `Bearer ${env.ZERNIO_API_KEY}` };
+    const res = await fetch(`${env.ZERNIO_API_BASE}/v1/accounts?platform=whatsapp`, { headers });
+    if (!res.ok) return { name: "Zernio", ok: false, detail: `La API key de Zernio no funciona (${res.status}). Corre otra vez: npx nubot-lite whatsapp` };
+    const { accounts = [] } = (await res.json().catch(() => ({}))) as { accounts?: { username?: string; displayName?: string }[] };
+    const names = accounts.map((a) => a.displayName ?? a.username ?? "WhatsApp");
+    const numbers = await fetch(`${env.ZERNIO_API_BASE}/v1/phone-numbers`, { headers }).catch(() => null);
+    const { sandbox } = numbers?.ok ? ((await numbers.json().catch(() => ({}))) as { sandbox?: { phoneNumber?: string } }) : {};
+    if (sandbox?.phoneNumber) names.push(`número de prueba ${sandbox.phoneNumber}`);
+    return names.length
+      ? { name: "Zernio", ok: true, detail: `WhatsApp conectado: ${names.join(", ")}` }
+      : { name: "Zernio", ok: false, detail: "La llave funciona pero no hay un número de WhatsApp conectado en Zernio" };
+  } catch (err) {
+    return { name: "Zernio", ok: false, detail: unreachable(err) };
+  }
+}
+
+async function webhookCheck(env: AppEnv["Bindings"], expected: string): Promise<Check> {
+  try {
+    const res = await fetch(`${env.ZERNIO_API_BASE}/v1/webhooks/settings`, { headers: { Authorization: `Bearer ${env.ZERNIO_API_KEY}` } });
+    const body = (await res.json().catch(() => ({}))) as { webhooks?: { url: string; isActive?: boolean }[] };
+    const found = (body.webhooks ?? []).find((w) => w.url === expected);
+    return {
+      name: "Webhook en Zernio",
+      ok: !!found?.isActive,
+      detail: found ? (found.isActive ? `Registrado: ${expected}` : "Registrado pero desactivado") : `Falta registrar ${expected}. Corre: npx nubot-lite whatsapp`,
+    };
+  } catch (err) {
+    return { name: "Webhook en Zernio", ok: false, detail: unreachable(err) };
+  }
+}
+
+/** Conversación de prueba con el agente real. Cuerpo: { messages: ["hola", "¿tienen depas en Surco?"] } */
+system.post("/agent/test", async (c) => {
+  const { messages } = await c.req.json<{ messages?: string[] }>();
+  const turns = (messages ?? []).map((m) => String(m).trim()).filter(Boolean).slice(0, 10);
+  if (!turns.length) return c.json({ error: "Manda al menos un mensaje de cliente." }, 400);
+  const stub = c.env.CONVERSATION.get(c.env.CONVERSATION.idFromName(`prueba:${newId()}`));
+  return c.json(await stub.sandbox(turns));
+});