xonecode 0.11.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";
@@ -106,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.
@@ -197,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.
  *
@@ -966,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
@@ -985,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",
@@ -1129,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)
@@ -1144,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;
@@ -3525,6 +3612,45 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
         });
         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.
      *
@@ -3733,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);
@@ -3912,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);
@@ -4542,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);
     /**
@@ -4856,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()