xonecode 0.26.0 → 0.28.0

package/dist/core/verificacionDeSubida.js

@@ -0,0 +1,58 @@
+/**
+ * La comprobación de lo que una subida dejó en CloudStudio: lo que se mandó contra lo que se
+ * relee. PURA, para poder probar el motivo sin red.
+ *
+ * Existe porque hay ficheros que se CORTAN al subirlos a Studio y la causa no se ha encontrado.
+ * Mientras tanto, cada texto subido se relee y se compara; un corte tiene que salir como fallo
+ * con cifras que se puedan medir —cuánto había, cuánto llegó, desde dónde difiere—, no como un
+ * «subido» que miente.
+ *
+ * La comparación normaliza SOLO dos transformaciones MEDIDAS contra el servidor real (una rama
+ * desechable de AppDemo), aplicadas a los dos lados:
+ * - **Studio quita el salto de línea FINAL** (o `studio_get_file` no lo devuelve): un
+ *   «…'añadir';\n» de 76 B vuelve con 75 B, y un fichero de 457.890 B vuelve con 457.889 B,
+ *   idéntico en todo lo demás. Un fichero SIN salto final vuelve idéntico.
+ * - **Studio convierte CRLF en LF** («\r\n» → «\n»).
+ * Nada más: el BOM se conserva, y tildes, emoji y «» llegan intactos, así que no se tocan.
+ * Normalizar a ciegas es justo cómo se esconde un corte; un corte de verdad (falta una línea,
+ * cambia algo en medio) sigue saliendo distinto. El motivo y los hashes se calculan sobre los
+ * textos EN CRUDO: son lo que hay de verdad a cada lado.
+ */
+import { createHash } from "node:crypto";
+/** sha256 en hexadecimal minúsculo: el mismo formato que pide `studio_upload_file`. */
+export function sha256Hex(datos) {
+    return createHash("sha256").update(datos).digest("hex");
+}
+/** Un número con el punto de miles del castellano, sin depender del ICU de la máquina. */
+export function conMiles(n) {
+    return String(n).replace(/\B(?=(\d{3})+(?!\d))/g, ".");
+}
+/** Las dos transformaciones medidas de Studio (ver cabecera), y ninguna más. */
+function comoLoGuardaStudio(texto) {
+    return texto.replace(/\r\n/g, "\n").replace(/\n+$/, "");
+}
+/** `undefined` = llegó igual. Si no, el motivo con las cifras y los dos hashes. */
+export function diferenciaDeTexto(local, studio) {
+    if (comoLoGuardaStudio(local) === comoLoGuardaStudio(studio))
+        return undefined;
+    let desde = 0;
+    const tope = Math.min(local.length, studio.length);
+    while (desde < tope && local[desde] === studio[desde])
+        desde++;
+    const bytesLocal = Buffer.byteLength(local, "utf8");
+    const bytesStudio = Buffer.byteLength(studio, "utf8");
+    return {
+        motivo: `llegó distinto a Studio: ${conMiles(bytesLocal)} B en local, ${conMiles(bytesStudio)} B en Studio ` +
+            `(difieren desde el carácter ${conMiles(desde)})`,
+        sha256Local: sha256Hex(local),
+        sha256Studio: sha256Hex(studio),
+    };
+}
+/** Cuánto de un motivo de error remoto se deja en un fallo: lo justo para reconocerlo. */
+const TOPE_DE_MOTIVO = 200;
+/** El motivo de una relectura que no se pudo hacer: el fichero se escribió pero NO está comprobado. */
+export function motivoSinComprobar(error) {
+    const corto = error.length > TOPE_DE_MOTIVO ? `${error.slice(0, TOPE_DE_MOTIVO)}…` : error;
+    return `subido pero no se pudo comprobar: ${corto}`;
+}
+//# sourceMappingURL=verificacionDeSubida.js.map

package/dist/core/verificacionDeSubida.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"verificacionDeSubida.js","sourceRoot":"","sources":["../../src/core/verificacionDeSubida.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAEzC,uFAAuF;AACvF,MAAM,UAAU,SAAS,CAAC,KAA0B;IAClD,OAAO,UAAU,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;AAC1D,CAAC;AAED,0FAA0F;AAC1F,MAAM,UAAU,QAAQ,CAAC,CAAS;IAChC,OAAO,MAAM,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,uBAAuB,EAAE,GAAG,CAAC,CAAC;AACzD,CAAC;AASD,gFAAgF;AAChF,SAAS,kBAAkB,CAAC,KAAa;IACvC,OAAO,KAAK,CAAC,OAAO,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC;AAC1D,CAAC;AAED,mFAAmF;AACnF,MAAM,UAAU,iBAAiB,CAAC,KAAa,EAAE,MAAc;IAC7D,IAAI,kBAAkB,CAAC,KAAK,CAAC,KAAK,kBAAkB,CAAC,MAAM,CAAC;QAAE,OAAO,SAAS,CAAC;IAC/E,IAAI,KAAK,GAAG,CAAC,CAAC;IACd,MAAM,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC;IACnD,OAAO,KAAK,GAAG,IAAI,IAAI,KAAK,CAAC,KAAK,CAAC,KAAK,MAAM,CAAC,KAAK,CAAC;QAAE,KAAK,EAAE,CAAC;IAC/D,MAAM,UAAU,GAAG,MAAM,CAAC,UAAU,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;IACpD,MAAM,WAAW,GAAG,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACtD,OAAO;QACL,MAAM,EACJ,4BAA4B,QAAQ,CAAC,UAAU,CAAC,gBAAgB,QAAQ,CAAC,WAAW,CAAC,eAAe;YACpG,+BAA+B,QAAQ,CAAC,KAAK,CAAC,GAAG;QACnD,WAAW,EAAE,SAAS,CAAC,KAAK,CAAC;QAC7B,YAAY,EAAE,SAAS,CAAC,MAAM,CAAC;KAChC,CAAC;AACJ,CAAC;AAED,0FAA0F;AAC1F,MAAM,cAAc,GAAG,GAAG,CAAC;AAE3B,uGAAuG;AACvG,MAAM,UAAU,kBAAkB,CAAC,KAAa;IAC9C,MAAM,KAAK,GAAG,KAAK,CAAC,MAAM,GAAG,cAAc,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,cAAc,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC;IAC3F,OAAO,qCAAqC,KAAK,EAAE,CAAC;AACtD,CAAC"}

package/dist/web/servidor/arranque.js

@@ -55,8 +55,11 @@ import { PLATAFORMAS_DE_DISPOSITIVO } from "../../core/settings.js";
 import { instalarHerramientaDeDispositivos, verificarDispositivo } from "../../agent/dispositivos/dispositivosEnMaquina.js";
 import { arrancarEmulador, pararEmulador } from "../../agent/dispositivos/arranqueDeEmulador.js";
 import { borrarAvd, clonarAvd, correrPasoDeReceta, crearAvd } from "../../agent/dispositivos/instalacionEnMaquina.js";
-import { asignarPuertosPendientes, motivoDeNombreDeAvdInaceptable, motivoDePuertoInaceptable, puertoDeAvd, } from "../../core/puertosDeAvd.js";
+import { asignarPuertosPendientes, motivoDeNombreDeAvdInaceptable, motivoDePuertoInaceptable, puertoDeAvd, PUERTO_DEL_HOTSWAP, } from "../../core/puertosDeAvd.js";
 import { abrirCarpetaDelSistema, abrirDirectorioDelSistema } from "../../agent/config/selectorEnMaquina.js";
+import { recargarFicheroDelProyecto, relanzarEnAparato, } from "../../agent/dispositivos/recargaEnAparato.js";
+import { textoDeRecarga } from "../../core/recargaEnCaliente.js";
+import { nombreDeApp } from "../../core/descriptoresDeApp.js";
 import { modelosDeMotor } from "../../agent/config/modelosDeMotor.js";
 import { parsear, compatibleConOpenAi, esProveedorPersonalizado, idDeProveedorPersonalizado, motivoDeEndpointInaceptable, motivoDeSlugInaceptable, nombreDeProveedor, PROVEEDORES, slugDesdeNombre, resolver, SIN_CREDENCIAL, PAPELES, } from "../../core/modelos.js";
 import { hayCredencial } from "../../cli/consola.js";
@@ -3020,15 +3023,21 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
      * se pintó el botón. Una revalidación que no pasa se contesta con un `lanzamiento` en `fallo`
      * y NO se llama al lanzador.
      */
-    const atenderLanzarApp = async () => {
+    /**
+     * `alAcabar` es para quien lanzó por OTRO camino que la pestaña (el «Probar» del editor): le dice
+     * cómo acabó, para que su línea no se quede en «desplegando» para siempre.
+     */
+    const atenderLanzarApp = async (alAcabar) => {
         // Ya hay uno: se reenvía su estado en vez de lanzar otro, como `atenderReceta`.
         if (lanzamiento !== undefined) {
             emitirLanzamiento("corriendo");
+            alAcabar?.("ocupado");
             return;
         }
         const medida = await medirLanzamiento();
         if (medida === undefined) {
             informar("no hay ningún proyecto abierto que lanzar");
+            alAcabar?.("fallo", "no hay ningún proyecto abierto");
             return;
         }
         const foto = medida.dispositivo === undefined ? undefined : fotoDeDispositivo(medida.dispositivo);
@@ -3043,6 +3052,7 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
                 ms: 0,
                 motivo,
             });
+            alAcabar?.("fallo", motivo);
         };
         const lanzar = opciones.lanzarEnDispositivo;
         const primeraFalta = medida.veredicto.causas[0];
@@ -3127,6 +3137,7 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
             ultimoLanzamiento = 0;
             trabajo.fase = resultado.fase;
             emitirLanzamiento(resultado.estado, resultado.motivo);
+            alAcabar?.(resultado.estado === "ok" ? "ok" : "fallo", resultado.motivo ?? (resultado.estado === "ok" ? undefined : resultado.estado));
         }
         catch (error) {
             // El contrato del lanzador es no lanzar nunca, así que esto es un bug suyo; aun así hay
@@ -3134,6 +3145,7 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
             // muerto y sin una palabra.
             ultimoLanzamiento = 0;
             emitirLanzamiento("fallo", motivoLegible(error));
+            alAcabar?.("fallo", motivoLegible(error));
         }
         finally {
             lanzamiento = undefined;
@@ -3814,7 +3826,7 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
      *  - 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 atenderGuardarFichero = async (ruta, texto, huella, id, proyecto, recargar = false) => {
         const abierto = vestibulo.proyectoAbierto();
         if (abierto === undefined) {
             emitir({ clase: "ficheroGuardado", ruta, id, error: "no hay ningún proyecto abierto" });
@@ -3842,13 +3854,152 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
             // `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 });
+            const guardado = await opciones.escribirFichero(abierto.raiz, ruta, texto, huella);
+            emitir({ clase: "ficheroGuardado", ...guardado, id });
+            // DESPUÉS de contestar el guardado, y sin esperarla: el «Guardando…» no depende del aparato,
+            // y nada de la recarga puede convertir un guardado bueno en uno fallido.
+            if (recargar && guardado.huella !== undefined && guardado.error === undefined) {
+                void atenderRecarga(abierto.raiz, ruta, { probar: false }).catch(contar);
+            }
         }
         catch (error) {
             informar(`no se pudo guardar «${ruta}» (${codigoDe(error)})`);
             emitir({ clase: "ficheroGuardado", ruta, id, error: "no se pudo guardar el fichero" });
         }
     };
+    /**
+     * A qué aparato y app va una recarga, resuelto aquí y no en el cliente: el dispositivo ELEGIDO en
+     * la sesión (si no hay, no se recarga — sin adivinar uno), Android, el puerto de SU AVD (con dos
+     * emuladores, el 8443 le hablaría al otro sin error) y el nombre de la app de `app.ini`, el
+     * MISMO que usa Ejecutar. `undefined` = no hay a dónde recargar, y eso no es un fallo.
+     */
+    const destinoDeRecarga = async (abierto) => {
+        if (abierto.dispositivo === undefined)
+            return { motivo: "no hay un aparato elegido en la sesión" };
+        const { dispositivo } = dispositivoDeLaSesion(abierto.dispositivo, informeDeDispositivos);
+        // La foto de Dispositivos solo se toma al conectar y al pulsar «Refrescar»: un emulador
+        // arrancado después no está en ella, y decir «la app no corre» mandaría a buscar donde no es.
+        if (dispositivo === undefined) {
+            return { motivo: "el aparato de la sesión no está en la última medida: pulsa Refrescar en Dispositivos" };
+        }
+        if (dispositivo.plataforma !== "android")
+            return { motivo: "la recarga en caliente solo existe en Android" };
+        const ini = await leerDescriptor(abierto.raiz, "app.ini");
+        const app = ini.texto === undefined ? undefined : nombreDeApp(ini.texto);
+        if (app === undefined)
+            return { motivo: "app.ini no dice el nombre de la app (name=)" };
+        return {
+            serie: dispositivo.id,
+            puerto: dispositivo.avd === undefined ? PUERTO_DEL_HOTSWAP : puertoDeAvd(ajustesDeDispositivos(), dispositivo.avd),
+            app,
+        };
+    };
+    /**
+     * UNA recarga a la vez para toda la máquina, como el lanzamiento: dos al mismo aparato se
+     * cruzarían en el canal (las respuestas se emparejan por ORDEN). Un guardado que llega con una en
+     * vuelo deja su ruta como SIGUIENTE, y la última pisa a la anterior: tras varios Cmd+S seguidos lo
+     * que importa es cómo quedó el fichero, no cada versión intermedia.
+     */
+    let recargando = false;
+    let siguienteRecarga;
+    const emitirRecarga = (ruta, resultado) => {
+        emitir({
+            clase: "recargaEnAparato",
+            ruta,
+            estado: resultado.estado,
+            ...(resultado.clase === undefined ? {} : { tipo: resultado.clase }),
+            texto: textoDeRecarga(resultado),
+        });
+    };
+    /**
+     * Recargar en el aparato. **Nunca lanza ni contesta un error al guardado**: sin aparato o sin
+     * app, dice `sin-app` y ya. Con `probar` y la app sin correr, lanza el despliegue entero de
+     * Ejecutar —que sube el proyecto entero— en vez de recargar lo que nadie tiene cargado.
+     */
+    const atenderRecarga = async (raiz, ruta, { probar }) => {
+        if (recargando) {
+            siguienteRecarga = { raiz, ruta, probar };
+            return;
+        }
+        recargando = true;
+        try {
+            const abierto = vestibulo.proyectoAbierto();
+            if (abierto === undefined || abierto.raiz !== raiz)
+                return;
+            if (lanzamiento !== undefined) {
+                emitirRecarga(ruta, { estado: "ocupado" });
+                return;
+            }
+            const destino = await destinoDeRecarga(abierto);
+            const recargar = opciones.recargarEnAparato;
+            if ("motivo" in destino) {
+                // Sin a dónde recargar tampoco hay a dónde desplegar: se dice por qué, y nada más.
+                emitirRecarga(ruta, { estado: "sin-app", motivo: destino.motivo });
+                return;
+            }
+            if (recargar === undefined) {
+                emitirRecarga(ruta, { estado: "sin-app", motivo: "esta ejecución no recarga en el aparato" });
+                return;
+            }
+            const resultado = await recargar(raiz, ruta, destino);
+            if (resultado.estado === "sin-app" && probar) {
+                emitirRecarga(ruta, { estado: "desplegando" });
+                // Y cómo acabó, en la MISMA línea: sin esto se quedaba en «desplegando» para siempre.
+                void atenderLanzarApp((estado, motivo) => {
+                    if (estado === "ok")
+                        emitirRecarga(ruta, { estado: "desplegada" });
+                    else if (estado === "ocupado")
+                        emitirRecarga(ruta, { estado: "ocupado" });
+                    else
+                        emitirRecarga(ruta, { estado: "fallo", motivo: `el despliegue no acabó bien: ${motivo ?? "sin motivo"}` });
+                }).catch(contar);
+                return;
+            }
+            emitirRecarga(ruta, resultado);
+        }
+        catch (error) {
+            // Su contrato es no lanzar; si lo hace, se dice como fallo de la RECARGA, nunca del guardado.
+            emitirRecarga(ruta, { estado: "fallo", motivo: motivoLegible(error) });
+        }
+        finally {
+            recargando = false;
+            const otra = siguienteRecarga;
+            siguienteRecarga = undefined;
+            if (otra !== undefined)
+                void atenderRecarga(otra.raiz, otra.ruta, { probar: otra.probar }).catch(contar);
+        }
+    };
+    /** Relanzar la app a petición (un CSS solo se ve así). Con las mismas reglas que la recarga. */
+    const atenderRelanzar = async (ruta) => {
+        const abierto = vestibulo.proyectoAbierto();
+        if (abierto === undefined)
+            return;
+        if (lanzamiento !== undefined || recargando) {
+            emitirRecarga(ruta, { estado: "ocupado" });
+            return;
+        }
+        const destino = await destinoDeRecarga(abierto);
+        const relanzar = opciones.relanzarEnAparato;
+        if ("motivo" in destino || relanzar === undefined) {
+            emitirRecarga(ruta, { estado: "sin-app", motivo: "motivo" in destino ? destino.motivo : "esta ejecución no relanza" });
+            return;
+        }
+        recargando = true;
+        try {
+            emitirRecarga(ruta, await relanzar(destino));
+        }
+        catch (error) {
+            emitirRecarga(ruta, { estado: "fallo", motivo: motivoLegible(error) });
+        }
+        finally {
+            recargando = false;
+            // Un guardado que llegó mientras se relanzaba quedó como siguiente: sin esto se perdía.
+            const otra = siguienteRecarga;
+            siguienteRecarga = undefined;
+            if (otra !== undefined)
+                void atenderRecarga(otra.raiz, otra.ruta, { probar: otra.probar }).catch(contar);
+        }
+    };
     /**
      * 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
@@ -5377,7 +5528,7 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
             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);
+            void atenderGuardarFichero(mensaje.ruta, mensaje.texto, mensaje.huella, mensaje.id, mensaje.proyecto, mensaje.recargar === true).catch(contar);
             respuesta.writeHead(204);
             respuesta.end();
             return;
@@ -5879,6 +6030,22 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
             respuesta.end();
             return;
         }
+        if (typeof mensaje === "object" &&
+            mensaje !== null &&
+            mensaje.clase === "recargarEnAparato" &&
+            typeof mensaje.ruta === "string") {
+            // Suelto: habla con el aparato, y la respuesta va por el SSE como `recargaEnAparato`.
+            const abierto = vestibulo.proyectoAbierto();
+            if (abierto !== undefined) {
+                if (mensaje.relanzar === true)
+                    void atenderRelanzar(mensaje.ruta).catch(contar);
+                else
+                    void atenderRecarga(abierto.raiz, mensaje.ruta, { probar: mensaje.probar === true }).catch(contar);
+            }
+            respuesta.writeHead(204);
+            respuesta.end();
+            return;
+        }
         if (typeof mensaje === "object" && mensaje !== null && mensaje.clase === "cancelarLanzamiento") {
             // Este SÍ es síncrono: `cancelar` solo mata el grupo del proceso en curso.
             atenderCancelarLanzamiento();
@@ -6486,6 +6653,17 @@ export function ficherosCableados() {
  * (`guardarAjusteDeAvd(undefined, …)`). `arrancar` entra solo para que un test vea qué recibe la
  * de verdad sin lanzar un emulador.
  */
+/**
+ * La recarga en caliente del editor, con las funciones de VERDAD y compuesta fuera del cableado
+ * por la trampa de siempre: un campo opcional olvidado en `arrancarConsolaWeb` deja la casilla
+ * pintada y sin hacer nada, con todo en verde. El `adb` y el canal reales los ponen ellas.
+ */
+export function recargaCableada() {
+    return {
+        recargarEnAparato: (raiz, ruta, destino) => recargarFicheroDelProyecto(raiz, ruta, destino),
+        relanzarEnAparato: (destino) => relanzarEnAparato(destino),
+    };
+}
 export function emuladoresCableados(opciones = {}) {
     const arrancar = opciones.arrancar ?? arrancarEmulador;
     return {
@@ -7048,6 +7226,7 @@ export async function arrancarConsolaWeb(opciones) {
          * arriba: una composición de producción que solo existe en el cableado nadie la prueba.
          */
         lanzarEnDispositivo,
+        ...recargaCableada(),
         catalogoDeModelos: async (proveedor) => {
             const modelos = await new CatalogoModelos(undefined, undefined, proveedoresPersonalizados).listar(proveedor);
             return modelos.map((m) => ({ id: m.id, ...(m.nombre === undefined ? {} : { nombre: m.nombre }) }));