@remcp/runtime 0.2.94 → 0.2.97

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # Changelog
 
+## 0.2.97 — 2026-09-22
+
+- Native GNOME Wayland `move`, `resize`, and `move_resize` no longer trust a portal drag as proof of success.
+- Window geometry is re-read after each gesture and must match the requested coordinates/size within a bounded tolerance; otherwise the action fails closed.
+- `move_resize` confirms the move before computing the resize gesture. Tool names and schemas remain unchanged.
+
+## 0.2.96 — 2026-09-22
+
+- Keeps readable search matches when an unreadable descendant is encountered while surfacing a warning.
+- Makes the regression backend-neutral so both ripgrep and the built-in scanner are validated consistently.
+- Supersedes the failed unpublished 0.2.95 tag; runtime behavior is otherwise unchanged from that candidate.
+
+## 0.2.95 — 2026-09-22
+
+- Search sessions preserve readable matches when ripgrep encounters unreadable descendant paths, reporting the partial traversal problem as a warning instead of a fatal session error.
+- The dependency-free fallback scanner now skips unreadable descendant directories/files with the same warning semantics.
+- Requested-root failures and non-traversal ripgrep errors still fail closed.
+- Added ripgrep and fallback regressions; runtime tool names and schemas remain unchanged.
+
 ## 0.2.94 — 2026-09-22
 
 - Replaced DOCX/PDF regex-heavy extraction with bounded scanners and added adversarial parser regressions.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remcp/runtime",
-  "version": "0.2.94",
+  "version": "0.2.97",
   "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/desktop-linux.mjs

@@ -283,6 +283,34 @@ async function focusExplicitWaylandInputTarget(args = {}) {
   return row;
 }
 
+function nativeWaylandGeometryMatches(row, expected = {}, tolerance = 24) {
+  for (const key of ['x','y','width','height']) {
+    if (expected[key] == null) continue;
+    const actual = Number(row?.[key]);
+    const wanted = Number(expected[key]);
+    if (!Number.isFinite(actual) || !Number.isFinite(wanted) || Math.abs(actual - wanted) > tolerance) return false;
+  }
+  return true;
+}
+
+async function verifyNativeWaylandGeometry(row, expected, label) {
+  let latest = row;
+  for (let attempt = 0; attempt < 6; attempt += 1) {
+    if (attempt > 0) await new Promise(resolve => setTimeout(resolve, 120));
+    try {
+      latest = await windowMatch({ id:row.id });
+      if (nativeWaylandGeometryMatches(latest, expected)) return latest;
+    } catch {}
+  }
+  const actual = ['x','y','width','height']
+    .map(key => `${key}=${Number.isFinite(Number(latest?.[key])) ? Number(latest[key]) : 'unknown'}`)
+    .join(' ');
+  const wanted = Object.entries(expected)
+    .map(([key,value]) => `${key}=${value}`)
+    .join(' ');
+  throw new Error(`Could not verify native Wayland window ${label} for ${row.title || row.app || row.id}: wanted ${wanted}; observed ${actual}`);
+}
+
 async function nativeWaylandWindowAction(row, action, args) {
   const backend = inputBackend(args);
   if (backend === 'x11') unavailable('Native Wayland window action', 'use backend=portal for compositor-managed windows');
@@ -336,8 +364,11 @@ async function nativeWaylandWindowAction(row, action, args) {
         hold_ms:80,
         duration_ms:120,
       });
-      currentX = x;
-      currentY = y;
+      const verified = await verifyNativeWaylandGeometry(row, { x, y }, 'move');
+      currentX = Number(verified.x);
+      currentY = Number(verified.y);
+      currentWidth = Number(verified.width);
+      currentHeight = Number(verified.height);
     }
 
     if (action === 'resize' || action === 'move_resize') {
@@ -352,7 +383,21 @@ async function nativeWaylandWindowAction(row, action, args) {
         hold_ms:80,
         duration_ms:120,
       });
+      const verified = await verifyNativeWaylandGeometry(row, { width, height }, 'resize');
+      currentX = Number(verified.x);
+      currentY = Number(verified.y);
+      currentWidth = Number(verified.width);
+      currentHeight = Number(verified.height);
     }
+    return jsonResult({
+      action,
+      backend:'xdg-desktop-portal',
+      id:row.id,
+      x:currentX,
+      y:currentY,
+      width:currentWidth,
+      height:currentHeight,
+    });
   }
   return jsonResult({ action, backend:'xdg-desktop-portal', id:row.id });
 }

package/src/sessions.mjs

@@ -188,6 +188,7 @@ export function createSearchSession({ type, pattern, path, filePattern }) {
     results: [],
     status: 'running',
     error: null,
+    warning: null,
     cancel: null,
     waiters: [],
     lastActivityAt: Date.now(),

package/src/tools/search.mjs

@@ -71,17 +71,50 @@ function formatContentResult(file, lineNumber, line, contextLines) {
   return rows.join('\n');
 }
 
-async function walk(target, options, onFile) {
-  const info = await stat(target).catch(() => fail(`Search path not found: ${displayPath(target)}`));
+function rememberSearchWarning(session, warning) {
+  if (session.warning) return;
+  session.warning = warning instanceof Error ? warning.message : String(warning);
+}
+
+function ripgrepTraversalWarnings(stderr, target) {
+  const lines = String(stderr || '').split(/\r?\n/).map(line => line.trim()).filter(Boolean);
+  if (!lines.length) return null;
+  const root = path.resolve(target);
+  for (const line of lines) {
+    const match = line.match(/^rg: (.*): .* \(os error \d+\)$/);
+    if (!match) return null;
+    const reported = path.resolve(match[1]);
+    const relative = path.relative(root, reported);
+    if (!relative || relative === '..' || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) return null;
+  }
+  return lines;
+}
+
+async function walk(target, options, onFile, isRoot = true) {
+  let info;
+  try {
+    info = await stat(target);
+  } catch (error) {
+    if (isRoot) fail(`Search path not found: ${displayPath(target)}`);
+    options.onWarning?.(error);
+    return;
+  }
   if (info.isFile()) { await onFile(target); return; }
-  const entries = await readdir(target, { withFileTypes: true });
+  let entries;
+  try {
+    entries = await readdir(target, { withFileTypes: true });
+  } catch (error) {
+    if (isRoot) throw error;
+    options.onWarning?.(error);
+    return;
+  }
   for (const entry of entries) {
     if (options.stopped()) return;
     if (!options.includeHidden && entry.name.startsWith('.')) continue;
     const child = path.join(target, entry.name);
     if (entry.isDirectory()) {
       if (options.skipDirectories.has(entry.name)) continue;
-      await walk(child, options, onFile);
+      await walk(child, options, onFile, false);
     } else if (entry.isFile()) {
       await onFile(child);
     }
@@ -131,8 +164,13 @@ function runRipgrep(session, { path: target, pattern, searchType, filePattern, i
   child.on('error', error => finishSearchSession(session, 'failed', error.message));
   child.on('close', code => {
     if (session.status !== 'running') { finishSearchSession(session, session.status); return; }
-    // ripgrep exits 2 for a real error (bad pattern, unreadable path) and 0/1 otherwise.
-    if (code === 2 && stderr.trim()) { finishSearchSession(session, 'failed', stderr.trim().split('\n')[0]); return; }
+    // ripgrep exits 2 both for fatal invocation errors and for partial traversal errors.
+    // Descendant OS errors are recoverable: preserve readable matches and surface a warning.
+    if (code === 2 && stderr.trim()) {
+      const warnings = ripgrepTraversalWarnings(stderr, target);
+      if (!warnings) { finishSearchSession(session, 'failed', stderr.trim().split(/\r?\n/)[0]); return; }
+      rememberSearchWarning(session, warnings.length === 1 ? warnings[0] : `${warnings[0]} (+${warnings.length - 1} more)`);
+    }
     finishSearchSession(session, capped ? 'capped' : 'completed');
   });
 }
@@ -142,7 +180,12 @@ async function runFallback(session, { path: target, matcher, searchType, filePat
   const nameGlob = searchType === 'files' ? globToRegExp(fileNameGlob(session.pattern)) : null;
   const nameLiteral = searchType === 'files' && !/[*?[\]{}]/.test(session.pattern) ? session.pattern : null;
   let collected = 0;
-  await walk(target, { includeHidden, skipDirectories: includeIgnored ? new Set() : SKIP_DIRECTORIES, stopped: () => session.status !== 'running' || collected >= maxResults }, async file => {
+  await walk(target, {
+    includeHidden,
+    skipDirectories: includeIgnored ? new Set() : SKIP_DIRECTORIES,
+    stopped: () => session.status !== 'running' || collected >= maxResults,
+    onWarning: warning => rememberSearchWarning(session, warning),
+  }, async file => {
     if (session.status !== 'running' || collected >= maxResults) return;
     if (fileGlobs.length && !fileGlobs.some(glob => glob.test(path.basename(file)))) return;
     if (searchType === 'files') {
@@ -153,8 +196,13 @@ async function runFallback(session, { path: target, matcher, searchType, filePat
       appendSearchResults(session, [displayPath(file)]);
       return;
     }
-    const handle = await open(file, constants.O_RDONLY | (constants.O_NOFOLLOW || 0)).catch(() => null);
-    if (!handle) return;
+    let handle;
+    try {
+      handle = await open(file, constants.O_RDONLY | (constants.O_NOFOLLOW || 0));
+    } catch (error) {
+      rememberSearchWarning(session, error);
+      return;
+    }
     let buffer;
     try {
       const info = await handle.stat();
@@ -210,6 +258,7 @@ export async function startSearchTool(args) {
   return text([
     `searchId: ${session.id} · type: ${searchType} · status: ${status} · results so far: ${session.results.length}`,
     `pattern: ${pattern} · path: ${displayPath(target)}`,
+    session.warning ? `warning: ${session.warning}` : '',
     initial.join('\n'),
     session.results.length > initial.length ? `… ${session.results.length - initial.length} more results buffered; use get_more_search_results with searchId ${session.id}` : '',
   ].filter(Boolean).join('\n'));
@@ -234,6 +283,7 @@ export async function getMoreSearchResultsTool(args) {
   const status = session.error ? `failed: ${session.error}` : session.status;
   return text([
     `searchId: ${session.id} · status: ${status} · results ${start}-${end} of ${total}`,
+    session.warning ? `warning: ${session.warning}` : '',
     session.results.slice(start, end).join('\n'),
   ].filter(Boolean).join('\n'));
 }