npm - chocolatito-code - Versions diffs - 1.6.7 → 1.6.9 - Mend

chocolatito-code 1.6.7 → 1.6.9

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (55) hide show

package/README.md +447 -341
package/dist/agent/context.d.ts +6 -0
package/dist/agent/context.js +69 -2
package/dist/agent/loop.js +8 -0
package/dist/agent/toolGate.js +13 -7
package/dist/agent/verifier.js +2 -1
package/dist/config/permissions.d.ts +17 -0
package/dist/config/permissions.js +47 -7
package/dist/config/plataforma.d.ts +62 -0
package/dist/config/plataforma.js +109 -0
package/dist/config/updater.js +4 -1
package/dist/hooks/manager.js +2 -1
package/dist/index.js +99 -6
package/dist/memory/manager.d.ts +15 -5
package/dist/memory/manager.js +146 -29
package/dist/servidor/captura.d.ts +36 -0
package/dist/servidor/captura.js +74 -0
package/dist/servidor/pagina.d.ts +27 -0
package/dist/servidor/pagina.js +268 -0
package/dist/servidor/puente.d.ts +34 -0
package/dist/servidor/puente.js +115 -0
package/dist/servidor/servidor.d.ts +61 -0
package/dist/servidor/servidor.js +249 -0
package/dist/sessions/manager.d.ts +8 -0
package/dist/sessions/manager.js +44 -0
package/dist/sessions/resume.d.ts +12 -0
package/dist/sessions/resume.js +10 -0
package/dist/tools/backgroundTask.d.ts +64 -0
package/dist/tools/backgroundTask.js +264 -0
package/dist/tools/browserExtension.d.ts +2 -1
package/dist/tools/browserExtension.js +48 -0
package/dist/tools/computerUse.js +51 -9
package/dist/tools/definitions.js +93 -1
package/dist/tools/gitAudit.d.ts +68 -0
package/dist/tools/gitAudit.js +374 -0
package/dist/tools/runCommand.js +5 -2
package/dist/tools/runner.js +36 -2
package/dist/tools/safety.d.ts +1 -0
package/dist/tools/safety.js +3 -0
package/dist/tools/todoTool.d.ts +2 -0
package/dist/tools/todoTool.js +29 -0
package/dist/tools/toolDefsComputer.js +9 -0
package/dist/tools/win/hostScript.js +7 -2
package/dist/ui/comandos.js +2 -0
package/dist/ui/marco.d.ts +1 -0
package/dist/ui/marco.js +4 -2
package/dist/ui/permissionPrompt.d.ts +9 -0
package/dist/ui/permissionPrompt.js +30 -0
package/dist/ui/pieFijo.d.ts +1 -1
package/dist/ui/pieFijo.js +1 -1
package/dist/ui/renderer.js +8 -0
package/extension/background.js +80 -0
package/extension/content.js +106 -0
package/extension/manifest.json +61 -60
package/package.json +3 -2

package/dist/servidor/pagina.js ADDED Viewed

@@ -0,0 +1,268 @@
+/**
+ * LA PAGINA, ENTERA Y SIN DEPENDENCIAS
+ *
+ * Nada de CDN: ni una fuente, ni una libreria. Tres razones y las tres pesan.
+ * Corre en tu red local, donde puede no haber salida a internet; un CDN veria la
+ * direccion desde la que entra cada sesion de cada cliente; y una pagina que
+ * depende de un tercero se rompe el dia que el tercero cambia algo.
+ *
+ * ESTA PENSADA PARA UN MOVIL, Y ESO SON DECISIONES CONCRETAS
+ *
+ *  - La caja de escribir tiene font-size 16px. Por debajo de 16, Safari de iOS
+ *    hace zoom solo al enfocar el campo y descoloca la pagina entera. Es la
+ *    razon de ese numero y no otro.
+ *  - `env(safe-area-inset-bottom)`: sin eso, en un iPhone la barra de escribir
+ *    queda debajo de la raya del gesto de inicio.
+ *  - `dvh` y no `vh`: con `vh`, al abrirse el teclado la pagina sigue midiendo
+ *    la pantalla entera y el campo se va hacia abajo, fuera de la vista.
+ *  - Se reconecta sola, con espera creciente. Un movil pierde la red a cada rato,
+ *    y una sesion que hay que recargar a mano no se usa dos veces.
+ *
+ * EL COLOR SALE DEL ANSI DE VERDAD
+ *
+ * La transcripcion llega tal cual, con los codigos de chalk dentro. Se traducen
+ * aqui a `<span>` en vez de quitarlos: el diff en verde y rojo ES el producto, y
+ * un diff en gris no vende nada.
+ */
+export function paginaHtml() {
+    return PAGINA;
+}
+const PAGINA = [
+    '<!doctype html>',
+    '<html lang="es">',
+    '<head>',
+    '<meta charset="utf-8">',
+    '<meta name="viewport" content="width=device-width, initial-scale=1, viewport-fit=cover">',
+    '<meta name="color-scheme" content="dark">',
+    '<meta name="robots" content="noindex, nofollow">',
+    '<title>Chocolatito Code</title>',
+    '<style>',
+    ':root { --fondo:#0b0b0d; --caja:#15151a; --borde:#2a2a33; --texto:#e6e6ea; --suave:#8b8b96; --zorro:#e8833a; }',
+    '* { box-sizing: border-box; }',
+    'html, body { margin:0; height:100%; background:var(--fondo); color:var(--texto); }',
+    'body { display:flex; flex-direction:column; height:100dvh; -webkit-text-size-adjust:100%;',
+    '  font:14px/1.5 ui-monospace, SFMono-Regular, Menlo, Consolas, monospace; }',
+    'header { display:flex; align-items:center; gap:8px; background:var(--caja);',
+    '  padding:calc(8px + env(safe-area-inset-top)) 12px 8px; border-bottom:1px solid var(--borde); }',
+    '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; }',
+    '#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; }',
+    'form { display:flex; gap:8px; background:var(--caja); border-top:1px solid var(--borde);',
+    '  padding:8px 8px calc(8px + env(safe-area-inset-bottom)); }',
+    'textarea { flex:1; resize:none; min-height:44px; max-height:40dvh; padding:10px; border-radius:10px;',
+    '  border:1px solid var(--borde); background:var(--fondo); color:var(--texto);',
+    '  font:16px/1.4 ui-monospace, Menlo, Consolas, monospace; }',
+    'button { border:0; border-radius:10px; padding:0 16px; min-width:56px; min-height:44px;',
+    '  background:var(--zorro); color:#14110e; font-weight:700; font-size:15px; }',
+    'button:disabled { opacity:.45; }',
+    'button.secundario { background:var(--borde); color:var(--texto); font-weight:500; }',
+    '#velo { position:fixed; inset:0; background:rgba(0,0,0,.72); display:none; align-items:flex-end;',
+    '  justify-content:center; padding:12px; }',
+    '#velo.abierto { display:flex; }',
+    '#permiso { width:100%; max-width:560px; background:var(--caja); border:1px solid var(--zorro);',
+    '  border-radius:14px; padding:14px; padding-bottom:calc(14px + env(safe-area-inset-bottom));',
+    '  max-height:85dvh; overflow-y:auto; }',
+    '#permiso h2 { margin:0 0 4px; font-size:15px; color:var(--zorro); }',
+    '#permisoDetalle { margin:0 0 12px; color:var(--suave); font-size:13px; white-space:pre-wrap; word-break:break-word; }',
+    '#permiso .opciones { display:flex; flex-direction:column; gap:8px; }',
+    '#permiso .opciones button { width:100%; text-align:left; padding:12px; }',
+    '#permiso small { display:block; font-weight:400; opacity:.75; }',
+    '#comentario { width:100%; margin-top:10px; display:none; }',
+    '.n{font-weight:700}.d{opacity:.6}.i{font-style:italic}.u{text-decoration:underline}',
+    '.f30{color:#5c6370}.f31{color:#e06c75}.f32{color:#98c379}.f33{color:#e5c07b}',
+    '.f34{color:#61afef}.f35{color:#c678dd}.f36{color:#56b6c2}.f37{color:#dcdfe4}',
+    '.f90{color:#7f848e}.f91{color:#ff7b86}.f92{color:#b5e890}.f93{color:#f0d399}',
+    '.f94{color:#82c0ff}.f95{color:#e0a3f0}.f96{color:#78d7de}.f97{color:#fff}',
+    '.b41{background:#4a1f22}.b42{background:#1f3a24}.b43{background:#463a1c}',
+    '.b44{background:#1f3048}.b45{background:#3a2440}.b46{background:#1d3a3c}.b47{background:#33333a}',
+    '</style>',
+    '</head>',
+    '<body>',
+    '<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>',
+    '<form id="envio">',
+    '<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="velo"><div id="permiso">',
+    '<h2 id="permisoTitulo">Pide permiso</h2>',
+    '<p id="permisoDetalle"></p>',
+    '<div class="opciones" id="permisoOpciones"></div>',
+    '<textarea id="comentario" rows="2" placeholder="Dile que prefieres que haga"></textarea>',
+    '</div></div>',
+    '<script>',
+    '(function () {',
+    '  var token = new URLSearchParams(location.search).get("t") || "";',
+    '  // Se quita de la barra de direcciones en cuanto se lee: el token no tiene',
+    '  // por que quedarse en el historial del navegador ni salir en una captura.',
+    '  if (token && history.replaceState) history.replaceState(null, "", location.pathname);',
+    '  var salida = document.getElementById("salida");',
+    '  var punto = document.getElementById("punto");',
+    '  var estadoTexto = document.getElementById("estadoTexto");',
+    '  var texto = document.getElementById("texto");',
+    '  var enviar = document.getElementById("enviar");',
+    '  var velo = document.getElementById("velo");',
+    '  var ws = null, ultimoId = 0, reintento = 800, peticionActual = null, terminada = false;',
+    '  var sesion = "";',
+    '  function alFinal() { return salida.scrollHeight - salida.scrollTop - salida.clientHeight < 60; }',
+    '  function escapar(s) { return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;"); }',
+    '  function quitar(l, fuera) { return l.filter(function (c) { return fuera.indexOf(c) < 0; }); }',
+    '  function sinPrefijo(l, p) { return l.filter(function (c) { return c.charAt(0) !== p; }); }',
+    '  // ANSI -> HTML. Solo SGR (las que ponen color): el resto de secuencias son',
+    '  // movimientos de cursor del terminal, que aqui no significan nada y se tiran.',
+    '  function ansi(linea) {',
+    '    var clases = [], html = "";',
+    '    var partes = linea.split(/\\x1b\\[([0-9;]*)m/);',
+    '    for (var i = 0; i < partes.length; i++) {',
+    '      if (i % 2 === 0) {',
+    '        var limpio = partes[i].replace(/\\x1b\\[[0-9;?]*[A-Za-z]/g, "").replace(/\\x1b\\][^\\x07]*\\x07/g, "");',
+    '        if (!limpio) continue;',
+    '        if (clases.length) html += "<span class=\\"" + clases.join(" ") + "\\">" + escapar(limpio) + "</span>";',
+    '        else html += escapar(limpio);',
+    '      } else {',
+    '        var codigos = (partes[i] || "0").split(";");',
+    '        for (var c = 0; c < codigos.length; c++) {',
+    '          var n = parseInt(codigos[c] || "0", 10);',
+    '          if (n === 0) clases = [];',
+    '          else if (n === 1) clases.push("n");',
+    '          else if (n === 2) clases.push("d");',
+    '          else if (n === 3) clases.push("i");',
+    '          else if (n === 4) clases.push("u");',
+    '          else if (n === 22) clases = quitar(clases, ["n", "d"]);',
+    '          else if (n === 23) clases = quitar(clases, ["i"]);',
+    '          else if (n === 24) clases = quitar(clases, ["u"]);',
+    '          else if (n === 39) clases = sinPrefijo(clases, "f");',
+    '          else if (n === 49) clases = sinPrefijo(clases, "b");',
+    '          else if ((n >= 30 && n <= 37) || (n >= 90 && n <= 97)) { clases = sinPrefijo(clases, "f"); clases.push("f" + n); }',
+    '          else if ((n >= 40 && n <= 47) || (n >= 100 && n <= 107)) { clases = sinPrefijo(clases, "b"); clases.push("b" + (n >= 100 ? n - 60 : n)); }',
+    '        }',
+    '      }',
+    '    }',
+    '    return html || "&nbsp;";',
+    '  }',
+    '  function pintar(lineas) {',
+    '    if (!lineas || !lineas.length) return;',
+    '    var pegado = alFinal();',
+    '    var frag = document.createDocumentFragment();',
+    '    for (var i = 0; i < lineas.length; i++) {',
+    '      var div = document.createElement("div");',
+    '      div.className = "fila";',
+    '      div.innerHTML = ansi(lineas[i].texto);',
+    '      frag.appendChild(div);',
+    '      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;',
+    '  }',
+    '  function conectado(si, etiqueta) {',
+    '    punto.className = si ? "ok" : "";',
+    '    estadoTexto.textContent = etiqueta;',
+    '    enviar.disabled = !si;',
+    '  }',
+    '  function responder(indice, comentario) {',
+    '    if (!peticionActual || !ws || ws.readyState !== 1) return;',
+    '    ws.send(JSON.stringify({ t: "permiso", id: peticionActual.id, opcion: indice, comentario: comentario || "" }));',
+    '    velo.className = "";',
+    '    peticionActual = null;',
+    '  }',
+    '  function abrirPermiso(p) {',
+    '    peticionActual = p;',
+    '    document.getElementById("permisoTitulo").textContent = "Permiso: " + p.herramienta;',
+    '    document.getElementById("permisoDetalle").textContent = (p.detalle || []).join("\\n");',
+    '    var caja = document.getElementById("permisoOpciones");',
+    '    caja.innerHTML = "";',
+    '    var comentario = document.getElementById("comentario");',
+    '    comentario.style.display = "none";',
+    '    comentario.value = "";',
+    '    var ops = p.opciones || [];',
+    '    for (var i = 0; i < ops.length; i++) {',
+    '      (function (indice, op) {',
+    '        var b = document.createElement("button");',
+    '        b.type = "button";',
+    '        b.className = indice === 0 ? "" : "secundario";',
+    '        b.innerHTML = escapar(op.label) + "<small>" + escapar(op.hint) + "</small>";',
+    '        b.onclick = function () {',
+    '          // La ultima opcion es "prefiero decirte otra cosa": el primer toque',
+    '          // abre el campo y el segundo envia lo escrito.',
+    '          if (indice >= 2 && comentario.style.display === "none") {',
+    '            comentario.style.display = "block";',
+    '            comentario.focus();',
+    '            return;',
+    '          }',
+    '          responder(indice, comentario.value);',
+    '        };',
+    '        caja.appendChild(b);',
+    '      })(i, ops[i]);',
+    '    }',
+    '    velo.className = "abierto";',
+    '  }',
+    '  function conectar() {',
+    '    if (terminada) return;',
+    '    var proto = location.protocol === "https:" ? "wss://" : "ws://";',
+    '    var mas = "&desde=" + ultimoId + (sesion ? "&sesion=" + encodeURIComponent(sesion) : "");',
+    '    ws = new WebSocket(proto + location.host + "/ws?t=" + encodeURIComponent(token) + mas);',
+    '    ws.onopen = function () { reintento = 800; conectado(true, "conectado"); };',
+    '    ws.onmessage = function (ev) {',
+    '      var m;',
+    '      try { m = JSON.parse(ev.data); } catch (e) { return; }',
+    '      if (m.t === "lineas") {',
+    '        // Sesión distinta: lo que hay en pantalla es de una sesión que ya no',
+    '        // existe. Se tira, o quedarían pegadas dos conversaciones distintas.',
+    '        if (m.sesion && m.sesion !== sesion) {',
+    '          sesion = m.sesion;',
+    '          if (m.nueva) { salida.innerHTML = ""; ultimoId = 0; }',
+    '        }',
+    '        pintar(m.lineas);',
+    '      }',
+    '      else if (m.t === "permiso") abrirPermiso(m);',
+    '      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) {} }',
+    '    };',
+    '    ws.onclose = function () {',
+    '      if (terminada) return;',
+    '      conectado(false, "reconectando");',
+    '      // Con tope: un movil en el bolsillo puede pasar horas sin red, y no tiene',
+    '      // sentido intentarlo cien veces por minuto.',
+    '      setTimeout(conectar, reintento);',
+    '      reintento = Math.min(reintento * 1.7, 15000);',
+    '    };',
+    '    ws.onerror = function () { try { ws.close(); } catch (e) {} };',
+    '  }',
+    '  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 }));',
+    '    texto.value = "";',
+    '    texto.style.height = "auto";',
+    '    salida.scrollTop = salida.scrollHeight;',
+    '  };',
+    '  // ENTER ENVIA, PERO SOLO CON TECLADO DE VERDAD.',
+    '  //',
+    '  // Se vio probando en un navegador: dentro de un <textarea> el Enter mete un',
+    '  // salto de linea y el formulario no se entera, asi que escribias la orden, le',
+    '  // dabas a Enter y no pasaba nada. En pantalla tactil se deja el salto de linea',
+    '  // y se envia con el boton: en un movil, un Enter que manda hace imposible',
+    '  // escribir dos renglones, y ahi el boton esta a un dedo de distancia.',
+    '  var tactil = window.matchMedia && window.matchMedia("(pointer: coarse)").matches;',
+    '  texto.addEventListener("keydown", function (ev) {',
+    '    if (ev.key !== "Enter" || ev.shiftKey || tactil) return;',
+    '    ev.preventDefault();',
+    '    document.getElementById("envio").requestSubmit();',
+    '  });',
+    '  texto.addEventListener("input", function () {',
+    '    texto.style.height = "auto";',
+    '    texto.style.height = Math.min(texto.scrollHeight, window.innerHeight * 0.4) + "px";',
+    '  });',
+    '  conectado(false, "conectando");',
+    '  conectar();',
+    '})();',
+    '</script>',
+    '</body>',
+    '</html>',
+].join("\n");

package/dist/servidor/puente.d.ts ADDED Viewed

@@ -0,0 +1,34 @@
+import type { PermissionPromptResult } from "../ui/permissionPrompt.js";
+export declare function servirActivo(): boolean;
+export declare function marcarServirActivo(valor: boolean): void;
+/** Llega algo del navegador. */
+export declare function entregarEntrada(texto: string): void;
+export declare function esperarEntradaWeb(): Promise<string>;
+export declare function hayEntradaEnCola(): boolean;
+export interface PeticionDePermiso {
+    id: number;
+    herramienta: string;
+    /** Lineas de detalle ya listas para mostrar. Sin ANSI. */
+    detalle: string[];
+    opciones: Array<{
+        label: string;
+        hint: string;
+    }>;
+}
+type Emisor = (peticion: PeticionDePermiso) => boolean;
+/**
+ * Lo instala el servidor. Devuelve false si no hay ningun cliente al que
+ * preguntar, y entonces el permiso se pide por el terminal como siempre.
+ */
+export declare function fijarEmisorDePermiso(fn: Emisor | null): void;
+export declare function pedirPermisoWeb(herramienta: string, detalle: string[], opciones: Array<{
+    label: string;
+    hint: string;
+}>): Promise<PermissionPromptResult> | null;
+export declare function responderPermiso(id: number, opcion: number, comentario?: string): void;
+/** Un cliente se fue con preguntas abiertas: se cierran en negativa. */
+export declare function cancelarPermisosAbiertos(motivo: string): void;
+export declare function permisosAbiertos(): number;
+/** Solo para pruebas. */
+export declare function vaciarPuente(): void;
+export {};

package/dist/servidor/puente.js ADDED Viewed

@@ -0,0 +1,115 @@
+/**
+ * EL PUENTE ENTRE LA SESION Y EL NAVEGADOR
+ *
+ * La sesion es la de siempre: el mismo AgentLoop, el mismo bucle de index.ts, el
+ * mismo terminal escribiendo. Lo unico que cambia es de donde viene lo que se
+ * teclea y por donde se contesta un permiso.
+ *
+ * POR QUE LA ENTRADA NO SE COMPARTE CON EL TECLADO
+ *
+ * La tentacion es correr los dos a la vez y quedarse con el primero que
+ * conteste. No se hace, y no es por pereza: `askInteractivePrompt` se queda con
+ * el teclado y el terminal prestado (ui/ink/prestamo.ts) mientras espera, y no
+ * tiene forma de cancelarse a medias. Dos entradas peleando por el mismo TTY es
+ * exactamente el fallo que dejo la pantalla en negro dos veces.
+ *
+ * Asi que con `--servir` manda el navegador y el terminal es el monitor. Se dice
+ * en pantalla al arrancar, porque un prompt que no responde al teclado sin
+ * explicacion parece un cuelgue.
+ *
+ * Y LOS PERMISOS NO SE APRUEBAN SOLOS. NUNCA.
+ *
+ * Es lo mas peligroso de todo esto. Si no hay nadie conectado y el agente pide
+ * borrar algo, la salida facil es aprobarlo "porque no hay a quien preguntar":
+ * eso es un `rm -rf` sin supervision en la maquina de un cliente. Aqui, sin
+ * cliente conectado, la pregunta vuelve al dialogo del terminal, que es donde
+ * hay un humano. --yes sigue siendo la unica forma de aprobar sin preguntar, y
+ * hay que escribirlo a mano.
+ */
+let activo = false;
+export function servirActivo() {
+    return activo;
+}
+export function marcarServirActivo(valor) {
+    activo = valor;
+}
+// ===================================================== entrada
+const cola = [];
+let esperando = null;
+/** Llega algo del navegador. */
+export function entregarEntrada(texto) {
+    if (esperando) {
+        const cb = esperando;
+        esperando = null;
+        cb(texto);
+        return;
+    }
+    // Escribio mientras el agente trabajaba: se guarda y se atiende al acabar, en
+    // vez de perderse. Es lo que ya hace el type-ahead del terminal.
+    cola.push(texto);
+}
+export function esperarEntradaWeb() {
+    const pendiente = cola.shift();
+    if (pendiente !== undefined)
+        return Promise.resolve(pendiente);
+    return new Promise((resolve) => {
+        esperando = resolve;
+    });
+}
+export function hayEntradaEnCola() {
+    return cola.length > 0;
+}
+let emisor = null;
+let siguientePeticion = 1;
+const abiertas = new Map();
+/**
+ * Lo instala el servidor. Devuelve false si no hay ningun cliente al que
+ * preguntar, y entonces el permiso se pide por el terminal como siempre.
+ */
+export function fijarEmisorDePermiso(fn) {
+    emisor = fn;
+}
+export function pedirPermisoWeb(herramienta, detalle, opciones) {
+    if (!emisor)
+        return null;
+    const id = siguientePeticion++;
+    const enviado = emisor({ id, herramienta, detalle, opciones });
+    if (!enviado)
+        return null;
+    return new Promise((resolve) => {
+        abiertas.set(id, resolve);
+    });
+}
+export function responderPermiso(id, opcion, comentario) {
+    const resolver = abiertas.get(id);
+    if (!resolver)
+        return;
+    abiertas.delete(id);
+    // El indice es el de PERMISSION_OPTIONS y el orden es parte del contrato con
+    // la pagina: 0 pasa una vez, 1 pasa y lo recuerda, cualquier otra cosa NO pasa.
+    // Un indice que no se reconoce se trata como negativa, no como aprobacion.
+    if (opcion === 0)
+        return resolver({ approved: true });
+    if (opcion === 1)
+        return resolver({ approved: true, rememberPattern: true });
+    resolver({ approved: false, userFeedback: comentario?.trim() || undefined });
+}
+/** Un cliente se fue con preguntas abiertas: se cierran en negativa. */
+export function cancelarPermisosAbiertos(motivo) {
+    for (const [id, resolver] of abiertas) {
+        abiertas.delete(id);
+        resolver({ approved: false, userFeedback: motivo });
+    }
+}
+export function permisosAbiertos() {
+    return abiertas.size;
+}
+/** Solo para pruebas. */
+export function vaciarPuente() {
+    cola.length = 0;
+    esperando = null;
+    emisor = null;
+    abiertas.clear();
+    siguientePeticion = 1;
+    activo = false;
+}

package/dist/servidor/servidor.d.ts ADDED Viewed

@@ -0,0 +1,61 @@
+/**
+ * EL SERVIDOR DE `--servir`
+ *
+ * Lo que hay detras de esta puerta es ejecucion de codigo en la maquina de
+ * alguien. No es "una web bonita para el movil": es la sesion entera, con sus
+ * permisos, accesible por red. Asi que aqui la parte interesante no son las
+ * funciones, son las cuatro comprobaciones, y ninguna sobra.
+ *
+ *  1. TOKEN EN TODO, INCLUIDO EL UPGRADE DEL WEBSOCKET. Es el fallo clasico:
+ *     se protege la pagina y se deja el socket abierto, que es justo el que
+ *     manda ordenes. Se compara con timingSafeEqual, no con ===.
+ *
+ *  2. LA CABECERA HOST TIENE QUE SER UNA IP O localhost. Esto para el ataque
+ *     de DNS rebinding, que es la unica forma real de atacar un servidor que
+ *     solo escucha en 127.0.0.1: una web cualquiera pone un dominio suyo a
+ *     resolver a 127.0.0.1 y el navegador de la victima -que si puede llegar-
+ *     hace las peticiones por ella. Un ataque asi llega SIEMPRE con un nombre
+ *     de dominio en Host; exigiendo IP o localhost se cae solo.
+ *
+ *  3. ORIGIN, SI VIENE, TIENE QUE COINCIDIR CON HOST. Mismo patron que ya usa
+ *     tools/browserExtension.ts:109 para la extension. Se permite que falte
+ *     porque un cliente que no sea un navegador no la manda.
+ *
+ *  4. 127.0.0.1 POR DEFECTO. Salir a la red es --servir-red, escrito a mano,
+ *     y avisando en pantalla. Lo contrario -abrir a la red por comodidad- es
+ *     como se filtran las cosas: nadie lee lo que no pidio.
+ *
+ * Lo que esto NO hace, a proposito: no hay HTTPS ni tunel propio. Para salir de
+ * tu red se usa Tailscale o cloudflared, que ya existen, estan auditados y no
+ * hay que mantenerlos. Escribir un tunel propio seria la parte facil de una
+ * responsabilidad muy grande.
+ */
+export interface OpcionesServidor {
+    puerto?: number;
+    /** true escucha en todas las interfaces. Solo desde --servir-red. */
+    enRed?: boolean;
+    /** Para pruebas: token fijo en vez de uno aleatorio. */
+    token?: string;
+}
+export interface ServidorWeb {
+    puerto: number;
+    token: string;
+    /** La direccion que hay que abrir en el movil, con el token puesto. */
+    url: string;
+    /** Las direcciones de red local, cuando se abrio con --servir-red. */
+    urlsDeRed: string[];
+    clientes: () => number;
+    /** Avisa al navegador de que la sesion se acabo, y cierra. */
+    cerrar: () => Promise<void>;
+}
+/**
+ * Host valido: localhost o una IP literal. Ver el punto 2 de la cabecera.
+ * Se le quita el puerto y los corchetes de IPv6 antes de mirarlo.
+ */
+export declare function anfitrionAceptable(host: string | undefined): boolean;
+/** Origin, si viene, tiene que ser el mismo sitio. Ver el punto 3. */
+export declare function origenAceptable(origin: string | undefined, host: string | undefined): boolean;
+export declare function tokenDeLaPeticion(url: string | undefined): string;
+export declare function iniciarServidorWeb(opciones?: OpcionesServidor): Promise<ServidorWeb>;
+/** Las IP de la maquina en la red local, para abrirla desde el movil. */
+export declare function direccionesDeRed(puerto: number, token: string): string[];