@evan_zhong/browser-attach 0.11.2 → 0.13.1

package/extension/controller.js

@@ -1,7 +1,7 @@
 // Browser operations live here; the WebSocket transport never exposes raw CDP.
 import { createVisuals } from './visuals.js';
 import { createClickVisuals } from './click-visuals.js';
-import { renderAX, snapshotPage } from './snapshot.js';
+import { renderAX, snapshotOptions, snapshotPage } from './snapshot.js';
 import { createNavigation } from './navigation.js';
 import { createClick, clickOptions, framePoint } from './click.js';
 import { createInput, inputMode, selectOptions, typeOptions } from './input.js';
@@ -17,9 +17,12 @@ import { validateSteps } from './batch.js';
 import { waitFor } from './wait.js';
 import { boundedRead, installOutcomeObserver } from './outcomes.js';
 import { createDrag, dragOptions } from './drag.js';
+import { createFetches, capturePage } from './fetch.js';
 
 export function createController(api, notify = () => {}) {
   const claims = new Map();
+  const temporaryTabs = new Map();
+  const fetches = createFetches(fetchPage);
   const snapshots = new Map();
   const documents = new Map();
   const pageContexts = new Map();
@@ -38,7 +41,7 @@ export function createController(api, notify = () => {}) {
     for (const key of pageContexts.keys()) { const [tab, session] = JSON.parse(key); if (tab === tabId && session === sessionId) pageContexts.delete(key); }
   }, tabId => diagnostics.networkOptions(tabId));
   const mouse = createClick(cdp, value, viewport, position, sessions, tabId => api.tabs.get(tabId), windowId => api.windows.get(windowId));
-  const gestures = createDrag(cdp, value, mouse);
+  const gestures = createDrag(cdp, value, mouse, viewport);
   const input = createInput(cdp, value, sessions);
   const evaluations = createEvaluations(cdp);
 
@@ -155,8 +158,8 @@ export function createController(api, notify = () => {}) {
   }
 
   async function releaseMatching(predicate) {
-    const targets = [...claims.entries()].filter(([, claim]) => predicate(claim));
-    const outcomes = await Promise.allSettled(targets.map(([tabId]) => queued(tabId, () => release(tabId))));
+    const targets = new Map([...claims, ...temporaryTabs].filter(([, claim]) => predicate(claim)));
+    const outcomes = await Promise.allSettled([...targets].map(([tabId]) => queued(tabId, () => temporaryTabs.has(tabId) ? closeTemporary(tabId) : release(tabId))));
     return { released: outcomes.filter(item => item.status === 'fulfilled').length,
       errors: outcomes.filter(item => item.status === 'rejected').map(item => String(item.reason)) };
   }
@@ -241,7 +244,7 @@ export function createController(api, notify = () => {}) {
     }
     if (method === 'Page.javascriptDialogClosed') dialogs.delete(source.tabId);
   });
-  api.tabs.onRemoved.addListener(forget);
+  api.tabs.onRemoved.addListener(tabId => { temporaryTabs.delete(tabId); forget(tabId); });
   api.tabs.onUpdated.addListener((tabId, change) => {
     // A subframe reload can also set the TAB status to loading. CDP main-frame
     // events identify document changes; a status-only update carries no identity.
@@ -291,6 +294,7 @@ export function createController(api, notify = () => {}) {
       if (!state) throw new Error('Snapshot cursor is stale or unknown. Take a new browser_snapshot.');
       return snapshotPage(state, args);
     }
+    const options = snapshotOptions(args);
     snapshots.delete(tabId);
     const documentVersion = documents.get(tabId);
     const versions = new Map(frameStates.get(tabId)?.versions);
@@ -329,12 +333,12 @@ export function createController(api, notify = () => {}) {
         knownFrames.add(childId); frames.push({ id: childId, url });
       }
       entries.push({ node: false, frameId: frame.id, line: `Frame ${frame.id} ${frame.url}` });
-      entries.push(...renderAX(nodes, token, refs, frame.id, target.sessionId));
+      entries.push(...renderAX(nodes, token, refs, frame.id, target.sessionId, options));
     }
     const metadata = value(await send(tabId, 'Runtime.evaluate', {
       expression: '({title: document.title, url: location.href})', returnByValue: true,
     }));
-    const state = { id: token, refs, entries, invalidFrames: new Set(), totalNodes: entries.filter(entry => entry.node).length,
+    const state = { id: token, options, refs, entries, invalidFrames: new Set(), totalNodes: entries.filter(entry => entry.node).length,
       metadata: { title: metadata.title, url: metadata.url, viewport: await (budget ? budget.run(() => viewport(tabId)) : viewport(tabId)), omitted_frames: omittedFrames } };
     if (documentVersion !== documents.get(tabId)) throw new Error('Document changed while reading the snapshot. Take a new browser_snapshot.');
     for (const frame of frames) if (versions.get(frame.id) !== frameStates.get(tabId)?.versions.get(frame.id)) {
@@ -697,7 +701,82 @@ export function createController(api, notify = () => {}) {
     return { x: 0, y: 0, width: cssContentSize.width, height: cssContentSize.height, scale: 1 };
   }
 
+  async function closeTemporary(tabId) {
+    try { await api.tabs.remove(tabId); }
+    catch (error) {
+      // A closed tab is already clean; otherwise retain ownership for later cleanup.
+      let tab;
+      try { tab = await api.tabs.get(tabId); }
+      catch (lookup) { if (!/No tab with id|Invalid tab ID/i.test(lookup.message)) throw error; }
+      if (tab) throw error;
+    }
+    temporaryTabs.delete(tabId);
+    if (claims.has(tabId)) forget(tabId);
+  }
+
+  async function fetchPage(owner, args, cap, checkConnection) {
+    const url = httpUrl(args.url);
+    const budget = deadline(args.timeout_ms ?? 15000, 'fetch');
+    const tab = await api.tabs.create({ url: 'about:blank', active: false });
+    const handle = crypto.randomUUID();
+    temporaryTabs.set(tab.id, { owner, handle });
+    return await queued(tab.id, async () => {
+      let failure;
+      try {
+        checkConnection();
+        await attach(tab.id, owner, { tab_handle: handle }, tab, budget);
+        const claim = claims.get(tab.id);
+        checkConnection();
+        if (budget.remaining() < 100) throw new Error('Fetch preparation timed out; no navigation was dispatched');
+        await navigation.navigate(tab.id, url, { wait_until: 'load', timeout_ms: Math.max(100, budget.remaining()) });
+        checkConnection();
+        if (args.wait_until === 'network_idle') await waitFor(cdp, value, sessions, diagnostics, mouse, tab.id, { condition: 'network_idle', budget });
+        checkConnection();
+        const version = documents.get(tab.id);
+        const { frameTree } = await budget.run(() => cdp(tab.id, 'Page.getFrameTree'));
+        const { executionContextId } = await budget.run(() => cdp(tab.id, 'Page.createIsolatedWorld', { frameId: frameTree.frame.id, worldName: 'browser-attach-fetch' }));
+        const result = value(await budget.run(() => cdp(tab.id, 'Runtime.evaluate', { contextId: executionContextId, returnByValue: true, userGesture: false,
+          expression: `(${capturePage.toString()})(${JSON.stringify(args.format ?? 'text')},${cap})` })));
+        if (claims.get(tab.id) !== claim || documents.get(tab.id) !== version) throw new Error('Document or control changed during fetch; capture discarded');
+        httpUrl(result.url);
+        return result;
+      } catch (error) { failure = error; throw error; }
+      finally {
+        try { await closeTemporary(tab.id); }
+        catch (error) { throw new Error(`${failure ? failure.message + '; ' : ''}Fetch temporary tab ${tab.id} could not be closed: ${error.message}. Cleanup will be retried on disconnect.`); }
+      }
+    });
+  }
+
+  async function attach(tabId, owner, args, tab, budget) {
+    const run = operation => budget ? budget.run(operation) : operation();
+    await run(() => api.debugger.attach({ tabId }, '1.3'));
+    try {
+      diagnostics.start(tabId);
+      await run(() => sessions.start(tabId));
+      const { frameTree } = await run(() => cdp(tabId, 'Page.getFrameTree'));
+      const state = { mainId: frameTree.frame.id, parents: new Map(), versions: new Map(), sessions: new Map() };
+      const remember = tree => {
+        if (tree.frame.parentId) state.parents.set(tree.frame.id, tree.frame.parentId);
+        (tree.childFrames || []).forEach(remember);
+      };
+      remember(frameTree); frameStates.set(tabId, state);
+      claims.set(tabId, { owner, handle: args.tab_handle });
+      let visualWarning;
+      try { if (!temporaryTabs.has(tabId)) await visuals.install(tabId); }
+      catch (error) { visualWarning = error.message; }
+      return { claimed: true, activation_requested: false, title: tab.title, url: tab.url,
+        ...(visualWarning ? { visual_warning: visualWarning } : {}) };
+    } catch (error) {
+      diagnostics.forget(tabId);
+      sessions.forget(tabId);
+      if (!temporaryTabs.has(tabId)) await api.debugger.detach({ tabId });
+      throw error;
+    }
+  }
+
   async function execute(owner, command, args) {
+    if (command === 'fetch') return await fetches.fetch(owner, args);
     if (command === 'open_tab') {
       const url = httpUrl(args.url);
       if (args.active != null && typeof args.active !== 'boolean') throw new Error('active must be a boolean');
@@ -706,15 +785,16 @@ export function createController(api, notify = () => {}) {
         note: 'List tabs after loading, then claim tab_id with optional exact URL/title guards before controlling this tab.' };
     }
     if (command === 'list_tabs') {
-      const tabs = await api.tabs.query({});
+      const tabs = (await api.tabs.query({})).filter(tab => !temporaryTabs.has(tab.id));
       return { tabs: tabs.map(tab => ({ tab_id: tab.id, window_id: tab.windowId, title: tab.title || '', url: tab.url || '',
         active: tab.active, group_id: tab.groupId, controllable: /^https?:\/\//.test(tab.url || '') })) };
     }
-    if (command === 'release_owner') return await releaseMatching(claim => claim.owner === owner);
+    if (command === 'release_owner') { fetches.forget(owner); return await releaseMatching(claim => claim.owner === owner); }
     const tabId = args.tab_id;
     if (!Number.isInteger(tabId)) throw new Error('Invalid tab ID');
     return await queued(tabId, async () => {
       if (command === 'claim_tab') {
+        if (temporaryTabs.has(tabId)) throw new Error('Tab is already controlled by a fetch operation');
         const tab = await api.tabs.get(tabId);
         if ((args.expected_url != null && tab.url !== args.expected_url) || (args.expected_title != null && tab.title !== args.expected_title)) throw new Error('Tab title/URL changed. List tabs again or omit optional identity guards to claim by tab_id.');
         httpUrl(tab.url);
@@ -723,29 +803,7 @@ export function createController(api, notify = () => {}) {
           if (existing.owner === owner && existing.handle === args.tab_handle) return { claimed: true };
           throw new Error('Tab is already controlled by another session');
         }
-        await api.debugger.attach({ tabId }, '1.3');
-        try {
-          diagnostics.start(tabId);
-          await sessions.start(tabId);
-          const { frameTree } = await cdp(tabId, 'Page.getFrameTree');
-          const state = { mainId: frameTree.frame.id, parents: new Map(), versions: new Map(), sessions: new Map() };
-          const remember = tree => {
-            if (tree.frame.parentId) state.parents.set(tree.frame.id, tree.frame.parentId);
-            (tree.childFrames || []).forEach(remember);
-          };
-          remember(frameTree); frameStates.set(tabId, state);
-          claims.set(tabId, { owner, handle: args.tab_handle });
-          let visualWarning;
-          try { await visuals.install(tabId); }
-          catch (error) { visualWarning = error.message; }
-          return { claimed: true, activation_requested: false, title: tab.title, url: tab.url,
-            ...(visualWarning ? { visual_warning: visualWarning } : {}) };
-        } catch (error) {
-          diagnostics.forget(tabId);
-          sessions.forget(tabId);
-          await api.debugger.detach({ tabId });
-          throw error;
-        }
+        return await attach(tabId, owner, args, tab);
       }
       const claim = claims.get(tabId);
       if (!claim || claim.owner !== owner || claim.handle !== args.tab_handle) throw new Error('Tab is not claimed by this connection');
@@ -779,7 +837,7 @@ export function createController(api, notify = () => {}) {
     });
   }
 
-  return { execute, releaseAll: () => releaseMatching(() => true), claimedCount: () => claims.size };
+  return { execute, releaseAll: () => { fetches.clear(); return releaseMatching(() => true); }, claimedCount: () => claims.size };
 }
 
 function scrollAtPoint(x, y, dx, dy) {

package/extension/drag.js

@@ -3,12 +3,15 @@ import { targetOptions } from './locator.js';
 
 export function dragOptions(args) {
   if (!args.source || !args.destination) throw new Error('drag requires source and destination');
-  for (const target of [args.source, args.destination]) targetOptions(target, { coordinates: true });
+  for (const target of [args.source, args.destination]) {
+    targetOptions(target, { coordinates: true });
+    if (target.coordinate_space === 'document' && (target.x < 0 || target.y < 0)) throw new Error('Document coordinates must be finite and nonnegative');
+  }
   if (!['pointer', 'html5'].includes(args.mode ?? 'pointer')) throw new Error('drag mode must be pointer or html5');
   if (!Number.isInteger(args.steps ?? 20) || (args.steps ?? 20) < 2 || (args.steps ?? 20) > 100) throw new Error('steps must be 2..100');
 }
 
-export function createDrag(cdp, value, mouse) {
+export function createDrag(cdp, value, mouse, viewport) {
   const pending = new Map();
   function event(tabId, method, params, sessionId) {
     const operation = pending.get(tabId);
@@ -36,6 +39,20 @@ export function createDrag(cdp, value, mouse) {
     dragOptions(args);
     const budget = args.budget || deadline(args.timeout_ms ?? 5000), html5 = args.mode === 'html5', steps = args.steps ?? 20;
     await mouse.assertReady(tabId, budget);
+    if (args.source.coordinate_space === 'document' && args.destination.coordinate_space === 'document') {
+      const view = await budget.run(() => viewport(tabId)), a = args.source, b = args.destination;
+      // Keep both endpoints in one viewport when possible. Centering them
+      // independently can erase the requested delta before interpolation.
+      if (Math.abs(a.x - b.x) < view.width && Math.abs(a.y - b.y) < view.height) {
+        const left = Math.min(a.x, b.x) < view.scroll_x || Math.max(a.x, b.x) >= view.scroll_x + view.width
+          ? Math.max(0, (a.x + b.x - view.width) / 2) : view.scroll_x;
+        const top = Math.min(a.y, b.y) < view.scroll_y || Math.max(a.y, b.y) >= view.scroll_y + view.height
+          ? Math.max(0, (a.y + b.y - view.height) / 2) : view.scroll_y;
+        if (left !== view.scroll_x || top !== view.scroll_y) value(await budget.run(() => cdp(tabId, 'Runtime.evaluate', {
+          expression: `scrollTo({left:${left},top:${top},behavior:'instant'})`, returnByValue: true,
+        })));
+      }
+    }
     const source = await mouse.prepare(tabId, await resolve(args.source, budget), { ...args.source, budget });
     const name = `__attachDrag_${crypto.randomUUID().replaceAll('-', '')}`, contexts = new Set(), guards = [], frames = new Set();
     let intercept; const intercepted = new Promise(resolve => { intercept = resolve; });

package/extension/fetch.js

@@ -0,0 +1,60 @@
+const CAPTURE_CHARS = 1000000;
+
+export function fetchOptions(args) {
+  if (!Number.isInteger(args.max_chars ?? 20000) || (args.max_chars ?? 20000) < 1 || (args.max_chars ?? 20000) > 100000) throw new Error('max_chars must be 1..100000');
+  if (args.cursor != null) {
+    if (typeof args.cursor !== 'string' || !args.cursor || ['url', 'format', 'wait_until', 'timeout_ms'].some(key => args[key] != null)) throw new Error('Cursor continuation accepts only browser_id, cursor and max_chars');
+    return;
+  }
+  const url = new URL(args.url);
+  if (!['http:', 'https:'].includes(url.protocol) || url.username || url.password) throw new Error('fetch requires an HTTP(S) URL without credentials');
+  if (!['text', 'html', 'json'].includes(args.format ?? 'text')) throw new Error('format must be text, html or json');
+  if (!['load', 'network_idle'].includes(args.wait_until ?? 'load')) throw new Error('wait_until must be load or network_idle');
+  if (!Number.isInteger(args.timeout_ms ?? 15000) || (args.timeout_ms ?? 15000) < 100 || (args.timeout_ms ?? 15000) > 30000) throw new Error('timeout_ms must be 100..30000');
+}
+
+// Executed in an isolated world. Read the rendered main document, never a second request.
+export function capturePage(format, cap) {
+  if (!/^https?:$/.test(location.protocol)) throw new Error('Final document is outside HTTP(S) scope');
+  let body = format === 'html' ? document.documentElement.outerHTML : format === 'json'
+    ? (document.querySelector('pre') || document.body)?.textContent || '' : document.body?.innerText || '';
+  if (format === 'json') {
+    if (body.length > cap) throw new Error('JSON document exceeds the 1000000 character capture limit');
+    body = JSON.stringify(JSON.parse(body));
+    if (body.length > cap) throw new Error('JSON document exceeds the 1000000 character capture limit');
+  }
+  return { url: location.href, title: document.title, contentType: document.contentType, format,
+    body: body.slice(0, cap), capture_truncated: body.length > cap };
+}
+
+// One bounded immutable capture per owner; closing the temporary tab does not expire it.
+export function createFetches(read) {
+  const results = new Map();
+  async function fetch(owner, args) {
+    fetchOptions(args);
+    let state;
+    if (args.cursor != null) {
+      state = results.get(owner);
+      if (!state?.result || state.cursor !== args.cursor) throw new Error('Fetch cursor is stale or belongs to another connection; a new fetch replaces the previous capture');
+    } else {
+      state = { offset: 0 };
+      results.set(owner, state);
+      try {
+        const result = await read(owner, args, CAPTURE_CHARS, () => {
+          if (results.get(owner) !== state) throw new Error('Fetch connection ended; capture discarded');
+        });
+        if (results.get(owner) !== state) throw new Error('Fetch connection ended; capture discarded');
+        state.result = result;
+      } catch (error) { if (results.get(owner) === state) results.delete(owner); throw error; }
+    }
+    const { body, ...metadata } = state.result;
+    const end = Math.min(body.length, state.offset + (args.max_chars ?? 20000));
+    const chunk = body.slice(state.offset, end);
+    state.offset = end;
+    state.cursor = end < body.length ? crypto.randomUUID() : null;
+    const result = { ...metadata, body: chunk, truncated: end < body.length || metadata.capture_truncated, next_cursor: state.cursor };
+    if (!state.cursor) results.delete(owner);
+    return result;
+  }
+  return { fetch, forget: owner => results.delete(owner), clear: () => results.clear() };
+}

package/extension/manifest.json

@@ -1,7 +1,7 @@
 {
   "manifest_version": 3,
   "name": "BrowserAttach",
-  "version": "0.11.2",
+  "version": "0.13.1",
   "description": "Connect existing Chrome and Edge tabs to a locally paired MCP client.",
   "minimum_chrome_version": "125",
   "permissions": [

package/extension/snapshot.js

@@ -1,9 +1,39 @@
 // Render semantic AX nodes once; page through the same observation without losing refs.
-export function renderAX(nodes, token, refs, frameId, sessionId) {
+export function snapshotOptions({ profile = 'full', text = true, text_limit } = {}) {
+  if (!['full', 'interactive'].includes(profile)) throw new Error('profile must be full or interactive');
+  if (typeof text !== 'boolean') throw new Error('text must be a boolean');
+  if (text_limit != null && (!Number.isInteger(text_limit) || text_limit < 0 || text_limit > 10000)) throw new Error('text_limit must be 0..10000');
+  return { profile, text, text_limit: text_limit ?? (profile === 'interactive' ? 80 : null) };
+}
+
+export function renderAX(nodes, token, refs, frameId, sessionId, options = snapshotOptions()) {
   const byId = new Map(nodes.map(node => [node.nodeId, node]));
   const visited = new Set();
   const entries = [];
   const textRoles = new Set(['StaticText', 'InlineTextBox', 'ListMarker']);
+  const controls = new Set(['button', 'checkbox', 'combobox', 'DisclosureTriangle', 'link', 'listbox', 'menuitem',
+    'menuitemcheckbox', 'menuitemradio', 'option', 'radio', 'scrollbar', 'searchbox', 'slider', 'spinbutton', 'switch', 'tab', 'textbox', 'treeitem']);
+  let kept;
+  if (options.profile === 'interactive') {
+    kept = new Set();
+    const parents = new Map();
+    for (const node of nodes) for (const child of node.childIds || []) parents.set(child, node.nodeId);
+    function keepText(node) {
+      if (!node || kept.has(node.nodeId)) return;
+      const role = node.role?.value;
+      if (!textRoles.has(role) && !node.ignored && !['none', 'generic'].includes(role)) return;
+      kept.add(node.nodeId);
+      for (const child of node.childIds || []) keepText(byId.get(child));
+    }
+    for (const node of nodes) {
+      if (node.ignored || !node.backendDOMNodeId || !(controls.has(node.role?.value) ||
+        node.properties?.some(prop => prop.name === 'focusable' && prop.value?.value === true ||
+          prop.name === 'editable' && prop.value?.value && prop.value.value !== 'false'))) continue;
+      for (const child of node.childIds || []) keepText(byId.get(child));
+      let id = node.nodeId;
+      while (id != null && !kept.has(id)) { kept.add(id); id = parents.get(id); }
+    }
+  }
   function plainText(node) {
     if (!node) return null;
     const role = node.role?.value;
@@ -15,6 +45,7 @@ export function renderAX(nodes, token, refs, frameId, sessionId) {
   function render(node, depth, parentName = '') {
     if (!node || visited.has(node.nodeId)) return;
     visited.add(node.nodeId);
+    if (kept && !kept.has(node.nodeId)) return;
     const role = node.role?.value || 'node';
     if (role === 'InlineTextBox') return;
     let name = String(node.name?.value || '');
@@ -28,8 +59,13 @@ export function renderAX(nodes, token, refs, frameId, sessionId) {
     ).map(prop => `${prop.name}=${JSON.stringify(prop.value?.value)}`);
     if (node.value?.value != null) states.push(`value=${JSON.stringify(node.value.value)}`);
     const attributes = states.join(' ');
-    const skip = node.ignored || (['none', 'generic'].includes(role) && !name && !attributes) ||
+    const skip = node.ignored || (!options.text && textRoles.has(role)) || (['none', 'generic'].includes(role) && !name && !attributes) ||
       (role === 'StaticText' && name === parentName);
+    const identityName = name;
+    if (textRoles.has(role) || merged) {
+      if (!options.text) name = '';
+      else if (options.text_limit != null && name.length > options.text_limit) name = name.slice(0, options.text_limit) + '…';
+    }
     let nextDepth = depth;
     if (!skip) {
       const ref = node.backendDOMNodeId ? `${token}:${refs.size + 1}` : null;
@@ -37,7 +73,7 @@ export function renderAX(nodes, token, refs, frameId, sessionId) {
       entries.push({ node: true, frameId, line: `${'  '.repeat(Math.min(depth, 24))}${ref ? `[${ref}] ` : ''}${role} ${JSON.stringify(name)}${attributes ? ' ' + attributes : ''}` });
       nextDepth++;
     }
-    if (!merged) for (const child of node.childIds || []) render(byId.get(child), nextDepth, skip ? parentName : name);
+    if (!merged) for (const child of node.childIds || []) render(byId.get(child), nextDepth, skip ? parentName : identityName);
   }
   // AX trees normally have a single root, but ignored roots can be disconnected.
   const children = new Set(nodes.flatMap(node => node.childIds || []));
@@ -45,12 +81,15 @@ export function renderAX(nodes, token, refs, frameId, sessionId) {
   return entries;
 }
 
-export function snapshotPage(state, { max_nodes = 600, max_chars = 24000, cursor } = {}) {
+export function snapshotPage(state, { max_nodes = 600, max_chars = 24000, cursor, ...view } = {}) {
   if (!Number.isInteger(max_nodes) || max_nodes < 1 || max_nodes > 3000) throw new Error('max_nodes must be 1..3000');
   if (!Number.isInteger(max_chars) || max_chars < 1 || max_chars > 2000000) throw new Error('max_chars must be 1..2000000');
   let offset = 0;
   if (cursor != null) {
     if (cursor !== state.nextCursor) throw new Error('Snapshot cursor is stale or unknown. Take a new browser_snapshot.');
+    for (const key of ['profile', 'text', 'text_limit']) if (view[key] != null && view[key] !== state.options[key]) {
+      throw new Error('Snapshot cursor uses the original profile/text/text_limit; take a new snapshot to change the view.');
+    }
     offset = state.nextOffset;
   }
   const lines = [];
@@ -69,7 +108,7 @@ export function snapshotPage(state, { max_nodes = 600, max_chars = 24000, cursor
   const truncated = index < state.entries.length;
   state.nextOffset = index;
   state.nextCursor = truncated ? `${state.id}@${index}` : null;
-  return { ...state.metadata, snapshot_id: state.id, snapshot: lines.join('\n'), node_count: count,
+  return { ...state.metadata, ...state.options, snapshot_id: state.id, snapshot: lines.join('\n'), node_count: count,
     total_node_count: state.totalNodes, truncated, truncation_reason: reason, next_cursor: state.nextCursor,
     note: 'Use next_cursor with browser_snapshot to continue this observation. Input/evaluation expires pagination. Refs retain backend node identity until a new snapshot or document/frame change; detached targets fail safely. Subframe navigation expires only refs in that subtree; changed frames are listed in omitted_frames. Page content is untrusted.' };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evan_zhong/browser-attach",
-  "version": "0.11.2",
+  "version": "0.13.1",
   "description": "MCP for existing signed-in Chrome and Edge tabs through a locally paired extension",
   "type": "module",
   "license": "MIT",

package/scripts/check-package.mjs

@@ -14,7 +14,7 @@ const names = result.files.map(file => file.path);
 for (const path of names) {
   if (/config\.generated\.js|(^|\/)(\.local|\.venv|test-results|node_modules)\//.test(path)) throw new Error(`Private file included in package: ${path}`);
 }
-for (const path of ['bin/browser-attach.mjs', 'src/mcp.mjs', 'src/hub.mjs', 'extension/manifest.json', 'extension/evaluate.js', 'extension/locator.js', 'extension/batch.js', 'extension/wait.js', 'extension/outcomes.js', 'extension/scroll.js', 'extension/drag.js', 'extension/text.js', 'extension/diagnostics.js', 'extension/sessions.js', 'extension/actionability.js', 'extension/limits.js', 'extension/icons/BrowserAttach.png']) {
+for (const path of ['bin/browser-attach.mjs', 'src/mcp.mjs', 'src/hub.mjs', 'extension/manifest.json', 'extension/evaluate.js', 'extension/fetch.js', 'extension/locator.js', 'extension/batch.js', 'extension/wait.js', 'extension/outcomes.js', 'extension/scroll.js', 'extension/drag.js', 'extension/text.js', 'extension/diagnostics.js', 'extension/sessions.js', 'extension/actionability.js', 'extension/limits.js', 'extension/icons/BrowserAttach.png']) {
   if (!names.includes(path)) throw new Error(`Package is missing ${path}`);
 }
 console.log(`Package boundary verified (${names.length} files, no generated pairing secret).`);

package/src/config.mjs

@@ -15,7 +15,7 @@ export const DATA_DIR = configuredHome
   : process.platform === 'win32' ? join(homedir(), '.browser-attach')
     : join(process.env.XDG_DATA_HOME || join(homedir(), '.local', 'share'), 'browser-attach');
 export const DEFAULT_CONFIG = join(DATA_DIR, 'config.json');
-export const VERSION = '0.11.2';
+export const VERSION = '0.13.1';
 
 export async function loadConfig(path = DEFAULT_CONFIG) {
   let config;

package/src/hub.mjs

@@ -6,7 +6,7 @@ import { VERSION } from './config.mjs';
 
 const MAX_MESSAGE = 24 * 1024 * 1024;
 const OPERATIONS = new Set(['release_tab', 'activate_tab', 'close_tab', 'snapshot', 'read_text', 'type', 'hover', 'drag', 'wait', 'select_option', 'click', 'fill', 'press_key', 'batch', 'scroll', 'navigate', 'screenshot', 'handle_dialog', 'upload_file', 'evaluate', 'logs']);
-export const CAPABILITIES = ['tabs', 'open_tab', 'activate_tab', 'close_tab', 'claim', 'ax_snapshot', 'text', 'type', 'hover', 'drag', 'wait', 'select_option', 'click', 'fill', 'keyboard', 'batch', 'scroll', 'navigate', 'screenshot', 'handle_dialog', 'upload_file', 'visual_indicator', 'evaluate', 'logs'];
+export const CAPABILITIES = ['tabs', 'fetch', 'open_tab', 'activate_tab', 'close_tab', 'claim', 'ax_snapshot', 'text', 'type', 'hover', 'drag', 'wait', 'select_option', 'click', 'fill', 'keyboard', 'batch', 'scroll', 'navigate', 'screenshot', 'handle_dialog', 'upload_file', 'visual_indicator', 'evaluate', 'logs'];
 export class OperationTimeout extends Error {}
 const send = (ws, data) => { if (ws.readyState === WebSocket.OPEN) ws.send(JSON.stringify(data)); };
 
@@ -47,10 +47,10 @@ export async function startHub(config, { port = config.port, operationTimeout =
       browsers: [...browsers.values()].map(browser => ({ browser_id: browser.id, ...browser.info, capabilities: CAPABILITIES })),
       hint: 'Load the paired extension in each Chrome/Edge profile if empty.',
     };
-    if (method === 'list_tabs' || method === 'claim_tab' || method === 'open_tab') {
+    if (method === 'list_tabs' || method === 'claim_tab' || method === 'open_tab' || method === 'fetch') {
       const browser = browsers.get(args.browser_id);
       if (!browser) throw new Error('Browser is not connected; call browser_discover kind=browsers again');
-      if (method === 'open_tab') return await requestBrowser(browser, owner, method, args);
+      if (method === 'open_tab' || method === 'fetch') return await requestBrowser(browser, owner, method, args);
       if (method === 'list_tabs') {
         const result = await requestBrowser(browser, owner, method, {});
         for (const [key, tab] of observed) if (tab.browser_id === browser.id) observed.delete(key);