@remcp/runtime 0.2.176 → 0.2.178

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.176",
+  "version": "0.2.178",
   "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,116 @@
+// 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';
+import { inspectDomGeometry } from './browser-geometry.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 === 'geometry') return inspectDomGeometry(session);
+  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 function buildDevtoolsReport(target, action, result) {
+  return { target_id:target.id,
+    ...(action === 'geometry' ? {} : {url:safeDevtoolsUrl(target.url)}),
+    ...result };
+}
+export async function browserDevtools(args = {}) {
+  const action = requireEnum(args.action, 'action', ['console','network','performance','layout','accessibility','geometry']);
+  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(buildDevtoolsReport(target, action,
+      await sampleBrowserDevtools(session,action,durationMs,maxEvents))));
+}

package/src/extended/browser-geometry.mjs

@@ -0,0 +1,95 @@
+// Local-only Chrome DOMSnapshot geometry aggregation.
+// DOMSnapshot can contain page text and attributes: NEVER serialize, log or return it.
+// The result contains counts and bounded geometry of tag types, not DOM content.
+const ALLOWED_TAGS = new Set([
+  'A','ARTICLE','ASIDE','BLOCKQUOTE','BUTTON','CANVAS','CODE','DD','DETAILS','DIV',
+  'DL','DT','FIELDSET','FIGCAPTION','FIGURE','FOOTER','FORM','H1','H2','H3','H4',
+  'H5','H6','HEADER','IFRAME','IMG','INPUT','LABEL','LI','MAIN','NAV','OL','OPTION',
+  'P','PICTURE','PRE','SECTION','SELECT','SPAN','SVG','TABLE','TBODY','TD',
+  'TEXTAREA','TH','THEAD','TR','UL','VIDEO',
+]);
+const MAX_LAYOUT_NODES = 12000;
+const MAX_CANDIDATES = 8;
+const EPSILON = 1;
+function decimal(value) {
+  return typeof value === 'number' && Number.isFinite(value)
+    ? Math.max(-10000000, Math.min(10000000, Math.round(value * 100) / 100))
+    : null;
+}
+function typeForNode(doc, strings, nodeIndex) {
+  const idx = doc?.nodes?.nodeName?.[nodeIndex];
+  if (!Number.isSafeInteger(idx) || !Array.isArray(strings)) return '';
+  const str = strings[idx];
+  if (typeof str !== 'string' || str.length > 20) return '';
+  const upper = str.toUpperCase();
+  return ALLOWED_TAGS.has(upper) ? upper.toLowerCase() : '';
+}
+export function summarizeDomGeometry(snapshot, pageMetrics, { maxNodes = MAX_LAYOUT_NODES } = {}) {
+  const rawDocs = Array.isArray(snapshot?.documents) ? snapshot.documents : [];
+  const doc = rawDocs[0] || {};
+  const indices = Array.isArray(doc?.layout?.nodeIndex) ? doc.layout.nodeIndex : [];
+  const bounds = Array.isArray(doc?.layout?.bounds) ? doc.layout.bounds : [];
+  const width = decimal(pageMetrics?.cssLayoutViewport?.clientWidth);
+  const scrollX = decimal(pageMetrics?.cssLayoutViewport?.pageX) ?? 0;
+  if (width == null || width <= 0) throw new Error('Chrome did not report a valid layout viewport width');
+  const left = scrollX, right = scrollX + width;
+  const count = Math.min(MAX_LAYOUT_NODES, Math.max(0,Math.floor(Number(maxNodes) || MAX_LAYOUT_NODES)),indices.length,bounds.length);
+  let eligible = 0, candidateCount = 0, leftOverflowCount = 0, rightOverflowCount = 0;
+  let biggestOverflow = 0;
+  const byTag = Object.create(null);
+  const top = [];
+  for (let i = 0; i < count; i++) {
+    const tag = typeForNode(doc,snapshot?.strings,indices[i]);
+    if (!tag) continue;
+    const box = bounds[i];
+    if (!Array.isArray(box) || box.length < 4) continue;
+    const [x,y,w,h] = box.map(decimal);
+    if ([x,y,w,h].some(v => v == null) || w <= 0 || h <= 0) continue;
+    eligible++;
+    const extraLeft = Math.max(0,left-x);
+    const extraRight = Math.max(0,x+w-right);
+    if (extraLeft <= EPSILON && extraRight <= EPSILON) continue;
+    candidateCount++;
+    if (extraLeft > EPSILON) leftOverflowCount++;
+    if (extraRight > EPSILON) rightOverflowCount++;
+    const overflow = Math.ceil(Math.max(extraLeft,extraRight));
+    biggestOverflow = Math.max(biggestOverflow,overflow);
+    byTag[tag] = (byTag[tag] || 0) + 1;
+    // Never send selectors, attributes, text, sources, titles or URLs.
+    const candidate = { tag, side:extraLeft > EPSILON && extraRight > EPSILON ? 'both' :
+      extraLeft > EPSILON ? 'left' : 'right', overflow_px:overflow,
+      bounds: { x, y, width:w, height:h } };
+    if (top.length < MAX_CANDIDATES) top.push(candidate);
+    else {
+      let smallest = 0;
+      for (let j=1; j<top.length; j++) if (top[j].overflow_px < top[smallest].overflow_px) smallest = j;
+      if (candidate.overflow_px > top[smallest].overflow_px) top[smallest] = candidate;
+    }
+  }
+  top.sort((a,b)=>b.overflow_px-a.overflow_px);
+  return {
+    viewport_width_px:width,
+    sampled_layout_nodes:count,
+    eligible_elements:eligible,
+    candidate_count:candidateCount,
+    left_overflow_count:leftOverflowCount,
+    right_overflow_count:rightOverflowCount,
+    maximum_overflow_px:biggestOverflow,
+    by_tag:Object.fromEntries(Object.entries(byTag).sort((a,b)=>b[1]-a[1]).slice(0,20)),
+    candidates:top,
+    frames_omitted:Math.max(0,rawDocs.length-1),
+    truncated:count<indices.length || count<bounds.length,
+    note:'Only numeric geometry and allowlisted HTML tag types leave the device. Candidate bounds may be intentional (for example carousels or offscreen animations); this is not proof of a layout bug. Only the main frame is inspected.',
+  };
+}
+export async function inspectDomGeometry(session) {
+  // Fetch just enough geometry for local assessment. The CDP transport enforces
+  // its own 16 MiB message bound; snapshot text never leaves this process.
+  const [metrics,snapshot] = await Promise.all([
+    session.send('Page.getLayoutMetrics'),
+    session.send('DOMSnapshot.captureSnapshot',{
+      computedStyles:[],includePaintOrder:false,includeDOMRects:false,
+    }),
+  ]);
+  return {action:'geometry',geometry:summarizeDomGeometry(snapshot,metrics)};
+}

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/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 inspect Chrome Console/Network live events, Performance, Layout, Accessibility or screenshot-free DOMSnapshot Geometry via native CDP. Network headers, bodies and cookies are excluded; geometry returns bounded numeric summaries without page text.', o({ ...browserTarget, action:e(['console','network','performance','layout','accessibility','geometry'],'Diagnostics mode. Layout measures CSS viewport, accessibility returns anonymized roles and unnamed controls, geometry audits DOMSnapshot bounds without page contents.'), sample_ms:n('Live event capture period 250–5000 ms; default 1500. Ignored for performance, layout, accessibility and geometry.'), 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']),