chocolatito-code 1.6.13 → 1.6.14

package/dist/servidor/fondo.js

@@ -0,0 +1,134 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { spawn, spawnSync } from "node:child_process";
+export function rutaDeLaSesion(home = os.homedir()) {
+    return path.join(home, ".chocolatito", "sesion-web.json");
+}
+export function guardarSesion(datos, home) {
+    const ruta = rutaDeLaSesion(home);
+    fs.mkdirSync(path.dirname(ruta), { recursive: true });
+    fs.writeFileSync(ruta, JSON.stringify(datos, null, 2), "utf-8");
+}
+export function olvidarSesion(home) {
+    try {
+        fs.rmSync(rutaDeLaSesion(home), { force: true });
+    }
+    catch { }
+}
+/**
+ * Si un proceso existe.
+ *
+ * `process.kill(pid, 0)` no mata nada: pregunta. Devuelve sin error si el
+ * proceso esta ahi, ESRCH si no existe, y EPERM si existe pero es de otro
+ * usuario -que para lo que nos importa tambien es "existe"-.
+ */
+export function procesoVivo(pid, matar = process.kill) {
+    if (!Number.isInteger(pid) || pid <= 0)
+        return false;
+    try {
+        matar(pid, 0);
+        return true;
+    }
+    catch (err) {
+        return err?.code === "EPERM";
+    }
+}
+/** La sesion de fondo, solo si de verdad sigue viva. */
+export function sesionViva(home, vivo = (p) => procesoVivo(p)) {
+    try {
+        const datos = JSON.parse(fs.readFileSync(rutaDeLaSesion(home), "utf-8"));
+        if (!datos?.pid || !vivo(datos.pid)) {
+            // El archivo sobrevivio al proceso. Se limpia aqui para que el siguiente
+            // arranque no tenga que decidir otra vez sobre un fantasma.
+            olvidarSesion(home);
+            return null;
+        }
+        return datos;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Se relanza a si mismo, suelto del terminal.
+ *
+ * `detached` + `stdio: ignore` + `unref` son las tres piezas, y las tres hacen
+ * falta: sin detached el hijo muere con el padre en Unix; sin ignorar la salida
+ * el hijo se bloquea en cuanto llene el buffer de una tuberia que ya no lee
+ * nadie; y sin unref el padre se queda esperando al hijo y el terminal no vuelve.
+ */
+export function lanzarEnFondo(argumentos, opciones = {}) {
+    const ejecutable = opciones.ejecutable || process.execPath;
+    const guion = opciones.guion || process.argv[1];
+    const hijo = spawn(ejecutable, [guion, ...argumentos], {
+        cwd: opciones.cwd || process.cwd(),
+        detached: true,
+        stdio: "ignore",
+        windowsHide: true,
+        env: { ...process.env, CHOCOLATITO_EN_FONDO: "1" },
+    });
+    hijo.unref();
+    return hijo.pid ?? 0;
+}
+/**
+ * Para la sesion de fondo. Devuelve que se hizo, en palabras.
+ *
+ * En Windows se mata el arbol entero con taskkill /T: el proceso de Node puede
+ * tener debajo un powershell.exe del control del ordenador o un Chrome del
+ * navegador, y matar solo al padre los deja huerfanos comiendo memoria.
+ */
+export async function pararSesion(home, opciones = {}) {
+    // Quien decide si un PID vive se inyecta ARRIBA y se usa en los dos sitios:
+    // al leer la ficha y al comprobar despues. Con la comprobacion de verdad en la
+    // primera y la inyectada en la segunda, la funcion contestaba una cosa u otra
+    // segun si ese numero de proceso existia por casualidad en la maquina que
+    // corriera las pruebas.
+    const vivo = opciones.vivo || ((pid) => procesoVivo(pid));
+    const esWindows = opciones.esWindows ?? process.platform === "win32";
+    const sesion = sesionViva(home, vivo);
+    if (!sesion) {
+        return { ok: false, mensaje: "No hay ninguna sesion de fondo abierta." };
+    }
+    try {
+        if (esWindows) {
+            // spawnSync Y NO spawn. La primera version lanzaba taskkill sin esperarlo
+            // y salia con process.exit() en la linea siguiente: el hijo no llegaba a
+            // arrancar, el archivo de sesion se borraba, y el programa anunciaba
+            // "Sesion detenida" con la sesion contestando en el puerto tan tranquila.
+            // Se vio en la prueba de verdad: --parar decia que si, y la pagina seguia
+            // dando 200.
+            const ejecutar = opciones.ejecutar ||
+                ((cmd, args) => {
+                    const r = spawnSync(cmd, args, { windowsHide: true, encoding: "utf-8" });
+                    return { ok: r.status === 0, detalle: String(r.stderr || r.stdout || "").trim() };
+                });
+            // /T mata el arbol: debajo puede haber un powershell del control del
+            // ordenador o un Chrome del navegador, y matar solo al padre los deja
+            // huerfanos comiendo memoria.
+            ejecutar("taskkill", ["/pid", String(sesion.pid), "/T", "/F"]);
+        }
+        else {
+            const matar = opciones.matar || ((pid) => process.kill(-pid, "SIGTERM"));
+            matar(sesion.pid);
+        }
+    }
+    catch {
+        // Si ya no estaba, el resultado es el que buscabamos. Se comprueba abajo.
+    }
+    // No se cree lo que diga el comando: se mira si el proceso sigue ahi. Es la
+    // unica forma de no volver a mentir.
+    for (let intento = 0; intento < 20 && vivo(sesion.pid); intento++) {
+        await new Promise((r) => setTimeout(r, 100));
+    }
+    if (vivo(sesion.pid)) {
+        // El archivo se queda: la sesion existe, asi que --estado tiene que seguir
+        // encontrandola para poder intentarlo otra vez o matarla a mano.
+        return {
+            ok: false,
+            mensaje: `No se pudo detener la sesion (pid ${sesion.pid}). Sigue abierta en ${sesion.url}`,
+        };
+    }
+    olvidarSesion(home);
+    return { ok: true, mensaje: `Sesion de fondo detenida (pid ${sesion.pid}).` };
+}

package/dist/servidor/pagina.js

@@ -47,6 +47,31 @@ const PAGINA = [
     'header b { color:var(--zorro); font-weight:600; }',
     '#estado { margin-left:auto; font-size:12px; color:var(--suave); display:flex; align-items:center; gap:6px; }',
     '#punto { width:8px; height:8px; border-radius:50%; background:#d14; transition:background .2s; }',
+    '/* Lo que produce el agente, mirable. max-width en porcentaje y no en pixeles:',
+    '   en un movil en vertical caben 300px justos y una pieza de 1080 rompe el ancho. */',
+    '.mini { margin:6px 0; }',
+    '/* El enlace de guardar, pegado bajo la miniatura y con sitio para el dedo. */',
+    '.guardar { display:inline-flex; align-items:center; gap:6px; margin-top:4px; padding:6px 12px;',
+    '  background:var(--caja); border:1px solid var(--borde); border-radius:999px;',
+    '  color:var(--texto); font-size:12px; text-decoration:none; }',
+    '.guardar:active { border-color:var(--zorro); }',
+    '.mini img, .mini video { max-width:min(100%, 420px); max-height:320px; border-radius:8px;',
+    '  border:1px solid var(--borde); background:#000; display:block; }',
+    '/* Lo que esta a punto de subir, en fila sobre la caja de escribir. */',
+    '#adjuntos { display:flex; gap:6px; overflow-x:auto; padding:6px 12px 0; }',
+    '#adjuntos:empty { display:none; }',
+    '.chip { display:flex; align-items:center; gap:6px; flex:0 0 auto; max-width:60%;',
+    '  background:var(--caja); border:1px solid var(--borde); border-radius:999px; padding:4px 10px; font-size:12px; }',
+    '.chip img { width:22px; height:22px; object-fit:cover; border-radius:4px; }',
+    '.chip span { overflow:hidden; text-overflow:ellipsis; white-space:nowrap; }',
+    '.chip b { color:var(--suave); cursor:pointer; font-weight:400; padding:0 2px; }',
+    '#clip { background:none; border:1px solid var(--borde); color:var(--suave); border-radius:10px;',
+    '  font-size:18px; line-height:1; padding:0 12px; cursor:pointer; }',
+    '/* El velo de arrastrar. pointer-events:none evita el parpadeo: si el velo',
+    '   recibe los eventos, al aparecer dispara dragleave y se va solo. */',
+    '#suelta { position:fixed; inset:0; display:none; place-items:center; z-index:20;',
+    '  background:rgba(11,11,13,.88); color:var(--zorro); font-size:16px; pointer-events:none; }',
+    '#suelta.visible { display:grid; }',
     '#punto.ok { background:#2ea043; }',
     '#salida { flex:1; overflow-y:auto; overflow-x:auto; padding:12px; white-space:pre; -webkit-overflow-scrolling:touch; }',
     '#salida .fila { min-height:1.5em; }',
@@ -84,10 +109,14 @@ const PAGINA = [
     '<header><b>Chocolatito</b><span class="d" style="font-size:12px">Code</span>',
     '<span id="estado"><span id="punto"></span><span id="estadoTexto">conectando</span></span></header>',
     '<div id="salida"></div>',
+    '<div id="adjuntos"></div>',
     '<form id="envio">',
+    '<input id="fichero" type="file" multiple style="display:none">',
+    '<button id="clip" type="button" title="Adjuntar archivos">+</button>',
     '<textarea id="texto" rows="1" placeholder="Escribele lo que quieres que haga" autocapitalize="sentences" autocomplete="off"></textarea>',
     '<button id="enviar" type="submit">Ir</button>',
     '</form>',
+    '<div id="suelta">Suelta aqui los archivos</div>',
     '<div id="velo"><div id="permiso">',
     '<h2 id="permisoTitulo">Pide permiso</h2>',
     '<p id="permisoDetalle"></p>',
@@ -144,6 +173,102 @@ const PAGINA = [
     '    }',
     '    return html || "&nbsp;";',
     '  }',
+    '  // MIRAR, NO SOLO LEER LA RUTA',
+    '  //',
+    '  // Sin esto, cuando el agente exporta una imagen contesta con la ruta. Delante',
+    '  // del PC se abre la carpeta; en un movil no puedes mirarlo, asi que no puedes',
+    '  // opinar, asi que no puedes trabajar. La ruta se detecta aqui y el permiso lo',
+    '  // da el servidor: /archivo solo sirve lo que este dentro de la carpeta.',
+    '  var EXT_VISIBLE = /^(png|jpe?g|webp|gif|bmp|avif|svg|mp4|webm|mov)$/i;',
+    '  // Todo lo que en una linea tiene pinta de ruta: con separador y con punto.',
+    '  function rutasDelTexto(crudo) {',
+    '    var limpio = String(crudo).replace(/\\x1b\\[[0-9;?]*[A-Za-z]/g, "");',
+    '    var encontradas = [];',
+    '    var trozos = limpio.split(/[\\s"\\u0027`<>|()\\[\\]]+/);',
+    '    for (var i = 0; i < trozos.length; i++) {',
+    '      var t = trozos[i].replace(/[.,;:]+$/, "");',
+    '      if (t.indexOf("/") < 0 && t.indexOf("\\\\") < 0) continue;',
+    '      if (t.lastIndexOf(".") < 0) continue;',
+    '      if (encontradas.indexOf(t) < 0) encontradas.push(t);',
+    '      if (encontradas.length >= 6) break;',
+    '    }',
+    '    return encontradas;',
+    '  }',
+    '  function extensionDe(ruta) {',
+    '    var punto = String(ruta).lastIndexOf(".");',
+    '    return punto < 0 ? "" : ruta.slice(punto + 1);',
+    '  }',
+    '  function rutasVisibles(crudo) {',
+    '    return rutasDelTexto(crudo).filter(function (r) { return EXT_VISIBLE.test(extensionDe(r)); }).slice(0, 4);',
+    '  }',
+    '  // Las que no se pueden ensenar pero si llevarse: el ZIP, el PDF, el CSV.',
+    '  function rutasGuardables(crudo, yaVistas) {',
+    '    return rutasDelTexto(crudo)',
+    '      .filter(function (r) { return yaVistas.indexOf(r) < 0 && EXT_GUARDABLE.test(extensionDe(r)); })',
+    '      .slice(0, 3);',
+    '  }',
+    '  // GUARDARLO, QUE ES LA ULTIMA MILLA',
+    '  //',
+    '  // Ver la pieza en el movil no termina el trabajo: el diseno sale del PC para',
+    '  // ir a un cliente, y ese cliente esta en el WhatsApp del telefono. Sin esto,',
+    '  // el circuito se queda a un paso: recibes por WhatsApp, procesas en el PC,',
+    '  // ves el resultado... y tienes que ir al ordenador a por el archivo.',
+    '  //',
+    '  // Y no solo imagenes: el ZIP del entregable, el PDF, el CSV y los subtitulos',
+    '  // no tienen miniatura que ensenar, asi que sin un enlace no existen para el',
+    '  // movil. Para esos se pregunta antes con HEAD si el archivo esta de verdad,',
+    '  // para no ofrecer un enlace roto sobre cualquier palabra con un punto.',
+    '  var EXT_GUARDABLE = /^(pdf|zip|rar|7z|csv|txt|md|srt|vtt|json|docx|xlsx|pptx|psd|ai|svg|mp3|wav|ogg|mp4|webm|mov|png|jpe?g|webp|gif)$/i;',
+    '  function urlDe(ruta, descargar) {',
+    '    return "/archivo?t=" + encodeURIComponent(token) + "&ruta=" + encodeURIComponent(ruta) +',
+    '      (descargar ? "&descargar=1" : "");',
+    '  }',
+    '  function nombreDe(ruta) {',
+    '    var trozos = String(ruta).split(/[\\\\/]/);',
+    '    return trozos[trozos.length - 1] || ruta;',
+    '  }',
+    '  function enlaceDeGuardar(ruta) {',
+    '    var a = document.createElement("a");',
+    '    a.className = "guardar";',
+    '    a.href = urlDe(ruta, true);',
+    '    a.setAttribute("download", nombreDe(ruta));',
+    '    a.textContent = "\u2913 Guardar " + nombreDe(ruta);',
+    '    return a;',
+    '  }',
+    '  // Un archivo sin miniatura: se ofrece solo si existe de verdad.',
+    '  function quizaDescargable(ruta, donde) {',
+    '    var punto = String(ruta).lastIndexOf(".");',
+    '    if (punto < 0 || !EXT_GUARDABLE.test(ruta.slice(punto + 1))) return;',
+    '    fetch(urlDe(ruta, false), { method: "HEAD" }).then(function (r) {',
+    '      if (!r.ok) return;',
+    '      donde.appendChild(enlaceDeGuardar(ruta));',
+    '    }).catch(function () {});',
+    '  }',
+    '  function rutasGuardables(crudo, yaVistas) {',
+    '    var todas = rutasDelTexto(crudo);',
+    '    var fuera = [];',
+    '    for (var i = 0; i < todas.length; i++) {',
+    '      if (yaVistas.indexOf(todas[i]) < 0) fuera.push(todas[i]);',
+    '    }',
+    '    return fuera.slice(0, 3);',
+    '  }',
+    '  function miniatura(ruta) {',
+    '    var url = "/archivo?t=" + encodeURIComponent(token) + "&ruta=" + encodeURIComponent(ruta);',
+    '    var caja = document.createElement("div");',
+    '    caja.className = "mini";',
+    '    var esVideo = /(mp4|webm|mov)$/i.test(ruta);',
+    '    var vista = document.createElement(esVideo ? "video" : "img");',
+    '    vista.src = url;',
+    '    if (esVideo) { vista.controls = true; vista.preload = "metadata"; }',
+    '    // Si no se puede servir -fuera de la carpeta, borrado, o es una ruta que',
+    '    // solo lo parecia- no se deja el icono de imagen rota: se quita la caja.',
+    '    vista.onerror = function () { try { caja.parentNode.removeChild(caja); } catch (e) {} };',
+    '    // El enlace solo aparece cuando la imagen ha cargado: si el archivo no se',
+    '    // puede servir, la caja entera se va y no queda un boton que no guarda nada.',
+    '    vista.onload = function () { caja.appendChild(enlaceDeGuardar(ruta)); };',
+    '    caja.appendChild(vista);',
+    '    return caja;',
+    '  }',
     '  function pintar(lineas) {',
     '    if (!lineas || !lineas.length) return;',
     '    var pegado = alFinal();',
@@ -153,12 +278,67 @@ const PAGINA = [
     '      div.className = "fila";',
     '      div.innerHTML = ansi(lineas[i].texto);',
     '      frag.appendChild(div);',
+    '      var vistas = rutasVisibles(lineas[i].texto);',
+    '      for (var v = 0; v < vistas.length; v++) frag.appendChild(miniatura(vistas[v]));',
+    '      var otras = rutasGuardables(lineas[i].texto, vistas);',
+    '      if (otras.length) {',
+    '        var fila = document.createElement("div");',
+    '        fila.className = "mini";',
+    '        frag.appendChild(fila);',
+    '        for (var g = 0; g < otras.length; g++) quizaDescargable(otras[g], fila);',
+    '      }',
     '      if (lineas[i].id > ultimoId) ultimoId = lineas[i].id;',
     '    }',
     '    salida.appendChild(frag);',
     '    while (salida.childNodes.length > 3000) salida.removeChild(salida.firstChild);',
     '    if (pegado) salida.scrollTop = salida.scrollHeight;',
     '  }',
+    '  // AVISAR AL MOVIL, SIN SER PESADO',
+    '  //',
+    '  // Sin esto, la sesion web solo sirve si estas mirandola. Dejas una tarea de',
+    '  // cinco minutos, te vas, y acabas sacando el telefono cada treinta segundos',
+    '  // por si acaso. Que es exactamente lo que hace inutil trabajar desde el movil.',
+    '  //',
+    '  // TRES DECISIONES:',
+    '  //',
+    '  //  1. SOLO SI NO ESTAS MIRANDO. Con la pagina delante, una notificacion de',
+    '  //     algo que ya ves en pantalla es ruido, y el ruido se acaba silenciando',
+    '  //     entero, tambien el aviso que si importaba.',
+    '  //  2. EL PERMISO SE PIDE AL ENVIAR, NO AL CARGAR. Chrome ignora -y Safari',
+    '  //     rechaza- una peticion de notificaciones que no venga de un gesto del',
+    '  //     usuario. Pedirlo al abrir la pagina es gastar la unica oportunidad.',
+    '  //  3. EL TITULO TAMBIEN AVISA. Si las notificaciones estan denegadas, el',
+    '  //     punto en la pestana es lo unico que queda, y se ve igual de bien.',
+    '  var tituloNormal = document.title;',
+    '  var avisoPuesto = false;',
+    '  function puedeAvisar() {',
+    '    return typeof Notification !== "undefined" && Notification.permission === "granted";',
+    '  }',
+    '  function pedirPermisoDeAviso() {',
+    '    if (typeof Notification === "undefined" || Notification.permission !== "default") return;',
+    '    try { Notification.requestPermission(); } catch (e) {}',
+    '  }',
+    '  function marcarTitulo(si) {',
+    '    avisoPuesto = si;',
+    '    document.title = si ? "\u25cf " + tituloNormal : tituloNormal;',
+    '  }',
+    '  function avisar(titulo, cuerpo, urgente) {',
+    '    // Mirando la pagina no se avisa de nada: ya lo estas viendo.',
+    '    if (!document.hidden) return;',
+    '    marcarTitulo(true);',
+    '    if (navigator.vibrate) {',
+    '      // Dos pulsos para un permiso -que te esta esperando- y uno para el final.',
+    '      try { navigator.vibrate(urgente ? [120, 80, 120] : [90]); } catch (e) {}',
+    '    }',
+    '    if (!puedeAvisar()) return;',
+    '    try {',
+    '      var n = new Notification(titulo, { body: cuerpo, tag: "chocolatito", renotify: true });',
+    '      n.onclick = function () { try { window.focus(); } catch (e) {} try { n.close(); } catch (e) {} };',
+    '    } catch (e) {}',
+    '  }',
+    '  document.addEventListener("visibilitychange", function () {',
+    '    if (!document.hidden && avisoPuesto) marcarTitulo(false);',
+    '  });',
     '  function conectado(si, etiqueta) {',
     '    punto.className = si ? "ok" : "";',
     '    estadoTexto.textContent = etiqueta;',
@@ -171,6 +351,7 @@ const PAGINA = [
     '    peticionActual = null;',
     '  }',
     '  function abrirPermiso(p) {',
+    '    avisar("Chocolatito te pide permiso", (p.detalle && p.detalle[0]) || p.herramienta, true);',
     '    peticionActual = p;',
     '    document.getElementById("permisoTitulo").textContent = "Permiso: " + p.herramienta;',
     '    document.getElementById("permisoDetalle").textContent = (p.detalle || []).join("\\n");',
@@ -220,6 +401,7 @@ const PAGINA = [
     '        pintar(m.lineas);',
     '      }',
     '      else if (m.t === "permiso") abrirPermiso(m);',
+    '      else if (m.t === "turno") avisar("Chocolatito ha terminado", "Te toca a ti.", false);',
     '      else if (m.t === "cierre") { velo.className = ""; peticionActual = null; }',
     '      else if (m.t === "fin") { terminada = true; conectado(false, "sesion terminada"); try { ws.close(); } catch (e) {} }',
     '    };',
@@ -233,11 +415,93 @@ const PAGINA = [
     '    };',
     '    ws.onerror = function () { try { ws.close(); } catch (e) {} };',
     '  }',
+    '  // LOS ARCHIVOS QUE ENTRAN',
+    '  //',
+    '  // Tres gestos, porque son tres sitios distintos: el boton y arrastrar (PC), y',
+    '  // PEGAR, que es el mas usado de los tres y el que casi nadie pone: una captura',
+    '  // de pantalla se pega, no se guarda antes en una carpeta para luego buscarla.',
+    '  var adjuntos = [];',
+    '  var tiraAdjuntos = document.getElementById("adjuntos");',
+    '  var fichero = document.getElementById("fichero");',
+    '  var suelta = document.getElementById("suelta");',
+    '  function pintarAdjuntos() {',
+    '    tiraAdjuntos.innerHTML = "";',
+    '    for (var i = 0; i < adjuntos.length; i++) {',
+    '      (function (a) {',
+    '        var chip = document.createElement("div");',
+    '        chip.className = "chip";',
+    '        if (a.vista) { var im = document.createElement("img"); im.src = a.vista; chip.appendChild(im); }',
+    '        var nom = document.createElement("span");',
+    '        nom.textContent = a.subiendo ? a.nombre + "\u2026" : a.nombre;',
+    '        chip.appendChild(nom);',
+    '        var x = document.createElement("b");',
+    '        x.textContent = "\u00d7";',
+    '        x.onclick = function () { adjuntos.splice(adjuntos.indexOf(a), 1); pintarAdjuntos(); };',
+    '        chip.appendChild(x);',
+    '        tiraAdjuntos.appendChild(chip);',
+    '      })(adjuntos[i]);',
+    '    }',
+    '  }',
+    '  function adjuntar(archivos) {',
+    '    for (var i = 0; i < archivos.length; i++) {',
+    '      (function (archivo) {',
+    '        var entrada = {',
+    '          nombre: archivo.name || "pegado.png",',
+    '          subiendo: true,',
+    '          ruta: "",',
+    '          vista: /^image\\//.test(archivo.type) ? URL.createObjectURL(archivo) : ""',
+    '        };',
+    '        adjuntos.push(entrada);',
+    '        pintarAdjuntos();',
+    '        fetch("/subir?t=" + encodeURIComponent(token) + "&nombre=" + encodeURIComponent(entrada.nombre), {',
+    '          method: "POST",',
+    '          body: archivo',
+    '        }).then(function (r) { return r.json(); }).then(function (j) {',
+    '          if (j && j.ok) { entrada.ruta = j.ruta; entrada.subiendo = false; }',
+    '          else {',
+    '            adjuntos.splice(adjuntos.indexOf(entrada), 1);',
+    '            pintar([{ id: 0, texto: "\u001b[33m  No se pudo subir " + entrada.nombre + ": " + ((j && j.error) || "error") + "\u001b[39m" }]);',
+    '          }',
+    '          pintarAdjuntos();',
+    '        }).catch(function () {',
+    '          adjuntos.splice(adjuntos.indexOf(entrada), 1);',
+    '          pintarAdjuntos();',
+    '        });',
+    '      })(archivos[i]);',
+    '    }',
+    '  }',
+    '  document.getElementById("clip").onclick = function () { fichero.click(); };',
+    '  fichero.onchange = function () { adjuntar(fichero.files); fichero.value = ""; };',
+    '  document.addEventListener("paste", function (ev) {',
+    '    var datos = ev.clipboardData;',
+    '    if (!datos || !datos.files || !datos.files.length) return;',
+    '    ev.preventDefault();',
+    '    adjuntar(datos.files);',
+    '  });',
+    '  var arrastres = 0;',
+    '  document.addEventListener("dragenter", function (ev) { ev.preventDefault(); arrastres++; suelta.className = "visible"; });',
+    '  document.addEventListener("dragover", function (ev) { ev.preventDefault(); });',
+    '  document.addEventListener("dragleave", function () { if (--arrastres <= 0) { arrastres = 0; suelta.className = ""; } });',
+    '  document.addEventListener("drop", function (ev) {',
+    '    ev.preventDefault();',
+    '    arrastres = 0;',
+    '    suelta.className = "";',
+    '    if (ev.dataTransfer && ev.dataTransfer.files && ev.dataTransfer.files.length) adjuntar(ev.dataTransfer.files);',
+    '  });',
     '  document.getElementById("envio").onsubmit = function (ev) {',
     '    ev.preventDefault();',
     '    var valor = texto.value.trim();',
-    '    if (!valor || !ws || ws.readyState !== 1) return;',
-    '    ws.send(JSON.stringify({ t: "entrada", texto: valor }));',
+    '    var listos = [];',
+    '    for (var i = 0; i < adjuntos.length; i++) if (adjuntos[i].ruta) listos.push(adjuntos[i].ruta);',
+    '    // Se puede mandar SOLO archivos: subir cinco fotos y no escribir nada es una',
+    '    // orden perfectamente clara para el que la recibe.',
+    '    if ((!valor && !listos.length) || !ws || ws.readyState !== 1) return;',
+    '    // Aqui, y no al cargar: Chrome ignora una peticion de notificaciones que no',
+    '    // venga de un gesto del usuario, y pedirla al abrir gasta la unica que hay.',
+    '    pedirPermisoDeAviso();',
+    '    ws.send(JSON.stringify({ t: "entrada", texto: valor, archivos: listos }));',
+    '    adjuntos = [];',
+    '    pintarAdjuntos();',
     '    texto.value = "";',
     '    texto.style.height = "auto";',
     '    salida.scrollTop = salida.scrollHeight;',

package/dist/servidor/puente.d.ts

@@ -3,6 +3,19 @@ export declare function servirActivo(): boolean;
 export declare function marcarServirActivo(valor: boolean): void;
 /** Llega algo del navegador. */
 export declare function entregarEntrada(texto: string): void;
+/**
+ * QUIEN AVISA AL MOVIL DE QUE YA PUEDE MIRAR
+ *
+ * El navegador sabia cuando le preguntaban algo -el permiso llega por su
+ * canal- pero no sabia cuando el agente TERMINABA. Y ese es justo el momento
+ * que importa cuando no estas delante: dejas una tarea de cinco minutos, te vas,
+ * y vuelves a mirar el telefono cada treinta segundos por si acaso.
+ *
+ * El momento no hay que inventarlo ni medirlo: es exactamente cuando el agente
+ * se pone a esperar lo que escribas. Ni un evento nuevo ni un temporizador.
+ */
+type AvisoDeTurno = () => void;
+export declare function fijarAvisoDeTurno(fn: AvisoDeTurno | null): void;
 export declare function esperarEntradaWeb(): Promise<string>;
 export declare function hayEntradaEnCola(): boolean;
 export interface PeticionDePermiso {

package/dist/servidor/puente.js

@@ -48,10 +48,20 @@ export function entregarEntrada(texto) {
     // vez de perderse. Es lo que ya hace el type-ahead del terminal.
     cola.push(texto);
 }
+let avisarDelTurno = null;
+export function fijarAvisoDeTurno(fn) {
+    avisarDelTurno = fn;
+}
 export function esperarEntradaWeb() {
     const pendiente = cola.shift();
+    // Con algo en la cola NO se avisa: el usuario ya habia escrito mientras el
+    // agente trabajaba, asi que no ha terminado nada para el, sigue la faena.
     if (pendiente !== undefined)
         return Promise.resolve(pendiente);
+    try {
+        avisarDelTurno?.();
+    }
+    catch { }
     return new Promise((resolve) => {
         esperando = resolve;
     });
@@ -106,6 +116,7 @@ export function permisosAbiertos() {
 }
 /** Solo para pruebas. */
 export function vaciarPuente() {
+    avisarDelTurno = null;
     cola.length = 0;
     esperando = null;
     emisor = null;

package/dist/servidor/servidor.d.ts

@@ -36,6 +36,12 @@ export interface OpcionesServidor {
     enRed?: boolean;
     /** Para pruebas: token fijo en vez de uno aleatorio. */
     token?: string;
+    /**
+     * La carpeta de trabajo, leida en cada peticion y no copiada al arrancar.
+     * Con /cd el agente se cambia de carpeta a mitad de sesion, y lo que se sube
+     * tiene que caer donde se esta trabajando AHORA, no donde se empezo.
+     */
+    carpeta?: () => string;
 }
 export interface ServidorWeb {
     puerto: number;