machine-bridge-mcp 0.4.2 → 0.6.0

package/src/local/service.mjs

@@ -6,6 +6,15 @@ import { ensureOwnerOnlyDir, expandHome } from "./state.mjs";
 
 const LABEL = "dev.machine-bridge-mcp.daemon";
 const WINDOWS_TASK = "MachineBridgeMCP";
+const SERVICE_COMMAND_OUTPUT_BYTES = 64 * 1024;
+
+function serviceRun(command, args) {
+  return run(command, args, {
+    capture: true,
+    allowFailure: true,
+    maxOutputBytes: SERVICE_COMMAND_OUTPUT_BYTES,
+  });
+}
 
 export async function installAutostart({ workspace, stateRoot, entryScript, logger = console }) {
   const spec = serviceSpec({ workspace, stateRoot, entryScript });
@@ -28,14 +37,14 @@ export async function autostartStatus({ logger = console } = {}) {
 
 export async function startAutostart({ logger = console } = {}) {
   if (process.platform === "darwin") return startLaunchd(logger);
-  if (process.platform === "win32") return run("schtasks", ["/Run", "/TN", WINDOWS_TASK], { capture: true, allowFailure: true });
-  return run("systemctl", ["--user", "start", "machine-bridge-mcp.service"], { capture: true, allowFailure: true });
+  if (process.platform === "win32") return serviceRun("schtasks", ["/Run", "/TN", WINDOWS_TASK]);
+  return serviceRun("systemctl", ["--user", "start", "machine-bridge-mcp.service"]);
 }
 
 export async function stopAutostart({ logger = console } = {}) {
   if (process.platform === "darwin") return stopLaunchd(logger);
-  if (process.platform === "win32") return run("schtasks", ["/End", "/TN", WINDOWS_TASK], { capture: true, allowFailure: true });
-  return run("systemctl", ["--user", "stop", "machine-bridge-mcp.service"], { capture: true, allowFailure: true });
+  if (process.platform === "win32") return serviceRun("schtasks", ["/End", "/TN", WINDOWS_TASK]);
+  return serviceRun("systemctl", ["--user", "stop", "machine-bridge-mcp.service"]);
 }
 
 
@@ -50,21 +59,31 @@ export function trimAutostartLogs(stateRoot, options = {}) {
       const info = statSync(file);
       if (info.size > maxBytes) {
         const fd = openSync(file, "r");
+        let buffer;
         try {
           const current = fstatSync(fd);
           const length = Math.min(keepBytes, current.size);
-          const buffer = Buffer.alloc(length);
+          buffer = Buffer.alloc(length);
           readSync(fd, buffer, 0, length, Math.max(0, current.size - length));
-          writeFileSync(file, buffer, { mode: 0o600 });
         } finally {
           closeSync(fd);
         }
+        writeFileSync(file, lineSafeTail(buffer), { mode: 0o600 });
       }
       chmodSync(file, 0o600);
     } catch {}
   }
 }
 
+function lineSafeTail(buffer) {
+  if (!Buffer.isBuffer(buffer) || buffer.length === 0) return Buffer.alloc(0);
+  let text = buffer.toString("utf8");
+  const firstNewline = text.indexOf("\n");
+  if (firstNewline >= 0 && firstNewline < text.length - 1) text = text.slice(firstNewline + 1);
+  else text = text.replace(/^\uFFFD+/, "");
+  return Buffer.from(text, "utf8");
+}
+
 function serviceSpec({ workspace, stateRoot, entryScript }) {
   const root = expandHome(stateRoot);
   const logs = path.join(root, "logs");
@@ -92,7 +111,7 @@ export function daemonArgs(spec) {
     "--workspace", spec.workspace,
     "--state-dir", spec.stateRoot,
     "--no-print-credentials",
-    "--quiet",
+    "--log-level", "warn",
   ];
 }
 
@@ -113,9 +132,9 @@ async function startLaunchd(logger) {
   const plistPath = launchdPlistPath();
   const target = `gui/${process.getuid?.() ?? ""}`;
   if (!existsSync(plistPath)) return { ok: false, error: "launchd plist not installed" };
-  await run("launchctl", ["bootout", target, plistPath], { capture: true, allowFailure: true });
-  const boot = await run("launchctl", ["bootstrap", target, plistPath], { capture: true, allowFailure: true });
-  const kick = await run("launchctl", ["kickstart", "-k", `${target}/${LABEL}`], { capture: true, allowFailure: true });
+  await serviceRun("launchctl", ["bootout", target, plistPath]);
+  const boot = await serviceRun("launchctl", ["bootstrap", target, plistPath]);
+  const kick = await serviceRun("launchctl", ["kickstart", "-k", `${target}/${LABEL}`]);
   logger.info?.("launchd service started");
   return { ok: boot.code === 0 || kick.code === 0, bootstrap: boot, kickstart: kick };
 }
@@ -123,7 +142,7 @@ async function startLaunchd(logger) {
 async function stopLaunchd(logger) {
   const plistPath = launchdPlistPath();
   const target = `gui/${process.getuid?.() ?? ""}`;
-  const result = await run("launchctl", ["bootout", target, plistPath], { capture: true, allowFailure: true });
+  const result = await serviceRun("launchctl", ["bootout", target, plistPath]);
   logger.info?.("launchd service stopped");
   return result;
 }
@@ -139,7 +158,7 @@ async function uninstallLaunchd(logger) {
 async function statusLaunchd() {
   const plistPath = launchdPlistPath();
   const target = `gui/${process.getuid?.() ?? ""}/${LABEL}`;
-  const result = await run("launchctl", ["print", target], { capture: true, allowFailure: true });
+  const result = await serviceRun("launchctl", ["print", target]);
   return { ok: existsSync(plistPath), provider: "launchd", installed: existsSync(plistPath), path: plistPath, active: result.code === 0, detail: result.stdout || result.stderr };
 }
 
@@ -173,25 +192,25 @@ async function installSystemd(spec, logger) {
   const servicePath = systemdPath();
   mkdirSync(path.dirname(servicePath), { recursive: true });
   writeFileSync(servicePath, systemdUnit(spec), { mode: 0o644 });
-  const reload = await run("systemctl", ["--user", "daemon-reload"], { capture: true, allowFailure: true });
-  const enable = await run("systemctl", ["--user", "enable", "machine-bridge-mcp.service"], { capture: true, allowFailure: true });
-  const linger = await run("loginctl", ["enable-linger", os.userInfo().username], { capture: true, allowFailure: true });
+  const reload = await serviceRun("systemctl", ["--user", "daemon-reload"]);
+  const enable = await serviceRun("systemctl", ["--user", "enable", "machine-bridge-mcp.service"]);
+  const linger = await serviceRun("loginctl", ["enable-linger", os.userInfo().username]);
   logger.info?.(`Autostart installed: ${servicePath}`);
   return { ok: reload.code === 0 && enable.code === 0, provider: "systemd", path: servicePath, reload, enable, linger };
 }
 
 async function uninstallSystemd(logger) {
-  await run("systemctl", ["--user", "disable", "--now", "machine-bridge-mcp.service"], { capture: true, allowFailure: true });
+  await serviceRun("systemctl", ["--user", "disable", "--now", "machine-bridge-mcp.service"]);
   const servicePath = systemdPath();
   if (existsSync(servicePath)) rmSync(servicePath, { force: true });
-  await run("systemctl", ["--user", "daemon-reload"], { capture: true, allowFailure: true });
+  await serviceRun("systemctl", ["--user", "daemon-reload"]);
   logger.info?.(`Autostart removed: ${servicePath}`);
   return { ok: true, provider: "systemd", path: servicePath };
 }
 
 async function statusSystemd() {
   const servicePath = systemdPath();
-  const result = await run("systemctl", ["--user", "status", "machine-bridge-mcp.service", "--no-pager"], { capture: true, allowFailure: true });
+  const result = await serviceRun("systemctl", ["--user", "status", "machine-bridge-mcp.service", "--no-pager"]);
   return { ok: existsSync(servicePath), provider: "systemd", installed: existsSync(servicePath), path: servicePath, active: result.code === 0, detail: result.stdout || result.stderr };
 }
 
@@ -216,19 +235,19 @@ WantedBy=default.target
 
 async function installWindowsTask(spec, logger) {
   const command = windowsCommand(spec);
-  const result = await run("schtasks", ["/Create", "/TN", WINDOWS_TASK, "/SC", "ONLOGON", "/TR", command, "/F"], { capture: true, allowFailure: true });
+  const result = await serviceRun("schtasks", ["/Create", "/TN", WINDOWS_TASK, "/SC", "ONLOGON", "/TR", command, "/F"]);
   logger.info?.("Windows Scheduled Task installed for logon");
   return { ok: result.code === 0, provider: "schtasks", task: WINDOWS_TASK, result };
 }
 
 async function uninstallWindowsTask(logger) {
-  const result = await run("schtasks", ["/Delete", "/TN", WINDOWS_TASK, "/F"], { capture: true, allowFailure: true });
+  const result = await serviceRun("schtasks", ["/Delete", "/TN", WINDOWS_TASK, "/F"]);
   logger.info?.("Windows Scheduled Task removed");
   return { ok: result.code === 0 || /cannot find/i.test(result.stderr), provider: "schtasks", task: WINDOWS_TASK, result };
 }
 
 async function statusWindowsTask() {
-  const result = await run("schtasks", ["/Query", "/TN", WINDOWS_TASK, "/FO", "LIST"], { capture: true, allowFailure: true });
+  const result = await serviceRun("schtasks", ["/Query", "/TN", WINDOWS_TASK, "/FO", "LIST"]);
   return { ok: result.code === 0, provider: "schtasks", installed: result.code === 0, task: WINDOWS_TASK, active: result.code === 0, detail: result.stdout || result.stderr };
 }
 

package/src/local/state.mjs

@@ -1,12 +1,16 @@
 import { createHash, randomBytes } from "node:crypto";
-import { closeSync, existsSync, fsyncSync, lstatSync, mkdirSync, openSync, readFileSync, renameSync, writeFileSync, chmodSync, realpathSync, rmSync, unlinkSync, readdirSync, statSync } from "node:fs";
+import { closeSync, constants as fsConstants, existsSync, fstatSync, fsyncSync, lstatSync, mkdirSync, openSync, readSync, renameSync, writeFileSync, chmodSync, realpathSync, rmSync, unlinkSync, readdirSync, statSync } from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
+import serverMetadata from "../shared/server-metadata.json" with { type: "json" };
 
 export const packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../..");
-export const appName = "machine-bridge-mcp";
+export const appName = String(serverMetadata.name);
 const STATE_MARKER = ".machine-bridge-mcp-state";
+const MAX_STATE_JSON_BYTES = 2 * 1024 * 1024;
+const MAX_LOCK_BYTES = 64 * 1024;
+const MAX_MARKER_BYTES = 4096;
 
 export function expandHome(input = "") {
   if (!input || input === "~") return os.homedir();
@@ -16,7 +20,7 @@ export function expandHome(input = "") {
 
 export function resolveWorkspace(input = process.cwd()) {
   const resolved = path.resolve(expandHome(input));
-  return realpathSync(resolved);
+  return realpathSync.native ? realpathSync.native(resolved) : realpathSync(resolved);
 }
 
 export function defaultStateRoot() {
@@ -29,7 +33,7 @@ export function defaultStateRoot() {
 }
 
 
-export function configPath(stateRoot = defaultStateRoot()) {
+function configPath(stateRoot = defaultStateRoot()) {
   return path.join(expandHome(stateRoot), "config.json");
 }
 
@@ -48,9 +52,10 @@ export function saveGlobalConfig(config, stateRoot = defaultStateRoot()) {
 
 export function setSelectedWorkspace(workspace, stateRoot = defaultStateRoot()) {
   const root = expandHome(stateRoot);
+  const canonicalWorkspace = resolveWorkspace(workspace);
   const config = loadGlobalConfig(root);
-  config.selectedWorkspace = workspace;
-  config.selectedWorkspaceHash = workspaceHash(workspace);
+  config.selectedWorkspace = canonicalWorkspace;
+  config.selectedWorkspaceHash = workspaceHash(canonicalWorkspace);
   saveGlobalConfig(config, root);
   return config;
 }
@@ -75,20 +80,53 @@ export function removeStateRoot(stateRoot = defaultStateRoot()) {
 }
 
 export function workspaceHash(workspace) {
-  return createHash("sha256").update(String(workspace)).digest("hex").slice(0, 24);
+  const canonical = resolveWorkspace(workspace);
+  const identity = process.platform === "win32" ? canonical.toLowerCase() : canonical;
+  return createHash("sha256").update(identity).digest("hex").slice(0, 24);
 }
 
-export function profileDirForWorkspace(workspace, stateRoot = defaultStateRoot()) {
+function profileDirForWorkspace(workspace, stateRoot = defaultStateRoot()) {
   return path.join(expandHome(stateRoot), "profiles", workspaceHash(workspace));
 }
 
-export function statePathForWorkspace(workspace, stateRoot = defaultStateRoot()) {
-  return path.join(profileDirForWorkspace(workspace, stateRoot), "state.json");
+
+function matchingLegacyProfileDir(canonicalWorkspace, stateRoot) {
+  const profilesRoot = path.join(stateRoot, "profiles");
+  if (!existsSync(profilesRoot)) return "";
+  const matches = [];
+  for (const entry of readdirSync(profilesRoot, { withFileTypes: true })) {
+    if (!entry.isDirectory() || !/^[a-f0-9]{24}$/.test(entry.name)) continue;
+    const profileDir = path.join(profilesRoot, entry.name);
+    const stateFile = path.join(profileDir, "state.json");
+    if (!existsSync(stateFile)) continue;
+    try {
+      const value = JSON.parse(readBoundedUtf8(stateFile, MAX_STATE_JSON_BYTES, "state JSON"));
+      const storedWorkspace = value?.workspace?.path;
+      if (typeof storedWorkspace !== "string") continue;
+      if (sameWorkspaceIdentity(storedWorkspace, canonicalWorkspace)) matches.push(profileDir);
+    } catch {}
+  }
+  if (matches.length > 1) throw new Error("multiple Machine Bridge profiles refer to the same canonical workspace; remove or merge the duplicate state profiles");
+  return matches[0] || "";
+}
+
+function sameWorkspaceIdentity(left, right) {
+  try {
+    const a = resolveWorkspace(left);
+    const b = resolveWorkspace(right);
+    return process.platform === "win32" ? a.toLowerCase() === b.toLowerCase() : a === b;
+  } catch {
+    return false;
+  }
 }
 
 export function loadState(workspace, options = {}) {
+  const canonicalWorkspace = resolveWorkspace(workspace);
   const stateRoot = ensureStateRoot(options.stateDir ? expandHome(options.stateDir) : defaultStateRoot());
-  const profileDir = profileDirForWorkspace(workspace, stateRoot);
+  const canonicalProfileDir = profileDirForWorkspace(canonicalWorkspace, stateRoot);
+  const profileDir = existsSync(canonicalProfileDir)
+    ? canonicalProfileDir
+    : matchingLegacyProfileDir(canonicalWorkspace, stateRoot) || canonicalProfileDir;
   const statePath = path.join(profileDir, "state.json");
   ensureOwnerOnlyDir(profileDir);
   let state = {};
@@ -96,15 +134,16 @@ export function loadState(workspace, options = {}) {
     ownerOnlyFile(statePath);
     state = readJsonObjectOrBackup(statePath);
   }
-  state.schemaVersion = 3;
+  state.schemaVersion = 5;
   state.workspace = {
-    path: workspace,
-    hash: workspaceHash(workspace),
+    path: canonicalWorkspace,
+    hash: path.basename(profileDir),
     updatedAt: new Date().toISOString(),
   };
   state.paths = { stateRoot, profileDir, statePath };
   state.worker ||= {};
   state.policy ||= {};
+  state.resources ||= {};
   delete state.localApi;
   return state;
 }
@@ -189,7 +228,7 @@ function releaseProcessLock(lockPath, token) {
 
 export function readDaemonLockOwner(lockPath) {
   try {
-    const parsed = JSON.parse(readFileSync(lockPath, "utf8"));
+    const parsed = JSON.parse(readBoundedUtf8(lockPath, MAX_LOCK_BYTES, "lock file"));
     return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
   } catch {
     return null;
@@ -207,9 +246,31 @@ function isPidAlive(pid) {
   }
 }
 
+function readBoundedUtf8(filePath, maxBytes, label) {
+  const pathInfo = lstatSync(filePath);
+  if (pathInfo.isSymbolicLink()) throw new Error(`${label} must not be a symbolic link`);
+  const noFollow = Number(fsConstants.O_NOFOLLOW || 0);
+  const fd = openSync(filePath, Number(fsConstants.O_RDONLY) | noFollow);
+  try {
+    const info = fstatSync(fd);
+    if (!info.isFile()) throw new Error(`${label} is not a regular file`);
+    if (info.size > maxBytes) throw new Error(`${label} 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 === 0) break;
+      offset += count;
+    }
+    return buffer.subarray(0, offset).toString("utf8");
+  } finally {
+    closeSync(fd);
+  }
+}
+
 function readJsonObjectOrBackup(filePath) {
   try {
-    const parsed = JSON.parse(readFileSync(filePath, "utf8"));
+    const parsed = JSON.parse(readBoundedUtf8(filePath, MAX_STATE_JSON_BYTES, "state JSON"));
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw new Error("JSON root must be an object");
     return parsed;
   } catch {
@@ -286,7 +347,7 @@ function assertSafeStateRootForRemoval(root) {
 }
 
 function assertValidStateMarker(marker, options = {}) {
-  const content = readFileSync(marker, "utf8");
+  const content = readBoundedUtf8(marker, MAX_MARKER_BYTES, "state marker");
   try {
     const value = JSON.parse(content);
     if (value?.app === appName && value?.schema === 1) return;
@@ -315,7 +376,7 @@ function stateRootMatchesRecordedWorkspace(root) {
       if (!entry.isDirectory()) continue;
       const stateFile = path.join(profiles, entry.name, "state.json");
       if (!existsSync(stateFile)) continue;
-      const value = JSON.parse(readFileSync(stateFile, "utf8"));
+      const value = JSON.parse(readBoundedUtf8(stateFile, MAX_STATE_JSON_BYTES, "state JSON"));
       if (typeof value?.workspace?.path !== "string") continue;
       try { if (realpathSync(value.workspace.path) === root) return true; } catch {}
     }
@@ -327,7 +388,7 @@ function isRecognizableLegacyStateRoot(root) {
   const config = path.join(root, "config.json");
   try {
     if (existsSync(config)) {
-      const value = JSON.parse(readFileSync(config, "utf8"));
+      const value = JSON.parse(readBoundedUtf8(config, MAX_STATE_JSON_BYTES, "config JSON"));
       if (
         value &&
         typeof value.selectedWorkspace === "string" &&
@@ -343,7 +404,7 @@ function isRecognizableLegacyStateRoot(root) {
       if (!entry.isDirectory() || !/^[a-f0-9]{24}$/.test(entry.name)) continue;
       const stateFile = path.join(profiles, entry.name, "state.json");
       if (!existsSync(stateFile)) continue;
-      const value = JSON.parse(readFileSync(stateFile, "utf8"));
+      const value = JSON.parse(readBoundedUtf8(stateFile, MAX_STATE_JSON_BYTES, "state JSON"));
       if (value?.workspace?.hash === entry.name && typeof value?.workspace?.path === "string") return true;
     }
   } catch {}
@@ -354,11 +415,13 @@ function atomicWriteJson(filePath, value) {
   const dir = path.dirname(filePath);
   ensureOwnerOnlyDir(dir);
   cleanupStaleAtomicTemps(dir, path.basename(filePath));
+  const serialized = `${JSON.stringify(value, null, 2)}\n`;
+  if (Buffer.byteLength(serialized) > MAX_STATE_JSON_BYTES) throw new Error(`state JSON exceeds ${MAX_STATE_JSON_BYTES} bytes`);
   const tempPath = path.join(dir, `.${path.basename(filePath)}.${process.pid}.${randomBytes(6).toString("hex")}.tmp`);
   let fd;
   try {
     fd = openSync(tempPath, "wx", 0o600);
-    writeFileSync(fd, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+    writeFileSync(fd, serialized, "utf8");
     fsyncSync(fd);
     closeSync(fd);
     fd = undefined;
@@ -412,11 +475,11 @@ export function ensureWorkerSecrets(state, options = {}) {
   if (!state.worker.name || options.workerName) state.worker.name = options.workerName || defaultWorkerName(state.workspace.hash);
 }
 
-export function defaultWorkerName(hash) {
+function defaultWorkerName(hash) {
   return `mbm-${String(hash || "default").slice(0, 12)}`;
 }
 
-export function randomToken(prefix) {
+function randomToken(prefix) {
   return `${prefix}_${randomBytes(32).toString("base64url")}`;
 }
 
@@ -424,9 +487,6 @@ export function sha256(value) {
   return createHash("sha256").update(String(value)).digest("hex");
 }
 
-export function fileSha256(filePath) {
-  return createHash("sha256").update(readFileSync(filePath)).digest("hex");
-}
 
 export function ensureOwnerOnlyDir(dir) {
   mkdirSync(dir, { recursive: true, mode: 0o700 });
@@ -434,6 +494,9 @@ export function ensureOwnerOnlyDir(dir) {
 }
 
 export function ownerOnlyFile(filePath) {
+  const info = lstatSync(filePath);
+  if (info.isSymbolicLink()) throw new Error(`owner-only file must not be a symbolic link: ${filePath}`);
+  if (!info.isFile()) throw new Error(`owner-only path is not a regular file: ${filePath}`);
   try { chmodSync(filePath, 0o600); } catch {}
 }
 
@@ -442,6 +505,11 @@ export function redactState(state) {
   if (clone.worker?.oauthPassword) clone.worker.oauthPassword = "<redacted>";
   if (clone.worker?.daemonSecret) clone.worker.daemonSecret = "<redacted>";
   if (clone.worker?.oauthTokenVersion) clone.worker.oauthTokenVersion = "<redacted>";
+  if (clone.resources && typeof clone.resources === "object") {
+    for (const value of Object.values(clone.resources)) {
+      if (value && typeof value === "object" && value.path) value.path = "<local-resource-path>";
+    }
+  }
   return clone;
 }
 

package/src/local/stdio.mjs

@@ -2,11 +2,12 @@ import readline from "node:readline";
 import { readFileSync } from "node:fs";
 import { randomBytes } from "node:crypto";
 import { LocalDaemon } from "./daemon.mjs";
-import { formatFields, sanitizeLogText } from "./log.mjs";
+import { classifyOperationalError, createLogger } from "./log.mjs";
 import {
   MCP_INSTRUCTIONS,
   MCP_PROTOCOL_VERSION,
   MCP_SUPPORTED_PROTOCOL_VERSIONS,
+  SERVER_NAME,
   rpcError,
   rpcResult,
   toolResult,
@@ -14,11 +15,12 @@ import {
 } from "./tools.mjs";
 
 const MAX_LINE_BYTES = 8 * 1024 * 1024;
+const SLOW_TOOL_CALL_MS = 30_000;
 const PACKAGE_VERSION = String(JSON.parse(readFileSync(new URL("../../package.json", import.meta.url), "utf8")).version);
 
-export async function runStdioServer({ workspace, policy, verbose = false }) {
-  const logger = stderrLogger(verbose);
-  const runtime = new LocalDaemon({ workspace, policy, logger });
+export async function runStdioServer({ workspace, policy, logLevel = "info", jobRoot = "", resources = {}, resourceStatePath = "" }) {
+  const logger = createLogger({ component: "stdio", level: logLevel, stderrOnly: true, color: false });
+  const runtime = new LocalDaemon({ workspace, policy, logger, jobRoot, resources, resourceStatePath });
   const pending = new Map();
   let negotiatedVersion = MCP_PROTOCOL_VERSION;
   let initialized = false;
@@ -40,7 +42,7 @@ export async function runStdioServer({ workspace, policy, verbose = false }) {
       return;
     }
     void handleLine(line).catch((error) => {
-      logger.error("stdio request handler failed", { error: errorMessage(error) });
+      logger.error("stdio request handler failed", { error_class: classifyOperationalError(error) });
     });
   });
 
@@ -74,7 +76,7 @@ export async function runStdioServer({ workspace, policy, verbose = false }) {
         protocolVersion: negotiatedVersion,
         capabilities: { tools: { listChanged: false }, logging: {} },
         serverInfo: {
-          name: "machine-bridge-mcp",
+          name: SERVER_NAME,
           title: "Machine Bridge MCP",
           version: PACKAGE_VERSION,
           description: "Workspace-scoped local coding tools over MCP stdio or authenticated remote relay.",
@@ -128,11 +130,15 @@ export async function runStdioServer({ workspace, policy, verbose = false }) {
       try {
         const result = await runtime.executeTool(name, args, { callId });
         send(rpcResult(message.id, toolResult(result)));
-        logger.info("tool call completed", { call_id: callId.slice(0, 20), tool: name, duration_ms: Date.now() - started, ok: true });
+        const durationMs = Date.now() - started;
+        if (durationMs >= SLOW_TOOL_CALL_MS) logger.info("slow tool call completed", { tool: name, duration_ms: durationMs });
+        else logger.debug("tool call completed", { call_id: callId.slice(0, 20), tool: name, duration_ms: durationMs });
       } catch (error) {
         const safeError = runtime.safeErrorMessage(error);
         send(rpcResult(message.id, toolResult({ error: safeError }, true)));
-        logger.warn("tool call failed", { call_id: callId.slice(0, 20), tool: name, duration_ms: Date.now() - started, ok: false, error_class: classifyError(error) });
+        const durationMs = Date.now() - started;
+        logger.warn("tool call failed", { tool: name, duration_ms: durationMs, error_class: classifyOperationalError(error) });
+        logger.debug("tool call failure correlation", { call_id: callId.slice(0, 20) });
       } finally {
         if (key) pending.delete(key);
         runtime.finishCall(callId);
@@ -162,33 +168,3 @@ function jsonRpcIdKey(value) {
 function asObject(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
-
-function classifyError(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 (/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";
-  if (/permission|EACCES|EPERM/i.test(message)) return "permission_denied";
-  if (/maximum|exceeds|max_bytes|too many/i.test(message)) return "limit_exceeded";
-  if (/invalid|must|requires|ambiguous|mismatch/i.test(message)) return "invalid_request";
-  return "execution_failed";
-}
-
-function errorMessage(error) {
-  return sanitizeLogText(error instanceof Error ? error.message : String(error)).slice(0, 4096) || "tool call failed";
-}
-
-function stderrLogger(verbose) {
-  const write = (level, message, fields) => {
-    if (level === "debug" && !verbose) return;
-    process.stderr.write(`[${level}] stdio: ${sanitizeLogText(message)}${formatFields(fields)}\n`);
-  };
-  return {
-    info(message, fields) { write("info", message, fields); },
-    warn(message, fields) { write("warn", message, fields); },
-    error(message, fields) { write("error", message, fields); },
-    debug(message, fields) { write("debug", message, fields); },
-  };
-}

package/src/local/tools.mjs

@@ -1,16 +1,30 @@
 import catalog from "../shared/tool-catalog.json" with { type: "json" };
+import serverMetadata from "../shared/server-metadata.json" with { type: "json" };
 
-export const MCP_PROTOCOL_VERSION = "2025-11-25";
-export const MCP_SUPPORTED_PROTOCOL_VERSIONS = ["2025-11-25", "2025-06-18", "2025-03-26"];
+export const SERVER_NAME = String(serverMetadata.name);
+export const MCP_PROTOCOL_VERSION = String(serverMetadata.protocolVersion);
+export const MCP_SUPPORTED_PROTOCOL_VERSIONS = Object.freeze(serverMetadata.supportedProtocolVersions.map((value) => String(value)));
 
-export const MCP_INSTRUCTIONS = [
-  "You are connected to a local workspace through machine-bridge-mcp.",
-  "Remote mode uses a Cloudflare relay; stdio mode runs entirely on the local machine.",
-  "File and command operations execute on the user's local runtime, not in the Worker.",
-  "Relative paths use the configured workspace. Direct filesystem tools are workspace-scoped unless unrestricted paths are explicitly enabled.",
-  "run_process avoids shell parsing but is not an OS sandbox. exec_command is only exposed in shell execution mode and has the local user's authority.",
-  "Inspect before editing, prefer edit_file or apply_patch over whole-file replacement, and report commands that were run.",
-].join("\n");
+export const MCP_INSTRUCTIONS = Object.freeze(serverMetadata.instructions.map((value) => String(value))).join("\n");
+
+
+export const DEFAULT_POLICY_PROFILE = "full";
+export const DEFAULT_POLICY_REVISION = 2;
+
+export const POLICY_PROFILES = Object.freeze({
+  review: Object.freeze({ profile: "review", allowWrite: false, execMode: "off", unrestrictedPaths: false, minimalEnv: true, exposeAbsolutePaths: false }),
+  edit: Object.freeze({ profile: "edit", allowWrite: true, execMode: "off", unrestrictedPaths: false, minimalEnv: true, exposeAbsolutePaths: false }),
+  agent: Object.freeze({ profile: "agent", allowWrite: true, execMode: "direct", unrestrictedPaths: false, minimalEnv: true, exposeAbsolutePaths: false }),
+  full: Object.freeze({ profile: "full", allowWrite: true, execMode: "shell", unrestrictedPaths: true, minimalEnv: false, exposeAbsolutePaths: true }),
+});
+
+const POLICY_ORIGINS = new Set(["default", "explicit", "custom", "migrated", "legacy-preserved"]);
+
+export function policyProfile(name, origin = "explicit") {
+  const profile = String(name || "").trim().toLowerCase();
+  if (!POLICY_PROFILES[profile]) throw new Error(`unknown policy profile: ${profile}`);
+  return normalizePolicy({ ...POLICY_PROFILES[profile], origin, revision: DEFAULT_POLICY_REVISION });
+}
 
 export function normalizePolicy(policy = {}) {
   const execMode = ["off", "direct", "shell"].includes(policy.execMode)
@@ -18,8 +32,12 @@ export function normalizePolicy(policy = {}) {
     : policy.allowExec === true
       ? "shell"
       : "off";
+  const origin = POLICY_ORIGINS.has(policy.origin) ? policy.origin : "custom";
+  const revision = Number.isInteger(policy.revision) && policy.revision > 0 ? policy.revision : DEFAULT_POLICY_REVISION;
   return {
     profile: typeof policy.profile === "string" && policy.profile ? policy.profile : "custom",
+    origin,
+    revision,
     allowWrite: policy.allowWrite === true,
     allowExec: execMode !== "off",
     execMode,
@@ -44,9 +62,6 @@ export function allToolNames() {
   return catalog.map((tool) => tool.name);
 }
 
-export function findTool(name) {
-  return catalog.find((tool) => tool.name === name) || null;
-}
 
 export function toolResult(value, isError = false) {
   const special = specialMcpResult(value);

package/src/shared/server-metadata.json

@@ -0,0 +1,24 @@
+{
+  "name": "machine-bridge-mcp",
+  "protocolVersion": "2025-11-25",
+  "supportedProtocolVersions": [
+    "2025-11-25",
+    "2025-06-18",
+    "2025-03-26"
+  ],
+  "instructions": [
+    "You are connected to a local workspace through machine-bridge-mcp.",
+    "Remote mode uses a Cloudflare relay; stdio mode runs on the local machine. File and command operations execute on the user's local runtime, not in the Worker.",
+    "Filesystem scope and path display follow the active local policy; the default full profile is unrestricted.",
+    "Filename sensitivity is not classified by this server; the MCP host, connector gateway, local OS, or endpoint-security software may enforce additional independent rules.",
+    "Use diagnose_runtime to distinguish a request that reached the daemon from local filesystem, process-spawn, shell, managed-job-storage, and resource failures. A tool call blocked before any response cannot be diagnosed by the server.",
+    "Never request or return secret-file contents when a local resource alias can be used. Resources are registered only through the local machine-mcp CLI and may be injected by path, stdin, or environment without entering MCP arguments.",
+    "If execution-class tools are unavailable but write access remains, use stage_job to persist a reviewed plan without running it; the operator can launch it locally with machine-mcp job approve JOB_ID.",
+    "For multi-step, remote, long-running, or cleanup-sensitive work, prefer one start_job call with argv steps, job-scoped temporary_files, and idempotent finally_steps. The detached runner continues after MCP disconnects; inspect it with read_job or the local machine-mcp job CLI.",
+    "Prefer sending remote shell programs through a process stdin rather than creating remote helper files. If temporary files are necessary, use {{temp:name}} or explicit finally_steps.",
+    "Managed-job resource redaction is defense in depth, not a guarantee against transformed or partial secret output. Use capture_output=discard for steps that may echo credentials.",
+    "Do not use shell encoding, renaming, or alternate tools to bypass host or platform safety policy.",
+    "run_process avoids shell parsing but is not an OS sandbox. exec_command is exposed only in shell mode and has the local user's authority.",
+    "Inspect before editing, prefer read_file line ranges, edit_file, or apply_patch over whole-file replacement, and report commands that were run."
+  ]
+}