@7ots/cli 0.1.0

package/server/channels/apuchat.mjs

@@ -0,0 +1,364 @@
+/**
+ * Canal apuchat: el agente tiene su propio @handle.
+ *
+ *  - Mensajes: cualquiera le escribe por la app de apuchat y el agente contesta.
+ *  - Videollamada: en meet.apuchat.com pulsas 📞 Ring y escribes su @handle → le llega un
+ *    mensaje con "Channel id / Token / PIN" (o un enlace /call#…) y entra en la llamada con su
+ *    propio avatar. Tú hablas; meet transcribe, el agente responde y tu navegador lo dice.
+ *  - Llamada al teléfono: si le pides "llámame", crea una llamada y te manda el enlace por
+ *    mensaje; eso hace SONAR la app de apuchat del móvil (push VoIP). No hay telefonía
+ *    clásica (SIP/PSTN): la "llamada" es la de la app.
+ *
+ *   APUCHAT_AGENT_IDENTITY_KEY  clave de la identidad del agente (X-Identity-Key). Usa un
+ *                               handle permanente: los gratis caducan tras 24 h sin mensajes
+ *                               (escuchar cuenta como actividad, así que aguanta encendido).
+ *   APUCHAT_AGENT_ALLOW         opcional: @handles que pueden hablarle (coma). Vacío = todos.
+ *   El avatar y la escena de meet salen de la identidad (look.meetAvatar / look.meetScene;
+ *   por defecto APUCHAT_AGENT_AVATAR / APUCHAT_AGENT_SCENE) y se leen en cada llamada.
+ *   AGENT_CALL_MAX_MINUTES      (defecto 15) · AGENT_CALL_MAX_TURNS (40) · AGENT_MAX_CALLS (3)
+ *
+ * Contrato del hub (apuchat.com):
+ *   GET  /api/dm/wait?since&timeout≤300   X-Identity-Key  → { callsign, messages:[{id,from,to,text,at}], next_since }
+ *   POST /api/dm  { to, text ≤4096 }       X-Identity-Key  → 202 siempre (0,5 msg/s por identidad)
+ *   POST /api/video-call {}                → { channel_id, channel_token, owner_password, call_url, … }
+ *   Canal: /join {identity_key, owner_password?} → session_id · /wait · /send {to:'all', message, kind?} · /leave
+ *   Tras entrar: ping kind:"status" (así meet lo trata como agente), luego "[avatar]<nombre>".
+ *   Líneas de control "[…]": se ignoran todas salvo "[lang]<código>".
+ *
+ * Textos fijos para la persona (avisos, saludo de reserva): en el idioma de la llamada
+ * ("[lang]") o, si no, en el de la identidad / LOCALE. Los registros siguen en español.
+ */
+
+import { resolveLocale, translator } from '../../src/i18n/index.js';
+import { i18nError, serverLocale } from '../i18n.mjs';
+
+const env = process.env;
+const DM_GAP_MS = 2100; // 0,5 mensajes/s por identidad
+const DM_MAX = 4000;
+const BACKLOG_MAX_AGE_MS = 10 * 60 * 1000;
+const INVITE_MAX_AGE_MS = 3 * 60 * 1000; // una invitación vieja es una llamada que ya acabó
+const PER_SENDER_PER_HOUR = 30;
+/** Configuración del canal desde el entorno (el SDK puede pasar la suya). */
+export function apuchatConfigFromEnv(e = env) {
+  return {
+    hub: e.APUCHAT_HUB || 'https://apuchat.com',
+    identityKey: e.APUCHAT_AGENT_IDENTITY_KEY || '',
+    allow: e.APUCHAT_AGENT_ALLOW || '',
+    maxCalls: Number(e.AGENT_MAX_CALLS || 3),
+    maxMinutes: Number(e.AGENT_CALL_MAX_MINUTES || 15),
+    maxTurns: Number(e.AGENT_CALL_MAX_TURNS || 40),
+  };
+}
+
+export function apuchatConfigured(cfg = apuchatConfigFromEnv()) {
+  return !!cfg.identityKey;
+}
+
+/**
+ * @param {{ agent: ReturnType<import('./agent.mjs').createServerAgent>, persona: Function, log: Function, config?: object }} deps
+ */
+export function createApuchatChannel({ agent, persona, log, config = apuchatConfigFromEnv() }) {
+  const cfg = { ...apuchatConfigFromEnv({}), ...config };
+  const key = cfg.identityKey;
+  const hub = String(cfg.hub).replace(/\/$/, '');
+  const hubFetch = (method, path, o) => hubRequest(hub, method, path, o);
+  const allow = (Array.isArray(cfg.allow) ? cfg.allow : String(cfg.allow || '').split(',')).map((s) => s.trim().replace(/^@/, '').toLowerCase()).filter(Boolean);
+  const { maxCalls, maxMinutes, maxTurns } = cfg;
+
+  const stats = { callsign: null, dmsIn: 0, dmsOut: 0, calls: 0, lastError: null };
+  const calls = new Map(); // channel_id → sesión de llamada
+  const rate = new Map(); // handle → { n, at }
+  let stopped = false;
+
+  // ── DMs: cola de salida para respetar el límite del hub ──
+  let queue = Promise.resolve();
+  function dm(to, text) {
+    const job = queue.then(async () => {
+      const res = await hubFetch('POST', '/api/dm', { headers: { 'X-Identity-Key': key }, body: { to, text: String(text).slice(0, DM_MAX) } });
+      if (!res.ok) throw new Error(`dm ${res.status}`);
+      stats.dmsOut++;
+      await sleep(DM_GAP_MS);
+    });
+    queue = job.catch(() => sleep(DM_GAP_MS));
+    return job;
+  }
+
+  const allowed = (from) => {
+    if (allow.length && !allow.includes(from)) return false;
+    const now = Date.now();
+    const r = rate.get(from);
+    if (!r || now - r.at > 3600_000) {
+      rate.set(from, { n: 1, at: now });
+      return true;
+    }
+    return ++r.n <= PER_SENDER_PER_HOUR;
+  };
+
+  // ── herramienta que el agente puede usar en un chat: llamar a quien le escribe ──
+  const ringTool = {
+    name: 'llamar_por_apuchat',
+    description:
+      'Llama por voz a la persona con la que hablas: crea una videollamada de meet.apuchat.com con tu avatar y ' +
+      'le manda el enlace, lo que hace sonar su app de apuchat. Úsalo cuando pida que la llames o hablar por voz.',
+    parameters: { type: 'object', properties: { motivo: { type: 'string', description: 'De qué vais a hablar (breve)' } } },
+  };
+
+  /**
+   * Crea una videollamada de meet con el agente ya dentro y devuelve el enlace para entrar.
+   * El enlace (`call_url`) lleva el token y el PIN de ESA llamada: solo se entrega a la persona
+   * para la que se creó (por DM o a quien la pidió desde la web), nunca a terceros.
+   */
+  async function openCall({ peer = null, reason = '' } = {}) {
+    if (calls.size >= maxCalls) throw i18nError(503, 'server.channels.tooManyCalls');
+    const res = await hubFetch('POST', '/api/video-call', { body: {} });
+    if (!res.ok || !res.data?.channel_id) throw i18nError(502, 'server.channels.callFailed', { status: res.status });
+    const c = res.data;
+    // Primero entra el agente (así ya está cuando la persona descuelga).
+    startCall({ channel_id: c.channel_id, token: c.channel_token, pin: c.owner_password, peer, reason }).catch((e) => log('apuchat call:', e.message));
+    return { call_url: c.call_url, channel_id: c.channel_id, expires_at: c.expires_at || null };
+  }
+
+  async function ring(handle, motivo = '') {
+    const c = await openCall({ peer: handle, reason: motivo });
+    const t = langT(persona().lang);
+    await dm(handle, motivo ? t('server.channels.ringAbout', { topic: motivo, url: c.call_url }) : t('server.channels.ring', { url: c.call_url })); // suena la app
+    return { ok: true, llamando_a: `@${handle}` };
+  }
+
+  // ── bucle de mensajes ──
+  async function listen() {
+    let since = 0;
+    let first = true;
+    while (!stopped) {
+      try {
+        const res = await hubFetch('GET', `/api/dm/wait?timeout=60${since ? `&since=${since}` : ''}`, { headers: { 'X-Identity-Key': key }, timeoutMs: 75000 });
+        if (res.status === 401 || res.status === 403) {
+          stats.lastError = `wait ${res.status}`;
+          log(`apuchat: la identidad del agente no es válida (${res.status}); se deja de escuchar. ¿Caducó? Revisa APUCHAT_AGENT_IDENTITY_KEY.`);
+          return;
+        }
+        if (!res.ok) throw new Error(`wait ${res.status}`);
+        if (!stats.callsign && res.data.callsign) {
+          stats.callsign = res.data.callsign;
+          log(`apuchat: el agente atiende como @${stats.callsign} (avatar ${persona().meetAvatar})`);
+        }
+        for (const m of res.data.messages || []) {
+          stats.dmsIn++;
+          onDm(m, { backlog: first }).catch((e) => log('apuchat dm:', e.message));
+        }
+        since = res.data.next_since ?? since;
+        first = false;
+      } catch (e) {
+        stats.lastError = e.message;
+        await sleep(5000);
+      }
+    }
+  }
+
+  async function onDm(m, { backlog }) {
+    const from = String(m.from || '').toLowerCase();
+    const text = String(m.text || '').trim();
+    if (!from || from === stats.callsign || !text) return;
+    const age = Date.now() - Number(m.at || 0);
+    const invite = parseInvite(text);
+    if (invite) {
+      if (age > INVITE_MAX_AGE_MS) return log(`apuchat: invitación antigua de @${from} ignorada`);
+      if (!allowed(from)) return;
+      log(`apuchat: @${from} llama al agente → entra en la llamada`);
+      return startCall({ ...invite, peer: from });
+    }
+    if (backlog && age > BACKLOG_MAX_AGE_MS) return;
+    if (!allowed(from)) return;
+    const reply = await agent.respond(`dm:${from}`, 'dm', text, {
+      tools: [ringTool],
+      run: async (name, args) => {
+        if (name !== 'llamar_por_apuchat') throw new Error(`Herramienta desconocida: ${name}`);
+        return ring(from, args.motivo);
+      },
+    });
+    if (reply) await dm(from, reply);
+  }
+
+  // ── una llamada de meet ──
+  async function startCall({ channel_id, token, pin, peer, reason = '' }) {
+    if (calls.has(channel_id)) return;
+    if (calls.size >= maxCalls) {
+      if (peer) await dm(peer, langT(persona().lang)('server.channels.busyDm')).catch(() => {});
+      return;
+    }
+    const p = persona();
+    const s = { ch: channel_id, token, sid: '', cs: '', since: 0, lang: p.lang, turns: 0, start: Date.now(), lastHuman: 0, greeted: false, done: false };
+    calls.set(channel_id, s);
+    const tc = (k, v) => langT(s.lang)(k, v); // s.lang cambia con "[lang]": se resuelve en cada uso
+    stats.calls++;
+    const path = (x) => `/api/channels/${encodeURIComponent(channel_id)}${x}`;
+    const headers = () => ({ Authorization: `Bearer ${token}`, ...(s.sid ? { 'X-Session-Id': s.sid } : {}) });
+    const send = (message, kind) => hubFetch('POST', path('/send'), { headers: headers(), body: { to: 'all', message: String(message).slice(0, 8000), ...(kind ? { kind } : {}) } });
+    const join = async () => {
+      const r = await hubFetch('POST', path('/join'), { headers: { Authorization: `Bearer ${token}` }, body: { identity_key: key, ...(pin ? { owner_password: pin } : {}) } });
+      if (!r.ok) throw new Error(`join ${r.status} ${r.data?.error || ''}`.trim());
+      s.sid = r.data.session_id;
+      s.cs = r.data.callsign || s.cs;
+      for (const m of r.data.history || []) if (m.id > s.since) s.since = m.id;
+    };
+    const leave = async (why) => {
+      if (s.done) return;
+      s.done = true;
+      calls.delete(channel_id);
+      agent.forget(`call:${channel_id}`);
+      log(`apuchat: sale de la llamada (${why}, ${s.turns} turnos)`);
+      await hubFetch('POST', path('/leave'), { headers: headers(), body: {} }).catch(() => {});
+    };
+    const say = async (text) => {
+      if (text) await send(text);
+    };
+    const greet = async () => {
+      if (s.greeted) return;
+      s.greeted = true;
+      s.lastHuman = Date.now();
+      const hello = await agent
+        .respond(`call:${channel_id}`, 'voice', `(La persona${peer ? ` @${peer}` : ''} acaba de entrar en la llamada${reason ? `; ibais a hablar de: ${reason}` : ''}. Salúdala en una frase y pregúntale en qué la ayudas.)`, { lang: s.lang })
+        .catch(() => '');
+      await say(hello || tc('server.channels.hello', { name: p.name }));
+    };
+
+    try {
+      await join();
+      await send(tc('server.channels.here', { name: p.name }), 'status'); // obligatorio: así meet le da avatar y voz
+      await send(`[avatar]${p.meetAvatar || 'vivi'}`);
+      if (p.meetScene) await send(`[scene]${p.meetScene}`);
+    } catch (e) {
+      calls.delete(channel_id);
+      stats.lastError = e.message;
+      log(`apuchat: no pudo entrar en la llamada (${e.message})`);
+      if (peer) await dm(peer, tc('server.channels.joinFailedDm')).catch(() => {});
+      return;
+    }
+
+    while (!s.done && !stopped) {
+      const now = Date.now();
+      if (!s.greeted && now - s.start > 120_000) return leave('nadie entró');
+      if (s.greeted && now - s.lastHuman > 180_000) {
+        await say(tc('server.channels.hangUp'));
+        return leave('silencio');
+      }
+      if (now - s.start > maxMinutes * 60_000 || s.turns >= maxTurns) {
+        await say(tc('server.channels.limit'));
+        return leave('límite');
+      }
+      let r;
+      try {
+        r = await hubFetch('GET', path(`/wait?timeout=25${s.since ? `&since=${s.since}` : ''}`), { headers: headers(), timeoutMs: 40000 });
+      } catch {
+        await sleep(2000);
+        continue;
+      }
+      if (r.status === 400 || r.status === 410) {
+        try {
+          await join(); // not_joined / session_expired → volver a entrar, igual que el navegador
+        } catch (e) {
+          return leave(`no pudo volver a entrar: ${e.message}`);
+        }
+        continue;
+      }
+      if (r.status === 401 || r.status === 403 || r.status === 404) return leave(`canal cerrado (${r.status})`);
+      if (!r.ok) {
+        await sleep(2000);
+        continue;
+      }
+      const lines = [];
+      for (const m of r.data.messages || []) {
+        if (m.id > s.since) s.since = m.id;
+        if (m.from === s.cs || m.kind === 'status' || !m.text) continue;
+        const t = String(m.text);
+        if (t.startsWith('[lang]')) {
+          const code = t.slice(6).trim().split(/\s/)[0].toLowerCase();
+          if (code && code !== 'auto') s.lang = code;
+          await greet();
+          continue;
+        }
+        if (/^\s*\[/.test(t)) continue; // [via] [rtc] [avatar] [scene]…: no son para el agente
+        lines.push(t.trim());
+      }
+      if (!lines.length) continue;
+      // Un /wait puede traer varias frases seguidas (STT por fragmentos): un solo turno.
+      const text = lines.join(' ').slice(0, 1500);
+      s.lastHuman = Date.now();
+      if (!s.greeted) s.greeted = true;
+      s.turns++;
+      await send(tc('server.channels.thinking'), 'status');
+      try {
+        await say(await agent.respond(`call:${channel_id}`, 'voice', text, { lang: s.lang }));
+      } catch (e) {
+        log('apuchat call llm:', e.message);
+        await say(tc('server.channels.repeat'));
+      }
+    }
+    await leave('parado');
+  }
+
+  return {
+    start() {
+      listen();
+    },
+    async stop() {
+      stopped = true;
+      await Promise.all(
+        [...calls.values()].map((s) =>
+          hubFetch('POST', `/api/channels/${encodeURIComponent(s.ch)}/leave`, { headers: { Authorization: `Bearer ${s.token}`, 'X-Session-Id': s.sid }, body: {} }).catch(() => {}),
+        ),
+      );
+    },
+    ring,
+    openCall,
+    handle: () => stats.callsign,
+    status: () => ({ ...stats, activeCalls: calls.size, avatar: persona().meetAvatar }),
+  };
+}
+
+// ───────────────────────────── helpers ─────────────────────────────
+
+/**
+ * Invitación a una llamada dentro de un mensaje: las líneas "Channel id / Token / PIN" del
+ * botón Ring de meet, o un enlace …/call#c=…&t=…&p=… (también en la query).
+ */
+export function parseInvite(text) {
+  const s = String(text || '');
+  const line = (label) => s.match(new RegExp(`${label}\\s*:\\s*([^\\s]+)`, 'i'))?.[1];
+  const id = line('channel id');
+  const token = line('token');
+  if (id && token) return { channel_id: id, token, pin: line('pin') || null };
+  for (const url of s.match(/https?:\/\/[^\s<>"')]+/g) || []) {
+    let u;
+    try {
+      u = new URL(url);
+    } catch {
+      continue;
+    }
+    if (!/\/call\b/.test(u.pathname)) continue;
+    const params = new URLSearchParams(u.hash.slice(1) || u.search.slice(1));
+    const c = params.get('c');
+    const t = params.get('t');
+    if (c && t) return { channel_id: c, token: t, pin: params.get('p') || null };
+  }
+  return null;
+}
+
+async function hubRequest(hub, method, path, { headers = {}, body, timeoutMs = 15000 } = {}) {
+  const res = await fetch(hub + path, {
+    method,
+    headers: { ...(body ? { 'Content-Type': 'application/json' } : {}), ...headers },
+    body: body ? JSON.stringify(body) : undefined,
+    signal: AbortSignal.timeout(timeoutMs),
+  });
+  let data = null;
+  try {
+    data = await res.json();
+  } catch {}
+  return { ok: res.ok, status: res.status, data };
+}
+
+/** Traductor para un idioma de persona o llamada (códigos sin catálogo → inglés; vacío → servidor). */
+const langT = (lang) => translator(lang ? resolveLocale(lang) : serverLocale());
+
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));

package/server/channels/apumail.mjs

@@ -0,0 +1,211 @@
+/**
+ * Canal apumail: el agente tiene su propio buzón y contesta los correos que le llegan.
+ *
+ *   APUMAIL_AGENT_INBOX           dirección del buzón del agente (p. ej. nube@tudominio.com)
+ *   APUMAIL_AGENT_TOKEN           token del buzón (o PAT de la cuenta dueña)
+ *   APUMAIL_AGENT_WEBHOOK_SECRET  opcional: si está, se espera el webhook de apumail en
+ *                                 POST /api/agent/channels/apumail (URL pública) y se verifica
+ *                                 X-Apumail-Signature. Si no, se usa long-poll (/wait).
+ *   APUMAIL_AGENT_DAILY           máximo de respuestas al día (defecto 20)
+ *
+ * Contrato de apumail usado:
+ *   GET  /api/v1/inbox/:address/wait?since=<id>&timeout≤300   Bearer token
+ *        → { messages: StoredMail[], next_since, timed_out }
+ *   POST /api/v1/inbox/:address/send  { to, subject, text, reply_to_mail_id }  (se enhebra solo)
+ *   Webhook: { event:'mail.received', inbox, mail, ts }  +  X-Apumail-Signature: sha256=<hex HMAC del cuerpo>
+ *   StoredMail: { id, to, from, subject, text, html, received_at, … }
+ *
+ * Usa un buzón permanente (dominio propio o handle de pago): los gratis caducan y solo
+ * envían 5 destinatarios al día.
+ */
+
+import { createHmac, timingSafeEqual } from 'node:crypto';
+import { i18nError, reqT, teamT } from '../i18n.mjs';
+
+const env = process.env;
+const BACKLOG_MAX_AGE_MS = 30 * 60 * 1000; // al arrancar, solo se contestan correos recientes
+const PER_SENDER_PER_DAY = 5;
+const MAX_BODY = 256 * 1024;
+
+/** Configuración del canal desde el entorno (el SDK puede pasar la suya). */
+export function apumailConfigFromEnv(e = env) {
+  return {
+    api: e.APUMAIL_API || 'https://api.apumail.com',
+    inbox: e.APUMAIL_AGENT_INBOX || '',
+    token: e.APUMAIL_AGENT_TOKEN || '',
+    webhookSecret: e.APUMAIL_AGENT_WEBHOOK_SECRET || '',
+    daily: Number(e.APUMAIL_AGENT_DAILY || 20),
+  };
+}
+
+export function apumailConfigured(cfg = apumailConfigFromEnv()) {
+  return !!(cfg.inbox && cfg.token);
+}
+
+/**
+ * @param {{ agent: ReturnType<import('./agent.mjs').createServerAgent>, log: Function, config?: object }} deps
+ */
+export function createApumailChannel({ agent, log, config = apumailConfigFromEnv() }) {
+  const cfg = { ...apumailConfigFromEnv({}), ...config };
+  const inbox = String(cfg.inbox || '').toLowerCase();
+  const token = cfg.token;
+  const secret = cfg.webhookSecret || '';
+  const dailyCap = Number(cfg.daily || 20);
+  const base = `${String(cfg.api).replace(/\/$/, '')}/api/v1/inbox/${encodeURIComponent(inbox)}`;
+  const auth = { Authorization: `Bearer ${token}` };
+
+  const seen = new Set(); // ids ya tratados (los webhooks se reintentan)
+  const stats = { mode: secret ? 'webhook' : 'long-poll', received: 0, replied: 0, skipped: 0, lastError: null };
+  let day = '';
+  let sentToday = 0;
+  const perSender = new Map();
+  let stopped = false;
+
+  const budget = (from) => {
+    const d = new Date().toISOString().slice(0, 10);
+    if (d !== day) {
+      day = d;
+      sentToday = 0;
+      perSender.clear();
+    }
+    if (sentToday >= dailyCap) return 'límite diario';
+    if ((perSender.get(from) || 0) >= PER_SENDER_PER_DAY) return 'límite por remitente';
+    return null;
+  };
+
+  async function handleMail(mail, { backlog = false } = {}) {
+    if (!mail?.id || seen.has(mail.id)) return;
+    seen.add(mail.id);
+    if (seen.size > 5000) seen.clear();
+    stats.received++;
+    const from = emailOf(mail.from);
+    const why = skipReason(mail, from, inbox) || (backlog && Date.now() - Number(mail.received_at || 0) > BACKLOG_MAX_AGE_MS ? 'antiguo' : null) || budget(from);
+    if (why) {
+      stats.skipped++;
+      log(`apumail: no se contesta el correo ${mail.id} (${why})`);
+      return;
+    }
+    const subject = String(mail.subject || '').slice(0, 200);
+    const body = (mail.text || stripHtml(mail.html) || '').split('\n').filter((l) => !l.startsWith('>')).join('\n').trim().slice(0, 6000);
+    const reply = await agent.respond(`mail:${from}`, 'email', `Asunto: ${subject || '(sin asunto)'}\n\n${body || '(vacío)'}`);
+    if (!reply) return;
+    const res = await fetch(`${base}/send`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', ...auth },
+      body: JSON.stringify({ to: from, subject: /^re:/i.test(subject) ? subject : `Re: ${subject || teamT()('server.channels.replySubject')}`, text: reply, reply_to_mail_id: mail.id }),
+      signal: AbortSignal.timeout(15000),
+    });
+    if (!res.ok) {
+      const out = await res.json().catch(() => ({}));
+      stats.lastError = `send ${res.status} ${out.code || ''}`.trim();
+      log(`apumail: no se pudo responder (${stats.lastError})`);
+      return;
+    }
+    sentToday++;
+    perSender.set(from, (perSender.get(from) || 0) + 1);
+    stats.replied++;
+    log(`apumail: respondido el correo ${mail.id}`);
+  }
+
+  /** Long-poll: sin URL pública. El primer lote es el atrasado (solo se contestan los recientes). */
+  async function poll() {
+    let since = 0;
+    let first = true;
+    while (!stopped) {
+      try {
+        const res = await fetch(`${base}/wait?timeout=60${since ? `&since=${since}` : ''}`, { headers: auth, signal: AbortSignal.timeout(75000) });
+        if (res.status === 401 || res.status === 403 || res.status === 404) {
+          stats.lastError = `wait ${res.status}`;
+          log(`apumail: el buzón del agente no responde (${res.status}); se deja de escuchar. Revisa APUMAIL_AGENT_INBOX / APUMAIL_AGENT_TOKEN.`);
+          return;
+        }
+        if (!res.ok) throw new Error(`wait ${res.status}`);
+        const out = await res.json();
+        for (const mail of out.messages || []) await handleMail(mail, { backlog: first }).catch((e) => log('apumail:', e.message));
+        since = out.next_since ?? since;
+        first = false;
+      } catch (e) {
+        stats.lastError = e.message;
+        await sleep(5000);
+      }
+    }
+  }
+
+  /** POST /api/agent/channels/apumail — webhook firmado. */
+  async function webhook(req, res) {
+    const raw = await readRaw(req);
+    const sig = String(req.headers['x-apumail-signature'] || '');
+    const want = `sha256=${createHmac('sha256', secret).update(raw).digest('hex')}`;
+    if (!secret || sig.length !== want.length || !timingSafeEqual(Buffer.from(sig), Buffer.from(want))) {
+      res.writeHead(401, { 'Content-Type': 'application/json' });
+      return res.end(JSON.stringify({ error: reqT(req)('server.channels.badSignature') }));
+    }
+    let evt;
+    try {
+      evt = JSON.parse(raw.toString('utf8'));
+    } catch {
+      res.writeHead(400);
+      return res.end();
+    }
+    // Se responde ya (apumail reintenta si tardamos); el correo se trata en segundo plano.
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end('{"ok":true}');
+    if (evt.event === 'mail.received' && String(evt.inbox || '').toLowerCase() === inbox) {
+      handleMail(evt.mail).catch((e) => log('apumail:', e.message));
+    }
+  }
+
+  return {
+    start() {
+      log(`apumail: el agente atiende ${inbox} (${stats.mode})`);
+      if (!secret) poll();
+    },
+    stop() {
+      stopped = true;
+    },
+    webhook,
+    status: () => ({ inbox, ...stats, sentToday }),
+  };
+}
+
+// ───────────────────────────── helpers ─────────────────────────────
+
+export function emailOf(from) {
+  const s = String(from || '');
+  return (s.match(/<([^>]+)>/)?.[1] || s).trim().toLowerCase();
+}
+
+/** Correos que nunca se contestan: propios, automáticos, rebotes, listas. */
+export function skipReason(mail, from, inbox) {
+  if (!/^[^\s@]+@[^\s@]+\.[^\s@]{2,}$/.test(from)) return 'remitente inválido';
+  if (from === inbox) return 'propio';
+  if (/^(no-?reply|mailer-daemon|postmaster|bounces?|notifications?)([+@.-])/i.test(from)) return 'automático';
+  if (/^(auto(matic)? ?reply|respuesta autom|out of office|fuera de la oficina|undeliverable|delivery status|returned mail)/i.test(String(mail.subject || ''))) return 'automático';
+  const h = mail.headers || {};
+  if (/auto-(replied|generated)/i.test(h['auto-submitted'] || '') || h['list-id'] || /bulk|list|junk/i.test(h.precedence || '')) return 'automático';
+  return null;
+}
+
+function stripHtml(html) {
+  return String(html || '')
+    .replace(/<(script|style)[\s\S]*?<\/\1>/gi, '')
+    .replace(/<br\s*\/?>|<\/p>/gi, '\n')
+    .replace(/<[^>]+>/g, '')
+    .replace(/&nbsp;/g, ' ')
+    .replace(/&amp;/g, '&')
+    .replace(/&lt;/g, '<')
+    .replace(/&gt;/g, '>');
+}
+
+async function readRaw(req) {
+  const chunks = [];
+  let size = 0;
+  for await (const c of req) {
+    size += c.length;
+    if (size > MAX_BODY) throw i18nError(413, 'server.http.bodyTooLarge');
+    chunks.push(c);
+  }
+  return Buffer.concat(chunks);
+}
+
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));

package/server/channels/index.mjs

@@ -0,0 +1,69 @@
+/**
+ * Canales para hablar con el agente fuera de la web: apumail (correo) y apuchat
+ * (mensajes, videollamadas de meet.apuchat.com y llamadas a la app).
+ * Cada canal se activa solo si tiene su configuración (por defecto, variables de entorno).
+ */
+
+import { getIdentity } from '../identity.mjs';
+import { i18nError, reqT } from '../i18n.mjs';
+import { createServerAgent, persona as personaOf } from './agent.mjs';
+import { apumailConfigFromEnv, apumailConfigured, createApumailChannel } from './apumail.mjs';
+import { apuchatConfigFromEnv, apuchatConfigured, createApuchatChannel } from './apuchat.mjs';
+
+/**
+ * @param {object} deps
+ * @param {{step: Function}} [deps.llm]       LLM del proxy
+ * @param {Function} [deps.brain]            cerebro propio (ver channels/agent.mjs); sustituye al LLM
+ * @param {() => object} [deps.identity]     identidad vigente (defecto: server/identity.mjs)
+ * @param {() => string} [deps.instructions] instrucciones fijas del servidor (defecto: SERVER_INSTRUCTIONS)
+ * @param {{ apumail?: object|false, apuchat?: object|false }} [deps.config]  por defecto, el entorno
+ * @param {Function} [deps.log]
+ */
+export function startAgentChannels({ llm, brain, identity = getIdentity, instructions, config = {}, log = (...a) => console.log('[7ots]', ...a) }) {
+  const agent = createServerAgent({ llm, brain, identity, instructions });
+  const persona = () => personaOf(identity);
+  const mailCfg = config.apumail === false ? null : { ...apumailConfigFromEnv(), ...(config.apumail || {}) };
+  const chatCfg = config.apuchat === false ? null : { ...apuchatConfigFromEnv(), ...(config.apuchat || {}) };
+  const apumail = mailCfg && apumailConfigured(mailCfg) ? createApumailChannel({ agent, log, config: mailCfg }) : null;
+  const apuchat = chatCfg && apuchatConfigured(chatCfg) ? createApuchatChannel({ agent, persona, log, config: chatCfg }) : null;
+  apumail?.start();
+  apuchat?.start();
+
+  return {
+    agent,
+    /** Rutas públicas de los canales (van antes del site key: las llama apumail, no el widget). */
+    async handle(req, res, path) {
+      if (path === '/channels/apumail' && req.method === 'POST') {
+        if (!apumail) {
+          res.writeHead(404, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ error: reqT(req)('server.channels.noApumail') }));
+          return true;
+        }
+        await apumail.webhook(req, res);
+        return true;
+      }
+      return false;
+    },
+    /** Qué canales funcionan ahora mismo (para la tarjeta pública de identidad). */
+    live: () => ({
+      email: !!apumail,
+      apuchat: apuchat?.handle() || null,
+      meet: !!apuchat,
+    }),
+    /** Videollamada de meet con el agente dentro; devuelve el enlace para entrar. */
+    openCall: (o) => {
+      if (!apuchat) throw i18nError(501, 'server.channels.noApuchat');
+      return apuchat.openCall(o);
+    },
+    /** Hace sonar la app de apuchat de @handle con una llamada del agente. */
+    ring: (handle, motivo) => {
+      if (!apuchat) throw i18nError(501, 'server.channels.noApuchat');
+      return apuchat.ring(String(handle).replace(/^@/, '').toLowerCase(), motivo);
+    },
+    status: () => ({ apumail: apumail?.status() || false, apuchat: apuchat?.status() || false }),
+    async stop() {
+      apumail?.stop();
+      await apuchat?.stop();
+    },
+  };
+}