@remcp/runtime 0.2.166 → 0.2.168

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remcp/runtime",
-  "version": "0.2.166",
+  "version": "0.2.168",
   "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-actions.mjs

@@ -125,6 +125,9 @@ export const PAGE_FILL_FORM = `function(fields) {
     }
     const tag = el.tagName.toLowerCase();
     if (!['input','textarea','select'].includes(tag)) throw new Error('Unsupported form field: ' + field.selector);
+    if (tag === 'input' && ['checkbox','radio'].includes(el.type) && typeof field.value !== 'boolean') {
+      throw new Error('Checkbox and radio fields require a boolean value: ' + field.selector);
+    }
     if (tag === 'select' && !Array.from(el.options).some(option => option.value === String(field.value))) {
       throw new Error('No matching select option: ' + field.selector);
     }

package/src/extended/browser-endpoint.mjs

@@ -98,8 +98,8 @@ export async function waitForBrowserEndpoint(timeoutMs = 5000) {
 
 export async function ensureBrowserEndpoint(endpoint) {
   assertBrowserRemoteEnabled();
-  if (endpoint || process.env.REMCP_CDP_URL) return;
-  if (await browserCapabilityAvailable(undefined, 250)) return;
+  if (endpoint || process.env.REMCP_CDP_URL) return false;
+  if (await browserCapabilityAvailable(undefined, 250)) return false;
   if (!browserLaunchPromise) {
     browserLaunchPromise = (async () => {
       const executable = browserExecutable();
@@ -112,9 +112,10 @@ export async function ensureBrowserEndpoint(endpoint) {
       if (selected.isolated) console.warn('ReMCP browser: using an isolated recovery profile; existing session and backups are preserved, and sign-in state is not copied.');
       spawnDetached(executable, browserAutoLaunchArgs(selected.profile));
       if (!await waitForBrowserEndpoint(5000)) throw new Error('ReMCP launched a browser but its local CDP endpoint did not become ready');
+      return true;
     })().finally(() => { browserLaunchPromise = null; });
   }
-  await browserLaunchPromise;
+  return browserLaunchPromise;
 }
 
 export async function browserControlAvailable(endpoint, timeoutMs = 500) {
@@ -193,11 +194,17 @@ export function isPrivateBrowserHost(hostname) {
 }
 
 export function endpointUrl(value) {
+  if (value != null && typeof value !== 'string' && !(value instanceof URL)) {
+    throw new Error('endpoint must be a valid local http(s) URL');
+  }
   let url;
-  try { url = new URL(optionalString(value) || process.env.REMCP_CDP_URL || DEFAULT_ENDPOINT); }
-  catch { throw new Error('endpoint must be a valid local http(s) URL'); }
+  try {
+    const provided = value instanceof URL ? value.href : optionalString(value);
+    url = new URL(provided || process.env.REMCP_CDP_URL || DEFAULT_ENDPOINT);
+  } catch { throw new Error('endpoint must be a valid local http(s) URL'); }
   if (!['http:', 'https:'].includes(url.protocol)) throw new Error('endpoint must use http or https');
   if (!isLoopbackHost(url.hostname)) throw new Error('Browser CDP endpoint must be loopback-only');
+  if (url.username || url.password) throw new Error('Browser CDP endpoint must not contain credentials');
   return url;
 }
 

package/src/extended/browser-read.mjs

@@ -98,18 +98,62 @@ export async function browserNavigate(args = {}) {
   });
 }
 
+// CDP accessibility can include an input's current value even when it is
+// masked on screen. The protected AX property must be checked before the
+// node is mirrored to structuredContent or snapshot diff state.
+export function safeAccessibilityValue(node) {
+  const props = Array.isArray(node?.properties) ? node.properties : [];
+  const protectedControl = props.some(item => item?.name === 'protected'
+    && (item?.value?.value === true || String(item?.value?.value) === 'true'));
+  const role = String(node?.role?.value || '').toLowerCase();
+  if (protectedControl || role === 'password' || role === 'passwordtext') return '';
+  return boundedText(node?.value?.value, 1000);
+}
+
+// Chromium's AX tree can repeat editable input values in descendant
+// StaticText/InlineTextBox names. Blank the complete editable subtree before
+// storing a snapshot diff or sending structured content to the MCP host.
+export function sensitiveAccessibilityDescendants(nodes) {
+  const indexed = new Map(nodes.map(node => [node.nodeId, node]));
+  const secret = new Set();
+  const queue = [];
+  for (const node of nodes) {
+    const role = String(node.role?.value || '').toLowerCase();
+    const properties = Array.isArray(node.properties) ? node.properties : [];
+    const editable = properties.some(item => item?.name === 'editable'
+      && ![false,'false',null].includes(item?.value?.value));
+    const protectedNode = properties.some(item => item?.name === 'protected'
+      && [true,'true'].includes(item?.value?.value));
+    if (['textbox','searchbox','combobox','password','passwordtext','spinbutton'].includes(role)
+      || editable || protectedNode) {
+      secret.add(node.nodeId);
+      for (const id of node.childIds || []) queue.push(id);
+    }
+  }
+  while (queue.length) {
+    const id = queue.pop();
+    if (secret.has(id)) continue;
+    secret.add(id);
+    for (const child of indexed.get(id)?.childIds || []) queue.push(child);
+  }
+  return secret;
+}
+
 export async function browserSnapshot(args) {
   return withTarget(args, async (session, target) => {
     await session.send('Accessibility.enable');
     const { nodes = [] } = await session.send('Accessibility.getFullAXTree');
     const limit = clamp(args.max_nodes, 1500, 1, 10_000);
+    const redacted = sensitiveAccessibilityDescendants(nodes);
     const simplified = nodes.slice(0, limit).map(node => ({
       node_id: boundedText(node.nodeId, 256),
       ignored: Boolean(node.ignored),
       role: boundedText(node.role?.value, 256),
-      name: boundedText(node.name?.value, 1000),
-      value: boundedText(node.value?.value, 1000),
-      description: boundedText(node.description?.value, 1000),
+      name: redacted.has(node.nodeId) && !['textbox','searchbox','combobox','spinbutton'].includes(
+        String(node.role?.value||'').toLowerCase()
+      ) ? '' : boundedText(node.name?.value, 1000),
+      value: redacted.has(node.nodeId) ? '' : safeAccessibilityValue(node),
+      description: redacted.has(node.nodeId) ? '' : boundedText(node.description?.value, 1000),
       child_ids: Array.isArray(node.childIds) ? node.childIds.slice(0, 200).map(id => boundedText(id, 256)) : [],
       backend_dom_node_id: node.backendDOMNodeId || null,
     }));
@@ -285,9 +329,19 @@ export function findExpression(args) {
     } else {
       selected = selected.slice(0, ${limit});
     }
+    // Credentials are never sent back in browser_find; even a normal
+    // text input can carry an OTP or API token via its name/autocomplete.
+    function isSensitiveControl(el) {
+      const tag = el.tagName.toLowerCase();
+      if (tag !== 'input' && tag !== 'textarea') return false;
+      if (tag === 'input' && String(el.type || '').toLowerCase() === 'password') return true;
+      const description = ['id','name','autocomplete'].map(key => el.getAttribute(key) || '').join(' ');
+      return /(?:password|passwd|passcode|one.time.code|otp|secret|api.?key|auth.?token|access.?token|recovery.?code)/i.test(description);
+    }
     return selected.map(({ el }) => {
       const b = el.getBoundingClientRect();
-      return { selector: cssPath(el), tag: el.tagName.toLowerCase(), role: semanticRole(el), name: el.getAttribute('aria-label') || el.getAttribute('name') || '', text: visibleText(el).slice(0, 500), value: 'value' in el ? String(el.value).slice(0, 500) : '', x: b.x, y: b.y, width: b.width, height: b.height, disabled: Boolean(el.disabled) };
+      const sensitive = isSensitiveControl(el);
+      return { selector: cssPath(el), tag: el.tagName.toLowerCase(), role: semanticRole(el), name: el.getAttribute('aria-label') || el.getAttribute('name') || '', text: sensitive ? '' : visibleText(el).slice(0, 500), value: !sensitive && 'value' in el ? String(el.value).slice(0, 500) : '', x: b.x, y: b.y, width: b.width, height: b.height, disabled: Boolean(el.disabled) };
     });
   })()`;
 }

package/src/extended/browser-session.mjs

@@ -290,8 +290,35 @@ export function retainProductionSession(key, session, removeGuard, targetId, end
   return record;
 }
 
+// New Chromium windows may report CDP readiness before their session restore
+// finishes. Only cold-start navigation pays this bounded settling cost; all
+// warm clicks, existing tabs and browser reads keep their current fast path.
+export const COLD_BROWSER_SETTLE_MS = 1200;
+export const COLD_TARGET_VERIFY_MS = 700;
+
+export class BrowserTargetDisappearedError extends Error {
+  constructor() {
+    super('Browser CDP target disappeared during startup; the requested tab was not retained. Retry once after checking browser readiness.');
+    this.name = 'BrowserTargetDisappearedError';
+    this.code = 'BROWSER_TARGET_DISAPPEARED';
+    this.retryable = true;
+  }
+}
+
+export async function assertCreatedTargetAvailable(targetId, endpoint, {
+  request = requestJson, pause = ms => new Promise(resolve => setTimeout(resolve, ms)),
+  verifyAfterMs = 0,
+} = {}) {
+  if (verifyAfterMs > 0) await pause(verifyAfterMs);
+  const targets = await request('/json/list', endpoint, { timeout_ms:2000 });
+  if (!Array.isArray(targets) || !targets.some(item => item?.id === targetId && item?.type === 'page')) {
+    throw new BrowserTargetDisappearedError();
+  }
+}
+
 export async function createGuardedNewTab(url, args) {
-  await ensureBrowserEndpoint(args.endpoint);
+  const autoLaunched = await ensureBrowserEndpoint(args.endpoint);
+  if (autoLaunched) await new Promise(resolve => setTimeout(resolve, COLD_BROWSER_SETTLE_MS));
   const created = await requestJson('/json/new', args.endpoint, { method:'PUT', timeout_ms:args.timeout_ms });
   if (!created?.id) throw new Error('Browser did not return a new page target');
   const endpoint = endpointUrl(args.endpoint);
@@ -325,6 +352,12 @@ export async function createGuardedNewTab(url, args) {
     if (loaded) await loaded;
     const finalUrl = await evaluate(session, 'location.href');
     await assertResolvedPageUrl(finalUrl);
+    // A successful Page.navigate is not enough: Chrome's cold-start session
+    // restoration can asynchronously close its targets. Fail rather than
+    // returning a stale ID the next MCP tool call cannot use.
+    await assertCreatedTargetAvailable(target.id, endpoint, {
+      verifyAfterMs:autoLaunched ? COLD_TARGET_VERIFY_MS : 0,
+    });
     return { target, navigation, finalUrl };
   } catch (error) {
     operationFailed = true;