@remcp/runtime 0.2.175 → 0.2.177

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## 0.2.176 — 2026-10-23
+
+- Reduce screenshot CDP round-trips by batching viewport resolution with capture and reusing measured element dimensions.
+- Cache Accessibility enablement per WebSocket connection with single-flight behavior.
+- Filter malformed, mismatched or unsafe page WebSocket targets during discovery rather than exposing unusable tabs.
+- Keep browser URL/DNS validation, permissions and the existing 83 operation definitions unchanged.
+
 ## 0.2.175 — 2026-10-22
 
 - Carry forward the public 0.2.174 browser-policy and diagnostics-recording module extraction without weakening CDP or recording controls.

package/README.md

@@ -31,8 +31,8 @@ node ./src/compact.mjs --print-tools  # compact local façade for scanners/local
 
 ## Tools
 
-83 tools are implemented in this repository: the original 44 filesystem/search/terminal/process tools
-plus 39 computer-use, browser, diagnostics, and document tools. The release contract contains all 83;
+84 tools are implemented in this repository: the original 44 filesystem/search/terminal/process tools
+plus 40 computer-use, browser, diagnostics, and document tools. The release contract contains all 84;
 the live local MCP `tools/list` omits optional platform-specific tools that the current computer cannot
 support and emits `notifications/tools/list_changed` when that capability set changes. The stdio server is dual-era: existing 2025-era clients continue to work unchanged, while clients that negotiate MCP `2026-07-28` use `server/discover`, cache hints, unrestricted structured output validation, and `subscriptions/listen` for list-change delivery.
 
@@ -52,10 +52,10 @@ support and emits `notifications/tools/list_changed` when that capability set ch
 | Diagnostics | `service`, `event_log`, `network`, `installed_apps`, `environment`, `audio`, `power_action`, `record_screen` — `audio` returns stable structured `volume`, `muted`, `action`, and `backend` fields across supported OS backends |
 | Documents | `read_document`, `edit_spreadsheet`, `edit_document`, `pdf_action` |
 
-The hosted ReMCP endpoint does not append those 83 granular operation names to its discovery list.
+The hosted ReMCP endpoint does not append those 84 granular operation names to its discovery list.
 Current production runs with `REMCP_CUSTOM_WIDGETS_ENABLED=false` and exposes **10 hosted tool definitions**,
 all model-visible: 8 device-facing façade tools plus 2 account/fleet tools. Those compact definitions route
-to the same **83 granular runtime operations** after the selected computer's live capabilities are checked.
+to the same **84 granular runtime operations** after the selected computer's live capabilities are checked.
 If custom widgets are explicitly re-enabled, hosted discovery expands to **15 definitions** by adding
 **5 app-only** UI helpers. Cached legacy clients can still call supported granular aliases without inflating
 discovery for new clients.
@@ -77,7 +77,7 @@ system tools such as qpdf/poppler when present. PDF text reading uses the built-
 `sharp`, or `exceljs`.
 
 `--print-tools` prints the exact JSON contract (schemas and annotations) the runtime advertises, and
-`src/catalog.mjs` plus `src/extended/catalog.mjs` are the source of truth for the 83-tool release surface.
+`src/catalog.mjs` plus `src/extended/catalog.mjs` are the source of truth for the 84-tool release surface.
 A running device can advertise a smaller capability-aware subset; the runtime declares
 `tools.listChanged`, emits `notifications/tools/list_changed` when dynamic capabilities change, and the
 agent forwards the refreshed tool names to the hosted relay. Browser/CDP tools are the primary dynamic
@@ -90,7 +90,7 @@ errors. Linux `display_inventory` follows the real monitor backend chain (GNOME
 backend (Wayland grim/GNOME/portal path or X11 ImageMagick), not merely because `ffmpeg` is installed.
 
 The generated hosted reference covers the current **10 hosted production definitions**, all model-visible
-and routing to the 83 granular runtime operations described above; the optional widget-enabled surface is 15.
+and routing to the 84 granular runtime operations described above; the optional widget-enabled surface is 15.
 The separate compact local stdio entrypoint advertises `read_file` plus up to seven domain tools
 (up to 8 tools total) and keeps those groups capability-aware at runtime with `tools/list_changed`; the paired agent keeps using the capability-aware granular runtime.
 See https://remcp.site/docs#tools and public `docs/TOOLS.md`.
@@ -256,7 +256,7 @@ MCP server.
 
 | | Desktop Commander 0.2.50 | ReMCP runtime |
 | --- | --- | --- |
-| Tools | 26, including config mutators and document tooling | 83, including filesystem/terminal plus native desktop UI, browser CDP, diagnostics, and lightweight document operations |
+| Tools | 26, including config mutators and document tooling | 84, including filesystem/terminal plus native desktop UI, browser CDP, diagnostics, and lightweight document operations |
 | Runtime dependencies | 34 (Supabase, Puppeteer/md-to-pdf, `sharp`, `exceljs`, Tiptap, ripgrep download) | 2 production-direct (`@modelcontextprotocol/server` v2, `@jellybrick/dbus-next`); legacy/modern clients are dev-only compatibility tests |
 | Install scripts | `postinstall` posts an install payload that ignores the telemetry setting | none |
 | Telemetry | opt-out, 51 event names, remote feature flags, A/B assignment, third-party processor | opt-out, whitelisted event schema, no endpoint, no flags |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remcp/runtime",
-  "version": "0.2.175",
+  "version": "0.2.177",
   "description": "First-party ReMCP local device runtime: filesystem, terminal, computer-use, browser, diagnostics and document tools over MCP.",
   "type": "module",
   "license": "MIT",

package/src/compact-catalog.mjs

@@ -18,7 +18,7 @@ export const compactRuntimeGroups = Object.freeze({
   ]),
   view_image: Object.freeze(['read_image','take_screenshot','screenshot_region']),
   control_browser: Object.freeze([
-    'browser_tabs','browser_navigate','browser_snapshot','browser_find','browser_action','browser_wait','browser_evaluate',
+    'browser_tabs','browser_navigate','browser_snapshot','browser_find','browser_action','browser_wait','browser_devtools','browser_evaluate',
   ]),
   manage_system: Object.freeze([
     'get_system_info','list_processes','kill_process','get_runtime_info','get_runtime_stats','set_config_value',

package/src/extended/browser-actions.mjs

@@ -14,6 +14,7 @@ import { callPageFunction, evaluate, withTarget, productionSessionKey } from './
 import { rememberBrowserViewport } from './browser-viewport.mjs';
 import { browserNavigate, browserSnapshot, browserTabs, findExpression } from './browser-read.mjs';
 import { executeBrowserWorkflow, validateBrowserWorkflow } from './browser-workflow.mjs';
+import { browserDevtools } from './browser-devtools.mjs';
 
 export async function browserFind(args) {
   if (!(args.selector || args.text || args.role)) throw new Error('browser_find requires selector, text, or role; use browser_snapshot to enumerate page structure');
@@ -387,4 +388,5 @@ export const browserHandlers = {
   browser_action: browserAction,
   browser_wait: browserWait,
   browser_evaluate: browserEvaluate,
+  browser_devtools: browserDevtools,
 };

package/src/extended/browser-devtools.mjs

@@ -0,0 +1,109 @@
+// Native Chrome DevTools Protocol diagnostics. No screenshots, request bodies,
+// authentication headers, cookies, or response bodies are collected.
+import { jsonResult, clamp, requireEnum } from './common.mjs';
+import { withTarget } from './browser-session.mjs';
+import { inspectNativeBrowserAudit } from './browser-native-audit.mjs';
+
+const METRIC_NAMES = new Set([
+  'Timestamp','Documents','Frames','JSEventListeners','Nodes','LayoutCount',
+  'RecalcStyleCount','LayoutDuration','RecalcStyleDuration','ScriptDuration',
+  'TaskDuration','JSHeapUsedSize','JSHeapTotalSize','DomContentLoaded','NavigationStart',
+]);
+const HIDDEN = '[redacted]';
+export function safeDevtoolsUrl(value) {
+  try {
+    const url = new URL(String(value || ''));
+    if (!['http:', 'https:'].includes(url.protocol)) return '[non-http resource]';
+    // No fragments, credentials or query parameters reach the relay.
+    return (url.origin + url.pathname).slice(0, 300);
+  } catch { return '[unavailable]'; }
+}
+export function safeDevtoolsMessage(value) {
+  let text = String(value ?? '').slice(0, 700);
+  text = text.replace(/\b(Bearer|Basic)\s+[a-z\d+/_=.-]+/gi, '$1 ' + HIDDEN)
+    .replace(/\b(?:eyJ[a-zA-Z0-9_-]{12,}\.){2}[a-zA-Z0-9_-]+\b/g, HIDDEN)
+    .replace(/([?&](?:token|key|secret|password|session|code|authorization)=)[^\s&#]+/gi, '$1' + HIDDEN)
+    .replace(/\b(?:password|access_token|refresh_token|api_key|client_secret)\s*[:=]\s*[^\s,;&]+/gi, HIDDEN);
+  return text.slice(0, 500);
+}
+export function normalizeDevtoolsMetrics(entries) {
+  return Object.fromEntries((Array.isArray(entries) ? entries : [])
+    .filter(item => METRIC_NAMES.has(item?.name) && Number.isFinite(item?.value))
+    .map(item => [item.name, item.value]));
+}
+export async function sampleBrowserDevtools(session, action, durationMs, maxEvents) {
+  const events = [];
+  const counts = {};
+  const requests = new Map();
+  function add(event) {
+    const key = event.level || event.kind || 'other';
+    counts[key] = (counts[key] || 0) + 1;
+    if (events.length < maxEvents) events.push(event);
+  }
+  if (action === 'layout' || action === 'accessibility') return inspectNativeBrowserAudit(session, action);
+  if (action === 'performance') {
+    await session.send('Performance.enable');
+    try {
+      const data = await session.send('Performance.getMetrics');
+      return { action, metrics:normalizeDevtoolsMetrics(data.metrics) };
+    } finally { await session.send('Performance.disable').catch(() => {}); }
+  }
+  const unsubscribe = [];
+  if (action === 'console') {
+    unsubscribe.push(session.observe('Runtime.consoleAPICalled', params => {
+      const level = String(params.type || 'log').slice(0, 24);
+      const previews = (params.args || []).slice(0, 3).map(arg =>
+        arg?.type === 'string' ? arg.value : arg?.description || (arg?.value == null ? arg?.type : String(arg.value)));
+      add({ kind:'console', level, message:safeDevtoolsMessage(previews.join(' ')) });
+    }));
+    unsubscribe.push(session.observe('Runtime.exceptionThrown', params => {
+      add({ kind:'exception', level:'error', message:safeDevtoolsMessage(params.exceptionDetails?.text || 'Uncaught exception') });
+    }));
+    unsubscribe.push(session.observe('Log.entryAdded', params => {
+      add({ kind:'log', level:String(params.entry?.level || 'info').slice(0, 24),
+        message:safeDevtoolsMessage(params.entry?.text || '') });
+    }));
+  } else {
+    unsubscribe.push(session.observe('Network.requestWillBeSent', params => {
+      const id = String(params.requestId || '');
+      if (requests.size > 1000) requests.clear();
+      const record = { kind:'request', method:String(params.request?.method || 'GET').slice(0, 12),
+        resource_type:String(params.type || 'Other').slice(0, 35), url:safeDevtoolsUrl(params.request?.url) };
+      requests.set(id,record);
+      add(record);
+    }));
+    unsubscribe.push(session.observe('Network.responseReceived', params => {
+      const original = requests.get(String(params.requestId || ''));
+      if (!original) return;
+      const status = Number(params.response?.status);
+      original.status = Number.isFinite(status) ? status : null;
+      original.resource_type = String(params.type || original.resource_type).slice(0,35);
+    }));
+    unsubscribe.push(session.observe('Network.loadingFailed', params => {
+      const original = requests.get(String(params.requestId || ''));
+      if (original) original.failed = true;
+    }));
+  }
+  try {
+    if (action === 'console') {
+      await session.send('Runtime.enable');
+      await session.send('Log.enable');
+    } else await session.send('Network.enable', { maxTotalBufferSize: 1_000_000 });
+    await new Promise(resolve => setTimeout(resolve, durationMs));
+  } finally {
+    for (const stop of unsubscribe) stop();
+    if (action === 'console') {
+      await Promise.allSettled([session.send('Log.disable'), session.send('Runtime.disable')]);
+    } else await session.send('Network.disable').catch(() => {});
+  }
+  return { action, sampled_ms:durationMs, counts, events, truncated:Object.values(counts).reduce((a,b) => a+b,0) > maxEvents,
+    note:'Live events only; DevTools does not backfill events recorded before sampling. Request/response contents and headers are excluded.' };
+}
+export async function browserDevtools(args = {}) {
+  const action = requireEnum(args.action, 'action', ['console','network','performance','layout','accessibility']);
+  const durationMs = clamp(args.sample_ms, 1500, 250, 5000);
+  const maxEvents = clamp(args.max_events, 50, 1, 100);
+  return withTarget(args, async (session,target) =>
+    jsonResult({ target_id:target.id, url:safeDevtoolsUrl(target.url),
+      ...(await sampleBrowserDevtools(session,action,durationMs,maxEvents)) }));
+}

package/src/extended/browser-endpoint.mjs

@@ -173,12 +173,18 @@ export async function browserCapabilityAvailable(endpoint, timeoutMs = 500) {
 // Validating every tab sequentially can require hundreds of serial DNS lookups,
 // making browser_tabs exceed the relay's deadline on machines with many tabs.
 // Keep DNS and security validation, but bound both the work and its concurrency.
-export async function filterBrowserTargets(list, { validate = assertResolvedPageUrl, targetId = null } = {}) {
+export async function filterBrowserTargets(list, { validate = assertResolvedPageUrl, targetId = null, endpoint = null } = {}) {
   if (!Array.isArray(list)) return [];
   const candidates = [];
   for (const item of list) {
     if (!item || item.type !== 'page' || !item.webSocketDebuggerUrl) continue;
     if (targetId && item.id !== targetId) continue;
+    // Reject fabricated/stale CDP socket metadata *before* DNS validation.
+    // browser_tabs must never advertise a target that cannot pass chooseTarget.
+    if (endpoint) {
+      try { validatedTargetWebSocketUrl(item, endpoint); }
+      catch { continue; }
+    }
     candidates.push(item);
     if (candidates.length >= 1000) break;
   }
@@ -242,13 +248,18 @@ export async function listBrowserTargets(endpoint, { targetId = null, readOnlySi
     throw new Error(`${label} is unavailable at ${base.origin}. Read-only browser_tabs and browser_snapshot do not launch a browser. Use ui_snapshot and ui_find for the existing browser window; do not retry this CDP endpoint unchanged. Only browser_navigate(action=new_tab), when explicitly requested, may start a local isolated browser.${browserLaunchExitHint({ configured })}`);
   }
   // Retain the current bounded concurrent DNS/security checks for up to 1000 tabs.
-  return filterBrowserTargets(list, { targetId, validate });
+  return filterBrowserTargets(list, { targetId, validate, endpoint:base });
 }
 
 export function validatedTargetWebSocketUrl(target, endpoint) {
   let socketUrl;
   try { socketUrl = new URL(String(target?.webSocketDebuggerUrl)); }
   catch { throw new Error('Browser returned an invalid CDP WebSocket URL'); }
+  const targetId = String(target?.id ?? '');
+  if (!targetId || targetId.length > 256 || socketUrl.username || socketUrl.password ||
+    socketUrl.search || socketUrl.hash) {
+    throw new Error('Browser returned an invalid CDP WebSocket target');
+  }
   if (!['ws:', 'wss:'].includes(socketUrl.protocol) || !isLoopbackHost(socketUrl.hostname)) {
     throw new Error('Browser CDP WebSocket target must be loopback-only');
   }

package/src/extended/browser-native-audit.mjs

@@ -0,0 +1,81 @@
+// Read-only, native CDP audits. Only numeric aggregates leave the device.
+// Unlike DOM snapshots, these methods do not transmit page text to ReMCP.
+const CONTROL_ROLES = new Set([
+  'button','link','checkbox','radio','switch','textbox','searchbox','combobox',
+  'menuitem','menuitemcheckbox','menuitemradio','tab','slider','spinbutton',
+]);
+const REPORT_ROLES = new Set([
+  ...CONTROL_ROLES, 'heading','image','img','form','table','dialog','alert',
+  'navigation','main','region','list','listitem','row','cell',
+]);
+const finite = value => typeof value === 'number' && Number.isFinite(value);
+const positive = value => finite(value) ? Math.max(0,Math.min(10_000_000, Math.round(value * 100) / 100)) : 0;
+
+export function normalizeLayoutMetrics(result = {}) {
+  const viewport = result.cssLayoutViewport || {};
+  const visual = result.cssVisualViewport || {};
+  const content = result.cssContentSize || {};
+  const clientWidth = positive(viewport.clientWidth);
+  const clientHeight = positive(viewport.clientHeight);
+  const contentWidth = positive(content.width);
+  const contentHeight = positive(content.height);
+  return {
+    viewport: { width:clientWidth, height:clientHeight, page_x:positive(viewport.pageX), page_y:positive(viewport.pageY) },
+    visual_viewport: {
+      width:positive(visual.clientWidth), height:positive(visual.clientHeight),
+      scale:finite(visual.scale) ? Math.max(0,Math.min(100,visual.scale)) : null,
+    },
+    document: { width:contentWidth, height:contentHeight },
+    horizontal_overflow_px:Math.max(0,Math.ceil(contentWidth-clientWidth)),
+    vertical_scroll_px:Math.max(0,Math.ceil(contentHeight-clientHeight)),
+    note:'Native CSS-pixel layout metrics from the current page. Overflow measures the document bounds, not whether a particular element is visually clipped.',
+  };
+}
+export function summarizeAccessibilityTree(nodes, { depth = 6 } = {}) {
+  const bounded = (Array.isArray(nodes) ? nodes : []).slice(0, 5000);
+  const roles = {};
+  let ignored = 0, interactive = 0, unlabeledControls = 0, unnamedImages = 0;
+  let headings = 0;
+  const headingLevels = {};
+  for (const node of bounded) {
+    if (!node || typeof node !== 'object') continue;
+    if (node.ignored === true) { ignored++; continue; }
+    const role = String(node.role?.value || '').toLowerCase();
+    if (!REPORT_ROLES.has(role)) continue;
+    roles[role] = (roles[role] || 0) + 1;
+    const name = String(node.name?.value || '').trim();
+    if (CONTROL_ROLES.has(role)) {
+      interactive++;
+      // Anonymous count only: actual labels, element identifiers and URLs are never returned.
+      if (!name) unlabeledControls++;
+    }
+    if (role === 'image' || role === 'img') {
+      if (!name) unnamedImages++;
+    }
+    if (role === 'heading') {
+      headings++;
+      const level = node.properties?.find(item => item?.name === 'level')?.value?.value;
+      if (Number.isSafeInteger(level) && level >= 1 && level <= 6)
+        headingLevels[level] = (headingLevels[level] || 0) + 1;
+    }
+  }
+  return {
+    sampled_nodes:bounded.length, ignored_nodes:ignored, requested_depth:depth,
+    roles, interactive_controls:interactive, unlabeled_controls:unlabeledControls,
+    headings, heading_levels:headingLevels, unnamed_images:unnamedImages,
+    truncated: Array.isArray(nodes) && nodes.length > bounded.length,
+    note:'Bounded native accessibility tree sample. These are diagnostic candidates, not a WCAG compliance verdict. Nodes deeper than the requested depth are not inspected.',
+  };
+}
+export async function inspectNativeBrowserAudit(session, action) {
+  if (action === 'layout') {
+    const result = await session.send('Page.getLayoutMetrics');
+    return { action, layout:normalizeLayoutMetrics(result) };
+  }
+  if (action === 'accessibility') {
+    const depth = 6;
+    const result = await session.send('Accessibility.getFullAXTree',{depth});
+    return { action, accessibility:summarizeAccessibilityTree(result.nodes,{depth}) };
+  }
+  throw new Error('Unsupported native browser audit mode');
+}

package/src/extended/browser-read.mjs

@@ -139,9 +139,42 @@ export function sensitiveAccessibilityDescendants(nodes) {
   return secret;
 }
 
+// One viewport evaluation is enough for both dimensions, and may run while
+// Chrome captures the screenshot. Selector capture already returned the viewport
+// dimensions with the element bounds, so it needs no further CDP evaluation.
+export async function captureViewportScreenshot(session, screenshotTarget = null) {
+  const dimensions = screenshotTarget
+    ? Promise.resolve({width:screenshotTarget.viewport_width, height:screenshotTarget.viewport_height})
+    : evaluate(session, '({width:innerWidth,height:innerHeight})').catch(() => null);
+  const image = session.send('Page.captureScreenshot', {
+    format:'png',fromSurface:true,captureBeyondViewport:false,
+  });
+  const [size,captured] = await Promise.all([dimensions,image]);
+  return {
+    captured,
+    viewport:{scope:'viewport',width:size?.width ?? null,height:size?.height ?? null},
+  };
+}
+
+// Enabling Accessibility is a per-CDP-socket state. Reuse the successful
+// handshake for retained guarded sockets; a new socket always enables afresh.
+const accessibilityReady = new WeakMap();
+export async function ensureAccessibilityReady(session) {
+  let pending = accessibilityReady.get(session);
+  if (!pending) {
+    pending = Promise.resolve().then(() => session.send('Accessibility.enable'));
+    accessibilityReady.set(session,pending);
+    try { await pending; }
+    catch (error) {
+      if (accessibilityReady.get(session)===pending) accessibilityReady.delete(session);
+      throw error;
+    }
+  } else await pending;
+}
+
 export async function browserSnapshot(args) {
   return withTarget(args, async (session, target) => {
-    await session.send('Accessibility.enable');
+    await ensureAccessibilityReady(session);
     const { nodes = [] } = await session.send('Accessibility.getFullAXTree');
     const limit = clamp(args.max_nodes, 1500, 1, 10_000);
     const redacted = sensitiveAccessibilityDescendants(nodes);
@@ -206,27 +239,19 @@ export async function browserSnapshot(args) {
       const { original_scroll_x: _originalX, original_scroll_y: _originalY, ...reportedBounds } = bounds;
       payload.screenshot_target = { selector, ...reportedBounds };
     }
-    payload.screenshot = {
-      scope: 'viewport',
-      width: await evaluate(session, 'innerWidth').catch(() => null),
-      height: await evaluate(session, 'innerHeight').catch(() => null),
-    };
-    const result = jsonResult(payload);
-    let captured;
+    let screenshot;
     try {
-      captured = await session.send('Page.captureScreenshot', {
-        format: 'png',
-        fromSurface: true,
-        captureBeyondViewport: false,
-      });
+      screenshot = await captureViewportScreenshot(session, payload.screenshot_target);
     } finally {
       if (restoreScroll) {
         await evaluate(session, `window.scrollTo({left:${restoreScroll.x},top:${restoreScroll.y},behavior:'instant'})`).catch(() => {});
       }
     }
-    const data = String(captured?.data || '');
+    const data = String(screenshot.captured?.data || '');
     if (!data) throw new Error('CDP returned no screenshot data');
     if (Buffer.byteLength(data, 'base64') > 8 * 1024 * 1024) throw new Error('Browser screenshot exceeds the 8 MiB inline image limit');
+    payload.screenshot = screenshot.viewport;
+    const result = jsonResult(payload);
     result.content.push({ type:'image', data, mimeType:'image/png' });
     return result;
   });

package/src/extended/catalog.mjs

@@ -167,6 +167,7 @@ export const extendedToolDefinitions = [
   define('browser_find', 'Find browser element', 'Find visible DOM elements by CSS selector, text, or ARIA role and return reusable selectors plus text, value, and bounding boxes.', o({ ...browserTarget, selector:s('CSS selector.'), text:s('Visible text substring.'), role:s('ARIA role.'), limit:n() }), readOnlyOpen, browserHandlers.browser_find, ['browser_cdp']),
   define('browser_action', 'Browser element action', 'Click, focus, type/set a value, fill up to 20 form fields in one guarded call, select, scroll a page or scrollable element, scroll an element into view, upload files, press a key, or set an exact responsive-test viewport in a debuggable browser page using DOM/CDP semantics.', o({ ...browserTarget, action:e(['click','focus','type','set_value','select','scroll','scroll_into_view','upload','press','set_viewport','fill_form','workflow']), selector:s('CSS selector for the target element; prefer the reusable selector returned by browser_find.'), steps:{type:'array',minItems:1,maxItems:12,description:'Workflow on one page: explicit CSS actions and bounded waits, max 12 seconds. Never silently submits; click must be explicit.',items:{type:'object',additionalProperties:false,properties:{action:e(['fill_form','set_value','select','focus','click','wait_for']),selector:s('CSS selector for action or wait_for.'),value:{type:['string','number','boolean']},fields:{type:'array',description:'CSS-selected field edits within the workflow step; no implicit form submission.',minItems:1,maxItems:20,items:{type:'object',additionalProperties:false,properties:{selector:s(),value:{type:['string','number','boolean']}},required:['selector','value']}},condition:e(['selector','text','url_contains','load']),text:s('Text or URL fragment for wait condition.'),timeout_ms:n('Wait timeout 100..4000 ms; default 1500.')},required:['action']}}, fields:{type:'array',minItems:1,maxItems:20,items:{type:'object',additionalProperties:false,properties:{selector:s('CSS selector.'),value:{type:['string','boolean','number'],description:'New field value; not returned in results.'}},required:['selector','value']},description:'fill_form: 1–20 CSS form fields in one CDP call. Does not submit.'}, browser_text:s('Visible text used only to locate a DOM element; use this instead of overloading text for action=type.'), text:s('For action=type, Unicode text to insert. For non-type element actions without selector/browser_text, visible text may identify the target.'), clear:b('For action=type, clear the current value before inserting text.'), value:s('Value for action=set_value; also accepted as a legacy type payload when text is used as the locator.'), text_value:s('Compatibility alias for the type/set_value text value.'), option:s(), delta_x:n('Horizontal scroll delta; positive means right.'), delta_y:n('Vertical scroll delta; positive means down.'), delta:n('Alias for delta_y.'), direction:e(['up','down','left','right']), wheel_times:n('Number of 120-unit wheel steps for direction; 1..50.'), path:s(), paths:{type:'array',items:{type:'string'}}, key:s(), width:n('CSS viewport width for set_viewport.'), height:n('CSS viewport height for set_viewport.'), device_scale_factor:n('Device scale factor for set_viewport; default 1.'), mobile:b('Enable mobile emulation for set_viewport.') }, ['action']), openMutating, browserHandlers.browser_action, ['browser_cdp']),
   define('browser_wait', 'Wait for browser', 'Wait for DOM state, page text, URL, completed loading, a navigation away from the current URL, or a short network-idle period in a debuggable browser page. Use browser_evaluate separately for JavaScript predicates or page-specific inspection.', o({ ...browserTarget, condition:e(['selector','text','url_contains','load','navigation','network_idle']), selector:s(), text:s(), value:s(), poll_ms:n(), idle_ms:n('Required zero-in-flight network quiet window for network_idle; default 500 ms.') }), readOnlyOpen, browserHandlers.browser_wait, ['browser_cdp']),
+  define('browser_devtools', 'Browser DevTools diagnostics', 'Use this to read a bounded live sample of Chrome Console or Network events, or native Performance metrics through CDP; excludes cookies, request bodies, response bodies and authentication headers.', o({ ...browserTarget, action:e(['console','network','performance','layout','accessibility'],'Diagnostics mode. Layout reports CSS-pixel viewport/overflow; accessibility reports anonymized role counts and unlabeled controls.'), sample_ms:n('Live event capture period 250–5000 ms; default 1500. Ignored for performance, layout and accessibility.'), max_events:n('Maximum 1–100 events retained; default 50.') }, ['action']), readOnlyOpen, browserHandlers.browser_devtools, ['browser_cdp']),
   define('browser_evaluate', 'Evaluate browser JavaScript', 'Evaluate JavaScript in a selected debuggable browser page and return its serializable value. This is a powerful escape hatch for page-specific automation.', o({ ...browserTarget, expression:s('JavaScript expression.'), await_promise:b('Await a returned Promise; default true.') }, ['expression']), openMutating, browserHandlers.browser_evaluate, ['browser_evaluate']),
 
   define('service', 'Service control', 'List, inspect, start, stop, or restart operating-system services using Service Control Manager, launchctl, or systemd. Mutating actions pass through ReMCP command policy.', o({ action:e(['list','status','start','stop','restart']), name:s('Service/unit/launchd label.'), scope:e(['user','system']) }, ['action']), mutating, diagnosticHandlers.service, ['services']),