ratacode 0.2.5

package/mcp/lib/tareas.js

@@ -0,0 +1,406 @@
+/**
+ * tareas — el registro de trabajos del MCP.
+ *
+ * Estados: `queued` → `running` → `completed` | `failed` | `cancelled`.
+ * Se guardan en `<casa>/mcp/tareas/<id>.json` (para poder mirarlos sin
+ * pantalla y para que el panel los lea) y se resume el conjunto en
+ * `<casa>/mcp/estado.json`.
+ *
+ * Una tarea = un hijo del motor. Cancelar = matar ese hijo. Por eso el estado
+ * nunca miente: si el hijo se fue, la tarea está terminada.
+ */
+import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { anotar } from './actividad.js';
+import { ajustesMcp } from './casa.js';
+import { apuntarSesionEnEspacio } from './espacios.js';
+import { lanzarTarea } from './nucleo.js';
+
+/** Un id corto y ordenable. */
+function nuevoId() {
+  const sello = Date.now().toString(36);
+  const azar = Math.random().toString(36).slice(2, 6);
+  return 't-' + sello + '-' + azar;
+}
+
+/** El registro de tareas de una casa. */
+export class Tareas {
+  /**
+   * @param {{casa: string, dshBin: string}} opciones - la casa y el motor.
+   */
+  constructor({ casa, dshBin }) {
+    this.casa = casa;
+    this.dshBin = dshBin;
+    /** @type {Map<string, object>} */
+    this.mapa = new Map();
+    /** @type {Set<string>} */
+    this.clientes = new Set();
+  }
+
+  /** La carpeta de tareas. */
+  get carpeta() {
+    return join(this.casa, 'mcp', 'tareas');
+  }
+
+  /** Anotar que un cliente se ha presentado (para el panel). */
+  verCliente(nombre) {
+    if (typeof nombre === 'string' && nombre.trim() !== '') this.clientes.add(nombre.trim());
+  }
+
+  /**
+   * Lanzar una tarea.
+   * @param {object} peticion - prompt, ruta de modelo, espacio, modo y límites.
+   * @returns {object} el recibo (task_id y estado).
+   */
+  crear(peticion) {
+    const taskId = nuevoId();
+    const registro = {
+      task_id: taskId,
+      estado: 'queued',
+      prompt: peticion.prompt,
+      prompt_resumen: peticion.prompt.replace(/\s+/g, ' ').trim().slice(0, 200),
+      provider: peticion.provider,
+      model: peticion.model,
+      espacio: peticion.espacio,
+      modo: peticion.modo,
+      max_tokens: peticion.maxTokens ?? null,
+      timeout_ms: peticion.timeoutMs ?? null,
+      cliente: peticion.cliente ?? 'MCP',
+      creada: new Date().toISOString(),
+      empezada: null,
+      terminada: null,
+      duracion_ms: null,
+      respuesta: null,
+      pasos: 0,
+      tokens: null,
+      coste: null,
+      motivo: null,
+      errores: [],
+      cancelada: false,
+      session_id: null,
+    };
+    this.mapa.set(taskId, registro);
+    this.persistir(registro);
+    this.resumir();
+
+    const mando = lanzarTarea({
+      id: taskId,
+      casa: this.casa,
+      dshBin: this.dshBin,
+      espacio: peticion.espacio,
+      raices: peticion.raices,
+      provider: peticion.provider,
+      model: peticion.model,
+      prompt: peticion.prompt,
+      maxTokens: peticion.maxTokens,
+      timeoutMs: peticion.timeoutMs,
+      modo: peticion.modo,
+    });
+    registro._mando = mando;
+    registro.estado = 'running';
+    registro.empezada = new Date().toISOString();
+    this.apuntarEnElPanel(registro);
+    this.persistir(registro);
+    this.resumir();
+
+    const cierre = mando.promesa.then((salida) => {
+      registro.session_id = salida.session_id;
+      registro.duracion_ms = salida.duracion_ms;
+      registro.respuesta = salida.texto === '' ? null : salida.texto;
+      registro.pasos = salida.pasos;
+      registro.tokens = salida.tokens?.informado === true
+        ? { input: salida.tokens.input, output: salida.tokens.output, total: salida.tokens.total, cache_read: salida.tokens.cache_read, cache_write: salida.tokens.cache_write, reasoning: salida.tokens.reasoning }
+        : null;
+      registro.motivo = salida.motivo;
+      registro.errores = salida.errores;
+      registro.cancelada = salida.cancelada === true;
+      registro.codigo_salida = salida.codigo_salida;
+      registro.coste = this.calcularCoste(registro);
+      registro.terminada = new Date().toISOString();
+      if (registro.cancelada) registro.estado = 'cancelled';
+      else if (salida.ok === true) registro.estado = 'completed';
+      else registro.estado = 'failed';
+      delete registro._mando;
+      // Y otra vez, ya cerrada: el panel puede haber reescrito su copia del
+      // registro mientras la tarea corría, y la sesión tiene que seguir ahí.
+      this.apuntarEnElPanel(registro);
+      this.persistir(registro);
+      this.resumir();
+      anotar(this.casa, {
+        cliente: registro.cliente,
+        modelo: registro.model,
+        proveedor: registro.provider,
+        tarea: registro.prompt,
+        duracion_ms: registro.duracion_ms,
+        tokens_input: registro.tokens?.input ?? null,
+        tokens_output: registro.tokens?.output ?? null,
+        coste: registro.coste?.total ?? null,
+        estado: registro.estado,
+        espacio: registro.espacio,
+        task_id: registro.task_id,
+      });
+    });
+    /** Se resuelve cuando la tarea ha cerrado de verdad (lo espera `cancelar`). */
+    registro._cierre = cierre;
+
+    return this.recibo(registro);
+  }
+
+  /**
+   * Apuntar la sesión de ESTA tarea en el registro de espacios de la casa, que
+   * es de donde el panel saca la barra lateral: así cada tarea del MCP se ve en
+   * el panel, con su conversación, y deja de ser una caja negra (R12 §3, R16 §3).
+   * Nunca puede tumbar una tarea: si el registro no se deja escribir, se apunta
+   * el motivo y se sigue.
+   * @param {object} registro - la tarea.
+   */
+  apuntarEnElPanel(registro) {
+    try {
+      const salida = apuntarSesionEnEspacio(this.casa, registro.espacio, 'mcp-' + registro.task_id);
+      registro.en_panel = salida.apuntada === true;
+      if (salida.apuntada === true) delete registro.aviso_panel;
+      else registro.aviso_panel = salida.motivo ?? 'no se pudo apuntar la sesión en el panel';
+    } catch (e) {
+      registro.en_panel = false;
+      registro.aviso_panel = e instanceof Error ? e.message : String(e);
+    }
+    if (registro.session_id === null) registro.session_id = 'mcp-' + registro.task_id;
+    return registro.en_panel;
+  }
+
+  /** El estado de una tarea, o un error claro si no existe. */
+  estado(taskId) {
+    const registro = this.exigir(taskId);
+    return {
+      task_id: registro.task_id,
+      estado: registro.estado,
+      provider: registro.provider,
+      model: registro.model,
+      espacio: registro.espacio,
+      modo: registro.modo,
+      cliente: registro.cliente,
+      creada: registro.creada,
+      empezada: registro.empezada,
+      terminada: registro.terminada,
+      duracion_ms: registro.duracion_ms,
+      pasos: registro.pasos,
+      cancelada: registro.cancelada,
+      motivo: registro.motivo,
+      errores: registro.errores,
+      coste: registro.coste,
+      sesion_en_el_panel: registro.en_panel === true,
+      aviso_panel: registro.aviso_panel ?? null,
+    };
+  }
+
+  /** El resultado de una tarea. Si aún no terminó, se dice, no se inventa. */
+  resultado(taskId) {
+    const registro = this.exigir(taskId);
+    if (registro.estado === 'queued' || registro.estado === 'running') {
+      throw new Error('la tarea ' + taskId + ' sigue en «' + registro.estado + '». Espera y vuelve a preguntar (get_task_status).');
+    }
+    return {
+      task_id: registro.task_id,
+      estado: registro.estado,
+      respuesta: registro.respuesta,
+      modelo: registro.model,
+      proveedor: registro.provider,
+      espacio: registro.espacio,
+      tokens: registro.tokens,
+      coste: registro.coste,
+      duracion_ms: registro.duracion_ms,
+      pasos: registro.pasos,
+      motivo: registro.motivo,
+      errores: registro.errores,
+      cancelada: registro.cancelada,
+      session_id: registro.session_id,
+      sesion_en_el_panel: registro.en_panel === true,
+    };
+  }
+
+  /**
+   * Esperar a que una tarea cierre, como mucho `ms`. Si ya había cerrado, se
+   * resuelve al momento: no se duerme de más. Nunca lanza por tardar — devuelve
+   * si terminó o no, y quien llama decide qué contar.
+   * @param {string} taskId - el id que devolvió `crear`.
+   * @param {number} ms - tope de espera, en milisegundos.
+   * @returns {Promise<{terminada: boolean, esperada_ms: number, estado: string}>}
+   */
+  async esperar(taskId, ms) {
+    const registro = this.exigir(taskId);
+    const empezado = Date.now();
+    const viva = registro.estado === 'queued' || registro.estado === 'running';
+    if (viva && registro._cierre !== undefined) {
+      let temporizador;
+      try {
+        await Promise.race([
+          registro._cierre,
+          new Promise((listo) => { temporizador = setTimeout(listo, ms); }),
+        ]);
+      } finally {
+        if (temporizador !== undefined) clearTimeout(temporizador);
+      }
+    }
+    return {
+      terminada: registro.estado !== 'queued' && registro.estado !== 'running',
+      esperada_ms: Date.now() - empezado,
+      estado: registro.estado,
+    };
+  }
+
+  /** Cancelar: se mata el hijo de esa tarea. El recibo no miente: se espera a que la tarea cierre. */
+  async cancelar(taskId) {
+    const registro = this.exigir(taskId);
+    if (registro.estado === 'queued' || registro.estado === 'running') {
+      if (registro._mando !== undefined) {
+        // `cancelar` mata el árbol y termina la tarea; el estado se escribe cuando
+        // la promesa se resuelve, así que aquí se espera antes de contestar.
+        registro._mando.cancelar('cancelada por el cliente');
+        await registro._cierre;
+      } else {
+        registro.cancelada = true;
+        registro.estado = 'cancelled';
+        this.persistir(registro);
+        this.resumir();
+      }
+    }
+    return this.estado(taskId);
+  }
+
+  /** Todas las tareas de esta sesión del servidor (las últimas primero). */
+  listar() {
+    return [...this.mapa.values()]
+      .sort((a, b) => (a.creada < b.creada ? 1 : -1))
+      .map((registro) => this.recibo(registro));
+  }
+
+  /** El recibo corto de una tarea. */
+  recibo(registro) {
+    return {
+      task_id: registro.task_id,
+      estado: registro.estado,
+      provider: registro.provider,
+      model: registro.model,
+      espacio: registro.espacio,
+      modo: registro.modo,
+      cliente: registro.cliente,
+    };
+  }
+
+  /** Una tarea del registro, o un error que dice qué ids hay. */
+  exigir(taskId) {
+    const registro = this.mapa.get(String(taskId));
+    if (registro === undefined) {
+      const conocidas = [...this.mapa.keys()].slice(-10);
+      throw new Error('no conozco la tarea «' + taskId + '»'
+        + (conocidas.length === 0 ? ' (todavía no hay ninguna)' : '. Las últimas que he visto: ' + conocidas.join(', ')));
+    }
+    return registro;
+  }
+
+  /**
+   * El coste, sólo si el humano declaró precios en `mcp.precios`.
+   * Si no hay precios o no hay tokens, se devuelve null: no se inventa.
+   */
+  calcularCoste(registro) {
+    if (registro.tokens === null) return null;
+    const precios = ajustesMcp(this.casa).precios;
+    const porProveedor = precios[registro.provider];
+    if (porProveedor === null || typeof porProveedor !== 'object') return null;
+    const entrada = porProveedor[registro.model];
+    if (entrada === null || typeof entrada !== 'object') return null;
+    const porEntrada = typeof entrada.entrada_por_millon === 'number' ? entrada.entrada_por_millon : null;
+    const porSalida = typeof entrada.salida_por_millon === 'number' ? entrada.salida_por_millon : null;
+    if (porEntrada === null || porSalida === null) return null;
+    const deEntrada = (registro.tokens.input / 1_000_000) * porEntrada;
+    const deSalida = (registro.tokens.output / 1_000_000) * porSalida;
+    return {
+      moneda: typeof entrada.moneda === 'string' ? entrada.moneda : 'EUR',
+      entrada: Number(deEntrada.toFixed(6)),
+      salida: Number(deSalida.toFixed(6)),
+      total: Number((deEntrada + deSalida).toFixed(6)),
+      origen: 'mcp.precios (declarado a mano en la casa)',
+    };
+  }
+
+  /** Guardar una tarea en disco (sin el mando ni la promesa de cierre, que son de memoria). */
+  persistir(registro) {
+    try {
+      mkdirSync(this.carpeta, { recursive: true });
+      const { _mando, _cierre, ...guardable } = registro;
+      writeFileSync(join(this.carpeta, registro.task_id + '.json'), JSON.stringify(guardable, null, 2) + '\n');
+    } catch {
+      // Que no poder escribir el cuaderno no tumbe la tarea.
+    }
+  }
+
+  /** El estado del servidor, para el panel y para `--status`. */
+  resumir() {
+    const tareas = [...this.mapa.values()];
+    const activas = tareas.filter((t) => t.estado === 'queued' || t.estado === 'running').length;
+    const estado = {
+      mcp: 'on',
+      casa: this.casa,
+      motor: this.dshBin,
+      actualizado: new Date().toISOString(),
+      tareas_totales: tareas.length,
+      tareas_activas: activas,
+      clientes: [...this.clientes],
+      ultima: tareas.length === 0 ? null : {
+        task_id: tareas[tareas.length - 1].task_id,
+        estado: tareas[tareas.length - 1].estado,
+        cliente: tareas[tareas.length - 1].cliente,
+        model: tareas[tareas.length - 1].model,
+        terminada: tareas[tareas.length - 1].terminada,
+      },
+    };
+    try {
+      mkdirSync(join(this.casa, 'mcp'), { recursive: true });
+      writeFileSync(join(this.casa, 'mcp', 'estado.json'), JSON.stringify(estado, null, 2) + '\n');
+    } catch {
+      // Igual que arriba: el cuaderno no puede tumbar el servicio.
+    }
+    return estado;
+  }
+}
+
+/**
+ * Leer el cuaderno de actividad de la casa (lo que ya pasó, aunque el servidor
+ * se haya reiniciado). Sólo lectura.
+ * @param {string} casa - la casa de RATACODE.
+ * @param {number} cuantas - cuántas líneas devolver (las últimas).
+ * @returns {object[]} las líneas más recientes primero.
+ */
+export function leerActividad(casa, cuantas = 20) {
+  const ruta = join(casa, 'mcp', 'actividad.jsonl');
+  if (!existsSync(ruta)) return [];
+  const lineas = readFileSync(ruta, 'utf8').split(/\r?\n/).filter((l) => l.trim() !== '');
+  const salida = [];
+  for (const linea of lineas.slice(-cuantas).reverse()) {
+    try {
+      salida.push(JSON.parse(linea));
+    } catch {
+      // Una línea rota no invalida el cuaderno.
+    }
+  }
+  return salida;
+}
+
+/**
+ * Un resumen de la casa para `ratacode-mcp --status`, sin arrancar el motor.
+ * @param {string} casa - la casa de RATACODE.
+ * @returns {object} estado del MCP y del cuaderno.
+ */
+export function estadoDeLaCasa(casa) {
+  const ruta = join(casa, 'mcp', 'estado.json');
+  const guardado = existsSync(ruta) ? JSON.parse(readFileSync(ruta, 'utf8')) : null;
+  const carpetaTareas = join(casa, 'mcp', 'tareas');
+  const cuantas = existsSync(carpetaTareas) ? readdirSync(carpetaTareas).filter((n) => n.endsWith('.json')).length : 0;
+  return {
+    mcp: guardado === null ? 'sin_arrancar' : 'on',
+    casa,
+    estado_guardado: guardado,
+    tareas_en_disco: cuantas,
+    ultimas: leerActividad(casa, 5),
+  };
+}

package/mcp/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "ratacode-mcp",
+  "version": "0.2.1",
+  "description": "Servidor MCP de RATACODE: deja que ChatGPT, Codex, Claude Code, Rowboat u OpenClaw manden trabajo a los modelos que ya tienes configurados en RATACODE.",
+  "license": "MIT",
+  "author": {
+    "name": "Patxi"
+  },
+  "type": "module",
+  "private": true,
+  "bin": {
+    "ratacode-mcp": "bin/ratacode-mcp.js"
+  },
+  "engines": {
+    "node": ">=24"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.30.1",
+    "js-yaml": "^4.3.2",
+    "zod": "^4.6.5"
+  }
+}

package/mcp/tunel.mjs

@@ -0,0 +1,209 @@
+#!/usr/bin/env node
+/**
+ * tunel.mjs — el túnel de Cloudflare para ChatGPT web.
+ *
+ * ⚠️ NO lo ejecutes tú solo: lo arranca el usuario cuando quiera abrir RATACODE a
+ * ChatGPT. Este script SÓLO es transporte: el servidor MCP (con su clave en la
+ * URL y su tope de tareas) ya funciona sin esto; el túnel sólo lo expone a
+ * Internet mientras corre.
+ *
+ * Y exponerlo ya NO expone nada de más: cada tarea va encerrada en las carpetas
+ * de `mcp.workspaces` (lee y escribe sólo ahí, sin terminal ni red ni
+ * subagentes), así que quien tenga la URL puede mandar trabajo, pero no sacar
+ * ficheros de fuera de esas carpetas. Antes hacía falta `--acepto-lectura-total`
+ * porque el motor no encerraba la LECTURA; desde R25 sí está encerrada (mira
+ * `lib/lectura.js`) y la bandera es un no-op que se acepta por no romper nada.
+ *
+ * Qué hace al ejecutarlo:
+ *   1. Lee la URL local del MCP (http://127.0.0.1:<puerto>/mcp/<clave>) de la
+ *      casa (<casa>/mcp/http-url.txt, o la reconstruye desde http-secret.txt).
+ *   2. Comprueba que `cloudflared` está instalado.
+ *   3. Si existe el túnel nombrado `mcp.mod-rat.com` (lo da de alta el usuario en
+ *      su Cloudflare), lo usa con ese hostname fijo (por fichero de config, no
+ *      por argumentos).
+ *   4. Si no, usa un quick tunnel sin cuenta (URL efímera).
+ *   5. Imprime la URL pública COMPLETA para pegar en ChatGPT (dominio + /mcp/<clave>).
+ *
+ * Uso:
+ *   node mcp/tunel.mjs --home <casa> [--port <puerto>] [--host 127.0.0.1] [--misma-clave]
+ *
+ * Al abrirlo estrena clave (el servidor que ya corre la adopta sin reiniciar);
+ * con `--misma-clave` reutiliza la que había.
+ *
+ * Para pararlo: Ctrl+C (mata cloudflared y deja de exponer el puerto).
+ */
+import { randomBytes } from 'node:crypto';
+import { spawnSync, spawn } from 'node:child_process';
+import { chmodSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { resolverCasa } from './lib/casa.js';
+
+const TUNEL_NOMBRADO = 'mcp.mod-rat.com';
+
+/** Escribir un secreto con permisos de sólo-dueño (en POSIX el `mode` no se
+ *  aplica si el fichero ya existía: por eso el `chmod` detrás). */
+function escribirSoloDueno(ruta, texto) {
+  mkdirSync(dirname(ruta), { recursive: true });
+  writeFileSync(ruta, texto, { mode: 0o600 });
+  try { chmodSync(ruta, 0o600); } catch { /* Windows: el modo es decorativo */ }
+}
+
+function leerOrdenes(argv) {
+  const o = { casa: undefined, port: 3778, aceptoLecturaTotal: false, mismaClave: false };
+  for (let i = 0; i < argv.length; i += 1) {
+    const a = argv[i];
+    if (a === '--acepto-lectura-total') { o.aceptoLecturaTotal = true; continue; }
+    if (a === '--misma-clave') { o.mismaClave = true; continue; }
+    const v = a.includes('=') ? a.slice(a.indexOf('=') + 1) : argv[++i];
+    if (a === '--home' || a.startsWith('--home=')) o.casa = v;
+    else if (a === '--port' || a.startsWith('--port=')) o.port = Number(v);
+    else if (a === '--host' || a.startsWith('--host=')) o.host = v;
+    else throw new Error('no entiendo ' + a);
+  }
+  return o;
+}
+
+const o = leerOrdenes(process.argv.slice(2));
+
+// R25 · `--acepto-lectura-total` ya no hace falta (y no hace nada): la lectura
+// va encerrada por el mismo cerco que en el MCP local. Se sigue aceptando para
+// no romper los comandos antiguos.
+
+const casa = resolverCasa(o.casa);
+const host = o.host ?? '127.0.0.1';
+const puerto = o.port;
+
+/** Dónde queda constancia de que el túnel está ABIERTO: `<casa>\mcp\tunel-url.txt`.
+ *  Lo lee Ajustes > Conexiones (la piel, ruta /ratacode/conexion) para decir si el
+ *  túnel está abierto y enseñar la URL pública. Se borra al cerrar el túnel, así
+ *  que su presencia es señal de que hay alguien exponiendo el puerto. */
+const RUTA_TUNEL_ABIERTO = join(casa, 'mcp', 'tunel-url.txt');
+/** La de la vez anterior no vale: hasta que cloudflared no dé la URL, no hay túnel. */
+try { rmSync(RUTA_TUNEL_ABIERTO, { force: true }); } catch { /* no había nada */ }
+
+/** El origen y la clave del MCP, tal como los dejó `ratacode mcp --http`. */
+function urlLocal() {
+  const rutaUrl = join(casa, 'mcp', 'http-url.txt');
+  let deFichero = null;
+  if (existsSync(rutaUrl)) {
+    const u = readFileSync(rutaUrl, 'utf8').trim();
+    if (u.startsWith('http') && u.includes('/mcp/')) deFichero = u;
+  }
+  if (deFichero === null) {
+    const rutaClave = join(casa, 'mcp', 'http-secret.txt');
+    if (!existsSync(rutaClave)) {
+      throw new Error('no encuentro la clave del MCP en ' + rutaClave + '. Arranca primero: ratacode mcp --http --port ' + puerto + ' --home ' + casa);
+    }
+    const leida = readFileSync(rutaClave, 'utf8').trim();
+    return { origen: 'http://' + host + ':' + puerto, clave: leida };
+  }
+  const corte = deFichero.indexOf('/mcp/');
+  return { origen: deFichero.slice(0, corte), clave: deFichero.slice(corte + '/mcp/'.length) };
+}
+
+let { origen, clave } = urlLocal();
+
+// CLAVE NUEVA AL ABRIR EL TÚNEL (esto es lo que se expone a Internet). El
+// servidor que ya está en marcha la adopta solo (mira `lib/http.js`): relee
+// `<casa>\mcp\http-secret.txt` cada dos segundos. Con `--misma-clave` se
+// reutiliza la que había (útil si el cliente ya la tiene pegada).
+if (o.mismaClave !== true) {
+  const nueva = randomBytes(32).toString('hex');
+  escribirSoloDueno(join(casa, 'mcp', 'http-secret.txt'), nueva + '\n');
+  clave = nueva;
+  console.log('Clave NUEVA para esta sesión del túnel (la anterior ya no vale).');
+} else {
+  console.log('Reutilizando la clave que ya había (--misma-clave).');
+}
+escribirSoloDueno(join(casa, 'mcp', 'http-url.txt'), origen + '/mcp/' + clave + '\n');
+
+console.log('URL local del MCP: ' + origen + '/mcp/<oculta> (la clave está en ' + join(casa, 'mcp', 'http-url.txt') + ')');
+
+// 1) ¿Está cloudflared?
+const donde = spawnSync('where', ['cloudflared'], { encoding: 'utf8' });
+if (donde.status !== 0) {
+  console.log('\n✋ cloudflared NO está instalado en este equipo.');
+  console.log('   Instálalo (Windows): winget install Cloudflare.cloudflared');
+  console.log('   o descárgalo de https://github.com/cloudflare/cloudflared/releases');
+  console.log('   Luego vuelve a ejecutar este script.');
+  process.exit(2);
+}
+console.log('cloudflared encontrado: ' + donde.stdout.trim().split('\n')[0]);
+
+// 2) ¿Existe el túnel nombrado del usuario?
+let modo = 'quick';
+let args;
+const lista = spawnSync('cloudflared', ['tunnel', 'list'], { encoding: 'utf8' });
+if (lista.status === 0 && lista.stdout.includes(TUNEL_NOMBRADO)) {
+  modo = 'nombrado';
+  // Un túnel nombrado necesita una regla de entrada (hostname → servicio) y su
+  // credencial; se pasa por FICHERO de configuración, no por argumentos (los
+  // argumentos de cualquier proceso los ve cualquier proceso local).
+  const rutaConfig = join(casa, 'mcp', 'cloudflared.yml');
+  mkdirSync(join(casa, 'mcp'), { recursive: true });
+  writeFileSync(rutaConfig, [
+    '# RATACODE · config del túnel nombrado. Lo escribe mcp/tunel.mjs.',
+    'tunnel: ' + TUNEL_NOMBRADO,
+    'ingress:',
+    '  - hostname: ' + TUNEL_NOMBRADO,
+    '    service: ' + origen,
+    '  - service: http_status:404',
+    '',
+  ].join('\n'), { mode: 0o600 });
+  args = ['tunnel', '--config', rutaConfig, 'run', TUNEL_NOMBRADO];
+  console.log('\nUsando túnel nombrado fijo: ' + TUNEL_NOMBRADO + ' (config: ' + rutaConfig + ')');
+} else {
+  modo = 'quick';
+  // A cloudflared se le pasa SÓLO el origen (sin la clave): el prefijo /mcp/<clave>
+  // viaja en la URL pública que se imprime abajo, no en los argumentos.
+  args = ['tunnel', '--url', origen];
+  console.log('\nNo hay túnel nombrado configurado; usando quick tunnel (URL efímera).');
+}
+
+console.log('\nArrancando cloudflared ' + (modo === 'nombrado' ? '(hostname fijo ' + TUNEL_NOMBRADO + ')' : '(quick tunnel)') + '...');
+console.log('En cuanto dé la URL pública, aquí abajo saldrá COMPLETA (dominio + /mcp/<clave>).\n');
+
+/**
+ * De la salida de cloudflared, la URL pública que sirve. El quick tunnel la
+ * escribe como `https://<algo>.trycloudflare.com`; el nombrado es el hostname.
+ */
+function dominioPublico(trozo) {
+  const m = /https:\/\/[a-z0-9-]+\.trycloudflare\.com/i.exec(trozo);
+  if (m !== null) return m[0];
+  if (modo === 'nombrado' && trozo.includes(TUNEL_NOMBRADO)) return 'https://' + TUNEL_NOMBRADO;
+  return null;
+}
+
+// 3) Arrancar cloudflared y dejarlo vivo; Ctrl+C para parar.
+// La salida va por tubería (no heredada) para poder CAZAR el dominio público y
+// enseñar la URL completa; se reenvía tal cual a la consola.
+let visto = '';
+let anunciada = false;
+const proc = spawn('cloudflared', args, { stdio: ['ignore', 'pipe', 'pipe'], windowsHide: false });
+const mirar = (trozo, destino) => {
+  destino.write(trozo);
+  if (anunciada) return;
+  visto = (visto + trozo).slice(-16384);
+  const dominio = dominioPublico(visto);
+  if (dominio === null) return;
+  anunciada = true;
+  // La URL pública COMPLETA (dominio + /mcp/<clave>) queda en la casa, para que
+  // Ajustes > Conexiones pueda decir «conectado» y enseñarla sin que nadie
+  // tenga que copiarla de la consola. Sólo-dueño, y se borra al cerrar.
+  try { escribirSoloDueno(RUTA_TUNEL_ABIERTO, dominio + '/mcp/' + clave + '\n'); } catch { /* la casa manda, pero no es imprescindible */ }
+  process.stdout.write('\n============================================================\n');
+  process.stdout.write('URL PÚBLICA DEL MCP (pégala en ChatGPT, modo desarrollador):\n');
+  process.stdout.write('  ' + dominio + '/mcp/' + clave + '\n');
+  process.stdout.write('============================================================\n\n');
+};
+proc.stdout.setEncoding('utf8');
+proc.stdout.on('data', (t) => mirar(t, process.stdout));
+proc.stderr.setEncoding('utf8');
+proc.stderr.on('data', (t) => mirar(t, process.stderr));
+proc.on('exit', (code) => {
+  try { rmSync(RUTA_TUNEL_ABIERTO, { force: true }); } catch { /* da igual */ }
+  console.log('\ncloudflared terminó (código ' + code + '). El túnel está cerrado; el puerto ya no se expone.');
+  process.exit(code ?? 0);
+});
+process.on('SIGINT', () => { proc.kill('SIGINT'); });
+process.on('SIGTERM', () => { proc.kill('SIGTERM'); });