xonecode 0.9.0 → 0.11.0

package/dist/web/servidor/arranque.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";
@@ -163,6 +170,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. */
@@ -2744,6 +2766,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 +3430,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 +3464,67 @@ 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);
+    });
     /**
      * `POST /adjunto?tarea=<id>&nombre=<fichero>` — los BYTES de un adjunto de tarea.
      *
@@ -3576,6 +3745,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" &&
@@ -4708,6 +4898,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,