chrome-bridge-mcp 1.27.0 → 1.28.0

package/README.md

@@ -169,13 +169,13 @@ default; the other 23 sit in seven optional caps that the agent switches on
 mid-session with `get_status({enable: ["visual"]})`, with no restart
 (`--caps` still sets them at startup).
 
-![The tools by group, from clicking a button to auditing a whole page](assets/readme/card4-toolbox.png)
+![66 tools in eight groups, from clicking a button to tracing a page](assets/readme/card4-toolbox.png)
 
 | Group | N | What's in it |
 |---|---|---|
 | Core & Navigation | 13 | tabs, windows, `navigate`, `screenshot`, `tile_windows` |
 | Interaction | 11 | `click`, `fill_form`, `upload_file`, dialogs, clipboard |
-| DOM & Inspection | 11 | `read_page`, `extract`, `query_dom`, `get_css_styles`, `watch_dom` |
+| DOM & Inspection | 12 | `read_page`, `extract`, `extract_table`, `query_dom`, `get_css_styles`, `watch_dom` |
 | Debugging & Network | 8 | `execute_js`, console, network log, mocking, `track_events` |
 | Visual & Responsive | 5 | `screenshot_diff`, viewport and zoom, media emulation |
 | Audits | 2 | `audit` (a11y, keyboard, SEO, security, links, vitals, css, resources, cache in one call), `cookie_audit` |
@@ -207,6 +207,7 @@ Environment variables, each with a matching CLI flag:
 | `CHROME_BRIDGE_HOST` / `--host` | `127.0.0.1` | `0.0.0.0` **only** where the browser lives outside the container (ChromeOS/Crostini port-forward) — and only with a token |
 | `CHROME_BRIDGE_TOKEN` | unset | Required on both `ext_init` and `relay_init`. Strongly recommended whenever the bind isn't loopback |
 | `CHROME_BRIDGE_CAPS` / `--caps` | `core` | `core`, `audits`, `visual`, `network`, `storage`, `dom`, `files`, `all`. Optional caps can also be switched on at runtime with `get_status({enable})` |
+| `CHROME_BRIDGE_ALWAYS_LOAD` / `--always-load` | 22 most used tools | Tools kept in context when the client loads the server whole; the others carry `_meta['anthropic/alwaysLoad'] = false` and wait behind tool search (Claude Code 2.1.285+). `all` loads every tool; a comma list picks them |
 | `CHROME_BRIDGE_NO_JS` / `--no-js` | unset | No arbitrary JavaScript in the page: `execute_js` and `modify_dom` leave the schema, `wait_for(condition=function)` and `javascript:`/`data:` URLs are refused. `get_status` reports `js_evaluation` |
 | `CHROME_BRIDGE_READ_ROOT` / `--read-root` | unset | Where `upload_file` may read from. Unset: any file except keys and credentials (`~/.ssh`, `~/.aws`, `~/.gnupg`, `.env*`, `id_*`, `*.pem`, `*.key`, …), symlinks resolved first. Set: only files under this directory, whatever their name — the way to upload a certificate key on purpose |
 | `CHROME_BRIDGE_BROWSER` | unset | Launch mode only: the browser binary, e.g. `C:\Program Files (x86)\Microsoft\Edge\Application\msedge.exe`. Unset: the first of Chromium, Edge, Brave, Google Chrome found in the standard paths (on Linux Chromium, then Google Chrome). Google Chrome 137+ cannot load the extension |
@@ -304,12 +305,14 @@ count.
 | `read_console` returns `note=Instrumentation not loaded` | The page was opened before the extension, "Capture console & metrics" is off, or the page isn't injectable (`chrome://`). Reload it. |
 | Screenshot times out, or `image readback failed` | A minimized or fully covered window stops producing frames; captures fail after 10 s. Bring the window forward. |
 | `wait_for`/`scroll` return `page_hidden: true`, pages stop updating | Same cause: Chrome does not render a hidden page and slows its timers (after a few minutes, to one wake-up per minute). `get_page_info` reports `visibility`. Bring the window on screen, or `create_tab` with `new_window` and bounds. |
-| `screenshot presets` says `NOT APPLIED` | Presets resize the window; they do not emulate a phone (no device pixel ratio, UA or touch). The window manager enforces a minimum width, and no window exceeds the screen (e.g. at most a 1536×686 viewport on a 1536×864 ChromeOS screen). For phone emulation or larger viewports use a headless browser. |
+| `screenshot presets` says `NOT APPLIED` | Presets resize the window; they do not emulate a phone (no device pixel ratio, UA or touch). The window manager enforces a minimum width, and no window exceeds the screen (e.g. at most a 1536×686 viewport on a 1536×864 ChromeOS screen). For phone emulation use `emulate_media` with `device` (via debugger), or a headless browser for larger viewports. |
 | `type_text` returns `mismatch: true` | The field rejected the value. Events from an extension have `isTrusted: false`, and some widgets (date pickers, search boxes with tokenizers) discard them. Try `mode: 'keys'`, then the site's own controls (the calendar buttons), or `handoff`. |
 | `[media removed: request limit]` instead of a screenshot | Written by the MCP client, not by the bridge: too many images in one request. Use `save_to`, or `element_screenshot` with `region` and a small `scale`. |
 | Commands work, then stop | The MV3 service worker restarted and in-memory state (network log, diff baselines, HTTP auth) was reset. Re-run the monitoring call. |
 | Extension dropped on every ChromeOS reboot | Install from the Web Store instead of Load unpacked. |
 | Tool missing from the list | It's in an opt-in group. Check `get_status` → `caps_available`, then set `CHROME_BRIDGE_CAPS=all`. |
+| `claude mcp get` shows no command, arguments or environment | Expected with the plugin: since Claude Code 2.1.285 it hides them for stdio servers that plugins provide (variable names stay). `get_status` reports the server and extension versions, mode, host, port and caps; `/mcp` shows the connection. |
+| Popup says «In attesa: un altro browser è collegato», `get_status` lists `refused_browsers` | Two browsers with the extension reach the same port. The one already connected keeps the bridge; the other retries every 15 s and takes over when the first disconnects. `get_status` → `browser` names the connected one. Before this, the last one to connect took over silently. |
 
 ## Documentation
 

package/extension/manifest.json

@@ -1,7 +1,7 @@
 {
   "manifest_version": 3,
   "name": "Chrome Bridge for Claude Code",
-  "version": "1.27.0",
+  "version": "1.28.0",
   "description": "Bridge your browser to Claude Code: 66 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/popup.css

@@ -58,6 +58,7 @@ body {
 .dot.connected { background: var(--ok); box-shadow: 0 0 6px var(--ok); }
 .dot.connecting { background: #f39c12; }
 .dot.disconnected { background: var(--err); }
+.dot.refused { background: #f39c12; }
 #status-text { font-weight: 600; }
 .status-row .ws-url {
   margin-left: auto;

package/extension/popup.js

@@ -4,6 +4,7 @@ const stateLabels = {
   connected: 'Connesso',
   connecting: 'Connessione…',
   disconnected: 'Disconnesso',
+  refused: 'In attesa: un altro browser è collegato',
 };
 
 function renderState(state) {

package/extension/service-worker.js

@@ -99,7 +99,38 @@ const KEEPALIVE_ALARM = 'chrome-bridge-keepalive';
 let ws = null;
 let reconnectTimer = null;
 let reconnectDelay = RECONNECT_BASE_MS;
-let connectionState = 'disconnected'; // 'connected' | 'connecting' | 'disconnected'
+let connectionState = 'disconnected'; // 'connected' | 'connecting' | 'disconnected' | 'refused'
+// Rifiutata perché un altro browser tiene la porta: si riprova piano, senza
+// riempire il log del server a ogni secondo.
+const REFUSED_RETRY_MS = 15000;
+let refusedBy = null;
+
+// Identità del browser per il server: un id che resta fra un riavvio e
+// l'altro (lo stesso browser che si riconnette sostituisce la sua vecchia
+// connessione, un altro browser no) e un'etichetta leggibile in get_status.
+// Calcolata una volta: all'apertura del socket l'ext_init deve partire
+// subito, o il server chiude la connessione non identificata (sotto carico lo
+// storage può metterci secondi). Prima di loadConfig launchMode non è noto:
+// si chiede dopo il primo connect.
+let identityPromise = null;
+function cachedIdentity() {
+  identityPromise ??= browserIdentity().catch(() => ({ id: null, label: 'Chromium-based browser' }));
+  return identityPromise;
+}
+
+async function browserIdentity() {
+  let { browserId } = await chrome.storage.local.get({ browserId: null });
+  if (!browserId) {
+    browserId = crypto.randomUUID();
+    await chrome.storage.local.set({ browserId });
+  }
+  const brands = navigator.userAgentData?.brands ?? [];
+  const brand = brands.find((b) => !/Not.?A.?Brand|^Chromium$/i.test(b.brand)) ?? brands.find((b) => /Chromium/i.test(b.brand));
+  const os = (await chrome.runtime.getPlatformInfo().catch(() => null))?.os ?? navigator.userAgentData?.platform ?? '';
+  const label = [brand ? `${brand.brand} ${brand.version}` : 'Chromium-based browser', os && `on ${os}`, launchMode && '(launch mode)']
+    .filter(Boolean).join(' ');
+  return { id: browserId, label };
+}
 
 let serverVersion = null;
 let sessionStats = { toolCallCount: 0, lastTool: null, lastToolTs: null, recentErrors: [] };
@@ -184,6 +215,7 @@ function connect() {
   }
 
   setConnectionState('connecting');
+  cachedIdentity();
 
   try {
     ws = new WebSocket(wsUrl);
@@ -195,12 +227,14 @@ function connect() {
 
   const socket = ws;
 
-  ws.onopen = () => {
+  ws.onopen = async () => {
     console.log('[chrome-bridge] Connected to MCP server');
-    const init = { type: 'ext_init', version: chrome.runtime.getManifest().version };
+    const init = { type: 'ext_init', version: chrome.runtime.getManifest().version, browser: await cachedIdentity() };
     if (extToken) init.token = extToken;
-    ws.send(JSON.stringify(init));
+    if (socket.readyState !== WebSocket.OPEN) return;
+    socket.send(JSON.stringify(init));
     setConnectionState('connected');
+    refusedBy = null;
     reconnectDelay = RECONNECT_BASE_MS; // Reset backoff
   };
 
@@ -209,7 +243,7 @@ function connect() {
     console.log('[chrome-bridge] Disconnected from MCP server');
     ws = null;
     serverVersion = null;
-    setConnectionState('disconnected');
+    setConnectionState(refusedBy ? 'refused' : 'disconnected');
     scheduleReconnect();
   };
 
@@ -233,6 +267,12 @@ function connect() {
       return;
     }
 
+    if (msg.type === 'ext_init_refused') {
+      refusedBy = msg.connected || 'another browser';
+      console.warn(`[chrome-bridge] Refused: ${msg.reason}`);
+      return;
+    }
+
     // Handshake: il server dichiara la sua versione
     if (msg.type === 'ext_init_ok') {
       serverVersion = msg.version || null;
@@ -271,7 +311,7 @@ function scheduleReconnect() {
   reconnectTimer = setTimeout(() => {
     reconnectDelay = Math.min(reconnectDelay * 2, RECONNECT_MAX_MS);
     connect();
-  }, reconnectDelay);
+  }, refusedBy ? REFUSED_RETRY_MS : reconnectDelay);
 }
 
 function sendMessage(obj) {
@@ -458,6 +498,10 @@ async function executeCommand(msg) {
       return await cmdScreencast(params);
     case 'cdp_target':
       return await cmdCdpTarget(params);
+    case 'upload_chunk':
+      return await cmdUploadChunk(params);
+    case 'handoff_end':
+      return await cmdHandoffEnd(params);
     case 'list_event_listeners':
       return await cmdListEventListeners(params);
     case 'monitor_websocket':
@@ -2762,6 +2806,19 @@ async function cmdHandoff({ message, pick_element = false, ask = false, pick_max
   });
 }
 
+// handoff_end: l'utente ha risposto nel terminale (elicitation MCP) prima che
+// nella pagina. Il banner va tolto e l'handoff in attesa finisce con quella
+// risposta, così la chiamata handoff originale ritorna una sola volta.
+async function cmdHandoffEnd({ action = 'done', answer, tab_id }) {
+  const tabId = await resolveTabId(tab_id);
+  const entry = handoffs.get(tabId);
+  if (!entry) return { ended: false };
+  try { await chrome.scripting.executeScript({ target: { tabId }, func: () => document.getElementById('cb-handoff-host')?.remove() }); } catch { /* tab chiusa */ }
+  const tab = await chrome.tabs.get(tabId).catch(() => null);
+  entry.resolve({ done: action === 'done', action, url: tab?.url ?? null, via: 'terminal', ...(typeof answer === 'string' && { answer }) });
+  return { ended: true };
+}
+
 // --- keyboard_walk ---
 // Ordine di tabulazione calcolato (tabindex>0 crescente, poi ordine DOM) e
 // focus programmatico elemento per elemento. NON sono veri tasti Tab: un
@@ -3575,27 +3632,55 @@ async function cmdGetFrames({ tab_id }) {
 
 // --- upload_file ---
 
-async function cmdUploadFile({ selector, name, mime_type, content_b64, tab_id }) {
+// upload_chunk: i file oltre 6 MB arrivano a pezzi (server/upload.js). La
+// pagina li tiene in window.__cbUploads finché upload_file li monta, o un
+// abort li butta.
+async function cmdUploadChunk({ upload_id, index, total, content_b64, abort = false, tab_id }) {
+  if (!upload_id) throw new Error('Missing required parameter: upload_id');
+  const tabId = await resolveTabId(tab_id);
+  const results = await chrome.scripting.executeScript({
+    target: { tabId },
+    func: (id, i, n, b64, drop) => {
+      const all = (window.__cbUploads ??= {});
+      if (drop) { delete all[id]; return { aborted: true }; }
+      const u = (all[id] ??= { parts: [], total: n });
+      u.parts[i] = Uint8Array.from(atob(b64), (c) => c.charCodeAt(0));
+      return { received: i + 1, total: n };
+    },
+    args: [upload_id, index ?? 0, total ?? 1, content_b64 ?? '', abort],
+    world: 'MAIN',
+  });
+  return results?.[0]?.result ?? { received: 0 };
+}
+
+async function cmdUploadFile({ selector, name, mime_type, content_b64, upload_id, size, tab_id }) {
   if (!selector) throw new Error('Missing required parameter: selector');
-  if (!content_b64) throw new Error('Missing required parameter: content_b64');
+  if (!content_b64 && !upload_id) throw new Error('Missing required parameter: content_b64');
   const tabId = await resolveTabId(tab_id);
   const results = await chrome.scripting.executeScript({
     target: { tabId },
-    func: (sel, fname, mime, b64) => {
+    func: (sel, fname, mime, b64, id, expected) => {
+      const pieces = id ? window.__cbUploads?.[id] : null;
+      if (id) delete window.__cbUploads?.[id];
       const el = document.querySelector(sel);
       if (!el) throw new Error(`Element not found: ${sel}`);
       // Un throw qui si perderebbe (elementOutcome lo leggerebbe come «not found»): esito esplicito.
       if (!(el instanceof HTMLInputElement) || el.type !== 'file') return { uploaded: false, error: 'Element is not an input[type=file]' };
-      const bytes = Uint8Array.from(atob(b64), (c) => c.charCodeAt(0));
+      if (id && (!pieces || pieces.parts.filter(Boolean).length !== pieces.total)) {
+        return { uploaded: false, error: `Upload ${id} incomplete: ${pieces ? pieces.parts.filter(Boolean).length : 0}/${pieces?.total ?? '?'} pieces (page reloaded meanwhile?)` };
+      }
+      const bytes = id ? new Blob(pieces.parts) : Uint8Array.from(atob(b64), (c) => c.charCodeAt(0));
+      const length = id ? bytes.size : bytes.length;
+      if (id && expected != null && length !== expected) return { uploaded: false, error: `Upload ${id}: ${length} bytes arrived, ${expected} expected` };
       const file = new File([bytes], fname, { type: mime });
       const dt = new DataTransfer();
       dt.items.add(file);
       el.files = dt.files;
       el.dispatchEvent(new Event('input', { bubbles: true }));
       el.dispatchEvent(new Event('change', { bubbles: true }));
-      return { uploaded: fname, size: bytes.length, mime };
+      return { uploaded: fname, size: length, mime, ...(id && { pieces: pieces.total }) };
     },
-    args: [selector, name, mime_type, content_b64],
+    args: [selector, name, mime_type, content_b64 ?? null, upload_id ?? null, size ?? null],
     world: 'MAIN',
   });
   return elementOutcome(results, selector);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "chrome-bridge-mcp",
   "mcpName": "io.github.frsorrentino/chrome-bridge",
-  "version": "1.27.0",
+  "version": "1.28.0",
   "type": "module",
   "description": "Chrome Bridge by frsorrentino: MCP server that lets Claude Code borrow a tab from your own logged-in Chrome and hand it back — logins, 2FA and CAPTCHAs stay with you (handoff). 66 tools; 2.8-4.3× cheaper and up to 9.3× fewer turns than Claude in Chrome, measured; ChromeOS included.",
   "main": "server/index.js",

package/server/cli.js

@@ -13,6 +13,7 @@
  *   chrome-bridge screenshot --out /tmp/shot.png
  */
 
+import { uploadBuffer } from './upload.js';
 import WebSocket from 'ws';
 import { readFile, writeFile, mkdir } from 'node:fs/promises';
 import { basename, extname, join } from 'node:path';
@@ -421,11 +422,9 @@ async function run(client, command, params, opts) {
   // Comandi con file I/O lato CLI
   if (command === 'upload_file') {
     const buf = await readFile(params.path);
-    if (buf.length > 10 * 1024 * 1024) throw new Error(`File too large: ${buf.length} bytes (max 10MB)`);
     const mime = params.mime_type || MIME_BY_EXT[extname(params.path).toLowerCase()] || 'application/octet-stream';
-    const data = await client.sendCommand(MessageType.UPLOAD_FILE, {
-      selector: params.selector, name: basename(params.path), mime_type: mime,
-      content_b64: buf.toString('base64'), tab_id: params.tab_id,
+    const data = await uploadBuffer((t, p) => client.sendCommand(t, p), {
+      selector: params.selector, name: basename(params.path), mime_type: mime, buf, tab_id: params.tab_id,
     });
     return JSON.stringify(data);
   }

package/server/index.js

@@ -39,6 +39,7 @@ function parseSecurity() {
     noJs: process.argv.includes('--no-js') || on(process.env.CHROME_BRIDGE_NO_JS),
     writeRoot: argValue('--write-root') ?? process.env.CHROME_BRIDGE_WRITE_ROOT ?? null,
     readRoot: argValue('--read-root') ?? process.env.CHROME_BRIDGE_READ_ROOT ?? null,
+    alwaysLoad: argValue('--always-load') ?? process.env.CHROME_BRIDGE_ALWAYS_LOAD ?? null,
   };
 }
 

package/server/launcher.js

@@ -8,7 +8,7 @@
  */
 
 import { spawn } from 'node:child_process';
-import { cp, mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
+import { cp, mkdir, mkdtemp, readdir, readFile, rm, stat, writeFile } from 'node:fs/promises';
 import { existsSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { dirname, join, win32 } from 'node:path';
@@ -71,9 +71,45 @@ export function findBrowser() {
   return found;
 }
 
+const LAUNCH_PREFIX = 'chrome-bridge-launch-';
+const STALE_WITHOUT_OWNER_MS = 24 * 3600 * 1000;
+
+function processAlive(pid) {
+  try { process.kill(pid, 0); return true; } catch (e) { return e.code === 'EPERM'; }
+}
+
+// Cartelle di sessioni launch finite male o mai pulite: su Windows Edge tiene
+// i file del profilo anche dopo la chiusura, rm falliva in silenzio e restavano
+// circa 47 MB a sessione (01-02/10/2026: 73 cartelle, 3,5 GB in %TEMP%). Ogni
+// cartella dice di chi è (owner.json con il pid del server): si cancella se
+// quel processo non esiste più. Senza owner.json (versioni fino alla 1.27) solo
+// dopo 24 ore, per non toccare una sessione in corso.
+export async function sweepStaleLaunchDirs({ dir = tmpdir(), now = Date.now(), alive = processAlive } = {}) {
+  const removed = [];
+  let names = [];
+  try { names = await readdir(dir); } catch { return removed; }
+  for (const name of names.filter((n) => n.startsWith(LAUNCH_PREFIX))) {
+    const path = join(dir, name);
+    let stale;
+    try {
+      const owner = JSON.parse(await readFile(join(path, 'owner.json'), 'utf8'));
+      stale = !alive(owner.pid);
+    } catch {
+      try { stale = now - (await stat(path)).mtimeMs > STALE_WITHOUT_OWNER_MS; } catch { stale = false; }
+    }
+    if (!stale) continue;
+    try {
+      await rm(path, { recursive: true, force: true, maxRetries: 3, retryDelay: 200 });
+      removed.push(name);
+    } catch { /* ancora bloccata: ci riprova il prossimo avvio */ }
+  }
+  return removed;
+}
+
 /** Prepara dir temporanee: copia estensione + launch.json, profilo con dev mode. */
 export async function prepareLaunch(port) {
-  const base = await mkdtemp(join(tmpdir(), 'chrome-bridge-launch-'));
+  const base = await mkdtemp(join(tmpdir(), LAUNCH_PREFIX));
+  await writeFile(join(base, 'owner.json'), JSON.stringify({ pid: process.pid, started: new Date().toISOString() }));
   const extDir = join(base, 'ext');
   const profileDir = join(base, 'profile');
 
@@ -95,6 +131,8 @@ export async function prepareLaunch(port) {
  */
 export async function launchBrowser({ port, headless = false }) {
   const browser = findBrowser();
+  const swept = await sweepStaleLaunchDirs();
+  if (swept.length) console.error(`[chrome-bridge] removed ${swept.length} leftover launch profile(s) from earlier sessions`);
   const { base, extDir, profileDir } = await prepareLaunch(port);
 
   const args = [
@@ -128,7 +166,13 @@ export async function launchBrowser({ port, headless = false }) {
         proc.once('exit', () => { clearTimeout(t); resolve(); });
       });
     }
-    await rm(base, { recursive: true, force: true }).catch(() => {});
+    // Su Windows i processi figli del browser rilasciano i file qualche
+    // istante dopo l'uscita del principale: ritentativi invece di un solo
+    // tentativo silenzioso. Se non basta, la spazzata del prossimo avvio la
+    // trova (owner.json con un pid morto).
+    await rm(base, { recursive: true, force: true, maxRetries: 10, retryDelay: 300 }).catch((e) => {
+      console.error(`[chrome-bridge] could not remove ${base} (${e.code ?? e.message}); the next launch removes it`);
+    });
   };
 
   console.error(`[chrome-bridge] launched ${browser}${headless ? ' (headless)' : ''} pid=${proc.pid}, ws port ${port}`);

package/server/protocol.js

@@ -44,6 +44,7 @@ export const MessageType = Object.freeze({
   MOVE_TAB:             'move_tab',
   TILE_WINDOWS:         'tile_windows',
   UPLOAD_FILE:           'upload_file',
+  UPLOAD_CHUNK:          'upload_chunk',
   WAIT_FOR_NAVIGATION:   'wait_for_navigation',
   WAIT_FOR_NETWORK_IDLE: 'wait_for_network_idle',
   WAIT_FOR_TEXT:         'wait_for_text',
@@ -82,6 +83,7 @@ export const MessageType = Object.freeze({
   PERF_TRACE:            'perf_trace',
   SCREENCAST:            'screencast',
   CDP_TARGET:            'cdp_target',
+  HANDOFF_END:           'handoff_end',
 
   // Risposte (extension → server)
   RESULT: 'result',
@@ -97,7 +99,7 @@ export const MessageType = Object.freeze({
 });
 
 // Versione
-export const VERSION               = '1.27.0';
+export const VERSION               = '1.28.0';
 
 // Configurazione
 export const DEFAULT_PORT          = 8765;
@@ -149,6 +151,7 @@ export function getTimeout(type) {
     || type === MessageType.WAIT_FOR_NETWORK_IDLE
     || type === MessageType.WAIT_FOR_TEXT
     || type === MessageType.UPLOAD_FILE
+    || type === MessageType.UPLOAD_CHUNK
     || type === MessageType.MANAGE_DOWNLOADS
     || type === MessageType.SAVE_PAGE
     || type === MessageType.HTTP_REQUEST

package/server/tools.js

@@ -26,6 +26,7 @@ import { windowLayout } from './layouts.js';
 import { fingerprintDelta } from './effect.js';
 import { analyzeTrace, traceEventsOf } from './trace-analysis.js';
 import { assembleVideo } from './video.js';
+import { uploadBuffer, MAX_UPLOAD_BYTES } from './upload.js';
 import { cdpConnect, targetWsUrl, takeHeapSnapshot, summarizeHeap, diffHeap } from './heap.js';
 import { lighthouseArgs, runLighthouse, summarizeLighthouse } from './lighthouse.js';
 import { consoleLines, networkLines, interactivesLines, interactiveLine, linksLines } from './formatters.js';
@@ -273,6 +274,24 @@ export const TOOL_CAPS = {
   files: ['save_page', 'manage_downloads', 'session_record'],
 };
 
+// Tool sempre caricati nel contesto quando il client carica il server per
+// intero (alwaysLoad del plugin). Gli altri portano
+// _meta['anthropic/alwaysLoad'] = false e restano dietro la ricerca dei tool
+// (Claude Code 2.1.285+): lo schema pagato a ogni sessione scende, e un tool
+// rimandato si trova con ToolSearch. Scelti dall'uso reale: ogni tool usato
+// almeno 5 volte in 61 sessioni dell'autore (docs/analisi-2026-09-01.md, B.4),
+// più extract_table e get_css_styles: le istruzioni del server li indicano per
+// tabelle e debug, e nel benchmark appaiato del 01/10 (w128a) ogni run heavy
+// caricava extract_table con ToolSearch, un turno in più, e le debug
+// get_css_styles.
+// CHROME_BRIDGE_ALWAYS_LOAD=all li rimette tutti, o una lista ne sceglie altri.
+export const EAGER_TOOLS = [
+  'execute_js', 'navigate', 'screenshot', 'find_text', 'click', 'get_interactives', 'create_tab', 'get_tabs',
+  'tab_action', 'tile_windows', 'full_page_screenshot', 'extract', 'read_page', 'get_status', 'scroll',
+  'wait_for', 'element_screenshot', 'type_text', 'window_layout', 'fill_form', 'extract_table', 'get_css_styles',
+];
+const DEFER_META = { 'anthropic/alwaysLoad': false };
+
 // Parametri ubiqui: un solo testo, così `tab_id` non significa una cosa in un
 // tool e un'altra nel gemello. test/unit/tool-parameters.test.js lo verifica.
 // save_to: il payload va su disco e nel contesto resta solo il percorso più un
@@ -499,8 +518,14 @@ export function registerTools(server, wsManager, caps = 'all', options = {}) {
   // fuori dai gruppi attivi, e le annotations vengono applicate da TOOL_ANNOTATIONS.
   // Un solo wrapper per entrambe le cose, altrimenti con caps != 'all' le
   // annotations sparivano insieme al filtro.
+  // Il server MCP a basso livello (capability del client, elicitation): il
+  // wrapper qui sotto espone solo tool().
+  const lowLevelServer = server.server ?? null;
   {
     const target = server;
+    const eagerOpt = options.alwaysLoad ?? null;
+    const eager = eagerOpt === 'all' ? null
+      : new Set(eagerOpt ? String(eagerOpt).split(',').map((s) => s.trim()).filter(Boolean) : EAGER_TOOLS);
     const enabled = caps !== 'all'
       ? new Set(String(caps).split(',').map((s) => s.trim()).filter(Boolean))
       : null;
@@ -517,6 +542,9 @@ export function registerTools(server, wsManager, caps = 'all', options = {}) {
         // Un tool senza voce resta registrato (meglio di un crash all'avvio):
         // è il test tool-annotations a segnalarlo.
         const reg = annotations ? target.tool(name, desc, schema, annotations, run) : target.tool(name, desc, schema, run);
+        // Assegnato e non con update(): update() manderebbe tools/list_changed
+        // per ogni tool, prima ancora che il client sia collegato.
+        if (eager && !eager.has(name) && reg && typeof reg === 'object') reg._meta = { ...(reg._meta ?? {}), ...DEFER_META };
         if (inactive) { reg.disable(); dormant.set(name, reg); }
       },
     };
@@ -843,6 +871,8 @@ export function registerTools(server, wsManager, caps = 'all', options = {}) {
             port: wsManager.port,
             version: VERSION,
             extension_version: wsManager.extVersion ?? null,
+            ...(wsManager.browser && { browser: wsManager.browser.label }),
+            ...(wsManager.refusedBrowsers?.length && { refused_browsers: wsManager.refusedBrowsers.map((r) => `${r.label} at ${r.at}`) }),
             // Un agente che non trova accessibility_audit non aveva modo di
             // scoprire che esiste ma è in un gruppo disattivato.
             js_evaluation: !noJs,
@@ -2219,7 +2249,7 @@ export function registerTools(server, wsManager, caps = 'all', options = {}) {
   // --- upload_file ---
   server.tool(
     'upload_file',
-    'Set a file on input[type=file] from the server filesystem via DataTransfer (max 10MB). Keys and credentials (~/.ssh, ~/.aws, '
+    'Set a file on input[type=file] from the server filesystem via DataTransfer (max 200 MB; over 6 MB it travels in pieces). Keys and credentials (~/.ssh, ~/.aws, '
       + '~/.gnupg, .env*, *.pem, *.key, id_*…) are refused, and a --read-root on the server limits the readable tree: the call fails '
       + 'with an error, nothing is read.',
     {
@@ -2229,12 +2259,12 @@ export function registerTools(server, wsManager, caps = 'all', options = {}) {
       tab_id: tabId,
     },
     async ({ selector, path, mime_type, tab_id }) => {
-      const buf = await readFile(await guardRead(path));
-      if (buf.length > 10 * 1024 * 1024) throw new Error(`File too large: ${buf.length} bytes (max 10MB)`);
+      const abs = await guardRead(path);
+      const { size } = await stat(abs);
+      if (size > MAX_UPLOAD_BYTES) throw new Error(`File too large: ${size} bytes (max ${MAX_UPLOAD_BYTES / 1024 / 1024} MB)`);
+      const buf = await readFile(abs);
       const mime = mime_type || MIME_BY_EXT[extname(path).toLowerCase()] || 'application/octet-stream';
-      const data = await send(MessageType.UPLOAD_FILE, {
-        selector, name: basename(path), mime_type: mime, content_b64: buf.toString('base64'), tab_id,
-      });
+      const data = await uploadBuffer(send, { selector, name: basename(path), mime_type: mime, buf, tab_id });
       return { content: [{ type: 'text', text: jsonText(data) }] };
     }
   );
@@ -2516,11 +2546,13 @@ export function registerTools(server, wsManager, caps = 'all', options = {}) {
       ask: z.boolean().optional().default(false).describe('Show a text box in the banner; the reply comes back as answer'),
       pick_max: z.number().optional().default(1).describe('With pick_element: up to N elements, the user presses Done when finished'),
       timeout: z.number().optional().default(300000).describe('ms to wait for the click, default 5 min'),
+      in_terminal: z.boolean().optional().default(true).describe('Also ask in the Claude Code terminal (MCP elicitation) when the client supports it; the first answer wins. Not for pick_element'),
       tab_id: tabId,
     },
-    async ({ message, pick_element, ask, pick_max, timeout, tab_id }) => {
-      const d = await send(MessageType.HANDOFF, { message, pick_element, ask, pick_max, timeout, tab_id });
-      const lines = [`handoff ${d.action}${d.url ? ` url=${d.url}` : ''}`];
+    async ({ message, pick_element, ask, pick_max, timeout, in_terminal, tab_id }) => {
+      const banner = send(MessageType.HANDOFF, { message, pick_element, ask, pick_max, timeout, tab_id });
+      const d = in_terminal !== false && !pick_element ? await withTerminalAsk(banner, { message, ask, tab_id }) : await banner;
+      const lines = [`handoff ${d.action}${d.url ? ` url=${d.url}` : ''}${d.via === 'terminal' ? ' via=terminal' : ''}`];
       if (ask && typeof d.answer === 'string' && d.answer.trim()) lines.push(`answer: ${d.answer.trim()}`);
       const fmt = (p) => `${p.selector}\t${p.tag}\t${p.text}\t@${p.rect.x},${p.rect.y} ${p.rect.width}x${p.rect.height}`;
       if (Array.isArray(d.picked_all) && d.picked_all.length) {
@@ -2529,10 +2561,45 @@ export function registerTools(server, wsManager, caps = 'all', options = {}) {
         lines.push(`picked ${fmt(d.picked)}`);
       }
       if (d.action === 'timeout') lines.push('the user did not click within the timeout: ask before retrying');
+      if (d.banner_left_open) lines.push('answered in the terminal; the page banner is still open (extension older than the server): the user can close it');
       return { content: [{ type: 'text', text: lines.join('\n') }] };
     }
   );
 
+  // handoff anche nel terminale: chi lavora con Claude Code spesso guarda il
+  // terminale, non il browser. Una richiesta form (elicitation MCP) corre in
+  // parallelo al banner e vince la prima risposta: dal terminale si chiude il
+  // banner (handoff_end), dal banner si annulla la richiesta nel terminale.
+  // La modalità URL dell'elicitation non serve qui: aprirebbe il link nel
+  // browser predefinito, che può non essere il Chrome in cui lavora l'agente.
+  async function withTerminalAsk(banner, { message, ask, tab_id }) {
+    const lowLevel = lowLevelServer;
+    if (!lowLevel?.getClientCapabilities?.()?.elicitation) return banner;
+    const abort = new AbortController();
+    const requestedSchema = ask
+      ? { type: 'object', properties: { answer: { type: 'string', title: 'Reply' } }, required: ['answer'] }
+      : { type: 'object', properties: {} };
+    const terminal = lowLevel.elicitInput(
+      { mode: 'form', message: `${message}\n\nDo it in Chrome (a banner there waits too), then accept here; decline to cancel.`, requestedSchema },
+      { signal: abort.signal, timeout: 24 * 3600 * 1000 },
+    ).then((r) => ({ from: 'terminal', r }), () => null);
+    const first = await Promise.race([banner.then((d) => ({ from: 'banner', d })), terminal.then((t) => t ?? banner.then((d) => ({ from: 'banner', d })))]);
+    if (first.from === 'banner') {
+      abort.abort();
+      return first.d;
+    }
+    const accepted = first.r.action === 'accept';
+    const action = accepted ? 'done' : 'cancel';
+    const answer = accepted && ask ? String(first.r.content?.answer ?? '') : undefined;
+    try {
+      const end = await send(MessageType.HANDOFF_END, { action, ...(answer != null && { answer }), tab_id });
+      if (end?.ended) return banner;
+    } catch { /* estensione fino alla 1.27: handoff_end non esiste */ }
+    // Il banner non si è potuto chiudere (estensione vecchia, o handoff già
+    // finito): vale la risposta del terminale, senza aspettare il banner.
+    return { done: accepted, action, url: null, via: 'terminal', ...(answer != null && { answer }), banner_left_open: true };
+  }
+
   // --- watch ---
   server.tool(
     'watch',

package/server/upload.js

@@ -0,0 +1,37 @@
+/**
+ * upload_file oltre i 10 MB: il file passa a pezzi.
+ *
+ * Fino alla 1.27 il file viaggiava intero in un solo messaggio, in base64,
+ * con un tetto di 10 MB (il 01/10/2026 un video per X è stato ricompresso
+ * apposta). Ora sopra CHUNK_BYTES il server manda upload_chunk uno alla volta
+ * (ciascuno ben sotto i 32 MB di maxPayload del bridge) e la pagina li
+ * accumula; upload_file monta il File dai pezzi. Sotto CHUNK_BYTES resta il
+ * messaggio unico, che funziona anche con le estensioni fino alla 1.27.
+ */
+import { randomBytes } from 'node:crypto';
+import { MessageType } from './protocol.js';
+
+export const CHUNK_BYTES = 6 * 1024 * 1024;
+export const MAX_UPLOAD_BYTES = 200 * 1024 * 1024;
+
+export async function uploadBuffer(send, { selector, name, mime_type, buf, tab_id }) {
+  if (buf.length > MAX_UPLOAD_BYTES) throw new Error(`File too large: ${buf.length} bytes (max ${MAX_UPLOAD_BYTES / 1024 / 1024} MB)`);
+  if (buf.length <= CHUNK_BYTES) {
+    return send(MessageType.UPLOAD_FILE, { selector, name, mime_type, content_b64: buf.toString('base64'), tab_id });
+  }
+  const upload_id = `u${randomBytes(6).toString('hex')}`;
+  const total = Math.ceil(buf.length / CHUNK_BYTES);
+  try {
+    for (let index = 0; index < total; index++) {
+      const part = buf.subarray(index * CHUNK_BYTES, (index + 1) * CHUNK_BYTES);
+      await send(MessageType.UPLOAD_CHUNK, { upload_id, index, total, content_b64: part.toString('base64'), tab_id });
+    }
+  } catch (err) {
+    await send(MessageType.UPLOAD_CHUNK, { upload_id, abort: true, tab_id }).catch(() => {});
+    if (/Unknown command type: upload_chunk/.test(err.message)) {
+      throw new Error(`Files over ${CHUNK_BYTES / 1024 / 1024} MB need the extension from version 1.28: update it, or upload a smaller file`);
+    }
+    throw err;
+  }
+  return send(MessageType.UPLOAD_FILE, { selector, name, mime_type, upload_id, size: buf.length, tab_id });
+}

package/server/ws-manager.js

@@ -23,6 +23,16 @@ export function relayExpiry(msg) {
   return Math.max(PENDING_RELAY_TTL_MS, base, Number.isFinite(asked) && asked > 0 ? asked + 5000 : 0) + 5000;
 }
 
+/**
+ * Stesso browser: stesso id persistente. Le estensioni fino alla 1.27 non
+ * mandano un id: fra due di queste vale la sostituzione di sempre (non si
+ * possono distinguere), mentre un id contro nessun id sono browser diversi.
+ */
+export function sameBrowser(a, b) {
+  if (!a?.id && !b?.id) return true;
+  return Boolean(a?.id && b?.id && a.id === b.id);
+}
+
 export class WSManager {
   constructor(port = DEFAULT_PORT, opts = {}) {
     this.port = port;
@@ -49,6 +59,8 @@ export class WSManager {
     this.relayExtConnected = undefined;  // relay mode: stato estensione riportato dal primary
     this.relayExtVersion = null;
     this._extVersion = null;     // versione estensione da ext_init (primary)
+    this._browser = null;        // { id, label } del browser collegato, da ext_init
+    this.refusedBrowsers = [];   // ultimi browser rifiutati perché un altro era già collegato
 
     // --- primary mode ---
     this.wss = null;
@@ -99,6 +111,11 @@ export class WSManager {
   }
 
   /** Versione dell'estensione collegata (da ext_init), o null. */
+  /** Browser collegato ({ id, label }) e ultimi rifiutati; in relay mode non noti. */
+  get browser() {
+    return this.mode === 'relay' ? null : this._browser;
+  }
+
   get extVersion() {
     return this.mode === 'relay' ? (this.relayExtVersion ?? null) : (this._extVersion ?? null);
   }
@@ -304,7 +321,7 @@ export class WSManager {
           ws.terminate();
           return;
         }
-        this._setupChromeClient(ws, msg.version ?? null);
+        this._setupChromeClient(ws, msg.version ?? null, msg.browser ?? null);
         return;
       }
 
@@ -316,8 +333,29 @@ export class WSManager {
     ws.on('close', () => clearTimeout(idTimer));
   }
 
-  _setupChromeClient(ws, extVersion = null) {
+  _setupChromeClient(ws, extVersion = null, browser = null) {
+    // Un secondo browser non prende più la connessione a quello collegato:
+    // il 01/10/2026 un Chromium di prova sulla stessa porta ha rubato la
+    // connessione al Chrome dell'utente, e i comandi delle altre sessioni
+    // finivano nel browser sbagliato. Lo stesso browser che si riconnette
+    // (service worker riavviato) sostituisce la sua vecchia connessione; un
+    // browser diverso aspetta che l'altro si scolleghi o smetta di rispondere.
+    const current = this.client;
+    const alive = current && current.readyState === WebSocket.OPEN
+      && Date.now() - this.lastPong <= this.pingIntervalMs * 2 + this.pongGraceMs;
+    if (alive && !sameBrowser(this._browser, browser)) {
+      const refused = { label: browser?.label ?? 'a browser with an older extension', id: browser?.id ?? null, at: new Date().toISOString() };
+      this.refusedBrowsers = [refused, ...this.refusedBrowsers.filter((r) => r.id !== refused.id || r.label !== refused.label)].slice(0, 5);
+      const connected = this._browser?.label ?? 'another browser';
+      console.error(`[chrome-bridge] Refused ${refused.label}: ${connected} is already connected on this port`);
+      try {
+        ws.send(JSON.stringify({ type: 'ext_init_refused', connected, reason: `${connected} is already connected to this chrome-bridge` }));
+      } catch {}
+      ws.close(4409, 'Another browser is connected');
+      return;
+    }
     this._extVersion = extVersion;
+    this._browser = browser;
     // Lo skew server/estensione era invisibile: con la latenza di review del
     // Chrome Web Store è la norma, non l'eccezione.
     if (extVersion && extVersion !== VERSION) {
@@ -363,6 +401,7 @@ export class WSManager {
       if (this.client === ws) {
         this.client = null;
         this._extVersion = null;
+        this._browser = null;
         this._broadcastExtState();
         // Rigetta pending locali
         this._rejectAllPending('Extension disconnected');