xonecode 0.9.0 → 0.12.0

package/dist/web/servidor/arranque.js

@@ -66,7 +66,7 @@ import { borrarProveedorPersonalizado, guardarProveedorPersonalizado, proveedore
 import { crearCheckpointerDeProyecto, mantenimientoDelCheckpointer, } from "../../agent/sesiones/checkpointer.js";
 import { resumenDePoda } from "../../core/podaDeCheckpoint.js";
 import { cargarSettings, guardarConcurrenciaDeTareas, guardarWorkspace as guardarWorkspaceEnDisco, guardarDispositivos, guardarEntorno as guardarEntornoEnDisco, olvidarEntornoDeSettings, copiasDeEntorno, borrarCopiasDeEntorno, } from "../../agent/config/settingsEnDisco.js";
-import { dentroDelWorkspace, expandirConCasa, motivoParaNoOlvidarEntorno, motivoDeWorkspaceInaceptable, } from "../../core/settings.js";
+import { dentroDelWorkspace, expandirConCasa, motivoParaNoOlvidarEntorno, motivoDeNombreDeEntornoInaceptable, motivoDeWorkspaceInaceptable, } from "../../core/settings.js";
 import { esModoDeEscritura, MODO_POR_OMISION, } from "../../core/modoDeEscritura.js";
 import { mudarWorkspaceLegado } from "../../agent/config/mudanzaEnDisco.js";
 import { elegirCarpetaEnMaquina, haySelectorDeCarpeta } from "../../agent/config/selectorEnMaquina.js";
@@ -77,7 +77,14 @@ import { cambiosDeSesion, fotoDeApertura, olvidarSesion, parcheDeSesion } from "
 import { commitDeTurno, cambiosPendientes, trabajoSinCommitear } from "../../agent/sesiones/gitSync.js";
 import { marcarTareaDeSesion, sembrarConsumosPendientes } from "./sesiones.js";
 import { RUTA_ARTEFACTOS, esRutaDeArtefacto } from "../../core/artefactos.js";
-import { arbolDeProyecto, leerFicheroDeProyecto, motivoDeRutaInaceptable, } from "../../agent/grafo/arbolDeProyecto.js";
+import { arbolDeProyecto, leerFicheroDeProyecto, mimeDeImagen, motivoDeRutaInaceptable, } from "../../agent/grafo/arbolDeProyecto.js";
+import { modeloEnDisco } from "../../agent/navegacion/indiceEnDisco.js";
+import { ficherosDelProyecto } from "../../agent/turno/ficherosDelProyecto.js";
+import { fotoDeColecciones } from "../../core/fotoDeColecciones.js";
+import { modeloDelCambio } from "../../agent/sesiones/modeloDelCambio.js";
+import { planesDelProyecto } from "../../agent/planesEnDisco.js";
+import { CSP_DE_OPENUI, documentoDeOpenui, esArtefactoOpenui } from "./visorOpenui.js";
+import { RUTA_IMAGEN_DEL_PROYECTO } from "../../core/imagenesDeDocumento.js";
 import { leerArtefactoCrudo, leerArtefactoDeSesion, } from "../../agent/grafo/artefactosEnDisco.js";
 import { CatalogoModelos, baseUrlDeOllama, baseUrlDeOllamaCloud, capacidadesDeOllama, } from "../../agent/config/catalogoModelos.js";
 import { Modelos } from "../../agent/config/modelos.js";
@@ -99,6 +106,8 @@ import { baseDeWorkspaceLegada, baseDeWorkspacePorOmision, conexionDeVestibulo,
 // doblan.
 import { filaDeTarea } from "./transporte.js";
 import { esEsfuerzo, nivelesDeEsfuerzo } from "../../core/esfuerzo.js";
+import { definicionDelCable, RUTA_CALLBACK_MCP } from "../../core/conectores.js";
+import { servicioDeConectoresCableado } from "../../agent/conectores/servicioDeConectores.js";
 /** Las dos rutas del cable. El cliente las tiene escritas en `apps/web/src/conexion.ts`. */
 /**
  * Cuánto se espera al aviso de «lo que ya había sin commitear» antes de anunciar sin él.
@@ -163,6 +172,21 @@ export const MS_ENTRE_PROGRESOS = 250;
 export function raizDelClientePorOmision() {
     return join(dirname(fileURLToPath(import.meta.url)), "..", "..", "..", "apps", "web", "dist");
 }
+/**
+ * El visor de OpenUI del build del cliente, o `undefined` si no está. Se lee en cada petición, como
+ * el resto del cliente: reconstruirlo se ve recargando, sin reiniciar el servidor.
+ */
+export function leerVisorOpenui(raizDelCliente) {
+    try {
+        return {
+            js: readFileSync(join(raizDelCliente, "openui", "visor.js"), "utf8"),
+            css: readFileSync(join(raizDelCliente, "openui", "visor.css"), "utf8"),
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
 export const FALTA_EL_BUILD = "falta el build del cliente: ejecuta «npm run build:web»";
 /** Tope del cuerpo de `POST /accion`. Generoso para una prosa larga, finito porque el
  *  cuerpo se acumula en memoria y un cliente roto no puede llenarla. */
@@ -175,6 +199,14 @@ function tipoServido(mime) {
         ? `${mime}; charset=utf-8`
         : mime;
 }
+/**
+ * Las cinco entidades de HTML, para la página del callback OAuth de un conector. El
+ * `mensaje` que escapa es siempre una frase NUESTRA (`ServicioDeConectores.completar`), pero
+ * se escapa igual: defensa en profundidad, no confianza en el origen.
+ */
+function escaparHtml(texto) {
+    return texto.replace(/[&<>"']/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[c]);
+}
 /**
  * Monta `/eventos` y `/accion` sobre un servidor ya levantado.
  *
@@ -944,6 +976,9 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
         // El workspace, por lo mismo que los subagentes y las skills: Ajustes se puede abrir en
         // cuanto conecta, y un campo en blanco se lee como «no hay ninguno puesto».
         const workspace = mensajeDeWorkspace();
+        // Y los conectores MCP, tras el workspace y por la misma regla: solo si esta ejecución
+        // los monta, y entonces la ventana de Ajustes no se abre con la sección en blanco.
+        const conectores = mensajeDeConectores();
         /**
          * Lo consumido por la sesión que se va a pintar. Va en la ráfaga por lo mismo que los
          * modelos: una pestaña que conecta a mitad de sesión no vio los cambios anteriores, y
@@ -963,6 +998,8 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
                 cliente(tareas);
             if (workspace !== undefined)
                 cliente(workspace);
+            if (conectores !== undefined)
+                cliente(conectores);
             if (consumoDeLaSesion !== undefined) {
                 cliente({
                     clase: "consumo",
@@ -1107,6 +1144,8 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
     });
     /** Los cuatro nombres conocidos y nada más: lo que llega por el cable no elige binario. */
     const esNombreDeHerramienta = (v) => v === "adb" || v === "emulator" || v === "xcrun" || v === "devicectl";
+    /** Las seis acciones conocidas sobre UN conector, y nada más: lo demás es un 400. */
+    const esAccionDeConector = (v) => v === "anadir" || v === "quitar" || v === "probar" || v === "autorizar" || v === "desconectar" || v === "crear";
     const mensajeDeWorkspace = () => {
         const ruta = opciones.workspace?.();
         if (ruta === undefined)
@@ -1122,6 +1161,76 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
         if (m !== undefined)
             emitir(m);
     };
+    /**
+     * El servicio de conectores, construido UNA VEZ al montar — no en cada mensaje, porque es
+     * quien guarda en memoria las pruebas y las autorizaciones pendientes (`servicioDeConectores.ts`).
+     * `alCambiar` es lo que hace que un cambio que ocurre en segundo plano (autorizar, probar)
+     * llegue por el cable sin que nadie lo pida — la misma costura que `emitirCambioDeTareas`.
+     * Ausente la OPCIÓN = esta ejecución no monta conectores.
+     */
+    const servicioConectores = opciones.conectores?.(() => emitirConectores());
+    const mensajeDeConectores = () => {
+        if (servicioConectores === undefined)
+            return undefined;
+        // El catálogo lo compone el SERVICIO y no se arma aquí: es `catálogo ∪ definiciones`, y una
+        // segunda composición en este fichero solo traería las filas de código — dejando sin nombre
+        // en pantalla a todo conector escrito a mano.
+        const { catalogo, conectores, desconocidos, ilegible, error } = servicioConectores.lista();
+        return {
+            clase: "conectores",
+            catalogo,
+            conectores,
+            desconocidos,
+            ...(ilegible ? { ilegible } : {}),
+            ...(error === undefined ? {} : { error }),
+        };
+    };
+    const emitirConectores = () => {
+        const m = mensajeDeConectores();
+        if (m !== undefined)
+            emitir(m);
+    };
+    /**
+     * Autoriza un conector POR DONDE ÉL PIDA: OAuth abre el navegador del sistema y `api-key` pide
+     * una clave por la consola. `ninguna` no se autoriza —por eso no llega a hacer nada— y un id
+     * que no resuelve tampoco.
+     *
+     * Es UNA función porque la usan DOS sitios —el «Conectar» de la fila y el encadenado de
+     * `crear`—: dos copias serían dos sitios donde el carril puede divergir del que dice la fila, y
+     * el carril lo contesta el SERVIDOR (`autenticacionDe`), nunca el cliente, que manda la
+     * intención («autoriza este id») y no por dónde. Así un conector escrito a mano con `api-key`
+     * no puede acabar abriendo un navegador por una pestaña que se equivocó: `autorizar` lo
+     * rechazaría, y esto ni lo intenta.
+     */
+    const autorizarConector = async (id) => {
+        if (servicioConectores === undefined)
+            return;
+        const autenticacion = servicioConectores.autenticacionDe(id);
+        if (autenticacion === "oauth") {
+            // El puerto REAL: con `--puerto 0` el sistema elige uno, y es el mismo que ya usa
+            // `servidor.url` para la ráfaga inicial — nunca uno construido a mano.
+            await servicioConectores.autorizar(id, `http://127.0.0.1:${servidor.puerto}${RUTA_CALLBACK_MCP}`);
+            return;
+        }
+        if (autenticacion !== "api-key")
+            return;
+        // La MISMA resolución de consola que `pedirCredencial`: la del proyecto si hay uno abierto y
+        // la del vestíbulo si no. La clave vuelve por `{clase: "secreto"}`, el único mensaje del
+        // cable que la lleva.
+        const consola = vestibulo.proyectoAbierto()?.consola.consola ?? vestibulo.consola.consola;
+        // La pregunta DICE que no hace falta el prefijo, y no es un adorno: la criba
+        // (`motivoDeClaveInaceptable`) rechaza cualquier valor con espacios —o sea justo el
+        // «Bearer abc» que suele ser lo que uno copia del servidor— y el `Bearer` lo pone
+        // `credencialDe` al componer la cabecera. Sin decirlo, el rechazo llega sin explicación.
+        const clave = (await consola.leerSecreto(`clave de ${id} (sin el «Bearer»): `)).trim();
+        // Cadena vacía es la consola sin nadie al otro lado y también el Enter a secas: en los dos
+        // casos no se guarda nada y no se dice nada más — quien canceló no necesita un sermón.
+        if (clave === "")
+            return;
+        // Una clave que no pasa la criba deja su motivo en `error`, que ya viaja por el cable: aquí
+        // no hay nada que informar por consola, que es donde `pedirCredencial` sí lo hace.
+        servicioConectores.guardarClave(id, clave);
+    };
     const mensajeDeTareas = () => {
         if (opciones.colaDeTareas === undefined)
             return undefined;
@@ -2744,6 +2853,73 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
             emitir({ clase: "arbol", rutas: [], recortado: false, error: "no se pudo listar el proyecto" });
         }
     };
+    /**
+     * El diff semántico de un `.xne` de Revisión. Siempre CONTESTA —la fila abierta espera, y un
+     * silencio la dejaría cargando para siempre—, y la ruta pasa por la MISMA barrera que la del
+     * lector de Ficheros antes de llegar a git.
+     */
+    const atenderModeloDelCambio = async (ruta) => {
+        const abierto = vestibulo.proyectoAbierto();
+        const sesion = abierto?.sesion;
+        const sinNada = (error) => emitir({ clase: "modeloDelCambio", ruta, error });
+        if (abierto === undefined || opciones.modeloDelCambio === undefined)
+            return sinNada("esta ejecución no sabe comparar el modelo");
+        if (sesion === undefined)
+            return sinNada("la sesión todavía no ha empezado");
+        if (motivoDeRutaInaceptable(ruta) !== undefined)
+            return sinNada("esa ruta no se enseña");
+        try {
+            const cambios = await opciones.modeloDelCambio(abierto.raiz, sesion, ruta);
+            if (cambios === undefined)
+                return sinNada("no hay con qué comparar");
+            emitir({ clase: "modeloDelCambio", ruta, cambios });
+        }
+        catch (error) {
+            informar(`no se pudo comparar el modelo (${codigoDe(error)})`);
+            sinNada("no se pudo comparar el modelo");
+        }
+    };
+    /**
+     * Los planes del proyecto abierto. Mismas reglas que el árbol: sin proyecto no se contesta,
+     * sin puerto se contesta con error, y el fallo viaja sin la ruta de la máquina.
+     */
+    const atenderPlanes = async () => {
+        const abierto = vestibulo.proyectoAbierto();
+        if (abierto === undefined)
+            return;
+        if (opciones.planesDelProyecto === undefined) {
+            emitir({ clase: "planes", error: "esta ejecución no puede leer los planes" });
+            return;
+        }
+        try {
+            emitir({ clase: "planes", planes: opciones.planesDelProyecto(abierto.raiz) });
+        }
+        catch (error) {
+            informar(`no se pudieron leer los planes (${codigoDe(error)})`);
+            emitir({ clase: "planes", error: "no se pudieron leer los planes" });
+        }
+    };
+    /**
+     * La foto del modelo XOne del proyecto abierto. Mismas reglas que el árbol: sin proyecto no
+     * se contesta, sin puerto se contesta con error —un «consultando…» eterno es un fallo mudo—,
+     * y el fallo viaja sin la ruta de la máquina.
+     */
+    const atenderColecciones = async () => {
+        const abierto = vestibulo.proyectoAbierto();
+        if (abierto === undefined)
+            return;
+        if (opciones.coleccionesDelProyecto === undefined) {
+            emitir({ clase: "colecciones", error: "esta ejecución no puede leer el modelo del proyecto" });
+            return;
+        }
+        try {
+            emitir({ clase: "colecciones", foto: await opciones.coleccionesDelProyecto(abierto.raiz) });
+        }
+        catch (error) {
+            informar(`no se pudo leer el modelo del proyecto (${codigoDe(error)})`);
+            emitir({ clase: "colecciones", error: "no se pudo leer el modelo del proyecto" });
+        }
+    };
     /**
      * El contenido de una ruta del proyecto abierto. El lector decide si se puede enseñar.
      *
@@ -3341,6 +3517,25 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
             return;
         }
         const descargar = query.get("descargar") !== null;
+        // Un programa de OpenUI se VE dentro de su visor, en un documento autocontenido y sin red
+        // (`visorOpenui.ts`). Descargarlo sigue dando el fichero tal cual.
+        if (!descargar && esArtefactoOpenui(leido.nombre)) {
+            const visor = opciones.visorOpenui?.();
+            if (visor === undefined) {
+                responder(503, "el visor de OpenUI no está construido: ejecuta «npm run build:web»");
+                return;
+            }
+            const documento = Buffer.from(documentoDeOpenui(leido.datos.toString("utf8"), visor, leido.nombre), "utf8");
+            respuesta.writeHead(200, {
+                "Content-Type": "text/html; charset=utf-8",
+                "Content-Length": documento.length,
+                "Content-Security-Policy": CSP_DE_OPENUI,
+                "X-Content-Type-Options": "nosniff",
+                "Cache-Control": "no-store",
+            });
+            respuesta.end(documento);
+            return;
+        }
         // Sin mime conocido se descarga en vez de adivinar. El nombre ya pasó la barrera de
         // segmento llano, así que entre comillas no puede romper la cabecera.
         const inline = !descargar && leido.mime !== undefined;
@@ -3356,6 +3551,106 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
         });
         respuesta.end(leido.datos);
     });
+    /**
+     * `GET /imagen-del-proyecto?ruta=<relativa>` — una IMAGEN del proyecto abierto, para que un `.md`
+     * de la pestaña Ficheros enseñe las suyas.
+     *
+     * Existe porque el visor de markdown solo pinta imágenes `http(s)` absolutas: un enlace relativo o
+     * una `data:` se quedaban en su texto alternativo. La vista del documento reescribe cada enlace a
+     * esta ruta (`arbolDeProyecto.ts#vistaDeMarkdown`), y aquí se sirve con la barrera de siempre:
+     *  - **Solo imágenes, por su extensión**, antes de leer nada: esto no es un lector de ficheros por
+     *    HTTP, y sin esa criba cualquier ruta que se enseñe se podría pedir por aquí.
+     *  - **Leída con `leerFichero`** —las dos barreras de la pestaña Ficheros, sobre el texto y sobre
+     *    el camino REAL, y su tope—, no con una copia de ellas.
+     *  - `Content-Security-Policy: sandbox`, `nosniff` y `no-store`: un `.svg` abierto a pelo en una
+     *    pestaña no ejecuta nada, el navegador no adivina el tipo, y una captura reescrita se ve nueva.
+     */
+    servidor.registrarRuta("GET", RUTA_IMAGEN_DEL_PROYECTO, async (peticion, respuesta) => {
+        const responder = (codigo, texto) => {
+            respuesta.writeHead(codigo, { "Content-Type": "text/plain; charset=utf-8" });
+            respuesta.end(texto);
+        };
+        const ruta = new URLSearchParams((peticion.url ?? "").split("?")[1] ?? "").get("ruta");
+        if (ruta === null || ruta === "") {
+            responder(400, "falta la ruta");
+            return;
+        }
+        if (mimeDeImagen(ruta) === undefined) {
+            responder(403, "eso no es una imagen");
+            return;
+        }
+        const abierto = vestibulo.proyectoAbierto();
+        if (abierto === undefined || opciones.leerFichero === undefined) {
+            responder(404, "no hay imagen");
+            return;
+        }
+        let leido;
+        try {
+            leido = await opciones.leerFichero(abierto.raiz, ruta);
+        }
+        catch (error) {
+            // Como en el resto: al cliente y a `informar` solo el código, nunca el mensaje de Node.
+            informar(`no se pudo servir la imagen «${ruta}» (${codigoDe(error)})`);
+            responder(500, "no se pudo leer");
+            return;
+        }
+        if (leido.error !== undefined) {
+            responder(leido.error === "no existe" ? 404 : 403, leido.error);
+            return;
+        }
+        if (leido.base64 === undefined || leido.mime === undefined) {
+            responder(413, "la imagen es demasiado grande");
+            return;
+        }
+        const datos = Buffer.from(leido.base64, "base64");
+        respuesta.writeHead(200, {
+            "Content-Type": leido.mime,
+            "Content-Length": datos.length,
+            "Content-Security-Policy": "sandbox",
+            "X-Content-Type-Options": "nosniff",
+            "Cache-Control": "no-store",
+        });
+        respuesta.end(datos);
+    });
+    /**
+     * `GET RUTA_CALLBACK_MCP` — a donde vuelve el navegador tras autorizar un conector.
+     *
+     * **Ruta PÚBLICA**, registrada con `registrarRutaPublica`: la cookie de sesión es
+     * `SameSite=Strict`, así que la redirección que manda el proveedor OAuth llega SIN ella —
+     * `Host` y `Origin` siguen delante, y la autenticación real es el `state` de un solo uso
+     * que `completar` consume (`core/conectores.ts#interpretarCallback`).
+     *
+     * Solo se registra si esta ejecución monta conectores (`servicioConectores` viene de la
+     * opción `conectores`): sin servicio no hay callback que atender.
+     *
+     * La página es MÍNIMA y NUESTRA — nunca repite la query cruda, que la escribe quien
+     * redirige — y va con `Content-Security-Policy: default-src 'none'; style-src
+     * 'unsafe-inline'` (sin red, sin script) y `Cache-Control: no-store` (no es un documento
+     * que se pueda volver a servir de caché: el `state` ya se consumió).
+     */
+    if (servicioConectores !== undefined) {
+        servidor.registrarRutaPublica("GET", RUTA_CALLBACK_MCP, async (peticion, respuesta) => {
+            const query = new URLSearchParams((peticion.url ?? "").split("?")[1] ?? "");
+            // `completar` no debería lanzar —sus propios fallos vuelven como `{ok:false}`—, pero
+            // esto es una ruta PÚBLICA sin cookie por delante: un reventón aquí no puede dejar al
+            // navegador con una petición colgada ni con un 500 sin nada que decir. Y tampoco puede
+            // desaparecer en silencio: `contar` es el mismo hueco por el que se avisa de cualquier
+            // otro fallo suelto de este cable (`probar`/`autorizar`, más abajo).
+            const { mensaje } = await servicioConectores.completar(query).catch((error) => {
+                contar(error);
+                return { ok: false, mensaje: "no se pudo completar la autorización: vuelve a pulsar Conectar" };
+            });
+            const cuerpo = `<!doctype html><html lang="es"><head><meta charset="utf-8">` +
+                `<title>xonecode</title></head><body><p>${escaparHtml(mensaje)}</p>` +
+                `<p>Ya puedes cerrar esta pestaña.</p></body></html>`;
+            respuesta.writeHead(200, {
+                "Content-Type": "text/html; charset=utf-8",
+                "Content-Security-Policy": "default-src 'none'; style-src 'unsafe-inline'",
+                "Cache-Control": "no-store",
+            });
+            respuesta.end(cuerpo);
+        });
+    }
     /**
      * `POST /adjunto?tarea=<id>&nombre=<fichero>` — los BYTES de un adjunto de tarea.
      *
@@ -3564,6 +3859,31 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
             respuesta.end();
             return;
         }
+        if (typeof mensaje === "object" &&
+            mensaje !== null &&
+            mensaje.clase === "entorno" &&
+            mensaje.accion === "renombrar") {
+            // Como `olvidar`: la negativa se decide AQUÍ y antes del 204, para que el motivo pueda
+            // ir en la respuesta — `informar` no llega al navegador desde el vestíbulo. Y el tipo
+            // se mira antes de la regla porque la regla es de cadenas: un `nombre` que no sea texto
+            // la haría reventar dentro del manejador, que es la única forma de que esta guarda no
+            // conteste nada.
+            const motivo = typeof mensaje.nombre === "string"
+                ? motivoDeNombreDeEntornoInaceptable(mensaje.nombre)
+                : "el nombre tiene que ser texto";
+            if (motivo !== undefined) {
+                respuesta.writeHead(409, { "content-type": "application/json" });
+                respuesta.end(JSON.stringify({ motivo }));
+                return;
+            }
+            void vestibulo
+                .renombrarEntorno(mensaje.entorno, mensaje.nombre)
+                .catch(contar)
+                .finally(() => void anunciarAlta().catch(contar));
+            respuesta.writeHead(204);
+            respuesta.end();
+            return;
+        }
         if (typeof mensaje === "object" && mensaje !== null && mensaje.clase === "revision") {
             void atenderRevision(mensaje.ruta).catch(contar);
             respuesta.writeHead(204);
@@ -3576,6 +3896,27 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
             respuesta.end();
             return;
         }
+        if (typeof mensaje === "object" &&
+            mensaje !== null &&
+            mensaje.clase === "modeloDelCambio" &&
+            typeof mensaje.ruta === "string") {
+            void atenderModeloDelCambio(mensaje.ruta).catch(contar);
+            respuesta.writeHead(204);
+            respuesta.end();
+            return;
+        }
+        if (typeof mensaje === "object" && mensaje !== null && mensaje.clase === "planes") {
+            void atenderPlanes().catch(contar);
+            respuesta.writeHead(204);
+            respuesta.end();
+            return;
+        }
+        if (typeof mensaje === "object" && mensaje !== null && mensaje.clase === "colecciones") {
+            void atenderColecciones().catch(contar);
+            respuesta.writeHead(204);
+            respuesta.end();
+            return;
+        }
         if (typeof mensaje === "object" &&
             mensaje !== null &&
             mensaje.clase === "sync" &&
@@ -3722,6 +4063,84 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
             respuesta.end();
             return;
         }
+        if (typeof mensaje === "object" && mensaje !== null && mensaje.clase === "conector") {
+            // Sin `as`: `mensaje.clase === "conector"` ya narrows a la forma de `MensajeDelCliente`
+            // —la misma unión discriminada que `workspace` usa un renglón más arriba—, así que
+            // `mensaje.accion` se lee directo. El `typeof` que sigue no es para el tipo (ese ya lo
+            // sabe TypeScript): es la guarda de verdad contra un JSON malformado, que puede mentir
+            // sobre lo que el tipo promete.
+            if (servicioConectores === undefined ||
+                typeof mensaje.accion !== "string" ||
+                !esAccionDeConector(mensaje.accion)) {
+                respuesta.writeHead(400);
+                respuesta.end();
+                return;
+            }
+            /**
+             * `crear` va ANTES y se lleva su propia guarda: es la única acción que NO trae `id` —lo
+             * DERIVA el servidor del nombre, que es lo que impide que el cliente elija el nombre de un
+             * fichero— y la única cuyo cuerpo hay que comprobar por FORMA antes de mirarlo de verdad.
+             */
+            if (mensaje.accion === "crear") {
+                const def = definicionDelCable(mensaje.definicion);
+                // Un cuerpo sin la forma no es una definición inaceptable —esa se RECHAZA con su motivo,
+                // y el motivo viaja en `error`—: es un mensaje malformado, y por eso es 400 y no 204.
+                if (def === undefined) {
+                    respuesta.writeHead(400);
+                    respuesta.end();
+                    return;
+                }
+                // El servicio valida lo que tiene que valer (nombre, URL, slug libre) y su motivo sale en
+                // `error`, que ya viaja.
+                const id = servicioConectores.crear(def);
+                // El encadenado es del SERVIDOR y va DESPUÉS de la escritura: pedir una clave —o abrir el
+                // navegador— por un conector que no llegó a estar añadido no llevaría a ninguna parte. Y
+                // sin `await`: esta respuesta sale en el acto y el resultado llega por `alCambiar`, igual
+                // que en `probar` — con `await`, este POST se quedaría colgado hasta que alguien teclee.
+                if (id !== undefined && def.autenticacion !== "ninguna")
+                    void autorizarConector(id).catch(contar);
+                respuesta.writeHead(204);
+                respuesta.end();
+                return;
+            }
+            // Las otras CINCO sí traen id, y ahí el `typeof` es la guarda contra el JSON que miente.
+            if (typeof mensaje.id !== "string") {
+                respuesta.writeHead(400);
+                respuesta.end();
+                return;
+            }
+            const { id, accion } = mensaje;
+            /**
+             * Las cinco contestan 204 EN EL ACTO. `anadir`/`quitar`/`desconectar` son síncronas —su
+             * `cambio()` ya reemite `conectores` antes de que esta función devuelva—; `probar` y
+             * `autorizar` corren en segundo plano (red, o esperar al navegador que abre el sistema)
+             * con `.catch(contar)`, la misma disciplina que `conexion` y `dispositivos`. El
+             * resultado de las cinco llega por `emitir(mensajeDeConectores())` vía `alCambiar`,
+             * nunca en esta respuesta.
+             */
+            switch (accion) {
+                case "anadir":
+                    servicioConectores.anadir(id);
+                    break;
+                case "quitar":
+                    servicioConectores.quitar(id);
+                    break;
+                case "desconectar":
+                    servicioConectores.desconectar(id);
+                    break;
+                case "probar":
+                    void servicioConectores.probar(id).catch(contar);
+                    break;
+                case "autorizar":
+                    // Por dónde se autoriza lo decide el SERVIDOR —OAuth abre el navegador, `api-key` pide
+                    // la clave—, así que este `case` no sabe ni de carriles ni de puertos.
+                    void autorizarConector(id).catch(contar);
+                    break;
+            }
+            respuesta.writeHead(204);
+            respuesta.end();
+            return;
+        }
         if (typeof mensaje === "object" && mensaje !== null && mensaje.clase === "modelosDeMotor" && typeof mensaje.motor === "string") {
             void atenderModelosDeMotor(mensaje.motor).catch(contar);
             respuesta.writeHead(204);
@@ -4352,6 +4771,21 @@ export function ajusteDeWorkspaceCableado(opciones) {
         },
     };
 }
+/**
+ * La opción `conectores` de `montarRutas`, cableada — extraída por el MISMO motivo que
+ * `ajusteDeWorkspaceCableado`: un literal inline dentro de `arrancarConsolaWeb` no quedaría
+ * probado, y esa composición concreta —que la fábrica de verdad (`servicioDeConectoresCableado`)
+ * llega montada, y con la CASA correcta— es exactamente el patrón de fallo que este repo ya
+ * tiene documentado nueve veces.
+ *
+ * Es una función de una línea, pero la línea es la que puede caerse: sin este sitio propio,
+ * `arrancarConsolaWeb` seguiría compilando y pasando sus tests aunque alguien borrara la
+ * opción del objeto que le pasa a `montarRutas` — el mismo campo OPCIONAL que hace que
+ * `ConsolaDeProyecto.consumo` fuera la novena vez.
+ */
+export function ajusteDeConectoresCableado(opciones) {
+    return { conectores: (alCambiar) => servicioDeConectoresCableado({ casa: opciones.casa, alCambiar }) };
+}
 export function construirCorredorDeTareasCableado(opciones) {
     const disco = opciones.tareasFabrica === undefined ? undefined : opciones.tareasFabrica(opciones.informar);
     /**
@@ -4666,6 +5100,9 @@ export async function arrancarConsolaWeb(opciones) {
         // (`ajusteDeWorkspaceCableado`) por el patrón de fallo de siempre — y aquí el escritor
         // ya venía con la marca puesta: existía con su test y sin un solo llamador.
         ...ajusteDeWorkspaceCableado({ casa: homedir() }),
+        // Los conectores MCP, con la MISMA disciplina: la composición extraída y probada
+        // (`ajusteDeConectoresCableado`), nunca un literal aquí dentro.
+        ...ajusteDeConectoresCableado({ casa: homedir() }),
         // El selector nativo, solo si este sistema tiene uno. En el que no, la opción no se
         // monta y el botón no llega a existir.
         ...(haySelectorDeCarpeta()
@@ -4708,6 +5145,12 @@ export async function arrancarConsolaWeb(opciones) {
         // El proyecto tal como lo ve el agente, para la pestaña Ficheros: mismo filtro, misma
         // barrera de rutas (`agent/grafo/arbolDeProyecto.ts`).
         arbolDelProyecto: async (raiz) => arbolDeProyecto(raiz),
+        // El modelo XOne con el MISMO cargador y el mismo conjunto de ficheros que la tool, para
+        // que la pestaña y el agente no contesten distinto sobre el mismo proyecto.
+        coleccionesDelProyecto: async (raiz) => fotoDeColecciones(await modeloEnDisco(raiz)(ficherosDelProyecto(raiz))),
+        modeloDelCambio,
+        planesDelProyecto,
+        visorOpenui: () => leerVisorOpenui(raizDelCliente),
         leerFichero: leerFicheroDeProyecto,
         leerArtefacto: leerArtefactoDeSesion,
         leerArtefactoCrudo,