@remcp/runtime 0.2.229 → 0.2.230

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remcp/runtime",
-  "version": "0.2.229",
+  "version": "0.2.230",
   "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-windows.mjs

@@ -1,4 +1,5 @@
 import { msaaBrowserSnapshot, windowsUiRootScript } from './desktop-windows-msaa.mjs';
+import { quoteWindowsArgument } from './windows-argv.mjs';
 import path from 'node:path';
 import process from 'node:process';
 
@@ -75,7 +76,8 @@ public static class RM {
    if(target!=0&&current!=target)attachTarget=AttachThreadInput(current,target,true);
    if(foreground!=0&&current!=foreground&&foreground!=target)attachForeground=AttachThreadInput(current,foreground,true);
    ShowWindow(h,9);AllowSetForegroundWindow(-1);BringWindowToTop(h);
-   SetWindowPos(h,new IntPtr(-1),0,0,0,0,0x0001|0x0002|0x0010|0x0040);
+   // HWND_TOP preserves the window's existing topmost status.
+   SetWindowPos(h,IntPtr.Zero,0,0,0,0,0x0001|0x0002|0x0010|0x0040);
    return SetForegroundWindow(h);
   }finally{
    if(attachForeground)AttachThreadInput(current,foreground,false);
@@ -445,8 +447,8 @@ export async function notification(args = {}) {
 
 export async function launchApp(app,argv=[],options={}) {
   const query=escapePowerShellSingle(String(app));
-  const argsText=argv.map(v=>`'${escapePowerShellSingle(v)}'`).join(',');
-  const argumentClause=argv.length?`-ArgumentList @(${argsText})`:'';
+  const argsText=escapePowerShellSingle(argv.map(quoteWindowsArgument).join(' '));
+  const argumentClause=argv.length?`-ArgumentList '${argsText}'`:'';
   const hasArgs=argv.length?'$true':'$false';
   const cwd=options.cwd?escapePowerShellSingle(String(options.cwd)):'';
   const hasCwd=cwd?'$true':'$false';

package/src/extended/diagnostics-platform.mjs

@@ -98,21 +98,36 @@ export async function serviceTool(args) {
   return text(`${policy?.note ? `${policy.note}\n` : ''}${action} requested for service ${name}.`);
 }
 
+// Windows Get-WinEvent raises NoMatchingEventsFound (and exits nonzero) when a
+// bounded time range has no events. Empty logs are not failed diagnostics, but
+// access denied/invalid log queries must still fail closed.
+export function buildWindowsEventLogScript({ log, seconds, filter, limit }) {
+  const safeLog = escapePowerShellSingle(log);
+  const where = filter ? ` | Where-Object { $_.Message -like '*${escapePowerShellSingle(filter)}*' -or $_.ProviderName -like '*${escapePowerShellSingle(filter)}*' }` : '';
+  const pipeline = `Get-WinEvent -FilterHashtable @{LogName='${safeLog}';StartTime=(Get-Date).AddSeconds(-${seconds})} -ErrorAction Stop${where} | Select-Object -First ${limit} TimeCreated,Id,LevelDisplayName,ProviderName,Message | ConvertTo-Json -Compress -Depth 3`;
+  return `try { ${pipeline} } catch { if ([string]$_.FullyQualifiedErrorId -like 'NoMatchingEventsFound,*') { '[]' } else { throw } }`;
+}
+
+// Unified log records the invocation of `/usr/bin/log show` itself, whose
+// arguments contain the sought text. Exclude that self-generated event.
+export function macosEventLogPredicate(filter) {
+  return `eventMessage CONTAINS[c] ${JSON.stringify(filter)} AND process != "log"`;
+}
+
 export async function eventLog(args) {
   const limit = clamp(args.limit, 200, 1, 5000);
   const since = durationSpec(args.since);
   const filter = optionalString(args.filter || args.query);
   if (process.platform === 'win32') {
-    const log = escapePowerShellSingle(optionalString(args.log) || 'System');
+    const log = optionalString(args.log) || 'System';
     const n = Number.parseInt(since, 10), unit = since.at(-1);
     const seconds = n * ({ s:1, m:60, h:3600, d:86400 }[unit] || 60);
-    const where = filter ? ` | Where-Object { $_.Message -like '*${escapePowerShellSingle(filter)}*' -or $_.ProviderName -like '*${escapePowerShellSingle(filter)}*' }` : '';
-    const script = `Get-WinEvent -FilterHashtable @{LogName='${log}';StartTime=(Get-Date).AddSeconds(-${seconds})} -ErrorAction SilentlyContinue${where} | Select-Object -First ${limit} TimeCreated,Id,LevelDisplayName,ProviderName,Message | ConvertTo-Json -Compress -Depth 3`;
+    const script = buildWindowsEventLogScript({ log, seconds, filter, limit });
     return text((await runPowerShell(script, { label: 'event log', timeout: 30_000 })).stdout.trim() || '[]');
   }
   if (process.platform === 'darwin') {
     const argv = ['show','--last',since,'--style','ndjson'];
-    if (filter) argv.push('--predicate', `eventMessage CONTAINS[c] ${JSON.stringify(filter)}`);
+    if (filter) argv.push('--predicate', macosEventLogPredicate(filter));
     const { stdout } = await runFileHeadLines('/usr/bin/log', argv, limit, { label: 'macOS unified log', timeout: 30_000, maxBuffer: 4 * 1024 * 1024 });
     return text(stdout);
   }

package/src/extended/windows-argv.mjs

@@ -0,0 +1,9 @@
+// Start-Process joins ArgumentList into one command-line string. Encode each
+// argument using the Windows CRT quoting rules before handing that string over.
+export function quoteWindowsArgument(value) {
+  const argument = String(value);
+  if (argument.includes('\0')) throw new Error('Application arguments must not contain NUL');
+  const escaped = argument.replace(/(\\*)"/g, (_, slashes) => `${slashes}${slashes}\\"`)
+    .replace(/\\+$/g, slashes => slashes + slashes);
+  return `"${escaped}"`;
+}

package/src/tools/files-write-edit.mjs

@@ -334,14 +334,28 @@ export async function moveToTrashTool(args) {
       destination = trash;
     } catch { destination = null; }
   }
-  if (!destination) destination = path.join(path.dirname(source), '.remcp-trash');
-  const existingDestination = await lstat(destination).catch(() => null);
-  if (existingDestination?.isSymbolicLink()) fail('Refusing to use a symlink as the trash directory');
-  if (existingDestination && !existingDestination.isDirectory()) fail('Trash destination is not a directory');
-  await ensureDirectoryPath(destination);
-  destination = await resolveSafePath(destination, 'trash');
-  const destinationInfo = await lstat(destination);
-  if (!destinationInfo.isDirectory() || destinationInfo.isSymbolicLink()) fail('Refusing to use a symlink as the trash directory');
+  const localTrash = path.join(path.dirname(source), '.remcp-trash');
+  if (!destination) destination = localTrash;
+  const prepareTrash = async candidate => {
+    const existing = await lstat(candidate).catch(() => null);
+    if (existing?.isSymbolicLink()) fail('Refusing to use a symlink as the trash directory');
+    if (existing && !existing.isDirectory()) fail('Trash destination is not a directory');
+    await ensureDirectoryPath(candidate);
+    const safe = await resolveSafePath(candidate, 'trash');
+    const info = await lstat(safe);
+    if (!info.isDirectory() || info.isSymbolicLink()) fail('Refusing to use a symlink as the trash directory');
+    return { path: safe, device: info.dev };
+  };
+  const sourceInfo = await lstat(source).catch(() => fail(`Path not found: ${displayPath(source)}`));
+  if (sourceInfo.isSymbolicLink()) fail('source cannot be a symbolic link');
+  let prepared = await prepareTrash(destination);
+  // A same-volume rename keeps an entire directory recoverable without copying it.
+  // If the home trash is on another filesystem, use a guarded sibling trash.
+  if (prepared.device !== sourceInfo.dev && sourceInfo.isDirectory()) {
+    prepared = await prepareTrash(localTrash);
+    if (prepared.device !== sourceInfo.dev) fail('No writable trash directory on the source filesystem');
+  }
+  destination = prepared.path;
   const stamp = new Date().toISOString().replace(/[:.]/g, '-');
   let target = path.join(destination, `${stamp}-${path.basename(source)}`);
   let counter = 1;