@remcp/runtime 0.2.101 → 0.2.103

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## 0.2.103 — 2026-09-22
+
+- Native Wayland `window_action` targets exact PID/title Accessibility windows for `close` and verifies that the requested window disappeared.
+- Shortcut-backed Wayland window actions require verified focus on the exact requested window before minimize, maximize, move, resize, or close proceeds; ambiguous targeting fails closed.
+- Live smoke coverage isolates XDG open/reveal handlers and stabilizes browser input focus without changing the runtime tool surface.
+- Verified on GNOME Wayland with 80 passing computer-use checks and a two-window isolation proof: target A closed while sibling B stayed open.
+
+## 0.2.102 — 2026-09-22
+
+- `runWithInput` installs a stdin error handler before writing input, so an early child pipe close is returned as a `ToolError` instead of an uncaught `EPIPE` that can terminate the runtime.
+- A failed input pipe now terminates the child before rejecting, preventing a rejected call from leaving an orphan process behind.
+- Empty input closes stdin without a zero-byte write, reducing races with short-lived subprocesses.
+- Added a deterministic closed-stdin regression and stress coverage; runtime tool names and schemas are unchanged.
+
 ## 0.2.101 — 2026-09-22
 
 - macOS `record_screen` resolves FFmpeg from standard Homebrew locations when launchd's minimal `PATH` cannot see it.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remcp/runtime",
-  "version": "0.2.101",
+  "version": "0.2.103",
   "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/common.mjs

@@ -98,7 +98,14 @@ export async function runWithInput(file, args = [], input = '', options = {}) {
       if (code === 0 || options.allowFailure) finish(resolve, { stdout, stderr, code });
       else finish(reject, new ToolError(`${options.label || file} failed: ${stderr.trim() || `exit ${code}`}`));
     });
-    child.stdin.end(String(input));
+    child.stdin.on('error', error => {
+      if (settled) return;
+      child.kill('SIGKILL');
+      finish(reject, new ToolError(`${options.label || file} input failed: ${error.message}`));
+    });
+    const inputText = String(input);
+    if (inputText.length) child.stdin.end(inputText);
+    else child.stdin.end();
   });
 }
 

package/src/extended/desktop-linux.mjs

@@ -312,19 +312,100 @@ async function verifyNativeWaylandGeometry(row, expected, label) {
   throw new Error(`Could not verify native Wayland window ${label} for ${row.title || row.app || row.id}: wanted ${wanted}; observed ${actual}`);
 }
 
+async function nativeWaylandAccessibilityAction(row, actionNames) {
+  const pid = Number(row?.pid);
+  if (!Number.isInteger(pid) || pid <= 0 || !Array.isArray(actionNames) || !actionNames.length) {
+    return { applied:false, available:[] };
+  }
+  const script = pyAtSpiPrelude() + `
+want_pid=${pid};want_window=${JSON.stringify(String(row.title || ''))};wanted_actions=${JSON.stringify(actionNames)}
+target=None
+for root,app_name,pid,active in q:
+ if pid!=want_pid: continue
+ try:
+  for child in root:
+   try:
+    role=(child.getRoleName() or "").lower();name=child.name or ""
+    if role not in ("frame","window","dialog"): continue
+    if want_window and want_window.strip().lower()!=name.strip().lower(): continue
+    target=child;break
+   except: pass
+ except: pass
+ if target is not None: break
+if target is None:
+ print(json.dumps({"applied":False,"available":[],"reason":"target window not found"}))
+else:
+ try:
+  actions=target.queryAction();available=[];chosen=-1;chosen_name=""
+  for i in range(actions.nActions):
+   try: action_name=actions.getName(i) or ""
+   except: action_name=""
+   available.append(action_name)
+   if chosen<0 and action_name in wanted_actions:
+    chosen=i;chosen_name=action_name
+  if chosen<0:
+   print(json.dumps({"applied":False,"available":available,"reason":"requested accessibility action unavailable"}))
+  else:
+   applied=actions.doAction(chosen)
+   if applied is False: raise Exception("accessibility window action returned false")
+   print(json.dumps({"applied":True,"action":chosen_name,"available":available}))
+ except Exception as exc:
+  print(json.dumps({"applied":False,"available":[],"reason":str(exc)}))
+`;
+  const result = await runFile('python3', ['-c', script], { label:'AT-SPI window action', timeout:2000, allowFailure:true });
+  try {
+    const payload = JSON.parse(result.stdout || '{}');
+    return payload && typeof payload === 'object' ? payload : { applied:false, available:[] };
+  } catch {
+    return { applied:false, available:[], reason:String(result.stderr || result.stdout || 'AT-SPI window action failed').trim() };
+  }
+}
+
+async function verifyNativeWaylandWindowClosed(row, timeoutMs = 2500) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    try { await windowMatch({ id:row.id }); }
+    catch { return; }
+    await new Promise(resolve => setTimeout(resolve, 100));
+  }
+  throw new Error(`Could not verify native Wayland window close for ${row.title || row.app || row.id}`);
+}
+
+async function focusNativeWaylandForAction(row, backend) {
+  await windowAction({ action:'focus', id:row.id, backend });
+  const focusState = await targetAccessibilityFocus(row);
+  if (!focusState.exact) throw new Error(`Could not verify native Wayland focus for ${row.title || row.app || row.id}`);
+}
+
 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');
   if (!waylandPortalCandidate()) unavailable('Native Wayland window action', 'no XDG RemoteDesktop portal is available');
   if (backend === 'auto' && !hasWaylandRemoteDesktopGrant()) portalPermissionHint('Native Wayland window action');
-  if (row.ui_id) {
-    try { await uiAction({ action:'focus', id:row.ui_id }); } catch {}
-  }
 
   const portalBackend = backend === 'portal' ? 'portal' : 'auto';
   const timeoutMs = backend === 'portal' ? 120_000 : 2500;
-  if (action === 'close') await portalShortcut('ALT+F4', { timeoutMs });
-  else if (action === 'minimize') await portalShortcut('ALT+F9', { timeoutMs });
+  if (action === 'close') {
+    const semantic = await nativeWaylandAccessibilityAction(row, ['window.close']);
+    if (semantic.applied) {
+      await verifyNativeWaylandWindowClosed(row);
+      return jsonResult({ action, backend:'atspi-window-action', id:row.id, accessibility_action:semantic.action });
+    }
+    // Some GTK apps disconnect from AT-SPI while handling window.close, before the action
+    // call can return a success payload. Trust the observed target state, not that race.
+    try {
+      await verifyNativeWaylandWindowClosed(row, 400);
+      return jsonResult({ action, backend:'atspi-window-action', id:row.id, accessibility_action:'window.close', verified_after_disconnect:true });
+    } catch {}
+    await focusNativeWaylandForAction(row, portalBackend);
+    await portalShortcut('ALT+F4', { timeoutMs });
+    await verifyNativeWaylandWindowClosed(row);
+    return jsonResult({ action, backend:'xdg-desktop-portal', id:row.id });
+  }
+  if (action === 'minimize') {
+    await focusNativeWaylandForAction(row, portalBackend);
+    await portalShortcut('ALT+F9', { timeoutMs });
+  }
   else if (action === 'maximize' || action === 'restore') {
     let maximized = false;
     try {
@@ -346,9 +427,11 @@ async function nativeWaylandWindowAction(row, action, args) {
       }
     } catch {}
     if ((action === 'maximize' && !maximized) || (action === 'restore' && maximized)) {
+      await focusNativeWaylandForAction(row, portalBackend);
       await portalShortcut('ALT+F10', { timeoutMs });
     }
   } else {
+    await focusNativeWaylandForAction(row, portalBackend);
     let currentX = Number(row.x), currentY = Number(row.y), currentWidth = Number(row.width), currentHeight = Number(row.height);
     if (![currentX,currentY,currentWidth,currentHeight].every(Number.isFinite)) unavailable('Native Wayland window geometry', 'accessibility bounds are unavailable');
 
@@ -495,6 +578,9 @@ except Exception:
    def currentValue(self,v): self.a.set_current_value(float(v))
   class _Action:
    def __init__(self,a): self.a=a
+   @property
+   def nActions(self): return self.a.get_n_actions()
+   def getName(self,i): return self.a.get_action_name(i)
    def doAction(self,i): return self.a.do_action(i)
   class _Editable:
    def __init__(self,a): self.a=a