boosterarena-mcp 0.1.0

package/sesion.mjs

@@ -0,0 +1,245 @@
+// ─────────────────────────────────────────────────────────────────────────────
+//  LA PUERTA — cómo un agente en una TERMINAL entra a la cuenta del maestro.
+//
+//  El editor entra con el login del navegador; un agente no tiene navegador. Así que se hace
+//  lo mismo que hace Claude Code: el CLI abre el navegador, el maestro entra como entra
+//  siempre, y el navegador devuelve la llave a un servidor minúsculo que el CLI dejó
+//  escuchando en su propia máquina.
+//
+//  POR QUÉ ASÍ Y NO CON UNA CLAVE DE API
+//
+//  · No hay que hospedar nada. El MCP corre en la máquina del maestro; lo que necesita
+//    permiso (guardar el proyecto, subir un archivo, quitar un fondo) va a las mismas
+//    funciones de `/api` que ya usa el navegador, con el mismo token. Cero infraestructura
+//    nueva, y por tanto cero costo — que importa, porque el MCP va a ser gratis.
+//  · El candado del plan YA existe ahí. `functions/api/quitar-fondo.ts` y `openai.ts`
+//    comprueban el plan y descuentan cuota contra el JWT. No hay un segundo sistema de
+//    permisos que mantener ni que se pueda desincronizar del primero.
+//  · Revocar es cerrar la sesión en Supabase. Si alguien pierde el portátil, se corta ahí.
+//
+//  ⚠️ PKCE, NO EL FLUJO IMPLÍCITO. El código que vuelve al loopback no sirve de nada sin el
+//  `verifier` que solo tiene este proceso, así que otro programa de la misma máquina que
+//  espiara el puerto no se llevaría nada. Es lo que manda la RFC 8252 para apps nativas.
+//
+//  ⚠️ Y NO SE USA CORREO+CONTRASEÑA AUNQUE SEA LO QUE MÁS USAN (5 de 8 cuentas, medido el
+//  2026-09-07). Un CLI que pide la contraseña enseña a la gente a teclearla en sitios raros,
+//  y además tendría que tocarla. El enlace por correo llega a la MISMA cuenta y no expone
+//  nada: es el camino que usan `gh` y compañía por la misma razón.
+//
+//    node mcp/sesion.mjs entrar            # con Google
+//    node mcp/sesion.mjs entrar --correo tu@correo.com
+//    node mcp/sesion.mjs quien             # a nombre de quién estoy
+//    node mcp/sesion.mjs salir             # borra la credencial de esta máquina
+// ─────────────────────────────────────────────────────────────────────────────
+import { createServer } from 'node:http';
+import { spawn } from 'node:child_process';
+import { randomBytes } from 'node:crypto';
+import { chmodSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { createClient } from '@supabase/supabase-js';
+
+// Los mismos valores públicos que el navegador. La `publishable` no es un secreto: acaba en el
+// bundle de cualquier app de Supabase, y lo que protege los datos es el RLS.
+const SUPABASE_URL = 'https://kjoadzhtgbrngpppbysh.supabase.co';
+const SUPABASE_KEY = 'sb_publishable_Zkvuw-xVLuns3msI14xH0g_YG5SYo7G';
+
+const CARPETA = join(homedir(), '.booster');
+const CREDENCIAL = join(CARPETA, 'credenciales.json');
+
+// ── Almacén en memoria ───────────────────────────────────────────────────────
+// `supabase-js` guarda el `code_verifier` de PKCE en el almacén mientras dura el viaje al
+// navegador. En Node no hay `localStorage`, y aquí no hace falta que sobreviva al proceso: el
+// mismo que abre el navegador es el que canjea el código.
+const memoria = new Map();
+const almacen = {
+  getItem: (k) => memoria.get(k) ?? null,
+  setItem: (k, v) => void memoria.set(k, v),
+  removeItem: (k) => void memoria.delete(k),
+};
+
+function cliente() {
+  return createClient(SUPABASE_URL, SUPABASE_KEY, {
+    auth: {
+      flowType: 'pkce',        // ← lo que hace que el código del loopback no valga solo
+      storage: almacen,
+      persistSession: true,
+      autoRefreshToken: false, // el refresco lo lleva el MCP, no este comando suelto
+      detectSessionInUrl: false,
+    },
+  });
+}
+
+// ── La credencial en disco ───────────────────────────────────────────────────
+// Se guarda el `refresh_token`, no el de acceso: el de acceso caduca en una hora y se renueva
+// solo. Este archivo ES una llave, así que va a 600 (solo su dueño), igual que `~/.claude`.
+function guardar(sesion) {
+  if (!existsSync(CARPETA)) mkdirSync(CARPETA, { recursive: true, mode: 0o700 });
+  const datos = {
+    refresh_token: sesion.refresh_token,
+    correo: sesion.user?.email ?? null,
+    guardado: new Date().toISOString(),
+  };
+  writeFileSync(CREDENCIAL, JSON.stringify(datos, null, 2), { mode: 0o600 });
+  try { chmodSync(CREDENCIAL, 0o600); } catch { /* Windows no siempre deja; el aviso va abajo */ }
+}
+
+export function leerCredencial() {
+  if (!existsSync(CREDENCIAL)) return null;
+  try { return JSON.parse(readFileSync(CREDENCIAL, 'utf8')); } catch { return null; }
+}
+
+/** Devuelve un token de acceso FRESCO, o null si no hay sesión. Es lo que usará el MCP. */
+export async function tokenDeAcceso() {
+  const cred = leerCredencial();
+  if (!cred?.refresh_token) return null;
+  const sb = cliente();
+  const { data, error } = await sb.auth.refreshSession({ refresh_token: cred.refresh_token });
+  if (error || !data.session) return null;
+  guardar(data.session); // el refresh token ROTA: si no se reescribe, la próxima vez falla
+  return data.session.access_token;
+}
+
+// ── Abrir el navegador ───────────────────────────────────────────────────────
+function abrirNavegador(url) {
+  const p = process.platform;
+  const [cmd, args] = p === 'win32' ? ['cmd', ['/c', 'start', '', url]]
+    : p === 'darwin' ? ['open', [url]]
+      : ['xdg-open', [url]];
+  try { spawn(cmd, args, { detached: true, stdio: 'ignore' }).unref(); return true; } catch { return false; }
+}
+
+export async function entrar(correo) {
+  const estado = randomBytes(16).toString('hex');
+  // El servidor primero: hay que saber el puerto ANTES de pedirle a Supabase el enlace, porque
+  // el puerto va dentro del `redirectTo`.
+  const s = createServer(() => {});
+  await new Promise((r) => s.listen(0, '127.0.0.1', r));
+  const puerto = s.address().port;
+  s.close();
+  const volverA = `http://127.0.0.1:${puerto}/callback`;
+
+  const sb = cliente();
+  let url;
+  if (correo) {
+    const { error } = await sb.auth.signInWithOtp({ email: correo, options: { emailRedirectTo: `${volverA}?state=${estado}` } });
+    if (error) throw new Error(`No se pudo mandar el enlace: ${error.message}`);
+    console.log(`\n  📧 Te mandé un enlace a ${correo}.`);
+    console.log('     Ábrelo en este mismo equipo y volverás aquí solo.');
+    // Mientras Booster no tenga servidor de correo propio, esto sale con la cara de Supabase.
+    // Medido el 2026-09-07: remitente `noreply@mail.app.supabase.io`, en inglés, y un tope de
+    // DOS por hora en todo el proyecto. Decirlo por delante evita que acabe en spam y que el
+    // maestro escriba diciendo que no le llegó nada.
+    console.log('\n     ⚠️ De momento el enlace llega firmado por «Supabase» y en inglés, porque');
+    console.log('        Booster todavía no tiene servidor de correo propio. Míralo en spam si no');
+    console.log('        aparece. Y solo salen 2 por hora: si llevas prisa, entra con Google.\n');
+  } else {
+    const { data, error } = await sb.auth.signInWithOAuth({
+      provider: 'google',
+      options: { redirectTo: `${volverA}?state=${estado}`, skipBrowserRedirect: true },
+    });
+    if (error) throw new Error(`No se pudo preparar el acceso: ${error.message}`);
+    url = data.url;
+    console.log('\n  Abriendo el navegador para que entres…');
+    console.log(`  Si no se abre solo, pega esto:\n\n  ${url}\n`);
+    abrirNavegador(url);
+  }
+
+  const codigo = await escuchar(puerto, estado);
+  const { data, error } = await sb.auth.exchangeCodeForSession(codigo);
+  if (error) throw new Error(`El código no valía: ${error.message}`);
+  guardar(data.session);
+  console.log(`\n  ✓ Dentro como ${data.session.user.email}`);
+  console.log(`    La credencial queda en ${CREDENCIAL} (solo tuya, permisos 600).`);
+  if (process.platform === 'win32') {
+    console.log('    ⚠️ En Windows los permisos de archivo no funcionan igual: cualquier programa');
+    console.log('       que corra con tu usuario puede leerla. Es la misma regla que ~/.claude.');
+  }
+}
+
+/** Levanta el loopback en un puerto ya elegido y espera el `?code=`. */
+function escuchar(puerto, estado) {
+  return new Promise((resolve, reject) => {
+    const s = createServer((req, res) => {
+      const u = new URL(req.url, 'http://127.0.0.1');
+      if (u.pathname !== '/callback') { res.writeHead(404).end(); return; }
+      const pagina = (titulo, cuerpo, ok) => {
+        res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+        res.end(`<!doctype html><meta charset="utf-8"><title>${titulo}</title>`
+          + '<body style="font:16px/1.5 system-ui;background:#0b1220;color:#e2e8f0;display:grid;'
+          + 'place-items:center;height:100vh;margin:0;text-align:center">'
+          + `<div><div style="font-size:44px">${ok ? '✓' : '✕'}</div>`
+          + `<h1 style="font-size:20px;margin:.4em 0">${titulo}</h1>`
+          + `<p style="color:#94a3b8">${cuerpo}</p></div>`);
+      };
+      if (u.searchParams.get('state') !== estado) {
+        pagina('Esa autorización no era para aquí', 'Vuelve a la terminal e inténtalo otra vez.', false);
+        return;
+      }
+      const err = u.searchParams.get('error_description') || u.searchParams.get('error');
+      if (err) { pagina('No se pudo entrar', err, false); s.close(); reject(new Error(err)); return; }
+      const codigo = u.searchParams.get('code');
+      if (!codigo) { pagina('Falta el código', 'Vuelve a la terminal e inténtalo otra vez.', false); return; }
+      pagina('Listo', 'Ya puedes cerrar esta pestaña y volver a la terminal.', true);
+      s.close();
+      resolve(codigo);
+    });
+    s.on('error', reject);
+    s.listen(puerto, '127.0.0.1');
+    // Si nadie vuelve en cinco minutos, no dejamos el proceso colgado para siempre.
+    setTimeout(() => { s.close(); reject(new Error('Nadie volvió del navegador en 5 minutos.')); }, 5 * 60_000).unref();
+  });
+}
+
+export async function quien() {
+  const cred = leerCredencial();
+  if (!cred) { console.log(`  No hay sesión en este equipo. Usa: ${YO} entrar`); return; }
+  const token = await tokenDeAcceso();
+  if (!token) { console.log(`  La sesión de ${cred.correo ?? 'este equipo'} ya no vale. Vuelve a entrar.`); return; }
+  const r = await fetch(`${SUPABASE_URL}/auth/v1/user`, {
+    headers: { apikey: SUPABASE_KEY, Authorization: `Bearer ${token}` },
+  });
+  const u = await r.json();
+  console.log(`  ✓ ${u.email}`);
+  console.log(`    id: ${u.id}`);
+  console.log(`    credencial guardada el ${cred.guardado}`);
+}
+
+export function salir() {
+  if (existsSync(CREDENCIAL)) { rmSync(CREDENCIAL); console.log('  Credencial borrada de este equipo.'); }
+  else console.log('  No había ninguna credencial que borrar.');
+  console.log('  (La sesión sigue viva en Supabase: para cortarla de verdad, ciérrala desde el sitio.)');
+}
+
+// ── Entrada ──────────────────────────────────────────────────────────────────
+// La ayuda repite el comando TAL Y COMO lo invocaron. Escribir `node mcp/sesion.mjs` a secas
+// mandaba a la gente a una ruta relativa que solo vale desde la carpeta del proyecto: Antonio se
+// lo comió en la primera prueba (2026-09-07) y perdió un intento con un MODULE_NOT_FOUND.
+const YO = `node ${process.argv[1] ?? 'mcp/sesion.mjs'}`;
+const [, , orden, ...resto] = process.argv;
+const correo = resto.includes('--correo') ? resto[resto.indexOf('--correo') + 1] : null;
+
+// ⚠️ Solo cuando ESTE archivo es el que se ejecutó. Sin este candado, cualquiera que importara
+// `tokenDeAcceso()` se comía además el menú de ayuda por pantalla — que es justo lo que hizo
+// `proyectos.mjs` la primera vez que se probó.
+// `pathToFileURL` y no una plantilla a mano: en Windows la URL lleva TRES barras
+// (`file:///C:/...`), y compararla con dos hacía que el candado no abriera nunca — el comando
+// se quedaba mudo, sin error. Que es la peor manera de fallar.
+if (import.meta.url === pathToFileURL(process.argv[1]).href) {
+try {
+  if (orden === 'entrar') await entrar(correo);
+  else if (orden === 'quien') await quien();
+  else if (orden === 'salir') salir();
+  else {
+    console.log('\n  La puerta del MCP de Booster\n');
+    console.log(`    ${YO} entrar                      entrar con Google (recomendado)`);
+    console.log(`    ${YO} entrar --correo tu@correo   entrar con un enlace por correo`);
+    console.log(`    ${YO} quien                       a nombre de quién estoy`);
+    console.log(`    ${YO} salir                       borrar la credencial de aquí\n`);
+  }
+} catch (e) {
+  console.error(`\n  ✕ ${e.message}\n`);
+  process.exit(1);
+}
+}

package/subidas.mjs

@@ -0,0 +1,84 @@
+// ─────────────────────────────────────────────────────────────────────────────
+//  SUBIR ARCHIVOS DESDE LA TERMINAL.
+//
+//  Es la pieza que le faltaba a la fábrica de Planificatron. Ellos generan FUERA de Booster
+//  —las imágenes con Flux en su propia gráfica, la voz con edge-tts— y el resultado entra por
+//  aquí. Booster no genera ninguna de las dos cosas (se retiró por costo, y el audio nunca se
+//  generó) y esto no lo cambia: la fábrica no le añade capacidades a Booster, le añade un
+//  PROVEEDOR DE ARCHIVOS. Un MP3 de un TTS y un MP3 que subió un maestro son el mismo elemento
+//  con una URL de R2, y el documento no puede notar la diferencia.
+//
+//  Pasa por la MISMA función que usa el navegador (`functions/api/upload.ts`), con el token del
+//  maestro: valida el JWT, sanea la extensión y escribe a R2 por binding. Nada nuevo que
+//  mantener, y las mismas reglas para los dos caminos.
+//
+//  ⚠️ EL NOMBRE DEL ARCHIVO EN R2 ES EL HASH DE SU CONTENIDO. Subir dos veces lo mismo devuelve
+//  la MISMA URL y ocupa una sola vez. Para una fábrica que repite la misma ilustración en
+//  cientos de clases, eso no es un detalle.
+// ─────────────────────────────────────────────────────────────────────────────
+import { readFile, stat } from 'node:fs/promises';
+import { extname, basename } from 'node:path';
+
+const SUBIDA = 'https://boosterarena.com/api/upload';
+
+/** Lo que el servidor acepta (ver `EXT_OK` en `functions/api/upload.ts`). */
+const TIPOS = {
+  webp: 'image/webp', png: 'image/png', jpg: 'image/jpeg', jpeg: 'image/jpeg',
+  gif: 'image/gif', svg: 'image/svg+xml',
+  mp3: 'audio/mpeg', wav: 'audio/wav', m4a: 'audio/mp4', ogg: 'audio/ogg', aac: 'audio/aac',
+  json: 'application/json', lottie: 'application/json',
+};
+const IMAGENES = ['webp', 'png', 'jpg', 'jpeg', 'gif', 'svg'];
+const AUDIOS = ['mp3', 'wav', 'm4a', 'ogg', 'aac'];
+
+/**
+ * El tope del guardián del peso de las arenas: un PNG/JPG de más de 300 KB es, casi siempre,
+ * uno que nadie pasó por `aligerar.mjs`. Aquí no se rechaza —el archivo es del maestro— pero se
+ * DICE, porque esto se le descarga al alumno y un agente no tiene ojos para notarlo.
+ */
+const AVISO_PESO = 300 * 1024;
+
+export async function subirArchivo(token, ruta, familia) {
+  let info;
+  try {
+    info = await stat(ruta);
+  } catch {
+    throw new Error(`No encuentro el archivo "${ruta}". Dame la ruta completa, y recuerda que `
+      + 'tiene que estar en ESTA computadora (la que corre el servidor).');
+  }
+  if (!info.isFile()) throw new Error(`"${ruta}" no es un archivo.`);
+
+  const ext = extname(ruta).slice(1).toLowerCase();
+  const tipo = TIPOS[ext];
+  const permitidas = familia === 'imagen' ? IMAGENES : AUDIOS;
+  if (!tipo || !permitidas.includes(ext)) {
+    throw new Error(`"${ext || 'sin extensión'}" no vale para ${familia}. Se aceptan: ${permitidas.join(', ')}.`);
+  }
+
+  const cuerpo = await readFile(ruta);
+  const r = await fetch(SUBIDA, {
+    method: 'POST',
+    headers: { Authorization: `Bearer ${token}`, 'Content-Type': tipo, 'X-Ext': ext },
+    body: cuerpo,
+  });
+  if (!r.ok) {
+    let detalle = String(r.status);
+    try { detalle = (await r.json())?.detail || detalle; } catch { /* respuesta no-JSON */ }
+    if (r.status === 401) throw new Error('La sesión ya no vale. Corre `node mcp/sesion.mjs entrar`.');
+    throw new Error(`No se pudo subir: ${detalle}`);
+  }
+  const { url } = await r.json();
+
+  const kb = Math.round(info.size / 1024);
+  const pesado = familia === 'imagen' && ['png', 'jpg', 'jpeg'].includes(ext) && info.size > AVISO_PESO;
+  return {
+    url,
+    nombre: basename(ruta),
+    kb,
+    aviso: pesado
+      ? `⚠️ Pesa ${kb} KB y es .${ext}. Esto se le descarga al ALUMNO cuando abra el slide: `
+        + 'conviértelo a WebP antes de subirlo y bajará a la décima parte. Se subió igual, pero '
+        + 'si vas a repetirlo en muchas clases, arréglalo ahora.'
+      : '',
+  };
+}