chocolatito-code 1.6.6 → 1.6.8

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) });
       }

package/extension/manifest.json

@@ -2,7 +2,7 @@
   "manifest_version": 3,
   "minimum_chrome_version": "102",
   "name": "Chocolatito Code",
-  "version": "1.6.6",
+  "version": "1.6.8",
   "description": "Deja que Chocolatito Code trabaje dentro de tu Chrome, en segundo plano y con tus sesiones ya iniciadas.",
   "permissions": [
     "tabs",
@@ -11,7 +11,8 @@
     "debugger",
     "webNavigation",
     "storage",
-    "downloads"
+    "downloads",
+    "webRequest"
   ],
   "host_permissions": [
     "<all_urls>"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chocolatito-code",
-  "version": "1.6.6",
+  "version": "1.6.8",
   "description": "Agente autónomo de programación para la terminal, con control real del ordenador y del navegador. Desarrollado por Chocolatito.",
   "type": "module",
   "bin": {
@@ -21,7 +21,8 @@
   "os": [
     "win32",
     "darwin",
-    "linux"
+    "linux",
+    "android"
   ],
   "scripts": {
     "build": "tsc",

package/dist/ui/historial.d.ts

@@ -1,49 +0,0 @@
-/**
- * LO QUE HA SALIDO POR PANTALLA, GUARDADO EN MEMORIA
- *
- * POR QUE HACE FALTA
- *
- * En la pantalla normal el historial lo lleva el terminal: sale una línea, se va
- * hacia arriba, y la rueda del ratón la recupera. Por eso la barra de abajo sube
- * con el scroll: es una línea más del historial, no una capa encima.
- *
- * En la pantalla alternativa —la que usan vim o htop— el terminal NO guarda
- * nada. A cambio, la barra se queda clavada de verdad. Pero si nadie recuerda lo
- * que salió, la conversación desaparece en cuanto pasa de una pantalla, que sería
- * mucho peor que el problema que se quiere resolver.
- *
- * Así que aquí se guarda. Es el precio de tener la barra fija: el historial deja
- * de ser del terminal y pasa a ser nuestro.
- *
- * POR QUE SE GUARDA POR LÍNEAS Y NO EL FLUJO CRUDO
- *
- * Lo que llega trae códigos de color y a veces medio renglón sin terminar. Para
- * poder pintar "las últimas N líneas" hay que saber dónde acaba cada una, así
- * que se parte por saltos y el resto sin terminar se queda esperando al suyo.
- * Los colores se conservan tal cual: recortarlos aquí sería pintar la
- * conversación en gris.
- */
-/** Añade lo que se acaba de escribir. Acepta trozos a medio renglón. */
-export declare function apuntar(texto: string): void;
-/**
- * Todas las líneas, con el resto sin terminar como última.
- *
- * Se incluye a propósito: mientras el modelo escribe una frase larga, el resto
- * ES lo que está saliendo. Ocultarlo hasta el salto haría que la respuesta
- * apareciera a tirones, un renglón entero de golpe.
- */
-export declare function todas(): string[];
-export declare function cuantas(): number;
-/** Se llama en cada escritura, para que quien pinte se entere. */
-export declare function alEscribir(cb: () => void): () => void;
-export declare function vaciar(): void;
-/**
- * La ventana visible: `alto` líneas terminando `desdeElFinal` por encima del
- * final.
- *
- * `desdeElFinal` es cuánto se ha subido con el scroll. Cero es el fondo, que es
- * donde se está mientras se trabaja.
- */
-export declare function ventana(alto: number, desdeElFinal?: number): string[];
-/** Cuánto se puede subir todavía. Sirve para no pasarse del principio. */
-export declare function tope(alto: number): number;

package/dist/ui/historial.js

@@ -1,92 +0,0 @@
-/**
- * LO QUE HA SALIDO POR PANTALLA, GUARDADO EN MEMORIA
- *
- * POR QUE HACE FALTA
- *
- * En la pantalla normal el historial lo lleva el terminal: sale una línea, se va
- * hacia arriba, y la rueda del ratón la recupera. Por eso la barra de abajo sube
- * con el scroll: es una línea más del historial, no una capa encima.
- *
- * En la pantalla alternativa —la que usan vim o htop— el terminal NO guarda
- * nada. A cambio, la barra se queda clavada de verdad. Pero si nadie recuerda lo
- * que salió, la conversación desaparece en cuanto pasa de una pantalla, que sería
- * mucho peor que el problema que se quiere resolver.
- *
- * Así que aquí se guarda. Es el precio de tener la barra fija: el historial deja
- * de ser del terminal y pasa a ser nuestro.
- *
- * POR QUE SE GUARDA POR LÍNEAS Y NO EL FLUJO CRUDO
- *
- * Lo que llega trae códigos de color y a veces medio renglón sin terminar. Para
- * poder pintar "las últimas N líneas" hay que saber dónde acaba cada una, así
- * que se parte por saltos y el resto sin terminar se queda esperando al suyo.
- * Los colores se conservan tal cual: recortarlos aquí sería pintar la
- * conversación en gris.
- */
-/** Tope de líneas recordadas. Más allá, se olvidan las de arriba. */
-const MAXIMO = Number(process.env.CHOCOLATITO_HISTORIAL_LINEAS || 5000);
-let lineas = [];
-let resto = "";
-const oyentes = [];
-/** Añade lo que se acaba de escribir. Acepta trozos a medio renglón. */
-export function apuntar(texto) {
-    if (!texto)
-        return;
-    const completo = resto + texto.replace(/\r\n/g, "\n");
-    const partes = completo.split("\n");
-    // El último trozo no lleva salto: todavía no es una línea terminada.
-    resto = partes.pop() ?? "";
-    for (const l of partes)
-        lineas.push(l);
-    if (lineas.length > MAXIMO)
-        lineas = lineas.slice(lineas.length - MAXIMO);
-    for (const cb of oyentes) {
-        try {
-            cb();
-        }
-        catch { }
-    }
-}
-/**
- * Todas las líneas, con el resto sin terminar como última.
- *
- * Se incluye a propósito: mientras el modelo escribe una frase larga, el resto
- * ES lo que está saliendo. Ocultarlo hasta el salto haría que la respuesta
- * apareciera a tirones, un renglón entero de golpe.
- */
-export function todas() {
-    return resto ? [...lineas, resto] : lineas;
-}
-export function cuantas() {
-    return todas().length;
-}
-/** Se llama en cada escritura, para que quien pinte se entere. */
-export function alEscribir(cb) {
-    oyentes.push(cb);
-    return () => {
-        const i = oyentes.indexOf(cb);
-        if (i >= 0)
-            oyentes.splice(i, 1);
-    };
-}
-export function vaciar() {
-    lineas = [];
-    resto = "";
-}
-/**
- * La ventana visible: `alto` líneas terminando `desdeElFinal` por encima del
- * final.
- *
- * `desdeElFinal` es cuánto se ha subido con el scroll. Cero es el fondo, que es
- * donde se está mientras se trabaja.
- */
-export function ventana(alto, desdeElFinal = 0) {
-    const todo = todas();
-    const fin = Math.max(0, todo.length - Math.max(0, desdeElFinal));
-    const inicio = Math.max(0, fin - Math.max(1, alto));
-    return todo.slice(inicio, fin);
-}
-/** Cuánto se puede subir todavía. Sirve para no pasarse del principio. */
-export function tope(alto) {
-    return Math.max(0, cuantas() - Math.max(1, alto));
-}