chocolatito-code 1.6.13 → 1.6.15

package/dist/index.js

@@ -17,14 +17,15 @@ import { fijarMotor } from "./ui/motorActual.js";
 import { elegirDeLista } from "./ui/selector.js";
 import { entrarEnPantallaFija, pantallaFijaPedida, salirDePantallaFija } from "./ui/pantalla.js";
 import { iniciarServidorWeb } from "./servidor/servidor.js";
-import { iniciarCaptura } from "./servidor/captura.js";
+import { anotarCrudoWeb, anotarWeb, iniciarCaptura } from "./servidor/captura.js";
+import { copiarSalidaAlWeb } from "./agent/salidaDelAgente.js";
 import { entregarEntrada, esperarEntradaWeb, marcarServirActivo } from "./servidor/puente.js";
 import { montarArbol, desmontarArbol } from "./ui/ink/montarApp.js";
 import { reafirmarModoCrudo } from "./ui/keyboardGuard.js";
 import { askInteractivePrompt, SLASH_COMMANDS } from "./ui/prompt.js";
 import { changeDir } from "./tools/changeDir.js";
 import { gitDiff, gitCommit } from "./tools/gitTools.js";
-import { renderUserPrompt } from "./ui/renderer.js";
+import { renderUserPrompt, formatColorDiff } from "./ui/renderer.js";
 import { parseFileMentions, buildPromptWithMentions, notaDeMencionesImplicitas } from "./agent/mentions.js";
 import { SkillManager } from "./skills/manager.js";
 import { MemoryManager } from "./memory/manager.js";
@@ -33,6 +34,8 @@ import { SessionManager } from "./sessions/manager.js";
 import { prepararRestauracion, formatearOpcionesDeSesion } from "./sessions/resume.js";
 import { auditGitDiff, formatAuditReport } from "./tools/gitAudit.js";
 import { instalarKit, listarKits, quitarKit, crearKit } from "./kits/manager.js";
+import { guardarSesion, lanzarEnFondo, olvidarSesion, pararSesion, sesionViva } from "./servidor/fondo.js";
+import { nombreDeAnfitrion } from "./servidor/servidor.js";
 import { leerCortes, rutaDelRegistro } from "./agent/cortes.js";
 import { globalUndoManager } from "./agent/undoManager.js";
 import { setAutoApprove } from "./ui/permissionPrompt.js";
@@ -220,8 +223,8 @@ async function main() {
     // errores raros dentro de una dependencia. Ver config/nodeVersion.ts.
     const nodeViejo = comprobarNode();
     if (nodeViejo) {
-        console.error(chalk.red(`
-${nodeViejo}
+        console.error(chalk.red(`
+${nodeViejo}
 `));
         process.exit(EXIT_USO);
     }
@@ -235,13 +238,58 @@ ${nodeViejo}
     // red local, que es lo que hace falta para entrar desde el movil.
     const enRed = rawArgs.includes("--servir-red");
     const quiereServir = enRed || rawArgs.includes("--servir");
+    // --fondo suelta la sesion del terminal; --parar y --estado la gobiernan
+    // desde fuera, sin tener que buscar la ventana que la lanzo.
+    const quiereFondo = rawArgs.includes("--fondo");
+    const quiereParar = rawArgs.includes("--parar");
+    const quiereEstado = rawArgs.includes("--estado");
+    // --tunel autoriza UN nombre de dominio mas, para entrar por cloudflared o
+    // ngrok desde fuera de casa. Uno concreto: la defensa contra el DNS rebinding
+    // sigue en pie para todos los demas.
+    const posTunel = rawArgs.indexOf("--tunel");
+    const tunelWeb = posTunel >= 0 ? String(rawArgs[posTunel + 1] || "") : "";
     const posPuerto = rawArgs.indexOf("--puerto");
     const puertoWeb = posPuerto >= 0 ? Number(rawArgs[posPuerto + 1]) || 0 : 0;
     // Ojo: lo que sobra de argv se convierte en la orden a ejecutar. Una bandera
     // que no se filtre aqui no es una bandera ignorada, es una orden al modelo.
-    const banderas = new Set(["--yes", "-y", "--servir", "--servir-red", "--puerto"]);
-    const args = rawArgs.filter((a, i) => !banderas.has(a) && !(posPuerto >= 0 && i === posPuerto + 1 && puertoWeb > 0));
+    const banderas = new Set([
+        "--yes",
+        "-y",
+        "--servir",
+        "--servir-red",
+        "--puerto",
+        "--fondo",
+        "--parar",
+        "--estado",
+        "--tunel",
+    ]);
+    const args = rawArgs.filter((a, i) => !banderas.has(a) &&
+        !(posPuerto >= 0 && i === posPuerto + 1 && puertoWeb > 0) &&
+        !(posTunel >= 0 && i === posTunel + 1 && !!tunelWeb));
     const singlePrompt = args.join(" ").trim();
+    // ESTAS DOS NO ARRANCAN NADA, y por eso van aqui arriba: montar el agente
+    // entero -API key, skills, MCP- para luego solo decir un PID seria hacer
+    // esperar al usuario por nada, y ademas pediria la clave a quien solo quiere
+    // apagar la sesion de ayer.
+    if (quiereParar) {
+        const res = await pararSesion();
+        console.log(res.ok ? chalk.green(`\n  ✔ ${res.mensaje}\n`) : chalk.yellow(`\n  ${res.mensaje}\n`));
+        process.exit(res.ok ? 0 : 1);
+    }
+    if (quiereEstado) {
+        const viva = sesionViva();
+        if (!viva) {
+            console.log(chalk.gray("\n  No hay ninguna sesion de fondo abierta.\n"));
+            process.exit(1);
+        }
+        console.log(chalk.bold.hex("#e8833a")("\n  🦊 Sesion de fondo abierta"));
+        console.log(`  ${chalk.bold("Enlace:")}  ${chalk.cyan(viva.url)}`);
+        console.log(`  ${chalk.bold("Carpeta:")} ${chalk.white(viva.carpeta)}`);
+        console.log(`  ${chalk.bold("Desde:")}   ${chalk.white(new Date(viva.desde).toLocaleString())}`);
+        console.log(chalk.gray(`  pid ${viva.pid} · ${viva.enRed ? "visible en tu red" : "solo esta maquina"}`));
+        console.log(chalk.gray("\n  Para cerrarla: chocolatito --parar\n"));
+        process.exit(0);
+    }
     // Los errores de uso se resuelven ANTES de la licencia y de la API key: no
     // dependen de estar suscrito, y en CI hay que poder distinguir "lo has
     // invocado mal" de "el agente no pudo".
@@ -283,6 +331,9 @@ ${nodeViejo}
     let isPlanMode = false;
     let systemPrompt = buildSystemPrompt(context, currentModel, skillManager, memoryManager, isPlanMode);
     const agent = new AgentLoop(apiKey, getEngineBaseUrl(), currentModel, systemPrompt);
+    // El historial de cambios es de CADA proyecto y vive en su carpeta, asi que
+    // hay que decirle cual es. Con /cd se vuelve a fijar mas abajo.
+    globalUndoManager.fijarCarpeta(agent.currentCwd);
     // Shift+Tab (en el prompt, durante la generacion o dentro del propio dialogo)
     // cambia el modo de permisos del agente al vuelo. El modo plan no entra en el
     // ciclo: se sigue activando con /plan, para no dejarlo a un golpe de tecla.
@@ -408,16 +459,87 @@ ${nodeViejo}
     // reemplazo los cuatro canales de console para mandarlos a la transcripcion, y
     // la captura tiene que envolver ESA version. Al reves, pantalla envolveria a la
     // captura y al navegador no llegaria nada. Ver servidor/captura.ts.
+    // SOLTARSE DEL TERMINAL
+    //
+    // Se relanza el mismo programa con los mismos argumentos, sin --fondo, y este
+    // proceso se va. El hijo no hereda ni la entrada ni la salida: la ventana se
+    // puede cerrar y la sesion sigue.
+    //
+    // El enlace lo imprime el PADRE, pero el token lo genera el HIJO. Asi que en
+    // vez de inventar un canal para pasarlo, se espera a que el hijo escriba su
+    // archivo de sesion. Eso ademas confirma que arranco de verdad: si el hijo
+    // revienta -puerto ocupado, licencia caducada-, el archivo no aparece y se
+    // dice que fallo, en lugar de imprimir un enlace a nada.
+    if (quiereServir && quiereFondo && !process.env["CHOCOLATITO_EN_FONDO"]) {
+        const yaAbierta = sesionViva();
+        if (yaAbierta) {
+            console.log(chalk.yellow("\n  Ya hay una sesion de fondo abierta."));
+            console.log(`  ${chalk.cyan(yaAbierta.url)}\n`);
+            console.log(chalk.gray("  Para cerrarla: chocolatito --parar\n"));
+            process.exit(1);
+        }
+        olvidarSesion();
+        const pid = lanzarEnFondo(rawArgs.filter((a) => a !== "--fondo"));
+        let viva = null;
+        for (let intento = 0; intento < 100 && !viva; intento++) {
+            await new Promise((r) => setTimeout(r, 100));
+            viva = sesionViva();
+        }
+        if (!viva) {
+            console.log(chalk.red("\n  La sesion de fondo no llego a arrancar."));
+            console.log(chalk.gray(`  Prueba sin --fondo para ver el error (pid ${pid}).\n`));
+            process.exit(1);
+        }
+        console.log(chalk.hex("#e8833a")("\n  🦊 Sesion abierta en segundo plano\n"));
+        console.log(`  ${chalk.bold("Enlace:")} ${chalk.cyan(viva.url)}`);
+        console.log(chalk.gray("\n  Ya puedes cerrar esta ventana: la sesion sigue."));
+        console.log(chalk.gray("  chocolatito --estado  ·  chocolatito --parar\n"));
+        process.exit(0);
+    }
     if (quiereServir) {
         try {
-            iniciarCaptura();
-            const web = await iniciarServidorWeb({ puerto: puertoWeb || undefined, enRed });
+            const web = await iniciarServidorWeb({
+                puerto: puertoWeb || undefined,
+                enRed,
+                anfitrionAutorizado: tunelWeb || undefined,
+                // La carpeta se pregunta en cada peticion, no se copia aqui: con /cd el
+                // agente se cambia a mitad de sesion y lo que suba el movil tiene que
+                // caer donde se esta trabajando AHORA.
+                carpeta: () => agent.currentCwd,
+            });
             marcarServirActivo(true);
+            // Solo el que corre suelto deja su ficha: una sesion normal muere con su
+            // terminal y anotarla solo serviria para que --estado mintiera despues.
+            if (process.env["CHOCOLATITO_EN_FONDO"]) {
+                guardarSesion({
+                    pid: process.pid,
+                    puerto: web.puerto,
+                    token: web.token,
+                    url: web.urlsDeRed[0] || web.url,
+                    carpeta: agent.currentCwd,
+                    desde: new Date().toISOString(),
+                    enRed,
+                });
+                const limpiar = () => olvidarSesion();
+                process.once("exit", limpiar);
+                process.once("SIGINT", () => {
+                    limpiar();
+                    process.exit(0);
+                });
+                process.once("SIGTERM", () => {
+                    limpiar();
+                    process.exit(0);
+                });
+            }
             console.log(chalk.hex("#e8833a")("\n  🦊 Sesión abierta en el navegador\n"));
             console.log(`  ${chalk.bold("Aquí:")}     ${chalk.cyan(web.url)}`);
             for (const dir of web.urlsDeRed) {
                 console.log(`  ${chalk.bold("Del móvil:")} ${chalk.cyan(dir)}`);
             }
+            if (tunelWeb) {
+                console.log(chalk.yellow(`\n  ⚠ Autorizado el tunel ${nombreDeAnfitrion(tunelWeb)}`) +
+                    chalk.gray("\n    Ese enlace sale a internet: quien lo tenga entero entra. Cierrala al acabar."));
+            }
             if (!enRed) {
                 console.log(chalk.gray("\n  Solo desde esta máquina. Para entrar desde el móvil: --servir-red"));
             }
@@ -427,6 +549,28 @@ ${nodeViejo}
                         "\n    puede usar esta sesión. No lo pegues en ningún sitio compartido."));
             }
             console.log(chalk.gray("\n  Lo que escribas aquí ya no se lee: manda el navegador y este terminal es el monitor.\n"));
+            // LA CAPTURA EMPIEZA AQUI, Y NO ANTES, POR DOS MOTIVOS
+            //
+            //  1. EL TOKEN. Lo que se acaba de imprimir incluye "Aqui: http://...?t=..."
+            //     con el token entero. Eso es para el que esta delante del PC; copiarlo
+            //     a la pagina lo deja escrito en la pantalla del movil, a la vista de
+            //     quien pase por al lado y en cualquier captura que se haga.
+            //  2. NO SIRVE DE NADA ALLI. "Para entrar desde el movil: --servir-red" se
+            //     lo estas leyendo YA desde el movil. Son instrucciones para llegar a
+            //     un sitio en el que ya estas.
+            //
+            // Asi que al navegador se le da una bienvenida suya, corta: el zorro y la
+            // carpeta, que es lo unico que hace falta saber al abrir.
+            iniciarCaptura();
+            // Y lo que contesta el agente, que NO va por console: sale por el pie fijo
+            // a process.stdout, asi que hay que copiarlo aparte o el movil se queda mudo.
+            copiarSalidaAlWeb((texto) => anotarCrudoWeb(texto));
+            // La cabecera de la pagina ya lleva el zorro oficial y el nombre, asi que
+            // repetirlo aqui con un emoji era decir dos veces lo mismo, y con dos
+            // dibujos distintos del mismo zorro. Queda la carpeta, que es lo unico que
+            // hace falta saber al abrir: en que proyecto estas.
+            anotarWeb(chalk.gray(`  ${agent.currentCwd}`));
+            anotarWeb("");
             // Una orden en la linea de comandos con --servir es la PRIMERA del turno,
             // no una tarea suelta: entra por la misma puerta que lo que llegue del movil.
             if (singlePrompt)
@@ -504,6 +648,48 @@ ${nodeViejo}
             }
             continue;
         }
+        if (trimmed === "/rewind" || trimmed.startsWith("/rewind ")) {
+            const pedido = trimmed.slice(7).trim();
+            const turnos = globalUndoManager.turnos();
+            if (turnos.length === 0) {
+                console.log(chalk.gray("\n  No hay nada guardado que deshacer en este proyecto.\n"));
+                continue;
+            }
+            if (!pedido) {
+                console.log(chalk.bold.hex("#D97757")("\n⏪ VOLVER ATRÁS"));
+                console.log(chalk.gray("  Lo que Chocolatito ha tocado en esta carpeta, de lo más nuevo a lo más viejo:\n"));
+                // Del mas nuevo al mas viejo: lo que quieres deshacer casi siempre es lo
+                // ultimo, y leerlo del reves obliga a contar renglones.
+                const alReves = [...turnos].reverse();
+                alReves.forEach((t, i) => {
+                    const cuando = new Date(t.cuando).toLocaleString();
+                    const conCopia = t.archivos.filter((a) => a.tipo === "file").length;
+                    const creados = t.archivos.filter((a) => a.tipo === "absent").length;
+                    const sinCopia = t.archivos.filter((a) => a.tipo === "unrestorable").length;
+                    const piezas = [
+                        conCopia ? `${conCopia} restaurable(s)` : "",
+                        creados ? `${creados} creado(s)` : "",
+                        sinCopia ? chalk.yellow(`${sinCopia} SIN copia`) : "",
+                    ].filter(Boolean);
+                    console.log(`  ${chalk.bold.white(String(i + 1).padStart(2))}. ${chalk.white(t.descripcion.slice(0, 60))}`);
+                    console.log(`      ${chalk.gray(cuando)}  ${chalk.gray(piezas.join(" · "))}`);
+                });
+                console.log(chalk.gray("\n  /rewind <n> vuelve a como estaba ANTES de ese turno (y deshace los de después).\n"));
+                continue;
+            }
+            const indice = Number(pedido);
+            if (!Number.isInteger(indice) || indice < 1 || indice > turnos.length) {
+                console.log(chalk.yellow(`\n  Elige un número del 1 al ${turnos.length}. /rewind a secas los lista.\n`));
+                continue;
+            }
+            const elegido = [...turnos].reverse()[indice - 1];
+            const res = globalUndoManager.volverAntesDe(elegido.id);
+            console.log(res.success ? chalk.green(`\n${res.message}`) : chalk.yellow(`\n${res.message}`));
+            res.restoredFiles.forEach((r) => console.log(`  ${chalk.gray("•")} ${chalk.white(r)}`));
+            res.failures.forEach((r) => console.log(`  ${chalk.red("✗")} ${chalk.yellow(r)}`));
+            console.log("");
+            continue;
+        }
         if (trimmed === "/undo") {
             const undoRes = globalUndoManager.undoLast();
             // Lo que no se pudo deshacer se imprime siempre, tambien cuando algo si se
@@ -522,15 +708,15 @@ ${nodeViejo}
                 .filter((m) => m.role === "user" || m.role === "assistant")
                 .map((m) => `### 👤 ${m.role === "user" ? "Usuario" : "Chocolatito"}\n\n${typeof m.content === "string" ? m.content : JSON.stringify(m.content, null, 2)}\n`)
                 .join("\n---\n\n");
-            const mdContent = `# 🦊 Bitácora de Sesión — Chocolatito Code
-**Fecha:** ${new Date().toLocaleString()}  
-**Directorio:** \`${agent.currentCwd}\`  
-**Motor:** ${currentModel.name}  
-**Inversión Total:** ${agent.tracker.calculateCost(undefined, undefined, undefined, currentModel.underlyingModel).formattedCost}  
-
----
-
-${sessionData}
+            const mdContent = `# 🦊 Bitácora de Sesión — Chocolatito Code
+**Fecha:** ${new Date().toLocaleString()}  
+**Directorio:** \`${agent.currentCwd}\`  
+**Motor:** ${currentModel.name}  
+**Inversión Total:** ${agent.tracker.calculateCost(undefined, undefined, undefined, currentModel.underlyingModel).formattedCost}  
+
+---
+
+${sessionData}
 `;
             fs.writeFileSync(exportPath, mdContent, "utf-8");
             console.log(chalk.green(`\n✔ Bitácora exportada exitosamente en: ${chalk.bold.white(exportPath)}\n`));
@@ -746,12 +932,12 @@ ${sessionData}
             }
             console.log(chalk.bold.hex("#A855F7")("\n🎯 INICIANDO MODO META AUTÓNOMA (GOAL MODE):"));
             console.log(chalk.gray(`  Objetivo: "${goalText}"\n`));
-            const autonomousPrompt = `[MODO META AUTÓNOMA ACTIVADO]
-Tu objetivo principal es: "${goalText}"
-Directivas de ejecución:
-1. Formula un plan de ejecución mental paso a paso.
-2. Ejecuta cada paso utilizando las herramientas correspondientes (creación, edición, ejecución, verificación).
-3. Si algo falla o hay errores, autocorregir inmediatamente y volver a probar.
+            const autonomousPrompt = `[MODO META AUTÓNOMA ACTIVADO]
+Tu objetivo principal es: "${goalText}"
+Directivas de ejecución:
+1. Formula un plan de ejecución mental paso a paso.
+2. Ejecuta cada paso utilizando las herramientas correspondientes (creación, edición, ejecución, verificación).
+3. Si algo falla o hay errores, autocorregir inmediatamente y volver a probar.
 4. No te detengas hasta verificar que el objetivo esté 100% completado con éxito.`;
             renderUserPrompt(`/goal ${goalText}`);
             await agent.runTask(autonomousPrompt);
@@ -774,7 +960,7 @@ Directivas de ejecución:
         if (trimmed === "/diff") {
             const diffOut = await gitDiff(false, agent.currentCwd);
             console.log(chalk.bold.hex("#D97757")("\n📝 DIFERENCIAS DE GIT (DIFF):"));
-            console.log(diffOut ? chalk.gray(diffOut) : chalk.green("✔ Sin cambios pendientes.") + "\n");
+            console.log(diffOut ? `${formatColorDiff(diffOut)}\n` : chalk.green("✔ Sin cambios pendientes.") + "\n");
             continue;
         }
         if (trimmed === "/audit" || trimmed === "/review" || trimmed.startsWith("/audit ") || trimmed.startsWith("/review ")) {
@@ -799,6 +985,9 @@ Directivas de ejecución:
             if (res.success) {
                 agent.currentCwd = res.newCwd;
                 memoryManager.setCwd(agent.currentCwd);
+                // El historial de cambios es de cada proyecto: al cambiar de carpeta se
+                // cambia de historial, o /rewind ensenaria los turnos de otro sitio.
+                globalUndoManager.fijarCarpeta(agent.currentCwd);
                 const refreshedContext = await getProjectContext(agent.currentCwd);
                 systemPrompt = buildSystemPrompt(refreshedContext, currentModel, skillManager, memoryManager, isPlanMode);
                 agent.clearHistory(systemPrompt);
@@ -861,12 +1050,12 @@ Directivas de ejecución:
             const refreshedContext = await getProjectContext(agent.currentCwd);
             const updatedPrompt = buildSystemPrompt(refreshedContext, currentModel, skillManager, memoryManager, isPlanMode);
             agent.setEspectroModel(currentModel, updatedPrompt);
-            console.log(chalk.green(`
+            console.log(chalk.green(`
 ✔ Nivel actualizado a `) +
                 chalk.bold.hex("#A855F7")(currentModel.name) +
                 chalk.gray(` (${currentModel.effortLevel})`) +
-                `
-  ${chalk.italic.gray(currentModel.description)}
+                `
+  ${chalk.italic.gray(currentModel.description)}
 `);
             // EL TECLADO SE QUEDABA TRABADO AL CAMBIAR DE MOTOR
             //

package/dist/prompts/systemPrompt.js

@@ -172,17 +172,21 @@ Puedes delegar tareas aisladas con 'spawn_agent':
    NUNCA pidas al usuario su contraseña ni la escribas. Si hace falta una cuenta, es
    él quien inicia sesión a mano.
 
-   APLICACIONES DE ESCRITORIO: usa 'computer_use'.
-     * Flujo: computer_use(list_windows) → computer_use(ui_snapshot, window:"...")
-       → computer_use(ui_click, ref:N).
-     * Pasa SIEMPRE 'window'. Sin ella actúas sobre lo que esté delante, que es
-       exactamente como se acaba escribiendo en la ventana equivocada.
-     * El modo por defecto es 'background': no robes el foco salvo que sea imprescindible.
-
-   CUANDO NO HAY ÁRBOL DE ACCESIBILIDAD (lienzos, vídeo, juegos, imágenes):
-     * 'screenshot' con 'window' captura esa ventana aunque esté tapada, y te la describe.
-     * 'find_element' localiza un control por texto y te da sus coordenadas reales.
-     * Solo entonces tiene sentido un click por coordenadas.
+    APLICACIONES DE ESCRITORIO: usa 'computer_use' (nivel Astra / OpenAI Operator):
+      * Flujo preferente: computer_use(list_windows) → computer_use(ui_snapshot, window:"...")
+        → computer_use(ui_click, ref:N).
+      * Pasa SIEMPRE 'window'. Sin ella actúas sobre lo que esté delante, que es
+        exactamente como se acaba escribiendo en la ventana equivocada.
+      * El modo por defecto es 'background': no robes el foco salvo que sea imprescindible.
+      * FLUJOS RÁPIDOS (ACTION CHAINING): Para secuencias interactivas comunes
+        (ej. clic en campo -> escribir texto -> pulsar Enter -> esperar resultado),
+        usa action: 'sequence' con 'steps'. Ejecuta todo en milisegundos en un solo turno sin latencia.
+      * CUANDO NO HAY ÁRBOL DE ACCESIBILIDAD (lienzos, juegos, vídeo, Flutter, interfaces gráficas complejas):
+        - Usa 'screenshot' con 'grid: true' para activar la cuadrícula de coordenadas milimétricas y situar controles con exactitud.
+        - Usa 'screenshot' con 'region: [x1,y1,x2,y2]' para inspeccionar zonas pequeñas o detalles finos en resolución nativa 1:1.
+        - Usa 'wait_visual_change' para esperar animaciones, cargas o cambios visuales cuando la app no emite eventos de accesibilidad.
+        - Usa 'find_element' para localizar un control por texto en el árbol o visualmente mediante visión multimodal.
+      * COORDENADAS: Soporta píxeles físicos o coordenadas normalizadas (0..1000 con normalized: true). Si 'ui_click' no tiene patrón nativo, se auto-recupera clicando el centro del elemento.
 
    PROHIBIDO: 'taskkill' o matar procesos de Chrome del usuario.
 8. LO QUE PRODUCES ES DEL USUARIO, NO TUYO:

package/dist/servidor/archivos.d.ts

@@ -0,0 +1,69 @@
+/**
+ * ARCHIVOS QUE ENTRAN Y ARCHIVOS QUE SALEN
+ *
+ * DE DONDE SALE
+ *
+ * La pagina de `--servir` solo sabia texto. Ni un `<input type=file>`, ni una
+ * sola `<img>`. Y eso deja el ciclo de trabajo cojo por los dos extremos:
+ *
+ *  - Lo que tienes en el movil -la foto, el video que te mando el cliente, la
+ *    captura del error- no hay forma de metarlo. Habia que pasarlo antes al PC.
+ *  - Lo que el agente produce se contesta con la RUTA. En un movil, "lo tienes
+ *    en C:\Users\...\salida\pieza-01.png" no sirve para nada: no puedes mirarlo,
+ *    asi que no puedes opinar, asi que no puedes trabajar.
+ *
+ * LAS DOS REGLAS
+ *
+ *  1. LO QUE ENTRA CAE EN UN SOLO SITIO: `entradas/` de la carpeta de trabajo.
+ *     No se deja elegir destino. Un nombre de archivo que llega por la red no
+ *     es un nombre: es lo que alguien escribio al otro lado, y "..\..\.ssh\id_rsa"
+ *     tambien es un nombre. Se le quita todo lo que parezca una ruta y se queda
+ *     el nombre pelado.
+ *
+ *  2. LO QUE SALE NO PUEDE SALIRSE DE LA CARPETA DE TRABAJO. Se resuelve la
+ *     ruta de verdad -con enlaces simbolicos ya seguidos- y se comprueba que
+ *     sigue estando dentro. Sin eso, `?ruta=../../.chocolatitorc` serviria la
+ *     clave de API por HTTP a quien tenga el enlace.
+ *
+ * Las dos comprobaciones viven aqui y no en el servidor a proposito: son la
+ * clase de cosa que se copia mal cuando se reparte entre tres sitios.
+ */
+/** Lo mas grande que se acepta de una vez. Un video de movil cabe de sobra. */
+export declare const LIMITE_DE_SUBIDA: number;
+/** Donde caen los archivos que llegan del navegador. */
+export declare const CARPETA_DE_ENTRADAS = "entradas";
+export declare function tipoDelArchivo(ruta: string): string;
+export declare function esImagen(ruta: string): boolean;
+/**
+ * Deja un nombre de archivo en algo que no pueda salirse de su carpeta.
+ *
+ * No vale con quitar "..": en Windows tambien separa la barra invertida, y
+ * "C:algo" es una ruta relativa al disco C. Se parte por los dos separadores y
+ * se toma el ultimo trozo, que es lo unico que de verdad es un nombre.
+ */
+export declare function nombreSeguro(propuesto: string): string;
+/** Si ya existe, se numera en vez de pisar lo que hubiera. */
+export declare function rutaLibre(carpeta: string, nombre: string): string;
+export interface Guardado {
+    ok: boolean;
+    ruta?: string;
+    error?: string;
+}
+export declare function guardarSubida(cwd: string, nombrePropuesto: string, datos: Buffer): Guardado;
+/**
+ * Comprueba que una ruta pedida por el navegador se puede servir.
+ *
+ * Devuelve la ruta real o null. Null es un 404 siempre, tambien cuando el
+ * archivo existe pero esta fuera: decir "existe pero no te lo doy" ya es contar
+ * algo del disco de alguien a quien no le hemos preguntado.
+ */
+export declare function rutaServible(cwd: string, pedida: string): string | null;
+/**
+ * La linea que se le mete a la conversacion cuando llegan archivos.
+ *
+ * Lleva las rutas COMPLETAS y no los nombres: el modelo tiene que poder
+ * abrirlos sin adivinar donde cayeron, y "la foto que acabo de subir" no es una
+ * ruta. Y se dice que vienen del navegador, porque cambia lo que hay que hacer
+ * con ellos: no son archivos del proyecto, son material que acaba de llegar.
+ */
+export declare function avisoDeSubida(rutas: string[]): string;

package/dist/servidor/archivos.js

@@ -0,0 +1,156 @@
+import fs from "node:fs";
+import path from "node:path";
+/**
+ * ARCHIVOS QUE ENTRAN Y ARCHIVOS QUE SALEN
+ *
+ * DE DONDE SALE
+ *
+ * La pagina de `--servir` solo sabia texto. Ni un `<input type=file>`, ni una
+ * sola `<img>`. Y eso deja el ciclo de trabajo cojo por los dos extremos:
+ *
+ *  - Lo que tienes en el movil -la foto, el video que te mando el cliente, la
+ *    captura del error- no hay forma de metarlo. Habia que pasarlo antes al PC.
+ *  - Lo que el agente produce se contesta con la RUTA. En un movil, "lo tienes
+ *    en C:\Users\...\salida\pieza-01.png" no sirve para nada: no puedes mirarlo,
+ *    asi que no puedes opinar, asi que no puedes trabajar.
+ *
+ * LAS DOS REGLAS
+ *
+ *  1. LO QUE ENTRA CAE EN UN SOLO SITIO: `entradas/` de la carpeta de trabajo.
+ *     No se deja elegir destino. Un nombre de archivo que llega por la red no
+ *     es un nombre: es lo que alguien escribio al otro lado, y "..\..\.ssh\id_rsa"
+ *     tambien es un nombre. Se le quita todo lo que parezca una ruta y se queda
+ *     el nombre pelado.
+ *
+ *  2. LO QUE SALE NO PUEDE SALIRSE DE LA CARPETA DE TRABAJO. Se resuelve la
+ *     ruta de verdad -con enlaces simbolicos ya seguidos- y se comprueba que
+ *     sigue estando dentro. Sin eso, `?ruta=../../.chocolatitorc` serviria la
+ *     clave de API por HTTP a quien tenga el enlace.
+ *
+ * Las dos comprobaciones viven aqui y no en el servidor a proposito: son la
+ * clase de cosa que se copia mal cuando se reparte entre tres sitios.
+ */
+/** Lo mas grande que se acepta de una vez. Un video de movil cabe de sobra. */
+export const LIMITE_DE_SUBIDA = 64 * 1024 * 1024;
+/** Donde caen los archivos que llegan del navegador. */
+export const CARPETA_DE_ENTRADAS = "entradas";
+const TIPOS = {
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".webp": "image/webp",
+    ".gif": "image/gif",
+    ".svg": "image/svg+xml",
+    ".bmp": "image/bmp",
+    ".avif": "image/avif",
+    ".pdf": "application/pdf",
+    ".mp4": "video/mp4",
+    ".webm": "video/webm",
+    ".mov": "video/quicktime",
+    ".mp3": "audio/mpeg",
+    ".wav": "audio/wav",
+    ".ogg": "audio/ogg",
+    ".txt": "text/plain; charset=utf-8",
+    ".md": "text/plain; charset=utf-8",
+    ".json": "application/json",
+    ".csv": "text/csv; charset=utf-8",
+};
+export function tipoDelArchivo(ruta) {
+    return TIPOS[path.extname(ruta).toLowerCase()] || "application/octet-stream";
+}
+export function esImagen(ruta) {
+    return tipoDelArchivo(ruta).startsWith("image/");
+}
+/**
+ * Deja un nombre de archivo en algo que no pueda salirse de su carpeta.
+ *
+ * No vale con quitar "..": en Windows tambien separa la barra invertida, y
+ * "C:algo" es una ruta relativa al disco C. Se parte por los dos separadores y
+ * se toma el ultimo trozo, que es lo unico que de verdad es un nombre.
+ */
+export function nombreSeguro(propuesto) {
+    const ultimo = String(propuesto || "")
+        .split(/[\\/]/)
+        .pop()
+        .replace(/^\.+/, "") // nada de ".." ni de archivos ocultos por accidente
+        .replace(/[\x00-\x1f<>:"|?*]/g, "") // lo que Windows no admite, y los de control
+        .trim();
+    const limpio = ultimo.slice(0, 120);
+    return limpio || `archivo-${Date.now()}`;
+}
+/** Si ya existe, se numera en vez de pisar lo que hubiera. */
+export function rutaLibre(carpeta, nombre) {
+    const ext = path.extname(nombre);
+    const base = path.basename(nombre, ext);
+    let intento = path.join(carpeta, nombre);
+    let n = 2;
+    while (fs.existsSync(intento)) {
+        intento = path.join(carpeta, `${base}-${n}${ext}`);
+        n++;
+        if (n > 9999)
+            return path.join(carpeta, `${base}-${Date.now()}${ext}`);
+    }
+    return intento;
+}
+export function guardarSubida(cwd, nombrePropuesto, datos) {
+    if (datos.length === 0)
+        return { ok: false, error: "El archivo llego vacio." };
+    if (datos.length > LIMITE_DE_SUBIDA) {
+        return { ok: false, error: `El archivo pasa de ${Math.round(LIMITE_DE_SUBIDA / 1024 / 1024)} MB.` };
+    }
+    try {
+        const carpeta = path.join(cwd, CARPETA_DE_ENTRADAS);
+        fs.mkdirSync(carpeta, { recursive: true });
+        const destino = rutaLibre(carpeta, nombreSeguro(nombrePropuesto));
+        fs.writeFileSync(destino, datos);
+        return { ok: true, ruta: destino };
+    }
+    catch (err) {
+        return { ok: false, error: err?.message || String(err) };
+    }
+}
+/**
+ * Comprueba que una ruta pedida por el navegador se puede servir.
+ *
+ * Devuelve la ruta real o null. Null es un 404 siempre, tambien cuando el
+ * archivo existe pero esta fuera: decir "existe pero no te lo doy" ya es contar
+ * algo del disco de alguien a quien no le hemos preguntado.
+ */
+export function rutaServible(cwd, pedida) {
+    if (!pedida)
+        return null;
+    try {
+        const absoluta = path.isAbsolute(pedida) ? pedida : path.resolve(cwd, pedida);
+        // realpath ANTES de comparar: si no, un enlace simbolico dentro de la
+        // carpeta apuntando a C:\Users\... pasaria la comprobacion y serviria
+        // cualquier cosa del disco.
+        const real = fs.realpathSync(absoluta);
+        const raiz = fs.realpathSync(cwd);
+        const dentro = real === raiz || real.startsWith(raiz + path.sep);
+        if (!dentro)
+            return null;
+        if (!fs.statSync(real).isFile())
+            return null;
+        return real;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * La linea que se le mete a la conversacion cuando llegan archivos.
+ *
+ * Lleva las rutas COMPLETAS y no los nombres: el modelo tiene que poder
+ * abrirlos sin adivinar donde cayeron, y "la foto que acabo de subir" no es una
+ * ruta. Y se dice que vienen del navegador, porque cambia lo que hay que hacer
+ * con ellos: no son archivos del proyecto, son material que acaba de llegar.
+ */
+export function avisoDeSubida(rutas) {
+    if (rutas.length === 0)
+        return "";
+    if (rutas.length === 1)
+        return `[El usuario subio un archivo desde el navegador: ${rutas[0]}]`;
+    return (`[El usuario subio ${rutas.length} archivos desde el navegador:\n` +
+        rutas.map((r) => `- ${r}`).join("\n") +
+        "]");
+}

package/dist/servidor/captura.d.ts

@@ -28,6 +28,15 @@ export interface LineaWeb {
 }
 /** Mete una linea propia (avisos del servidor, eco de lo que llega del movil). */
 export declare function anotarWeb(texto: string): void;
+export declare function anotarCrudoWeb(texto: string): void;
+/**
+ * Suelta lo que quede sin salto de linea.
+ *
+ * Hace falta porque la ultima linea de una respuesta muchas veces no lo trae, y
+ * sin esto se quedaria esperando un \n que no va a llegar: el final de cada
+ * respuesta desapareceria del movil.
+ */
+export declare function cerrarLineaWeb(): void;
 export declare function iniciarCaptura(): void;
 export declare function detenerCaptura(): void;
 export declare function historialWeb(desde?: number): LineaWeb[];