machine-bridge-mcp 0.15.0 → 0.16.1

package/src/local/process-execution.mjs

@@ -0,0 +1,153 @@
+import { spawn } from "node:child_process";
+import { stat } from "node:fs/promises";
+import { executionEnv, workspaceShellCommand } from "./shell.mjs";
+import { MAX_COMMAND_BYTES, terminateProcessTreeWithEscalation, validateArgv } from "./process-sessions.mjs";
+import { BridgeError } from "./errors.mjs";
+
+const MAX_STDIN_BYTES = 1024 * 1024;
+const DEFAULT_OUTPUT_BYTES = 512 * 1024;
+
+export class ProcessExecutionService {
+  constructor({ workspace, policy, policyGate, runtimeDir, processTracker, resolveExistingPath, resolveLocalCommand, displayPath, throwIfCancelled }) {
+    this.workspace = workspace;
+    this.policy = policy;
+    this.policyGate = policyGate;
+    this.runtimeDir = runtimeDir;
+    this.processTracker = processTracker;
+    this.resolveExistingPath = resolveExistingPath;
+    this.resolveLocalCommand = resolveLocalCommand;
+    this.displayPath = displayPath;
+    this.throwIfCancelled = throwIfCancelled;
+  }
+
+  async runDirect(args, context = {}) {
+    this.policyGate.assert("run_process");
+    const argv = validateArgv(args.argv);
+    const cwd = await this.resolveExistingPath(args.cwd || ".");
+    if (!(await stat(cwd)).isDirectory()) throw new BridgeError("invalid_request", "cwd is not a directory");
+    return this.run(argv[0], argv.slice(1), clampInt(args.timeout_seconds, 120, 1, 600) * 1000, false, DEFAULT_OUTPUT_BYTES, context, cwd);
+  }
+
+  async runRegistered(args, context = {}) {
+    this.policyGate.assert("run_local_command");
+    const command = await this.resolveLocalCommand(args, context);
+    const argv = validateArgv(command.argv);
+    const cwd = await this.resolveExistingPath(command.cwd);
+    if (!(await stat(cwd)).isDirectory()) throw new BridgeError("invalid_request", "registered command cwd is not a directory");
+    const requested = args.timeout_seconds === undefined
+      ? command.timeoutSeconds
+      : clampInt(args.timeout_seconds, command.timeoutSeconds, 1, 600);
+    const timeoutSeconds = Math.min(requested, command.timeoutSeconds);
+    const result = await this.run(argv[0], argv.slice(1), timeoutSeconds * 1000, false, DEFAULT_OUTPUT_BYTES, context, cwd);
+    return { name: command.name, cwd: this.displayPath(cwd), timeout_seconds: timeoutSeconds, ...result };
+  }
+
+  async probeShell(context = {}) {
+    const shell = workspaceShellCommand(process.platform === "win32" ? "cd" : "pwd");
+    return this.run(shell.cmd, shell.args, 5000, true, 64 * 1024, context);
+  }
+
+  async runShell(command, timeoutSeconds, context = {}) {
+    this.policyGate.assert("exec_command");
+    if (!command || typeof command !== "string") throw new BridgeError("invalid_request", "command is required");
+    if (command.includes("\0")) throw new BridgeError("invalid_request", "command contains a NUL byte");
+    if (Buffer.byteLength(command) > MAX_COMMAND_BYTES) throw new BridgeError("limit_exceeded", `command exceeds maximum size (${MAX_COMMAND_BYTES} bytes)`);
+    const shell = workspaceShellCommand(command);
+    return this.run(shell.cmd, shell.args, clampInt(timeoutSeconds, 120, 1, 600) * 1000, false, DEFAULT_OUTPUT_BYTES, context);
+  }
+
+  terminateAll(signal = "SIGTERM", escalate = false) {
+    this.processTracker.terminateAll(signal, escalate);
+  }
+
+  async run(cmd, args, timeoutMs, allowFailure = false, maxOutputBytes = DEFAULT_OUTPUT_BYTES, context = {}, cwd = this.workspace, stdin = null) {
+    this.throwIfCancelled(context);
+    if (stdin !== null && Buffer.byteLength(String(stdin)) > MAX_STDIN_BYTES) {
+      throw new BridgeError("limit_exceeded", "process stdin exceeds 1 MiB");
+    }
+    return new Promise((resolvePromise, rejectPromise) => {
+      const child = spawn(cmd, args, {
+        cwd,
+        env: executionEnv(this.workspace, { fullEnv: this.policy.minimalEnv === false, runtimeDir: this.runtimeDir }),
+        detached: process.platform !== "win32",
+        windowsHide: true,
+      });
+      this.processTracker.track(child, context.callId);
+      if (stdin !== null) {
+        child.stdin.on("error", () => {});
+        child.stdin.end(String(stdin));
+      }
+      let stdout = "";
+      let stderr = "";
+      let stdoutTruncated = 0;
+      let stderrTruncated = 0;
+      let timedOut = false;
+      let settled = false;
+      let killTimer = null;
+      const timer = setTimeout(() => {
+        timedOut = true;
+        killTimer = terminateProcessTreeWithEscalation(child);
+      }, timeoutMs);
+      timer.unref?.();
+      const cleanup = () => {
+        clearTimeout(timer);
+        if (killTimer && !timedOut) clearTimeout(killTimer);
+        this.processTracker.untrack(child);
+      };
+      const finish = (callback) => {
+        if (settled) return;
+        settled = true;
+        cleanup();
+        callback();
+      };
+      child.stdout.on("data", (chunk) => {
+        const next = appendLimited(stdout, chunk, maxOutputBytes);
+        stdout = next.value;
+        stdoutTruncated += next.truncated;
+      });
+      child.stderr.on("data", (chunk) => {
+        const next = appendLimited(stderr, chunk, maxOutputBytes);
+        stderr = next.value;
+        stderrTruncated += next.truncated;
+      });
+      child.on("error", (error) => finish(() => {
+        if (allowFailure) resolvePromise({ code: 127, stdout: finalizeOutput(stdout, stdoutTruncated), stderr: boundedErrorMessage(error) });
+        else rejectPromise(error);
+      }));
+      child.on("close", (code) => finish(() => {
+        const result = { code, stdout: finalizeOutput(stdout, stdoutTruncated), stderr: finalizeOutput(stderr, stderrTruncated) };
+        try { this.throwIfCancelled(context); } catch (error) { rejectPromise(error); return; }
+        if (timedOut) {
+          rejectPromise(new BridgeError("timeout", `command timed out after ${timeoutMs}ms`, { retryable: true }));
+          return;
+        }
+        if (code === 0 || allowFailure) resolvePromise(result);
+        else rejectPromise(new BridgeError("execution_failed", stderr.trim() || stdout.trim() || `${cmd} exited ${code}`));
+      }));
+    });
+  }
+}
+
+export function boundedErrorMessage(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return message.replace(/[\r\n]+/g, " ").slice(0, 4096) || "tool call failed";
+}
+
+function appendLimited(current, chunk, maximum) {
+  const text = String(chunk || "");
+  const budget = Math.max(0, maximum - Buffer.byteLength(current));
+  const textBytes = Buffer.byteLength(text);
+  if (textBytes <= budget) return { value: current + text, truncated: 0 };
+  const slice = Buffer.from(text).subarray(0, budget).toString();
+  return { value: current + slice, truncated: textBytes - Buffer.byteLength(slice) };
+}
+
+function finalizeOutput(value, truncated) {
+  return truncated > 0 ? `${value}\n\n[truncated ${truncated} bytes]` : value;
+}
+
+function clampInt(value, fallback, minimum, maximum) {
+  const parsed = Number.parseInt(String(value ?? ""), 10);
+  const number = Number.isFinite(parsed) ? parsed : fallback;
+  return Math.min(Math.max(number, minimum), maximum);
+}

package/src/local/process-sessions.mjs

@@ -2,6 +2,7 @@ import { spawn } from "node:child_process";
 import { randomBytes } from "node:crypto";
 import { basename } from "node:path";
 import { executionEnv } from "./shell.mjs";
+import { createToolAuthorizer } from "./policy.mjs";
 
 export const MAX_COMMAND_BYTES = 64 * 1024;
 const MAX_ARGV_ITEMS = 256;
@@ -11,12 +12,12 @@ const MAX_PROCESS_STDIN_BYTES = 64 * 1024;
 const PROCESS_SESSION_RETENTION_MS = 30 * 60 * 1000;
 
 export class ProcessSessionManager {
-  constructor({ workspace, policy, runtimeDir, activeProcesses, callProcesses, resolveCwd, displayPath, throwIfCancelled }) {
+  constructor({ workspace, policy, authorizeTool = null, runtimeDir, processTracker, resolveCwd, displayPath, throwIfCancelled }) {
     this.workspace = workspace;
     this.policy = policy;
+    this.authorizeTool = createToolAuthorizer(this.policy, authorizeTool);
     this.runtimeDir = runtimeDir;
-    this.activeProcesses = activeProcesses;
-    this.callProcesses = callProcesses;
+    this.processTracker = processTracker;
     this.resolveCwd = resolveCwd;
     this.displayPath = displayPath;
     this.throwIfCancelled = throwIfCancelled;
@@ -40,7 +41,7 @@ export class ProcessSessionManager {
   }
 
   async start(args, context = {}) {
-    this.assertEnabled("start_process");
+    this.authorizeTool("start_process");
     const argv = validateArgv(args.argv);
     const cwd = await this.resolveCwd(args.cwd || ".");
     this.prune();
@@ -109,7 +110,7 @@ export class ProcessSessionManager {
   }
 
   async read(args, context = {}) {
-    this.assertEnabled("read_process");
+    this.authorizeTool("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);
@@ -137,7 +138,7 @@ export class ProcessSessionManager {
   }
 
   async write(args, context = {}) {
-    this.assertEnabled("write_process");
+    this.authorizeTool("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 ?? "");
@@ -158,7 +159,7 @@ export class ProcessSessionManager {
   }
 
   async kill(args, context = {}) {
-    this.assertEnabled("kill_process");
+    this.authorizeTool("kill_process");
     const session = this.get(args.session_id);
     this.throwIfCancelled(context);
     const wasRunning = session.closedAt === null;
@@ -207,24 +208,13 @@ export class ProcessSessionManager {
     }
   }
 
-  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);
+    this.processTracker.track(child, callId);
   }
 
   untrackChild(child) {
-    this.activeProcesses.delete(child);
-    for (const [callId, set] of this.callProcesses) {
-      set.delete(child);
-      if (!set.size) this.callProcesses.delete(callId);
-    }
+    this.processTracker.untrack(child);
   }
 }
 

package/src/local/process-tracker.mjs

@@ -0,0 +1,55 @@
+import { terminateProcessTree, terminateProcessTreeWithEscalation } from "./process-sessions.mjs";
+
+export class ProcessTracker {
+  constructor(options = {}) {
+    this.terminate = typeof options.terminate === "function" ? options.terminate : terminateProcessTree;
+    this.terminateWithEscalation = typeof options.terminateWithEscalation === "function"
+      ? options.terminateWithEscalation
+      : terminateProcessTreeWithEscalation;
+    this.active = new Set();
+    this.byCall = new Map();
+  }
+
+  track(child, callId = "") {
+    if (!child) return;
+    this.active.add(child);
+    if (!callId) return;
+    const id = String(callId);
+    const children = this.byCall.get(id) || new Set();
+    children.add(child);
+    this.byCall.set(id, children);
+  }
+
+  untrack(child) {
+    if (!child) return;
+    this.active.delete(child);
+    for (const [callId, children] of this.byCall) {
+      children.delete(child);
+      if (!children.size) this.byCall.delete(callId);
+    }
+  }
+
+  releaseCall(callId) {
+    if (callId) this.byCall.delete(String(callId));
+  }
+
+  terminateCall(callId, { force = false } = {}) {
+    const children = [...(this.byCall.get(String(callId || "")) || [])];
+    for (const child of children) {
+      if (force) this.terminate(child, "SIGKILL");
+      else this.terminateWithEscalation(child);
+    }
+    return children.length;
+  }
+
+  terminateAll(signal = "SIGTERM", escalate = false) {
+    for (const child of [...this.active]) {
+      if (escalate && signal !== "SIGKILL") this.terminateWithEscalation(child);
+      else this.terminate(child, signal);
+    }
+  }
+
+  snapshot() {
+    return { active_processes: this.active.size, calls_with_processes: this.byCall.size };
+  }
+}