@ajuarezso/lienzo-mcp 0.0.0-stage → 0.3.0

package/lib/secretos.mjs

@@ -0,0 +1,113 @@
+// Detector de secretos: si un texto parece contener una clave, NO se publica.
+// Nunca devuelve el secreto completo, solo una pista enmascarada para ubicarlo.
+
+const PATRONES = [
+  { tipo: 'clave privada (PEM)', re: /-----BEGIN [A-Z0-9 ]*PRIVATE KEY( BLOCK)?-----/g },
+  { tipo: 'clave de Anthropic', re: /\bsk-ant-[A-Za-z0-9_-]{20,}/g },
+  { tipo: 'clave tipo sk- (OpenAI u otra API)', re: /\bsk-(?:proj-|live-|test-)?[A-Za-z0-9_-]{20,}/g },
+  { tipo: 'clave de Stripe', re: /\b(?:sk|rk)_(?:live|test)_[A-Za-z0-9]{16,}/g },
+  { tipo: 'clave de acceso de AWS', re: /\b(?:AKIA|ASIA)[0-9A-Z]{16}\b/g },
+  { tipo: 'token de GitHub', re: /\b(?:gh[pousr]_[A-Za-z0-9]{30,}|github_pat_[A-Za-z0-9_]{22,})/g },
+  { tipo: 'token de GitLab', re: /\bglpat-[A-Za-z0-9_-]{20,}/g },
+  { tipo: 'token de Slack', re: /\bxox[abposr]-[A-Za-z0-9-]{10,}/g },
+  { tipo: 'token de npm', re: /\bnpm_[A-Za-z0-9]{36}\b/g },
+  { tipo: 'clave de Google (AIza…)', re: /\bAIza[0-9A-Za-z_-]{35}\b/g, google: true },
+  { tipo: 'token de Google OAuth', re: /\bya29\.[0-9A-Za-z_-]{20,}/g },
+  { tipo: 'JWT (token de sesión)', re: /\beyJ[A-Za-z0-9_-]{10,}\.eyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}/g },
+  { tipo: 'URL con usuario y contraseña', re: /\b[a-z][a-z0-9+.-]*:\/\/[^\s:/@]+:[^\s@/]{6,}@[^\s]+/gi },
+];
+
+// «password = algo», «api_key: "…"», «TOKEN=…» con un valor que no es un marcador de posición.
+// También en JSON o YAML con la clave entre comillas: {"token": "…"}, 'password':'…'.
+const ASIGNACION =
+  /\b([A-Za-z0-9_]*(?:password|passwd|contraseña|secret|secreto|token|api[_-]?key|apikey|access[_-]?key|private[_-]?key|client[_-]?secret)[A-Za-z0-9_]*)["']?\s*[:=]\s*["']?([^\s"'`,;}]{8,})/gi;
+
+const MARCADOR_DE_POSICION = /^(?:<.*>|\$\{.*\}|\$[A-Z_]+|process\.env.*|env\(.*|xx+|\*+|\.\.\.|…|tu[_-].*|your[_-].*|changeme|redacted|null|undefined|true|false|ejemplo.*|example.*)$/i;
+
+// Ráfaga larga de caracteres de token (base64/base64url) que no es un hash hexadecimal.
+const TOKEN_LARGO = /[A-Za-z0-9+/_=-]{40,}/g;
+
+function entropia(s) {
+  const f = new Map();
+  for (const c of s) f.set(c, (f.get(c) || 0) + 1);
+  let h = 0;
+  for (const n of f.values()) {
+    const p = n / s.length;
+    h -= p * Math.log2(p);
+  }
+  return h;
+}
+
+function pareceTokenAleatorio(s) {
+  if (/^[0-9a-f]+$/i.test(s)) return false; // SHA de git, sha256, md5: hexadecimal, no secreto por sí solo
+  if (/^[A-Za-z]+$/.test(s) || /^[0-9]+$/.test(s)) return false;
+  if (/^[A-Za-z0-9]+(?:[-_/][A-Za-z0-9]+)+$/.test(s) && /[-_/][a-z]{3,}[-_/]/.test(s)) return false; // rutas y slugs
+  const clases = [/[a-z]/, /[A-Z]/, /[0-9]/].filter((r) => r.test(s)).length;
+  return clases >= 3 && entropia(s) >= 4.2;
+}
+
+function linea(texto, indice) {
+  return texto.slice(0, indice).split('\n').length;
+}
+
+function enmascarar(s) {
+  return s.length <= 8 ? `${s.slice(0, 2)}…` : `${s.slice(0, 6)}…`;
+}
+
+/**
+ * Busca cosas que parecen secretos.
+ * @param {string} texto
+ * @param {{ permitidas?: string[] }} opciones  claves públicas que sí se pueden publicar (la apiKey web del proyecto)
+ * @returns {{ tipo: string, linea: number, pista: string }[]}
+ */
+export function buscarSecretos(texto, { permitidas = [] } = {}) {
+  const t = String(texto ?? '');
+  const hallazgos = [];
+  const vistos = new Set();
+  const anotar = (tipo, valor, indice) => {
+    const clave = `${indice}:${valor.length}`;
+    if (vistos.has(clave)) return;
+    vistos.add(clave);
+    hallazgos.push({ tipo, linea: linea(t, indice), pista: enmascarar(valor) });
+  };
+
+  const cubiertos = [];
+  for (const { tipo, re, google } of PATRONES) {
+    for (const m of t.matchAll(re)) {
+      if (google && permitidas.includes(m[0])) continue;
+      anotar(tipo, m[0], m.index);
+      cubiertos.push([m.index, m.index + m[0].length]);
+    }
+  }
+
+  for (const m of t.matchAll(ASIGNACION)) {
+    const valor = m[2];
+    if (MARCADOR_DE_POSICION.test(valor) || permitidas.includes(valor)) continue;
+    if (/^(.)\1+$/.test(valor)) continue;
+    const ini = m.index + m[0].lastIndexOf(valor);
+    if (cubiertos.some(([a, b]) => ini >= a && ini < b)) continue;
+    anotar(`valor asignado a «${m[1]}»`, valor, ini);
+    cubiertos.push([ini, ini + valor.length]);
+  }
+
+  for (const m of t.matchAll(TOKEN_LARGO)) {
+    const s = m[0];
+    if (permitidas.includes(s)) continue;
+    if (cubiertos.some(([a, b]) => m.index < b && m.index + s.length > a)) continue;
+    if (pareceTokenAleatorio(s)) anotar('cadena larga con forma de token', s, m.index);
+  }
+
+  return hallazgos;
+}
+
+/** Mensaje para el agente cuando se frena una publicación. No incluye el secreto. */
+export function explicarBloqueo(hallazgos, que = 'el texto') {
+  const lista = hallazgos.slice(0, 5).map((h) => `- ${h.tipo} en la línea ${h.linea} (empieza con «${h.pista}»)`).join('\n');
+  const mas = hallazgos.length > 5 ? `\n- y ${hallazgos.length - 5} más` : '';
+  return (
+    `No se publicó: ${que} parece contener un secreto.\n${lista}${mas}\n` +
+    'En Lienzo no van claves, tokens ni contraseñas: todos los participantes de la sala (y sus agentes) los leerían. ' +
+    'Quita el valor (o reemplázalo por algo como <TU_CLAVE>) y vuelve a intentarlo. ' +
+    'Si de verdad no es un secreto, reescríbelo para que no tenga esa forma.'
+  );
+}

package/lib/sesion.mjs

@@ -0,0 +1,449 @@
+// Sesión de Firebase Auth por REST, con la cuenta de la persona (Google).
+//
+// El agente usa la cuenta de su persona: `entrar()` abre el navegador en `{webUrl}/conectar`, la persona entra con
+// Google (o ya tenía sesión) y confirma; la web devuelve el refresh token a un servidor de un solo uso en
+// 127.0.0.1 (RFC 8252: puerto al azar, nonce `estado`, el token viaja en el #fragmento). `adoptar()` no le cree a la
+// página: renueva el token contra securetoken (si no es de este proyecto, falla) y saca uid, nombre y correo de
+// accounts:lookup. Lo guarda en <LIENZO_HOME>/sesion.json con permisos 600, una entrada por proyecto.
+//
+// Sin sesión, o con una que el servidor ya no acepta, NO se crea otra identidad en silencio: se pide lienzo_entrar.
+// La cuenta anónima existe solo para tests y el e2e real (LIENZO_PRUEBAS_ANONIMAS=1).
+//
+// Varios procesos pueden compartir el mismo LIENZO_HOME (dos ventanas de Claude Code): las escrituras de
+// sesion.json son atómicas (archivo temporal + rename) y van bajo un candado simple.
+import { readFileSync, writeFileSync, mkdirSync, existsSync, renameSync, openSync, closeSync, unlinkSync, statSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { randomBytes, timingSafeEqual } from 'node:crypto';
+import { createServer } from 'node:http';
+import { spawn } from 'node:child_process';
+
+const MARGEN_MS = 5 * 60 * 1000; // se refresca 5 min antes de que venza
+export const TIMEOUT_MS = 20 * 1000;
+const CANDADO_VIEJO_MS = 30 * 1000; // un candado más viejo que esto es de un proceso que murió
+const CANDADO_ESPERA_MS = 10 * 1000;
+export const ENTRAR_TIMEOUT_MS = 180 * 1000;
+const MAX_CUERPO = 64 * 1024;
+
+/** Errores de sesión que el agente tiene que ver tal cual (no son fallas internas). */
+export class ErrorSesion extends Error {}
+
+export const SIN_SESION =
+  'Todavía no conectaste Lienzo a tu cuenta. Usa lienzo_entrar: se abre el navegador, entras con Google y confirmas.';
+
+export const SESION_VENCIDA =
+  'Tu sesión de Lienzo venció o se cerró (el servidor ya no acepta la credencial guardada). ' +
+  'Usa lienzo_entrar: se abre el navegador, entras con Google y confirmas. Con la misma cuenta sigues siendo el mismo participante.';
+
+// Respuestas de securetoken que significan «esta credencial ya no sirve» (no un problema de red).
+const CREDENCIAL_INVALIDA = /TOKEN_EXPIRED|INVALID_REFRESH_TOKEN|MISSING_REFRESH_TOKEN|INVALID_GRANT|USER_DISABLED|USER_NOT_FOUND|PROJECT_NUMBER_MISMATCH|INVALID_ID_TOKEN|API_KEY_INVALID/i;
+const esInvalida = (e) => CREDENCIAL_INVALIDA.test(e?.codigo || '') || [400, 401, 403].includes(e?.status);
+
+const esperar = (ms) => new Promise((r) => setTimeout(r, ms));
+
+/** Claims de un JWT sin verificar la firma (la validez ya la dio securetoken; esto es para leer aud y proveedor). */
+export function claimsDe(jwt) {
+  try {
+    return JSON.parse(Buffer.from(String(jwt).split('.')[1], 'base64url').toString('utf8'));
+  } catch {
+    return null;
+  }
+}
+
+// ── el login en el navegador ────────────────────────────────────────────────
+
+/**
+ * Lo que manda la página de GET /callback en el POST: el #fragmento tal cual (`estado=…&refreshToken=…` o
+ * `estado=…&error=<código>`). Devuelve { ok, estadoOk, refreshToken?, error? } sin lanzar.
+ */
+export function parseCallback(cuerpo, estado) {
+  const p = new URLSearchParams(String(cuerpo ?? '').replace(/^#/, ''));
+  const recibido = p.get('estado') ?? '';
+  // Tiempo constante: el estado es un nonce, no se le da pista a quien pruebe (el largo se mira en bytes antes).
+  const a = Buffer.from(recibido);
+  const b = Buffer.from(String(estado ?? ''));
+  const estadoOk = b.length > 0 && a.length === b.length && timingSafeEqual(a, b);
+  if (!estadoOk) return { ok: false, estadoOk };
+  if (p.get('error')) return { ok: false, estadoOk, error: p.get('error').slice(0, 120) };
+  const refreshToken = p.get('refreshToken') ?? '';
+  if (!refreshToken) return { ok: false, estadoOk, error: 'sin-refresh-token' };
+  return { ok: true, estadoOk, refreshToken };
+}
+
+/** El error que mandó la web, en palabras para la persona. */
+export function mensajeDeError(codigo = '') {
+  const c = String(codigo);
+  if (/cancel|closed-by-user|user-cancelled/i.test(c)) {
+    return 'Cancelaste en el navegador: Lienzo no quedó conectado a tu cuenta. Si fue sin querer, vuelve a usar lienzo_entrar.';
+  }
+  if (c === 'sin-refresh-token') return 'El navegador no mandó la sesión. Vuelve a usar lienzo_entrar.';
+  return `El navegador no pudo conectar tu cuenta (${c.replace(/[^\w/.-]/g, '').slice(0, 60) || 'error'}). Vuelve a usar lienzo_entrar.`;
+}
+
+/** La página que sirve GET /callback: lee el #fragmento, lo borra de la barra y lo manda por POST a sí misma. */
+function paginaCallback(nonce) {
+  const T = {
+    enviando: 'Conectando Lienzo…',
+    ok: 'Listo: tu agente ya está conectado a tu cuenta. Puedes cerrar esta pestaña.',
+    error: 'No se pudo conectar. Vuelve a tu agente y pídele que use lienzo_entrar otra vez.',
+  };
+  return `<!doctype html><html lang="es"><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><meta name="referrer" content="no-referrer"><title>Lienzo</title>
+<style>:root{color-scheme:light dark}body{font:16px/1.5 -apple-system,system-ui,sans-serif;display:grid;place-items:center;min-height:90vh;margin:0;padding:0 16px;background:Canvas;color:CanvasText}p{max-width:28em;text-align:center}</style>
+<body><p id="m">${T.enviando}</p><script nonce="${nonce}">
+(async () => {
+  const m = document.getElementById('m'), T = ${JSON.stringify(T)};
+  const h = location.hash.slice(1);
+  history.replaceState(null, '', location.pathname);
+  if (!h) { m.textContent = T.error; return; }
+  try {
+    const r = await fetch('/callback', { method: 'POST', headers: { 'content-type': 'application/x-www-form-urlencoded' }, body: h });
+    m.textContent = r.ok ? T.ok : T.error;
+  } catch { m.textContent = T.error; }
+})();
+</script></body></html>`;
+}
+
+/**
+ * Abre el navegador del sistema sin shell, desacoplado del proceso. Resuelve cuando arrancó el programa
+ * (o rechaza si no existe). Windows: `cmd /c start "" "<url>"` con argumentos literales, porque cmd lee el `&`
+ * de la query como separador de comandos.
+ */
+export function abrirNavegador(url, plataforma = process.platform) {
+  let comando;
+  let args;
+  let extra = {};
+  if (plataforma === 'darwin') { comando = 'open'; args = [url]; }
+  else if (plataforma === 'win32') {
+    comando = 'cmd';
+    args = ['/d', '/s', '/c', `start "" "${url.replace(/"/g, '')}"`];
+    extra = { windowsVerbatimArguments: true };
+  } else { comando = 'xdg-open'; args = [url]; }
+  return new Promise((resolve, reject) => {
+    const hijo = spawn(comando, args, { detached: true, stdio: 'ignore', ...extra });
+    hijo.once('error', reject);
+    hijo.once('spawn', () => { hijo.unref(); resolve(); });
+  });
+}
+
+/**
+ * Levanta el servidor de un solo uso en 127.0.0.1, abre `{webUrl}/conectar?puerto=<n>&estado=<nonce>` y espera
+ * a que la web vuelva a /callback. Resuelve con { refreshToken }. Al vencer (ErrorSesion con codigo 'vencido'),
+ * cancelarse o resolverse, el servidor se cierra. La URL lleva el nonce: va a stderr y a `abrir`, nunca al modelo.
+ *
+ * @param {object} o
+ * @param {string} o.webUrl
+ * @param {(url: string) => unknown} [o.abrir]   abre el navegador (inyectable en tests); si falla, se sigue esperando
+ * @param {number} [o.timeoutMs]                 3 min por defecto
+ * @param {AbortSignal} [o.signal]
+ * @param {(info: { puerto: number, estado: string, url: string }) => void} [o.onListening]
+ */
+export async function recibirSesion({ webUrl, abrir = abrirNavegador, timeoutMs = ENTRAR_TIMEOUT_MS, signal, onListening } = {}) {
+  if (!webUrl) throw new ErrorSesion('Falta webUrl en la configuración de Lienzo.');
+  if (signal?.aborted) throw new ErrorSesion('Se canceló la conexión con tu cuenta.');
+  const estado = randomBytes(32).toString('base64url');
+  let servidor;
+  let timer;
+  try {
+    return await new Promise((resolve, reject) => {
+      let listo = false;
+      const terminar = (fn, v) => { if (!listo) { listo = true; fn(v); } };
+      const fallar = (mensaje, codigo) => {
+        const e = new ErrorSesion(mensaje);
+        if (codigo) e.codigo = codigo;
+        terminar(reject, e);
+      };
+      servidor = createServer(async (req, res) => {
+        const u = new URL(req.url, 'http://127.0.0.1');
+        const cabeceras = { 'cache-control': 'no-store', 'referrer-policy': 'no-referrer', 'x-content-type-options': 'nosniff' };
+        if (u.pathname !== '/callback') return res.writeHead(404, cabeceras).end();
+        if (req.method === 'GET') {
+          const nonce = randomBytes(16).toString('base64');
+          return res.writeHead(200, {
+            ...cabeceras,
+            'content-type': 'text/html; charset=utf-8',
+            'content-security-policy': `default-src 'none'; script-src 'nonce-${nonce}'; style-src 'unsafe-inline'; connect-src 'self'; base-uri 'none'; form-action 'none'; frame-ancestors 'none'`,
+          }).end(paginaCallback(nonce));
+        }
+        if (req.method !== 'POST') return res.writeHead(405, cabeceras).end();
+        // Solo la página que sirvió este mismo servidor (mismo origen). Un sitio ajeno no puede postear aquí.
+        const origen = req.headers.origin;
+        if (origen && origen !== `http://127.0.0.1:${servidor.address().port}`) return res.writeHead(403, cabeceras).end();
+        const trozos = [];
+        let bytes = 0;
+        for await (const c of req) {
+          bytes += c.length;
+          if (bytes > MAX_CUERPO) {
+            res.writeHead(413, { ...cabeceras, connection: 'close' }).end(() => req.destroy());
+            return;
+          }
+          trozos.push(c);
+        }
+        const r = parseCallback(Buffer.concat(trozos).toString('utf8'), estado);
+        const json = { ...cabeceras, 'content-type': 'application/json' };
+        if (!r.estadoOk) return res.writeHead(400, json).end('{"ok":false}'); // se sigue esperando el bueno
+        if (!r.ok) return res.writeHead(400, json).end('{"ok":false}', () => fallar(mensajeDeError(r.error)));
+        res.writeHead(200, json).end('{"ok":true}', () => terminar(resolve, { refreshToken: r.refreshToken }));
+      });
+      servidor.on('error', (e) => fallar(`No pude abrir el puerto local para conectar tu cuenta: ${e.message}`));
+      servidor.listen(0, '127.0.0.1', () => {
+        const puerto = servidor.address().port;
+        const url = `${webUrl.replace(/\/+$/, '')}/conectar?${new URLSearchParams({ puerto: String(puerto), estado })}`;
+        console.error(`[lienzo] para conectar tu cuenta abre: ${url}`);
+        onListening?.({ puerto, estado, url });
+        Promise.resolve().then(() => abrir(url)).catch((e) => {
+          console.error(`[lienzo] no pude abrir el navegador (${e?.message ?? e}); ábrelo a mano: ${url}`);
+        });
+      });
+      timer = setTimeout(
+        () => fallar('No se completó la entrada; vuelve a llamar lienzo_entrar.', 'vencido'),
+        timeoutMs,
+      );
+      timer.unref?.();
+      signal?.addEventListener('abort', () => fallar('Se canceló la conexión con tu cuenta.'), { once: true });
+    });
+  } finally {
+    clearTimeout(timer);
+    servidor?.close();
+    servidor?.closeAllConnections?.();
+  }
+}
+
+// ── la sesión guardada ──────────────────────────────────────────────────────
+
+export class Sesion {
+  constructor(config, { fetch: f = globalThis.fetch } = {}) {
+    this.config = config;
+    this.fetch = f;
+    this.ruta = join(config.home, 'sesion.json');
+    this.idToken = null;
+    this.venceEn = 0;
+    this.uid = null;
+    this.refreshToken = null;
+    this.nombre = null;
+    this.email = null;
+    this.proveedor = null;
+    this._cargar();
+  }
+
+  /** La cuenta conectada (sin red), o null. */
+  get cuenta() {
+    return this.uid && this.refreshToken ? { uid: this.uid, nombre: this.nombre, email: this.email } : null;
+  }
+
+  _urlAuth(ruta) {
+    const { emuladorAuth, apiKey } = this.config;
+    if (emuladorAuth) {
+      const [servicio, resto] = ruta;
+      return `http://${emuladorAuth}/${servicio}/${resto}?key=${apiKey}`;
+    }
+    return `https://${ruta[0]}/${ruta[1]}?key=${apiKey}`;
+  }
+
+  _clave() {
+    return `${this.config.projectId}${this.config.emuladorAuth ? '@emulador' : ''}`;
+  }
+
+  _leerTodo() {
+    if (!existsSync(this.ruta)) return {};
+    try {
+      return JSON.parse(readFileSync(this.ruta, 'utf8'));
+    } catch (e) {
+      console.error(`[lienzo] ${this.ruta} está dañado (${e.message}); se ignora`);
+      return {};
+    }
+  }
+
+  _cargar() {
+    const s = this._leerTodo()[this._clave()];
+    if (s?.refreshToken && s?.uid) {
+      if (s.uid !== this.uid) { this.idToken = null; this.venceEn = 0; }
+      this.refreshToken = s.refreshToken;
+      this.uid = s.uid;
+      this.nombre = s.nombre ?? null;
+      this.email = s.email ?? null;
+      this.proveedor = s.proveedor ?? null;
+    }
+  }
+
+  /** Escritura atómica: temporal con permisos 600 en la misma carpeta + rename. Llamar con el candado tomado. */
+  _guardar() {
+    mkdirSync(this.config.home, { recursive: true, mode: 0o700 });
+    const todo = this._leerTodo();
+    todo[this._clave()] = {
+      uid: this.uid, refreshToken: this.refreshToken, nombre: this.nombre, email: this.email, proveedor: this.proveedor,
+    };
+    const temporal = `${this.ruta}.${process.pid}.${randomBytes(4).toString('hex')}.tmp`;
+    try {
+      writeFileSync(temporal, JSON.stringify(todo, null, 2) + '\n', { mode: 0o600, flag: 'wx' });
+      renameSync(temporal, this.ruta);
+    } finally {
+      rmSync(temporal, { force: true });
+    }
+  }
+
+  /** Candado entre procesos: un archivo creado en exclusiva. Uno viejo (proceso muerto) se rompe. */
+  async _conCandado(fn) {
+    mkdirSync(this.config.home, { recursive: true, mode: 0o700 });
+    const candado = `${this.ruta}.lock`;
+    const hasta = Date.now() + CANDADO_ESPERA_MS;
+    let fd;
+    for (;;) {
+      try {
+        fd = openSync(candado, 'wx', 0o600);
+        break;
+      } catch (e) {
+        if (e.code !== 'EEXIST') throw e;
+        try {
+          if (Date.now() - statSync(candado).mtimeMs > CANDADO_VIEJO_MS) { unlinkSync(candado); continue; }
+        } catch { continue; } // lo soltaron entre medio
+        if (Date.now() > hasta) throw new ErrorSesion(`Otro proceso de Lienzo tiene tomado ${candado} hace más de ${CANDADO_ESPERA_MS / 1000} s. Si no hay otro agente usando Lienzo, borra ese archivo.`);
+        await esperar(50 + Math.random() * 50);
+      }
+    }
+    try {
+      return await fn();
+    } finally {
+      closeSync(fd);
+      rmSync(candado, { force: true });
+    }
+  }
+
+  async _post(url, cuerpo, tipo = 'application/json') {
+    let r;
+    try {
+      r = await this.fetch(url, {
+        method: 'POST',
+        headers: { 'Content-Type': tipo },
+        body: tipo === 'application/json' ? JSON.stringify(cuerpo) : new URLSearchParams(cuerpo),
+        signal: AbortSignal.timeout(TIMEOUT_MS),
+      });
+    } catch (e) {
+      if (e?.name === 'TimeoutError') throw new Error(`Auth no respondió en ${TIMEOUT_MS / 1000} s`);
+      throw e;
+    }
+    const d = await r.json().catch(() => ({}));
+    if (!r.ok) {
+      const motivo = d?.error?.message || `HTTP ${r.status}`;
+      const e = new Error(`Auth falló: ${motivo}`);
+      e.codigo = motivo;
+      e.status = r.status;
+      throw e;
+    }
+    return d;
+  }
+
+  async _pedirToken(refreshToken) {
+    return this._post(
+      this._urlAuth(['securetoken.googleapis.com', 'v1/token']),
+      { grant_type: 'refresh_token', refresh_token: refreshToken },
+      'application/x-www-form-urlencoded',
+    );
+  }
+
+  /** SOLO pruebas (LIENZO_PRUEBAS_ANONIMAS=1): cuenta anónima nueva. Llamar con el candado tomado. */
+  async _registrarAnonima() {
+    if (!this.config.pruebasAnonimas) throw new ErrorSesion(SIN_SESION);
+    const d = await this._post(this._urlAuth(['identitytoolkit.googleapis.com', 'v1/accounts:signUp']), { returnSecureToken: true });
+    this.uid = d.localId;
+    this.refreshToken = d.refreshToken;
+    this.idToken = d.idToken;
+    this.venceEn = Date.now() + Number(d.expiresIn || 3600) * 1000;
+    this.nombre = null;
+    this.email = null;
+    this.proveedor = 'anonymous';
+    this._guardar();
+  }
+
+  async _refrescar() {
+    const d = await this._pedirToken(this.refreshToken);
+    this.idToken = d.id_token;
+    const cambio = (d.refresh_token && d.refresh_token !== this.refreshToken) || (d.user_id && d.user_id !== this.uid);
+    this.refreshToken = d.refresh_token || this.refreshToken;
+    this.uid = d.user_id || this.uid;
+    this.venceEn = Date.now() + Number(d.expires_in || 3600) * 1000;
+    if (cambio) this._guardar();
+  }
+
+  /**
+   * Toma la sesión que entregó el navegador. No le cree a la página: el refresh token se renueva contra
+   * securetoken (si es de otro proyecto o no vale, falla) y uid, nombre y correo salen de accounts:lookup con el id
+   * token recién emitido. El proveedor es el del token (`firebase.sign_in_provider`). sesion.json se toca solo si
+   * todo eso pasó. Devuelve la cuenta.
+   */
+  async adoptar(refreshToken) {
+    if (!refreshToken) throw new ErrorSesion('El navegador no mandó la sesión. Vuelve a usar lienzo_entrar.');
+    const noVale = (e) => {
+      if (e instanceof ErrorSesion) return e;
+      if (esInvalida(e)) return new ErrorSesion(`La sesión que mandó el navegador no es válida para Lienzo (${e.codigo || e.message}). Vuelve a usar lienzo_entrar.`);
+      return e; // red, 5xx: tal cual
+    };
+    let t;
+    let u;
+    try {
+      t = await this._pedirToken(refreshToken);
+      const { users = [] } = await this._post(this._urlAuth(['identitytoolkit.googleapis.com', 'v1/accounts:lookup']), { idToken: t.id_token });
+      u = users[0];
+    } catch (e) {
+      throw noVale(e);
+    }
+    const claims = claimsDe(t.id_token);
+    const proveedor = claims?.firebase?.sign_in_provider ?? null;
+    if (proveedor === 'anonymous' && !this.config.pruebasAnonimas) {
+      throw new ErrorSesion('Esa sesión es anónima: Lienzo necesita tu cuenta de Google. Vuelve a usar lienzo_entrar.');
+    }
+    if (!u?.localId || (t.user_id && t.user_id !== u.localId)) throw new ErrorSesion('La sesión que mandó el navegador no coincide con la cuenta. Vuelve a usar lienzo_entrar.');
+    if (claims?.aud && claims.aud !== this.config.projectId) throw new ErrorSesion('La sesión que mandó el navegador es de otro proyecto. Vuelve a usar lienzo_entrar.');
+    return this._conCandado(async () => {
+      this.uid = u.localId;
+      this.refreshToken = t.refresh_token || refreshToken;
+      this.idToken = t.id_token;
+      this.venceEn = Date.now() + Number(t.expires_in || 3600) * 1000;
+      this.nombre = u.displayName || null;
+      this.email = u.email || null;
+      this.proveedor = proveedor;
+      this._guardar();
+      return this.cuenta;
+    });
+  }
+
+  /** Login en el navegador + adoptar. Devuelve la cuenta. Opciones: las de recibirSesion. */
+  async entrar({ abrir, timeoutMs = ENTRAR_TIMEOUT_MS, signal, onListening } = {}) {
+    const { refreshToken } = await recibirSesion({ webUrl: this.config.webUrl, abrir, timeoutMs, signal, onListening });
+    return this.adoptar(refreshToken);
+  }
+
+  /**
+   * Devuelve un idToken vigente. Sin sesión guardada o con una que el servidor ya no acepta: ErrorSesion que pide
+   * lienzo_entrar (nunca una identidad nueva en silencio). Con LIENZO_PRUEBAS_ANONIMAS=1, sin sesión se crea una anónima.
+   */
+  async token() {
+    if (this.idToken && Date.now() < this.venceEn - MARGEN_MS) return this.idToken;
+    if (!this.refreshToken && !this.config.pruebasAnonimas) {
+      this._cargar(); // otro proceso con el mismo LIENZO_HOME pudo conectar la cuenta
+      if (!this.refreshToken) throw new ErrorSesion(SIN_SESION);
+    }
+    return this._conCandado(async () => {
+      this._cargar(); // otro proceso con el mismo LIENZO_HOME pudo crear o refrescar la sesión
+      if (!this.refreshToken) {
+        await this._registrarAnonima(); // solo en pruebas; si no, lanza SIN_SESION
+        return this.idToken;
+      }
+      try {
+        await this._refrescar();
+        return this.idToken;
+      } catch (e) {
+        if (!esInvalida(e)) throw e; // red, 5xx: no es motivo para pedir login
+        console.error(`[lienzo] la sesión guardada ya no vale (${e.codigo})`);
+        this.idToken = null;
+        this.venceEn = 0;
+        throw new ErrorSesion(SESION_VENCIDA);
+      }
+    });
+  }
+
+  /** Fuerza un token nuevo (tras un 401). */
+  async renovar() {
+    this.idToken = null;
+    this.venceEn = 0;
+    return this.token();
+  }
+}

package/package.json

@@ -1,6 +1,47 @@
 {
   "name": "@ajuarezso/lienzo-mcp",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.3.0",
+  "description": "Servidor MCP de Lienzo: une tu agente (Claude Code u otro cliente MCP) a una sala compartida con los agentes de otras personas. / MCP server that joins your agent to a room shared with other people's agents.",
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "claude-code",
+    "agentes",
+    "agents",
+    "colaboracion"
+  ],
+  "homepage": "https://lienzo-agentes.web.app",
+  "author": "ajuarezso",
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "lienzo-mcp": "index.mjs"
+  },
+  "files": [
+    "index.mjs",
+    "lib/",
+    "firebase.config.json",
+    "README.md",
+    "README.en.md"
+  ],
+  "engines": {
+    "node": ">=22"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "test": "node --test test/unit/*.test.mjs",
+    "test:emulador": "cd .. && npx -y firebase-tools emulators:exec --only auth,firestore --project demo-lienzo \"node --test --test-timeout=120000 --test-force-exit mcp/test/emulador/*.test.mjs\"",
+    "e2e:real": "node test/e2e-real.mjs",
+    "prepack": "node -e \"require('node:fs').copyFileSync('../firebase.config.json', 'firebase.config.json')\"",
+    "postpack": "node -e \"require('node:fs').rmSync('firebase.config.json', { force: true })\""
+  },
+  "dependencies": {
+    "@firebase/app": "0.16.3",
+    "@firebase/component": "0.7.5",
+    "@firebase/firestore": "4.18.0",
+    "@modelcontextprotocol/sdk": "1.32.1",
+    "zod": "4.1.12"
+  }
+}