@remcp/runtime 0.2.178 → 0.2.180

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## 0.2.180 — 2026-10-25
+
+- Categorize lost CDP sessions, stale targets, navigation failures and browser guard failures without transmitting page content, URLs, target IDs or raw exception messages as telemetry categories.
+- Treat nonempty `Page.navigate.errorText` as a failed tool call for both selected tabs and guarded new tabs.
+- Preserve existing browser policies and existing runtime operation contracts; regression tests cover redaction and failure semantics.
+
+
 ## 0.2.176 — 2026-10-23
 
 - Reduce screenshot CDP round-trips by batching viewport resolution with capture and reusing measured element dimensions.

package/package.json

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

package/src/error-classes.mjs

@@ -14,11 +14,28 @@ export function classifyRuntimeToolError(error, toolName = '') {
   if (MISSING_CODES.has(code)) return 'not_found';
   if (TIMEOUT_CODES.has(code)) return 'timeout';
   if (browserTool && CONNECTION_CODES.has(code)) return 'browser_unavailable';
+  if (browserTool && code === 'BROWSER_TARGET_DISAPPEARED') return 'browser_target_stale';
   if (/\bcancelled\b|\bcanceled\b|\baborted by the client\b/.test(message)) return 'cancelled';
   if (/blocked (?:by|local|private)|outside the directories this device allows|private browser destination|blocked local browser scheme/.test(message)) return 'blocked';
   if (browserTool && /browser cdp endpoint is unavailable|browser control is unavailable|cdp websocket (?:error|connection timed out)|local cdp endpoint did not become ready/.test(message)) {
     return 'browser_unavailable';
   }
+  if (browserTool) {
+    // Match only fixed CDP failure signatures; never emit the error text, tab ID,
+    // destination URL or selector as a telemetry category.
+    if (/browser child guard failed|browser request guard failed|browser safety guard failed/.test(message)) {
+      return 'browser_guard_failed';
+    }
+    if (/browser cdp target disappeared|target (?:was )?closed|no target with given id|target with given id not found|inspected target navigated or closed/.test(message)) {
+      return 'browser_target_stale';
+    }
+    if (/cdp websocket (?:closed|is not open)|session with given id not found|cdp session (?:closed|disconnected)/.test(message)) {
+      return 'browser_session_lost';
+    }
+    if (/browser navigation failed|cannot navigate (?:back|forward)|net::err_[a-z_]+/.test(message)) {
+      return 'browser_navigation_failed';
+    }
+  }
   if (/permission denied|access is denied|not authorized|not authorised|accessibility permission/.test(message)) return 'permission';
   if (/timed out|timeout after|time limit exceeded/.test(message)) return 'timeout';
   if (/element not found|no element matches|no matching ui window|target not found|not found in the current/.test(message)) return 'not_found';

package/src/extended/browser-devtools.mjs

@@ -4,6 +4,7 @@ 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';
+import { inspectElementListeners } from './browser-listeners.mjs';
 
 const METRIC_NAMES = new Set([
   'Timestamp','Documents','Frames','JSEventListeners','Nodes','LayoutCount',
@@ -32,7 +33,7 @@ export function normalizeDevtoolsMetrics(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) {
+export async function sampleBrowserDevtools(session, action, durationMs, maxEvents, selector) {
   const events = [];
   const counts = {};
   const requests = new Map();
@@ -43,6 +44,7 @@ export async function sampleBrowserDevtools(session, action, durationMs, maxEven
   }
   if (action === 'layout' || action === 'accessibility') return inspectNativeBrowserAudit(session, action);
   if (action === 'geometry') return inspectDomGeometry(session);
+  if (action === 'listeners') return inspectElementListeners(session,selector);
   if (action === 'performance') {
     await session.send('Performance.enable');
     try {
@@ -103,14 +105,16 @@ export async function sampleBrowserDevtools(session, action, durationMs, maxEven
 }
 export function buildDevtoolsReport(target, action, result) {
   return { target_id:target.id,
-    ...(action === 'geometry' ? {} : {url:safeDevtoolsUrl(target.url)}),
+    ...(['geometry','listeners'].includes(action) ? {} : {url:safeDevtoolsUrl(target.url)}),
     ...result };
 }
 export async function browserDevtools(args = {}) {
-  const action = requireEnum(args.action, 'action', ['console','network','performance','layout','accessibility','geometry']);
+  const action = requireEnum(args.action, 'action', ['console','network','performance','layout','accessibility','geometry','listeners']);
   const durationMs = clamp(args.sample_ms, 1500, 250, 5000);
   const maxEvents = clamp(args.max_events, 50, 1, 100);
+  if (action === 'listeners' && (typeof args.target_id !== 'string' || !args.target_id.trim()))
+    throw new TypeError('Listener diagnostics require an explicitly selected target_id');
   return withTarget(args, async (session,target) =>
     jsonResult(buildDevtoolsReport(target, action,
-      await sampleBrowserDevtools(session,action,durationMs,maxEvents))));
+      await sampleBrowserDevtools(session,action,durationMs,maxEvents,args.selector))));
 }

package/src/extended/browser-listeners.mjs

@@ -0,0 +1,65 @@
+// Native CDP event-listener audit for one explicitly selected DOM element.
+// CDP returns handler references, source positions and custom listener names:
+// NONE of that may leave the paired device. Never evaluate page JavaScript.
+const TYPES = new Set([
+  'click','dblclick','auxclick','contextmenu','input','change','beforeinput',
+  'submit','reset','keydown','keyup','keypress','focus','blur','focusin','focusout',
+  'mousedown','mouseup','mousemove','mouseenter','mouseleave',
+  'pointerdown','pointerup','pointermove','pointerenter','pointerleave',
+  'touchstart','touchend','touchmove','wheel','scroll','resize','load','error',
+  'drag','dragstart','dragend','dragover','drop','animationend','transitionend',
+]);
+const MAX_LISTENERS = 200;
+const MAX_TYPES = 24;
+function validSelector(value) {
+  if (typeof value !== 'string') throw new TypeError('A CSS selector is required for the event listener audit');
+  const selector = value.trim();
+  if (!selector || selector.length > 120 || /[\u0000-\u001f\u007f<>]/.test(selector)) {
+    throw new TypeError('A CSS selector between 1 and 120 safe characters is required');
+  }
+  return selector;
+}
+export function summarizeElementListeners(raw) {
+  const listeners = Array.isArray(raw) ? raw : [];
+  const sample = listeners.slice(0,MAX_LISTENERS);
+  const types = Object.create(null);
+  let passive = 0, once = 0, capturing = 0;
+  for (const listener of sample) {
+    if (!listener || typeof listener !== 'object') continue;
+    const eventType = TYPES.has(listener.type) ? listener.type : 'other';
+    types[eventType] = (types[eventType] || 0) + 1;
+    if (listener.passive === true) passive++;
+    if (listener.once === true) once++;
+    if (listener.useCapture === true) capturing++;
+  }
+  const byType = Object.entries(types).sort((a,b)=>b[1]-a[1] || a[0].localeCompare(b[0])).slice(0,MAX_TYPES);
+  return {
+    sampled_listeners:sample.length,
+    listener_count:Math.min(listeners.length,100000),
+    truncated:listeners.length>MAX_LISTENERS,
+    by_type:Object.fromEntries(byType),
+    passive_count:passive, once_count:once, capture_count:capturing,
+    repeated_event_types:byType.filter(([,count])=>count>1).length,
+    note:'Native CDP listener counts on the single selected node. Repeated event types are not proof of duplicate handlers. Delegated ancestor listeners are not included; handler code, locations, custom event names and page contents are never returned.',
+  };
+}
+export async function inspectElementListeners(session,selectorValue) {
+  const selector=validSelector(selectorValue);
+  // getDocument(depth:0) is enough to get the root without enumerating contents.
+  const {root} = await session.send('DOM.getDocument',{depth:0,pierce:false});
+  if (!Number.isSafeInteger(root?.nodeId) || root.nodeId<=0) throw new Error('CDP document root unavailable');
+  let objectId;
+  try {
+    const selected = await session.send('DOM.querySelector',{nodeId:root.nodeId,selector});
+    if (!Number.isSafeInteger(selected?.nodeId) || selected.nodeId<=0)
+      return {action:'listeners',found:false,listeners:summarizeElementListeners([])};
+    const resolved=await session.send('DOM.resolveNode',{nodeId:selected.nodeId});
+    objectId=resolved?.object?.objectId;
+    if (typeof objectId!=='string' || !objectId || objectId.length>512) throw new Error('Selected DOM node cannot be resolved');
+    const result=await session.send('DOMDebugger.getEventListeners',{objectId,depth:0,pierce:false});
+    return {action:'listeners',found:true,listeners:summarizeElementListeners(result.listeners)};
+  } finally {
+    if (objectId) await session.send('Runtime.releaseObject',{objectId}).catch(()=>{});
+    await session.send('DOM.disable').catch(()=>{});
+  }
+}

package/src/extended/browser-navigation-result.mjs

@@ -0,0 +1,8 @@
+// Page.navigate may resolve successfully while Chrome explicitly reports a
+// navigation error. Treat that as a failed tool call, without echoing CDP's
+// errorText (which may contain user data) into diagnostics.
+export function requireSuccessfulBrowserNavigation(result) {
+  if (typeof result?.errorText === 'string' && result.errorText.trim()) {
+    throw new Error('Browser navigation failed: Chrome reported an unsuccessful navigation');
+  }
+}

package/src/extended/browser-read.mjs

@@ -1,4 +1,5 @@
 import { snapshotDelta } from './browser-snapshot-diff.mjs';
+import { requireSuccessfulBrowserNavigation } from './browser-navigation-result.mjs';
 import process from 'node:process';
 import os from 'node:os';
 import path from 'node:path';
@@ -75,6 +76,7 @@ export async function browserNavigate(args = {}) {
     let historyUrl = null;
     if (action === 'url') {
       const result = await session.send('Page.navigate', { url });
+      requireSuccessfulBrowserNavigation(result);
       frameId = result.frameId || null;
       errorText = result.errorText || null;
     } else if (action === 'reload') {

package/src/extended/browser-session.mjs

@@ -1,3 +1,4 @@
+import { requireSuccessfulBrowserNavigation } from './browser-navigation-result.mjs';
 import process from 'node:process';
 import os from 'node:os';
 import path from 'node:path';
@@ -350,6 +351,7 @@ export async function createGuardedNewTab(url, args) {
     await session.send('Page.enable');
     const loaded = session.waitFor('Page.loadEventFired', clamp(args.timeout_ms, 15_000, 500, 120_000)).catch(() => null);
     const navigation = await session.send('Page.navigate', { url });
+    requireSuccessfulBrowserNavigation(navigation);
     if (loaded) await loaded;
     const finalUrl = await evaluate(session, 'location.href');
     await assertResolvedPageUrl(finalUrl);

package/src/extended/catalog.mjs

@@ -167,7 +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_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','listeners'],'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, geometry and listeners.'), selector:s('Required CSS selector for action=listeners; only the first matching element is inspected, with no script source or DOM text returned.'), 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']),