xonecode 0.38.4 → 0.38.11

package/skills/xone-hotswap/lib/dispositivo.mjs

@@ -179,9 +179,55 @@ export function ajusteDelAvd(avd, { casa = homedir(), leer = (r) => readFileSync
   }
 }
 
+/** La forma de un serial de adb. Copia de `core/puertosDeAvd.ts#FORMA_DE_SERIE`. */
+export const FORMA_DE_SERIE = /^[A-Za-z0-9._:-]{1,128}$/;
+
+const puertoValido = (p) => Number.isInteger(p) && p >= 1024 && p <= 65535;
+
+/** `dispositivos` de `~/.xonecode/settings.json`, o `{}`. Se lee en CADA ejecución, como el resto. */
+function ajustesDeDispositivos({ casa = homedir(), leer = (r) => readFileSync(r, "utf8") } = {}) {
+  try {
+    const d = JSON.parse(leer(join(casa, ".xonecode", "settings.json")))?.dispositivos;
+    return typeof d === "object" && d !== null ? d : {};
+  } catch {
+    return {};
+  }
+}
+
+/** Los puertos ya guardados, de AVD y de físicos, con el MISMO filtro que `core/settings.ts`. */
+function puertosGuardados(d) {
+  const usados = new Set();
+  const de = (tabla, forma) => {
+    if (typeof tabla !== "object" || tabla === null) return;
+    for (const [clave, valor] of Object.entries(tabla)) {
+      if (forma.test(clave) && typeof valor === "object" && valor !== null && puertoValido(valor.puerto)) usados.add(valor.puerto);
+    }
+  };
+  de(d.avds, FORMA_DE_NOMBRE_DE_AVD);
+  de(d.fisicos, FORMA_DE_SERIE);
+  return usados;
+}
+
+/**
+ * El puerto de un móvil FÍSICO (IXCODE-32): el guardado para su serie o, sin él, el primero libre
+ * desde el 8443. Antes era siempre el 8443, el mismo que el primer AVD, y el último `adb forward`
+ * se quedaba el puerto: la sesión del móvil hablaba con el emulador sin error. Copia de
+ * `core/puertosDeAvd.ts#puertoDeFisico` (un test compara las dos).
+ */
+export function puertoDeFisico(serie, deps = {}) {
+  const d = ajustesDeDispositivos(deps);
+  const guardado = FORMA_DE_SERIE.test(serie ?? "") ? d.fisicos?.[serie]?.puerto : undefined;
+  if (puertoValido(guardado)) return guardado;
+  const usados = puertosGuardados(d);
+  let candidato = PUERTO_DEL_HOTSWAP;
+  while (usados.has(candidato)) candidato++;
+  return candidato;
+}
+
 /**
  * El puerto LOCAL del túnel. De más explícito a menos: `--puerto`, el guardado del AVD de esta
- * serie, 8443. Misma regla que `core/puertosDeAvd.ts#puertoDeAvd` (un test compara las dos).
+ * serie (o el del físico), 8443. Misma regla que `core/puertosDeAvd.ts#puertoDeDispositivo`
+ * (un test compara las dos).
  */
 export function puertoAndroid(explicito, serie, deps = {}) {
   return puertoConMotivo(explicito, serie, deps).puerto;
@@ -196,6 +242,7 @@ export function puertoAndroid(explicito, serie, deps = {}) {
 export function puertoConMotivo(explicito, serie, deps = {}) {
   const n = Number(explicito);
   if (explicito !== undefined && Number.isInteger(n) && n >= 1024 && n <= 65535) return { puerto: n };
+  if (serie !== undefined && !serie.startsWith("emulator-")) return { puerto: puertoDeFisico(serie, deps) };
   const avd = avdDeLaSerie(serie, deps);
   const guardado = ajusteDelAvd(avd, deps).puerto;
   if (guardado !== undefined) return { puerto: guardado };
@@ -205,6 +252,64 @@ export function puertoConMotivo(explicito, serie, deps = {}) {
   return { puerto: PUERTO_DEL_HOTSWAP };
 }
 
+/** De la salida de `adb forward --list`, la serie que tiene el puerto local `tcp:<puerto>`, o `undefined`. Pura. */
+export function duenoDelPuerto(salidaDeForwardList, puerto) {
+  for (const linea of String(salidaDeForwardList).split(/\r?\n/)) {
+    const [serie, local] = linea.trim().split(/\s+/);
+    if (local === `tcp:${puerto}` && serie) return serie;
+  }
+  return undefined;
+}
+
+/**
+ * ¿De quién es AHORA el túnel de este puerto? (IXCODE-32). La tabla de `adb forward` es de toda la
+ * máquina: si otra sesión, una tarea o una consola le hizo un forward a OTRO aparato en el mismo
+ * puerto, los comandos de ésta irían a ese aparato sin error y el script seguiría diciendo
+ * «dispositivo: el de la sesión». Comprobar la SERIE no basta; hay que comprobar el puerto.
+ *
+ * `propio` (es suyo), `libre` (nadie lo tiene), `ajeno` (con `dueno`) o `desconocido` (adb no
+ * contestó: no se puede afirmar nada y quien llama sigue como antes).
+ */
+export function estadoDelTunel(serie, puerto, { entorno = process.env, ejecutar = ejecutarAdb } = {}) {
+  let salida;
+  try {
+    salida = ejecutar(rutaDeAdb(entorno), ["forward", "--list"]);
+  } catch {
+    return { estado: "desconocido" };
+  }
+  const dueno = duenoDelPuerto(salida, puerto);
+  if (dueno === undefined) return { estado: "libre" };
+  return dueno === serie ? { estado: "propio" } : { estado: "ajeno", dueno };
+}
+
+/**
+ * Comprueba el túnel antes de usarlo, y lo pone si NADIE lo tiene: sale con 2 si es de otro
+ * aparato, y con adb mudo no afirma nada. Devuelve el estado que encontró. `poner` es falso para
+ * quien va a poner el túnel él mismo justo después (desplegar, reiniciar).
+ */
+export function asegurarTunel(serie, puerto, { entorno = process.env, ejecutar = ejecutarAdb, negar = negarYSalir, poner = true } = {}) {
+  const t = estadoDelTunel(serie, puerto, { entorno, ejecutar });
+  if (t.estado === "ajeno") return negar(textoDeTunelAjeno(serie, puerto, t.dueno));
+  if (t.estado === "libre" && poner) {
+    try {
+      ejecutar(rutaDeAdb(entorno), ["-s", serie, "forward", `tcp:${puerto}`, `tcp:${PUERTO_DEL_HOTSWAP}`]);
+      process.stderr.write(`túnel: no estaba puesto; ahora 127.0.0.1:${puerto} → ${serie}\n`);
+    } catch {
+      // Sin túnel la conexión fallará y lo dirá; aquí no hay nada más que afirmar.
+    }
+  }
+  return t;
+}
+
+/** Lo que se dice cuando el puerto lo tiene otro aparato: cuál, y que no se le quita. */
+export function textoDeTunelAjeno(serie, puerto, dueno) {
+  return (
+    `El túnel 127.0.0.1:${puerto} lleva a ${dueno}, no a ${serie}: otra sesión, una tarea o un adb forward a mano ` +
+    "se lo quedó. No se le quita, porque dejaría al otro hablando con este aparato. " +
+    "Comprueba los puertos en Ajustes → Dispositivos o, si ese aparato ya no se usa, desconéctalo."
+  );
+}
+
 /**
  * Retira de los argumentos las opciones que llevan valor (`--puerto 9000`), estén donde estén, y
  * deja el resto INTACTO (incluidos `--` y los `clave=valor`). Solo quita lo que ESTÁ: con un

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

@@ -49,7 +49,7 @@ import { execFileSync } from "node:child_process";
 import { existsSync, readFileSync, readdirSync } from "node:fs";
 import { basename, join, relative, sep } from "node:path";
 import { deflateRawSync } from "node:zlib";
-import { serieAndroid, rutaDeAdb, NODE, dormir, PUERTO_DEL_HOTSWAP, puertoConMotivo } from "../lib/dispositivo.mjs";
+import { serieAndroid, rutaDeAdb, NODE, dormir, PUERTO_DEL_HOTSWAP, puertoConMotivo, asegurarTunel } from "../lib/dispositivo.mjs";
 
 const PAQUETE = "com.xone.android.framework";
 const ACTIVIDAD = `${PAQUETE}/com.xone.android.hotswap.activities.SetupActivity`;
@@ -353,6 +353,8 @@ function exigirAparato() {
 
   exigirAparato();
   console.log(`1/5 túnel: 127.0.0.1:${PUERTO} → ${PUERTO_DEL_HOTSWAP} del aparato`);
+  // Antes de ponerlo, que no sea de OTRO aparato (IXCODE-32): quitárselo dejaría al otro hablando con éste.
+  if (serie !== undefined) asegurarTunel(serie, PUERTO, { poner: false });
   adb("forward", `tcp:${PUERTO}`, `tcp:${PUERTO_DEL_HOTSWAP}`);
 
   console.log("2/5 empaquetando el proyecto (sin .xonecode ni .git)");

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

@@ -56,7 +56,7 @@ process.on("warning", (aviso) => {
 import { mkdirSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { guardarGeometria } from "../lib/geometria.mjs";
-import { dispositivoDeLaSesion, puertoConMotivo, retirarOpciones, serieAndroid, PUERTO_DEL_HOTSWAP } from "../lib/dispositivo.mjs";
+import { asegurarTunel, dispositivoDeLaSesion, puertoConMotivo, retirarOpciones, serieAndroid, PUERTO_DEL_HOTSWAP } from "../lib/dispositivo.mjs";
 
 /**
  * La URL cuando nadie dice `HOTSWAP_URL`: el puerto LOCAL del túnel es del aparato, no un 8443
@@ -69,6 +69,9 @@ function urlPorOmision(puertoPedido, seriePedida) {
   const { serie, porque } = serieAndroid(seriePedida);
   const { puerto, porque: porquePuerto } = puertoConMotivo(puertoPedido, serie);
   if (porquePuerto !== undefined) process.stderr.write(`puerto: ${puerto} (${porquePuerto})\n`);
+  // El puerto puede ser de OTRO aparato aunque la serie sea la buena (IXCODE-32): la tabla de
+  // `adb forward` es de toda la máquina. Se comprueba antes de hablar; con `--puerto` manda quien lo pasó.
+  if (serie !== undefined && puertoPedido === undefined) asegurarTunel(serie, puerto);
   return `wss://127.0.0.1:${puerto}/hotswap`;
 }
 const TOPE_MS = Number(process.env.HOTSWAP_TOPE_MS ?? 40_000);

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

@@ -22,7 +22,7 @@
  */
 import { execFileSync } from "node:child_process";
 import { join } from "node:path";
-import { serieAndroid, rutaDeAdb, NODE, dormir, PUERTO_DEL_HOTSWAP, puertoConMotivo } from "../lib/dispositivo.mjs";
+import { serieAndroid, rutaDeAdb, NODE, dormir, PUERTO_DEL_HOTSWAP, puertoConMotivo, asegurarTunel } from "../lib/dispositivo.mjs";
 
 const PAQUETE = "com.xone.android.framework";
 const ACTIVIDAD = `${PAQUETE}/com.xone.android.hotswap.activities.SetupActivity`;
@@ -102,6 +102,8 @@ exigirAparato();
 console.log(`1/3 túnel (127.0.0.1:${PUERTO} → ${PUERTO_DEL_HOTSWAP} del aparato) y parada de ${PAQUETE}`);
 // El túnel PRIMERO y sin quitarlo después: hay que reaplicarlo tras cada reconexión del cable,
 // así que quitarlo dejaría al siguiente hablando con nadie.
+// Antes de ponerlo, que no sea de OTRO aparato (IXCODE-32): quitárselo dejaría al otro hablando con éste.
+if (serie !== undefined) asegurarTunel(serie, PUERTO, { poner: false });
 adb("forward", `tcp:${PUERTO}`, `tcp:${PUERTO_DEL_HOTSWAP}`);
 adb("shell", "am", "force-stop", PAQUETE);