machine-bridge-mcp 0.5.0 → 0.6.0

package/src/local/state.mjs

@@ -20,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() {
@@ -52,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;
 }
@@ -79,7 +80,9 @@ 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);
 }
 
 function profileDirForWorkspace(workspace, stateRoot = defaultStateRoot()) {
@@ -87,9 +90,43 @@ function profileDirForWorkspace(workspace, stateRoot = defaultStateRoot()) {
 }
 
 
+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 = {};
@@ -97,15 +134,16 @@ export function loadState(workspace, options = {}) {
     ownerOnlyFile(statePath);
     state = readJsonObjectOrBackup(statePath);
   }
-  state.schemaVersion = 4;
+  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;
 }
@@ -467,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

@@ -18,9 +18,9 @@ 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" }) {
+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 });
+  const runtime = new LocalDaemon({ workspace, policy, logger, jobRoot, resources, resourceStatePath });
   const pending = new Map();
   let negotiatedVersion = MCP_PROTOCOL_VERSION;
   let initialized = false;

package/src/shared/server-metadata.json

@@ -10,7 +10,14 @@
     "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 may enforce additional independent rules.",
+    "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."
   ]

package/src/shared/tool-catalog.json

@@ -603,6 +603,504 @@
       "additionalProperties": false
     }
   },
+  {
+    "name": "diagnose_runtime",
+    "title": "Diagnose runtime layers",
+    "description": "Run fixed, non-user-controlled local probes to distinguish MCP policy, local filesystem, process-spawn, shell, managed-job storage, and registered-resource failures. A successful response proves the request reached the local daemon; it cannot diagnose a host refusal that blocks the tool call itself.",
+    "availability": "always",
+    "annotations": {
+      "readOnlyHint": true,
+      "destructiveHint": false,
+      "idempotentHint": true,
+      "openWorldHint": false
+    },
+    "inputSchema": {
+      "type": "object",
+      "additionalProperties": false
+    }
+  },
+  {
+    "name": "list_local_resources",
+    "title": "List local resource aliases",
+    "description": "List names and validation status for locally registered file resources without returning their paths or contents. Resources are registered only through the local machine-mcp CLI.",
+    "availability": "write",
+    "annotations": {
+      "readOnlyHint": true,
+      "destructiveHint": false,
+      "idempotentHint": true,
+      "openWorldHint": false
+    },
+    "inputSchema": {
+      "type": "object",
+      "additionalProperties": false
+    }
+  },
+  {
+    "name": "stage_job",
+    "title": "Stage managed job for local approval",
+    "description": "Validate and persist a managed-job plan without starting any process. Use this when execution tools are unavailable or local operator review is required; launch later with machine-mcp job approve JOB_ID.",
+    "availability": "write",
+    "annotations": {
+      "readOnlyHint": false,
+      "destructiveHint": false,
+      "idempotentHint": false,
+      "openWorldHint": false
+    },
+    "inputSchema": {
+      "type": "object",
+      "properties": {
+        "name": {
+          "type": "string",
+          "maxLength": 128
+        },
+        "steps": {
+          "type": "array",
+          "minItems": 1,
+          "maxItems": 16,
+          "items": {
+            "type": "object",
+            "properties": {
+              "name": {
+                "type": "string",
+                "maxLength": 128
+              },
+              "argv": {
+                "type": "array",
+                "minItems": 1,
+                "maxItems": 256,
+                "items": {
+                  "type": "string",
+                  "maxLength": 16384
+                }
+              },
+              "cwd": {
+                "type": "string",
+                "maxLength": 4096
+              },
+              "env": {
+                "type": "object",
+                "maxProperties": 64,
+                "additionalProperties": {
+                  "type": "string",
+                  "maxLength": 16384
+                }
+              },
+              "env_resources": {
+                "type": "object",
+                "maxProperties": 32,
+                "additionalProperties": {
+                  "type": "string",
+                  "pattern": "^[a-z][a-z0-9._-]{0,63}$"
+                }
+              },
+              "stdin": {
+                "type": "string",
+                "maxLength": 262144
+              },
+              "stdin_resource": {
+                "type": "string",
+                "pattern": "^[a-z][a-z0-9._-]{0,63}$"
+              },
+              "timeout_seconds": {
+                "type": "integer",
+                "minimum": 1,
+                "maximum": 3600,
+                "default": 600
+              },
+              "allow_failure": {
+                "type": "boolean",
+                "default": false
+              },
+              "capture_output": {
+                "type": "string",
+                "enum": [
+                  "redacted",
+                  "discard"
+                ],
+                "default": "redacted"
+              }
+            },
+            "required": [
+              "argv"
+            ],
+            "additionalProperties": false
+          }
+        },
+        "finally_steps": {
+          "type": "array",
+          "maxItems": 16,
+          "items": {
+            "type": "object",
+            "properties": {
+              "name": {
+                "type": "string",
+                "maxLength": 128
+              },
+              "argv": {
+                "type": "array",
+                "minItems": 1,
+                "maxItems": 256,
+                "items": {
+                  "type": "string",
+                  "maxLength": 16384
+                }
+              },
+              "cwd": {
+                "type": "string",
+                "maxLength": 4096
+              },
+              "env": {
+                "type": "object",
+                "maxProperties": 64,
+                "additionalProperties": {
+                  "type": "string",
+                  "maxLength": 16384
+                }
+              },
+              "env_resources": {
+                "type": "object",
+                "maxProperties": 32,
+                "additionalProperties": {
+                  "type": "string",
+                  "pattern": "^[a-z][a-z0-9._-]{0,63}$"
+                }
+              },
+              "stdin": {
+                "type": "string",
+                "maxLength": 262144
+              },
+              "stdin_resource": {
+                "type": "string",
+                "pattern": "^[a-z][a-z0-9._-]{0,63}$"
+              },
+              "timeout_seconds": {
+                "type": "integer",
+                "minimum": 1,
+                "maximum": 3600,
+                "default": 600
+              },
+              "allow_failure": {
+                "type": "boolean",
+                "default": false
+              },
+              "capture_output": {
+                "type": "string",
+                "enum": [
+                  "redacted",
+                  "discard"
+                ],
+                "default": "redacted"
+              }
+            },
+            "required": [
+              "argv"
+            ],
+            "additionalProperties": false
+          }
+        },
+        "temporary_files": {
+          "type": "array",
+          "maxItems": 16,
+          "items": {
+            "type": "object",
+            "properties": {
+              "name": {
+                "type": "string",
+                "pattern": "^[a-z][a-z0-9._-]{0,63}$"
+              },
+              "content": {
+                "type": "string",
+                "maxLength": 262144
+              },
+              "executable": {
+                "type": "boolean",
+                "default": false
+              }
+            },
+            "required": [
+              "name",
+              "content"
+            ],
+            "additionalProperties": false
+          }
+        }
+      },
+      "required": [
+        "steps"
+      ],
+      "additionalProperties": false
+    }
+  },
+  {
+    "name": "start_job",
+    "title": "Start managed job",
+    "description": "Durably accept a detached argv-based job with ordered steps, job-scoped temporary files, and guaranteed-attempt finally steps. The independent local runner continues if the MCP connection disappears. Use {{temp:name}}, {{resource:name}}, env_resources, or stdin_resource; registered resource contents never enter MCP arguments.",
+    "availability": "direct-exec",
+    "annotations": {
+      "readOnlyHint": false,
+      "destructiveHint": true,
+      "idempotentHint": false,
+      "openWorldHint": true
+    },
+    "inputSchema": {
+      "type": "object",
+      "properties": {
+        "name": {
+          "type": "string",
+          "maxLength": 128
+        },
+        "steps": {
+          "type": "array",
+          "minItems": 1,
+          "maxItems": 16,
+          "items": {
+            "type": "object",
+            "properties": {
+              "name": {
+                "type": "string",
+                "maxLength": 128
+              },
+              "argv": {
+                "type": "array",
+                "minItems": 1,
+                "maxItems": 256,
+                "items": {
+                  "type": "string",
+                  "maxLength": 16384
+                }
+              },
+              "cwd": {
+                "type": "string",
+                "maxLength": 4096
+              },
+              "env": {
+                "type": "object",
+                "maxProperties": 64,
+                "additionalProperties": {
+                  "type": "string",
+                  "maxLength": 16384
+                }
+              },
+              "env_resources": {
+                "type": "object",
+                "maxProperties": 32,
+                "additionalProperties": {
+                  "type": "string",
+                  "pattern": "^[a-z][a-z0-9._-]{0,63}$"
+                }
+              },
+              "stdin": {
+                "type": "string",
+                "maxLength": 262144
+              },
+              "stdin_resource": {
+                "type": "string",
+                "pattern": "^[a-z][a-z0-9._-]{0,63}$"
+              },
+              "timeout_seconds": {
+                "type": "integer",
+                "minimum": 1,
+                "maximum": 3600,
+                "default": 600
+              },
+              "allow_failure": {
+                "type": "boolean",
+                "default": false
+              },
+              "capture_output": {
+                "type": "string",
+                "enum": [
+                  "redacted",
+                  "discard"
+                ],
+                "default": "redacted"
+              }
+            },
+            "required": [
+              "argv"
+            ],
+            "additionalProperties": false
+          }
+        },
+        "finally_steps": {
+          "type": "array",
+          "maxItems": 16,
+          "items": {
+            "type": "object",
+            "properties": {
+              "name": {
+                "type": "string",
+                "maxLength": 128
+              },
+              "argv": {
+                "type": "array",
+                "minItems": 1,
+                "maxItems": 256,
+                "items": {
+                  "type": "string",
+                  "maxLength": 16384
+                }
+              },
+              "cwd": {
+                "type": "string",
+                "maxLength": 4096
+              },
+              "env": {
+                "type": "object",
+                "maxProperties": 64,
+                "additionalProperties": {
+                  "type": "string",
+                  "maxLength": 16384
+                }
+              },
+              "env_resources": {
+                "type": "object",
+                "maxProperties": 32,
+                "additionalProperties": {
+                  "type": "string",
+                  "pattern": "^[a-z][a-z0-9._-]{0,63}$"
+                }
+              },
+              "stdin": {
+                "type": "string",
+                "maxLength": 262144
+              },
+              "stdin_resource": {
+                "type": "string",
+                "pattern": "^[a-z][a-z0-9._-]{0,63}$"
+              },
+              "timeout_seconds": {
+                "type": "integer",
+                "minimum": 1,
+                "maximum": 3600,
+                "default": 600
+              },
+              "allow_failure": {
+                "type": "boolean",
+                "default": false
+              },
+              "capture_output": {
+                "type": "string",
+                "enum": [
+                  "redacted",
+                  "discard"
+                ],
+                "default": "redacted"
+              }
+            },
+            "required": [
+              "argv"
+            ],
+            "additionalProperties": false
+          }
+        },
+        "temporary_files": {
+          "type": "array",
+          "maxItems": 16,
+          "items": {
+            "type": "object",
+            "properties": {
+              "name": {
+                "type": "string",
+                "pattern": "^[a-z][a-z0-9._-]{0,63}$"
+              },
+              "content": {
+                "type": "string",
+                "maxLength": 262144
+              },
+              "executable": {
+                "type": "boolean",
+                "default": false
+              }
+            },
+            "required": [
+              "name",
+              "content"
+            ],
+            "additionalProperties": false
+          }
+        }
+      },
+      "required": [
+        "steps"
+      ],
+      "additionalProperties": false
+    }
+  },
+  {
+    "name": "list_jobs",
+    "title": "List managed jobs",
+    "description": "List recent detached managed jobs and their lifecycle status without returning step output.",
+    "availability": "write",
+    "annotations": {
+      "readOnlyHint": true,
+      "destructiveHint": false,
+      "idempotentHint": true,
+      "openWorldHint": false
+    },
+    "inputSchema": {
+      "type": "object",
+      "properties": {
+        "limit": {
+          "type": "integer",
+          "minimum": 1,
+          "maximum": 50,
+          "default": 20
+        }
+      },
+      "additionalProperties": false
+    }
+  },
+  {
+    "name": "read_job",
+    "title": "Read managed job",
+    "description": "Return one managed job status plus bounded, resource-redacted step results. Registered resource paths and contents are never returned.",
+    "availability": "direct-exec",
+    "annotations": {
+      "readOnlyHint": true,
+      "destructiveHint": false,
+      "idempotentHint": true,
+      "openWorldHint": false
+    },
+    "inputSchema": {
+      "type": "object",
+      "properties": {
+        "job_id": {
+          "type": "string",
+          "pattern": "^job_[A-Za-z0-9_-]{24,}$"
+        }
+      },
+      "required": [
+        "job_id"
+      ],
+      "additionalProperties": false
+    }
+  },
+  {
+    "name": "cancel_job",
+    "title": "Cancel managed job",
+    "description": "Request cancellation of a detached managed job. The runner terminates the active process tree and still attempts declared finally steps and local resource cleanup.",
+    "availability": "write",
+    "annotations": {
+      "readOnlyHint": false,
+      "destructiveHint": true,
+      "idempotentHint": true,
+      "openWorldHint": true
+    },
+    "inputSchema": {
+      "type": "object",
+      "properties": {
+        "job_id": {
+          "type": "string",
+          "pattern": "^job_[A-Za-z0-9_-]{24,}$"
+        }
+      },
+      "required": [
+        "job_id"
+      ],
+      "additionalProperties": false
+    }
+  },
   {
     "name": "exec_command",
     "title": "Execute shell command",

package/src/worker/index.ts

@@ -3,7 +3,7 @@ import toolCatalog from "../shared/tool-catalog.json";
 import serverMetadata from "../shared/server-metadata.json";
 
 const SERVER_NAME = String(serverMetadata.name);
-const SERVER_VERSION = "0.5.0";
+const SERVER_VERSION = "0.6.0";
 const MCP_PROTOCOL_VERSION = String(serverMetadata.protocolVersion);
 const MCP_SUPPORTED_PROTOCOL_VERSIONS = serverMetadata.supportedProtocolVersions.map((value) => String(value));
 const JSONRPC_VERSION = "2.0";