xonecode 0.8.27 → 0.8.37

package/skills/xone-hotswap/scripts/xone-desplegar-android

@@ -236,6 +236,26 @@ function concederPermisos() {
     console.log("    no se pudo leer qué permisos pide; sigo");
     return;
   }
+  /**
+   * **El de dibujar sobre otras apps NO se concede con `pm grant`, y sin él el arranque es una
+   * carrera contra el foco.**
+   *
+   * `SYSTEM_ALERT_WINDOW` es un appop, no un permiso de ejecución, así que el bucle de abajo lo
+   * intenta y falla en silencio con los demás. Y lo que concede no es cosmético: Android 10 y
+   * superiores BLOQUEAN que una app en segundo plano arranque una actividad, y ese permiso es la
+   * exención que reconocen. El framework se va a segundo plano con solo apagarse la pantalla, o
+   * en cuanto se cierra la app — así que sin esto `launchApplication` contesta
+   * «Cannot launch app while the framework is in the background» y el despliegue parece que
+   * funcionó sin que arrancara nada. Es buena parte del síntoma que teníamos apuntado como
+   * «`result:true` significa aceptado, no arrancó».
+   *
+   * Idempotente, y su fallo no para nada: en un aparato donde no aplique, se sigue.
+   */
+  try {
+    adbCallado("shell", "appops", "set", PAQUETE, "SYSTEM_ALERT_WINDOW", "allow");
+  } catch {
+    // Aparato que no lo admite. El despliegue sigue; lo que se pierde es la garantía de foco.
+  }
   let dados = 0;
   for (const permiso of declaradas) {
     try {
@@ -260,7 +280,24 @@ function concederPermisos() {
 function excepcionDeXOne() {
   let log;
   try {
-    log = adbCallado("logcat", "-d", "-t", "600");
+    /**
+     * **Acotado al PROCESO, no a las últimas N líneas del aparato.** Era `-t 600` a secas, y
+     * eso no es «lo último de la app»: son 600 líneas de TODO —Chromium, el sistema, lo que
+     * haya—, que en este emulador son un par de minutos. La excepción de XOne se salía de esa
+     * ventana enseguida, el despliegue no la veía y no contaba nada.
+     *
+     * Y lo que pasa después es el motivo de arreglarlo: sin el texto, a quien diagnostica solo
+     * le queda **fotografiar el diálogo de error** —visto en una sesión real—, que cuesta 3.375
+     * tokens y dice exactamente lo mismo que estas seis líneas.
+     *
+     * Con `--pid`, 600 líneas son 600 líneas DE LA APP. Es como ya leía `xone-log-android`;
+     * que dos sitios miraran el mismo log de forma distinta era la razón de que uno lo
+     * encontrara y el otro no.
+     */
+    const pid = adbCallado("shell", "pidof", PAQUETE).trim().split(/\s+/)[0];
+    log = pid
+      ? adbCallado("logcat", "-d", "--pid", pid, "-t", "600")
+      : adbCallado("logcat", "-d", "-t", "600");
   } catch {
     return undefined;
   }
@@ -340,8 +377,27 @@ function exigirAparato() {
 
   console.log("5/5 esperando al canal, lanzando y comprobando que está VIVA");
   const cliente = join(import.meta.dirname, "xone-hotswap");
-  const mandar = (comando) =>
-    execFileSync("node", [cliente, JSON.stringify(comando)], { encoding: "utf8" }).trim();
+  /**
+   * **En `clave=valor`, que es lo único que el cliente entiende.**
+   *
+   * Esto mandaba `JSON.stringify(comando)` y se rompió ENTERO el día que el cliente dejó de
+   * aceptar JSON: el objeto se metía como NOMBRE del comando, el aparato contestaba
+   * `Unknown command: {…}` y el despliegue no lanzaba nada. Lanzar la app, pedir el árbol y
+   * capturar —las tres cosas que hace este paso— pasaban por aquí, así que se cayeron las
+   * tres a la vez, y en silencio: el script reintenta diez veces y acaba diciendo que el
+   * canal no levantó, que manda a mirar el puerto y el paquete en vez de al cliente.
+   *
+   * La conversión es la misma que hace el cliente al revés: cada campo que no es `command`
+   * sale como `clave=valor`, y un objeto o un array se serializan porque el tipado del
+   * cliente los reconoce por la forma.
+   */
+  const mandar = (comando) => {
+    const { command, ...resto } = comando;
+    const pares = Object.entries(resto).map(([k, v]) =>
+      `${k}=${typeof v === "object" && v !== null ? JSON.stringify(v) : String(v)}`,
+    );
+    return execFileSync("node", [cliente, command, ...pares], { encoding: "utf8" }).trim();
+  };
   const esperar = (segundos) => execFileSync("sleep", [String(segundos)]);
 
   /**
@@ -380,18 +436,37 @@ function exigirAparato() {
        * hay que volver a preguntar. Tres órdenes encadenadas por el modelo son tres viajes;
        * ésta es una.
        */
-      if (args.includes("--captura")) {
+      /**
+       * **El log ANTES que la captura, y por un fallo visto en vivo.**
+       *
+       * El orden era al revés y producía una foto que engaña: la app contesta el árbol, se
+       * cae mientras se pide la captura, y lo que sale fotografiado es la **pantalla del
+       * propio servidor hotswap** —«Applications / MyAllXOne / Explore / Delete», con
+       * «Awaiting connection…» abajo—. Eso no es la app, y quien lo mire después no tiene
+       * forma de saberlo: parece una app en blanco. Ocurrió con un `--captura` real y el
+       * usuario lo cazó mirando el artefacto.
+       *
+       * Cuando XOne ha reventado al cargar, la respuesta entera está en el LOG y la captura
+       * solo añade ruido —y 3.375 tokens si alguien se la enseña al revisor visual—. Así que
+       * primero se mira el log; si reventó, se cuenta y NO se captura.
+       */
+      const roto = excepcionDeXOne();
+      if (args.includes("--captura") && roto === undefined) {
         try {
           console.log(mandar({ command: "getScreenshot" }));
         } catch {
           console.error("la app arrancó pero la captura falló; el árbol de arriba sí es bueno.");
         }
+      } else if (args.includes("--captura")) {
+        console.error(
+          "NO capturo: XOne reventó al cargar y lo que saldría en la foto es la pantalla del " +
+            "host, no tu app. Lo que pasó está en el log de aquí abajo.",
+        );
       }
       // **Estar VIVA no es estar BIEN.** Una app que revienta al cargar la configuración se
       // queda con su diálogo de error delante, y el canal contesta igual: el árbol llega, la
       // captura sale, y todo parece haber ido bien. Quien lo cuenta es el log, y no pedirlo
       // aquí obliga a que alguien se acuerde de hacerlo — que es justo lo que no pasa.
-      const roto = excepcionDeXOne();
       if (roto !== undefined) {
         console.error("");
         console.error("La app ARRANCÓ pero XOne lanzó una excepción al cargar:");

package/skills/xone-hotswap/scripts/xone-hotswap

@@ -95,9 +95,18 @@ if (pedidos.length === 0 || pedidos.includes("--help") || pedidos.includes("-h")
   // un viaje y deja al modelo adivinando argumentos.
   console.error(`xone-hotswap — manda comandos al servidor hotswap de la app (WebSocket).
 
-  xone-hotswap '{"command":"getAllElements","format":"xone"}'
-  xone-hotswap '{"command":"getScreenshot"}'           la captura va a $XONECODE_ARTEFACTOS
-  xone-hotswap '{"command":"click","name":"MAP_BT"}'   varios comandos, en orden, si pasas varios
+  xone-hotswap click name=MAP_BT
+  xone-hotswap waitForElement name=BTN_OK timeout=5000 -- click name=BTN_OK
+  xone-hotswap screen                        en qué pantalla estás (barato)
+  xone-hotswap elements                      el árbol de controles (va a $XONECODE_HOTSWAP)
+  xone-hotswap shot                          la captura va a $XONECODE_ARTEFACTOS
+  xone-hotswap shot name=MAP_ACEPTAR scale=0.5 quality=40     recortada a un control
+  xone-hotswap sql MiApp "SELECT * FROM CLIENTES LIMIT 20"
+
+Cada comando es "<nombre> clave=valor ..."; con -- se encadenan varios por la MISMA
+conexion, que es lo que hay que hacer (el servidor admite una sola y cierra la anterior).
+Los valores se tipan solos: número, true/false y {...}/[...] como JSON.
+Con --dry-run se imprime lo que se enviaría, sin conectar.
 
 Antes, en Android, hace falta el túnel: adb forward tcp:8443 tcp:8443
 Una respuesta larga no se imprime: una IMAGEN va a $XONECODE_ARTEFACTOS (y sale en el chat),
@@ -107,13 +116,124 @@ El catálogo entero de comandos está en el SKILL.md de xone-hotswap.`);
   process.exit(pedidos.length === 0 ? 1 : 0);
 }
 
+/**
+ * De `clave=valor` a los objetos del protocolo, con `--` separando comandos.
+ *
+ * **POR QUÉ SE FUE EL JSON.** Antes cada comando era un objeto JSON entre comillas
+ * (`'{"command":"click","name":"BTN_OK"}'`). Medido sobre cinco comandos típicos, esta
+ * sintaxis los escribe en un **38 % menos de caracteres** —un `click` pasa de 37 a 17— y
+ * quita el escapado, que es donde un modelo se equivoca y gasta un viaje en volver a
+ * intentarlo. No se aceptan las dos: una capa de compatibilidad es deuda desde el primer día,
+ * y el JSON solo se escribía dentro de esta misma skill.
+ *
+ * Los valores se TIPAN solos —número, `true`/`false`, y `{…}`/`[…]` como JSON— porque el
+ * protocolo distingue `timeout=5000` de `"5000"` y `where={"ID":"7"}` es un objeto. Lo que no
+ * encaje en ninguno se queda como cadena, que es lo que casi todo es.
+ */
+function valorTipado(bruto) {
+  if (bruto === "true") return true;
+  if (bruto === "false") return false;
+  if (bruto !== "" && !Number.isNaN(Number(bruto))) return Number(bruto);
+  if (/^[{[]/.test(bruto)) {
+    try {
+      return JSON.parse(bruto);
+    } catch {
+      salir(`«${bruto.slice(0, 60)}» empieza como JSON pero no lo es`);
+    }
+  }
+  return bruto;
+}
+
+/**
+ * Los ATAJOS, que existen para lo que si no cuesta dos viajes o un base64 a mano.
+ *
+ * Cada uno es exactamente un comando del protocolo con sus campos ya puestos: no añaden
+ * capacidades, quitan la parte que se escribe mal. `shot` es el que más se nota — decodifica
+ * el JPEG y lo deja donde el harness lo anuncia.
+ */
+const ATAJOS = {
+  elements: (resto) => ({ command: "getAllElements", format: resto[0] ?? "xone" }),
+  screen: () => ({ command: "getCurrentScreen" }),
+  shot: (resto) => aplicarPares({ command: "getScreenshot" }, resto),
+  tables: (resto) => ({ command: "getDatabaseTableNames", appName: resto[0] }),
+  sql: (resto) => ({ command: "runSql", appName: resto[0], sql: resto.slice(1).join(" ") }),
+};
+
+function aplicarPares(json, pares) {
+  for (const par of pares) {
+    const corte = par.indexOf("=");
+    if (corte <= 0) salir(`«${par}» no es clave=valor`);
+    json[par.slice(0, corte)] = valorTipado(par.slice(corte + 1));
+  }
+  return json;
+}
+
+/**
+ * `--dry-run`: imprime lo que se enviaría y no conecta.
+ *
+ * No es comodidad: es lo que hace comprobable el tipado de los valores sin un aparato
+ * delante —`timeout=5000` tiene que salir como número y `where={...}` como objeto, y si salen
+ * como cadena el servidor los rechaza sin decir por qué—. También deja probar un comando
+ * escrito a mano antes de gastarle un viaje al canal.
+ */
+const seco = pedidos.includes("--dry-run");
+const utiles = pedidos.filter((a) => a !== "--dry-run");
+
 const comandos = [];
-for (const arg of pedidos) {
-  try {
-    comandos.push(JSON.parse(arg));
-  } catch {
-    salir(`no es JSON válido: ${arg.slice(0, 80)}`);
+for (const trozo of partirPorSeparador(utiles)) {
+  const [cabeza, ...resto] = trozo;
+  /**
+   * **El JSON viejo se RECHAZA con la forma buena escrita, nunca se acepta a medias.**
+   *
+   * Al quitar el JSON, una llamada con la sintaxis de antes no fallaba: metía el objeto
+   * ENTERO como nombre del comando y mandaba
+   * `{"command":"{\"command\":\"getAllElements\",…}"}`. El aparato contestaba
+   * `Unknown command: {"command":"getAllElements","format":"xone"}` —visto en pantalla— y
+   * quien lo leyera no tenía forma de saber que el problema era la sintaxis del cliente y no
+   * el comando: parecía que el framework no conocía `getAllElements`. Un fallo que miente
+   * sobre dónde está invita a reintentar, y reintentar es lo que cuesta.
+   *
+   * No se ACEPTA —eso era la capa de compatibilidad que se decidió no tener— pero tampoco se
+   * traga: se dice qué escribir, que es el patrón de `porQueNo` y el de `xone_navegacion`
+   * cuando no sabe contestar.
+   */
+  if (cabeza.startsWith("{")) {
+    let comoJson;
+    try {
+      comoJson = JSON.parse(cabeza);
+    } catch {
+      comoJson = undefined;
+    }
+    const nombre = typeof comoJson?.command === "string" ? comoJson.command : undefined;
+    const pares = nombre
+      ? Object.entries(comoJson)
+          .filter(([k]) => k !== "command")
+          .map(([k, v]) => `${k}=${typeof v === "object" ? JSON.stringify(v) : String(v)}`)
+          .join(" ")
+      : "";
+    salir(
+      `este cliente ya NO recibe JSON. Escríbelo como "<comando> clave=valor".` +
+        (nombre ? `\n  Lo que querías es:  xone-hotswap ${nombre}${pares ? ` ${pares}` : ""}` : "") +
+        `\n  Y con -- se encadenan varios por la misma conexión. Mira --help.`,
+    );
   }
+  const atajo = ATAJOS[cabeza];
+  comandos.push(atajo ? atajo(resto) : aplicarPares({ command: cabeza }, resto));
+}
+
+if (seco) {
+  for (const c of comandos) console.log(JSON.stringify(c));
+  process.exit(0);
+}
+
+/** Parte `a x=1 -- b y=2` en `[["a","x=1"],["b","y=2"]]`. Un `--` suelto no abre comando. */
+function partirPorSeparador(args) {
+  const trozos = [[]];
+  for (const a of args) {
+    if (a === "--") trozos.push([]);
+    else trozos[trozos.length - 1].push(a);
+  }
+  return trozos.filter((t) => t.length > 0);
 }
 
 
@@ -230,6 +350,29 @@ ws.onmessage = (ev) => {
     siguiente();
     return;
   }
+  /**
+   * **Las tramas PUSH no son la respuesta de nadie, y tragárselas DESINCRONIZA el canal.**
+   *
+   * El protocolo **no correla peticiones con respuestas**: no hay identificador de comando,
+   * así que se emparejan por ORDEN —se manda de uno en uno y se toma la siguiente trama que
+   * no sea un push—. Eso lo documenta el cliente del equipo del framework
+   * (`pack_ia/scripts/hotswap-cli.mjs`), y aquí solo se filtraba el saludo.
+   *
+   * La consecuencia de que falten las otras dos no es perder una línea: es que **el push se
+   * cuenta como la respuesta del comando pendiente y TODO lo que viene después va
+   * desfasado** — cada comando recibe la contestación del anterior. Y no falla siempre, solo
+   * cuando llega un push en medio, que es lo que lo hace difícil de ver.
+   *
+   * Las dos que faltaban:
+   *  - `logger: true` — una línea de log que el aparato empuja. Las produce cualquier cosa
+   *    que encienda el registro, o sea justo lo que se hace para diagnosticar.
+   *  - `state` — el progreso de una descarga.
+   */
+  if (mensaje.logger === true || mensaje.state !== undefined || mensaje.command === "server_hello") {
+    // No se imprime: quien pidió un comando no pidió esto, y meterlo en la salida es meterlo
+    // en el contexto del agente. Lo que se conserva es el ORDEN.
+    return;
+  }
   console.log(JSON.stringify({ comando: pendiente?.command, ...sinBinarios(mensaje) }));
   pendiente = undefined;
   siguiente();