@remcp/runtime 0.2.4 → 0.2.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remcp/runtime",
-  "version": "0.2.4",
+  "version": "0.2.5",
   "description": "First-party ReMCP local device runtime: file, search, terminal and process tools over MCP for computers paired with ReMCP.",
   "type": "module",
   "license": "MIT",

package/src/catalog.mjs

@@ -37,7 +37,7 @@ export const toolDefinitions = [
       properties: {
         path: { type: 'string', description: 'Absolute directory (or single file) to start from.' },
         pattern: { type: 'string', description: 'Glob matched against the relative path and the file name, such as "src/**/*.ts" or "*.md". Default **/* .' },
-        max_files: { type: 'number', description: 'Stop after this many files. Default 50, maximum 200.' },
+        max_files: { type: 'number', description: 'Stop after this many files. Default 100, maximum 500.' },
         max_lines_per_file: { type: 'number', description: 'Lines kept per file. Default 2000.' },
         include_ignored: { type: 'boolean', description: 'Also descend into .git and node_modules. Default false.' },
       },
@@ -85,7 +85,7 @@ export const toolDefinitions = [
       properties: {
         path: { type: 'string', description: 'Absolute path of the file to read.' },
         offset_bytes: { type: 'number', description: 'Byte offset to start at. Default 0.' },
-        length_bytes: { type: 'number', description: 'Chunk size in bytes. Default and maximum 524288 (512 KiB).' },
+        length_bytes: { type: 'number', description: 'Chunk size in bytes. Default and maximum 1048576 (1 MiB).' },
       },
       required: ['path'],
       additionalProperties: false,
@@ -203,6 +203,42 @@ export const toolDefinitions = [
     annotations: mutating,
     handler: fileToolHandlers.write_files,
   },
+  {
+    name: 'apply_patch',
+    title: 'Apply patch',
+    description: 'Apply a unified diff to one file or to several files at once, matching each hunk with a little fuzz so small offsets and whitespace differences still apply. This is the fastest way to land a multi-line change a model has already worked out. Pass dry_run to see the result as a diff first.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        patch: { type: 'string', description: 'Unified diff, including ---/+++ headers and @@ hunks.' },
+        path: { type: 'string', description: 'Apply every hunk to this file, ignoring the patch headers.' },
+        dry_run: { type: 'boolean', description: 'Report the diff without writing. Default false.' },
+      },
+      required: ['patch'],
+      additionalProperties: false,
+    },
+    annotations: mutating,
+    handler: fileToolHandlers.apply_patch,
+  },
+  {
+    name: 'set_permissions',
+    title: 'Set permissions',
+    description: 'Change the permission mode of a file or directory, optionally recursively and optionally with a numeric owner. Use this to make a script executable after writing it.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        path: { type: 'string', description: 'Absolute path whose permissions should change.' },
+        mode: { type: 'string', description: 'Octal mode such as "755" or "0644".' },
+        recursive: { type: 'boolean', description: 'Apply to a directory and everything inside it. Default false.' },
+        uid: { type: 'number', description: 'Optional numeric user id to set as owner.' },
+        gid: { type: 'number', description: 'Optional numeric group id to set as owner.' },
+      },
+      required: ['path', 'mode'],
+      additionalProperties: false,
+    },
+    annotations: mutating,
+    handler: fileToolHandlers.set_permissions,
+  },
   {
     name: 'edit_block',
     title: 'Edit file',

package/src/config.mjs

@@ -80,15 +80,17 @@ const telemetryEnabled = telemetryDisabled
   ? false
   : booleanValue(process.env.REMCP_RUNTIME_TELEMETRY ?? file.telemetryEnabled, true);
 
-const configuredOutputBytes = positiveNumber(process.env.REMCP_RUNTIME_MAX_OUTPUT_BYTES ?? file.maxOutputBytes, 1024 * 1024);
+// 2 MiB of tool result per call by default: enough for a large file read or a batch of
+// files, still comfortably below the transport ceiling.
+const configuredOutputBytes = positiveNumber(process.env.REMCP_RUNTIME_MAX_OUTPUT_BYTES ?? file.maxOutputBytes, 2 * 1024 * 1024);
 
 export const runtimeConfig = Object.freeze({
   allowedRoots: Object.freeze(allowedRoots),
   blockedCommands: Object.freeze(stringList(process.env.REMCP_RUNTIME_BLOCKED_COMMANDS ?? file.blockedCommands)),
   dangerousCommands: dangerousMode(process.env.REMCP_RUNTIME_DANGEROUS_COMMANDS ?? file.dangerousCommands),
   maxOutputBytes: Math.min(configuredOutputBytes, HARD_OUTPUT_CEILING_BYTES),
-  maxReadLines: positiveNumber(process.env.REMCP_RUNTIME_MAX_READ_LINES ?? file.maxReadLines, 2000),
-  maxBufferedLines: positiveNumber(process.env.REMCP_RUNTIME_MAX_BUFFERED_LINES ?? file.maxBufferedLines, 50000),
+  maxReadLines: positiveNumber(process.env.REMCP_RUNTIME_MAX_READ_LINES ?? file.maxReadLines, 4000),
+  maxBufferedLines: positiveNumber(process.env.REMCP_RUNTIME_MAX_BUFFERED_LINES ?? file.maxBufferedLines, 100000),
   maxWriteBytes: positiveNumber(process.env.REMCP_RUNTIME_MAX_WRITE_BYTES ?? file.maxWriteBytes, 8 * 1024 * 1024),
   defaultShell: String(process.env.REMCP_RUNTIME_SHELL || file.defaultShell || '').trim(),
   name: String(process.env.REMCP_RUNTIME_NAME || file.name || os.hostname()).trim(),

package/src/patch.mjs

@@ -0,0 +1,95 @@
+import { splitLines } from './util.mjs';
+
+// Minimal unified-diff applier. Models produce `--- a/file` / `+++ b/file` patches with
+// `@@ -start,count +start,count @@` hunks; applying them directly is far more reliable
+// than asking a model to re-send whole files or exact blocks.
+
+const HUNK_HEADER = /^@@\s+-(\d+)(?:,(\d+))?\s+\+(\d+)(?:,(\d+))?\s+@@/;
+
+export function parseUnifiedDiff(patch) {
+  const lines = String(patch).replace(/\r\n/g, '\n').split('\n');
+  const files = [];
+  let current = null;
+  let hunk = null;
+  for (const line of lines) {
+    if (line.startsWith('--- ')) {
+      current = { oldPath: line.slice(4).trim(), newPath: null, hunks: [] };
+      files.push(current);
+      hunk = null;
+      continue;
+    }
+    if (line.startsWith('+++ ')) {
+      if (current) current.newPath = line.slice(4).trim();
+      continue;
+    }
+    const header = line.match(HUNK_HEADER);
+    if (header) {
+      if (!current) { current = { oldPath: null, newPath: null, hunks: [] }; files.push(current); }
+      hunk = {
+        oldStart: Number(header[1]),
+        oldCount: header[2] === undefined ? 1 : Number(header[2]),
+        newStart: Number(header[3]),
+        newCount: header[4] === undefined ? 1 : Number(header[4]),
+        lines: [],
+      };
+      current.hunks.push(hunk);
+      continue;
+    }
+    if (!hunk) continue;
+    if (line.startsWith('\\')) continue; // ""
+    if (line === '' && hunk.lines.length === 0) continue;
+    const marker = line[0];
+    if (marker === ' ' || marker === '+' || marker === '-') hunk.lines.push({ type: marker, text: line.slice(1) });
+  }
+  return files.filter(file => file.hunks.length);
+}
+
+function normalize(line) {
+  return String(line).replace(/[ \t]+/g, ' ').trim();
+}
+
+// Find the block a hunk expects, allowing for a few lines of drift and for whitespace
+// differences, the same way patch(1) does with fuzz.
+function locate(lines, hunk) {
+  const expected = hunk.lines.filter(entry => entry.type !== '+').map(entry => entry.text);
+  if (!expected.length) return { index: hunk.oldStart - 1, fuzz: 0 };
+  const candidates = [];
+  const anchor = Math.max(0, hunk.oldStart - 1);
+  for (let offset = 0; offset <= 200; offset += 1) {
+    for (const index of offset === 0 ? [anchor] : [anchor - offset, anchor + offset]) {
+      if (index < 0 || index + expected.length > lines.length) continue;
+      const window = lines.slice(index, index + expected.length);
+      if (window.every((line, position) => line === expected[position])) candidates.push({ index, fuzz: offset });
+      else if (window.every((line, position) => normalize(line) === normalize(expected[position]))) candidates.push({ index, fuzz: offset + 1000 });
+    }
+    if (candidates.length) break;
+  }
+  if (!candidates.length) return null;
+  candidates.sort((a, b) => a.fuzz - b.fuzz || a.index - b.index);
+  return candidates[0];
+}
+
+export function applyHunks(content, hunks) {
+  const eol = content.includes('\r\n') ? '\r\n' : '\n';
+  const endsWithNewline = /\n$/.test(content);
+  const lines = splitLines(content);
+  const applied = [];
+  const failed = [];
+  // Apply from the bottom of the file upwards so earlier hunks keep their line numbers.
+  const ordered = [...hunks].sort((a, b) => b.oldStart - a.oldStart);
+  for (const hunk of ordered) {
+    const found = locate(lines, hunk);
+    if (!found) { failed.push(hunk); continue; }
+    let cursor = found.index;
+    const replacement = [];
+    for (const entry of hunk.lines) {
+      if (entry.type === ' ') { replacement.push(lines[cursor]); cursor += 1; continue; }
+      if (entry.type === '-') { cursor += 1; continue; }
+      replacement.push(entry.text);
+    }
+    lines.splice(found.index, cursor - found.index, ...replacement);
+    applied.push({ hunk, fuzz: found.fuzz });
+  }
+  const updated = `${lines.join(eol)}${endsWithNewline && lines.length ? eol : ''}`;
+  return { updated, applied, failed };
+}

package/src/tools/files.mjs

@@ -3,16 +3,17 @@ import os from 'node:os';
 import { spawnSync } from 'node:child_process';
 import { createHash } from 'node:crypto';
 import { constants, createReadStream } from 'node:fs';
-import { access, copyFile, cp, mkdir, open, readFile, readdir, rename, rm, stat, unlink, writeFile } from 'node:fs/promises';
+import { access, chmod, chown, copyFile, cp, mkdir, open, readFile, readdir, rename, rm, stat, unlink, writeFile } from 'node:fs/promises';
 import { pipeline } from 'node:stream/promises';
 import { runtimeConfig } from '../config.mjs';
 import { diffStats, unifiedDiff } from '../diff.mjs';
+import { applyHunks, parseUnifiedDiff } from '../patch.mjs';
 import { countEvent, recordEvent } from '../telemetry.mjs';
 import { clampInteger, decodeText, displayPath, fail, globToRegExp, image, looksBinary, multi, pageLines, resolveSafePath, splitLines, text } from '../util.mjs';
 
-const MAX_INLINE_FILE_BYTES = 5 * 1024 * 1024;
+const MAX_INLINE_FILE_BYTES = 20 * 1024 * 1024;
 const MAX_IMAGE_BYTES = 8 * 1024 * 1024;
-const MAX_BINARY_CHUNK_BYTES = 512 * 1024;
+const MAX_BINARY_CHUNK_BYTES = 1024 * 1024;
 const IMAGE_TYPES = new Map([
   ['.png', 'image/png'], ['.jpg', 'image/jpeg'], ['.jpeg', 'image/jpeg'], ['.gif', 'image/gif'],
   ['.webp', 'image/webp'], ['.bmp', 'image/bmp'], ['.svg', 'image/svg+xml'], ['.avif', 'image/avif'],
@@ -466,8 +467,8 @@ export async function readFilesTool(args) {
   // instead of one round trip per path.
   const root = await resolveSafePath(args.path || '.');
   const pattern = typeof args.pattern === 'string' && args.pattern.trim() ? args.pattern.trim() : '**/*';
-  const maxFiles = clampInteger(args.max_files, 50, 1, 200);
-  const maxLinesPerFile = clampInteger(args.max_lines_per_file, runtimeConfig.maxReadLines, 1, 10000);
+  const maxFiles = clampInteger(args.max_files, 100, 1, 500);
+  const maxLinesPerFile = clampInteger(args.max_lines_per_file, runtimeConfig.maxReadLines, 1, 20000);
   const includeIgnored = args.include_ignored === true;
   const matcher = globToRegExp(pattern);
   const files = [];
@@ -646,6 +647,76 @@ export async function movePathsTool(args) {
   return text(`${moved}/${pairs.length} path(s) moved\n${results.join('\n')}`, moved !== pairs.length);
 }
 
+// Applying a unified diff is the fastest path from "the model knows the change" to "the
+// change is on disk": no exact-block matching, no re-sending whole files.
+export async function applyPatchTool(args) {
+  const patch = typeof args.patch === 'string' && args.patch.trim() ? args.patch : fail('patch must be a unified diff');
+  const dryRun = args.dry_run === true;
+  const forcePath = typeof args.path === 'string' && args.path.trim() ? args.path : null;
+  const files = parseUnifiedDiff(patch);
+  if (!files.length) fail('patch does not contain any @@ hunks');
+  const results = [];
+  let changed = 0;
+  for (const file of files) {
+    const target = forcePath || (file.newPath && file.newPath !== '/dev/null' ? file.newPath : file.oldPath);
+    if (!target || target === '/dev/null') { results.push('failed: a hunk has no target path; pass path explicitly'); continue; }
+    try {
+      const absolute = await resolveSafePath(target);
+      let original = '';
+      try { original = (await readTextFile(absolute)).content; } catch (error) {
+        if (file.oldPath === '/dev/null' || /not found/i.test(error?.message || '')) original = '';
+        else throw error;
+      }
+      const { updated, applied, failed } = applyHunks(original, file.hunks);
+      if (failed.length && !applied.length) { results.push(`failed ${displayPath(absolute)}: none of the ${file.hunks.length} hunk(s) matched`); continue; }
+      const stats = diffStats(original, updated);
+      if (!dryRun) {
+        assertWritableSize(updated);
+        await mkdir(path.dirname(absolute), { recursive: true });
+        await writeFile(absolute, updated, 'utf8');
+      }
+      changed += 1;
+      const fuzzy = applied.filter(entry => entry.fuzz > 0).length;
+      results.push(`${dryRun ? 'would patch' : 'patched'} ${displayPath(absolute)} · ${applied.length}/${file.hunks.length} hunk(s), +${stats.added}/-${stats.removed} lines${fuzzy ? `, ${fuzzy} with fuzz` : ''}${failed.length ? `, ${failed.length} hunk(s) did not match` : ''}`);
+      if (dryRun) results.push(unifiedDiff(original, updated, { oldLabel: displayPath(absolute), newLabel: 'after' }));
+    } catch (error) {
+      results.push(`failed ${target}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  const failedCount = results.filter(line => line.startsWith('failed')).length;
+  return text([`${changed}/${files.length} file(s) ${dryRun ? 'would be patched' : 'patched'}`, ...results].join('\n'), failedCount > 0);
+}
+
+export async function setPermissionsTool(args) {
+  const absolute = await resolveSafePath(args.path);
+  const info = await stat(absolute).catch(() => fail(`Path not found: ${displayPath(absolute)}`));
+  const raw = typeof args.mode === 'string' ? args.mode.trim() : String(args.mode ?? '');
+  if (!/^[0-7]{3,4}$/.test(raw)) fail('mode must be an octal string such as "755" or "0644"');
+  const mode = Number.parseInt(raw, 8);
+  const recursive = args.recursive === true;
+  const uid = Number.isInteger(Number(args.uid)) ? Number(args.uid) : null;
+  const gid = Number.isInteger(Number(args.gid)) ? Number(args.gid) : null;
+  const targets = [];
+  async function collect(target) {
+    targets.push(target);
+    const entry = await stat(target).catch(() => null);
+    if (!entry?.isDirectory() || !recursive) return;
+    for (const child of await readdir(target).catch(() => [])) await collect(path.join(target, child));
+  }
+  await collect(absolute);
+  let changed = 0;
+  for (const target of targets) {
+    try {
+      await chmod(target, mode);
+      if (uid !== null || gid !== null) await chown(target, uid ?? -1, gid ?? -1);
+      changed += 1;
+    } catch (error) {
+      fail(`Could not change permissions on ${displayPath(target)}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  return text(`Set mode ${raw}${uid !== null || gid !== null ? ` (uid ${uid ?? '-'} gid ${gid ?? '-'})` : ''} on ${changed} path(s) starting at ${displayPath(absolute)}.`);
+}
+
 export async function createDirectoryTool(args) {
   const list = Array.isArray(args.paths) ? args.paths : [args.path];
   if (!list.filter(Boolean).length) fail('path (or paths) is required');
@@ -845,6 +916,8 @@ export const fileToolHandlers = {
   replace_in_files: replaceInFilesTool,
   diff_files: diffFilesTool,
   create_directory: createDirectoryTool,
+  apply_patch: applyPatchTool,
+  set_permissions: setPermissionsTool,
   delete_path: deletePathTool,
   delete_paths: deletePathsTool,
   move_file: moveFileTool,