chocolatito-code 1.1.0 → 1.3.0

package/extension/background.js

@@ -195,6 +195,9 @@ function connect(port) {
   ws.onclose = () => {
     clearInterval(link.timer);
     if (link.socket === ws) link.socket = null;
+    const oldTab = link.state && link.state.workingTabId;
+    if (link.state) link.state.workingTabId = null;
+    if (oldTab) setTabOverlay(oldTab, false);
     refreshBadge();
     scheduleReconnect(port);
   };
@@ -399,6 +402,86 @@ async function readTab(tabId, st) {
   return { tabId: activa.id, own: false };
 }
 
+/**
+ * Comprueba si alguna sesión activa está usando la pestaña como pestaña de trabajo (B4).
+ * Permite que dos sesiones convivan sin que el cierre de una apague el borde
+ * de la pestaña si la otra aún la está utilizando.
+ */
+function tabEnUso(tabId) {
+  if (!tabId) return false;
+  for (const link of links.values()) {
+    if (link.state && link.state.workingTabId === tabId) return true;
+  }
+  return false;
+}
+
+/**
+ * Pide al content script encender o apagar el borde naranja y la insignia (B1-B4).
+ * Si se pide apagar pero otra sesión aún usa la pestaña, se mantiene encendido.
+ * Si el content script no está inyectado todavía (páginas internas, cargando),
+ * se captura el error silenciosamente para no impedir la acción.
+ */
+async function setTabOverlay(tabId, activo) {
+  if (!tabId) return;
+  if (!activo && tabEnUso(tabId)) return;
+  try {
+    await chrome.tabs.sendMessage(tabId, { cmd: "overlay", tipo: "overlay", activo: Boolean(activo) });
+  } catch (_) {
+    // Si la página aún no tiene content script o es una URL vetada, se ignora
+  }
+}
+
+// D8: Detección y reporte de descargas disparadas por acciones del agente
+const descargasRecientes = [];
+try {
+  if (typeof chrome !== "undefined" && chrome.downloads && chrome.downloads.onCreated) {
+    chrome.downloads.onCreated.addListener((item) => {
+      descargasRecientes.push({
+        id: item.id,
+        url: item.url,
+        filename: item.filename || "",
+        state: item.state || "in_progress",
+        timestamp: Date.now(),
+      });
+      if (descargasRecientes.length > 20) descargasRecientes.shift();
+    });
+  }
+  if (typeof chrome !== "undefined" && chrome.downloads && chrome.downloads.onChanged) {
+    chrome.downloads.onChanged.addListener((delta) => {
+      const item = descargasRecientes.find((d) => d.id === delta.id);
+      if (item) {
+        if (delta.filename && delta.filename.current) item.filename = delta.filename.current;
+        if (delta.state && delta.state.current) item.state = delta.state.current;
+      }
+    });
+  }
+} catch (_) {}
+
+async function detectarDescarga(tiempoInicio) {
+  try {
+    if (typeof chrome !== "undefined" && chrome.downloads && typeof chrome.downloads.search === "function") {
+      const items = await chrome.downloads.search({
+        startedAfter: new Date(tiempoInicio).toISOString(),
+        limit: 1,
+      });
+      if (items && items.length > 0) {
+        return {
+          id: items[0].id,
+          filename: items[0].filename || "",
+          state: items[0].state || "in_progress",
+          url: items[0].url,
+        };
+      }
+    }
+  } catch (_) {}
+  for (let i = descargasRecientes.length - 1; i >= 0; i--) {
+    if (descargasRecientes[i].timestamp >= tiempoInicio) {
+      return descargasRecientes[i];
+    }
+  }
+  return null;
+}
+
 /**
  * Mete la pestana en un grupo visible llamado "Chocolatito Code", para que el
  * usuario vea de un vistazo donde esta trabajando el agente.
@@ -664,7 +747,13 @@ async function typeTrusted(tabId, frameId, ref, text, submit, replace) {
 async function capturar(tabId) {
   try {
     return await withTrustedTab(tabId, async (target) => {
-      const res = await cdp(target, "Page.captureScreenshot", { format: "png", captureBeyondViewport: false });
+      // JPEG y no PNG, y no es cosmetico. Una captura en PNG de un monitor
+      // normal son 1,3 MB, que en base64 se convierten en 1,75 MB dentro de la
+      // peticion al modelo de vision. Eso no llega: la peticion se muere por el
+      // camino, no vuelve nada, y se lleva por delante uno de los cuatro huecos
+      // de la licencia durante minutos. En JPEG al 70 la misma captura ocupa
+      // unos 120 KB y se lee igual de bien.
+      const res = await cdp(target, "Page.captureScreenshot", { format: "jpeg", quality: 70, captureBeyondViewport: false });
       return { data: res.data, via: "cdp" };
     });
   } catch (err) {
@@ -679,9 +768,9 @@ async function capturar(tabId) {
         if (activa && activa.id !== tabId) previaId = activa.id;
         if (!tab.active) await chrome.tabs.update(tabId, { active: true });
         await sleep(250);
-        const dataUrl = await chrome.tabs.captureVisibleTab(windowId, { format: "png" });
+        const dataUrl = await chrome.tabs.captureVisibleTab(windowId, { format: "jpeg", quality: 70 });
         return {
-          data: String(dataUrl).replace(/^data:image\/png;base64,/, ""),
+          data: String(dataUrl).replace(/^data:image\/\w+;base64,/, ""),
           via: "tabs",
           warning: "el depurador no estaba disponible (¿DevTools abierto?): captura por la via normal",
         };
@@ -732,6 +821,7 @@ async function handle(msg, st) {
     await esperarCarga(tab.id, msg.timeout || 30000);
     await groupTab(tab.id, st);
     await banner(tab.id, msg.note || "pestana abierta");
+    await setTabOverlay(tab.id, true);
     const info = await chrome.tabs.get(tab.id);
     return { tabId: tab.id, title: info.title || "", url: info.url || "" };
   }
@@ -743,12 +833,18 @@ async function handle(msg, st) {
       (t) => (t.url || "").toLowerCase().includes(needle) || (t.title || "").toLowerCase().includes(needle)
     );
     if (!hit) throw new Error('ninguna pestana contiene "' + msg.match + '"');
+    if (st.workingTabId && st.workingTabId !== hit.id) {
+      const vieja = st.workingTabId;
+      st.workingTabId = null;
+      await setTabOverlay(vieja, false);
+    }
     st.workingTabId = hit.id;
     // Elegirla es un acto explicito del agente: a partir de aqui es suya y la
     // puede cerrar. Mirarla (readTab) nunca da ese derecho.
     st.propias.add(hit.id);
     await groupTab(hit.id, st);
     await banner(hit.id, "pestana seleccionada");
+    await setTabOverlay(hit.id, true);
     return { tabId: hit.id, title: hit.title || "", url: hit.url || "" };
   }
 
@@ -770,13 +866,17 @@ async function handle(msg, st) {
     await groupTab(tabId, st);
     const info = await chrome.tabs.get(tabId);
     await banner(tabId, "navegando a " + (info.url || "").slice(0, 60));
+    await setTabOverlay(tabId, true);
     return { tabId, title: info.title || "", url: info.url || "" };
   }
 
   if (cmd === "snapshot") {
     const { tabId, own } = await readTab(msg.tabId, st);
     // Solo se adopta como pestana de trabajo si ya era nuestra o vino con tabId.
-    if (own) st.workingTabId = tabId;
+    if (own) {
+      st.workingTabId = tabId;
+      await setTabOverlay(tabId, true);
+    }
     await banner(tabId, "leyendo la pagina");
     st.refIndex.clear();
 
@@ -839,6 +939,9 @@ async function handle(msg, st) {
     const tabId = loc ? loc.tabId : await actTab(msg.tabId, st);
     const frameId = loc ? loc.frameId : 0;
     st.workingTabId = tabId;
+    await setTabOverlay(tabId, true);
+
+    const tiempoInicioAccion = Date.now() - 50;
 
     if (cmd === "click") await banner(tabId, "pulsando un elemento");
     if (cmd === "type") await banner(tabId, "escribiendo");
@@ -882,7 +985,24 @@ async function handle(msg, st) {
     // Se deja respirar a la pagina para que reaccione antes del siguiente paso.
     await sleep(msg.settle === undefined ? 600 : msg.settle);
     const info = await chrome.tabs.get(tabId);
-    return { tabId, title: info.title || "", url: info.url || "", label: res.label, value: res.value, via: res.via, warning: res.warning };
+
+    // D8: Detectar si esta acción inició o completó alguna descarga de archivo
+    const descarga = await detectarDescarga(tiempoInicioAccion);
+    if (descarga) {
+      res.download = descarga;
+      res.label = (res.label ? res.label + " " : "") + `[Descarga: ${descarga.filename || descarga.url}]`;
+    }
+
+    return {
+      tabId,
+      title: info.title || "",
+      url: info.url || "",
+      label: res.label,
+      value: res.value,
+      via: res.via,
+      warning: res.warning,
+      download: res.download,
+    };
   }
 
   if (cmd === "getText") {
@@ -903,7 +1023,23 @@ async function handle(msg, st) {
 
   if (cmd === "waitFor") {
     const { tabId } = await readTab(msg.tabId, st);
-    const deadline = Date.now() + (msg.timeout || 20000);
+    const timeout = msg.timeout || 20000;
+    const deadline = Date.now() + timeout;
+
+    // D3: Espera hasta que aparezca un selector CSS en el DOM
+    if (msg.selector || msg.css) {
+      const sel = msg.selector || msg.css;
+      while (Date.now() < deadline) {
+        const res = await tell(tabId, 0, { cmd: "waitForCondition", selector: sel });
+        if (res && res.ok && res.conditionMet) {
+          return { ok: true, found: true, selector: sel };
+        }
+        await sleep(300);
+      }
+      return { ok: false, found: false, error: `Tiempo agotado esperando el selector "${sel}"` };
+    }
+
+    // D3: Espera hasta que aparezca un texto concreto
     if (msg.text) {
       while (Date.now() < deadline) {
         const res = await tell(tabId, 0, { cmd: "getText" });
@@ -912,8 +1048,22 @@ async function handle(msg, st) {
       }
       return { found: false };
     }
-    await sleep(msg.ms || 2000);
-    return { waited: msg.ms || 2000 };
+
+    // D3: Espera hasta que la pantalla "esté quieta" (sin mutaciones de DOM durante quietMs)
+    if (msg.stable || msg.quiet || msg.condition === "stable") {
+      while (Date.now() < deadline) {
+        const res = await tell(tabId, 0, { cmd: "waitForCondition", stable: true, quietMs: msg.quietMs || 400 });
+        if (res && res.ok && res.conditionMet) {
+          return { ok: true, stable: true };
+        }
+        await sleep(250);
+      }
+      return { ok: true, stable: true, warning: "Tiempo límite alcanzado esperando quietud" };
+    }
+
+    const ms = msg.ms || 2000;
+    await sleep(ms);
+    return { waited: ms };
   }
 
   if (cmd === "screenshot") {
@@ -950,9 +1100,12 @@ async function handle(msg, st) {
     }
 
     if (ids.length === 0) return { closed: 0 };
-    await chrome.tabs.remove(ids);
-    for (const id of ids) st.propias.delete(id);
     if (ids.includes(st.workingTabId)) st.workingTabId = null;
+    for (const id of ids) st.propias.delete(id);
+    await chrome.tabs.remove(ids);
+    for (const id of ids) {
+      await setTabOverlay(id, false);
+    }
     return { closed: ids.length };
   }
 
@@ -962,16 +1115,17 @@ async function handle(msg, st) {
     // no era de nadie, y el usuario tenia que deshacerlo a mano.
     const aSoltar = new Set(st.propias);
     if (st.workingTabId) aSoltar.add(st.workingTabId);
+    st.groupId = null;
+    st.workingTabId = null;
+    st.propias.clear();
+    st.refIndex.clear();
     for (const id of aSoltar) {
       try {
         await chrome.tabs.ungroup(id);
       } catch (_) {}
       await banner(id, null);
+      await setTabOverlay(id, false);
     }
-    st.groupId = null;
-    st.workingTabId = null;
-    st.propias.clear();
-    st.refIndex.clear();
     return { ok: true, soltadas: aSoltar.size };
   }
 
@@ -983,6 +1137,7 @@ async function handle(msg, st) {
 // with id") en vez de decir que ya no hay donde trabajar.
 try {
   chrome.tabs.onRemoved.addListener((tabId) => {
+    setTabOverlay(tabId, false);
     for (const link of links.values()) {
       if (!link.state) continue;
       link.state.propias.delete(tabId);
@@ -992,4 +1147,26 @@ try {
   });
 } catch (_) {}
 
+// Al navegar o recargar la página, se reinyecta el content script y el overlay
+// se apaga. Si la pestaña sigue siendo de trabajo para alguna sesión, se vuelve a activar (B4).
+try {
+  if (typeof chrome !== "undefined" && chrome.webNavigation && chrome.webNavigation.onCompleted && typeof chrome.webNavigation.onCompleted.addListener === "function") {
+    chrome.webNavigation.onCompleted.addListener((details) => {
+      if (details && details.frameId === 0 && tabEnUso(details.tabId)) {
+        setTabOverlay(details.tabId, true);
+      }
+    });
+  }
+} catch (_) {}
+
+try {
+  if (typeof chrome !== "undefined" && chrome.tabs && chrome.tabs.onUpdated && typeof chrome.tabs.onUpdated.addListener === "function") {
+    chrome.tabs.onUpdated.addListener((tabId, changeInfo) => {
+      if (changeInfo && changeInfo.status === "complete" && tabEnUso(tabId)) {
+        setTabOverlay(tabId, true);
+      }
+    });
+  }
+} catch (_) {}
+
 for (const p of WS_PORTS) connect(p);