machine-bridge-mcp 0.3.3 → 0.4.2

package/src/local/patch.mjs

@@ -0,0 +1,140 @@
+const BEGIN = "*** Begin Patch";
+const END = "*** End Patch";
+const SECTION_PREFIXES = ["*** Add File: ", "*** Update File: ", "*** Delete File: "];
+
+export function parsePatchEnvelope(input) {
+  const text = String(input ?? "").replaceAll("\r\n", "\n");
+  const lines = text.split("\n");
+  if (lines[0] !== BEGIN) throw new Error(`patch must start with ${BEGIN}`);
+  const endIndex = lines.lastIndexOf(END);
+  if (endIndex < 1) throw new Error(`patch must end with ${END}`);
+  if (lines.slice(endIndex + 1).some((line) => line !== "")) throw new Error("unexpected content after patch envelope");
+
+  const operations = [];
+  let index = 1;
+  while (index < endIndex) {
+    if (!lines[index]) {
+      index += 1;
+      continue;
+    }
+    const header = lines[index];
+    const kind = header.startsWith(SECTION_PREFIXES[0])
+      ? "add"
+      : header.startsWith(SECTION_PREFIXES[1])
+        ? "update"
+        : header.startsWith(SECTION_PREFIXES[2])
+          ? "delete"
+          : "";
+    if (!kind) throw new Error(`invalid patch section header at line ${index + 1}`);
+    const prefix = SECTION_PREFIXES[kind === "add" ? 0 : kind === "update" ? 1 : 2];
+    const path = header.slice(prefix.length).trim();
+    if (!path) throw new Error(`patch ${kind} path is empty`);
+    index += 1;
+
+    if (kind === "add") {
+      const contentLines = [];
+      while (index < endIndex && !isSectionHeader(lines[index])) {
+        const line = lines[index];
+        if (!line.startsWith("+")) throw new Error(`added file content must start with + at line ${index + 1}`);
+        contentLines.push(line.slice(1));
+        index += 1;
+      }
+      operations.push({ kind, path, content: contentLines.length ? `${contentLines.join("\n")}\n` : "" });
+      continue;
+    }
+
+    if (kind === "delete") {
+      if (index < endIndex && !isSectionHeader(lines[index]) && lines[index] !== "") {
+        throw new Error(`delete section must not contain patch body at line ${index + 1}`);
+      }
+      operations.push({ kind, path });
+      continue;
+    }
+
+    let moveTo = "";
+    if (lines[index]?.startsWith("*** Move to: ")) {
+      moveTo = lines[index].slice("*** Move to: ".length).trim();
+      if (!moveTo) throw new Error("move destination is empty");
+      index += 1;
+    }
+    const hunks = [];
+    while (index < endIndex && !isSectionHeader(lines[index])) {
+      if (!lines[index]) {
+        index += 1;
+        continue;
+      }
+      if (!lines[index].startsWith("@@")) throw new Error(`update hunk must start with @@ at line ${index + 1}`);
+      const headerText = lines[index].slice(2).trim();
+      index += 1;
+      const hunkLines = [];
+      while (index < endIndex && !isSectionHeader(lines[index]) && !lines[index].startsWith("@@")) {
+        const line = lines[index];
+        if (!line || ![" ", "+", "-"].includes(line[0])) {
+          throw new Error(`invalid update line prefix at line ${index + 1}`);
+        }
+        hunkLines.push({ type: line[0], text: line.slice(1) });
+        index += 1;
+      }
+      if (!hunkLines.length) throw new Error("empty update hunk");
+      if (!hunkLines.some((line) => line.type !== "+")) throw new Error("update hunk needs context or removed lines");
+      hunks.push({ header: headerText, lines: hunkLines });
+    }
+    if (!hunks.length) throw new Error(`update section for ${path} contains no hunks`);
+    operations.push({ kind, path, moveTo: moveTo || undefined, hunks });
+  }
+
+  if (!operations.length) throw new Error("patch contains no file operations");
+  const touched = new Set();
+  for (const operation of operations) {
+    for (const path of [operation.path, operation.moveTo].filter(Boolean)) {
+      if (touched.has(path)) throw new Error(`patch touches the same path more than once: ${path}`);
+      touched.add(path);
+    }
+  }
+  return operations;
+}
+
+export function applyUpdateHunks(content, hunks, path = "file") {
+  const normalized = String(content).replaceAll("\r\n", "\n");
+  const trailingNewline = normalized.endsWith("\n");
+  let lines = normalized.split("\n");
+  if (trailingNewline) lines.pop();
+  let searchFrom = 0;
+
+  for (const [hunkIndex, hunk] of hunks.entries()) {
+    const oldLines = hunk.lines.filter((line) => line.type !== "+").map((line) => line.text);
+    const newLines = hunk.lines.filter((line) => line.type !== "-").map((line) => line.text);
+    const matches = findSequenceMatches(lines, oldLines, searchFrom);
+    if (matches.length === 0) {
+      throw new Error(`patch context not found for ${path} hunk ${hunkIndex + 1}`);
+    }
+    if (matches.length > 1) {
+      throw new Error(`patch context is ambiguous for ${path} hunk ${hunkIndex + 1}`);
+    }
+    const at = matches[0];
+    lines.splice(at, oldLines.length, ...newLines);
+    searchFrom = at + newLines.length;
+  }
+
+  return `${lines.join("\n")}${trailingNewline ? "\n" : ""}`;
+}
+
+function findSequenceMatches(lines, sequence, start) {
+  const matches = [];
+  if (!sequence.length) return matches;
+  for (let index = Math.max(0, start); index <= lines.length - sequence.length; index += 1) {
+    let matched = true;
+    for (let offset = 0; offset < sequence.length; offset += 1) {
+      if (lines[index + offset] !== sequence[offset]) {
+        matched = false;
+        break;
+      }
+    }
+    if (matched) matches.push(index);
+  }
+  return matches;
+}
+
+function isSectionHeader(line) {
+  return SECTION_PREFIXES.some((prefix) => line.startsWith(prefix));
+}

package/src/local/process-sessions.mjs

@@ -0,0 +1,352 @@
+import { spawn } from "node:child_process";
+import { randomBytes } from "node:crypto";
+import { basename } from "node:path";
+import { executionEnv } from "./shell.mjs";
+
+export const MAX_COMMAND_BYTES = 64 * 1024;
+export const MAX_ARGV_ITEMS = 256;
+export const MAX_PROCESS_SESSIONS = 8;
+export const MAX_SESSION_OUTPUT_BYTES = 1024 * 1024;
+export const MAX_PROCESS_STDIN_BYTES = 64 * 1024;
+export const PROCESS_SESSION_RETENTION_MS = 30 * 60 * 1000;
+
+export class ProcessSessionManager {
+  constructor({ workspace, policy, runtimeDir, activeProcesses, callProcesses, resolveCwd, displayPath, throwIfCancelled }) {
+    this.workspace = workspace;
+    this.policy = policy;
+    this.runtimeDir = runtimeDir;
+    this.activeProcesses = activeProcesses;
+    this.callProcesses = callProcesses;
+    this.resolveCwd = resolveCwd;
+    this.displayPath = displayPath;
+    this.throwIfCancelled = throwIfCancelled;
+    this.sessions = new Map();
+  }
+
+  status() {
+    return {
+      active: [...this.sessions.values()].filter((session) => session.closedAt === null).length,
+      retained: this.sessions.size,
+      maximum: MAX_PROCESS_SESSIONS,
+    };
+  }
+
+  clear() {
+    this.sessions.clear();
+  }
+
+  notifyCancellation() {
+    for (const session of this.sessions.values()) notifySessionWaiters(session);
+  }
+
+  async start(args, context = {}) {
+    this.assertEnabled("start_process");
+    const argv = validateArgv(args.argv);
+    const cwd = await this.resolveCwd(args.cwd || ".");
+    this.prune();
+    if (this.sessions.size >= MAX_PROCESS_SESSIONS) throw new Error(`process session limit reached (${MAX_PROCESS_SESSIONS})`);
+    this.throwIfCancelled(context);
+
+    const child = spawn(argv[0], argv.slice(1), {
+      cwd,
+      env: executionEnv(this.workspace, { fullEnv: this.policy.minimalEnv === false, runtimeDir: this.runtimeDir }),
+      detached: process.platform !== "win32",
+      windowsHide: true,
+    });
+    const session = {
+      id: `proc_${randomBytes(24).toString("base64url")}`,
+      child,
+      argv0: basename(argv[0]),
+      cwd,
+      stdout: createSessionStream(),
+      stderr: createSessionStream(),
+      startedAt: Date.now(),
+      lastActivity: Date.now(),
+      closedAt: null,
+      exitCode: null,
+      signal: null,
+      stdinClosed: false,
+      waiters: new Set(),
+    };
+    this.sessions.set(session.id, session);
+    this.trackChild(child, context.callId);
+
+    child.stdout.on("data", (chunk) => {
+      appendSessionStream(session.stdout, chunk);
+      session.lastActivity = Date.now();
+      notifySessionWaiters(session);
+    });
+    child.stderr.on("data", (chunk) => {
+      appendSessionStream(session.stderr, chunk);
+      session.lastActivity = Date.now();
+      notifySessionWaiters(session);
+    });
+    child.on("close", (code, signal) => {
+      session.exitCode = Number.isInteger(code) ? code : null;
+      session.signal = signal ? String(signal) : null;
+      session.closedAt = Date.now();
+      session.lastActivity = Date.now();
+      session.stdinClosed = true;
+      this.untrackChild(child);
+      notifySessionWaiters(session);
+    });
+
+    try {
+      await waitForSpawn(child);
+    } catch (error) {
+      this.sessions.delete(session.id);
+      this.untrackChild(child);
+      throw error;
+    }
+
+    child.on("error", (error) => {
+      appendSessionStream(session.stderr, Buffer.from(`${boundedErrorMessage(error)}\n`));
+      session.lastActivity = Date.now();
+      notifySessionWaiters(session);
+    });
+    this.throwIfCancelled(context);
+    return this.summary(session);
+  }
+
+  async read(args, context = {}) {
+    this.assertEnabled("read_process");
+    const session = this.get(args.session_id);
+    const stdoutOffset = clampInt(args.stdout_offset, 0, 0, Number.MAX_SAFE_INTEGER);
+    const stderrOffset = clampInt(args.stderr_offset, 0, 0, Number.MAX_SAFE_INTEGER);
+    const maxBytes = clampInt(args.max_bytes, 64 * 1024, 1, 256 * 1024);
+    const waitMs = clampInt(args.wait_ms, 0, 0, 30_000);
+    this.throwIfCancelled(context);
+    const waitForExit = args.wait_for_exit === true;
+    if (waitMs > 0 && session.closedAt === null) {
+      const deadline = Date.now() + waitMs;
+      if (waitForExit) {
+        while (session.closedAt === null && Date.now() < deadline) {
+          await waitForSessionChange(session, Math.max(1, deadline - Date.now()), () => this.throwIfCancelled(context));
+        }
+      } else if (!sessionHasOutputAfter(session, stdoutOffset, stderrOffset)) {
+        await waitForSessionChange(session, waitMs, () => this.throwIfCancelled(context));
+      }
+    }
+    this.throwIfCancelled(context);
+    session.lastActivity = Date.now();
+    return {
+      ...this.summary(session),
+      stdout: readSessionStream(session.stdout, stdoutOffset, maxBytes),
+      stderr: readSessionStream(session.stderr, stderrOffset, maxBytes),
+    };
+  }
+
+  async write(args, context = {}) {
+    this.assertEnabled("write_process");
+    const session = this.get(args.session_id);
+    if (session.closedAt !== null) throw new Error("process session has already exited");
+    const data = String(args.data ?? "");
+    if (Buffer.byteLength(data) > MAX_PROCESS_STDIN_BYTES) throw new Error(`stdin data exceeds maximum size (${MAX_PROCESS_STDIN_BYTES} bytes)`);
+    if (session.stdinClosed || session.child.stdin.destroyed) throw new Error("process session stdin is closed");
+    this.throwIfCancelled(context);
+    if (data) {
+      await new Promise((resolvePromise, rejectPromise) => {
+        session.child.stdin.write(data, (error) => error ? rejectPromise(error) : resolvePromise());
+      });
+    }
+    if (args.close_stdin === true) {
+      session.child.stdin.end();
+      session.stdinClosed = true;
+    }
+    session.lastActivity = Date.now();
+    return { ...this.summary(session), bytes_written: Buffer.byteLength(data) };
+  }
+
+  async kill(args, context = {}) {
+    this.assertEnabled("kill_process");
+    const session = this.get(args.session_id);
+    this.throwIfCancelled(context);
+    const wasRunning = session.closedAt === null;
+    if (wasRunning) terminateProcessTree(session.child, args.force === true ? "SIGKILL" : "SIGTERM");
+    session.lastActivity = Date.now();
+    return { ...this.summary(session), termination_requested: wasRunning, force: args.force === true };
+  }
+
+  get(sessionId) {
+    this.prune();
+    const id = String(sessionId || "");
+    if (!/^proc_[A-Za-z0-9_-]{20,}$/.test(id)) throw new Error("invalid process session id");
+    const session = this.sessions.get(id);
+    if (!session) throw new Error("process session not found or expired");
+    return session;
+  }
+
+  summary(session) {
+    return {
+      session_id: session.id,
+      command: session.argv0,
+      cwd: this.displayPath(session.cwd),
+      running: session.closedAt === null,
+      exit_code: session.exitCode,
+      signal: session.signal,
+      stdin_closed: session.stdinClosed,
+      started_at: new Date(session.startedAt).toISOString(),
+      closed_at: session.closedAt ? new Date(session.closedAt).toISOString() : null,
+      stdout_offset: session.stdout.totalBytes,
+      stderr_offset: session.stderr.totalBytes,
+    };
+  }
+
+  prune() {
+    const cutoff = Date.now() - PROCESS_SESSION_RETENTION_MS;
+    for (const [id, session] of this.sessions) {
+      if (session.closedAt !== null && session.lastActivity < cutoff) this.sessions.delete(id);
+    }
+    if (this.sessions.size < MAX_PROCESS_SESSIONS) return;
+    const exited = [...this.sessions.values()]
+      .filter((session) => session.closedAt !== null)
+      .sort((left, right) => left.lastActivity - right.lastActivity);
+    for (const session of exited) {
+      if (this.sessions.size < MAX_PROCESS_SESSIONS) break;
+      this.sessions.delete(session.id);
+    }
+  }
+
+  assertEnabled(tool) {
+    if (this.policy.execMode !== "direct" && this.policy.execMode !== "shell") throw new Error(`${tool} is disabled by daemon policy`);
+  }
+
+  trackChild(child, callId) {
+    this.activeProcesses.add(child);
+    if (!callId) return;
+    const set = this.callProcesses.get(callId) || new Set();
+    set.add(child);
+    this.callProcesses.set(callId, set);
+  }
+
+  untrackChild(child) {
+    this.activeProcesses.delete(child);
+    for (const [callId, set] of this.callProcesses) {
+      set.delete(child);
+      if (!set.size) this.callProcesses.delete(callId);
+    }
+  }
+}
+
+export function validateArgv(value) {
+  if (!Array.isArray(value) || !value.length || value.length > MAX_ARGV_ITEMS) throw new Error(`argv must contain 1-${MAX_ARGV_ITEMS} strings`);
+  const argv = value.map((item) => {
+    if (typeof item !== "string" || item.includes("\0")) throw new Error("argv entries must be strings without NUL bytes");
+    return item;
+  });
+  if (!argv[0]) throw new Error("argv[0] must not be empty");
+  if (Buffer.byteLength(JSON.stringify(argv)) > MAX_COMMAND_BYTES) throw new Error(`argv exceeds maximum size (${MAX_COMMAND_BYTES} bytes)`);
+  return argv;
+}
+
+export function terminateProcessTree(child, signal) {
+  if (!child?.pid) return;
+  if (process.platform === "win32") {
+    try {
+      const killer = spawn("taskkill.exe", ["/PID", String(child.pid), "/T", "/F"], { stdio: "ignore", windowsHide: true });
+      killer.unref();
+      return;
+    } catch {}
+  }
+  try { process.kill(-child.pid, signal); } catch {
+    try { child.kill(signal); } catch {}
+  }
+}
+
+function waitForSpawn(child) {
+  return new Promise((resolvePromise, rejectPromise) => {
+    const onSpawn = () => { cleanup(); resolvePromise(); };
+    const onError = (error) => { cleanup(); rejectPromise(error); };
+    const cleanup = () => {
+      child.off("spawn", onSpawn);
+      child.off("error", onError);
+    };
+    child.once("spawn", onSpawn);
+    child.once("error", onError);
+  });
+}
+
+function createSessionStream() {
+  return { buffer: Buffer.alloc(0), baseOffset: 0, totalBytes: 0 };
+}
+
+function appendSessionStream(stream, chunk) {
+  const input = Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk ?? ""));
+  stream.totalBytes += input.length;
+  let combined = stream.buffer.length ? Buffer.concat([stream.buffer, input]) : Buffer.from(input);
+  if (combined.length > MAX_SESSION_OUTPUT_BYTES) {
+    const dropped = combined.length - MAX_SESSION_OUTPUT_BYTES;
+    combined = combined.subarray(dropped);
+    stream.baseOffset += dropped;
+  }
+  stream.buffer = combined;
+}
+
+function readSessionStream(stream, requestedOffset, maxBytes) {
+  const clampedOffset = Math.min(requestedOffset, stream.totalBytes);
+  const effectiveOffset = Math.max(clampedOffset, stream.baseOffset);
+  const start = effectiveOffset - stream.baseOffset;
+  const slice = stream.buffer.subarray(start, Math.min(stream.buffer.length, start + maxBytes));
+  let data;
+  let dataBase64;
+  let encoding = "utf8";
+  try {
+    data = new TextDecoder("utf-8", { fatal: true }).decode(slice);
+  } catch {
+    data = new TextDecoder("utf-8").decode(slice);
+    dataBase64 = slice.toString("base64");
+    encoding = "base64";
+  }
+  return {
+    data,
+    ...(dataBase64 ? { data_base64: dataBase64 } : {}),
+    encoding,
+    requested_offset: requestedOffset,
+    start_offset: effectiveOffset,
+    next_offset: effectiveOffset + slice.length,
+    total_offset: stream.totalBytes,
+    truncated_before: requestedOffset < stream.baseOffset,
+    truncated_after: effectiveOffset + slice.length < stream.totalBytes,
+  };
+}
+
+function sessionHasOutputAfter(session, stdoutOffset, stderrOffset) {
+  return session.stdout.totalBytes > stdoutOffset || session.stderr.totalBytes > stderrOffset;
+}
+
+function notifySessionWaiters(session) {
+  for (const waiter of [...session.waiters]) waiter();
+}
+
+function waitForSessionChange(session, waitMs, cancellationCheck) {
+  return new Promise((resolvePromise, rejectPromise) => {
+    let timer;
+    const done = () => {
+      cleanup();
+      try {
+        cancellationCheck();
+        resolvePromise();
+      } catch (error) {
+        rejectPromise(error);
+      }
+    };
+    const cleanup = () => {
+      if (timer) clearTimeout(timer);
+      session.waiters.delete(done);
+    };
+    session.waiters.add(done);
+    timer = setTimeout(done, waitMs);
+    timer.unref?.();
+  });
+}
+
+function boundedErrorMessage(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return message.replace(/[\r\n]+/g, " ").slice(0, 4096) || "process failed";
+}
+
+function clampInt(value, fallback, min, max) {
+  const parsed = Number.parseInt(String(value ?? ""), 10);
+  const number = Number.isFinite(parsed) ? parsed : fallback;
+  return Math.min(Math.max(number, min), max);
+}

package/src/local/service.mjs

@@ -7,8 +7,8 @@ import { ensureOwnerOnlyDir, expandHome } from "./state.mjs";
 const LABEL = "dev.machine-bridge-mcp.daemon";
 const WINDOWS_TASK = "MachineBridgeMCP";
 
-export async function installAutostart({ workspace, stateRoot, entryScript, policy, logger = console }) {
-  const spec = serviceSpec({ workspace, stateRoot, entryScript, policy });
+export async function installAutostart({ workspace, stateRoot, entryScript, logger = console }) {
+  const spec = serviceSpec({ workspace, stateRoot, entryScript });
   if (process.platform === "darwin") return installLaunchd(spec, logger);
   if (process.platform === "win32") return installWindowsTask(spec, logger);
   return installSystemd(spec, logger);
@@ -65,7 +65,7 @@ export function trimAutostartLogs(stateRoot, options = {}) {
   }
 }
 
-function serviceSpec({ workspace, stateRoot, entryScript, policy = {} }) {
+function serviceSpec({ workspace, stateRoot, entryScript }) {
   const root = expandHome(stateRoot);
   const logs = path.join(root, "logs");
   ensureOwnerOnlyDir(root);
@@ -81,17 +81,11 @@ function serviceSpec({ workspace, stateRoot, entryScript, policy = {} }) {
     node: process.execPath,
     stdout: path.join(logs, "daemon.out.log"),
     stderr: path.join(logs, "daemon.err.log"),
-    policy: {
-      allowWrite: policy.allowWrite !== false,
-      allowExec: policy.allowExec !== false,
-      minimalEnv: policy.minimalEnv !== false,
-      unrestrictedPaths: policy.unrestrictedPaths === true,
-    },
   };
 }
 
-function daemonArgs(spec) {
-  const args = [
+export function daemonArgs(spec) {
+  return [
     spec.entryScript,
     "start",
     "--daemon-only",
@@ -100,11 +94,6 @@ function daemonArgs(spec) {
     "--no-print-credentials",
     "--quiet",
   ];
-  if (spec.policy.allowWrite === false) args.push("--no-write");
-  if (spec.policy.allowExec === false) args.push("--no-exec");
-  if (spec.policy.minimalEnv === false) args.push("--full-env");
-  if (spec.policy.unrestrictedPaths === true) args.push("--unrestricted-paths");
-  return args;
 }
 
 function launchdPlistPath() {

package/src/local/shell.mjs

@@ -111,12 +111,29 @@ export function workspaceShellCommand(command) {
 }
 
 export function executionEnv(workspace, options = {}) {
-  // Keep environment small to avoid accidental dependence on the launching shell,
-  // but do not hide filesystem contents. Operators can opt into full env when desired.
+  // Minimal mode deliberately replaces user home/temp/cache locations so common
+  // toolchains do not inherit credential-bearing configuration by accident.
   if (options.fullEnv || process.env.MBM_PASS_ENV === "true") return { ...process.env, MBM_WORKSPACE: workspace };
-  const allowed = ["PATH", "HOME", "USER", "LOGNAME", "SHELL", "LANG", "LC_ALL", "LC_CTYPE", "TMPDIR", "TMP", "TEMP", "SystemRoot", "WINDIR"];
-  const env = { MBM_WORKSPACE: workspace };
-  for (const key of allowed) if (process.env[key]) env[key] = process.env[key];
+  const runtimeDir = options.runtimeDir ? path.resolve(String(options.runtimeDir)) : "";
+  if (!runtimeDir) throw new Error("minimal execution environment requires a runtime directory");
+  const runtimeHome = path.join(runtimeDir, "home");
+  const runtimeTmp = path.join(runtimeDir, "tmp");
+  const runtimeCache = path.join(runtimeDir, "cache");
+  const env = {
+    MBM_WORKSPACE: workspace,
+    HOME: runtimeHome,
+    USERPROFILE: runtimeHome,
+    TMPDIR: runtimeTmp,
+    TMP: runtimeTmp,
+    TEMP: runtimeTmp,
+    XDG_CACHE_HOME: runtimeCache,
+    npm_config_cache: path.join(runtimeCache, "npm"),
+    PIP_CACHE_DIR: path.join(runtimeCache, "pip"),
+    CARGO_HOME: path.join(runtimeCache, "cargo"),
+  };
+  for (const key of ["PATH", "LANG", "LC_ALL", "LC_CTYPE", "SystemRoot", "WINDIR", "COMSPEC", "PATHEXT"]) {
+    if (process.env[key]) env[key] = process.env[key];
+  }
   if (!env.PATH) env.PATH = process.env.PATH || "/usr/local/bin:/opt/homebrew/bin:/usr/bin:/bin:/usr/sbin:/sbin";
   return env;
 }

package/src/local/state.mjs

@@ -96,7 +96,7 @@ export function loadState(workspace, options = {}) {
     ownerOnlyFile(statePath);
     state = readJsonObjectOrBackup(statePath);
   }
-  state.schemaVersion = 2;
+  state.schemaVersion = 3;
   state.workspace = {
     path: workspace,
     hash: workspaceHash(workspace),