@7ots/cli 0.1.0

package/server/platform/store.mjs

@@ -0,0 +1,331 @@
+/**
+ * Datos de la plataforma: cuentas, sesiones, ots, conversaciones y uso.
+ * Todo pasa por aquí; las rutas nunca escriben SQL.
+ */
+
+import { defineIdentity } from '../../src/identity/schema.js';
+import { getDb, monthOf, tx } from './db.mjs';
+import { newId, open, seal, sha256, token } from './crypto.mjs';
+
+const now = () => Date.now();
+const parse = (s, fallback) => {
+  try {
+    return JSON.parse(s);
+  } catch {
+    return fallback;
+  }
+};
+
+export const SESSION_TTL = 30 * 24 * 3600_000;
+export const MAX_OTS_PER_ACCOUNT = () => Number(process.env.PLATFORM_MAX_OTS || 10);
+
+/**
+ * Ajustes que cada ots puede cambiar. Lo que no está aquí lo fija la plataforma
+ * (hub de apuchat, API de apumail, URL de la voz de apuchat, puertos…): así nadie puede
+ * apuntar el servidor a direcciones internas.
+ *   secret: se guarda cifrado y nunca se devuelve.
+ *   max:    tope numérico.
+ *   channels: al cambiar, se reinician los canales de ese ots.
+ */
+export const OTS_KEYS = {
+  LLM_PROVIDER: {}, LLM_MODEL: {}, LLM_EFFORT: {}, LLM_MAX_TOKENS: { max: 16000 },
+  ANTHROPIC_API_KEY: { secret: true }, OPENAI_API_KEY: { secret: true },
+  SERVER_INSTRUCTIONS: {},
+  TTS_PROVIDER: {}, OPENAI_TTS_MODEL: {}, OPENAI_TTS_VOICE: {},
+  ELEVENLABS_API_KEY: { secret: true }, ELEVENLABS_VOICE_ID: {}, ELEVENLABS_MODEL: {},
+  APUCHAT_VOICE_TOKEN: { secret: true }, APUCHAT_VOICE_ID: {}, APUCHAT_VOICE_PROVIDER: {},
+  XAI_API_KEY: { secret: true }, XAI_TTS_VOICE: {},
+  FISH_API_KEY: { secret: true }, FISH_VOICE_ID: {}, FISH_MODEL: {},
+  APUMAIL_INBOX: {}, APUMAIL_INBOX_TOKEN: { secret: true }, APUMAIL_TO: {},
+  APUCHAT_NOTIFIER_IDENTITY_KEY: { secret: true }, APUCHAT_OPERATOR_HANDLE: {}, APUCHAT_TRANSCRIBE: {},
+  APUMAIL_AGENT_INBOX: { channels: true }, APUMAIL_AGENT_TOKEN: { secret: true, channels: true },
+  APUMAIL_AGENT_DAILY: { channels: true, max: 100 },
+  APUCHAT_AGENT_IDENTITY_KEY: { secret: true, channels: true }, APUCHAT_AGENT_ALLOW: { channels: true },
+  AGENT_MAX_CALLS: { channels: true, max: 3 }, AGENT_CALL_MAX_MINUTES: { channels: true, max: 30 }, AGENT_CALL_MAX_TURNS: { channels: true, max: 60 },
+};
+
+// ───────────────────────────── cuentas ─────────────────────────────
+
+export function accountById(id) {
+  return getDb().prepare('SELECT * FROM accounts WHERE id = ?').get(id) || null;
+}
+
+/**
+ * Cuenta para un login. Con notlogin se busca por `sub`; si no existe y trae un email
+ * verificado que ya tiene cuenta, se vincula a esa. Si no, se crea.
+ */
+export function upsertAccount({ email = null, notloginSub = null, name = '' }) {
+  email = email ? String(email).trim().toLowerCase() : null;
+  return tx((d) => {
+    let acc = notloginSub ? d.prepare('SELECT * FROM accounts WHERE notlogin_sub = ?').get(notloginSub) : null;
+    if (!acc && email) acc = d.prepare('SELECT * FROM accounts WHERE email = ?').get(email);
+    if (acc) {
+      if (notloginSub && !acc.notlogin_sub) d.prepare('UPDATE accounts SET notlogin_sub = ? WHERE id = ?').run(notloginSub, acc.id);
+      if (email && !acc.email && !d.prepare('SELECT 1 FROM accounts WHERE email = ?').get(email)) d.prepare('UPDATE accounts SET email = ? WHERE id = ?').run(email, acc.id);
+      d.prepare('UPDATE accounts SET last_login_at = ? WHERE id = ?').run(now(), acc.id);
+      return d.prepare('SELECT * FROM accounts WHERE id = ?').get(acc.id);
+    }
+    const id = newId('acc');
+    d.prepare('INSERT INTO accounts (id, email, notlogin_sub, name, created_at, last_login_at) VALUES (?, ?, ?, ?, ?, ?)').run(id, email, notloginSub, String(name || '').slice(0, 80), now(), now());
+    return d.prepare('SELECT * FROM accounts WHERE id = ?').get(id);
+  });
+}
+
+export function publicAccount(acc) {
+  return { id: acc.id, email: acc.email, name: acc.name, plan: acc.plan, notlogin: !!acc.notlogin_sub, createdAt: acc.created_at };
+}
+
+// ───────────────────────────── sesiones ─────────────────────────────
+
+/** Crea una sesión y devuelve el token en claro (solo va en la cookie). */
+export function createSession(accountId, via) {
+  const raw = token();
+  getDb().prepare('INSERT INTO sessions (id, account_id, created_at, expires_at, via) VALUES (?, ?, ?, ?, ?)').run(sha256(raw), accountId, now(), now() + SESSION_TTL, via);
+  return raw;
+}
+
+export function sessionAccount(raw) {
+  if (!raw) return null;
+  const row = getDb().prepare('SELECT a.* FROM sessions s JOIN accounts a ON a.id = s.account_id WHERE s.id = ? AND s.expires_at > ?').get(sha256(raw), now());
+  return row || null;
+}
+
+export function deleteSession(raw) {
+  if (raw) getDb().prepare('DELETE FROM sessions WHERE id = ?').run(sha256(raw));
+}
+
+// ───────────────────────────── enlaces por email ─────────────────────────────
+
+export const LOGIN_TOKEN_TTL = 15 * 60_000;
+
+export function createLoginToken(email) {
+  const raw = token();
+  const d = getDb();
+  d.prepare('DELETE FROM login_tokens WHERE expires_at < ?').run(now() - 24 * 3600_000);
+  d.prepare('INSERT INTO login_tokens (hash, email, expires_at) VALUES (?, ?, ?)').run(sha256(raw), email, now() + LOGIN_TOKEN_TTL);
+  return raw;
+}
+
+/** Enlaces pedidos para ese email en la última hora (límite anti-abuso). */
+export function recentLoginTokens(email) {
+  return getDb().prepare('SELECT COUNT(*) n FROM login_tokens WHERE email = ? AND expires_at > ?').get(email, now() + LOGIN_TOKEN_TTL - 3600_000).n;
+}
+
+/** Gasta un enlace: devuelve el email si era válido (una sola vez). */
+export function consumeLoginToken(raw) {
+  if (!raw) return null;
+  return tx((d) => {
+    const row = d.prepare('SELECT * FROM login_tokens WHERE hash = ?').get(sha256(raw));
+    if (!row || row.used_at || row.expires_at < now()) return null;
+    d.prepare('UPDATE login_tokens SET used_at = ? WHERE hash = ?').run(now(), row.hash);
+    return row.email;
+  });
+}
+
+// ───────────────────────────── ots ─────────────────────────────
+
+function hydrate(row) {
+  if (!row) return null;
+  return {
+    id: row.id,
+    accountId: row.account_id,
+    name: row.name,
+    status: row.status,
+    domains: parse(row.domains, []),
+    identity: defineIdentity(parse(row.identity, {})),
+    widget: parse(row.widget, {}),
+    settings: parse(row.settings, {}),
+    secrets: open(row.secrets),
+    createdAt: row.created_at,
+    updatedAt: row.updated_at,
+  };
+}
+
+export function getOts(id) {
+  return hydrate(getDb().prepare('SELECT * FROM ots WHERE id = ?').get(String(id || '')));
+}
+
+/** El ots solo si es de esa cuenta (si no, null: la ruta responde 404, no 403). */
+export function getOwnOts(accountId, id) {
+  const o = getOts(id);
+  return o && o.accountId === accountId ? o : null;
+}
+
+export function listOts(accountId) {
+  return getDb().prepare('SELECT * FROM ots WHERE account_id = ? ORDER BY created_at').all(accountId).map(hydrate);
+}
+
+export function countOts(accountId) {
+  return getDb().prepare('SELECT COUNT(*) n FROM ots WHERE account_id = ?').get(accountId).n;
+}
+
+export function createOts(accountId, { name, identity = {}, widget = {}, settings = {}, secrets = {}, domains = [] } = {}) {
+  const id = newId('ots');
+  const nm = cleanName(name) || 'Ots';
+  const ident = defineIdentity({ ...identity, name: identity.name || nm });
+  getDb()
+    .prepare('INSERT INTO ots (id, account_id, name, status, domains, identity, widget, settings, secrets, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)')
+    .run(id, accountId, nm, 'on', JSON.stringify(cleanDomains(domains)), JSON.stringify(ident), JSON.stringify(widget), JSON.stringify(settings), seal(secrets), now(), now());
+  return getOts(id);
+}
+
+/** Copia un ots (sin sus claves ni canales propios: un @handle no puede estar en dos ots). */
+export function duplicateOts(accountId, src) {
+  const settings = { ...src.settings };
+  for (const k of Object.keys(settings)) if (OTS_KEYS[k]?.channels) delete settings[k];
+  return createOts(accountId, { name: `${src.name} (copia)`, identity: src.identity, widget: src.widget, settings, domains: src.domains });
+}
+
+export function updateOts(id, patch) {
+  const cur = getOts(id);
+  if (!cur) return null;
+  const next = { ...cur, ...patch };
+  getDb()
+    .prepare('UPDATE ots SET name = ?, status = ?, domains = ?, identity = ?, widget = ?, settings = ?, secrets = ?, updated_at = ? WHERE id = ?')
+    .run(cleanName(next.name) || cur.name, next.status === 'off' ? 'off' : 'on', JSON.stringify(cleanDomains(next.domains)), JSON.stringify(next.identity), JSON.stringify(next.widget), JSON.stringify(next.settings), seal(next.secrets), now(), id);
+  return getOts(id);
+}
+
+export function deleteOts(id) {
+  getDb().prepare('DELETE FROM ots WHERE id = ?').run(id);
+}
+
+/** Todos los ots encendidos (para arrancar sus canales). */
+export function allLiveOts() {
+  return getDb().prepare("SELECT * FROM ots WHERE status = 'on'").all().map(hydrate);
+}
+
+function cleanName(s) {
+  return String(s ?? '').replace(/\s+/g, ' ').trim().slice(0, 60);
+}
+
+/**
+ * Dominios donde puede ir el widget: "tienda.com", "*.tienda.com" o "http://localhost:3000".
+ * Se guardan como orígenes o comodines normalizados.
+ */
+export function cleanDomains(list) {
+  const out = new Set();
+  for (const raw of Array.isArray(list) ? list : String(list || '').split(/[\s,]+/)) {
+    let s = String(raw || '').trim().toLowerCase().replace(/\/+$/, '');
+    if (!s) continue;
+    const wildcard = s.startsWith('*.');
+    if (wildcard) s = s.slice(2);
+    if (!/^https?:\/\//.test(s)) s = `https://${s}`;
+    let u;
+    try {
+      u = new URL(s);
+    } catch {
+      continue;
+    }
+    if (!/^[a-z0-9.-]+$/.test(u.hostname) || u.pathname !== '/' || u.search || u.username) continue;
+    out.add(wildcard ? `*.${u.hostname}` : u.origin);
+    if (out.size >= 20) break;
+  }
+  return [...out];
+}
+
+/** ¿Puede este origen usar el ots? */
+export function originAllowed(ots, origin) {
+  let u;
+  try {
+    u = new URL(origin);
+  } catch {
+    return false;
+  }
+  return ots.domains.some((d) => {
+    if (d.startsWith('*.')) {
+      const base = d.slice(2);
+      return u.protocol === 'https:' && (u.hostname === base || u.hostname.endsWith(`.${base}`));
+    }
+    // "https://tienda.com" también admite www.tienda.com
+    const a = new URL(d);
+    return u.protocol === a.protocol && u.port === a.port && (u.hostname === a.hostname || u.hostname === `www.${a.hostname}`);
+  });
+}
+
+// ───────────────────────────── conversaciones ─────────────────────────────
+
+/**
+ * Apunta un turno en la conversación (se crea la primera vez).
+ * `key` la elige quien llama (sesión del widget, contacto del canal); el id se deriva de ella.
+ * @returns {{ created: boolean }}
+ */
+/** `page`: URL concreta (actualiza la conversación); `origin`: solo si aún no hay página. */
+export function logTurn(ots, { key, channel = 'web', visitor = '', page = '', origin = '', user = '', reply = '' }) {
+  if (!key || (!user && !reply)) return { created: false };
+  const id = `c_${sha256(`${ots.id}:${channel}:${key}`).slice(0, 22)}`;
+  const t = now();
+  return tx((d) => {
+    const cur = d.prepare('SELECT id FROM conversations WHERE id = ?').get(id);
+    if (!cur) {
+      d.prepare('INSERT INTO conversations (id, ots_id, channel, visitor, page, title, messages, started_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, 0, ?, ?)').run(id, ots.id, channel, String(visitor).slice(0, 120), String(page || origin).slice(0, 500), String(user || reply).replace(/\s+/g, ' ').slice(0, 80), t, t);
+    }
+    let n = 0;
+    if (user) {
+      d.prepare('INSERT INTO messages (conversation_id, role, content, at) VALUES (?, ?, ?, ?)').run(id, 'user', String(user).slice(0, 8000), t);
+      n++;
+    }
+    if (reply) {
+      d.prepare('INSERT INTO messages (conversation_id, role, content, at) VALUES (?, ?, ?, ?)').run(id, 'assistant', String(reply).slice(0, 8000), t);
+      n++;
+    }
+    d.prepare('UPDATE conversations SET messages = messages + ?, updated_at = ?, page = CASE WHEN ? != \'\' THEN ? ELSE page END WHERE id = ?').run(n, t, page, String(page).slice(0, 500), id);
+    return { created: !cur };
+  });
+}
+
+export function listConversations(otsId, { limit = 50, before = null } = {}) {
+  const lim = Math.min(200, Math.max(1, Number(limit) || 50));
+  const rows = before
+    ? getDb().prepare('SELECT * FROM conversations WHERE ots_id = ? AND updated_at < ? ORDER BY updated_at DESC LIMIT ?').all(otsId, Number(before), lim)
+    : getDb().prepare('SELECT * FROM conversations WHERE ots_id = ? ORDER BY updated_at DESC LIMIT ?').all(otsId, lim);
+  return rows.map((r) => ({ id: r.id, channel: r.channel, visitor: r.visitor, page: r.page, title: r.title, messages: r.messages, startedAt: r.started_at, updatedAt: r.updated_at }));
+}
+
+export function getConversation(otsId, id) {
+  const c = getDb().prepare('SELECT * FROM conversations WHERE id = ? AND ots_id = ?').get(id, otsId);
+  if (!c) return null;
+  const messages = getDb().prepare('SELECT role, content, at FROM messages WHERE conversation_id = ? ORDER BY id LIMIT 2000').all(id);
+  return { id: c.id, channel: c.channel, visitor: c.visitor, page: c.page, title: c.title, startedAt: c.started_at, updatedAt: c.updated_at, messages };
+}
+
+export function deleteConversation(otsId, id) {
+  return getDb().prepare('DELETE FROM conversations WHERE id = ? AND ots_id = ?').run(id, otsId).changes > 0;
+}
+
+// ───────────────────────────── uso ─────────────────────────────
+
+/**
+ * Tipos: llm (respuestas de IA), llm_platform (las pagadas por la plataforma),
+ * tts / tts_platform (audios), call (videollamadas), conversation (conversaciones nuevas).
+ */
+export function addUsage(ots, kind, n = 1) {
+  getDb()
+    .prepare('INSERT INTO usage (account_id, ots_id, month, kind, count) VALUES (?, ?, ?, ?, ?) ON CONFLICT(ots_id, month, kind) DO UPDATE SET count = count + excluded.count')
+    .run(ots.accountId, ots.id, monthOf(), kind, n);
+}
+
+/** Uso del mes de toda la cuenta de un tipo (para el cupo gratis). */
+export function accountUsage(accountId, kind, month = monthOf()) {
+  return getDb().prepare('SELECT COALESCE(SUM(count), 0) n FROM usage WHERE account_id = ? AND month = ? AND kind = ?').get(accountId, month, kind).n;
+}
+
+/** Uso del mes por ots: { [otsId]: { llm, llm_platform, … } } */
+export function usageByOts(accountId, month = monthOf()) {
+  const out = {};
+  for (const r of getDb().prepare('SELECT ots_id, kind, count FROM usage WHERE account_id = ? AND month = ?').all(accountId, month)) {
+    (out[r.ots_id] ||= {})[r.kind] = r.count;
+  }
+  return out;
+}
+
+/** Últimos meses de un ots: [{ month, llm, … }] */
+export function usageHistory(otsId, months = 6) {
+  const rows = getDb().prepare('SELECT month, kind, count FROM usage WHERE ots_id = ? ORDER BY month DESC').all(otsId);
+  const by = new Map();
+  for (const r of rows) {
+    if (!by.has(r.month)) by.set(r.month, { month: r.month });
+    by.get(r.month)[r.kind] = r.count;
+  }
+  return [...by.values()].slice(0, months);
+}

package/server/sdk.mjs

@@ -0,0 +1,125 @@
+/**
+ * 7ots/server — identidad y contactabilidad para CUALQUIER agente, sin el widget.
+ *
+ * Tienes tu propio agente (LangChain, tu API, un bot…) y quieres darle una cara, una voz y
+ * formas de contactarlo: un correo propio (apumail), un @handle que contesta mensajes y
+ * llamadas (apuchat), videollamadas con avatar (meet.apuchat.com) y una tarjeta pública.
+ *
+ *   import { createAgentIdentity } from '7ots/server';
+ *
+ *   const nube = createAgentIdentity({
+ *     identity: {
+ *       name: 'Nube', role: 'asistente de Nimbus', bio: 'Te ayudo con tu almacenamiento.',
+ *       look: { color: '#6d5dfc', image: 'https://…/nube.png', meetAvatar: 'maya' },
+ *       voice: { provider: 'openai', voiceId: 'coral', style: 'cálida y clara' },
+ *       contact: { site: 'https://nimbus.example', email: 'nube@nimbus.example' },
+ *     },
+ *     // Tu cerebro: recibe el mensaje y devuelve el texto de la respuesta.
+ *     brain: async ({ text, channel, history, identity }) => miAgente.responder(text),
+ *     apumail: { inbox: 'nube@nimbus.example', token: process.env.NUBE_MAIL_TOKEN },
+ *     apuchat: { identityKey: process.env.NUBE_APUCHAT_KEY },
+ *   });
+ *   nube.start();
+ *
+ *   http.createServer((req, res) => nube.handler(req, res) || miApp(req, res));
+ *
+ * Sin `brain`, usa el LLM del proxy de 7ots (LLM_PROVIDER + claves en el entorno).
+ * Las claves se pasan en el código del servidor o por entorno; nunca aparecen en la tarjeta.
+ */
+
+import { defineIdentity, publicIdentity, toVCard, identityPrompt, useIdentity, getIdentity, MEET_AVATARS, MEET_SCENES, OPENAI_VOICES, GROK_VOICES } from './identity.mjs';
+import { startAgentChannels } from './channels/index.mjs';
+import { synthesize } from './tts.mjs';
+
+export { defineIdentity, publicIdentity, toVCard, identityPrompt, MEET_AVATARS, MEET_SCENES, OPENAI_VOICES, GROK_VOICES };
+
+/**
+ * @param {object} o
+ * @param {object} [o.identity]           ficha de identidad (ver server/identity.mjs). Sin ella: entorno + data/identity.json
+ * @param {Function} [o.brain]            async ({ key, channel, text, lang, history, identity, system, tools, run }) => string
+ * @param {{step: Function}} [o.llm]      o un LLM con la interfaz neutral de 7ots (sin brain ni llm: el del entorno)
+ * @param {object|false} [o.apumail]      { inbox, token, webhookSecret, daily, api } — false lo apaga
+ * @param {object|false} [o.apuchat]      { identityKey, allow, maxCalls, maxMinutes, maxTurns, hub } — false lo apaga
+ * @param {string} [o.basePath]           prefijo de las rutas de handler() (defecto '/agent')
+ * @param {Function} [o.log]
+ */
+export function createAgentIdentity({ identity, brain, llm, apumail, apuchat, basePath = '/agent', log } = {}) {
+  if (identity) useIdentity(identity);
+  let channels = null;
+  const base = basePath.replace(/\/$/, '');
+
+  const ensure = async () => {
+    if (channels) return channels;
+    let theLlm = llm;
+    if (!brain && !theLlm) theLlm = (await import('./llm.mjs')).createLLM();
+    channels = startAgentChannels({ llm: theLlm, brain, identity: getIdentity, config: { apumail, apuchat }, ...(log ? { log } : {}) });
+    return channels;
+  };
+
+  const api = {
+    /** Arranca los canales configurados (long-poll de apumail, mensajes y llamadas de apuchat). */
+    async start() {
+      await ensure();
+      return api;
+    },
+    async stop() {
+      await channels?.stop();
+    },
+    /** Identidad completa (incluye instrucciones; no la publiques tal cual). */
+    get identity() {
+      return getIdentity();
+    },
+    /** Cambia la identidad en caliente (nombre, voz, avatar de meet…). */
+    update(patch) {
+      return useIdentity(defineIdentity(patch, getIdentity()));
+    },
+    /** Tarjeta pública (segura para servir). */
+    card() {
+      return publicIdentity(getIdentity(), channels?.live() || {});
+    },
+    vcard(o) {
+      return toVCard(api.card(), o);
+    },
+    /** Texto → audio con la voz de la identidad. → { audio: Buffer, contentType } */
+    speak(text) {
+      return synthesize({ text, voice: getIdentity().voice });
+    },
+    /** Responde a un mensaje como lo haría por un canal ('email' | 'dm' | 'voice'). */
+    async respond(text, { from = 'sdk', channel = 'dm', lang } = {}) {
+      return (await ensure()).agent.respond(`${channel}:${from}`, channel, text, { lang });
+    },
+    /** Hace sonar la app de apuchat de @handle con una videollamada del agente. */
+    async call(handle, motivo) {
+      return (await ensure()).ring(handle, motivo);
+    },
+    /** Crea una videollamada de meet con el agente dentro → { call_url } (dásela solo a quien llama). */
+    async openCall(o) {
+      return (await ensure()).openCall(o);
+    },
+    status() {
+      return channels?.status() || { apumail: false, apuchat: false };
+    },
+    /**
+     * Manejador HTTP para Node (http, Express, Fastify con .raw…). Devuelve una promesa que
+     * resuelve true si atendió la ruta:
+     *   GET  {base}/identity  ·  GET {base}/identity.vcf  ·  GET /.well-known/7ots-agent.json
+     *   POST {base}/channels/apumail   (webhook de apumail)
+     */
+    async handler(req, res) {
+      const path = new URL(req.url, 'http://x').pathname;
+      if (req.method === 'GET' && (path === `${base}/identity` || path === '/.well-known/7ots-agent.json')) {
+        res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8', 'Access-Control-Allow-Origin': '*' });
+        res.end(JSON.stringify(api.card()));
+        return true;
+      }
+      if (req.method === 'GET' && path === `${base}/identity.vcf`) {
+        res.writeHead(200, { 'Content-Type': 'text/vcard; charset=utf-8', 'Access-Control-Allow-Origin': '*' });
+        res.end(api.vcard());
+        return true;
+      }
+      if (path.startsWith(`${base}/channels/`)) return (await ensure()).handle(req, res, path.slice(base.length));
+      return false;
+    },
+  };
+  return api;
+}