xonecode 0.20.3 → 0.22.0

package/dist/web/servidor/arranque.js

@@ -53,8 +53,9 @@ import { lanzarEnDispositivo, } from "../../agent/dispositivos/lanzamientoEnMaqu
 import { motivoDeBloqueo, puedeLanzarse, } from "../../core/puedeLanzarse.js";
 import { PLATAFORMAS_DE_DISPOSITIVO } from "../../core/settings.js";
 import { instalarHerramientaDeDispositivos, verificarDispositivo } from "../../agent/dispositivos/dispositivosEnMaquina.js";
-import { arrancarEmulador } from "../../agent/dispositivos/arranqueDeEmulador.js";
-import { correrPasoDeReceta } from "../../agent/dispositivos/instalacionEnMaquina.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 { abrirCarpetaDelSistema, abrirDirectorioDelSistema } from "../../agent/config/selectorEnMaquina.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";
@@ -65,10 +66,10 @@ 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, guardarEntorno as guardarEntornoEnDisco, olvidarEntornoDeSettings, copiasDeEntorno, borrarCopiasDeEntorno, } from "../../agent/config/settingsEnDisco.js";
+import { cargarSettings, guardarConcurrenciaDeTareas, guardarDepurar, 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 { mudarWorkspaceLegado } from "../../agent/config/mudanzaEnDisco.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 { abrirEnSistema, olvidarEntorno as olvidarCredencialesDeEntorno, rutaAuthPorDefecto } from "../../agent/cloudstudio/cloudstudioMcp.js";
@@ -107,7 +108,7 @@ import { baseDeWorkspaceLegada, baseDeWorkspacePorOmision, conexionDeVestibulo,
 // doblan.
 import { filaDeTarea } from "./transporte.js";
 import { esEsfuerzo, nivelesDeEsfuerzo } from "../../core/esfuerzo.js";
-import { CATALOGO_DE_CONECTORES, definicionDelCable, RUTA_CALLBACK_MCP } from "../../core/conectores.js";
+import { CATALOGO_DE_CONECTORES, conectoresParaElAgente, definicionDelCable, RUTA_CALLBACK_MCP } from "../../core/conectores.js";
 import { servicioDeConectoresCableado } from "../../agent/conectores/servicioDeConectores.js";
 import { crearGestorJira } from "../../agent/conectores/gestorJira.js";
 import { crearGestorNotion } from "../../agent/conectores/gestorNotion.js";
@@ -1020,6 +1021,14 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
             })),
         };
     };
+    /**
+     * El último progreso de la mudanza del workspace EN MARCHA, o ausente. Existe para la ráfaga:
+     * un navegador que reconecta a mitad de una copia larga tira la mudanza al caerse el cable
+     * (`store.ts#marcarDesconectado`) y el `resultado` solo va a quien está conectado al acabar,
+     * así que sin esto no sabría que sigue una —y los controles del workspace se le quedarían
+     * sueltos mientras el servidor niega cualquier otro cambio—.
+     */
+    let ultimoProgresoDeMudanza;
     /**
      * Engancha el cable a la consola que toque, con el transcript entero por delante.
      *
@@ -1114,6 +1123,8 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
                 cliente(tareas);
             if (workspace !== undefined)
                 cliente(workspace);
+            if (ultimoProgresoDeMudanza !== undefined)
+                cliente({ clase: "mudanzaDeWorkspace", progreso: ultimoProgresoDeMudanza });
             if (depuracion !== undefined)
                 cliente(depuracion);
             if (conectores !== undefined)
@@ -1124,12 +1135,13 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
                     modelo: consumoDeLaSesion.modelo,
                     externo: consumoDeLaSesion.externo,
                     ventana: ventanaDeAhora(consumoDeLaSesion.contexto),
+                    ...(consumoDeLaSesion.porModelo === undefined ? {} : { porModelo: consumoDeLaSesion.porModelo }),
                 });
             }
             // La foto de la máquina, si ya se tomó. Si no, se dispara abajo UNA vez y llega a
             // todos por el SSE cuando termine: no se espera aquí, que son varios procesos.
             if (informeDeDispositivos !== undefined) {
-                cliente({ clase: "dispositivos", informe: informeDeDispositivos, ajustes: ajustesDeDispositivos() });
+                cliente(mensajeDeDispositivos(informeDeDispositivos));
             }
             // Y si hay turno corriendo, se dice: quien conecta a mitad no vio el mensaje que lo
             // anunció, y sin esto vería el compositor encendido y sin borde —«no pasa nada»—
@@ -1274,6 +1286,8 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
             ? { clase: "workspace", ruta }
             : { clase: "workspace", ruta, puedeElegir: true };
     };
+    /** Hay una mudanza del workspace en marcha: una segunda se niega, y crear una tarea también. */
+    let mudandoWorkspace = false;
     const emitirWorkspace = () => {
         const m = mensajeDeWorkspace();
         if (m !== undefined)
@@ -1662,6 +1676,30 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
     };
     /** Los ajustes de destino, o `{}` —que es «se miran todos»— si esta ejecución no los lee. */
     const ajustesDeDispositivos = () => opciones.ajustesDeDispositivos?.() ?? {};
+    /**
+     * Qué dispositivo tiene elegido CADA consola abierta, no solo la del foco: con dos proyectos
+     * abiertos sobre dos emuladores, lo que la PASTILLA del chat tiene que poder decir es «este lo usa Tienda».
+     *
+     * Se pregunta a las consolas vivas y no se guarda, igual que `sesionesTrabajando`: es un
+     * estado de este instante. El `proyecto` es el SEGMENTO de su carpeta —el mismo nombre que ya
+     * viaja en el lanzamiento (`medirLanzable`) y que enseña la barra—, nunca la ruta: `sinRutas`.
+     * **Límite declarado**: va por `basename(raiz)`, así que el mismo nombre de proyecto en dos
+     * entornos (`<entorno>/<proyecto>`) se confunde.
+     */
+    const dispositivosEnUso = () => vestibulo
+        .proyectosAbiertos()
+        .flatMap((c) => (c.dispositivo === undefined ? [] : [{ id: c.dispositivo.id, proyecto: basename(c.raiz) }]));
+    /**
+     * El mensaje `dispositivos` entero, compuesto en UN sitio: la foto, los ajustes leídos AHORA y
+     * quién usa qué. Con cada emisor montando el suyo, uno se quedaba sin el campo nuevo —una
+     * pestaña que reconecta, o una verificación, borrarían el «en uso» de la pantalla—.
+     */
+    const mensajeDeDispositivos = (informe) => ({
+        clase: "dispositivos",
+        informe,
+        ajustes: ajustesDeDispositivos(),
+        enUso: dispositivosEnUso(),
+    });
     let deteccionEnVuelo;
     /**
      * Cómo acabó el último «Arrancar». Viaja con la foto porque el resultado de arrancar ES la
@@ -1678,10 +1716,24 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
         deteccionEnVuelo = (async () => {
             try {
                 informeDeDispositivos = sinRutas(await detectar());
+                // Cada AVD necesita SU puerto, y fijado —también el único, en silencio—: una propuesta que
+                // se recalculara al crear otro AVD le movería el puerto a uno que ya se usa. Se siembra
+                // ANTES de emitir para que la foto salga con los puertos ya puestos, y releyendo después
+                // (`ajustesDeDispositivos` va al disco): lo emitido es lo que quedó escrito. Un AVD recién
+                // creado desde Ajustes recibe el suyo aquí, en la medida que cierra su trabajo.
+                const pendientes = asignarPuertosPendientes(informeDeDispositivos.avds, ajustesDeDispositivos());
+                if (pendientes !== undefined && opciones.guardarPuertosAsignados !== undefined) {
+                    try {
+                        opciones.guardarPuertosAsignados(pendientes);
+                    }
+                    catch (error) {
+                        // No impide emitir: la foto sigue siendo verdad, y sin puerto guardado el AVD usa el
+                        // de fábrica, que es lo que había antes. Lo que no se puede es callarlo.
+                        informar(`no se pudieron guardar los puertos de los emuladores (${codigoDe(error)})`);
+                    }
+                }
                 emitir({
-                    clase: "dispositivos",
-                    informe: informeDeDispositivos,
-                    ajustes: ajustesDeDispositivos(),
+                    ...mensajeDeDispositivos(informeDeDispositivos),
                     ...(ultimoArranque === undefined ? {} : { arranque: ultimoArranque }),
                 });
             }
@@ -1732,7 +1784,9 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
         }
         arranqueEnVuelo = avd;
         try {
-            const r = await arrancar(avd);
+            // «Sin ventana» es un ajuste de ESE AVD (Ajustes → Dispositivos), leído al arrancar y no
+            // del cliente: lo que se pulsa es «Arrancar», y cómo se arranca ya está elegido.
+            const r = await arrancar(avd, { sinVentana: ajustesDeDispositivos().avds?.[avd]?.sinVentana === true });
             ultimoArranque = { avd, ...r };
         }
         catch (error) {
@@ -1797,7 +1851,80 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
             ...informeDeDispositivos,
             dispositivos: informeDeDispositivos.dispositivos.map((d) => (d.id === id ? { ...d, verificado } : d)),
         };
-        emitir({ clase: "dispositivos", informe: informeDeDispositivos, ajustes: ajustesDeDispositivos() });
+        emitir(mensajeDeDispositivos(informeDeDispositivos));
+    };
+    /**
+     * **Lo de UN AVD: su puerto del túnel y si arranca sin ventana.**
+     *
+     * El nombre llega por el cable, así que tiene que estar en NUESTRA última medida (la misma
+     * guarda que «Arrancar»): guardar ajustes de un AVD que no existe llenaría `settings.json` de
+     * nombres que nadie ve. El puerto pasa por `motivoDePuertoInaceptable` contra los ajustes de
+     * AHORA —dos AVD con el mismo puerto son el fallo que todo esto viene a quitar—, y la negativa
+     * se dice sin guardar NADA del mensaje, tampoco el `sinVentana` que viniera con él: medio
+     * cambio aplicado es un cambio que nadie pidió.
+     *
+     * No se vuelve a medir: el ajuste no cambia la máquina. Se reemite la foto que hay con los
+     * ajustes releídos, que es lo que el campo tiene que enseñar.
+     */
+    const atenderAjusteDeAvd = async (avd, cambio) => {
+        const guardar = opciones.guardarAjusteDeAvd;
+        if (guardar === undefined) {
+            informar("esta ejecución no puede guardar los ajustes de los emuladores");
+            return;
+        }
+        if (informeDeDispositivos === undefined)
+            await atenderDispositivos().catch(contar);
+        if (informeDeDispositivos === undefined || !informeDeDispositivos.avds.includes(avd)) {
+            informar(`no consta ningún AVD llamado «${avd}» en la última medida`);
+            return;
+        }
+        if (cambio.puerto !== undefined) {
+            const motivo = motivoDePuertoInaceptable(cambio.puerto, avd, ajustesDeDispositivos());
+            if (motivo !== undefined) {
+                informar(`no se cambió el puerto de ${avd}: ${motivo}`);
+                return;
+            }
+        }
+        try {
+            guardar(avd, cambio);
+        }
+        catch (error) {
+            informar(`no se pudieron guardar los ajustes de ${avd} (${codigoDe(error)})`);
+            return;
+        }
+        emitir(mensajeDeDispositivos(informeDeDispositivos));
+    };
+    /**
+     * **Parar un emulador**, por su serie de la última medida y solo si ES un emulador: la serie
+     * acaba siendo un argumento de `adb`, y un físico no se «para» desde aquí. Al acabar se mide
+     * SIEMPRE, como al arrancar: la foto es la que dice si se paró.
+     */
+    const atenderParadaDeEmulador = async (id) => {
+        const parar = opciones.pararEmulador;
+        if (parar === undefined) {
+            informar("esta ejecución no puede parar emuladores");
+            return;
+        }
+        if (informeDeDispositivos === undefined)
+            await atenderDispositivos().catch(contar);
+        const dispositivo = informeDeDispositivos?.dispositivos.find((d) => d.id === id);
+        if (dispositivo === undefined || dispositivo.clase !== "emulador") {
+            informar(`no consta ningún emulador «${id}» en la última medida`);
+            return;
+        }
+        try {
+            const r = await parar(dispositivo.id);
+            if (!r.ok)
+                informar(`no se pudo parar ${dispositivo.nombre}: ${r.detalle}`);
+        }
+        catch (error) {
+            // El puerto promete no lanzar; si lo hace, se cuenta y se mide igual.
+            informar(`no se pudo parar ${dispositivo.nombre} (${codigoDe(error)})`);
+        }
+        finally {
+            informeDeDispositivos = undefined;
+            await atenderDispositivos().catch(contar);
+        }
     };
     const atenderCatalogo = async (proveedor) => {
         if (!proveedorConocido(proveedor))
@@ -2203,6 +2330,7 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
             modelo: alAbrir?.modelo ?? SIN_CONSUMO,
             externo: alAbrir?.externo ?? SIN_CONSUMO,
             ventana: ventanaDeAhora(alAbrir?.contexto ?? 0),
+            ...(alAbrir?.porModelo === undefined ? {} : { porModelo: alAbrir.porModelo }),
         });
         // Y la cola se vuelve a mirar: este proyecto queda bloqueado para las tareas —gana la
         // persona— y el que estuviera abierto antes acaba de quedar libre.
@@ -2925,7 +3053,17 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
             // doble mal hecho, o un bug suyo en el camino síncrono— dejaría el recorrido en
             // `corriendo` para siempre y el botón muerto, que es justo lo que este `try` existe para
             // evitar. Su contrato es no lanzar nunca; esto es por si deja de cumplirlo.
-            const enCurso = lanzar({ dispositivo: medida.dispositivo, raiz: medida.abierto.raiz, app: medida.app }, { alFase });
+            const enCurso = lanzar({
+                dispositivo: medida.dispositivo,
+                raiz: medida.abierto.raiz,
+                app: medida.app,
+                // El puerto LOCAL del túnel es el de SU AVD: con dos emuladores y el mismo puerto,
+                // el `adb forward` del segundo le quita el túnel al primero sin error. Un físico no
+                // tiene AVD y va por el de fábrica, que es lo que hace el lanzador sin puerto.
+                ...(medida.dispositivo.avd === undefined
+                    ? {}
+                    : { puerto: puertoDeAvd(ajustesDeDispositivos(), medida.dispositivo.avd) }),
+            }, { alFase });
             trabajo.cancelar = enCurso.cancelar;
             const resultado = await enCurso.terminado;
             // El último SIEMPRE se emite, aunque no haya pasado el plazo: es el que dice cómo acabó.
@@ -3673,40 +3811,25 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
         ultimoProgreso = Date.now();
     };
     /**
-     * Lanza un paso, o cancela el que corre.
+     * El cerrojo compartido: monta `trabajo`, emite el primer progreso y, al terminar, el último y
+     * una medida nueva. Lo usan los pasos de receta y crear un AVD, que son la misma clase de
+     * trabajo (`sdkmanager`/`avdmanager` sobre el mismo SDK): quien llama ya comprobó que no había
+     * otro en marcha.
      *
-     * Al terminar se vuelve a MEDIR, y es lo que decide si el paso queda hecho: lo que diga el
+     * Al terminar se vuelve a MEDIR, y es lo que decide si el trabajo queda hecho: lo que diga el
      * instalador es lo que él cree, y la foto es lo que hay. Es la misma regla que ya sigue
      * `instalar`.
      */
-    const atenderReceta = (mensaje) => {
-        if (mensaje.accion === "cancelar") {
-            trabajo?.cancelar();
-            return;
-        }
-        if (trabajo !== undefined) {
-            // Ya hay uno: se reenvía su estado en vez de lanzar otro.
-            emitirProgreso("corriendo");
-            return;
-        }
-        const correr = opciones.correrPasoDeReceta;
-        if (correr === undefined) {
-            informar("esta ejecución no puede ejecutar pasos de instalación");
-            return;
-        }
-        const enMarcha = correr(mensaje.id, mensaje.paso, (linea) => {
-            if (trabajo === undefined)
-                return;
-            trabajo.lineas.push(linea);
-            // A ritmo: cada emisión manda la cola entera, y por línea sería cuadrático en bytes
-            // con un `sdkmanager` que habla cada pocos milisegundos. Es la misma razón que
-            // `MS_ENTRE_PARCIALES` en la piel web.
-            if (Date.now() - ultimoProgreso >= MS_ENTRE_PROGRESOS)
-                emitirProgreso("corriendo");
-        });
+    const correrTrabajo = (receta, paso, enMarcha, 
+    /**
+     * Lo que el servidor apunta al acabar (la procedencia de un AVD nuevo, los ajustes de uno
+     * eliminado), ANTES del último progreso y de la medida: así la foto que sigue ya lo trae.
+     * Un fallo suyo se dice y no tumba el cierre del trabajo.
+     */
+    alAcabar) => {
         trabajo = {
-            receta: mensaje.id,
-            paso: mensaje.paso,
+            receta,
+            paso,
             titulo: enMarcha.titulo,
             lineas: [],
             cancelar: enMarcha.cancelar,
@@ -3715,6 +3838,12 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
         emitirProgreso("corriendo");
         void (async () => {
             const resultado = await enMarcha.terminado;
+            try {
+                alAcabar?.(resultado);
+            }
+            catch (error) {
+                informar(`no se pudo apuntar lo que cambió al acabar (${codigoDe(error)})`);
+            }
             // El último progreso SIEMPRE se emite, aunque no haya pasado el plazo: es el que
             // completa el log y el que dice cómo acabó.
             ultimoProgreso = 0;
@@ -3725,6 +3854,145 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
             await atenderDispositivos().catch(contar);
         })();
     };
+    /**
+     * Cada línea de la salida, a la cola del trabajo en curso y emitida A RITMO: cada emisión manda
+     * la cola entera, y por línea sería cuadrático en bytes con un `sdkmanager` que habla cada
+     * pocos milisegundos. Es la misma razón que `MS_ENTRE_PARCIALES` en la piel web.
+     */
+    const alSalirLineaDelTrabajo = (linea) => {
+        if (trabajo === undefined)
+            return;
+        trabajo.lineas.push(linea);
+        if (Date.now() - ultimoProgreso >= MS_ENTRE_PROGRESOS)
+            emitirProgreso("corriendo");
+    };
+    /** Lanza un paso, o cancela el que corre. */
+    const atenderReceta = (mensaje) => {
+        if (mensaje.accion === "cancelar") {
+            trabajo?.cancelar();
+            return;
+        }
+        if (trabajo !== undefined) {
+            // Ya hay uno: se reenvía su estado en vez de lanzar otro.
+            emitirProgreso("corriendo");
+            return;
+        }
+        const correr = opciones.correrPasoDeReceta;
+        if (correr === undefined) {
+            informar("esta ejecución no puede ejecutar pasos de instalación");
+            return;
+        }
+        correrTrabajo(mensaje.id, mensaje.paso, correr(mensaje.id, mensaje.paso, alSalirLineaDelTrabajo));
+    };
+    /** ¿Corre ahora el AVD `avd`, según la ÚLTIMA medida? Todo lo que no es «apagado» o «no disponible» cuenta. */
+    const baseEnMarcha = (avd) => (informeDeDispositivos?.dispositivos ?? []).some((d) => d.avd === avd && d.estado !== "apagado" && d.estado !== "no-disponible");
+    /**
+     * **Crear un AVD con nombre**, por el MISMO cerrojo que las recetas y contado igual
+     * (`receta: "crear-avd"`, `paso: 0`): la pantalla ya sabe pintar ese log.
+     *
+     * El nombre acaba siendo un argumento de `avdmanager`, así que se valida aquí con la regla
+     * pura (forma, largo, y que no exista ya en la última medida) antes de lanzar nada; sin medida
+     * no se puede saber si se repite, así que se mide primero. El cerrojo se vuelve a mirar
+     * DESPUÉS de esa espera: mientras se medía pudo arrancar otro trabajo.
+     */
+    const atenderCrearEmulador = async (nombre, base, conDatos) => {
+        if (trabajo !== undefined) {
+            emitirProgreso("corriendo");
+            return;
+        }
+        const crear = opciones.crearAvd;
+        if (crear === undefined) {
+            informar("esta ejecución no puede crear emuladores");
+            return;
+        }
+        if (informeDeDispositivos === undefined)
+            await atenderDispositivos().catch(contar);
+        if (informeDeDispositivos === undefined) {
+            informar("no se creó el emulador: todavía no hay una medida con la que comprobar el nombre");
+            return;
+        }
+        const motivo = motivoDeNombreDeAvdInaceptable(nombre, informeDeDispositivos.avds);
+        if (motivo !== undefined) {
+            informar(`no se creó el emulador: ${motivo}`);
+            return;
+        }
+        if (base !== undefined) {
+            // La base es un NOMBRE que acaba en una ruta: tiene que ser uno de los que la medida vio.
+            if (!informeDeDispositivos.avds.includes(base)) {
+                informar(`no se creó el emulador: ${base} no es un emulador que conozcamos`);
+                return;
+            }
+            // Clonar copia discos que la base tiene bloqueados mientras corre (`multiinstance.lock`);
+            // copiar solo la configuración no los toca y vale con ella encendida.
+            if (conDatos === true && baseEnMarcha(base)) {
+                informar(`no se creó el emulador: ${base} está en marcha; apágalo para clonarlo con lo instalado`);
+                return;
+            }
+        }
+        if (trabajo !== undefined) {
+            emitirProgreso("corriendo");
+            return;
+        }
+        correrTrabajo("crear-avd", 0, crear(nombre, alSalirLineaDelTrabajo, base === undefined ? undefined : { base, conDatos: conDatos === true }), 
+        // La procedencia se GUARDA al acabar bien: «copia de X» (configuración) o «clon de X» (con lo
+        // instalado). Sin base no hay de quién, y un fallo no deja AVD al que apuntarla.
+        base === undefined
+            ? undefined
+            : (r) => {
+                if (r.estado !== "ok")
+                    return;
+                opciones.guardarAjusteDeAvd?.(nombre, { copiaDe: base, ...(conDatos === true ? { clon: true } : {}) });
+            });
+    };
+    /**
+     * **Eliminar un AVD**, por el MISMO cerrojo que crear (`receta: "borrar-avd"`, `paso: 0`). El
+     * nombre llega por el cable y acaba en un argumento de `avdmanager`, así que tiene que ser uno de
+     * los de NUESTRA última medida. Tres negativas, en orden, y cada una se DICE (la del navegador no
+     * llega de vuelta: el cliente aplica las mismas reglas antes y no deja pulsar):
+     *  - nunca el ÚLTIMO: es la base de las copias, y siempre tiene que quedar uno;
+     *  - nunca uno EN MARCHA (el mismo criterio que `baseEnMarcha`): el emulador tiene sus discos
+     *    bloqueados y borrar la carpeta por debajo lo dejaría roto.
+     * Al acabar BIEN se quitan también sus ajustes (puerto, sin ventana, procedencia) para que su
+     * puerto quede libre, y `correrTrabajo` vuelve a medir.
+     */
+    const atenderEliminarEmulador = async (avd) => {
+        if (trabajo !== undefined) {
+            emitirProgreso("corriendo");
+            return;
+        }
+        const borrar = opciones.borrarAvd;
+        if (borrar === undefined) {
+            informar("esta ejecución no puede eliminar emuladores");
+            return;
+        }
+        if (informeDeDispositivos === undefined)
+            await atenderDispositivos().catch(contar);
+        if (informeDeDispositivos === undefined) {
+            informar("no se eliminó el emulador: todavía no hay una medida con la que comprobarlo");
+            return;
+        }
+        if (!informeDeDispositivos.avds.includes(avd)) {
+            informar(`no se eliminó el emulador: ${avd} no es un emulador que conozcamos`);
+            return;
+        }
+        if (informeDeDispositivos.avds.length <= 1) {
+            informar(`no se eliminó ${avd}: es el único: siempre tiene que quedar al menos uno`);
+            return;
+        }
+        if (baseEnMarcha(avd)) {
+            informar(`no se eliminó ${avd}: está en marcha; apágalo para eliminarlo`);
+            return;
+        }
+        // Mientras se medía pudo arrancar otro trabajo.
+        if (trabajo !== undefined) {
+            emitirProgreso("corriendo");
+            return;
+        }
+        correrTrabajo("borrar-avd", 0, borrar(avd, alSalirLineaDelTrabajo), (r) => {
+            if (r.estado === "ok")
+                opciones.quitarAjustesDeAvd?.(avd);
+        });
+    };
     /**
      * Los modelos de un motor externo, para el desplegable de un subagente.
      *
@@ -3911,7 +4179,13 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
         // contador a pintar un cero que nadie ha medido.
         if (c === undefined)
             return;
-        emitir({ clase: "consumo", modelo: c.modelo, externo: c.externo, ventana: ventanaDeAhora(c.contexto) });
+        emitir({
+            clase: "consumo",
+            modelo: c.modelo,
+            externo: c.externo,
+            ventana: ventanaDeAhora(c.contexto),
+            ...(c.porModelo === undefined ? {} : { porModelo: c.porModelo }),
+        });
     };
     /**
      * Cuánto ocupa la ventana y cuál es su tope, si se sabe.
@@ -4888,6 +5162,51 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
             respuesta.end();
             return;
         }
+        if (typeof mensaje === "object" &&
+            mensaje !== null &&
+            mensaje.clase === "eliminarEmulador" &&
+            typeof mensaje.avd === "string") {
+            void atenderEliminarEmulador(mensaje.avd).catch(contar);
+            respuesta.writeHead(204);
+            respuesta.end();
+            return;
+        }
+        if (typeof mensaje === "object" &&
+            mensaje !== null &&
+            mensaje.clase === "crearEmulador" &&
+            typeof mensaje.nombre === "string" &&
+            (mensaje.base === undefined || typeof mensaje.base === "string") &&
+            (mensaje.conDatos === undefined || typeof mensaje.conDatos === "boolean")) {
+            // Suelto, como la receta: el progreso y la foto de después viajan por el SSE.
+            void atenderCrearEmulador(mensaje.nombre, mensaje.base, mensaje.conDatos).catch(contar);
+            respuesta.writeHead(204);
+            respuesta.end();
+            return;
+        }
+        if (typeof mensaje === "object" &&
+            mensaje !== null &&
+            mensaje.clase === "ajusteDeAvd" &&
+            typeof mensaje.avd === "string" &&
+            (mensaje.puerto === undefined || typeof mensaje.puerto === "number") &&
+            (mensaje.sinVentana === undefined || typeof mensaje.sinVentana === "boolean")) {
+            // Campo a campo: lo que no es un número o un booleano no llega a `settings.json`.
+            void atenderAjusteDeAvd(mensaje.avd, {
+                ...(mensaje.puerto === undefined ? {} : { puerto: mensaje.puerto }),
+                ...(mensaje.sinVentana === undefined ? {} : { sinVentana: mensaje.sinVentana }),
+            }).catch(contar);
+            respuesta.writeHead(204);
+            respuesta.end();
+            return;
+        }
+        if (typeof mensaje === "object" &&
+            mensaje !== null &&
+            mensaje.clase === "pararEmulador" &&
+            typeof mensaje.id === "string") {
+            void atenderParadaDeEmulador(mensaje.id).catch(contar);
+            respuesta.writeHead(204);
+            respuesta.end();
+            return;
+        }
         /**
          * ANTES del `recibir` de la consola, y también antes que las demás clases de tarea: por
          * aquí no entra nada hacia ningún turno. Ver `atenderMirar`.
@@ -4904,6 +5223,13 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
             return;
         }
         if (typeof mensaje === "object" && mensaje !== null && mensaje.clase === "tarea") {
+            if (mensaje.accion === "crear" && mudandoWorkspace) {
+                // Una tarea creada a mitad de la mudanza guardaría la raíz VIEJA, que está a punto de
+                // borrarse. Se niega con motivo, como cualquier otra negativa del cable.
+                respuesta.writeHead(409, { "content-type": "application/json" });
+                respuesta.end(JSON.stringify({ motivo: "se está cambiando la carpeta de los proyectos: crea la tarea cuando termine" }));
+                return;
+            }
             if (mensaje.accion === "crear" && opciones.colaDeTareas !== undefined) {
                 const creada = atenderCrearTarea(mensaje.proyecto, mensaje.peticion, mensaje.encargo, mensaje.borrador);
                 if (creada !== undefined) {
@@ -4964,9 +5290,84 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
              * Y se reemite SIEMPRE, se haya escrito o no: con el valor nuevo cuando valió y con el
              * de antes cuando no, así el campo acaba enseñando lo que hay en disco y no lo que se
              * tecleó. Un rechazo mudo dejaría la pantalla afirmando un ajuste que no está puesto.
+             *
+             * **Y cambiarla MUDA lo que ya está bajado**, en dos actos (`vestibulo.mudarWorkspace`):
+             * `planear` contesta en la PROPIA respuesta qué se movería —por nombre y entorno, nunca
+             * una ruta— o por qué no se puede, sin tocar nada; `aplicar` (o sin `accion`) contesta
+             * 204 en el acto y el recorrido llega por `mudanzaDeWorkspace`, porque copiar y
+             * verificar cientos de megas no cabe en una petición. La negativa que se sabe ANTES
+             * de empezar —una ruta que no vale, una mudanza ya en marcha— va en un 409 con motivo.
              */
-            opciones.guardarWorkspace?.(mensaje.ruta);
-            emitirWorkspace();
+            const negarWorkspace = (motivo) => {
+                respuesta.writeHead(409, { "content-type": "application/json" });
+                respuesta.end(JSON.stringify({ motivo }));
+            };
+            const tareasVivas = () => (opciones.colaDeTareas?.listar() ?? []).map((t) => ({ estado: t.estado, raiz: t.proyecto.raiz }));
+            const resuelta = opciones.resolverWorkspace?.(mensaje.ruta);
+            if (resuelta === undefined || opciones.casaXonecode === undefined) {
+                // Esta ejecución no sabe mudar: el comportamiento de siempre, solo escribir el ajuste.
+                opciones.guardarWorkspace?.(mensaje.ruta);
+                emitirWorkspace();
+                respuesta.writeHead(204);
+                respuesta.end();
+                return;
+            }
+            if ("motivo" in resuelta) {
+                emitirWorkspace();
+                negarWorkspace(resuelta.motivo);
+                return;
+            }
+            if (mensaje.accion === "planear") {
+                const plan = vestibulo.planearWorkspace(resuelta.ruta, opciones.casaXonecode, tareasVivas());
+                let megas;
+                if (plan.motivo === undefined && plan.mudanzas.length > 0) {
+                    megas = await megasDeLasMudanzas(plan.mudanzas).catch(() => undefined);
+                }
+                respuesta.writeHead(200, { "content-type": "application/json" });
+                respuesta.end(JSON.stringify({
+                    proyectos: plan.mudanzas.map((m) => ({ entorno: m.entorno, proyecto: m.proyecto })),
+                    ...(megas === undefined ? {} : { megas }),
+                    ...(plan.motivo === undefined ? {} : { motivo: plan.motivo }),
+                }));
+                return;
+            }
+            if (mudandoWorkspace) {
+                negarWorkspace("ya hay un cambio de carpeta en marcha: espera a que termine");
+                return;
+            }
+            mudandoWorkspace = true;
+            const casaXonecode = opciones.casaXonecode;
+            const guardar = opciones.guardarWorkspace ?? (() => { });
+            void (async () => {
+                try {
+                    const { resultado, cerroLaAbierta } = await vestibulo.mudarWorkspace({
+                        hacia: resuelta.ruta,
+                        casaXonecode,
+                        tareas: tareasVivas,
+                        guardar,
+                        progreso: (progreso) => {
+                            ultimoProgresoDeMudanza = progreso;
+                            emitir({ clase: "mudanzaDeWorkspace", progreso });
+                        },
+                    });
+                    // El cable se quedaría enganchado a una consola cerrada: al vestíbulo, como al
+                    // borrar una copia. El alta siguiente ya trae las copias en la base nueva.
+                    if (cerroLaAbierta)
+                        adjuntar();
+                    emitir({ clase: "mudanzaDeWorkspace", resultado });
+                }
+                catch (error) {
+                    contar(error);
+                    emitir({ clase: "mudanzaDeWorkspace", resultado: { estado: "rechazado", motivo: "no se pudo cambiar la carpeta" } });
+                }
+                finally {
+                    mudandoWorkspace = false;
+                    ultimoProgresoDeMudanza = undefined;
+                    emitirWorkspace();
+                    opciones.revisarTareas?.();
+                    await anunciarAlta().catch(contar);
+                }
+            })().catch(contar);
             respuesta.writeHead(204);
             respuesta.end();
             return;
@@ -5173,6 +5574,10 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
                 // Suelto: `anunciarAlta` consulta CloudStudio y el `POST` no puede quedarse
                 // esperando por eso. El alta nueva llega por el SSE, como siempre.
                 void anunciarAlta().catch(contar);
+                // Y la foto que hay, sin volver a medir: lo que cambió es QUIÉN usa ese aparato, y
+                // Ajustes lo enseña al lado de cada uno (`enUso`).
+                if (informeDeDispositivos !== undefined)
+                    emitir(mensajeDeDispositivos(informeDeDispositivos));
             }
             respuesta.writeHead(204);
             respuesta.end();
@@ -5696,6 +6101,12 @@ export function ajusteDeWorkspaceCableado(opciones) {
     const guardar = opciones.guardar ?? ((ruta) => void guardarWorkspaceEnDisco(undefined, ruta));
     return {
         workspace: () => leer() ?? baseDeWorkspacePorOmision(),
+        casaXonecode: join(opciones.casa, ".xonecode"),
+        resolverWorkspace: (ruta) => {
+            const absoluta = expandirConCasa(ruta, opciones.casa);
+            const motivo = motivoDeWorkspaceInaceptable(absoluta);
+            return motivo === undefined ? { ruta: absoluta } : { motivo };
+        },
         guardarWorkspace: (ruta) => {
             const absoluta = expandirConCasa(ruta, opciones.casa);
             if (motivoDeWorkspaceInaceptable(absoluta) !== undefined)
@@ -5704,6 +6115,31 @@ export function ajusteDeWorkspaceCableado(opciones) {
         },
     };
 }
+/**
+ * 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
+ * que ningún test mira, y cada uno es un campo OPCIONAL de `montarRutas`, así que olvidarlo o
+ * perder un argumento por el camino compila y pasa.
+ *
+ * `casa` es la del `settings.json` donde se guardan los ajustes por AVD; ausente, la del usuario
+ * (`guardarAjusteDeAvd(undefined, …)`). `arrancar` entra solo para que un test vea qué recibe la
+ * de verdad sin lanzar un emulador.
+ */
+export function emuladoresCableados(opciones = {}) {
+    const arrancar = opciones.arrancar ?? arrancarEmulador;
+    return {
+        arrancarEmulador: (avd, o) => arrancar(avd, {}, o ?? {}),
+        // Con `conDatos` se CLONA la carpeta; sin él, solo la configuración de la base sobre un AVD vacío.
+        crearAvd: (nombre, alSalirLinea, desde) => desde?.conDatos === true
+            ? clonarAvd(desde.base, nombre, { alSalirLinea })
+            : crearAvd(nombre, { alSalirLinea }, desde === undefined ? {} : { base: desde.base }),
+        borrarAvd: (nombre, alSalirLinea) => borrarAvd(nombre, { alSalirLinea }),
+        pararEmulador: (serie) => pararEmulador(serie),
+        guardarAjusteDeAvd: (avd, cambio) => void guardarAjusteDeAvd(opciones.casa, avd, cambio),
+        quitarAjustesDeAvd: (avd) => void quitarAjustesDeAvd(opciones.casa, avd),
+        guardarPuertosAsignados: (asignados) => void guardarPuertosAsignados(opciones.casa, asignados),
+    };
+}
 /**
  * Las dos mitades de la casilla «Depurar», cableadas — extraídas por el MISMO motivo que
  * `ajusteDeWorkspaceCableado`. `leer`/`guardar` entran por parámetro, y no como en el workspace
@@ -5756,8 +6192,28 @@ export function ajusteDeGestorCableado(ajuste) {
         jira: crearGestorJira,
         notion: crearGestorNotion,
     };
+    const sinServicio = () => {
+        throw new Error("esta ejecución no tiene conectores");
+    };
     return {
         conectores: (alCambiar) => (servicio = ajuste.conectores(alCambiar)),
+        conectoresDeSesion: {
+            delProyecto: (raiz) => {
+                if (servicio === undefined)
+                    return [];
+                const proyecto = cargar(raiz).config.proyecto;
+                const lista = servicio.lista();
+                return conectoresParaElAgente({
+                    marcados: proyecto?.conectores ?? [],
+                    gestor: proyecto?.gestorDeTareas?.conector,
+                    anadidos: lista.conectores.map((c) => c.id),
+                    catalogo: lista.catalogo,
+                });
+            },
+            // `async`: sin servicio, el fallo sale como promesa RECHAZADA, que es lo que la tool devuelve como texto.
+            tools: async (id) => (servicio === undefined ? sinServicio() : servicio.tools(id)),
+            llamar: async (id, nombre, args, opciones) => (servicio === undefined ? sinServicio() : servicio.llamar(id, nombre, args, opciones)),
+        },
         gestorDeTareas: (conector) => {
             const fabrica = Object.hasOwn(FABRICAS, conector) ? FABRICAS[conector] : undefined;
             if (fabrica === undefined)
@@ -6005,7 +6461,10 @@ export async function arrancarConsolaWeb(opciones) {
         escribir(`${texto}\n`);
         vestibulo?.consola.consola.escribir(`${texto}\n`);
     };
-    vestibulo = opciones.vestibulo ?? vestibuloReal(opciones, servidor, escribir, informar);
+    // Los conectores y el gestor de tareas, sobre UN servicio —construido luego por `montarRutas`—, y
+    // las sesiones sobre ese mismo: por eso esto va ANTES del vestíbulo, que es quien las abre.
+    const conectoresYGestor = ajusteDeGestorCableado(ajusteDeConectoresCableado({ casa: homedir() }));
+    vestibulo = opciones.vestibulo ?? vestibuloReal(opciones, servidor, escribir, informar, conectoresYGestor.conectoresDeSesion);
     const conVestibulo = vestibulo;
     /**
      * El corredor de tareas y su costura con el cable — `construirCorredorDeTareasCableado`
@@ -6098,7 +6557,8 @@ export async function arrancarConsolaWeb(opciones) {
         // (`ajusteDeConectoresCableado`), nunca un literal aquí dentro.
         // Y el gestor de tareas (IXCODE-11) llama por ESE mismo servicio: los dos salen de
         // `ajusteDeGestorCableado`, que envuelve la fábrica de conectores.
-        ...ajusteDeGestorCableado(ajusteDeConectoresCableado({ casa: homedir() })),
+        conectores: conectoresYGestor.conectores,
+        gestorDeTareas: conectoresYGestor.gestorDeTareas,
         // El selector nativo, solo si este sistema tiene uno. En el que no, la opción no se
         // monta y el botón no llega a existir.
         ...(haySelectorDeCarpeta()
@@ -6166,7 +6626,12 @@ export async function arrancarConsolaWeb(opciones) {
         // nueve veces, y la que el comentario de justo abajo describe para las cuatro del
         // lanzamiento. `montarRutas` lo trata como ausente si falta, así que olvidarlo aquí
         // dejaría el botón diciendo «esta ejecución no puede arrancar emuladores» con todo verde.
-        arrancarEmulador: (avd) => arrancarEmulador(avd),
+        // Los cinco de los emuladores —arrancar, crear, parar, y guardar lo de cada AVD—, con las
+        // funciones REALES y compuestos fuera (`emuladoresCableados`) para que la composición tenga
+        // test: `arrancarEmulador: (avd) => arrancarEmulador(avd)` compilaba igual perdiendo el
+        // «sin ventana», y un campo opcional olvidado aquí deja el botón diciendo «esta ejecución no
+        // puede» con todo en verde.
+        ...emuladoresCableados(),
         /**
          * Las cuatro de «¿se puede lanzar y lánzalo?», compuestas con las funciones REALES.
          *
@@ -6327,10 +6792,10 @@ function esperarInterrupcion() {
 }
 /** El vestíbulo con todas sus piezas reales. Se construye DESPUÉS del servidor porque el
  *  callback de OAuth necesita saber a qué URL devolver al navegador. */
-function vestibuloReal(opciones, servidor, escribir, informar) {
+function vestibuloReal(opciones, servidor, escribir, informar, conectores) {
     // Lo PRIMERO, antes de leer nada de disco: si esto va a fallar, que falle sin haber
     // aplicado credenciales al proceso ni construido medio vestíbulo.
-    const ejecutor = banderaDeEjecutor(opciones);
+    const ejecutor = banderaDeEjecutor(opciones, conectores);
     const cargado = cargar(opciones.cwd);
     aplicarAuth(cargado.auth);
     // La lectura NO se hace aquí: se hace al abrir cada consola, que es lo que hace que una
@@ -6441,12 +6906,18 @@ function vestibuloReal(opciones, servidor, escribir, informar) {
  * O el ejecutor real, o el de pega PEDIDO con `--guion`, o un error. Lo que no hay es una
  * tercera opción muda.
  */
-function banderaDeEjecutor(opciones) {
+export function banderaDeEjecutor(opciones, conectores) {
     if (opciones.guion === true)
         return {};
-    if (opciones.crearEjecutor === undefined) {
+    const crear = opciones.crearEjecutor;
+    if (crear === undefined) {
         throw new Error("esta consola web se montó sin `crearEjecutor`: correría el agente de pega sin decirlo (usa --guion si es lo que quieres)");
     }
-    return { crearEjecutor: opciones.crearEjecutor };
+    // Los conectores se AÑADEN aquí, a todas las consolas —de persona y de tarea—: el vestíbulo no
+    // tiene que acordarse de pasarlos en cada puerta. En una tarea, lo que escriben se rechaza igual
+    // (`consolaDeTarea.ts`).
+    if (conectores === undefined)
+        return { crearEjecutor: crear };
+    return { crearEjecutor: (alAbrir, o) => crear(alAbrir, { ...o, conectores }) };
 }
 //# sourceMappingURL=arranque.js.map