chocolatito-code 1.6.7 → 1.6.8

package/dist/tools/runner.js

@@ -25,6 +25,7 @@ import { globalUndoManager } from "../agent/undoManager.js";
 import { validateFileSyntax } from "../agent/syntaxValidator.js";
 import { fileTracker } from "../agent/fileTracker.js";
 import { mcpManager } from "../mcp/manager.js";
+import { taskManager } from "./backgroundTask.js";
 import fs from "node:fs";
 import path from "node:path";
 /**
@@ -82,10 +83,12 @@ export async function executeToolCall(name, args, cwd = process.cwd(), apiKey, m
                 break;
             }
             case "save_memory":
-                rawResult = memoryManager.saveMemory(args.topic, args.fact);
+                memoryManager.setCwd(cwd);
+                rawResult = memoryManager.saveMemory(args.topic, args.fact, args.scope);
                 break;
             case "read_memory":
-                rawResult = memoryManager.readMemory(args.topic);
+                memoryManager.setCwd(cwd);
+                rawResult = memoryManager.readMemory(args.topic, args.scope);
                 break;
             case "spawn_agent": {
                 if (!apiKey) {
@@ -201,6 +204,37 @@ export async function executeToolCall(name, args, cwd = process.cwd(), apiKey, m
             case "run_command":
                 rawResult = await runCommand(args.command, cwd, args.timeout);
                 break;
+            case "start_background_task": {
+                const res = await taskManager.startTask(args.command, args.cwd || cwd, args.description);
+                rawResult = `Tarea iniciada en segundo plano:\n- ID: ${res.taskId}\n- PID: ${res.pid}\n- Estado: ${res.status}\n- Log: ${res.logPath}`;
+                break;
+            }
+            case "read_task_output": {
+                const res = taskManager.readTaskOutput(args.taskId, args.lines, args.offset);
+                if (res.status === "not_found") {
+                    rawResult = res.output;
+                }
+                else {
+                    rawResult = `[Tarea ${res.taskId}] Estado: ${res.status} (Exit Code: ${res.exitCode !== null ? res.exitCode : "N/A"})\nTotal de líneas: ${res.totalLines}\n--- Salida ---\n${res.output || "(sin salida aún)"}`;
+                }
+                break;
+            }
+            case "list_background_tasks": {
+                const tasks = taskManager.listTasks();
+                if (tasks.length === 0) {
+                    rawResult = "No hay tareas en segundo plano registradas.";
+                }
+                else {
+                    const lines = tasks.map((t) => `- [${t.taskId}] PID ${t.pid} | ${t.status.toUpperCase()} | Ejecución: ${t.runtimeSeconds}s | Comando: "${t.command}"${t.description ? ` (${t.description})` : ""}${t.exitCode !== null ? ` | Exit code: ${t.exitCode}` : ""}`);
+                    rawResult = `Tareas en segundo plano (${tasks.length}):\n${lines.join("\n")}`;
+                }
+                break;
+            }
+            case "stop_background_task": {
+                const res = await taskManager.stopTask(args.taskId, args.force);
+                rawResult = res.message;
+                break;
+            }
             case "list_dir":
                 rawResult = await listDir(args.dirPath || ".", cwd);
                 break;

package/dist/tools/safety.d.ts

@@ -7,6 +7,7 @@
  * estado. En cambio dos escrituras seguidas SI pueden pisarse, y el orden
  * importa, asi que esas van una detras de otra.
  */
+export declare const READ_ONLY_TOOLS: Set<string>;
 export declare function isReadOnly(toolName: string): boolean;
 /**
  * Un lote solo se paraleliza si TODAS sus llamadas son de solo lectura y hay

package/dist/tools/safety.js

@@ -18,7 +18,10 @@ const READ_ONLY = new Set([
     "web_search",
     "read_memory",
     "use_skill",
+    "read_task_output",
+    "list_background_tasks",
 ]);
+export const READ_ONLY_TOOLS = READ_ONLY;
 export function isReadOnly(toolName) {
     return READ_ONLY.has(toolName);
 }

package/dist/tools/todoTool.d.ts

@@ -5,4 +5,6 @@ export interface TaskItem {
 }
 export declare function setSessionTasks(tasks: TaskItem[]): string;
 export declare function getSessionTasks(): TaskItem[];
+export declare function renderTaskWidget(tasks?: TaskItem[]): string | null;
+export declare function sincronizarTareasConPie(tasks?: TaskItem[]): void;
 export declare function renderTaskList(tasks: TaskItem[]): string;

package/dist/tools/todoTool.js

@@ -1,12 +1,41 @@
 import chalk from "chalk";
+import { fijarSeccion, quitarSeccion } from "../ui/pieFijo.js";
 let sessionTasks = [];
 export function setSessionTasks(tasks) {
     sessionTasks = tasks;
+    sincronizarTareasConPie(sessionTasks);
     return renderTaskList(sessionTasks);
 }
 export function getSessionTasks() {
     return sessionTasks;
 }
+export function renderTaskWidget(tasks) {
+    const list = tasks !== undefined ? tasks : sessionTasks;
+    if (!list || list.length === 0)
+        return null;
+    const total = list.length;
+    const completed = list.filter((t) => t.status === "completed").length;
+    const inProgress = list.find((t) => t.status === "in_progress");
+    return (chalk.hex("#D97757")("⎿") +
+        " " +
+        chalk.green("✔") +
+        ` ${completed}/${total} tareas` +
+        (inProgress
+            ? chalk.gray(" · ") + chalk.hex("#D97757")("En curso: ") + chalk.bold.white(inProgress.text)
+            : completed === total
+                ? chalk.green(" · Completado")
+                : ""));
+}
+export function sincronizarTareasConPie(tasks) {
+    const list = tasks !== undefined ? tasks : sessionTasks;
+    const widget = renderTaskWidget(list);
+    if (widget) {
+        fijarSeccion("tareas", [widget]);
+    }
+    else {
+        quitarSeccion("tareas");
+    }
+}
 export function renderTaskList(tasks) {
     if (tasks.length === 0)
         return "No hay tareas registradas.";

package/dist/tools/toolDefsComputer.js

@@ -111,6 +111,8 @@ export const COMPUTER_USE_TOOL = {
                         "scroll",
                         "type",
                         "key",
+                        "hotkey",
+                        "press",
                         "wait",
                         "wait_change",
                         "cursor_position",
@@ -183,11 +185,14 @@ export const CHROME_TOOL = {
                         "status", "tabs", "open", "select_tab", "navigate", "snapshot",
                         "click", "type", "press", "get_text", "eval", "wait_for",
                         "screenshot", "notice", "close_tab", "done",
+                        "console_logs", "network_errors",
                     ],
                     description: "status: comprueba que la extension esta conectada. tabs: lista las pestanas del usuario. " +
                         "open: abre una pestana nueva SIN quitarle la pantalla al usuario. select_tab: elige una ya abierta. " +
                         "snapshot: LEE la pagina y numera los elementos. click/type: actuan sobre un ref. " +
                         "wait_for: espera un texto o unos ms. screenshot: captura la pestana aunque no este visible y la describe. " +
+                        "console_logs: obtiene errores y advertencias de consola y excepciones no controladas de la pagina. " +
+                        "network_errors: obtiene peticiones de red HTTP fallidas (4xx/5xx o errores de conexion). " +
                         "notice: cambia el texto del aviso flotante. close_tab: cierra una pestaña que abriste. done: cierra el trabajo y quita el aviso.",
                 },
                 url: { type: "string", description: "URL para open o navigate." },
@@ -212,6 +217,10 @@ export const CHROME_TOOL = {
                 analyze: { type: "boolean", description: "false para no gastar tokens de vision." },
                 outputPath: { type: "string", description: "Ruta donde guardar la captura." },
                 note: { type: "string", description: "Texto inicial del aviso flotante al abrir la pestana." },
+                clear: {
+                    type: "boolean",
+                    description: "true para limpiar el buffer tras consultar (en console_logs o network_errors).",
+                },
             },
             required: ["action"],
         },

package/dist/tools/win/hostScript.js

@@ -283,9 +283,14 @@ public static class Choco
         double scale = 1.0;
         int longEdge = Math.Max(w, h);
         if (maxLongEdge > 0 && longEdge > maxLongEdge) scale = (double)maxLongEdge / (double)longEdge;
+        ImageFormat fmt = ImageFormat.Png;
+        if (path.EndsWith(".jpg", StringComparison.OrdinalIgnoreCase) || path.EndsWith(".jpeg", StringComparison.OrdinalIgnoreCase))
+        {
+            fmt = ImageFormat.Jpeg;
+        }
         if (scale >= 0.999)
         {
-            bmp.Save(path, ImageFormat.Png);
+            bmp.Save(path, fmt);
             return 1.0;
         }
         int nw = (int)Math.Round(w * scale), nh = (int)Math.Round(h * scale);
@@ -294,7 +299,7 @@ public static class Choco
         {
             g.InterpolationMode = System.Drawing.Drawing2D.InterpolationMode.HighQualityBicubic;
             g.DrawImage(bmp, 0, 0, nw, nh);
-            dst.Save(path, ImageFormat.Png);
+            dst.Save(path, fmt);
         }
         return scale;
     }

package/dist/ui/comandos.js

@@ -35,6 +35,8 @@ export const SLASH_COMMANDS = [
     { name: "/goal", description: "Ejecutar meta compleja autónoma con auto-corrección", args: "<meta>" },
     { name: "/compact", description: "Comprimir contexto y optimizar memoria de la sesión" },
     { name: "/diff", description: "Ver diferencias de código (Git diff) del proyecto" },
+    { name: "/audit", description: "Auditar git diff en busca de secretos, logs residuales y sugerir commit", args: "[review]" },
+    { name: "/review", description: "Revisar cambios pendientes de git (alias de /audit)" },
     { name: "/commit", description: "Crear un commit en Git con mensaje semántico", args: "<mensaje>" },
     { name: "/cd", description: "Cambiar el directorio de trabajo activo", args: "<ruta>" },
     { name: "/uso", description: "Ver cuánto llevas consumido de tu cuenta" },

package/dist/ui/marco.d.ts

@@ -13,6 +13,7 @@ export interface PromptFrameOptions {
     cursorIndex?: number;
     items?: DropdownItem[];
     selectedIndex?: number;
+    taskWidget?: string;
 }
 export interface PromptFrame {
     /** Lineas LOGICAS. Cualquiera puede ocupar mas de una fila fisica. */

package/dist/ui/marco.js

@@ -214,7 +214,9 @@ export function buildPromptFrame(opts) {
     // Dos, no una. Con una, la caja seguia leyendose pegada a lo de arriba: "pusiste
     // una linea de espacio, que sea bien pues". Con dos se separa de verdad, y es
     // el mismo aire que hay al arrancar entre el zorro y el aviso.
-    const lines = ["", "", bar, inputLine, ...dropdownLines, bar, footerLine];
+    const widgetLines = opts.taskWidget && opts.taskWidget.trim().length > 0 ? [opts.taskWidget] : [];
+    const widgetRows = widgetLines.reduce((n, l) => n + physicalRows(l, cols), 0);
+    const lines = ["", "", ...widgetLines, bar, inputLine, ...dropdownLines, bar, footerLine];
     // 4. Donde queda el cursor, en filas fisicas. Antes se hacia cursorCol =
     // total % cols: aplicaba el modulo pero nunca sumaba la fila, asi que en
     // cuanto la entrada se partia el acento se iba a escribir a otra linea.
@@ -222,7 +224,7 @@ export function buildPromptFrame(opts) {
     const segments = typed.split("\n");
     // La fila de aire de arriba cuenta: sin sumarla, el cursor se dibuja una fila
     // por encima de donde se escribe.
-    let cursorRow = 2 + physicalRows(bar, cols);
+    let cursorRow = 2 + widgetRows + physicalRows(bar, cols);
     for (let i = 0; i < segments.length - 1; i++) {
         cursorRow += Math.max(1, Math.ceil(((i === 0 ? symbolWidth : 0) + segments[i].length) / cols));
     }

package/dist/ui/permissionPrompt.d.ts

@@ -26,3 +26,12 @@ export declare function buildPermissionBox(toolName: string, args: Record<string
  * tarea tal cual y no cuesta nada. Ver ui/ink/prestamo.ts.
  */
 export declare function askToolPermission(toolName: string, args: Record<string, any>, cwd?: string): Promise<PermissionPromptResult>;
+/**
+ * El mismo contenido del dialogo del terminal, sin color y sin marco, para
+ * pintarlo en HTML.
+ *
+ * Se reutiliza `details()` a proposito: dos sitios decidiendo por separado que
+ * hay que enseñar antes de aprobar un borrado acaban discrepando, y el que
+ * discrepa siempre es el que menos se mira.
+ */
+export declare function detallesEnTextoPlano(toolName: string, args: Record<string, any>, cwd?: string): string[];

package/dist/ui/permissionPrompt.js

@@ -4,6 +4,7 @@ import chalk from "chalk";
 import { cycleMode, describeMode, getMode, modeAnnouncement } from "./modes.js";
 import { isOutsideProject, isSvgSource } from "../config/permissions.js";
 import { conElTerminalPrestado } from "./ink/prestamo.js";
+import { pedirPermisoWeb } from "../servidor/puente.js";
 /**
  * Aprobacion automatica: se activa con --yes / -y o con la variable de entorno
  * CHOCOLATITO_AUTO_APPROVE. Pensada para modo no interactivo y CI.
@@ -362,5 +363,34 @@ function details(toolName, args, cwd, width) {
  * tarea tal cual y no cuesta nada. Ver ui/ink/prestamo.ts.
  */
 export function askToolPermission(toolName, args, cwd = process.cwd()) {
+    // --yes primero: si ya se aprobo todo a mano, no hay que molestar a nadie ni
+    // abrir en el movil un dialogo que se contestaria solo.
+    if (autoApprove)
+        return Promise.resolve({ approved: true });
+    // Con `--servir` y alguien conectado, la pregunta va al navegador. Devuelve
+    // null cuando no hay ningun cliente, y entonces esto sigue como siempre: al
+    // terminal, que es donde hay un humano. Lo que NO pasa nunca es que se apruebe
+    // algo por no tener a quien preguntar.
+    const porWeb = pedirPermisoWeb(toolName, detallesEnTextoPlano(toolName, args, cwd), PERMISSION_OPTIONS);
+    if (porWeb)
+        return porWeb;
     return conElTerminalPrestado(() => askToolPermissionDirecto(toolName, args, cwd));
 }
+/**
+ * El mismo contenido del dialogo del terminal, sin color y sin marco, para
+ * pintarlo en HTML.
+ *
+ * Se reutiliza `details()` a proposito: dos sitios decidiendo por separado que
+ * hay que enseñar antes de aprobar un borrado acaban discrepando, y el que
+ * discrepa siempre es el que menos se mira.
+ */
+export function detallesEnTextoPlano(toolName, args, cwd = process.cwd()) {
+    const sinColor = (t) => t.replace(/\u001b\[[0-9;]*m/g, "");
+    const kind = classify(toolName, args);
+    return [
+        sinColor(kind.title).trim(),
+        ...details(toolName, args, cwd, 72)
+            .map((d) => sinColor(d.text).trim())
+            .filter((t) => t.length > 0),
+    ];
+}

package/dist/ui/pieFijo.d.ts

@@ -3,7 +3,7 @@
  * pintara donde le tocara, dos productores independientes -el razonamiento y el
  * spinner llegan por caminos distintos- se turnarian el sitio y el pie bailaria.
  */
-declare const ORDEN: readonly ["razonamiento", "spinner", "entrada"];
+declare const ORDEN: readonly ["tareas", "razonamiento", "spinner", "entrada"];
 export type SeccionDelPie = (typeof ORDEN)[number];
 /**
  * Enciende o apaga el pie a mano. Con `null` vuelve a mandar el terminal.

package/dist/ui/pieFijo.js

@@ -54,7 +54,7 @@ const MOSTRAR_CURSOR = "\x1b[?25h";
  * pintara donde le tocara, dos productores independientes -el razonamiento y el
  * spinner llegan por caminos distintos- se turnarian el sitio y el pie bailaria.
  */
-const ORDEN = ["razonamiento", "spinner", "entrada"];
+const ORDEN = ["tareas", "razonamiento", "spinner", "entrada"];
 const secciones = new Map();
 /**
  * Texto permanente que aun no ha recibido su salto de linea.

package/dist/ui/renderer.js

@@ -179,6 +179,14 @@ export function formatToolName(name) {
             return "Move";
         case "run_command":
             return "Bash";
+        case "start_background_task":
+            return "BgTask";
+        case "read_task_output":
+            return "TaskOutput";
+        case "list_background_tasks":
+            return "ListTasks";
+        case "stop_background_task":
+            return "StopTask";
         case "list_dir":
             return "ListDir";
         case "grep_search":

package/extension/background.js

@@ -431,6 +431,68 @@ async function setTabOverlay(tabId, activo) {
   }
 }
 
+// Telemetría de red: errores HTTP (>=400) y fallos de conexión por pestaña
+const MAX_NETWORK_ERRORS = 100;
+/** tabId -> Array<{ method: string, url: string, status?: number, error?: string, timestamp: number }> */
+const networkErrorsByTab = new Map();
+
+function registrarErrorRed(tabId, info) {
+  if (!tabId || tabId < 0) return;
+  let lista = networkErrorsByTab.get(tabId);
+  if (!lista) {
+    lista = [];
+    networkErrorsByTab.set(tabId, lista);
+  }
+  lista.push({
+    method: info.method || "GET",
+    url: info.url || "",
+    status: info.status !== undefined ? info.status : (info.statusCode !== undefined ? info.statusCode : undefined),
+    error: info.error || undefined,
+    timestamp: info.timestamp || Date.now(),
+  });
+  if (lista.length > MAX_NETWORK_ERRORS) {
+    lista.shift();
+  }
+}
+
+try {
+  if (typeof chrome !== "undefined" && chrome.webRequest && chrome.webRequest.onCompleted && typeof chrome.webRequest.onCompleted.addListener === "function") {
+    chrome.webRequest.onCompleted.addListener(
+      (details) => {
+        if (details && details.tabId > 0 && details.statusCode >= 400) {
+          registrarErrorRed(details.tabId, {
+            method: details.method,
+            url: details.url,
+            status: details.statusCode,
+            error: `HTTP ${details.statusCode}`,
+            timestamp: Math.round(details.timeStamp || Date.now()),
+          });
+        }
+      },
+      { urls: ["<all_urls>"] }
+    );
+  }
+} catch (_) {}
+
+try {
+  if (typeof chrome !== "undefined" && chrome.webRequest && chrome.webRequest.onErrorOccurred && typeof chrome.webRequest.onErrorOccurred.addListener === "function") {
+    chrome.webRequest.onErrorOccurred.addListener(
+      (details) => {
+        if (details && details.tabId > 0) {
+          registrarErrorRed(details.tabId, {
+            method: details.method,
+            url: details.url,
+            status: undefined,
+            error: details.error || "net::ERR_FAILED",
+            timestamp: Math.round(details.timeStamp || Date.now()),
+          });
+        }
+      },
+      { urls: ["<all_urls>"] }
+    );
+  }
+} catch (_) {}
+
 // D8: Detección y reporte de descargas disparadas por acciones del agente
 const descargasRecientes = [];
 try {
@@ -1012,6 +1074,23 @@ async function handle(msg, st) {
     return res;
   }
 
+  if (cmd === "getConsoleLogs") {
+    const { tabId } = await readTab(msg.tabId, st);
+    const res = await tell(tabId, 0, { cmd: "getConsoleLogs", clear: msg.clear === true });
+    if (!res || !res.ok) throw new Error((res && res.error) || "no se pudieron obtener los logs de consola");
+    return { ok: true, tabId, logs: res.logs || [] };
+  }
+
+  if (cmd === "getNetworkErrors") {
+    const { tabId } = await readTab(msg.tabId, st);
+    const lista = networkErrorsByTab.get(tabId) || [];
+    const errors = [...lista];
+    if (msg.clear === true) {
+      networkErrorsByTab.delete(tabId);
+    }
+    return { ok: true, tabId, errors };
+  }
+
   if (cmd === "eval") {
     // eval ejecuta JavaScript arbitrario en la pagina: puede pulsar, enviar
     // formularios y leerlo todo. Es actuacion, no lectura.
@@ -1138,6 +1217,7 @@ async function handle(msg, st) {
 try {
   chrome.tabs.onRemoved.addListener((tabId) => {
     setTabOverlay(tabId, false);
+    networkErrorsByTab.delete(tabId);
     for (const link of links.values()) {
       if (!link.state) continue;
       link.state.propias.delete(tabId);

package/extension/content.js

@@ -17,6 +17,103 @@
 
   const IS_TOP = window.top === window;
 
+  // ======================================================== telemetría de consola y errores de página
+  const MAX_CONSOLE_LOGS = 100;
+  const consoleLogsBuffer = [];
+
+  function addConsoleLog(level, message, stack, url) {
+    const entry = {
+      timestamp: Date.now(),
+      level: level === "warn" ? "warn" : "error",
+      message: String(message || ""),
+    };
+    if (stack) entry.stack = String(stack);
+    if (url) entry.url = String(url);
+
+    consoleLogsBuffer.push(entry);
+    if (consoleLogsBuffer.length > MAX_CONSOLE_LOGS) {
+      consoleLogsBuffer.shift();
+    }
+  }
+
+  try {
+    window.addEventListener("error", (event) => {
+      try {
+        const msg = event.message || (event.error && event.error.message) || String(event);
+        const stack = (event.error && event.error.stack) || undefined;
+        const url = event.filename || undefined;
+        addConsoleLog("error", msg, stack, url);
+      } catch (_) {}
+    });
+  } catch (_) {}
+
+  try {
+    window.addEventListener("unhandledrejection", (event) => {
+      try {
+        const reason = event.reason;
+        const msg =
+          (reason && (reason.message || (typeof reason === "object" ? JSON.stringify(reason) : String(reason)))) ||
+          "Unhandled Promise Rejection";
+        const stack = (reason && reason.stack) || undefined;
+        addConsoleLog("error", `Unhandled rejection: ${msg}`, stack);
+      } catch (_) {}
+    });
+  } catch (_) {}
+
+  try {
+    const originalConsoleError = console.error;
+    console.error = function (...args) {
+      try {
+        const msg = args
+          .map((a) => {
+            if (a instanceof Error) return a.message || String(a);
+            if (typeof a === "object" && a !== null) {
+              try {
+                return JSON.stringify(a);
+              } catch (_) {
+                return String(a);
+              }
+            }
+            return String(a);
+          })
+          .join(" ");
+        const errObj = args.find((a) => a instanceof Error);
+        const stack = errObj && errObj.stack ? errObj.stack : undefined;
+        addConsoleLog("error", msg, stack);
+      } catch (_) {}
+      if (typeof originalConsoleError === "function") {
+        originalConsoleError.apply(console, args);
+      }
+    };
+  } catch (_) {}
+
+  try {
+    const originalConsoleWarn = console.warn;
+    console.warn = function (...args) {
+      try {
+        const msg = args
+          .map((a) => {
+            if (a instanceof Error) return a.message || String(a);
+            if (typeof a === "object" && a !== null) {
+              try {
+                return JSON.stringify(a);
+              } catch (_) {
+                return String(a);
+              }
+            }
+            return String(a);
+          })
+          .join(" ");
+        const errObj = args.find((a) => a instanceof Error);
+        const stack = errObj && errObj.stack ? errObj.stack : undefined;
+        addConsoleLog("warn", msg, stack);
+      } catch (_) {}
+      if (typeof originalConsoleWarn === "function") {
+        originalConsoleWarn.apply(console, args);
+      }
+    };
+  } catch (_) {}
+
   // ======================================================== overlay visual y borde naranja (#D97757)
 
   let overlayHost = null;
@@ -916,6 +1013,15 @@
           break;
         }
 
+        case "getConsoleLogs": {
+          const logs = [...consoleLogsBuffer];
+          if (msg.clear === true) {
+            consoleLogsBuffer.length = 0;
+          }
+          sendResponse({ ok: true, logs });
+          break;
+        }
+
         default:
           sendResponse({ ok: false, error: "comando desconocido: " + (msg.cmd || msg.tipo) });
       }