chrome-bridge-mcp 1.17.0 → 1.18.0

package/extension/manifest.json

@@ -1,7 +1,7 @@
 {
   "manifest_version": 3,
   "name": "Chrome Bridge for Claude Code",
-  "version": "1.17.0",
+  "version": "1.18.0",
   "description": "Bridge your browser to Claude Code: 59 token-efficient web-dev automation tools over a local WebSocket. ChromeOS included.",
   "homepage_url": "https://github.com/frsorrentino/chrome-bridge",
   "minimum_chrome_version": "135",

package/extension/service-worker.js

@@ -683,7 +683,7 @@ async function bitmapToBase64Capped(bitmap, maxSide = MAX_IMAGE_SIDE) {
 
 // --- Implementazione comandi ---
 
-async function cmdGetTabs({ include_windows = false } = {}) {
+async function cmdGetTabs({ include_windows = false, ended } = {}) {
   const tabs = await chrome.tabs.query({});
   const list = tabs.map((t) => ({
     id: t.id,
@@ -691,8 +691,17 @@ async function cmdGetTabs({ include_windows = false } = {}) {
     title: t.title,
     active: t.active,
     windowId: t.windowId,
+    // Una scheda scartata da Chrome (memory saver) esiste ancora ma non ha un
+    // renderer: execute_js e compagni falliscono finché non torna in primo piano.
+    ...(t.discarded ? { discarded: true } : {}),
   }));
-  if (!include_windows) return list;
+  // ended = id che il server sa suoi e non trova più: la forma ad array resta
+  // quella di sempre per chi non lo chiede.
+  const open = new Set(list.map((t) => t.id));
+  const endings = Array.isArray(ended) && ended.length
+    ? Object.fromEntries(ended.filter((id) => !open.has(id)).map((id) => [id, tabEndings.get(id) ?? { reason: 'unknown' }]))
+    : null;
+  if (!include_windows) return endings ? { tabs: list, ended: endings } : list;
 
   // Senza geometria e stato non si può decidere dove mettere una finestra: si
   // può solo indovinare. `left` in particolare è ciò che identifica il monitor
@@ -712,7 +721,7 @@ async function cmdGetTabs({ include_windows = false } = {}) {
     // provarci.
     scriptable: (w.tabs || []).some((t) => /^(https?|file):/i.test(t.url || '')),
   }));
-  return { tabs: list, windows };
+  return endings ? { tabs: list, windows, ended: endings } : { tabs: list, windows };
 }
 
 async function cmdNavigate({ url, tab_id }) {
@@ -1189,12 +1198,26 @@ async function cmdMoveTab({ tab_id, window_id, new_window = false, window_type,
   };
 }
 
+// Perché una scheda non c'è più: «No tab with id» da solo non distingue una
+// chiusura a mano da una sostituzione. In memoria e limitato: se il service
+// worker riparte il registro si svuota e il motivo torna 'unknown'.
+const tabEndings = new Map();
+const TAB_ENDINGS_MAX = 200;
+const bridgeClosing = new Set();
+
+function recordTabEnding(tabId, ending) {
+  if (bridgeClosing.delete(tabId) && ending.reason === 'closed') ending = { reason: 'closed_by_bridge' };
+  tabEndings.set(tabId, { ...ending, at: new Date().toISOString() });
+  if (tabEndings.size > TAB_ENDINGS_MAX) tabEndings.delete(tabEndings.keys().next().value);
+}
+
 async function cmdTabAction({ action, tab_id, bypass_cache = false }) {
   if (!action) throw new Error('Missing required parameter: action');
   const tabId = await resolveTabId(tab_id);
 
   if (action === 'close') {
-    await chrome.tabs.remove(tabId);
+    bridgeClosing.add(tabId);
+    try { await chrome.tabs.remove(tabId); } catch (e) { bridgeClosing.delete(tabId); throw e; }
     return { action, closed: tabId };
   }
   if (action === 'discard') {
@@ -4561,9 +4584,16 @@ async function cmdHttpAuth({ action, username, password }) {
 
 // --- Tab lifecycle: cleanup injection state ---
 
-chrome.tabs.onRemoved.addListener((tabId) => {
+chrome.tabs.onRemoved.addListener((tabId, info) => {
   browserNetLog.delete(tabId);
   mainFrameHeaders.delete(tabId);
+  recordTabEnding(tabId, { reason: info?.isWindowClosing ? 'window_closed' : 'closed' });
+});
+
+// Chrome sostituisce l'id quando rimpiazza la scheda (prerender, alcuni
+// discard): per chi teneva il vecchio id è una scheda sparita senza chiusura.
+chrome.tabs.onReplaced.addListener((addedTabId, removedTabId) => {
+  recordTabEnding(removedTabId, { reason: 'replaced', replaced_by: addedTabId });
 });
 
 // --- get_interactives ---

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "chrome-bridge-mcp",
   "mcpName": "io.github.frsorrentino/chrome-bridge",
-  "version": "1.17.0",
+  "version": "1.18.0",
   "type": "module",
   "description": "MCP server with 59 tools for browser automation via Chrome extension. Works on ChromeOS/Crostini.",
   "main": "server/index.js",

package/server/cli.js

@@ -119,10 +119,13 @@ function connect(port) {
         sendCommand(type, params = {}) {
           return new Promise((res, rej) => {
             const command = createCommand(type, params);
+            // Come ws-manager: un timeout chiesto dal comando alza quello di trasporto.
+            const asked = Number(params?.timeout);
+            const timeout = Number.isFinite(asked) && asked > 0 ? Math.max(getTimeout(type), asked + 5000) : getTimeout(type);
             const timer = setTimeout(() => {
               pending.delete(command.id);
-              rej(new Error(`Command ${type} timed out after ${getTimeout(type)}ms`));
-            }, getTimeout(type));
+              rej(new Error(`Command ${type} timed out after ${timeout}ms`));
+            }, timeout);
             pending.set(command.id, { res, rej, timer });
             ws.send(JSON.stringify(command));
           });

package/server/protocol.js

@@ -92,7 +92,7 @@ export const MessageType = Object.freeze({
 });
 
 // Versione
-export const VERSION               = '1.17.0';
+export const VERSION               = '1.18.0';
 
 // Configurazione
 export const DEFAULT_PORT          = 8765;

package/server/tools.js

@@ -113,6 +113,34 @@ function fitArray(items, max, serialize) {
   return items.slice(0, lo);
 }
 
+/**
+ * Output di execute_js sotto `max` senza rompere il JSON: tagliare la
+ * serializzazione a metà stringa dava «Invalid control character» a chi la
+ * parsava. Una stringa si accorcia dentro il suo valore, un array per elementi
+ * (jsonText), il resto diventa un prefisso dichiarato come tale.
+ */
+export function jsResultText(data, max) {
+  const text = JSON.stringify(data);
+  if (text == null || text.length <= max) return text;
+  const hint = 'raise max_length, or save_to for the whole result';
+  const value = data?.result;
+  const wrap = (field, cut, total) => JSON.stringify({ [field]: cut, truncated: true, total_chars: total, hint });
+  const fitString = (field, full) => {
+    // Gli escape JSON allungano la stringa: il prefisso più lungo che sta nel
+    // tetto si cerca sulla serializzazione, non sui caratteri grezzi.
+    let lo = 0;
+    let hi = Math.min(full.length, max);
+    while (lo < hi) {
+      const mid = Math.ceil((lo + hi) / 2);
+      if (wrap(field, full.slice(0, mid), full.length).length <= max) lo = mid; else hi = mid - 1;
+    }
+    return wrap(field, full.slice(0, lo), full.length);
+  };
+  if (typeof value === 'string') return fitString('result', value);
+  if (Array.isArray(value)) return jsonText(data, max, hint);
+  return fitString('result_json_prefix', JSON.stringify(value));
+}
+
 /** Una riga (oggetto colonna→valore o array di celle) soddisfa il filtro where. */
 function tableRowMatches(row, where) {
   return Object.entries(where).every(([col, needle]) => {
@@ -534,21 +562,38 @@ export function registerTools(server, wsManager, caps = 'all', options = {}) {
   server.tool(
     'get_tabs',
     'List every open tab with id, url, title, active flag and mine (created by this session). Read-only. Find a tab_id when the implicit '
-      + 'target is not the one you mean. include_windows adds position, size, state and type of each window — needed before moving or tiling.',
+      + 'target is not the one you mean. include_windows adds position, size, state and type of each window — needed before moving or tiling. '
+      + 'Session tabs gone since the last call come back once in closed_session_tabs with the reason (closed, window_closed, replaced, closed_by_bridge).',
     {
       include_windows: z.boolean().optional().default(false)
         .describe('Also return the windows with bounds, state, type and tab count'),
     },
     async ({ include_windows }) => {
-      const data = await send(MessageType.GET_TABS, { include_windows: include_windows === true });
+      // `ended` = le schede che il server sa sue: l'estensione dà il motivo di
+      // quelle che non trova più. Senza schede di sessione la risposta resta
+      // quella di sempre.
+      const data = await send(MessageType.GET_TABS, {
+        include_windows: include_windows === true,
+        ...(ownedTabs.size ? { ended: [...ownedTabs] } : {}),
+      });
       const list = Array.isArray(data) ? data : (data?.tabs ?? []);
+      const windows = Array.isArray(data) ? null : data?.windows;
       for (const t of list) if (ownedTabs.has(t.id)) t.mine = true;
-      return {
-        content: [{
-          type: 'text',
-          text: jsonText(data),
-        }],
-      };
+      const missing = [...ownedTabs].filter((id) => !list.some((t) => t.id === id));
+      const shaped = windows ? { tabs: list, windows } : list;
+      if (!missing.length) return { content: [{ type: 'text', text: jsonText(shaped) }] };
+
+      // Un'estensione precedente ignora `ended` e risponde con l'array: motivo ignoto.
+      const ended = (!Array.isArray(data) && data?.ended) || {};
+      const closed = missing.map((id) => ({ id, ...(ended[id] ?? { reason: 'unknown' }) }));
+      for (const c of closed) {
+        ownedTabs.delete(c.id);
+        const successor = c.replaced_by != null ? list.find((t) => t.id === c.replaced_by) : null;
+        // Scheda sostituita da Chrome: resta della sessione con il nuovo id.
+        if (successor) { ownedTabs.add(successor.id); successor.mine = true; }
+        if (sessionTabId === c.id) sessionTabId = successor?.id ?? null;
+      }
+      return { content: [{ type: 'text', text: jsonText({ tabs: list, ...(windows ? { windows } : {}), closed_session_tabs: closed }) }] };
     }
   );
 
@@ -645,21 +690,25 @@ export function registerTools(server, wsManager, caps = 'all', options = {}) {
   // --- execute_js ---
   server.tool(
     'execute_js',
-    'Run JavaScript in the page (MAIN world). Requires the extension\'s "Allow user scripts" toggle; errors explain setup if disabled.',
+    'Run JavaScript in the page (MAIN world). Requires the extension\'s "Allow user scripts" toggle; errors explain setup if disabled. '
+      + 'A promise is awaited up to timeout. A cut result stays valid JSON and says truncated; save_to writes the whole result to disk.',
     {
       code:       z.string().describe('JS evaluated in the page; the value of the last expression is returned'),
       tab_id:     tabId,
       frame_id:   frameId,
       max_length: z.number().optional().default(20000).describe('Max output chars'),
+      timeout:    z.number().optional().describe('Max ms to wait for the result (default 30000); raise it for long async work'),
+      save_to:    saveToField('the result (a string as is, anything else as JSON)'),
     },
-    async ({ code, tab_id, frame_id, max_length }) => {
-      const data = await send(MessageType.EXECUTE_JS, { code, tab_id, frame_id });
-      return {
-        content: [{
-          type: 'text',
-          text: truncateText(JSON.stringify(data), max_length ?? DEFAULT_MAX_OUTPUT, 'max_length'),
-        }],
-      };
+    async ({ code, tab_id, frame_id, max_length, timeout, save_to }) => {
+      guardWrite(save_to);
+      const data = await send(MessageType.EXECUTE_JS, { code, tab_id, frame_id, ...(timeout ? { timeout } : {}) });
+      if (save_to) {
+        const value = data?.result;
+        const isString = typeof value === 'string';
+        return savedSummary(save_to, Buffer.from(isString ? value : JSON.stringify(value ?? null), 'utf8'), { format: isString ? 'text' : 'json' });
+      }
+      return { content: [{ type: 'text', text: jsResultText(data, max_length ?? DEFAULT_MAX_OUTPUT) }] };
     }
   );
 
@@ -1367,6 +1416,7 @@ export function registerTools(server, wsManager, caps = 'all', options = {}) {
         return { content: [{ type: 'text', text: jsonText({ closed }) }] };
       }
       const data = await send(MessageType.TAB_ACTION, { action, bypass_cache, tab_id });
+      if (action === 'close') ownedTabs.delete(data?.closed ?? tab_id ?? sessionTabId);
       if (action === 'close' && (tab_id == null || tab_id === sessionTabId)) sessionTabId = null;
       if (action === 'activate' && tab_id != null) sessionTabId = tab_id;
       return { content: [{ type: 'text', text: jsonText(data) }] };