machine-bridge-mcp 0.14.0 → 0.16.0

package/src/local/service.mjs

@@ -226,6 +226,7 @@ export function daemonArgs(spec) {
     "--state-dir", spec.stateRoot,
     "--no-print-credentials",
     "--log-level", "warn",
+    "--log-format", "json",
   ];
 }
 
@@ -465,11 +466,15 @@ async function statusWindowsTask() {
 }
 
 function windowsCommand(spec) {
-  return [spec.node, ...daemonArgs(spec)].map(winQuote).join(" ");
+  return [spec.node, ...daemonArgs(spec)].map(windowsCommandLineArgument).join(" ");
 }
 
-function winQuote(value) {
-  return `"${String(value).replaceAll('"', '\\"')}"`;
+export function windowsCommandLineArgument(value) {
+  const text = String(value);
+  if (text.includes("\0")) throw new Error("Windows command-line argument contains a NUL byte");
+  const escapedQuotes = text.replace(/(\\*)"/g, (_match, slashes) => `${slashes}${slashes}\\"`);
+  const escapedTrailingSlashes = escapedQuotes.replace(/(\\+)$/, (slashes) => `${slashes}${slashes}`);
+  return `"${escapedTrailingSlashes}"`;
 }
 
 export function systemdQuote(value) {

package/src/local/stdio.mjs

@@ -2,6 +2,7 @@ import { readFileSync } from "node:fs";
 import { randomBytes } from "node:crypto";
 import { LocalRuntime } from "./runtime.mjs";
 import { classifyOperationalError, createLogger } from "./log.mjs";
+import { publicError } from "./errors.mjs";
 import {
   MCP_INSTRUCTIONS,
   MCP_PROTOCOL_VERSION,
@@ -14,7 +15,6 @@ 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, logLevel = "info", jobRoot = "", resources = {}, resourceStatePath = "", browserStateRoot = "" }) {
@@ -115,21 +115,13 @@ export async function runStdioServer({ workspace, policy, logLevel = "info", job
       return;
     }
     if (key) pending.set(key, callId);
-    const started = Date.now();
-    logger.debug("tool call started", { call_id: callId.slice(0, 20), tool: name });
     try {
-      const result = await runtime.executeTool(name, args, { callId });
+      const result = await runtime.executeTool(name, args, { callId, origin: "stdio" });
       send(rpcResult(message.id, toolResult(result)));
-      const durationMs = Date.now() - started;
-      logger.debug(durationMs >= SLOW_TOOL_CALL_MS ? "slow tool call completed" : "tool call completed", { call_id: callId.slice(0, 20), tool: name, duration_ms: durationMs });
     } catch (error) {
-      const safeError = runtime.safeErrorMessage(error, args);
-      send(rpcResult(message.id, toolResult({ error: safeError }, true)));
-      const durationMs = Date.now() - started;
-      logger.debug("tool call failed", { call_id: callId.slice(0, 20), tool: name, duration_ms: durationMs, error_class: classifyOperationalError(error) });
+      send(rpcResult(message.id, toolResult({ error: publicError(error) }, true)));
     } finally {
       if (key) pending.delete(key);
-      runtime.finishCall(callId);
     }
   }
 

package/src/local/tool-executor.mjs

@@ -0,0 +1,102 @@
+import { errorCode, normalizeBridgeError } from "./errors.mjs";
+
+export class ToolExecutor {
+  constructor(options = {}) {
+    this.handlers = options.handlers || {};
+    this.policyGate = options.policyGate;
+    this.callRegistry = options.callRegistry;
+    this.observability = options.observability;
+    this.logger = options.logger || console;
+    this.safeMessage = typeof options.safeMessage === "function" ? options.safeMessage : (error) => String(error?.message || error || "operation failed");
+    this.slowMs = Number.isFinite(Number(options.slowMs)) ? Math.max(1, Number(options.slowMs)) : 30_000;
+    this.pipeline = composeMiddleware([
+      lifecycleMiddleware(this.callRegistry),
+      observabilityMiddleware(this.observability, this.logger, this.safeMessage, this.slowMs),
+      authorizeMiddleware(this.policyGate),
+    ], invokeHandler(this.handlers));
+  }
+
+  execute(tool, args = {}, request = {}) {
+    return this.pipeline({ tool: String(tool || ""), args: isRecord(args) ? args : {}, request });
+  }
+}
+
+export function composeMiddleware(middleware, terminal) {
+  return middleware.reduceRight((next, current) => (operation) => current(operation, next), terminal);
+}
+
+function authorizeMiddleware(policyGate) {
+  return async (operation, next) => {
+    policyGate.assert(operation.tool);
+    return next(operation);
+  };
+}
+
+function lifecycleMiddleware(callRegistry) {
+  return async (operation, next) => {
+    const context = callRegistry.open({
+      callId: operation.request.callId,
+      tool: operation.tool,
+      origin: operation.request.origin || "local",
+      timeoutMs: operation.request.timeoutMs,
+    });
+    operation.context = { ...operation.request.context, ...context };
+    try {
+      callRegistry.throwIfCancelled(operation.context);
+      const result = await next(operation);
+      callRegistry.throwIfCancelled(operation.context);
+      return result;
+    } finally {
+      callRegistry.finish(context.callId);
+    }
+  };
+}
+
+function observabilityMiddleware(observability, logger, safeMessage, slowMs) {
+  return async (operation, next) => {
+    const started = Date.now();
+    observability.start(operation.tool);
+    logger.event?.("debug", "tool.call.started", {
+      call_id: shortCallId(operation.context.callId),
+      tool: operation.tool,
+      origin: operation.context.origin,
+    });
+    try {
+      const result = await next(operation);
+      const durationMs = Date.now() - started;
+      const slow = durationMs >= slowMs;
+      observability.finish(operation.tool, { status: "completed", durationMs, slow });
+      logger.event?.("debug", slow ? "tool.call.slow" : "tool.call.completed", {
+        call_id: shortCallId(operation.context.callId), tool: operation.tool, origin: operation.context.origin, duration_ms: durationMs,
+      });
+      return result;
+    } catch (error) {
+      const normalized = normalizeBridgeError(error, { safeMessage: () => safeMessage(error, operation.args) });
+      const durationMs = Date.now() - started;
+      const code = errorCode(normalized);
+      const status = code === "cancelled" ? "cancelled" : code === "timeout" ? "timeout" : "failed";
+      observability.finish(operation.tool, { status, durationMs, errorCode: code, slow: durationMs >= slowMs });
+      logger.event?.("debug", "tool.call.failed", {
+        call_id: shortCallId(operation.context.callId), tool: operation.tool, origin: operation.context.origin,
+        duration_ms: durationMs, error_code: code, retryable: normalized.retryable,
+      });
+      throw normalized;
+    }
+  };
+}
+
+function invokeHandler(handlers) {
+  return async (operation) => {
+    const handler = handlers[operation.tool];
+    if (typeof handler !== "function") throw new Error(`runtime handler is missing for tool: ${operation.tool}`);
+    return handler(operation.args, operation.context);
+  };
+}
+
+function shortCallId(value) {
+  return String(value || "").slice(0, 20);
+}
+
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}

package/src/local/tools.mjs

@@ -1,110 +1,36 @@
-import catalog from "../shared/tool-catalog.json" with { type: "json" };
 import serverMetadata from "../shared/server-metadata.json" with { type: "json" };
+export {
+  DEFAULT_POLICY_PROFILE,
+  DEFAULT_POLICY_REVISION,
+  POLICY_AVAILABILITY,
+  POLICY_ORIGINS,
+  POLICY_PROFILES,
+  PolicyGate,
+  allToolNames,
+  assertCanonicalFullPolicy,
+  assertToolAllowed,
+  isCanonicalFullPolicy,
+  normalizePolicy,
+  policyAllowsAvailability,
+  policyAllowsTool,
+  policyCapabilitiesEqual,
+  policyProfile,
+  toolDefinition,
+  toolNamesForPolicy,
+  toolsForPolicy,
+} from "./policy.mjs";
 
 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 = Object.freeze(serverMetadata.instructions.map((value) => String(value))).join("\n");
 
-
-export const DEFAULT_POLICY_PROFILE = "full";
-export const DEFAULT_POLICY_REVISION = 3;
-
-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)
-    ? policy.execMode
-    : 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;
-  const requestedProfile = typeof policy.profile === "string" && policy.profile ? policy.profile : "custom";
-  const normalized = {
-    profile: requestedProfile,
-    origin,
-    revision,
-    allowWrite: policy.allowWrite === true,
-    allowExec: execMode !== "off",
-    execMode,
-    unrestrictedPaths: policy.unrestrictedPaths === true,
-    minimalEnv: policy.minimalEnv !== false,
-    exposeAbsolutePaths: policy.exposeAbsolutePaths === true,
-  };
-  if (POLICY_PROFILES[requestedProfile]) {
-    const canonical = POLICY_PROFILES[requestedProfile];
-    normalized.allowWrite = canonical.allowWrite;
-    normalized.allowExec = canonical.execMode !== "off";
-    normalized.execMode = canonical.execMode;
-    normalized.unrestrictedPaths = canonical.unrestrictedPaths;
-    normalized.minimalEnv = canonical.minimalEnv;
-    normalized.exposeAbsolutePaths = canonical.exposeAbsolutePaths;
-  }
-  return normalized;
-}
-
-export function isCanonicalFullPolicy(policy = {}) {
-  return policyCapabilitiesEqual(normalizePolicy(policy), POLICY_PROFILES.full);
-}
-
-export function assertCanonicalFullPolicy(policy = {}) {
-  const normalized = normalizePolicy(policy);
-  if (!isCanonicalFullPolicy(normalized) || normalized.profile !== "full") {
-    throw new Error("full profile invariant failed: full must enable writes, shell execution, unrestricted paths, full parent environment, and absolute paths");
-  }
-  const exposed = toolsForPolicy(normalized);
-  if (exposed.length !== catalog.length) throw new Error("full profile invariant failed: complete tool catalog is not exposed");
-  return normalized;
-}
-
-function policyCapabilitiesEqual(left, right) {
-  return left.allowWrite === right.allowWrite
-    && left.execMode === right.execMode
-    && left.unrestrictedPaths === right.unrestrictedPaths
-    && left.minimalEnv === right.minimalEnv
-    && left.exposeAbsolutePaths === right.exposeAbsolutePaths;
-}
-
-export function toolsForPolicy(policy = {}) {
-  const normalized = normalizePolicy(policy);
-  return catalog
-    .filter((tool) => isAvailable(tool.availability, normalized))
-    .map(({ availability, ...tool }) => structuredClone(tool));
-}
-
-export function toolNamesForPolicy(policy = {}) {
-  return toolsForPolicy(policy).map((tool) => tool.name);
-}
-
-export function allToolNames() {
-  return catalog.map((tool) => tool.name);
-}
-
-
 export function toolResult(value, isError = false) {
   const special = specialMcpResult(value);
   if (special) return { ...special, isError };
   const structuredContent = toStructuredContent(value);
   const text = typeof value === "string" ? value : JSON.stringify(value, null, 2);
-  const result = {
-    content: [{ type: "text", text }],
-    isError,
-  };
+  const result = { content: [{ type: "text", text }], isError };
   if (structuredContent) result.structuredContent = structuredContent;
   return result;
 }
@@ -120,15 +46,6 @@ export function rpcError(id, code, message, data) {
   return { jsonrpc: "2.0", id: id ?? null, error };
 }
 
-function isAvailable(availability, policy) {
-  if (availability === "always") return true;
-  if (availability === "write") return policy.allowWrite;
-  if (availability === "direct-exec") return policy.execMode === "direct" || policy.execMode === "shell";
-  if (availability === "shell-exec") return policy.execMode === "shell";
-  if (availability === "full") return policy.profile === "full" && isCanonicalFullPolicy(policy);
-  return false;
-}
-
 function specialMcpResult(value) {
   const special = value && typeof value === "object" && !Array.isArray(value) ? value.$mcp : null;
   if (!special || typeof special !== "object" || !Array.isArray(special.content)) return null;