chocolatito-code 1.6.13 → 1.6.15

package/dist/servidor/servidor.js

@@ -1,11 +1,14 @@
 import http from "node:http";
+import fs from "node:fs";
+import path from "node:path";
 import os from "node:os";
 import crypto from "node:crypto";
 import chalk from "chalk";
 import { WebSocketServer, WebSocket } from "ws";
 import { paginaHtml } from "./pagina.js";
-import { alEscribirWeb, anotarWeb, historialWeb } from "./captura.js";
-import { cancelarPermisosAbiertos, entregarEntrada, fijarEmisorDePermiso, responderPermiso, } from "./puente.js";
+import { LIMITE_DE_SUBIDA, avisoDeSubida, guardarSubida, rutaServible, tipoDelArchivo, } from "./archivos.js";
+import { alEscribirWeb, anotarWeb, cerrarLineaWeb, historialWeb } from "./captura.js";
+import { cancelarPermisosAbiertos, entregarEntrada, fijarAvisoDeTurno, fijarEmisorDePermiso, responderPermiso, } from "./puente.js";
 const PUERTO_POR_DEFECTO = 4700;
 /**
  * Identifica ESTA sesion, y existe por un caso concreto.
@@ -36,7 +39,22 @@ function mismoToken(a, b) {
  * 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 function anfitrionAceptable(host) {
+/**
+ * Host valido: localhost, una IP literal, o EL NOMBRE QUE SE HAYA AUTORIZADO.
+ *
+ * Lo tercero existe por un caso real: el README dice desde el primer dia que
+ * para entrar desde fuera de casa se use Tailscale o cloudflared... y con
+ * cloudflared esto devolvia 401. Tailscale funciona porque reparte IPs, que
+ * pasan la comprobacion; un tunel llega siempre con un nombre de dominio.
+ * O sea que el programa prometia algo que el mismo rechazaba.
+ *
+ * Se arregla SIN quitar la cerradura. No es "acepta cualquier dominio": es
+ * "acepta exactamente este, el que me acabas de decir". Contra el DNS rebinding
+ * -una web cualquiera que apunta su dominio a tu 127.0.0.1 y usa el navegador de
+ * la victima de puente- la defensa sigue entera, porque ese ataque llega con el
+ * dominio del atacante y no con el que tu autorizaste.
+ */
+export function anfitrionAceptable(host, autorizado) {
     if (!host)
         return false;
     let nombre = host.trim();
@@ -53,19 +71,99 @@ export function anfitrionAceptable(host) {
     }
     if (nombre === "localhost")
         return true;
+    if (autorizado && nombre.toLowerCase() === autorizado.toLowerCase())
+        return true;
     return /^[0-9.]+$/.test(nombre) || /^[0-9a-fA-F:]+$/.test(nombre);
 }
+/**
+ * De lo que pegue el usuario, saca el nombre.
+ *
+ * Nadie copia "abc-def.trycloudflare.com": se copia el enlace entero con su
+ * https:// delante, y a veces con la barra final. Exigir el nombre pelado seria
+ * un 401 que nadie sabria explicar.
+ */
+export function nombreDeAnfitrion(entrada) {
+    if (!entrada)
+        return "";
+    const limpio = entrada.trim();
+    try {
+        if (/^[a-z]+:\/\//i.test(limpio))
+            return new URL(limpio).hostname;
+    }
+    catch { }
+    return limpio.replace(/^\/+|\/+$/g, "").split("/")[0].split(":")[0];
+}
 /** Origin, si viene, tiene que ser el mismo sitio. Ver el punto 3. */
-export function origenAceptable(origin, host) {
+/**
+ * Origin, si viene, tiene que ser el mismo sitio. Ver el punto 3.
+ *
+ * CON UN TUNEL DELANTE, "EL MISMO SITIO" NO ES EL MISMO TEXTO
+ *
+ * Se vio en la primera prueba de verdad desde un movil con datos: la pagina
+ * cargaba y el WebSocket rebotaba con 401. El motivo es que cloudflared
+ * REESCRIBE la cabecera Host con la del destino -127.0.0.1:4700-, mientras que
+ * el navegador manda el Origin que el ve, que es el del tunel. Comparados a
+ * pelo no coinciden nunca, asi que la sesion se quedaba muda: el usuario
+ * escribia y no pasaba nada.
+ *
+ * Por eso el dominio autorizado vale tambien como Origin. Y sigue siendo una
+ * cerradura: se acepta EXACTAMENTE ese, el que se escribio en --tunel.
+ */
+export function origenAceptable(origin, host, autorizado) {
     if (!origin)
         return true;
     try {
-        return new URL(origin).host === host;
+        const u = new URL(origin);
+        if (u.host === host)
+            return true;
+        return !!autorizado && u.hostname.toLowerCase() === autorizado.toLowerCase();
     }
     catch {
         return false;
     }
 }
+/**
+ * EL TOKEN TIENE QUE SOBREVIVIR A UNA RECARGA, Y LA URL NO LO HACE
+ *
+ * DE DONDE SALE: primera prueba con un movil de verdad. El enlace se abre bien,
+ * la pagina quita el token de la barra de direcciones -para que no se quede en
+ * el historial ni salga en una captura- y a la primera recarga se acabo la
+ * sesion: la peticion de la propia pagina ya no lleva token, el servidor
+ * contesta 401 "No." y ahi no hay javascript que valga, porque la pagina ni
+ * llega a cargarse. En el terminal salieron trece rechazos seguidos.
+ *
+ * Y en un movil recargar no es raro: es tirar hacia abajo sin querer, y sobre
+ * todo es lo que hace Android solo cuando la pestana se queda de fondo. O sea,
+ * exactamente lo que hay que hacer para probar las notificaciones.
+ *
+ * Se arregla como se arregla en cualquier sitio: al entrar con el token bueno se
+ * deja una cookie, y a partir de ahi el navegador la manda sola en todo -la
+ * pagina, el socket, las imagenes-.
+ *
+ *  - SameSite=Strict: una web ajena no puede hacer que tu navegador la mande.
+ *    Es la misma defensa que el Origin, por otro camino.
+ *  - HttpOnly: no la lee ningun javascript, ni el nuestro.
+ *  - Sin Max-Age: se muere al cerrar el navegador, como la sesion.
+ */
+export const COOKIE_DE_SESION = "chocolatito_web";
+export function tokenDeLaCookie(cabecera) {
+    if (!cabecera)
+        return "";
+    for (const trozo of cabecera.split(";")) {
+        const igual = trozo.indexOf("=");
+        if (igual < 0)
+            continue;
+        if (trozo.slice(0, igual).trim() !== COOKIE_DE_SESION)
+            continue;
+        try {
+            return decodeURIComponent(trozo.slice(igual + 1).trim());
+        }
+        catch {
+            return "";
+        }
+    }
+    return "";
+}
 export function tokenDeLaPeticion(url) {
     if (!url)
         return "";
@@ -86,19 +184,40 @@ export async function iniciarServidorWeb(opciones = {}) {
     const sesion = sesionNueva();
     const clientes = new Set();
     const wss = new WebSocketServer({ noServer: true });
-    const autorizada = (req) => anfitrionAceptable(req.headers.host) &&
-        origenAceptable(req.headers.origin, req.headers.host) &&
-        mismoToken(tokenDeLaPeticion(req.url), token);
+    const tunel = nombreDeAnfitrion(opciones.anfitrionAutorizado);
+    const autorizada = (req) => {
+        if (!anfitrionAceptable(req.headers.host, tunel))
+            return false;
+        if (!origenAceptable(req.headers.origin, req.headers.host, tunel))
+            return false;
+        // El de la URL al entrar; el de la cookie en todo lo demas.
+        return (mismoToken(tokenDeLaPeticion(req.url), token) ||
+            mismoToken(tokenDeLaCookie(req.headers.cookie), token));
+    };
+    const carpetaDeTrabajo = opciones.carpeta || (() => process.cwd());
     const servidor = http.createServer((req, res) => {
         const ruta = (req.url || "/").split("?")[0];
-        if (req.method !== "GET") {
-            res.writeHead(405).end();
+        const rutasConocidas = ["/", "/subir", "/archivo"];
+        if (!rutasConocidas.includes(ruta)) {
+            res.writeHead(404).end();
             return;
         }
-        if (ruta !== "/") {
-            res.writeHead(404).end();
+        const metodoValido = ruta === "/subir"
+            ? req.method === "POST"
+            : // HEAD solo en /archivo: la pagina pregunta "existe esto?" antes de
+                // ofrecer el enlace de guardar, y pedir el archivo entero para
+                // averiguarlo seria mandar un video de 40 MB para no ensenarlo.
+                req.method === "GET" || (ruta === "/archivo" && req.method === "HEAD");
+        if (!metodoValido) {
+            res.writeHead(405).end();
             return;
         }
+        // LA PUERTA ES UNA SOLA PARA LAS TRES RUTAS.
+        //
+        // Antes habia una ruta y por eso la comprobacion vivia pegada a ella. Con
+        // tres, lo que no puede pasar es que cada una traiga su copia: la cuarta se
+        // escribe un martes con prisa y se olvida, y detras de esta puerta hay
+        // ejecucion de comandos en la maquina de alguien.
         if (!autorizada(req)) {
             // Se dice en el terminal: si a alguien le tocan la puerta, tiene derecho a
             // enterarse en el momento y no al revisar registros que nadie revisa.
@@ -106,16 +225,107 @@ export async function iniciarServidorWeb(opciones = {}) {
             res.writeHead(401, { "content-type": "text/plain; charset=utf-8" }).end("No.");
             return;
         }
+        if (ruta === "/subir") {
+            recibirSubida(req, res);
+            return;
+        }
+        if (ruta === "/archivo") {
+            servirArchivo(req, res);
+            return;
+        }
         res.writeHead(200, {
             "content-type": "text/html; charset=utf-8",
             "cache-control": "no-store",
+            // Path=/ para que valga tambien en /ws, /archivo y /subir.
+            "set-cookie": `${COOKIE_DE_SESION}=${encodeURIComponent(token)}; Path=/; HttpOnly; SameSite=Strict`,
             // La pagina no tiene que salir de aqui ni meterse en ningun marco ajeno.
             "x-frame-options": "DENY",
             "referrer-policy": "no-referrer",
-            "content-security-policy": "default-src 'none'; style-src 'unsafe-inline'; script-src 'unsafe-inline'; connect-src 'self' ws: wss:",
+            "content-security-policy": 
+            // img/media 'self': las miniaturas y los videos salen de /archivo, que es
+            // esta misma casa. blob: para la vista previa de lo que aun no se ha
+            // subido. Nada de terceros: la pagina sigue sin pedirle nada a nadie.
+            "default-src 'none'; style-src 'unsafe-inline'; script-src 'unsafe-inline'; " +
+                "img-src 'self' blob: data:; font-src 'self' data:; media-src 'self' blob:; connect-src 'self' ws: wss:",
         });
         res.end(paginaHtml());
     });
+    /** Un archivo que llega del navegador: cuerpo crudo, nombre en la consulta. */
+    function recibirSubida(req, res) {
+        const consulta = new URL(req.url || "/", "http://x").searchParams;
+        const nombre = consulta.get("nombre") || "archivo";
+        // Se corta por tamano MIENTRAS llega, no despues: esperar a tener 500 MB en
+        // memoria para entonces decir que no es justo lo que no hay que hacer.
+        const trozos = [];
+        let total = 0;
+        let cortado = false;
+        req.on("data", (trozo) => {
+            if (cortado)
+                return;
+            total += trozo.length;
+            if (total > LIMITE_DE_SUBIDA) {
+                cortado = true;
+                res.writeHead(413, { "content-type": "application/json" }).end(JSON.stringify({ ok: false, error: "El archivo es demasiado grande." }));
+                req.destroy();
+                return;
+            }
+            trozos.push(trozo);
+        });
+        req.on("end", () => {
+            if (cortado)
+                return;
+            const guardado = guardarSubida(carpetaDeTrabajo(), nombre, Buffer.concat(trozos));
+            if (!guardado.ok) {
+                res.writeHead(400, { "content-type": "application/json" }).end(JSON.stringify(guardado));
+                return;
+            }
+            anotarWeb(chalk.gray(`  ⇩ Llego del navegador: ${guardado.ruta}`));
+            res.writeHead(200, { "content-type": "application/json" }).end(JSON.stringify(guardado));
+        });
+        req.on("error", () => {
+            if (!cortado)
+                res.writeHead(400).end();
+        });
+    }
+    /** Un archivo de la carpeta de trabajo, para verlo en el navegador. */
+    function servirArchivo(req, res) {
+        const consulta = new URL(req.url || "/", "http://x").searchParams;
+        const real = rutaServible(carpetaDeTrabajo(), consulta.get("ruta") || "");
+        // Fuera de la carpeta es un 404, no un 403: decir "existe pero no te lo doy"
+        // ya cuenta algo del disco de alguien que no ha preguntado.
+        if (!real) {
+            res.writeHead(404).end();
+            return;
+        }
+        // "descargar" cambia una palabra de la cabecera y con eso el navegador deja
+        // de ensenar el archivo y lo guarda. Es la ultima milla del movil: el agente
+        // exporta la pieza, la ves, y te la llevas para mandarsela al cliente sin
+        // pasar por el ordenador.
+        const guardar = consulta.get("descargar") === "1";
+        const nombre = path.basename(real).replace(/"/g, "");
+        try {
+            const tam = fs.statSync(real).size;
+            res.writeHead(200, {
+                "content-type": tipoDelArchivo(real),
+                "content-length": String(tam),
+                "cache-control": "no-store",
+                // Que el navegador no se ponga a adivinar el tipo: un .txt con HTML
+                // dentro no se ejecuta como pagina.
+                "x-content-type-options": "nosniff",
+                "content-disposition": `${guardar ? "attachment" : "inline"}; filename="${nombre}"`,
+            });
+            // HEAD es la pregunta sin la respuesta: las cabeceras dicen que existe,
+            // que tamano tiene y de que tipo es, y no se mueve un solo byte del disco.
+            if (req.method === "HEAD") {
+                res.end();
+                return;
+            }
+            res.end(fs.readFileSync(real));
+        }
+        catch {
+            res.writeHead(404).end();
+        }
+    }
     servidor.on("upgrade", (req, socket, head) => {
         const ruta = (req.url || "/").split("?")[0];
         if (ruta !== "/ws" || !autorizada(req)) {
@@ -180,6 +390,19 @@ export async function iniciarServidorWeb(opciones = {}) {
             catch {
                 return;
             }
+            if (m?.t === "entrada" && typeof m.texto === "string") {
+                // Los archivos que se acaban de subir van DELANTE de lo que escribio el
+                // usuario, y con la ruta entera. El aviso se compone aqui y no en la
+                // pagina para que la forma de decirlo viva en un solo sitio.
+                const subidos = Array.isArray(m.archivos)
+                    ? m.archivos.filter((r) => typeof r === "string" && r.length > 0)
+                    : [];
+                if (subidos.length > 0) {
+                    const aviso = avisoDeSubida(subidos);
+                    m.texto = m.texto.trim() ? `${aviso}
+${m.texto}` : aviso;
+                }
+            }
             if (m?.t === "entrada" && typeof m.texto === "string") {
                 const texto = m.texto.slice(0, 20_000).trim();
                 if (texto)
@@ -204,6 +427,15 @@ export async function iniciarServidorWeb(opciones = {}) {
         });
     });
     fijarEmisorDePermiso((peticion) => aTodos({ t: "permiso", ...peticion }) > 0);
+    // El agente se puso a esperar: para el movil, eso es "ya esta".
+    fijarAvisoDeTurno(() => {
+        // Primero se suelta lo que quede a medias. La ultima linea de una respuesta
+        // casi nunca trae salto de linea -el modelo acaba con un punto-, asi que sin
+        // esto el final de CADA respuesta se quedaba esperando un salto que no llega
+        // nunca: justo la frase que el usuario esta esperando leer.
+        cerrarLineaWeb();
+        aTodos({ t: "turno" });
+    });
     const puerto = await new Promise((resolve, reject) => {
         servidor.once("error", reject);
         servidor.listen(puertoPedido, anfitrion, () => {

package/dist/tools/computerUse.d.ts

@@ -23,7 +23,7 @@
  *     "background": se actua sobre una ventana concreta sin traerla al frente y
  *     sin mover el raton del usuario.
  */
-export type ComputerAction = "screenshot" | "ui_snapshot" | "ui_click" | "ui_type" | "ui_focus" | "find_element" | "left_click" | "click" | "double_click" | "triple_click" | "right_click" | "middle_click" | "mouse_move" | "move" | "left_click_drag" | "scroll" | "type" | "key" | "hotkey" | "wait" | "wait_change" | "sleep" | "cursor_position" | "list_windows" | "focus_window" | "get_active_window" | "open_app";
+export type ComputerAction = "screenshot" | "ui_snapshot" | "ui_click" | "ui_type" | "ui_focus" | "find_element" | "left_click" | "click" | "mouse_click" | "double_click" | "triple_click" | "right_click" | "middle_click" | "mouse_move" | "move" | "left_click_drag" | "drag" | "scroll" | "type" | "key" | "hotkey" | "press" | "key_press" | "wait" | "wait_change" | "wait_visual_change" | "sequence" | "scroll_into_view" | "scroll_to" | "read_text" | "get_text" | "sleep" | "cursor_position" | "list_windows" | "focus_window" | "get_active_window" | "open_app";
 export interface ComputerUseParams {
     action: ComputerAction;
     /** Ventana objetivo por titulo o proceso (ej. "chrome", "Flow"). */
@@ -42,6 +42,8 @@ export interface ComputerUseParams {
     key?: string;
     query?: string;
     filter?: string;
+    target?: string | number;
+    maxAttempts?: number;
     direction?: "up" | "down" | "left" | "right";
     amount?: number;
     repeat?: number;
@@ -54,5 +56,13 @@ export interface ComputerUseParams {
     question?: string;
     /** Solo para screenshot: pone false para saltarse la vision y ahorrar tokens. */
     analyze?: boolean;
+    /** Solo para screenshot/find_element: dibuja una cuadrícula de coordenadas sobre la captura. */
+    grid?: boolean;
+    /** Región de interés [x1, y1, x2, y2] para capturar o esperar cambios en alta resolución. */
+    region?: [number, number, number, number];
+    /** Sub-acciones a ejecutar en ráfaga para action="sequence". */
+    steps?: ComputerUseParams[];
+    /** true si las coordenadas están en escala 0..1000 estilo OpenAI Operator / Astra. */
+    normalized?: boolean;
 }
 export declare function computerUse(params: ComputerUseParams, cwd?: string, apiKey?: string): Promise<string>;