xonecode 0.22.1 → 0.24.1

package/dist/web/servidor/arranque.js

@@ -66,19 +66,20 @@ import { borrarCredencial, guardarCredencial } from "../../agent/config/authEnDi
 import { borrarProveedorPersonalizado, guardarProveedorPersonalizado, proveedoresPersonalizados, } from "../../agent/config/configEnDisco.js";
 import { crearCheckpointerDeProyecto, mantenimientoDelCheckpointer, } from "../../agent/sesiones/checkpointer.js";
 import { resumenDePoda } from "../../core/podaDeCheckpoint.js";
-import { cargarSettings, guardarConcurrenciaDeTareas, guardarDepurar, guardarWorkspace as guardarWorkspaceEnDisco, guardarDispositivos, guardarAjusteDeAvd, quitarAjustesDeAvd, guardarPuertosAsignados, guardarEntorno as guardarEntornoEnDisco, olvidarEntornoDeSettings, copiasDeEntorno, borrarCopiasDeEntorno, } from "../../agent/config/settingsEnDisco.js";
+import { cargarSettings, guardarConcurrenciaDeTareas, guardarDepurar, guardarModoPorDefecto, guardarWorkspace as guardarWorkspaceEnDisco, guardarDispositivos, guardarAjusteDeAvd, quitarAjustesDeAvd, guardarPuertosAsignados, guardarEntorno as guardarEntornoEnDisco, olvidarEntornoDeSettings, copiasDeEntorno, borrarCopiasDeEntorno, } from "../../agent/config/settingsEnDisco.js";
 import { dentroDelWorkspace, depuracionActiva, expandirConCasa, mismaRuta, motivoParaNoOlvidarEntorno, motivoDeNombreDeEntornoInaceptable, motivoDeWorkspaceInaceptable, } from "../../core/settings.js";
 import { esModoDeEscritura, MODO_POR_OMISION, } from "../../core/modoDeEscritura.js";
 import { megasDeLasMudanzas, mudarWorkspaceLegado } from "../../agent/config/mudanzaEnDisco.js";
 import { elegirCarpetaEnMaquina, haySelectorDeCarpeta } from "../../agent/config/selectorEnMaquina.js";
-import { cloudstudioDelProyecto } from "../../agent/config/configEnDisco.js";
+import { cloudstudioDelProyecto, guardarModoDeEscrituraDeProyecto, modoDeEscrituraDelProyecto } from "../../agent/config/configEnDisco.js";
 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 { 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, leerFicheroDeProyecto, mimeDeImagen, motivoDeRutaInaceptable, } 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";
@@ -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
@@ -1101,6 +1114,8 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
         // La casilla «Depurar», por lo mismo que el workspace: Ajustes se puede abrir en cuanto
         // conecta.
         const depuracion = mensajeDeDepuracion();
+        // El modo de las sesiones nuevas (IXCODE-31), por lo mismo: está en Ajustes > General.
+        const modoPorDefecto = mensajeDeModoPorDefecto();
         // 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();
@@ -1127,6 +1142,8 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
                 cliente({ clase: "mudanzaDeWorkspace", progreso: ultimoProgresoDeMudanza });
             if (depuracion !== undefined)
                 cliente(depuracion);
+            if (modoPorDefecto !== undefined)
+                cliente(modoPorDefecto);
             if (conectores !== undefined)
                 cliente(conectores);
             if (consumoDeLaSesion !== undefined) {
@@ -1302,6 +1319,10 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
         if (m !== undefined)
             emitir(m);
     };
+    const mensajeDeModoPorDefecto = () => {
+        const modo = opciones.modoPorDefectoGlobal?.();
+        return modo === undefined ? undefined : { clase: "modoPorDefecto", modo };
+    };
     /**
      * 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`).
@@ -3750,6 +3771,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.
      *
@@ -4918,11 +5007,59 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
                 const { clase: _clase, ...medida } = await lecturaDeSync(raiz);
                 sync = medida;
             }
-            const foto = { tareas, ...(sync === undefined ? {} : { sync }) };
+            // El modo de las sesiones nuevas de ESTE proyecto (IXCODE-31): solo con copia, que es
+            // donde vive su `config.json`; dentro, ausente es «como el global».
+            const modoDeEscritura = opciones.modoDelProyecto === undefined || !esProyectoEnDisco(raiz)
+                ? undefined
+                : (() => {
+                    const proyecto = opciones.modoDelProyecto(raiz);
+                    return proyecto === undefined ? {} : { proyecto };
+                })();
+            const foto = {
+                tareas,
+                ...(sync === undefined ? {} : { sync }),
+                ...(modoDeEscritura === undefined ? {} : { modoDeEscritura }),
+            };
             respuesta.writeHead(200, { "content-type": "application/json" });
             respuesta.end(JSON.stringify(foto));
             return;
         }
+        if (typeof mensaje === "object" && mensaje !== null && mensaje.clase === "copiaLocal" && mensaje.accion === "modoDeEscritura") {
+            // IXCODE-31. Del cable llega el ID y, opcional, el modo; la raíz la pone el servidor,
+            // como en `resumen`. Sin `modo` se QUITA: vuelve a mandar el global.
+            const pedido = mensaje.modo;
+            if (pedido !== undefined && !esModoDeEscritura(pedido)) {
+                respuesta.writeHead(400);
+                respuesta.end();
+                return;
+            }
+            const identidad = proyectos.find((p) => p.id === mensaje.proyecto);
+            const raiz = entornoElegido === undefined || identidad === undefined
+                ? undefined
+                : vestibulo.raizDeProyecto(entornoElegido, identidad.nombre);
+            if (raiz === undefined || !esProyectoEnDisco(raiz) || opciones.guardarModoDelProyecto === undefined) {
+                respuesta.writeHead(409, { "content-type": "application/json" });
+                respuesta.end(JSON.stringify({
+                    motivo: raiz === undefined
+                        ? "ese proyecto no está en el listado del entorno activo"
+                        : "el proyecto no tiene copia local: el modo se guarda en su configuración",
+                }));
+                return;
+            }
+            try {
+                opciones.guardarModoDelProyecto(raiz, pedido);
+            }
+            catch (error) {
+                // Un `config.json` roto PARA sin escribir (`leerObjetoCrudoOAbortar`): se dice, sin la ruta.
+                respuesta.writeHead(409, { "content-type": "application/json" });
+                respuesta.end(JSON.stringify({ motivo: `no se pudo guardar en la configuración del proyecto (${codigoDe(error) ?? "su config.json no se puede leer"})` }));
+                return;
+            }
+            const proyecto = opciones.modoDelProyecto?.(raiz);
+            respuesta.writeHead(200, { "content-type": "application/json" });
+            respuesta.end(JSON.stringify(proyecto === undefined ? {} : { proyecto }));
+            return;
+        }
         if (typeof mensaje === "object" && mensaje !== null && mensaje.clase === "soporte" && mensaje.accion === "listar") {
             // El listado de la pestaña Soporte, con el análisis PREVIO de cada chat y cada tarea
             // (`core/analisisDeSesion.ts`), contestado en la propia respuesta como `resumen`.
@@ -5134,6 +5271,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);
@@ -5372,6 +5532,18 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
             respuesta.end();
             return;
         }
+        if (typeof mensaje === "object" && mensaje !== null && mensaje.clase === "modoPorDefecto") {
+            // Un modo que no existe no se guarda: el cliente manda la intención, el servidor decide.
+            if (esModoDeEscritura(mensaje.modo)) {
+                opciones.guardarModoPorDefectoGlobal?.(mensaje.modo);
+                const m = mensajeDeModoPorDefecto();
+                if (m !== undefined)
+                    emitir(m);
+            }
+            respuesta.writeHead(204);
+            respuesta.end();
+            return;
+        }
         if (typeof mensaje === "object" && mensaje !== null && mensaje.clase === "depuracion" && typeof mensaje.activa === "boolean") {
             opciones.guardarDepuracion?.(mensaje.activa);
             emitirDepuracion();
@@ -6115,6 +6287,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 };
+}
 /**
  * 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
@@ -6156,6 +6337,32 @@ export function ajusteDeDepuracionCableado(opciones = {}) {
         guardarDepuracion: (activa) => guardar(activa),
     };
 }
+/**
+ * El modo con que NACEN las sesiones nuevas (IXCODE-31), cableado: el global
+ * (`settings.json#modoDeEscritura`, Ajustes > General) y el de cada proyecto
+ * (`.xonecode/config.json#modoDeEscritura`, panel del proyecto). Extraída por el patrón de
+ * fallo de siempre, y con una trampa concreta que el test vigila: el del proyecto se lee por la
+ * RAÍZ, porque en la web `fuentes().proyecto` no se rellena nunca — leerlo de ahí daría el
+ * ajuste por guardado y no se aplicaría jamás.
+ */
+export function ajusteDeModoPorDefectoCableado(opciones = {}) {
+    const leerGlobal = opciones.leerGlobal ?? (() => cargarSettings().settings.modoDeEscritura);
+    const guardarGlobal = opciones.guardarGlobal ?? ((modo) => void guardarModoPorDefecto(undefined, modo));
+    const leerProyecto = opciones.leerProyecto ?? modoDeEscrituraDelProyecto;
+    const guardarProyecto = opciones.guardarProyecto ??
+        ((raiz, modo) => void guardarModoDeEscrituraDeProyecto(raiz, modo));
+    return {
+        modoPorDefecto: (raiz) => {
+            const proyecto = leerProyecto(raiz);
+            const global = leerGlobal();
+            return { ...(proyecto === undefined ? {} : { proyecto }), ...(global === undefined ? {} : { global }) };
+        },
+        modoPorDefectoGlobal: () => leerGlobal() ?? MODO_POR_OMISION,
+        guardarModoPorDefectoGlobal: (modo) => guardarGlobal(modo),
+        modoDelProyecto: (raiz) => leerProyecto(raiz),
+        guardarModoDelProyecto: (raiz, modo) => guardarProyecto(raiz, modo),
+    };
+}
 /**
  * La opción `conectores` de `montarRutas`, cableada — extraída por el MISMO motivo que
  * `ajusteDeWorkspaceCableado`: un literal inline dentro de `arrancarConsolaWeb` no quedaría
@@ -6553,6 +6760,9 @@ export async function arrancarConsolaWeb(opciones) {
         // La casilla «Depurar», con la MISMA disciplina: composición extraída y probada
         // (`ajusteDeDepuracionCableado`).
         ...ajusteDeDepuracionCableado(),
+        // El modo con que nacen las sesiones nuevas (IXCODE-31), con la MISMA disciplina. El
+        // lector por raíz va al vestíbulo (`vestibuloReal`); aquí, los de Ajustes y del panel.
+        ...(({ modoPorDefecto: _paraElVestibulo, ...resto }) => resto)(ajusteDeModoPorDefectoCableado()),
         // Los conectores MCP, con la MISMA disciplina: la composición extraída y probada
         // (`ajusteDeConectoresCableado`), nunca un literal aquí dentro.
         // Y el gestor de tareas (IXCODE-11) llama por ESE mismo servicio: los dos salen de
@@ -6607,7 +6817,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 }),
@@ -6808,6 +7019,8 @@ function vestibuloReal(opciones, servidor, escribir, informar, conectores) {
         informar,
         origenDeTrabajo: resolver(fuentes()).trabajo.origen,
         fuentes,
+        // Con qué modo nace una sesión nueva (IXCODE-31): el del proyecto de ESA raíz, si no el global.
+        modoPorDefecto: ajusteDeModoPorDefectoCableado().modoPorDefecto,
         // Se resuelve UNA vez, aquí, y no en cada `anunciarAlta`: `git config`/`os.userInfo`
         // no cambian a media conexión, y repetir el subproceso en cada anuncio del alta sería
         // gastar sin motivo. Nunca viaja hacia CloudStudio ni hacia ningún acto —