xonecode 0.23.0 → 0.26.0

package/dist/web/servidor/arranque.js

@@ -75,17 +75,18 @@ import { cloudstudioDelProyecto, guardarModoDeEscrituraDeProyecto, modoDeEscritu
 import { abrirEnSistema, olvidarEntorno as olvidarCredencialesDeEntorno, rutaAuthPorDefecto } from "../../agent/cloudstudio/cloudstudioMcp.js";
 import { nombreDePersona } from "../../agent/config/persona.js";
 import { cambiosDeSesion, fotoDeApertura, olvidarSesion, parcheDeSesion } from "../../agent/sesiones/sesionGit.js";
-import { commitDeTurno, cambiosPendientes, trabajoSinCommitear } from "../../agent/sesiones/gitSync.js";
+import { commitDeTurno, cambiosPendientes, parcheDeSubida, pendientesDeSubida, sinSeguir, trabajoSinCommitear, } from "../../agent/sesiones/gitSync.js";
 import { marcarTareaDeSesion, sembrarConsumosPendientes } from "./sesiones.js";
 import { RUTA_ARTEFACTOS, esRutaDeArtefacto } from "../../core/artefactos.js";
-import { arbolDeProyecto, leerFicheroDeProyecto, mimeDeImagen, motivoDeRutaInaceptable, } from "../../agent/grafo/arbolDeProyecto.js";
+import { arbolDeProyecto, escribirFicheroDeProyecto, iconoDelProyecto, leerFicheroDeProyecto, mimeDeImagen, motivoDeRutaInaceptable, motivoParaNoEnsenar, } from "../../agent/grafo/arbolDeProyecto.js";
+import { baseDeFichero } from "../../agent/sesiones/baseDeFichero.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, temaDeVisor } from "./visorOpenui.js";
-import { RUTA_IMAGEN_DEL_PROYECTO } from "../../core/imagenesDeDocumento.js";
+import { RUTA_ICONO_DEL_PROYECTO, 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";
@@ -452,6 +453,31 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
                 clearTimeout(reloj);
         }
     };
+    /**
+     * CUÁL es el proyecto abierto, deducido de su raíz: la que le tocaría a cada proyecto de la
+     * lista se calcula con la misma función que la creó. Guardar el id aparte al abrirlo sería una
+     * segunda fuente de verdad que se queda vieja el día que alguien abra por otro camino.
+     *
+     * Lo usan el alta (`proyectoActivo`) y el guardado del editor, que compara con él el proyecto
+     * con que se ABRIÓ la edición: tiene que ser la MISMA cuenta, o el editor y el servidor
+     * podrían no estar de acuerdo sobre cuál es «el abierto».
+     *
+     * El `entorno` se copia a una constante porque TypeScript no puede saber que `entornoElegido`
+     * —una variable del cierre, que otro mensaje puede cambiar— sigue definida dentro del callback.
+     */
+    const proyectoActivoDe = (abierto) => {
+        const entorno = entornoElegido;
+        if (abierto === undefined || entorno === undefined)
+            return undefined;
+        return proyectos.find((p) => {
+            try {
+                return vestibulo.raizDeProyecto(entorno, p.nombre) === abierto.raiz;
+            }
+            catch {
+                return false;
+            }
+        })?.id;
+    };
     /**
      * El mensaje de alta: qué falta, y con qué elegirlo.
      *
@@ -481,24 +507,11 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
         // puede escribirlo después de abrir (el alta de un proyecto cloud), y una copia
         // tomada antes se quedaría diciendo lo de antes.
         const modo = abierto === undefined ? undefined : modoDeProyecto(abierto.raiz);
-        // CUÁL es el abierto, deducido de su raíz: la que le tocaría a cada proyecto de la
-        // lista se calcula con la misma función que la creó. Guardar el id aparte al abrirlo
-        // sería una segunda fuente de verdad que se queda vieja el día que alguien abra por
-        // otro camino.
-        // El `entorno` se copia a una constante porque TypeScript no puede saber que
-        // `entornoElegido` —una variable del cierre, que otro mensaje puede cambiar— sigue
-        // definida dentro del callback.
+        // CUÁL es el abierto, deducido de su raíz (`proyectoActivoDe`). El `entorno` se copia a una
+        // constante porque `entornoElegido` es una variable del cierre que otro mensaje puede cambiar,
+        // y TypeScript no sabría que sigue definida dentro de los callbacks de abajo.
         const entorno = entornoElegido;
-        const activo = abierto === undefined || entorno === undefined
-            ? undefined
-            : proyectos.find((p) => {
-                try {
-                    return vestibulo.raizDeProyecto(entorno, p.nombre) === abierto.raiz;
-                }
-                catch {
-                    return false;
-                }
-            })?.id;
+        const activo = proyectoActivoDe(abierto);
         const pendientes = proyectoAbierto ? [] : await vestibulo.pasosPendientes();
         // Lo que ya había sin commitear al ABRIR. `abierto` se capturó arriba, antes de este
         // `await`: `anunciarAlta` no va en la cola del vestíbulo, así que entre medias puede
@@ -534,6 +547,22 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
                 return undefined;
             }
         };
+        /**
+         * Qué proyectos BAJADOS tienen icono de app, una vez por anuncio y antes de componerlo (la
+         * lista se compone síncrona). Por el cable solo viaja el booleano: qué fichero es lo vuelve a
+         * decidir `RUTA_ICONO_DEL_PROYECTO` al servirlo, y ninguna ruta sale del host.
+         */
+        const conIcono = new Set();
+        const buscarIcono = opciones.iconoDelProyecto;
+        if (buscarIcono !== undefined) {
+            await Promise.all(proyectos.map(async (p) => {
+                if (!hayCopiaLocal(p.nombre))
+                    return;
+                const raiz = raizDeProyectoOSilencio(p.nombre);
+                if (raiz !== undefined && (await buscarIcono(raiz).catch(() => undefined)) !== undefined)
+                    conIcono.add(p.id);
+            }));
+        }
         emitir({
             clase: "alta",
             pasos,
@@ -593,6 +622,8 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
                         const rama = raiz === undefined ? undefined : cloudstudioDelProyecto(raiz)?.rama;
                         return typeof rama === "string" && rama !== "" ? { rama } : {};
                     })(),
+                    // El icono de la app, solo si la copia tiene uno que se pueda enseñar (ver `conIcono`).
+                    ...(conIcono.has(p.id) ? { icono: true } : {}),
                 };
             }),
             ramas,
@@ -2775,7 +2806,23 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
             return;
         }
         const { via, ficheros, mezclados } = await opciones.cambiosDeSesion(abierto.raiz, sesion);
-        emitir({ clase: "revision", via, ficheros, ...(mezclados === undefined ? {} : { mezclados }) });
+        // Lo pendiente de subir se marca AQUÍ, en la misma foto que la lista: cruzarlo en el
+        // cliente con el `sync` —que llega en otro momento— escondería lo recién escrito.
+        const marcados = await marcarPendientes(abierto.raiz, ficheros);
+        emitir({ clase: "revision", via, ficheros: marcados, ...(mezclados === undefined ? {} : { mezclados }) });
+    };
+    /**
+     * Lo pendiente de subir del proyecto ABIERTO —el mismo que sincroniza `atenderSync`—: la
+     * lista sin `ruta`, el diff de uno con ella. Las reglas viven en `lecturaDePendientesDeSubida`
+     * y `lecturaDeParcheDeSubida`, exportadas y probadas contra git de verdad.
+     */
+    const atenderPendientesDeSubida = async (ruta) => {
+        const abierto = vestibulo.proyectoAbierto();
+        if (abierto === undefined) {
+            emitir({ clase: "pendientesDeSubida", error: "no hay ningún proyecto abierto" });
+            return;
+        }
+        emitir(ruta === undefined ? await lecturaDePendientesDeSubida(abierto.raiz) : await lecturaDeParcheDeSubida(abierto.raiz, ruta));
     };
     /**
      * La sincronización con CloudStudio del proyecto abierto, pedida desde un control
@@ -3758,6 +3805,74 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
             });
         }
     };
+    /**
+     * Guardar lo que la persona editó. Tres cosas antes de tocar el disco, y cada una contesta en
+     * vez de callar —el editor tiene un «Guardando…» encendido esperando—:
+     *  - que haya proyecto abierto y puerto que escriba;
+     *  - que nadie trabaje en esa RAÍZ (`vestibulo.motivoParaNoEditar`): un turno o una tarea que
+     *    escribe en la misma copia pisaría, o sería pisado, sin avisar;
+     *  - lo demás —guardas de ruta, huella, tope— lo decide el puerto y lo DEVUELVE.
+     * El `try` es el de `atenderFichero`: un fallo inesperado contesta sin la ruta de la máquina.
+     */
+    const atenderGuardarFichero = async (ruta, texto, huella, id, proyecto) => {
+        const abierto = vestibulo.proyectoAbierto();
+        if (abierto === undefined) {
+            emitir({ clase: "ficheroGuardado", ruta, id, error: "no hay ningún proyecto abierto" });
+            return;
+        }
+        // El guardado va al proyecto del FOCO, que puede haber cambiado desde que se abrió la edición
+        // (otra pestaña abre otro, se cambia de entorno). La huella no lo frena si el contenido es
+        // idéntico —el mismo proyecto en dos entornos, dos proyectos del mismo esqueleto—, así que se
+        // compara el proyecto con que se abrió con el de ahora, con la MISMA cuenta que el alta. Si no
+        // se puede deducir, tampoco se escribe: no se sabe dónde caería.
+        if (proyectoActivoDe(abierto) !== proyecto) {
+            emitir({ clase: "ficheroGuardado", ruta, id, error: "el proyecto abierto ya no es el de este fichero: vuelve a abrirlo" });
+            return;
+        }
+        if (opciones.escribirFichero === undefined) {
+            emitir({ clase: "ficheroGuardado", ruta, id, error: "esta ejecución no puede escribir en el proyecto" });
+            return;
+        }
+        const ocupado = vestibulo.motivoParaNoEditar(abierto.raiz);
+        if (ocupado !== undefined) {
+            emitir({ clase: "ficheroGuardado", ruta, id, error: ocupado });
+            return;
+        }
+        try {
+            // `id` lo pone la pestaña en CADA guardado y vuelve en la respuesta: esta va a todas las
+            // pestañas, y cada una reconoce la suya por él. La huella no vale —dos pestañas que parten de
+            // la misma versión mandan la misma—.
+            emitir({ clase: "ficheroGuardado", ...(await opciones.escribirFichero(abierto.raiz, ruta, texto, huella)), id });
+        }
+        catch (error) {
+            informar(`no se pudo guardar «${ruta}» (${codigoDe(error)})`);
+            emitir({ clase: "ficheroGuardado", ruta, id, error: "no se pudo guardar el fichero" });
+        }
+    };
+    /**
+     * La base de las marcas del editor. Con la sesión ABIERTA (`abierto.sesion`, la misma que mira
+     * Revisión): su ref es la foto del inicio. Sin puerto se contesta `sinBase` —el editor funciona
+     * igual, sin marcas, y lo dice— en vez de dejar la barra en «Trayendo la base…».
+     */
+    const atenderBaseDeFichero = async (ruta, base) => {
+        const abierto = vestibulo.proyectoAbierto();
+        if (abierto === undefined) {
+            // Contesta igual: callar dejaría la barra del editor en «Trayendo la base…».
+            emitir({ clase: "baseDeFichero", ruta, base, sinBase: "no hay ningún proyecto abierto" });
+            return;
+        }
+        if (opciones.baseDeFichero === undefined) {
+            emitir({ clase: "baseDeFichero", ruta, base, sinBase: "esta ejecución no puede leer git" });
+            return;
+        }
+        try {
+            emitir({ clase: "baseDeFichero", ...(await opciones.baseDeFichero(abierto.raiz, abierto.sesion, ruta, base)) });
+        }
+        catch (error) {
+            informar(`no se pudo leer la base de «${ruta}» (${codigoDe(error)})`);
+            emitir({ clase: "baseDeFichero", ruta, base, sinBase: "no se pudo leer la base" });
+        }
+    };
     /**
      * El contenido de un ARTEFACTO de la sesión abierta, por su nombre.
      *
@@ -4645,6 +4760,63 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
         });
         respuesta.end(datos);
     });
+    /**
+     * `GET RUTA_ICONO_DEL_PROYECTO?id=<id>` — el icono de la app de un proyecto BAJADO, para su fila
+     * de la barra y la cabecera de su panel.
+     *
+     * Del cable llega el ID, nunca una ruta: el nombre sale del listado del SERVIDOR (como al borrar
+     * la copia local), la raíz de `vestibulo.raizDeProyecto`, y el fichero lo decide `app.ini` con la
+     * barrera de Ficheros (`iconoDelProyecto`). Se lee luego con `leerFichero`, que la vuelve a
+     * aplicar. A diferencia de `RUTA_IMAGEN_DEL_PROYECTO`, vale para cualquier copia, no solo la
+     * abierta: la barra enseña todas. Mismas cabeceras de seguridad (un `.svg` no ejecuta nada).
+     */
+    servidor.registrarRuta("GET", RUTA_ICONO_DEL_PROYECTO, async (peticion, respuesta) => {
+        const responder = (codigo, texto) => {
+            respuesta.writeHead(codigo, { "Content-Type": "text/plain; charset=utf-8" });
+            respuesta.end(texto);
+        };
+        const id = new URLSearchParams((peticion.url ?? "").split("?")[1] ?? "").get("id");
+        if (id === null || id === "") {
+            responder(400, "falta el proyecto");
+            return;
+        }
+        const entorno = entornoElegido;
+        const proyecto = proyectos.find((p) => p.id === id);
+        const buscar = opciones.iconoDelProyecto;
+        const leer = opciones.leerFichero;
+        if (entorno === undefined || proyecto === undefined || buscar === undefined || leer === undefined || !hayCopiaLocal(proyecto.nombre)) {
+            responder(404, "no hay icono");
+            return;
+        }
+        let leido;
+        try {
+            const raiz = vestibulo.raizDeProyecto(entorno, proyecto.nombre);
+            const ruta = await buscar(raiz);
+            if (ruta === undefined) {
+                responder(404, "no hay icono");
+                return;
+            }
+            leido = await leer(raiz, ruta);
+        }
+        catch (error) {
+            informar(`no se pudo servir el icono de «${proyecto.nombre}» (${codigoDe(error)})`);
+            responder(500, "no se pudo leer");
+            return;
+        }
+        if (leido.error !== undefined || leido.base64 === undefined || leido.mime === undefined) {
+            responder(404, "no hay icono");
+            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.
      *
@@ -5124,6 +5296,13 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
             respuesta.end();
             return;
         }
+        if (typeof mensaje === "object" && mensaje !== null && mensaje.clase === "pendientesDeSubida") {
+            const ruta = mensaje.ruta;
+            void atenderPendientesDeSubida(typeof ruta === "string" ? ruta : undefined).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);
@@ -5190,6 +5369,29 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
             respuesta.end();
             return;
         }
+        if (typeof mensaje === "object" &&
+            mensaje !== null &&
+            mensaje.clase === "guardarFichero" &&
+            typeof mensaje.ruta === "string" &&
+            typeof mensaje.texto === "string" &&
+            typeof mensaje.huella === "string" &&
+            typeof mensaje.id === "string" &&
+            typeof mensaje.proyecto === "string") {
+            void atenderGuardarFichero(mensaje.ruta, mensaje.texto, mensaje.huella, mensaje.id, mensaje.proyecto).catch(contar);
+            respuesta.writeHead(204);
+            respuesta.end();
+            return;
+        }
+        if (typeof mensaje === "object" &&
+            mensaje !== null &&
+            mensaje.clase === "baseDeFichero" &&
+            typeof mensaje.ruta === "string" &&
+            (mensaje.base === "sesion" || mensaje.base === "commit")) {
+            void atenderBaseDeFichero(mensaje.ruta, mensaje.base).catch(contar);
+            respuesta.writeHead(204);
+            respuesta.end();
+            return;
+        }
         if (typeof mensaje === "object" && mensaje !== null && mensaje.clase === "artefacto" && typeof mensaje.nombre === "string") {
             void atenderArtefacto(mensaje.nombre).catch(contar);
             respuesta.writeHead(204);
@@ -6008,6 +6210,88 @@ export async function lecturaDeSync(raiz, sesion) {
         };
     }
 }
+/**
+ * TODO lo pendiente de subir del proyecto, como mensaje del cable (la pestaña Sincronización del
+ * panel). Sin CloudStudio, o si la medida falla, lo DICE: «no se pudo medir» no es «nada».
+ */
+export async function lecturaDePendientesDeSubida(raiz) {
+    const rama = cloudstudioDelProyecto(raiz)?.rama;
+    if (rama === undefined || rama === "") {
+        return { clase: "pendientesDeSubida", error: "este proyecto no está dado de alta en CloudStudio" };
+    }
+    try {
+        return { clase: "pendientesDeSubida", ficheros: await pendientesDeSubida(raiz, rama) };
+    }
+    catch {
+        return {
+            clase: "pendientesDeSubida",
+            error: "no se pudo medir lo que falta por subir: la copia local no se puede comparar con la rama",
+        };
+    }
+}
+/**
+ * El diff de UN fichero pendiente, con las DOS guardas antes de tocar git:
+ * - la ruta tiene que estar en la lista pendiente RECIÉN medida —una ruta inventada por el
+ *   cable no saca nada del disco—;
+ * - y tiene que poder ENSEÑARSE con la MISMA regla del lector que Ficheros y Revisión
+ *   (`motivoParaNoEnsenar`, texto y `realpath`): un `.env` pendiente sale en la lista, pero su
+ *   diff NO viaja nunca.
+ */
+export async function lecturaDeParcheDeSubida(raiz, ruta) {
+    const vacio = (negado) => ({
+        clase: "parcheDeSubida",
+        ruta,
+        texto: "",
+        recortado: false,
+        ...(negado === undefined ? {} : { negado }),
+    });
+    const rama = cloudstudioDelProyecto(raiz)?.rama;
+    if (rama === undefined || rama === "")
+        return vacio("el proyecto no está dado de alta en CloudStudio");
+    let fichero;
+    try {
+        fichero = (await pendientesDeSubida(raiz, rama)).find((f) => f.ruta === ruta);
+    }
+    catch {
+        return vacio("no se pudo medir lo que falta por subir");
+    }
+    if (fichero === undefined)
+        return vacio("ya no está pendiente de subir");
+    const motivo = await motivoParaNoEnsenar(raiz, ruta);
+    if (motivo !== undefined)
+        return vacio(motivo);
+    const parche = await parcheDeSubida(raiz, rama, ruta, fichero.sinCommitear === true);
+    return parche === undefined ? vacio() : { clase: "parcheDeSubida", ruta, ...parche };
+}
+/**
+ * Marca cada fichero de la sesión con si sigue PENDIENTE de subir a CloudStudio.
+ *
+ * Revisión enseña solo lo de la sesión que falta por subir: lo ya subido no es nada que
+ * revisar antes de subir. Se decide aquí y no en el cliente porque la lista (`revision`) y la
+ * medida (`sync`) son dos mensajes que llegan en momentos distintos, y cruzar uno nuevo con
+ * uno viejo escondería justo el fichero que el agente acaba de escribir —sin un solo error—.
+ *
+ * Misma medida que la banda (`cambiosPendientes` contra la ref de la bajada) y mismo cruce
+ * por ruta exacta que `cuantosDeLaSesion`, **más lo que git aún no sigue** (`sinSeguir`): un
+ * fichero recién creado a mitad de turno no sale en `git diff` y quedaría escondido justo
+ * cuando más falta hace verlo. La regla: lo que la ref no confirma como subido, se enseña. **Sin CloudStudio, o si la medida falla, los
+ * ficheros vuelven SIN la marca**: «no consta» no es «nada pendiente», y Revisión enseña
+ * entonces todo. No va dentro de `cambiosDeSesion`, que usan también el comentario de cierre,
+ * Soporte y `cuantosDeLaSesion`.
+ */
+export async function marcarPendientes(raiz, ficheros) {
+    const rama = cloudstudioDelProyecto(raiz)?.rama;
+    if (rama === undefined || rama === "" || ficheros.length === 0)
+        return [...ficheros];
+    try {
+        const [cambios, nuevos] = await Promise.all([cambiosPendientes(raiz, rama), sinSeguir(raiz)]);
+        const pendientes = new Set([...cambios.map((cambio) => cambio.ruta), ...nuevos]);
+        return ficheros.map((fichero) => ({ ...fichero, pendiente: pendientes.has(fichero.ruta) }));
+    }
+    catch {
+        return [...ficheros];
+    }
+}
 /**
  * De los pendientes, cuántos tocó ESTA sesión — o `undefined` cuando no se puede atribuir.
  *
@@ -6183,6 +6467,15 @@ export function ajusteDeWorkspaceCableado(opciones) {
         },
     };
 }
+/**
+ * Los tres puertos de la pestaña Ficheros —leer, guardar y la base de las marcas—, cableados con las
+ * funciones de verdad y extraídos por el MISMO motivo que `emuladoresCableados`: dentro de
+ * `arrancarConsolaWeb` serían un literal que ningún test mira, y cada uno es un campo OPCIONAL de
+ * `montarRutas`, así que olvidarlo compila y pasa.
+ */
+export function ficherosCableados() {
+    return { leerFichero: leerFicheroDeProyecto, escribirFichero: escribirFicheroDeProyecto, baseDeFichero, iconoDelProyecto };
+}
 /**
  * Los siete puertos de los emuladores, cableados con las funciones de verdad — extraídos por el
  * MISMO motivo que `ajusteDeWorkspaceCableado`: dentro de `arrancarConsolaWeb` serían un literal
@@ -6704,7 +6997,8 @@ export async function arrancarConsolaWeb(opciones) {
         modeloDelCambio,
         planesDelProyecto,
         visorOpenui: () => leerVisorOpenui(raizDelCliente),
-        leerFichero: leerFicheroDeProyecto,
+        // Leer, guardar y la base del editor, compuestos fuera para que la composición tenga test.
+        ...ficherosCableados(),
         leerArtefacto: leerArtefactoDeSesion,
         leerArtefactoCrudo,
         correrPasoDeReceta: (receta, paso, alSalirLinea) => correrPasoDeReceta(receta, paso, { alSalirLinea }),