@remcp/runtime 0.2.183 → 0.2.185

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## 0.2.185 — 2026-10-26
+
+**Make read-only browser discovery more focused and patch application fail safely.**
+
+- Coalesce simultaneous read-only CDP readiness checks for the same validated endpoint, request implementation and timeout without sharing URL-policy decisions or mutating browser state.
+- Honor browser tab ID, title and URL filters before expensive validation, while preserving per-target DNS, socket and SSRF checks.
+- Reject incomplete multi-hunk patch writes to one file and out-of-range zero-context insertion positions instead of silently modifying the wrong text.
+- Keep existing runtime tool schemas and authorization boundaries; validate across isolated Chromium, deterministic regressions and the full runtime suite.
+
+## 0.2.184 — 2026-10-26
+
+- Return initial output from long-running terminal sessions with a 45 ms exit-status grace instead of 175 ms, while preserving final exit codes for fast commands, silent-process timeout bounds and tool output schemas.
+- Add regression coverage for first-output latency, structured exit state, incremental output and command cancellation.
+
 ## 0.2.181 — 2026-10-25
 
 - Add bounded read-only `browser_devtools` Form Map and selector-scoped computed Styles/box-model inspection with no user-entered values, raw CSS, URL content or page text in diagnostic reports.

package/package.json

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

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, endpoint = null } = {}) {
+export async function filterBrowserTargets(list, { validate = assertResolvedPageUrl, targetId = null, titleContains = null, urlContains = null, endpoint = null } = {}) {
   if (!Array.isArray(list)) return [];
   const candidates = [];
+  const titleNeedle = String(titleContains || '').toLowerCase();
+  const urlNeedle = String(urlContains || '').toLowerCase();
   for (const item of list) {
     if (!item || item.type !== 'page' || !item.webSocketDebuggerUrl) continue;
     if (targetId && item.id !== targetId) continue;
+    // Filter untrusted CDP metadata before expensive URL/DNS validation, but
+    // still validate every matching URL before it can reach the caller.
+    if (titleNeedle && !String(item.title || '').toLowerCase().includes(titleNeedle)) continue;
+    if (urlNeedle && !String(item.url || '').toLowerCase().includes(urlNeedle)) continue;
     // Reject fabricated/stale CDP socket metadata *before* DNS validation.
     // browser_tabs must never advertise a target that cannot pass chooseTarget.
     if (endpoint) {
@@ -229,7 +235,7 @@ export async function filterBrowserTargets(list, { validate = assertResolvedPage
   return targets;
 }
 
-export async function listBrowserTargets(endpoint, { targetId = null, readOnlySingleFlight = false, validate = assertResolvedPageUrl } = {}) {
+export async function listBrowserTargets(endpoint, { targetId = null, titleContains = null, urlContains = null, readOnlySingleFlight = false, validate = assertResolvedPageUrl } = {}) {
   assertBrowserRemoteEnabled();
   // Reading tabs and page semantics must not launch a separate Chromium/profile.
   // Only an explicit browser_navigate(action=new_tab) can bootstrap an isolated browser.
@@ -248,7 +254,7 @@ 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, endpoint:base });
+  return filterBrowserTargets(list, { targetId, titleContains, urlContains, validate, endpoint:base });
 }
 
 export function validatedTargetWebSocketUrl(target, endpoint) {

package/src/extended/browser-read.mjs

@@ -15,7 +15,12 @@ import { assertResolvedBrowserUrl, assertResolvedPageUrl, boundedText, endpointU
 import { createGuardedNewTab, evaluate, withTarget } from './browser-session.mjs';
 
 export async function browserTabs(args = {}) {
-  const targets = await listBrowserTargets(args.endpoint, { readOnlySingleFlight:true });
+  const targetId = optionalString(args.target_id || args.targetId);
+  const titleContains = optionalString(args.title);
+  const urlContains = optionalString(args.url_contains || args.urlContains);
+  const targets = await listBrowserTargets(args.endpoint, {
+    targetId, titleContains, urlContains, readOnlySingleFlight:true,
+  });
   const pages = targets.filter(item => item.type === 'page').slice(0, 500).map(item => ({
     id: boundedText(item.id, 256),
     title: boundedText(item.title, 1000),
@@ -25,7 +30,10 @@ export async function browserTabs(args = {}) {
   const result = jsonResult(pages);
   // Keep the typed empty-array contract while providing a native fallback hint.
   if (!pages.length) {
-    result.content = [{ type: 'text', text: 'CDP is connected, but no debuggable Chromium tabs are available. Use ui_snapshot and ui_find to inspect existing browser windows without CDP; only open a new tab when explicitly requested.' }];
+    const scoped = Boolean(targetId || titleContains || urlContains);
+    result.content = [{ type: 'text', text: scoped
+      ? 'CDP is connected, but no authorized browser page matches the requested selector. Check the selector or use ui_snapshot and ui_find for native browser accessibility.'
+      : 'CDP is connected, but no debuggable Chromium tabs are available. Use ui_snapshot and ui_find to inspect existing browser windows without CDP; only open a new tab when explicitly requested.' }];
   }
   return result;
 }

package/src/extended/browser-readiness.mjs

@@ -4,6 +4,9 @@
 import { browserRemoteEnabled, endpointUrl, requestJson, validatedTargetWebSocketUrl } from './browser-endpoint.mjs';
 
 const records = new Map();
+// Avoid duplicate /json/version + /json/list reads when several agent calls
+// request CDP readiness at once. Never coalesce different probe transports.
+const pendingProbes = new Map();
 const CACHE_MS = 3000;
 const MAX_ENTRIES = 8;
 const transportError = message =>
@@ -39,30 +42,43 @@ export async function probeBrowserReadiness({
   let key;
   try { key = endpointUrl(endpoint).origin; }
   catch { return { status:'blocked_endpoint', ready:false, candidate_pages:0, next_step:'check_local_cdp_config' }; }
+  const timeout = Math.max(100, Math.min(800, Number(timeoutMs) || 350));
   if (cache) {
     const previous = records.get(key);
-    if (previous && previous.expires > now) return { ...previous.value, cache_hit:true };
+    if (previous && previous.expires > now && previous.request === request &&
+      previous.timeout === timeout) return { ...previous.value, cache_hit:true };
   }
-  const timeout = Math.max(100, Math.min(800, Number(timeoutMs) || 350));
-  let result;
-  try {
-    const version = await request('/json/version', endpoint, { timeout_ms:timeout });
-    // CDP version alone is not evidence a useful debuggable tab exists.
-    if (!version || typeof version !== 'object' || !(version.Browser || version.webSocketDebuggerUrl)) {
-      result = { status:'invalid_response', ready:false, candidate_pages:0 };
-    } else {
-      const targets = await request('/json/list', endpoint, { timeout_ms:timeout });
-      result = classifyBrowserReadiness(version, targets, endpoint);
+  const load = async () => {
+    let result;
+    try {
+      const version = await request('/json/version', endpoint, { timeout_ms:timeout });
+      // CDP version alone is not evidence a useful debuggable tab exists.
+      if (!version || typeof version !== 'object' || !(version.Browser || version.webSocketDebuggerUrl)) {
+        result = { status:'invalid_response', ready:false, candidate_pages:0 };
+      } else {
+        const targets = await request('/json/list', endpoint, { timeout_ms:timeout });
+        result = classifyBrowserReadiness(version, targets, endpoint);
+      }
+    } catch (error) {
+      result = { status:transportError(String(error?.message || '')) ? 'unavailable' : 'invalid_response',
+        ready:false, candidate_pages:0 };
     }
-  } catch (error) {
-    result = { status:transportError(String(error?.message || '')) ? 'unavailable' : 'invalid_response',
-      ready:false, candidate_pages:0 };
-  }
-  const next_step = result.ready ? 'use_browser_tabs' : 'use_native_accessibility';
-  const output = { ...result, next_step };
-  if (cache) {
-    records.set(key, { expires:now + CACHE_MS, value:output });
-    while (records.size > MAX_ENTRIES) records.delete(records.keys().next().value);
+    const output = { ...result, next_step:result.ready ? 'use_browser_tabs' : 'use_native_accessibility' };
+    if (cache) {
+      records.set(key, { expires:now + CACHE_MS, value:output, request, timeout });
+      while (records.size > MAX_ENTRIES) records.delete(records.keys().next().value);
+    }
+    return output;
+  };
+  if (!cache) return load();
+  const pending = pendingProbes.get(key);
+  if (pending && pending.request === request && pending.timeout === timeout) return pending.work;
+  // Bounded memory; mismatched transports must never share probe results.
+  if (pending || pendingProbes.size >= MAX_ENTRIES) return load();
+  const work = Promise.resolve().then(load);
+  pendingProbes.set(key, { request, timeout, work });
+  try { return await work; }
+  finally {
+    if (pendingProbes.get(key)?.work === work) pendingProbes.delete(key);
   }
-  return output;
 }

package/src/patch.mjs

@@ -87,7 +87,12 @@ function locate(lines, hunk) {
   // A hunk with no context and no removals is a pure insertion: `@@ -N,0 +M,K @@` inserts after
   // line N, so the zero-based insertion point is N (and the end of file when N is the last line).
   // Using N-1 here inserted every such hunk one line too early while still reporting success.
-  if (!expected.length) return { index: Math.min(Math.max(hunk.oldStart, 0), lines.length), fuzz: 0 };
+  if (!expected.length) {
+    // A stale or malformed insertion offset must fail instead of silently
+    // appending to EOF (which can corrupt an unrelated section of a file).
+    if (!Number.isSafeInteger(hunk.oldStart) || hunk.oldStart < 0 || hunk.oldStart > lines.length) return null;
+    return { index: hunk.oldStart, fuzz: 0 };
+  }
   const candidates = [];
   const anchor = Math.max(0, hunk.oldStart - 1);
   for (let offset = 0; offset <= 200; offset += 1) {

package/src/tools/files-bulk-operations.mjs

@@ -234,7 +234,12 @@ export async function applyPatchTool(args) {
         else throw error;
       }
       const { updated, applied, failed } = applyHunks(original, file.hunks);
-      if (failed.length && !applied.length) { results.push(`failed ${displayPath(absolute)}: none of the ${file.hunks.length} hunk(s) matched`); continue; }
+      // Never persist a partially applied file, even if one hunk did match.
+      // An MCP success response here would let an agent continue with broken code.
+      if (failed.length) {
+        results.push(`failed ${displayPath(absolute)}: ${failed.length}/${file.hunks.length} hunk(s) did not match; no changes written`);
+        continue;
+      }
       const stats = diffStats(original, updated);
       if (!dryRun) {
         assertWritableSize(updated);

package/src/tools/terminal.mjs

@@ -69,9 +69,12 @@ function terminalStructured(value, fallbackText) {
 // useful output arrives, keeping a short grace window so quick commands can
 // still report their real exit status without requiring a follow-up tool call.
 // Explicit timeout_ms remains an upper bound, including for silent commands.
+// Buffered output needs only a short exit-status grace: 175ms held long-running
+// commands even after their first useful text was already ready. A 45ms window
+// lets immediate exits report their final code without delaying live feedback.
 async function waitForInitialOutput(session, timeoutMs) {
   const deadline = Date.now() + timeoutMs;
-  const graceUntil = Date.now() + Math.min(175, timeoutMs);
+  const graceUntil = Date.now() + Math.min(45, timeoutMs);
   while (!session.exited) {
     const now = Date.now();
     if (now >= deadline || (now >= graceUntil && hasNewOutput(session))) break;