@remcp/runtime 0.2.174 → 0.2.176

package/CHANGELOG.md

@@ -1,10 +1,17 @@
 # Changelog
 
-## 0.2.174 — 2026-10-22
+## 0.2.176 — 2026-10-23
 
-- Preserve the 83 runtime operations and existing schemas while separating guarded browser CDP security policy and diagnostics recording backends.
-- Retain browser-origin, DNS/SSRF checks, platform protections and output limits without widening device permissions.
-- Publish alongside the refactored client/host at the same version for package compatibility.
+- 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.
+- Require the patched MCP client 2.3.1 development dependency and retain 83 runtime operation contracts.
+- No new remote execution permissions or OAuth bypasses are introduced.
 
 ## 0.2.173 — 2026-10-22
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remcp/runtime",
-  "version": "0.2.174",
+  "version": "0.2.176",
   "description": "First-party ReMCP local device runtime: filesystem, terminal, computer-use, browser, diagnostics and document tools over MCP.",
   "type": "module",
   "license": "MIT",
@@ -28,7 +28,7 @@
     "@modelcontextprotocol/server": "^2.3.0"
   },
   "devDependencies": {
-    "@modelcontextprotocol/client": "^2.0.0"
+    "@modelcontextprotocol/client": "^2.3.1"
   },
   "repository": {
     "type": "git",

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-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;
   });