machine-bridge-mcp 0.6.2 → 0.8.0

package/src/local/full-access-test.mjs

@@ -2,7 +2,7 @@ import { chmod, mkdtemp, readFile, realpath, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join, resolve } from "node:path";
 import process from "node:process";
-import { LocalDaemon } from "./daemon.mjs";
+import { LocalRuntime } from "./runtime.mjs";
 import { generateSshKeyPair } from "./ssh-key.mjs";
 import { run } from "./shell.mjs";
 import { allToolNames, assertCanonicalFullPolicy, policyProfile } from "./tools.mjs";
@@ -29,7 +29,7 @@ export async function runFullAccessTest({ workspace, policy = policyProfile("ful
   let runtime;
 
   try {
-    runtime = new LocalDaemon({
+    runtime = new LocalRuntime({
       workspace: resolve(workspace),
       policy: canonicalPolicy,
       jobRoot,

package/src/local/job-runner.mjs

@@ -1,10 +1,11 @@
 import { spawn } from "node:child_process";
 import { createHash, randomBytes } from "node:crypto";
-import { chmodSync, closeSync, constants as fsConstants, existsSync, fstatSync, mkdirSync, openSync, readSync, rmSync, writeFileSync } from "node:fs";
+import { chmodSync, closeSync, existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { basename, dirname, join, resolve } from "node:path";
 import { executionEnv } from "./shell.mjs";
 import { terminateProcessTree } from "./process-sessions.mjs";
 import { replaceFileSync } from "./atomic-fs.mjs";
+import { readBoundedRegularFileSync } from "./secure-file.mjs";
 
 const RESOURCE_TOKEN = /\{\{resource:([a-z][a-z0-9._-]{0,63})\}\}/g;
 const TEMP_TOKEN = /\{\{temp:([a-z][a-z0-9._-]{0,63})\}\}/g;
@@ -13,10 +14,13 @@ const MAX_OUTPUT_BYTES = 64 * 1024;
 const MAX_JOB_CAPTURE_BYTES = 256 * 1024;
 const MAX_RESULT_BYTES = 4 * 1024 * 1024;
 const MAX_STATUS_BYTES = 256 * 1024;
+const JOB_ID = /^job_[A-Za-z0-9_-]{24,}$/;
 
 const options = parseArgs(process.argv.slice(2));
-const jobDir = resolve(options.jobDir || "");
-if (!jobDir) throw new Error("--job-dir is required");
+const jobDirInput = typeof options.jobDir === "string" ? options.jobDir.trim() : "";
+if (!jobDirInput) throw new Error("--job-dir is required");
+const jobDir = resolve(jobDirInput);
+if (!JOB_ID.test(basename(jobDir))) throw new Error("--job-dir must name a managed job directory");
 const recover = options.recover === true;
 const planFile = join(jobDir, "plan.json");
 const statusFile = join(jobDir, "status.json");
@@ -43,17 +47,19 @@ for (const signal of ["SIGTERM", "SIGINT"]) {
   process.on(signal, () => requestCancellation());
 }
 
-writeFileSync(runnerPidFile, `${process.pid}\n`, { mode: 0o600 });
+const initial = readJson(statusFile, MAX_STATUS_BYTES);
+assertLaunchState(initial);
+writeFileSync(runnerPidFile, `${process.pid}\n`, { mode: 0o600, flag: "wx" });
 if (recover) rmSync(join(jobDir, "recovery.lock"), { force: true });
 try {
-  await main();
+  const plan = readJson(planFile, 1024 * 1024);
+  assertPlanIntegrity(plan, initial);
+  await main(plan, initial);
 } catch (error) {
   recordFatalRunnerError(error);
 }
 
-async function main() {
-  const plan = readJson(planFile, 1024 * 1024);
-  const initial = readJson(statusFile, MAX_STATUS_BYTES);
+async function main(plan, initial) {
   const status = {
     ...initial,
     runner_pid: process.pid,
@@ -137,6 +143,20 @@ async function main() {
   try { rmSync(cancelFile, { force: true }); } catch {}
 }
 
+function assertLaunchState(status) {
+  if (!status || typeof status !== "object" || Array.isArray(status)) throw new Error("job status is unavailable or invalid");
+  const expected = recover ? "interrupted" : "queued";
+  if (status.status !== expected) throw new Error(`runner cannot start job in status: ${status.status}`);
+  if (status.approval === "pending-local-operator" || !status.approval) throw new Error("runner cannot start an unapproved managed job");
+}
+
+function assertPlanIntegrity(plan, status) {
+  if (!plan || typeof plan !== "object" || Array.isArray(plan)) throw new Error("job plan is unavailable or invalid");
+  const expected = String(status?.plan_sha256 || "");
+  const actual = createHash("sha256").update(JSON.stringify(plan)).digest("hex");
+  if (!/^[a-f0-9]{64}$/.test(expected) || actual !== expected) throw new Error("managed job plan integrity check failed");
+}
+
 function recordFatalRunnerError(error) {
   rmSync(runtimeDir, { recursive: true, force: true });
   const now = new Date().toISOString();
@@ -234,11 +254,12 @@ function spawnStep(argv, { cwd, env, input, timeoutMs, cancellationAware, captur
     let stderrTruncated = 0;
     let timedOut = false;
     let closed = false;
+    let killTimer = null;
     const timer = setTimeout(() => {
       timedOut = true;
       terminateProcessTree(child, "SIGTERM");
-      const kill = setTimeout(() => terminateProcessTree(child, "SIGKILL"), 2000);
-      kill.unref?.();
+      killTimer = setTimeout(() => terminateProcessTree(child, "SIGKILL"), 2000);
+      killTimer.unref?.();
     }, timeoutMs);
     timer.unref?.();
     const cancellationPoll = setInterval(() => {
@@ -279,6 +300,7 @@ function spawnStep(argv, { cwd, env, input, timeoutMs, cancellationAware, captur
       if (closed) return;
       closed = true;
       clearTimeout(timer);
+      if (killTimer) clearTimeout(killTimer);
       clearInterval(cancellationPoll);
       activeChild = null;
       activeChildCancellationAware = false;
@@ -293,6 +315,7 @@ function materializeResources(resources) {
   mkdirSync(resourcesDir, { recursive: true, mode: 0o700 });
   chmodSync(resourcesDir, 0o700);
   const paths = {};
+  const sourcePaths = {};
   const bytes = {};
   const redactions = {};
   for (const [name, resource] of Object.entries(resources)) {
@@ -303,6 +326,10 @@ function materializeResources(resources) {
     const target = join(resourcesDir, name);
     writeFileSync(target, data, { mode: 0o600, flag: "wx" });
     paths[name] = target;
+    sourcePaths[name] = [...new Set([
+      ...resourcePathVariants(resource.path),
+      ...(Array.isArray(resource.pathAliases) ? resource.pathAliases.flatMap(resourcePathVariants) : []),
+    ])].sort((left, right) => right.length - left.length);
     bytes[name] = data;
     const patterns = [];
     try {
@@ -316,7 +343,7 @@ function materializeResources(resources) {
     }
     redactions[name] = [...new Set(patterns.filter((value) => value.length > 0))].sort((a, b) => b.length - a.length);
   }
-  return { paths, bytes, redactions };
+  return { paths, sourcePaths, bytes, redactions };
 }
 
 function materializeTemporaryFiles(files) {
@@ -366,15 +393,46 @@ function substitute(value, plan, context) {
     });
 }
 
+function resourcePathVariants(value) {
+  const canonical = resolve(value);
+  const variants = new Set(pathTextVariants(canonical));
+  if (process.platform === "darwin" && canonical.startsWith("/private/")) {
+    for (const variant of pathTextVariants(canonical.slice("/private".length))) variants.add(variant);
+  }
+  return [...variants].sort((left, right) => right.length - left.length);
+}
+
+function pathTextVariants(value) {
+  const path = String(value);
+  return [...new Set([path, path.replaceAll("\\", "/"), path.replaceAll("/", "\\")])];
+}
+
+function replacePathText(text, value, replacement) {
+  let output = text;
+  for (const variant of pathTextVariants(value)) {
+    if (!variant) continue;
+    if (process.platform === "win32") output = output.replace(new RegExp(escapeRegExp(variant), "gi"), replacement);
+    else output = output.split(variant).join(replacement);
+  }
+  return output;
+}
+
+function escapeRegExp(value) {
+  return String(value).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
 function redactOutput(buffer, context) {
   let text = new TextDecoder("utf-8").decode(buffer);
   for (const [name, path] of Object.entries(context.paths)) {
-    text = text.split(path).join(`<resource:${name}>`);
+    text = replacePathText(text, path, `<resource:${name}>`);
+  }
+  for (const [name, paths] of Object.entries(context.sourcePaths || {})) {
+    for (const path of paths) text = replacePathText(text, path, `<resource-source:${name}>`);
   }
   for (const [name, path] of Object.entries(context.temporaryPaths)) {
-    text = text.split(path).join(`<temp:${name}>`);
+    text = replacePathText(text, path, `<temp:${name}>`);
   }
-  text = text.split(runtimeDir).join("<job-runtime>");
+  text = replacePathText(text, runtimeDir, "<job-runtime>");
   for (const [name, patterns] of Object.entries(context.redactions)) {
     for (const value of patterns) text = text.split(value).join(`<redacted-resource:${name}>`);
   }
@@ -429,23 +487,7 @@ function readJson(file, maxBytes) {
 }
 
 function readBoundedFile(file, maxBytes) {
-  const flags = Number(fsConstants.O_RDONLY) | Number(fsConstants.O_NOFOLLOW || 0);
-  const fd = openSync(file, flags);
-  try {
-    const info = fstatSync(fd);
-    if (!info.isFile()) throw new Error("path is not a regular file");
-    if (info.size > maxBytes) throw new Error(`file exceeds ${maxBytes} bytes`);
-    const buffer = Buffer.alloc(info.size);
-    let offset = 0;
-    while (offset < buffer.length) {
-      const count = readSync(fd, buffer, offset, buffer.length - offset, offset);
-      if (!count) break;
-      offset += count;
-    }
-    return buffer.subarray(0, offset);
-  } finally {
-    closeSync(fd);
-  }
+  return readBoundedRegularFileSync(file, maxBytes);
 }
 
 function classifyError(error) {

package/src/local/log.mjs

@@ -1,4 +1,5 @@
 import process from "node:process";
+import os from "node:os";
 
 const COLORS = {
   reset: "\x1b[0m",
@@ -15,8 +16,16 @@ const MAX_LOG_ARRAY_ITEMS = 32;
 const MAX_LOG_OBJECT_KEYS = 48;
 const LEVEL_RANK = Object.freeze({ debug: 10, info: 20, success: 20, warn: 30, error: 40 });
 const SENSITIVE_KEY = /(authorization|cookie|password|passwd|secret|token|api[_-]?key|private[_-]?key|credential)/i;
+const LOCAL_PATH_KEY = /(path|paths|cwd|workspace|directory|(?:^|[_-])dir(?:$|[_-])|root|home)/i;
 const SECRET_VALUE = /\b(?:mcp_password|daemon_secret|token_version|mcp_at|mcp_code)_[A-Za-z0-9_-]+\b/g;
 const BEARER_VALUE = /\bBearer\s+[A-Za-z0-9._~+\/-]+=*\b/gi;
+const EMAIL_VALUE = /\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b/gi;
+const AWS_ACCESS_KEY = /\b(?:AKIA|ASIA)[A-Z0-9]{16}\b/g;
+const GITHUB_TOKEN = /\bgh[pousr]_[A-Za-z0-9_]{30,}\b/g;
+const API_SECRET = /\bsk-(?:proj-)?[A-Za-z0-9_-]{20,}\b/g;
+const PRIVATE_KEY_HEADER = /-----BEGIN\s+(?:OPENSSH|RSA|EC|DSA)\s+PRIVATE\s+KEY-----/g;
+const HOME_PATHS = [...new Set([process.env.HOME, process.env.USERPROFILE, safeHomeDirectory()].filter(value => typeof value === "string" && value.length > 1))]
+  .sort((left, right) => right.length - left.length);
 
 export function createLogger(options = {}) {
   const quiet = Boolean(options.quiet);
@@ -62,6 +71,8 @@ export function classifyOperationalError(error) {
   const message = error instanceof Error ? error.message : String(error ?? "");
   if (/cancel/i.test(message)) return "cancelled";
   if (/timed out/i.test(message)) return "timeout";
+  if (/unauthorized|forbidden|authentication|\b401\b|\b403\b/i.test(message)) return "authentication_failed";
+  if (/ECONNRESET|ECONNREFUSED|ETIMEDOUT|EHOSTUNREACH|ENETUNREACH|ENOTFOUND|EAI_AGAIN|socket hang up|network|websocket|TLS|SSL/i.test(message)) return "network_error";
   if (/outside the configured workspace/i.test(message)) return "path_boundary";
   if (/disabled|requires .* mode/i.test(message)) return "policy_denied";
   if (/not found|ENOENT/i.test(message)) return "not_found";
@@ -86,8 +97,9 @@ export function formatFields(fields) {
   }
 }
 
-export function sanitizeLogValue(value, key = "", seen = new WeakSet(), depth = 0) {
+function sanitizeLogValue(value, key = "", seen = new WeakSet(), depth = 0) {
   if (SENSITIVE_KEY.test(key)) return "<redacted>";
+  if (LOCAL_PATH_KEY.test(key)) return "<local-path>";
   if (value instanceof Error) return sanitizeLogText(value.message || value.name);
   if (typeof value === "string") return sanitizeLogText(value);
   if (typeof value === "bigint") return value.toString();
@@ -106,9 +118,19 @@ export function sanitizeLogValue(value, key = "", seen = new WeakSet(), depth =
 export function sanitizeLogText(value, maxChars = MAX_LOG_MESSAGE_CHARS) {
   let raw;
   try { raw = String(value ?? ""); } catch { raw = "<unprintable>"; }
-  const sanitized = raw
+  let sanitized = raw
     .replace(SECRET_VALUE, "<redacted-secret>")
     .replace(BEARER_VALUE, "Bearer <redacted>")
+    .replace(AWS_ACCESS_KEY, "<redacted-cloud-key>")
+    .replace(GITHUB_TOKEN, "<redacted-access-token>")
+    .replace(API_SECRET, "<redacted-api-secret>")
+    .replace(PRIVATE_KEY_HEADER, "<redacted-private-key-header>")
+    .replace(EMAIL_VALUE, "<redacted-email>");
+  for (const home of HOME_PATHS) sanitized = sanitized.split(home).join("<home>");
+  sanitized = sanitized
+    .replace(/\/(?:Users|home)\/[^/\s"'<>]+(?=\/|$)/g, "<home>")
+    .replace(/\b[A-Za-z]:\\Users\\[^\\\s"'<>]+(?=\\|$)/g, "<home>")
+    .replace(/[\u200B-\u200F\u202A-\u202E\u2066-\u2069\uFEFF]/g, "")
     .replace(/[\r\n\t]/g, match => match === "\t" ? "\\t" : "\\n")
     .replace(/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/g, "?");
   if (!Number.isFinite(Number(maxChars)) || Number(maxChars) <= 0) return "";
@@ -116,6 +138,10 @@ export function sanitizeLogText(value, maxChars = MAX_LOG_MESSAGE_CHARS) {
   return sanitized.length > limit ? `${sanitized.slice(0, limit - 1)}…` : sanitized;
 }
 
+function safeHomeDirectory() {
+  try { return os.homedir(); } catch { return ""; }
+}
+
 function shouldUseColor(options) {
   if (options.color === false || process.env.NO_COLOR) return false;
   if (options.color === true) return true;