boosterarena-mcp 0.1.0

package/encargos.mjs

@@ -0,0 +1,117 @@
+// ─────────────────────────────────────────────────────────────────────────────
+//  LOS ENCARGOS, REMATADOS SIN NAVEGADOR (petición D del equipo de Planificatron).
+//
+//  Tres boosters no se «ponen»: se USAN encima de algo. El maestro coge la moneda y la suelta
+//  sobre la imagen. El ejecutor hace la mitad que cabe en el documento —crear la moneda y
+//  centrarla— y deja un ENCARGO (`pedirSoltar`) para que alguien remate. En el navegador lo
+//  remata el editor, con su bicho comiendo y su lluvia de estrellas. Aquí no hay nada de eso
+//  que enseñar, así que se hace directamente lo que queda en el documento:
+//
+//    · quitafondo  → llamada de red al recortador, y el `src` del objetivo cambia.
+//    · magichat    → una bandera: `magic: true`. La animación no es parte del documento.
+//    · transformar → una lista de imágenes en `morph`. Las trae quien llama.
+//    · trayectoria → NO se puede: hace falta el trazo del dedo. Se devuelve sin resolver, que
+//                    es lo que ya hacía, y el agente se lo dice al maestro.
+//
+//  ⚠️ EL RECORTE SE SUBE A R2, NO SE INCRUSTA. El recortador devuelve un PNG y es tentador
+//  meterlo como data-URL en el documento. Ya pasó: proyectos con PNG de 2 MB dentro, que hay
+//  que descargar enteros cada vez que se abre el slide. Se arregló en el editor (`bd02c94`) y
+//  aquí se hace igual desde el primer día — un camino nuevo no puede reintroducir un fallo que
+//  el otro ya pagó.
+//
+//  ⚠️ Y LA MONEDA SE CONSUME. En el editor la moneda desaparece al soltarla: hizo su trabajo y
+//  no va al Player. Si se quedara, el maestro proyectaría un camaleón encima de su lámina.
+// ─────────────────────────────────────────────────────────────────────────────
+const RECORTE = 'https://boosterarena.com/api/quitar-fondo';
+const SUBIDA = 'https://boosterarena.com/api/upload';
+
+/** Quita la moneda del slide: hizo lo suyo y no debe llegar a la proyección. */
+function consumirMoneda(doc, monedaId) {
+  for (const esc of doc) {
+    for (const sl of esc.slides) {
+      sl.base = sl.base.filter((e) => e.id !== monedaId);
+    }
+  }
+}
+
+function buscarEnDoc(doc, id) {
+  for (const esc of doc) {
+    for (const sl of esc.slides) {
+      const e = sl.base.find((x) => x.id === id);
+      if (e) return e;
+    }
+  }
+  return null;
+}
+
+/**
+ * Remata el encargo que dejó `aplicar_booster`. Devuelve lo que hay que contarle al agente.
+ * Si no hay encargo, devuelve cadena vacía y no toca nada.
+ */
+export async function rematarEncargo(borrador, token) {
+  const s = borrador.pedirSoltar;
+  if (!s) return '';
+  borrador.pedirSoltar = undefined;   // se atiende una vez
+
+  const objetivo = buscarEnDoc(borrador.doc, s.objetivo.id);
+  if (!objetivo) return '\n⚠️ El objeto sobre el que ibas a aplicar la moneda ya no está.';
+
+  if (s.tipo === 'magichat') {
+    objetivo.magic = true;
+    consumirMoneda(borrador.doc, s.moneda.id);
+    return '\nHecho: la imagen queda en SILUETA negra y se revela a color cuando la toquen en el '
+      + '▶ Player. La moneda del sombrero se consumió, como en el editor.';
+  }
+
+  if (s.tipo === 'transformar') {
+    // El Transformador necesita EN QUÉ se convierte, y eso no lo puede adivinar nadie. En el
+    // editor lo elige el maestro en un diálogo; aquí lo tiene que traer quien llama.
+    consumirMoneda(borrador.doc, s.moneda.id);
+    return '\n⚠️ El Transformador necesita saber en qué se convierte, y eso no se puede adivinar. '
+      + 'Usa `transformar_en` con las URLs de las imágenes por las que va pasando (súbelas antes '
+      + 'con `subir_imagen` si están en el disco).';
+  }
+
+  if (s.tipo === 'quitafondo') {
+    if (!objetivo.src) return '\n⚠️ Esa imagen no tiene archivo, así que no hay fondo que quitar.';
+    const r = await fetch(RECORTE, {
+      method: 'POST',
+      headers: { Authorization: `Bearer ${token}`, 'Content-Type': 'application/json' },
+      body: JSON.stringify({ url: objetivo.src }),
+    });
+    if (!r.ok) {
+      // El servidor contesta con un motivo concreto. Traducirlo importa: «PRO_REQUIRED» y
+      // «se acabó la cuota» piden cosas distintas del agente.
+      const info = await r.json().catch(() => ({}));
+      const motivo = info.error;
+      const dice = motivo === 'PRO_REQUIRED'
+        ? 'El recorte de máxima calidad es del plan Pro y esta cuenta no lo tiene. Díselo a quien '
+          + 'te lo pidió: se activa desde boosterarena.com.'
+        : motivo === 'MONTHLY_LIMIT' ? 'Se acabaron los recortes de este mes en esta cuenta.'
+          : motivo === 'NO_AUTH' ? 'La sesión ya no vale. Corre `node mcp/sesion.mjs entrar`.'
+            : info.detail || `El recortador contestó ${r.status}.`;
+      consumirMoneda(borrador.doc, s.moneda.id);
+      return `\n⚠️ No se pudo quitar el fondo: ${dice} La imagen se queda como estaba.`;
+    }
+    const png = Buffer.from(await r.arrayBuffer());
+    // A R2, no al documento. Ver la cabecera.
+    const sub = await fetch(SUBIDA, {
+      method: 'POST',
+      headers: { Authorization: `Bearer ${token}`, 'Content-Type': 'image/png', 'X-Ext': 'png' },
+      body: png,
+    });
+    if (!sub.ok) {
+      consumirMoneda(borrador.doc, s.moneda.id);
+      return '\n⚠️ El recorte salió bien pero no se pudo guardar en la nube. La imagen se queda '
+        + 'como estaba; vuelve a intentarlo.';
+    }
+    const { url } = await sub.json();
+    objetivo.src = url;
+    consumirMoneda(borrador.doc, s.moneda.id);
+    return `\nHecho: fondo quitado (${Math.round(png.length / 1024)} KB). La imagen ahora es el `
+      + 'recorte, guardado en la nube. La moneda del camaleón se consumió, como en el editor.';
+  }
+
+  consumirMoneda(borrador.doc, s.moneda.id);
+  return `\n⚠️ No sé rematar la moneda "${s.tipo}" sin navegador.`;
+}

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "boosterarena-mcp",
+  "version": "0.1.0",
+  "description": "El MCP de Booster: tu agente crea y edita presentaciones dentro de boosterarena.com",
+  "keywords": [
+    "mcp",
+    "booster",
+    "boosterarena",
+    "presentaciones",
+    "educacion"
+  ],
+  "homepage": "https://boosterarena.com",
+  "license": "UNLICENSED",
+  "type": "module",
+  "bin": {
+    "boosterarena-mcp": "cli.mjs"
+  },
+  "files": [
+    "cli.mjs",
+    "servidor.mjs",
+    "sesion.mjs",
+    "proyectos.mjs",
+    "subidas.mjs",
+    "encargos.mjs",
+    "dist/nucleo.mjs",
+    "LEEME.md"
+  ],
+  "dependencies": {
+    "@supabase/supabase-js": "^2.108.2"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "prepack": "node construir.mjs"
+  }
+}

package/proyectos.mjs

@@ -0,0 +1,140 @@
+// ─────────────────────────────────────────────────────────────────────────────
+//  LOS PROYECTOS, DESDE FUERA DEL NAVEGADOR.
+//
+//  Un proyecto de Booster es una fila con una columna `jsonb`: el documento es `Scene[]`, que
+//  es EXACTAMENTE lo que come y devuelve `robot/ejecutor.ts`. Por eso el MCP no necesita
+//  ningún formato intermedio — abre, ejecuta la tanda, guarda.
+//
+//  TODO PASA POR EL REST DE SUPABASE CON EL TOKEN DEL MAESTRO. No hay `service_role` por aquí
+//  a propósito: el RLS es el que decide qué ve y qué toca cada uno, y es el MISMO que ya
+//  protege al navegador. Un agente no puede llegar más lejos que la persona que lo abrió.
+//
+//  ⚠️ GUARDAR ES PARCIAL, NUNCA UN UPSERT ENTERO. Se mandan solo `document` y `slide_count`.
+//  El editor puede estar autoguardando el mismo proyecto en otra pestaña: un upsert completo
+//  desde aquí le pisaría el título, la miniatura o el equipo. Es la misma disciplina que ya
+//  siguen `saveThumb` y `renameProject` en `src/projects/store.ts`, y por la misma razón.
+//
+//    node mcp/proyectos.mjs listar
+//    node mcp/proyectos.mjs abrir <id>
+//    node mcp/proyectos.mjs crear "Título de la clase"
+// ─────────────────────────────────────────────────────────────────────────────
+import { pathToFileURL } from 'node:url';
+import { tokenDeAcceso } from './sesion.mjs';
+
+const SUPABASE_URL = 'https://kjoadzhtgbrngpppbysh.supabase.co';
+const SUPABASE_KEY = 'sb_publishable_Zkvuw-xVLuns3msI14xH0g_YG5SYo7G';
+const REST = `${SUPABASE_URL}/rest/v1`;
+
+/** Las columnas de la LISTA. Sin `document` a posta: un curso entero son megas, y para elegir
+ *  proyecto no hace falta ni una escena. La lista de la galería hace lo mismo. */
+const COLUMNAS_LISTA = 'id,type,title,slide_count,updated_at,folder_id,team_id';
+
+async function pedir(token, ruta, opciones = {}) {
+  const r = await fetch(`${REST}/${ruta}`, {
+    ...opciones,
+    headers: {
+      apikey: SUPABASE_KEY,
+      Authorization: `Bearer ${token}`,
+      'Content-Type': 'application/json',
+      ...(opciones.headers ?? {}),
+    },
+  });
+  if (!r.ok) {
+    const detalle = await r.text();
+    // El 401 tiene una causa concreta y una salida concreta: no vale con «falló».
+    if (r.status === 401) throw new Error('La sesión ya no vale. Vuelve a entrar: `sesion.mjs entrar`.');
+    throw new Error(`Supabase contestó ${r.status}: ${detalle.slice(0, 300)}`);
+  }
+  return r.status === 204 ? null : r.json();
+}
+
+/** Los proyectos del maestro, del más reciente al más viejo. Sin el documento. */
+export async function listar(token, { tipo, limite = 50 } = {}) {
+  const q = new URLSearchParams({ select: COLUMNAS_LISTA, order: 'updated_at.desc', limit: String(limite) });
+  if (tipo) q.set('type', `eq.${tipo}`);
+  return pedir(token, `projects?${q}`);
+}
+
+/** Un proyecto ENTERO, con su documento. Es lo que el ejecutor va a modificar. */
+export async function abrir(token, id) {
+  const filas = await pedir(token, `projects?id=eq.${encodeURIComponent(id)}&select=*&limit=1`);
+  if (!filas.length) throw new Error(`No hay ningún proyecto con id ${id} en esta cuenta.`);
+  return filas[0];
+}
+
+/**
+ * Guarda el documento. Update PARCIAL: solo `document` y `slide_count`.
+ * `escenas` es el `Scene[]` que devuelve el ejecutor.
+ */
+export async function guardar(token, id, escenas) {
+  if (!Array.isArray(escenas)) throw new Error('El documento tiene que ser una lista de escenas (Scene[]).');
+  const slides = escenas.reduce((n, e) => n + (e.slides?.length ?? 0), 0);
+  await pedir(token, `projects?id=eq.${encodeURIComponent(id)}`, {
+    method: 'PATCH',
+    headers: { Prefer: 'return=minimal' },
+    body: JSON.stringify({ document: escenas, slide_count: slides }),
+  });
+  return { slides };
+}
+
+/**
+ * Crea un proyecto nuevo. `team_id` va sin poner a propósito: hay un trigger
+ * (`projects_default_team`) que lo manda al equipo personal del maestro, que es lo que
+ * queremos por defecto.
+ */
+export async function crear(token, titulo, tipo = 'presentation') {
+  const escenaVacia = [{ id: `sc-${Date.now().toString(36)}`, name: 'Escena 1', slides: [{ id: `sl-${Date.now().toString(36)}`, base: [], layers: [] }] }];
+  const filas = await pedir(token, 'projects?select=*', {
+    method: 'POST',
+    headers: { Prefer: 'return=representation' },
+    body: JSON.stringify({
+      type: tipo,
+      title: titulo?.trim() || 'Presentación sin título',
+      slide_count: 1,
+      document: tipo === 'presentation' ? escenaVacia : null,
+      assets: [],
+    }),
+  });
+  return filas[0];
+}
+
+// ── Cara de línea de comandos (para probar a mano) ───────────────────────────
+// `pathToFileURL` y no una plantilla a mano: en Windows la URL lleva TRES barras
+// (`file:///C:/...`), y compararla con dos hacía que el comando se quedara MUDO, sin error.
+if (import.meta.url === pathToFileURL(process.argv[1]).href) {
+  const YO = `node ${process.argv[1]}`;
+  const [, , orden, ...resto] = process.argv;
+  const token = await tokenDeAcceso();
+  if (!token) {
+    console.error('\n  ✕ No hay sesión. Entra primero con `sesion.mjs entrar`.\n');
+    process.exit(1);
+  }
+  try {
+    if (orden === 'listar') {
+      const ps = await listar(token);
+      console.log(`\n  ${ps.length} proyecto(s):\n`);
+      for (const p of ps) {
+        const fecha = new Date(p.updated_at).toISOString().slice(0, 16).replace('T', ' ');
+        console.log(`  ${p.id}  ${String(p.slide_count).padStart(3)} slides  ${fecha}  ${p.title}`);
+      }
+      console.log('');
+    } else if (orden === 'abrir') {
+      const p = await abrir(token, resto[0]);
+      const escenas = Array.isArray(p.document) ? p.document : [];
+      console.log(`\n  «${p.title}»  ·  ${p.type}  ·  ${escenas.length} escena(s)\n`);
+      for (const e of escenas) console.log(`    ${e.name ?? '(sin nombre)'} — ${e.slides?.length ?? 0} slide(s)`);
+      console.log('');
+    } else if (orden === 'crear') {
+      const p = await crear(token, resto.join(' '));
+      console.log(`\n  ✓ Creado «${p.title}»\n    id: ${p.id}\n`);
+    } else {
+      console.log('\n  Proyectos de Booster desde la terminal\n');
+      console.log(`    ${YO} listar`);
+      console.log(`    ${YO} abrir <id>`);
+      console.log(`    ${YO} crear "Título de la clase"\n`);
+    }
+  } catch (e) {
+    console.error(`\n  ✕ ${e.message}\n`);
+    process.exit(1);
+  }
+}

package/servidor.mjs

@@ -0,0 +1,364 @@
+// ─────────────────────────────────────────────────────────────────────────────
+//  EL SERVIDOR MCP DE BOOSTER.
+//
+//  Esto es lo que convierte todo lo demás en algo que un agente puede usar. Hasta ahora las
+//  piezas estaban —la puerta, los proyectos, el ejecutor puro, las fábricas, el registro— pero
+//  nadie de fuera podía hablar con ellas: hacía falta un script que importara los módulos.
+//
+//  CÓMO SE CONECTA UN AGENTE. Por la entrada y la salida estándar, con JSON-RPC 2.0 en líneas
+//  sueltas. Se declara en el `mcp.json` del cliente:
+//
+//      { "mcpServers": { "booster": { "command": "node",
+//        "args": ["<ruta>/mcp/servidor.mjs"] } } }
+//
+//  ⚠️ LA SALIDA ESTÁNDAR ES DEL PROTOCOLO. Un `console.log` suelto aquí corrompe el canal y el
+//  cliente se desconecta sin decir por qué. TODO lo que se quiera contar va por `stderr`
+//  (`aviso()`), que el cliente enseña como registro. Es el error clásico de un servidor MCP y
+//  se paga con una hora de no entender nada.
+//
+//  QUÉ NO HACE FALTA HOSPEDAR. Nada. Esto corre en la máquina del maestro y habla con las
+//  mismas funciones de `/api` que usa el navegador, con su token. El candado del plan ya vive
+//  allí, así que un agente no puede llegar más lejos que la persona que lo abrió.
+//
+//    node mcp/sesion.mjs entrar     ← primero hay que tener sesión
+//    node mcp/servidor.mjs          ← esto lo arranca el cliente, no tú
+// ─────────────────────────────────────────────────────────────────────────────
+import { createInterface } from 'node:readline';
+import { unlinkSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { existsSync } from 'node:fs';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { tokenDeAcceso } from './sesion.mjs';
+import { abrir, crear, guardar, listar } from './proyectos.mjs';
+import { subirArchivo } from './subidas.mjs';
+import { rematarEncargo } from './encargos.mjs';
+
+const aviso = (...a) => process.stderr.write(`[booster-mcp] ${a.join(' ')}\n`);
+
+// Los mismos valores públicos que el navegador (ver `mcp/sesion.mjs`).
+const SUPABASE_URL = 'https://kjoadzhtgbrngpppbysh.supabase.co';
+const SUPABASE_KEY = 'sb_publishable_Zkvuw-xVLuns3msI14xH0g_YG5SYo7G';
+
+// ── El núcleo ────────────────────────────────────────────────────────────────
+// El núcleo está en TypeScript y Node no lo carga solo, así que hay DOS caminos y se prefiere
+// el primero:
+//
+//   1. `dist/nucleo.mjs` — lo deja `construir.mjs` antes de publicar. El paquete que instala
+//      Planificatron trae esto y NO necesita esbuild ni el repo: arranca y ya.
+//   2. esbuild al vuelo sobre `src/nucleo/mcp.ts` — solo cuando se corre desde el repo, para
+//      que el servidor use SIEMPRE el código vivo y no una copia que se quede vieja.
+//
+// ⚠️ LA RUTA SE CALCULA DESDE ESTE ARCHIVO, NO DESDE EL DIRECTORIO ACTUAL. Antes decía
+// `entryPoints: ['src/nucleo/mcp.ts']`, que es relativo al cwd: el cliente MCP arranca el
+// servidor desde donde le da la gana y aquello solo funcionaba si te habías puesto en la raíz
+// del proyecto. Un fallo que en el repo no se nota nunca y en casa ajena no arranca jamás.
+//
+// ⚠️ UNA SOLA ENTRADA (`src/nucleo/mcp.ts`), NO UNA POR MÓDULO. Empaquetar cada uno por
+// separado le da a cada paquete su propia copia de lo compartido: se llamaba a
+// `cargarBiblioteca()` en una y `poner_dibujo` buscaba en otra, vacía. Contestaba «no hay nada
+// parecido a "torre Eiffel"» con el dibujo delante. Ver la cabecera de `src/nucleo/mcp.ts`.
+const AQUI = fileURLToPath(new URL('.', import.meta.url));
+const RAIZ = join(AQUI, '..');
+const YA_HECHO = join(AQUI, 'dist', 'nucleo.mjs');
+
+let nucleo;
+if (existsSync(YA_HECHO)) {
+  nucleo = await import(pathToFileURL(YA_HECHO).href);
+  aviso('núcleo cargado (compilado)');
+} else {
+  const esbuild = await import('esbuild').catch(() => {
+    throw new Error('No encuentro ni `mcp/dist/nucleo.mjs` ni esbuild. Si estás en el repo, '
+      + 'corre `npm install`; si esto es el paquete instalado, está incompleto y hay que '
+      + 'reinstalarlo.');
+  });
+  const salida = join(tmpdir(), `booster-mcp-nucleo-${process.pid}.mjs`);
+  await esbuild.build({
+    entryPoints: [join(RAIZ, 'src/nucleo/mcp.ts')], bundle: true, format: 'esm',
+    platform: 'neutral', outfile: salida, logLevel: 'silent',
+  });
+  nucleo = await import(pathToFileURL(salida).href);
+  try { unlinkSync(salida); } catch { /* da igual */ }
+  aviso('núcleo cargado (del repo, al vuelo)');
+}
+
+// ── El estado de la sesión ───────────────────────────────────────────────────
+// Un servidor por cliente, así que el estado vive aquí: qué proyecto está abierto y el
+// borrador sobre el que se trabaja. `guardar_proyecto` lo sube y ya.
+const yo = { proyecto: null, borrador: null, plan: 'desconocido' };
+
+let idSeq = 0;
+const manos = () => ({
+  premium: yo.plan === 'pro',
+  uid: (p) => `mcp${p}-${Date.now().toString(36)}-${(idSeq++).toString(36)}`,
+  // Cascada tonta: lo justo para que dos boosters seguidos no caigan exactamente encima.
+  nextPos: (x, y) => ({ x: Math.min(92, x + (idSeq % 5) * 2.5), y: Math.min(84, y + (idSeq % 5) * 2.5) }),
+});
+const fabricas = () => ({
+  nuevoWidget: (t) => nucleo.construirWidget(t, manos()),
+  nuevaArena: (t) => nucleo.construirArena(t, manos()),
+});
+
+async function token() {
+  const t = await tokenDeAcceso();
+  if (!t) throw new Error('No hay sesión en este equipo. Corre `node mcp/sesion.mjs entrar` y vuelve a arrancar el agente.');
+  return t;
+}
+
+/**
+ * El plan del maestro, de la MISMA tabla que lee el navegador (`profiles.plan`, ver
+ * `src/lib/billing.ts`). Una sola fuente a propósito: si el MCP mirara otro sitio, un día
+ * diría «Pro» donde el editor dice «free» y nadie entendería por qué.
+ *
+ * Sin fila o sin poder leerla ⇒ `free`. Equivocarse hacia abajo cuesta un aviso; equivocarse
+ * hacia arriba regala lo de pago.
+ */
+async function mirarPlan(t) {
+  try {
+    const r = await fetch(`${SUPABASE_URL}/rest/v1/profiles?select=plan&limit=1`, {
+      headers: { apikey: SUPABASE_KEY, Authorization: `Bearer ${t}` },
+    });
+    const filas = r.ok ? await r.json() : [];
+    yo.plan = filas[0]?.plan === 'pro' ? 'pro' : 'free';
+  } catch { yo.plan = 'free'; }
+  aviso(`plan de la cuenta: ${yo.plan}`);
+}
+
+// ── Las herramientas ─────────────────────────────────────────────────────────
+// Las del lienzo salen del MISMO catálogo que ve el Robot en el navegador: si el editor
+// aprende algo nuevo, el MCP lo sabe usar sin tocar este archivo. Solo cambia el envoltorio
+// (`parameters` de OpenAI → `inputSchema` de MCP), que resultan ser el mismo JSON Schema.
+function herramientasDelLienzo() {
+  return nucleo.construirCatalogo({
+    boosters: nucleo.ALL_WIDGETS.filter((w) => w.ready).map((w) => w.type),
+    arenas: nucleo.ARENAS.filter((a) => a.ready).map((a) => a.type),
+    formas: Object.keys(nucleo.FORMA_DEF),
+  }).map((t) => ({
+    name: t.function.name,
+    description: t.function.description,
+    inputSchema: t.function.parameters,
+  }));
+}
+
+const HERRAMIENTAS_PROYECTO = [
+  {
+    name: 'listar_proyectos',
+    description: 'Los proyectos de Booster del maestro, del más reciente al más viejo. Devuelve id, '
+      + 'título y cuántos slides tiene. Úsalo para saber sobre cuál trabajar.',
+    inputSchema: { type: 'object', properties: {}, required: [] },
+  },
+  {
+    name: 'abrir_proyecto',
+    description: 'Abre un proyecto y lo deja LISTO para trabajar. A partir de aquí, todo lo que pongas '
+      + 'cae en él. Hay que llamarlo antes que cualquier herramienta del lienzo.',
+    inputSchema: {
+      type: 'object',
+      properties: { id: { type: 'string', description: 'El id que devolvió `listar_proyectos`.' } },
+      required: ['id'],
+    },
+  },
+  {
+    name: 'crear_proyecto',
+    description: 'Crea una presentación nueva, vacía, y la deja abierta para trabajar.',
+    inputSchema: {
+      type: 'object',
+      properties: { titulo: { type: 'string', description: 'Cómo se va a llamar. Ej: "A2 Kids · Topic 9 · Clase 2".' } },
+      required: ['titulo'],
+    },
+  },
+  {
+    name: 'guardar_proyecto',
+    description: '⚠️ SUBE A LA NUBE lo que llevas hecho. Hasta que llames a esto, nada de lo que has '
+      + 'puesto existe fuera de esta conversación. Llámalo al terminar, y también de vez en cuando '
+      + 'si la tanda es larga.',
+    inputSchema: { type: 'object', properties: {}, required: [] },
+  },
+  {
+    name: 'subir_imagen',
+    description: 'Sube una imagen de ESTA computadora a la nube de Booster y devuelve su URL. Es '
+      + 'para lo que genera tu fábrica (Flux, un render, una foto). Después ponla en el slide con '
+      + '`poner_imagen` usando la URL que devuelve. ⚠️ Conviértela a WebP antes: eso se le '
+      + 'descarga al alumno.',
+    inputSchema: {
+      type: 'object',
+      properties: { ruta: { type: 'string', description: 'Ruta completa del archivo en esta computadora.' } },
+      required: ['ruta'],
+    },
+  },
+  {
+    name: 'subir_audio',
+    description: 'Sube un audio de ESTA computadora a la nube de Booster y devuelve su URL. Es para '
+      + 'lo que genera tu fábrica (un TTS, una grabación). Después ponlo con `poner_audio`. '
+      + 'Booster NO genera voz: la trae quien llama.',
+    inputSchema: {
+      type: 'object',
+      properties: { ruta: { type: 'string', description: 'Ruta completa del archivo en esta computadora.' } },
+      required: ['ruta'],
+    },
+  },
+  {
+    name: 'transformar_en',
+    description: 'Hace que un objeto se CONVIERTA en otras imágenes al hacerle clic en el ▶ Player '
+      + '(de la oruga a la mariposa); la última lo devuelve a como estaba. Es el remate de '
+      + '`aplicar_booster` con "transformar", que por sí solo no puede saber en qué se convierte. '
+      + 'Las imágenes tienen que estar ya subidas: usa `subir_imagen` si están en el disco.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        objetivo: { type: 'string', description: 'El `ref` o el id del objeto que se transforma.' },
+        urls: {
+          type: 'array', items: { type: 'string' },
+          description: 'Las imágenes por las que va pasando, en orden. De 1 a 12.',
+        },
+      },
+      required: ['objetivo', 'urls'],
+    },
+  },
+  {
+    name: 'ver_slide',
+    description: 'Cuenta qué hay ahora mismo en el proyecto abierto: sus escenas, sus slides y lo que '
+      + 'tiene cada uno. Úsalo para orientarte antes de tocar algo que ya existe.',
+    inputSchema: { type: 'object', properties: {}, required: [] },
+  },
+];
+
+// ── Ejecutar una herramienta ─────────────────────────────────────────────────
+function exigeProyecto() {
+  if (!yo.borrador) {
+    throw new Error('No hay ningún proyecto abierto. Llama antes a `abrir_proyecto` (o a '
+      + '`crear_proyecto` si es una clase nueva).');
+  }
+}
+
+function resumenDelDoc(doc) {
+  const filas = [];
+  doc.forEach((esc, i) => {
+    filas.push(`Escena ${i + 1}: «${esc.name ?? 'sin nombre'}» — ${esc.slides.length} slide(s)`);
+    esc.slides.forEach((s, j) => {
+      const qué = s.base.map((e) => (
+        e.kind === 'text' ? `texto «${String(e.text ?? '').slice(0, 26)}»`
+          : e.kind === 'arena' ? `ARENA ${e.arena}`
+            : e.kind === 'widget' ? `booster ${e.widget}`
+              : e.kind === 'image' ? 'dibujo' : e.kind));
+      filas.push(`  slide ${j + 1}: ${qué.join(' · ') || '(vacío)'}`);
+    });
+  });
+  return filas.join('\n');
+}
+
+async function llamar(nombre, args = {}) {
+  // ── Proyectos ──────────────────────────────────────────────────────────────
+  if (nombre === 'listar_proyectos') {
+    const t = await token();
+    const ps = await listar(t, { tipo: 'presentation' });
+    return ps.map((p) => `${p.id}  ${String(p.slide_count).padStart(3)} slides  ${p.title}`).join('\n')
+      || 'No hay ningún proyecto todavía. Crea uno con `crear_proyecto`.';
+  }
+  if (nombre === 'abrir_proyecto' || nombre === 'crear_proyecto') {
+    const t = await token();
+    await mirarPlan(t);
+    const p = nombre === 'crear_proyecto' ? await crear(t, args.titulo) : await abrir(t, args.id);
+    if (p.type !== 'presentation') throw new Error(`«${p.title}» es un ${p.type}, y por aquí solo se trabajan presentaciones.`);
+    yo.proyecto = p;
+    yo.borrador = nucleo.nuevoBorrador(Array.isArray(p.document) ? p.document : [], 0, 0, '');
+    await nucleo.cargarBiblioteca();  // `poner_dibujo` busca en caliente
+    return `Abierto «${p.title}» (${yo.borrador.doc.length} escena(s)). Plan de la cuenta: ${yo.plan}.\n\n${resumenDelDoc(yo.borrador.doc)}`;
+  }
+  if (nombre === 'subir_imagen' || nombre === 'subir_audio') {
+    const t = await token();
+    const r = await subirArchivo(t, args.ruta, nombre === 'subir_imagen' ? 'imagen' : 'audio');
+    return `Subido «${r.nombre}» (${r.kb} KB).
+URL: ${r.url}
+`
+      + `Ahora ponlo con \`${nombre === 'subir_imagen' ? 'poner_imagen' : 'poner_audio'}\` usando esa URL.`
+      + (r.aviso ? `
+${r.aviso}` : '');
+  }
+  if (nombre === 'guardar_proyecto') {
+    exigeProyecto();
+    const t = await token();
+    const { slides } = await guardar(t, yo.proyecto.id, yo.borrador.doc);
+    return `Guardado en la nube: «${yo.proyecto.title}», ${slides} slide(s). Ya se puede abrir en boosterarena.com.`;
+  }
+  if (nombre === 'ver_slide') {
+    exigeProyecto();
+    return resumenDelDoc(yo.borrador.doc);
+  }
+
+  // ── Transformar: la única moneda que necesita datos de fuera ────────────────
+  // En el editor, el maestro elige en un diálogo en qué se convierte el objeto. Aquí no hay
+  // diálogo, así que las imágenes las trae quien llama.
+  if (nombre === 'transformar_en') {
+    exigeProyecto();
+    const urls = (args.urls ?? []).filter((u) => /^https?:\/\//i.test(String(u)));
+    if (!urls.length) throw new Error('Ninguna de esas `urls` es una dirección https:// de una imagen ya subida. Súbelas antes con `subir_imagen`.');
+    if (urls.length > 12) throw new Error('Doce imágenes es el tope: una cadena más larga no hay quien la proyecte.');
+    const id = yo.borrador.alias.get(String(args.objetivo).trim()) ?? String(args.objetivo).trim();
+    let obj = null;
+    for (const esc of yo.borrador.doc) for (const sl of esc.slides) { const e = sl.base.find((x) => x.id === id); if (e) obj = e; }
+    if (!obj) throw new Error(`No encuentro ningún objeto "${args.objetivo}".`);
+    obj.morph = { srcs: urls };
+    return `Listo: al hacer clic sobre ese objeto en el ▶ Player irá pasando por ${urls.length} `
+      + 'imagen(es) y volverá a la original.';
+  }
+
+  // ── El lienzo: lo hace el MISMO ejecutor que el Robot del navegador ─────────
+  exigeProyecto();
+  const dijo = nucleo.ejecutar(yo.borrador, nombre, args, fabricas());
+  // Si la herramienta dejó un ENCARGO (una de las tres monedas que se sueltan sobre algo), se
+  // remata aquí: en el navegador lo hace el editor con su animación; sin navegador, esto.
+  const remate = yo.borrador.pedirSoltar ? await rematarEncargo(yo.borrador, await token()) : '';
+  // La bitácora es lo que el editor le enseña al maestro. Aquí se devuelve también, porque
+  // para un agente es la única forma de saber qué quedó apuntado.
+  const últimas = yo.borrador.bitacora.slice(-3).join(' · ');
+  return `${dijo}${remate}${últimas ? `\n(bitácora: ${últimas})` : ''}`;
+}
+
+// ── El protocolo ─────────────────────────────────────────────────────────────
+const escribir = (obj) => process.stdout.write(`${JSON.stringify(obj)}\n`);
+const ok = (id, result) => escribir({ jsonrpc: '2.0', id, result });
+const mal = (id, code, message) => escribir({ jsonrpc: '2.0', id, error: { code, message } });
+
+async function atender(msg) {
+  const { id, method, params } = msg;
+  // Las notificaciones no llevan id y NO se contestan. Contestarlas rompe a algunos clientes.
+  if (id === undefined) return;
+
+  if (method === 'initialize') {
+    return ok(id, {
+      protocolVersion: params?.protocolVersion ?? '2024-11-05',
+      capabilities: { tools: {} },
+      serverInfo: { name: 'booster', version: '0.1.0' },
+    });
+  }
+  if (method === 'tools/list') {
+    return ok(id, { tools: [...HERRAMIENTAS_PROYECTO, ...herramientasDelLienzo()] });
+  }
+  if (method === 'tools/call') {
+    const nombre = params?.name;
+    try {
+      const texto = await llamar(nombre, params?.arguments ?? {});
+      return ok(id, { content: [{ type: 'text', text: String(texto) }] });
+    } catch (e) {
+      // Un fallo de herramienta se devuelve como RESULTADO con `isError`, no como error de
+      // protocolo: así el agente lo lee, lo entiende y puede corregir en el mismo turno, en vez
+      // de que el cliente lo trate como una caída del servidor.
+      aviso(`fallo en ${nombre}: ${e.message}`);
+      return ok(id, { content: [{ type: 'text', text: `✕ ${e.message}` }], isError: true });
+    }
+  }
+  return mal(id, -32601, `No conozco el método "${method}".`);
+}
+
+createInterface({ input: process.stdin }).on('line', (linea) => {
+  const t = linea.trim();
+  if (!t) return;
+  let msg;
+  try { msg = JSON.parse(t); } catch { return aviso('llegó una línea que no era JSON'); }
+  atender(msg).catch((e) => {
+    aviso(`error atendiendo: ${e.message}`);
+    if (msg.id !== undefined) mal(msg.id, -32603, e.message);
+  });
+});
+
+aviso('listo, escuchando por stdio');