chocolatito-code 1.6.6 → 1.6.8

package/dist/servidor/servidor.js

@@ -0,0 +1,249 @@
+import http from "node:http";
+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";
+const PUERTO_POR_DEFECTO = 4700;
+/**
+ * Identifica ESTA sesion, y existe por un caso concreto.
+ *
+ * El navegador reconecta pidiendo «desde la linea N». Si mientras tanto se
+ * reinicio `chocolatito --servir`, la sesion nueva empieza a contar desde 1, y
+ * ese «desde N» se tragaria las N primeras lineas: el movil se queda en blanco
+ * y parece que no funciona. Con esto, una sesion distinta manda el historial
+ * entero y el navegador tira lo que tenia.
+ */
+function sesionNueva() {
+    return crypto.randomBytes(6).toString("hex");
+}
+/** Coalescencia del envio: un turno del modelo son cientos de lineas. */
+const MS_DE_AGRUPADO = 40;
+function tokenNuevo() {
+    return crypto.randomBytes(24).toString("base64url");
+}
+function mismoToken(a, b) {
+    const ba = Buffer.from(a);
+    const bb = Buffer.from(b);
+    // timingSafeEqual exige el mismo largo, y su excepcion ya filtraria el largo.
+    if (ba.length !== bb.length)
+        return false;
+    return crypto.timingSafeEqual(ba, bb);
+}
+/**
+ * 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) {
+    if (!host)
+        return false;
+    let nombre = host.trim();
+    if (nombre.startsWith("[")) {
+        const cierre = nombre.indexOf("]");
+        if (cierre < 0)
+            return false;
+        nombre = nombre.slice(1, cierre);
+    }
+    else {
+        const dosPuntos = nombre.lastIndexOf(":");
+        if (dosPuntos > 0)
+            nombre = nombre.slice(0, dosPuntos);
+    }
+    if (nombre === "localhost")
+        return true;
+    return /^[0-9.]+$/.test(nombre) || /^[0-9a-fA-F:]+$/.test(nombre);
+}
+/** Origin, si viene, tiene que ser el mismo sitio. Ver el punto 3. */
+export function origenAceptable(origin, host) {
+    if (!origin)
+        return true;
+    try {
+        return new URL(origin).host === host;
+    }
+    catch {
+        return false;
+    }
+}
+export function tokenDeLaPeticion(url) {
+    if (!url)
+        return "";
+    try {
+        return new URL(url, "http://x").searchParams.get("t") || "";
+    }
+    catch {
+        return "";
+    }
+}
+export async function iniciarServidorWeb(opciones = {}) {
+    const token = opciones.token || tokenNuevo();
+    const enRed = !!opciones.enRed;
+    const anfitrion = enRed ? "0.0.0.0" : "127.0.0.1";
+    // 0 es valido y significa «uno libre, el que sea». Con `||` se convertia en
+    // el de por defecto y dos servidores a la vez chocaban.
+    const puertoPedido = opciones.puerto === undefined ? PUERTO_POR_DEFECTO : opciones.puerto;
+    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 servidor = http.createServer((req, res) => {
+        const ruta = (req.url || "/").split("?")[0];
+        if (req.method !== "GET") {
+            res.writeHead(405).end();
+            return;
+        }
+        if (ruta !== "/") {
+            res.writeHead(404).end();
+            return;
+        }
+        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.
+            anotarWeb(chalk.yellow("⚠ Se rechazo una conexion a la sesion web (token u origen incorrecto)."));
+            res.writeHead(401, { "content-type": "text/plain; charset=utf-8" }).end("No.");
+            return;
+        }
+        res.writeHead(200, {
+            "content-type": "text/html; charset=utf-8",
+            "cache-control": "no-store",
+            // 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:",
+        });
+        res.end(paginaHtml());
+    });
+    servidor.on("upgrade", (req, socket, head) => {
+        const ruta = (req.url || "/").split("?")[0];
+        if (ruta !== "/ws" || !autorizada(req)) {
+            // El upgrade es el que manda ordenes: si algo falla aqui, se corta en seco.
+            socket.write("HTTP/1.1 401 Unauthorized\r\n\r\n");
+            socket.destroy();
+            return;
+        }
+        wss.handleUpgrade(req, socket, head, (ws) => {
+            wss.emit("connection", ws, req);
+        });
+    });
+    // ---------------------------------------------------- envio de lineas
+    let porEnviar = [];
+    let temporizador = null;
+    const repartir = () => {
+        temporizador = null;
+        if (!porEnviar.length || !clientes.size) {
+            porEnviar = [];
+            return;
+        }
+        const mensaje = JSON.stringify({ t: "lineas", lineas: porEnviar });
+        porEnviar = [];
+        for (const ws of clientes) {
+            if (ws.readyState === WebSocket.OPEN)
+                ws.send(mensaje);
+        }
+    };
+    const dejarDeEscuchar = alEscribirWeb((linea) => {
+        porEnviar.push(linea);
+        if (!temporizador) {
+            temporizador = setTimeout(repartir, MS_DE_AGRUPADO);
+            // 40 ms no pueden ser la razon de que el proceso siga vivo al terminar.
+            temporizador.unref?.();
+        }
+    });
+    const aTodos = (obj) => {
+        const mensaje = JSON.stringify(obj);
+        let enviados = 0;
+        for (const ws of clientes) {
+            if (ws.readyState === WebSocket.OPEN) {
+                ws.send(mensaje);
+                enviados++;
+            }
+        }
+        return enviados;
+    };
+    wss.on("connection", (ws, req) => {
+        clientes.add(ws);
+        const consulta = new URL(req.url || "/", "http://x").searchParams;
+        // Al reconectar solo se manda lo que se perdio: el movil que vuelve de un
+        // tunel no tiene que tragarse la sesion entera otra vez. Pero solo si sigue
+        // siendo la misma sesion; si no, su cuenta no vale y se manda todo.
+        const misma = consulta.get("sesion") === sesion;
+        const desde = misma ? Number(consulta.get("desde") || 0) || 0 : 0;
+        ws.send(JSON.stringify({ t: "lineas", sesion, nueva: !misma, lineas: historialWeb(desde) }));
+        ws.on("message", (datos) => {
+            let m;
+            try {
+                m = JSON.parse(String(datos));
+            }
+            catch {
+                return;
+            }
+            if (m?.t === "entrada" && typeof m.texto === "string") {
+                const texto = m.texto.slice(0, 20_000).trim();
+                if (texto)
+                    entregarEntrada(texto);
+                return;
+            }
+            if (m?.t === "permiso" && Number.isFinite(m.id)) {
+                responderPermiso(Number(m.id), Number(m.opcion), typeof m.comentario === "string" ? m.comentario : undefined);
+                // Los demas dispositivos cierran el dialogo: si no, dos moviles abiertos
+                // se quedan con una pregunta fantasma que ya no espera a nadie.
+                aTodos({ t: "cierre" });
+            }
+        });
+        ws.on("close", () => {
+            clientes.delete(ws);
+            if (!clientes.size) {
+                cancelarPermisosAbiertos("Se cerro la sesion web antes de contestar; no se aprobo nada.");
+            }
+        });
+        ws.on("error", () => {
+            clientes.delete(ws);
+        });
+    });
+    fijarEmisorDePermiso((peticion) => aTodos({ t: "permiso", ...peticion }) > 0);
+    const puerto = await new Promise((resolve, reject) => {
+        servidor.once("error", reject);
+        servidor.listen(puertoPedido, anfitrion, () => {
+            const dir = servidor.address();
+            resolve(typeof dir === "object" && dir ? dir.port : puertoPedido);
+        });
+    });
+    return {
+        puerto,
+        token,
+        url: `http://127.0.0.1:${puerto}/?t=${token}`,
+        urlsDeRed: enRed ? direccionesDeRed(puerto, token) : [],
+        clientes: () => clientes.size,
+        cerrar: async () => {
+            aTodos({ t: "fin" });
+            dejarDeEscuchar();
+            fijarEmisorDePermiso(null);
+            if (temporizador)
+                clearTimeout(temporizador);
+            for (const ws of clientes) {
+                try {
+                    ws.close();
+                }
+                catch { }
+            }
+            clientes.clear();
+            wss.close();
+            await new Promise((resolve) => servidor.close(() => resolve()));
+        },
+    };
+}
+/** Las IP de la maquina en la red local, para abrirla desde el movil. */
+export function direccionesDeRed(puerto, token) {
+    const salida = [];
+    for (const interfaces of Object.values(os.networkInterfaces())) {
+        for (const inter of interfaces || []) {
+            if (inter.family === "IPv4" && !inter.internal) {
+                salida.push(`http://${inter.address}:${puerto}/?t=${token}`);
+            }
+        }
+    }
+    return salida;
+}

package/dist/sessions/manager.d.ts

@@ -30,4 +30,12 @@ export declare class SessionManager {
         updatedAt: string;
         cwd: string;
     }>;
+    listSessionsDetailed(): Array<{
+        id: string;
+        updatedAt: string;
+        cwd: string;
+        messageCount: number;
+        preview: string;
+        modelId?: string;
+    }>;
 }

package/dist/sessions/manager.js

@@ -79,4 +79,48 @@ export class SessionManager {
         }
         return sesiones.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
     }
+    listSessionsDetailed() {
+        if (!fs.existsSync(this.sessionsDir))
+            return [];
+        let files;
+        try {
+            files = fs.readdirSync(this.sessionsDir).filter((f) => f.endsWith(".json") && f !== "latest.json");
+        }
+        catch {
+            return [];
+        }
+        const sesiones = [];
+        for (const f of files) {
+            try {
+                const data = JSON.parse(fs.readFileSync(path.join(this.sessionsDir, f), "utf-8"));
+                if (!data || typeof data.id !== "string")
+                    continue;
+                const messages = Array.isArray(data.messages) ? data.messages : [];
+                let preview = "";
+                const firstUser = messages.find((m) => m && m.role === "user");
+                if (firstUser) {
+                    if (typeof firstUser.content === "string") {
+                        preview = firstUser.content.replace(/\s+/g, " ").trim();
+                    }
+                    else if (Array.isArray(firstUser.content)) {
+                        const textPart = firstUser.content.find((p) => p && p.type === "text");
+                        preview = (textPart?.text || "").replace(/\s+/g, " ").trim();
+                    }
+                }
+                if (preview.length > 60) {
+                    preview = `${preview.slice(0, 59)}…`;
+                }
+                sesiones.push({
+                    id: data.id,
+                    updatedAt: typeof data.updatedAt === "string" ? data.updatedAt : "",
+                    cwd: typeof data.cwd === "string" ? data.cwd : "",
+                    messageCount: messages.length,
+                    preview: preview || "[Sin mensajes]",
+                    modelId: typeof data.modelId === "string" ? data.modelId : undefined,
+                });
+            }
+            catch { }
+        }
+        return sesiones.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+    }
 }

package/dist/sessions/resume.d.ts

@@ -34,3 +34,15 @@ export declare function prepararRestauracion(sesion: SessionData, actual: {
     cwd: string;
     modelId: string;
 }, motores?: Record<string, unknown>): RestauracionSesion;
+export declare function formatearOpcionesDeSesion(sesiones: Array<{
+    id: string;
+    updatedAt: string;
+    cwd: string;
+    messageCount: number;
+    preview: string;
+    modelId?: string;
+}>): Array<{
+    id: string;
+    titulo: string;
+    detalle: string;
+}>;

package/dist/sessions/resume.js

@@ -41,3 +41,13 @@ function existeDirectorio(ruta) {
         return false;
     }
 }
+export function formatearOpcionesDeSesion(sesiones) {
+    return sesiones.map((s) => {
+        const fecha = s.updatedAt ? s.updatedAt.split("T")[0] || s.updatedAt : "Reciente";
+        return {
+            id: s.id,
+            titulo: `${s.id}  ·  ${fecha} (${s.messageCount} msgs)`,
+            detalle: `${s.preview ? `"${s.preview}" · ` : ""}${s.cwd}`,
+        };
+    });
+}

package/dist/tools/backgroundTask.d.ts

@@ -0,0 +1,64 @@
+import { type ChildProcess } from "node:child_process";
+export type TaskStatus = "running" | "completed" | "failed" | "stopped";
+export interface BackgroundTask {
+    taskId: string;
+    pid: number;
+    command: string;
+    description: string;
+    cwd: string;
+    status: TaskStatus;
+    startTime: number;
+    endTime?: number;
+    exitCode: number | null;
+    logPath: string;
+    child?: ChildProcess;
+}
+export declare class TaskManager {
+    private tasks;
+    private taskCounter;
+    /**
+     * Inicia un proceso en segundo plano, redirigiendo su salida a un archivo de log persistente.
+     */
+    startTask(command: string, cwd?: string, description?: string): Promise<{
+        taskId: string;
+        pid: number;
+        logPath: string;
+        status: string;
+    }>;
+    /**
+     * Lee de forma no bloqueante la salida de una tarea desde su archivo de log.
+     */
+    readTaskOutput(taskId: string, lines?: number, offset?: number): {
+        taskId: string;
+        status: string;
+        exitCode: number | null;
+        output: string;
+        totalLines: number;
+    };
+    /**
+     * Lista todas las tareas registradas con su tiempo transcurrido en segundos.
+     */
+    listTasks(): Array<{
+        taskId: string;
+        pid: number;
+        command: string;
+        description: string;
+        status: string;
+        runtimeSeconds: number;
+        exitCode: number | null;
+    }>;
+    /**
+     * Detiene una tarea activa y elimina todo su árbol de procesos.
+     */
+    stopTask(taskId: string, force?: boolean): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    getTask(taskId: string): BackgroundTask | undefined;
+    /**
+     * Limpia y detiene todas las tareas activas (útil para pruebas y reseteos).
+     */
+    clear(): Promise<void>;
+    private killProcessTree;
+}
+export declare const taskManager: TaskManager;

package/dist/tools/backgroundTask.js

@@ -0,0 +1,264 @@
+import { spawn } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import { esWindows, shellPosix } from "../config/plataforma.js";
+function getTasksDir() {
+    const home = process.env.HOME || process.env.USERPROFILE || os.homedir();
+    const dir = path.join(home, ".chocolatito", "tasks");
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    return dir;
+}
+export class TaskManager {
+    tasks = new Map();
+    taskCounter = 0;
+    /**
+     * Inicia un proceso en segundo plano, redirigiendo su salida a un archivo de log persistente.
+     */
+    async startTask(command, cwd = process.cwd(), description) {
+        const trimmed = command.trim();
+        if (!trimmed) {
+            throw new Error("Comando vacío.");
+        }
+        let taskId = `task-${++this.taskCounter}`;
+        while (this.tasks.has(taskId)) {
+            taskId = `task-${++this.taskCounter}`;
+        }
+        const tasksDir = getTasksDir();
+        const logPath = path.join(tasksDir, `${taskId}.log`);
+        fs.writeFileSync(logPath, "");
+        const isWindows = esWindows;
+        const shellPath = isWindows ? "powershell.exe" : shellPosix("bash");
+        const shellArgs = isWindows
+            ? ["-NoProfile", "-NonInteractive", "-Command", trimmed]
+            : ["-c", trimmed];
+        const logFd = fs.openSync(logPath, "a");
+        let child;
+        try {
+            child = spawn(shellPath, shellArgs, {
+                cwd: cwd || process.cwd(),
+                env: { ...process.env, FORCE_COLOR: "0", NO_COLOR: "1" },
+                windowsHide: true,
+                stdio: ["ignore", logFd, logFd],
+                detached: !isWindows,
+            });
+        }
+        finally {
+            try {
+                fs.closeSync(logFd);
+            }
+            catch { }
+        }
+        child.unref();
+        const task = {
+            taskId,
+            pid: child.pid ?? 0,
+            command: trimmed,
+            description: description || "",
+            cwd: cwd || process.cwd(),
+            status: "running",
+            startTime: Date.now(),
+            exitCode: null,
+            logPath,
+            child,
+        };
+        child.on("exit", (code) => {
+            if (task.status === "stopped")
+                return;
+            task.endTime = Date.now();
+            task.exitCode = code;
+            task.status = code === 0 ? "completed" : "failed";
+        });
+        child.on("error", (err) => {
+            if (task.status === "stopped")
+                return;
+            task.endTime = Date.now();
+            task.status = "failed";
+            task.exitCode = -1;
+            try {
+                fs.appendFileSync(logPath, `\nError al ejecutar proceso: ${err?.message || String(err)}\n`);
+            }
+            catch { }
+        });
+        this.tasks.set(taskId, task);
+        return {
+            taskId,
+            pid: task.pid,
+            logPath,
+            status: task.status,
+        };
+    }
+    /**
+     * Lee de forma no bloqueante la salida de una tarea desde su archivo de log.
+     */
+    readTaskOutput(taskId, lines = 100, offset) {
+        const task = this.tasks.get(taskId);
+        if (!task) {
+            return {
+                taskId,
+                status: "not_found",
+                exitCode: null,
+                output: `Error: No se encontró la tarea con ID "${taskId}".`,
+                totalLines: 0,
+            };
+        }
+        let content = "";
+        try {
+            if (fs.existsSync(task.logPath)) {
+                content = fs.readFileSync(task.logPath, "utf-8");
+            }
+        }
+        catch (err) {
+            return {
+                taskId,
+                status: task.status,
+                exitCode: task.exitCode,
+                output: `Error al leer archivo de log: ${err?.message || String(err)}`,
+                totalLines: 0,
+            };
+        }
+        if (!content) {
+            return {
+                taskId,
+                status: task.status,
+                exitCode: task.exitCode,
+                output: "",
+                totalLines: 0,
+            };
+        }
+        const allLines = content.split(/\r?\n/);
+        if (allLines.length > 0 && allLines[allLines.length - 1] === "") {
+            allLines.pop();
+        }
+        const totalLines = allLines.length;
+        const count = typeof lines === "number" && lines > 0 ? lines : 100;
+        let selectedLines;
+        if (offset !== undefined && offset !== null) {
+            const start = Math.max(0, offset);
+            selectedLines = allLines.slice(start, start + count);
+        }
+        else {
+            selectedLines = allLines.slice(-count);
+        }
+        return {
+            taskId,
+            status: task.status,
+            exitCode: task.exitCode,
+            output: selectedLines.join("\n"),
+            totalLines,
+        };
+    }
+    /**
+     * Lista todas las tareas registradas con su tiempo transcurrido en segundos.
+     */
+    listTasks() {
+        const now = Date.now();
+        return Array.from(this.tasks.values()).map((t) => {
+            const end = t.endTime ?? now;
+            const runtimeSeconds = Math.max(0, Math.floor((end - t.startTime) / 1000));
+            return {
+                taskId: t.taskId,
+                pid: t.pid,
+                command: t.command,
+                description: t.description,
+                status: t.status,
+                runtimeSeconds,
+                exitCode: t.exitCode,
+            };
+        });
+    }
+    /**
+     * Detiene una tarea activa y elimina todo su árbol de procesos.
+     */
+    async stopTask(taskId, force = true) {
+        const task = this.tasks.get(taskId);
+        if (!task) {
+            return {
+                success: false,
+                message: `Error: No se encontró la tarea con ID "${taskId}".`,
+            };
+        }
+        if (task.status !== "running") {
+            return {
+                success: true,
+                message: `La tarea "${taskId}" ya no estaba en ejecución (estado: ${task.status}).`,
+            };
+        }
+        task.status = "stopped";
+        task.endTime = Date.now();
+        await this.killProcessTree(task.pid, force);
+        if (task.child) {
+            try {
+                task.child.kill(force ? "SIGKILL" : "SIGTERM");
+            }
+            catch { }
+        }
+        return {
+            success: true,
+            message: `Tarea "${taskId}" (PID ${task.pid}) detenida con éxito.`,
+        };
+    }
+    getTask(taskId) {
+        return this.tasks.get(taskId);
+    }
+    /**
+     * Limpia y detiene todas las tareas activas (útil para pruebas y reseteos).
+     */
+    async clear() {
+        for (const task of this.tasks.values()) {
+            if (task.status === "running") {
+                task.status = "stopped";
+                task.endTime = Date.now();
+                await this.killProcessTree(task.pid, true);
+                if (task.child) {
+                    try {
+                        task.child.kill("SIGKILL");
+                    }
+                    catch { }
+                }
+            }
+        }
+        this.tasks.clear();
+        this.taskCounter = 0;
+    }
+    killProcessTree(pid, force = true) {
+        return new Promise((resolve) => {
+            if (!pid || pid <= 0) {
+                resolve();
+                return;
+            }
+            if (process.platform === "win32") {
+                try {
+                    const args = ["/pid", String(pid), "/t"];
+                    if (force)
+                        args.push("/f");
+                    const t = spawn("taskkill", args, {
+                        stdio: "ignore",
+                        windowsHide: true,
+                    });
+                    t.on("close", () => resolve());
+                    t.on("error", () => resolve());
+                    setTimeout(resolve, 2000).unref();
+                }
+                catch {
+                    resolve();
+                }
+                return;
+            }
+            const sig = force ? "SIGKILL" : "SIGTERM";
+            try {
+                process.kill(-pid, sig);
+            }
+            catch {
+                try {
+                    process.kill(pid, sig);
+                }
+                catch { }
+            }
+            resolve();
+        });
+    }
+}
+export const taskManager = new TaskManager();

package/dist/tools/browserExtension.d.ts

@@ -40,7 +40,7 @@ declare class ExtensionBridge {
 }
 export declare const extensionBridge: ExtensionBridge;
 export interface ChromeParams {
-    action: "status" | "tabs" | "open" | "select_tab" | "navigate" | "snapshot" | "click" | "type" | "press" | "get_text" | "eval" | "wait_for" | "screenshot" | "notice" | "close_tab" | "done";
+    action: "status" | "tabs" | "open" | "select_tab" | "navigate" | "snapshot" | "click" | "type" | "press" | "get_text" | "eval" | "wait_for" | "screenshot" | "notice" | "close_tab" | "done" | "console_logs" | "network_errors";
     url?: string;
     tabId?: number;
     ref?: number;
@@ -58,6 +58,7 @@ export interface ChromeParams {
     analyze?: boolean;
     outputPath?: string;
     note?: string;
+    clear?: boolean;
 }
 export declare function chromeExtension(params: ChromeParams, cwd?: string, apiKey?: string): Promise<string>;
 export {};