@remcp/runtime 0.2.99 → 0.2.101

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## 0.2.101 — 2026-09-22
+
+- macOS `record_screen` resolves FFmpeg from standard Homebrew locations when launchd's minimal `PATH` cannot see it.
+- AVFoundation screen capture now enumerates devices and selects the actual `Capture screen` index instead of assuming input 1.
+- Capability discovery stays conservative: no recorder backend means no `record_screen`; Linux Wayland still requires `wf-recorder`.
+- Added regression coverage for Homebrew discovery and real-world AVFoundation ordering where input 1 is OBS Virtual Camera and the screen is input 3.
+
+## 0.2.100 — 2026-09-22
+
+- Wayland portal-backed region screenshots clip compositor window bounds to the visible virtual desktop before FFmpeg cropping.
+- Portal crop geometry translates negative virtual-desktop origins and scales logical coordinates to the captured PNG dimensions.
+- Partially visible windows return the visible pixels with an explicit clipping summary; fully invisible regions fail closed.
+- Added regressions for oversized/off-screen windows and multi-monitor scaling, plus a real GNOME Wayland 931×910 → 931×900 capture proof.
+
 ## 0.2.99 — 2026-09-22
 
 - Lockstep runtime republish for the release-pipeline catalog synchronization fix.

package/package.json

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

@@ -1,5 +1,6 @@
 import path from 'node:path';
 import process from 'node:process';
+import { open } from 'node:fs/promises';
 
 import { image, multi, text } from '../util.mjs';
 import { capturePortalScreenshot, isWaylandSession } from '../screenshot-portal.mjs';
@@ -1302,6 +1303,79 @@ export async function displayInventory() {
   return jsonResult(rows);
 }
 
+async function pngDimensions(file) {
+  const handle = await open(file, 'r');
+  try {
+    const buffer = Buffer.alloc(24);
+    const { bytesRead } = await handle.read(buffer, 0, buffer.length, 0);
+    if (bytesRead < buffer.length || buffer.subarray(0, 8).toString('hex') !== '89504e470d0a1a0a') return null;
+    const width = buffer.readUInt32BE(16);
+    const height = buffer.readUInt32BE(20);
+    if (!width || !height) return null;
+    return { width, height };
+  } finally {
+    await handle.close();
+  }
+}
+
+export function portalCropGeometry(rect, displays = [], bitmap = null) {
+  const requested = {
+    x: Math.trunc(Number(rect?.x)),
+    y: Math.trunc(Number(rect?.y)),
+    width: Math.trunc(Number(rect?.width)),
+    height: Math.trunc(Number(rect?.height)),
+  };
+  if (![requested.x,requested.y,requested.width,requested.height].every(Number.isFinite)
+      || requested.width <= 0 || requested.height <= 0) {
+    throw new Error('portal crop requires a finite positive rectangle');
+  }
+  const visibleDisplays = Array.isArray(displays) ? displays.filter(item => {
+    const x = Number(item?.x), y = Number(item?.y), width = Number(item?.width), height = Number(item?.height);
+    return [x,y,width,height].every(Number.isFinite) && width > 0 && height > 0;
+  }) : [];
+  const bitmapWidth = Math.trunc(Number(bitmap?.width));
+  const bitmapHeight = Math.trunc(Number(bitmap?.height));
+  const hasBitmap = Number.isFinite(bitmapWidth) && bitmapWidth > 0 && Number.isFinite(bitmapHeight) && bitmapHeight > 0;
+
+  let minX = 0, minY = 0;
+  let maxX = hasBitmap ? bitmapWidth : requested.x + requested.width;
+  let maxY = hasBitmap ? bitmapHeight : requested.y + requested.height;
+  if (visibleDisplays.length) {
+    minX = Math.min(...visibleDisplays.map(item => Number(item.x)));
+    minY = Math.min(...visibleDisplays.map(item => Number(item.y)));
+    maxX = Math.max(...visibleDisplays.map(item => Number(item.x) + Number(item.width)));
+    maxY = Math.max(...visibleDisplays.map(item => Number(item.y) + Number(item.height)));
+  }
+  const left = Math.max(requested.x, minX);
+  const top = Math.max(requested.y, minY);
+  const right = Math.min(requested.x + requested.width, maxX);
+  const bottom = Math.min(requested.y + requested.height, maxY);
+  if (right <= left || bottom <= top) throw new Error('screenshot region is outside visible desktop bounds');
+
+  const virtualWidth = maxX - minX;
+  const virtualHeight = maxY - minY;
+  const scaleX = hasBitmap && virtualWidth > 0 ? bitmapWidth / virtualWidth : 1;
+  const scaleY = hasBitmap && virtualHeight > 0 ? bitmapHeight / virtualHeight : 1;
+  const x = Math.max(0, Math.floor((left - minX) * scaleX));
+  const y = Math.max(0, Math.floor((top - minY) * scaleY));
+  const sourceRight = hasBitmap
+    ? Math.min(bitmapWidth, Math.ceil((right - minX) * scaleX))
+    : Math.ceil((right - minX) * scaleX);
+  const sourceBottom = hasBitmap
+    ? Math.min(bitmapHeight, Math.ceil((bottom - minY) * scaleY))
+    : Math.ceil((bottom - minY) * scaleY);
+  const width = sourceRight - x;
+  const height = sourceBottom - y;
+  if (width <= 0 || height <= 0) throw new Error('screenshot region has no visible portal pixels');
+
+  return {
+    x, y, width, height,
+    visible: { x:left, y:top, width:right-left, height:bottom-top },
+    clipped: left !== requested.x || top !== requested.y
+      || right !== requested.x + requested.width || bottom !== requested.y + requested.height,
+  };
+}
+
 export async function screenshotRegion(args = {}) {
   const x=Math.trunc(Number(args.x)), y=Math.trunc(Number(args.y)), width=Math.trunc(Number(args.width)), height=Math.trunc(Number(args.height));
   if (![x,y,width,height].every(Number.isFinite) || width<=0 || height<=0) throw new Error('x, y, width and height are required; width/height must be positive');
@@ -1309,19 +1383,30 @@ export async function screenshotRegion(args = {}) {
   const dir = await tempDir('remcp-region-');
   const target = path.join(dir, 'region.png');
   const full = path.join(dir, 'full.png');
+  let captured = { x, y, width, height };
+  let clipped = false;
   try {
     if (commandExists('grim')) {
       await runFile('grim', ['-g',`${x},${y} ${width}x${height}`,target], { label:'screenshot region' });
     } else if (isWaylandSession() && commandExists('ffmpeg')) {
       await capturePortalScreenshot(full);
-      await runFile('ffmpeg', ['-hide_banner','-loglevel','error','-y','-i',full,'-vf',`crop=${width}:${height}:${x}:${y}`,'-frames:v','1',target], { label:'crop portal screenshot', timeout:30_000, maxBuffer:4*1024*1024 });
+      const inventory = await displayInventory().catch(() => null);
+      const displays = Array.isArray(inventory?.structuredContent?.data) ? inventory.structuredContent.data : [];
+      const bitmap = await pngDimensions(full);
+      const crop = portalCropGeometry({ x, y, width, height }, displays, bitmap);
+      captured = crop.visible;
+      clipped = crop.clipped;
+      await runFile('ffmpeg', ['-hide_banner','-loglevel','error','-y','-i',full,'-vf',`crop=${crop.width}:${crop.height}:${crop.x}:${crop.y}`,'-frames:v','1',target], { label:'crop portal screenshot', timeout:30_000, maxBuffer:4*1024*1024 });
     } else if (commandExists('import')) {
       await runFile('import', ['-window','root','-crop',`${width}x${height}+${x}+${y}`,target], { label:'screenshot region' });
     } else {
       unavailable('Region screenshots', isWaylandSession() ? 'the XDG Desktop Portal plus ffmpeg, or grim, is required' : 'install ImageMagick import');
     }
     const {data} = await readPrivateTempFile(target, 4 * 1024 * 1024);
-    return multi([{type:'text',text:`Captured ${width}x${height} at ${x},${y}.`}, image(data.toString('base64'),'image/png')]);
+    const summary = clipped
+      ? `Captured visible ${captured.width}x${captured.height} at ${captured.x},${captured.y}; clipped from requested ${width}x${height} at ${x},${y}.`
+      : `Captured ${width}x${height} at ${x},${y}.`;
+    return multi([{type:'text',text:summary}, image(data.toString('base64'),'image/png')]);
   } finally { await removeTemp(dir); }
 }
 

package/src/extended/diagnostics.mjs

@@ -3,6 +3,7 @@ import net from 'node:net';
 import os from 'node:os';
 import path from 'node:path';
 import process from 'node:process';
+import { existsSync } from 'node:fs';
 import { stat } from 'node:fs/promises';
 import { assertAllowedCommand } from '../policy.mjs';
 import { isWaylandSession } from '../screenshot-portal.mjs';
@@ -245,17 +246,54 @@ export async function powerAction(args) {
   return text(`${policy.note ? `${policy.note}\n` : ''}Power action ${action} requested.`);
 }
 
+export function resolveRecordScreenFfmpeg({
+  platform = process.platform,
+  commandExistsFn = commandExists,
+  existsSyncFn = existsSync,
+} = {}) {
+  if (commandExistsFn('ffmpeg')) return 'ffmpeg';
+  if (platform === 'darwin') {
+    for (const candidate of ['/opt/homebrew/bin/ffmpeg', '/usr/local/bin/ffmpeg']) {
+      if (existsSyncFn(candidate)) return candidate;
+    }
+  }
+  return null;
+}
+
+export function parseAvfoundationScreenInput(output) {
+  for (const line of String(output || '').split(/\r?\n/)) {
+    const match = line.match(/\[(\d+)\]\s+Capture screen(?:\s+\d+)?\s*$/i);
+    if (match) return match[1];
+  }
+  return null;
+}
+
+async function avfoundationScreenInput(ffmpeg) {
+  const result = await runFile(ffmpeg, [
+    '-hide_banner',
+    '-f','avfoundation',
+    '-list_devices','true',
+    '-i','',
+  ], { label:'AVFoundation device inventory', timeout:10_000, allowFailure:true });
+  const index = parseAvfoundationScreenInput(`${result.stderr || ''}\n${result.stdout || ''}`);
+  if (!index) unavailable('Screen recording', 'ffmpeg could not find an AVFoundation Capture screen input');
+  return index;
+}
+
 export function recordScreenAvailable({
   platform = process.platform,
   wayland = platform === 'linux' ? isWaylandSession() : false,
   display = process.env.DISPLAY || '',
   commandExistsFn = commandExists,
+  existsSyncFn = existsSync,
 } = {}) {
   if (platform === 'linux') {
     if (wayland) return commandExistsFn('wf-recorder') && commandExistsFn('timeout');
     return Boolean(String(display).trim()) && commandExistsFn('ffmpeg');
   }
-  if (platform === 'darwin' || platform === 'win32') return commandExistsFn('ffmpeg');
+  if (platform === 'darwin' || platform === 'win32') {
+    return Boolean(resolveRecordScreenFfmpeg({ platform, commandExistsFn, existsSyncFn }));
+  }
   return false;
 }
 
@@ -268,22 +306,26 @@ export async function recordScreen(args) {
     const result = await runFile('timeout', ['--signal=INT', `${seconds}s`, 'wf-recorder', '-f',destination,'-r',String(fps),'-c','libx264'], { label:'screen recording', timeout:(seconds+10)*1000, allowFailure:true });
     if (![0, 124, 130].includes(Number(result.code))) throw new Error(result.stderr.trim() || `wf-recorder exited ${result.code}`);
   } else {
+    const ffmpeg = resolveRecordScreenFfmpeg();
     if (wayland) {
       unavailable('Screen recording', 'wf-recorder and timeout are required on Wayland');
     }
     if (process.platform === 'linux' && !String(process.env.DISPLAY || '').trim()) {
       unavailable('Screen recording', 'an active X11 DISPLAY is required on Linux X11');
     }
-    if (!commandExists('ffmpeg')) {
+    if (!ffmpeg) {
       if (process.platform === 'darwin') unavailable('Screen recording', 'ffmpeg is required on macOS');
       if (process.platform === 'win32') unavailable('Screen recording', 'ffmpeg is required on Windows');
       unavailable('Screen recording', 'ffmpeg is required on X11');
     }
     let argv;
     if (process.platform === 'win32') argv=['-y','-f','gdigrab','-framerate',String(fps),'-i','desktop','-t',String(seconds),'-pix_fmt','yuv420p',destination];
-    else if (process.platform === 'darwin') argv=['-y','-f','avfoundation','-framerate',String(fps),'-i','1:none','-t',String(seconds),'-pix_fmt','yuv420p',destination];
+    else if (process.platform === 'darwin') {
+      const input = await avfoundationScreenInput(ffmpeg);
+      argv=['-y','-f','avfoundation','-framerate',String(fps),'-i',`${input}:none`,'-t',String(seconds),'-pix_fmt','yuv420p',destination];
+    }
     else argv=['-y','-f','x11grab','-framerate',String(fps),'-i',process.env.DISPLAY,'-t',String(seconds),'-pix_fmt','yuv420p',destination];
-    await runFile('ffmpeg', argv, { label:'screen recording', timeout:(seconds+20)*1000, maxBuffer:8*1024*1024 });
+    await runFile(ffmpeg, argv, { label:'screen recording', timeout:(seconds+20)*1000, maxBuffer:8*1024*1024 });
   }
   const info = await stat(destination);
   return jsonResult({ path:destination, bytes:info.size, duration_seconds:seconds, format:path.extname(destination).slice(1) || 'mp4' });