machine-bridge-mcp 0.6.2 → 0.8.0

package/src/local/stdio.mjs

@@ -1,7 +1,6 @@
-import readline from "node:readline";
 import { readFileSync } from "node:fs";
 import { randomBytes } from "node:crypto";
-import { LocalDaemon } from "./daemon.mjs";
+import { LocalRuntime } from "./runtime.mjs";
 import { classifyOperationalError, createLogger } from "./log.mjs";
 import {
   MCP_INSTRUCTIONS,
@@ -20,131 +19,208 @@ const PACKAGE_VERSION = String(JSON.parse(readFileSync(new URL("../../package.js
 
 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 runtime = new LocalRuntime({ workspace, policy, logger, jobRoot, resources, resourceStatePath });
   const pending = new Map();
   let negotiatedVersion = MCP_PROTOCOL_VERSION;
   let initialized = false;
 
-  const rl = readline.createInterface({ input: process.stdin, crlfDelay: Infinity, terminal: false });
   const writes = new Set();
   const send = (message) => {
     if (message === null || message === undefined) return;
     const line = `${JSON.stringify(message)}\n`;
     const promise = new Promise((resolvePromise, rejectPromise) => {
       process.stdout.write(line, (error) => error ? rejectPromise(error) : resolvePromise());
+    }).catch((error) => {
+      logger.warn("stdio output write failed", { error_class: classifyOperationalError(error) });
     }).finally(() => writes.delete(promise));
     writes.add(promise);
   };
 
-  rl.on("line", (line) => {
-    if (Buffer.byteLength(line) > MAX_LINE_BYTES) {
-      send(rpcError(null, -32600, "JSON-RPC message exceeds maximum size"));
-      return;
-    }
-    void handleLine(line).catch((error) => {
-      logger.error("stdio request handler failed", { error_class: classifyOperationalError(error) });
-    });
-  });
-
-  await new Promise((resolvePromise, rejectPromise) => {
-    rl.once("close", resolvePromise);
-    rl.once("error", rejectPromise);
+  await consumeBoundedJsonLines(process.stdin, {
+    maxLineBytes: MAX_LINE_BYTES,
+    onOversize() { send(rpcError(null, -32600, "JSON-RPC message exceeds maximum size")); },
+    onLine(line) {
+      void handleLine(line).catch((error) => {
+        logger.error("stdio request handler failed", { error_class: classifyOperationalError(error) });
+      });
+    },
   });
   for (const callId of pending.values()) runtime.cancelCall(callId, "stdio input closed");
   await Promise.allSettled([...writes]);
   runtime.stop();
 
   async function handleLine(line) {
-    let message;
-    try { message = JSON.parse(line); } catch {
-      send(rpcError(null, -32700, "Parse error"));
-      return;
-    }
-    if (!isJsonRpcMessage(message)) {
-      send(rpcError(null, -32600, "Invalid JSON-RPC message"));
+    const message = parseJsonRpcLine(line, send);
+    if (!message || typeof message.method !== "string") return;
+    if (handleControlMessage(message)) return;
+    if (!initialized) {
+      send(rpcError(message.id, -32002, "Server is not initialized"));
       return;
     }
-    if (typeof message.method !== "string") return;
+    await handleInitializedMessage(message);
+  }
 
+  function handleControlMessage(message) {
     if (message.method === "initialize") {
       const requested = asObject(message.params).protocolVersion;
       negotiatedVersion = typeof requested === "string" && MCP_SUPPORTED_PROTOCOL_VERSIONS.includes(requested)
         ? requested
         : MCP_PROTOCOL_VERSION;
       initialized = true;
-      send(rpcResult(message.id, {
-        protocolVersion: negotiatedVersion,
-        capabilities: { tools: { listChanged: false }, logging: {} },
-        serverInfo: {
-          name: SERVER_NAME,
-          title: "Machine Bridge MCP",
-          version: PACKAGE_VERSION,
-          description: "Workspace-scoped local coding tools over MCP stdio or authenticated remote relay.",
-        },
-        instructions: MCP_INSTRUCTIONS,
-      }));
-      return;
+      send(rpcResult(message.id, initializationResult(negotiatedVersion)));
+      return true;
     }
-
-    if (message.method === "notifications/initialized") return;
+    if (message.method === "notifications/initialized") return true;
     if (message.method === "notifications/cancelled") {
       const requestId = asObject(message.params).requestId;
-      const key = jsonRpcIdKey(requestId);
-      const callId = pending.get(key);
+      const callId = pending.get(jsonRpcIdKey(requestId));
       if (callId) runtime.cancelCall(callId, "MCP cancellation notification");
-      return;
+      return true;
     }
-    if (message.method === "logging/setLevel") {
+    if (message.method === "logging/setLevel" || message.method === "ping") {
       send(rpcResult(message.id, {}));
+      return true;
+    }
+    return false;
+  }
+
+  async function handleInitializedMessage(message) {
+    if (message.method === "tools/list") {
+      send(rpcResult(message.id, { tools: toolsForPolicy(policy) }));
       return;
     }
-    if (message.method === "ping") {
-      send(rpcResult(message.id, {}));
+    if (message.method === "tools/call") {
+      await handleToolCall(message);
       return;
     }
-    if (!initialized) {
-      send(rpcError(message.id, -32002, "Server is not initialized"));
+    send(rpcError(message.id, -32601, `Method not found: ${message.method}`));
+  }
+
+  async function handleToolCall(message) {
+    if (!("id" in message) || message.id === null) {
+      send(rpcError(null, -32600, "tools/call requires a non-null request id"));
       return;
     }
-    if (message.method === "tools/list") {
-      send(rpcResult(message.id, { tools: toolsForPolicy(policy) }));
+    const params = asObject(message.params);
+    const name = typeof params.name === "string" ? params.name : "";
+    if (!name) {
+      send(rpcError(message.id, -32602, "tools/call requires a tool name"));
       return;
     }
-    if (message.method === "tools/call") {
-      const params = asObject(message.params);
-      const name = typeof params.name === "string" ? params.name : "";
-      if (!name) {
-        send(rpcError(message.id, -32602, "tools/call requires a tool name"));
-        return;
-      }
-      const args = asObject(params.arguments);
-      const callId = `stdio_${randomBytes(16).toString("hex")}`;
-      const key = jsonRpcIdKey(message.id);
-      if (key && pending.has(key)) {
-        send(rpcError(message.id, -32600, "Duplicate in-flight JSON-RPC request id"));
-        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 });
-        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);
-        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) });
-      } finally {
-        if (key) pending.delete(key);
-        runtime.finishCall(callId);
-      }
+    const args = asObject(params.arguments);
+    const callId = `stdio_${randomBytes(16).toString("hex")}`;
+    const key = jsonRpcIdKey(message.id);
+    if (key && pending.has(key)) {
+      send(rpcError(message.id, -32600, "Duplicate in-flight JSON-RPC request id"));
       return;
     }
-    send(rpcError(message.id, -32601, `Method not found: ${message.method}`));
+    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 });
+      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) });
+    } finally {
+      if (key) pending.delete(key);
+      runtime.finishCall(callId);
+    }
+  }
+
+}
+
+function parseJsonRpcLine(line, send) {
+  let message;
+  try { message = JSON.parse(line); } catch {
+    send(rpcError(null, -32700, "Parse error"));
+    return null;
+  }
+  if (!isJsonRpcMessage(message)) {
+    send(rpcError(null, -32600, "Invalid JSON-RPC message"));
+    return null;
   }
+  return message;
+}
+
+function initializationResult(protocolVersion) {
+  return {
+    protocolVersion,
+    capabilities: { tools: { listChanged: false }, logging: {} },
+    serverInfo: {
+      name: SERVER_NAME,
+      title: "Machine Bridge MCP",
+      version: PACKAGE_VERSION,
+      description: "Workspace-scoped local coding tools over MCP stdio or authenticated remote relay.",
+    },
+    instructions: MCP_INSTRUCTIONS,
+  };
+}
+
+function consumeBoundedJsonLines(stream, { maxLineBytes, onLine, onOversize }) {
+  return new Promise((resolvePromise, rejectPromise) => {
+    let chunks = [];
+    let bytes = 0;
+    let discarding = false;
+    let settled = false;
+
+    const resetLine = () => { chunks = []; bytes = 0; };
+    const emitLine = () => {
+      let line = bytes ? Buffer.concat(chunks, bytes) : Buffer.alloc(0);
+      if (line.length && line[line.length - 1] === 13) line = line.subarray(0, line.length - 1);
+      resetLine();
+      onLine(line.toString("utf8"));
+    };
+    const onData = (input) => {
+      const buffer = Buffer.isBuffer(input) ? input : Buffer.from(input);
+      let offset = 0;
+      while (offset < buffer.length) {
+        const newline = buffer.indexOf(10, offset);
+        const end = newline === -1 ? buffer.length : newline;
+        const segment = buffer.subarray(offset, end);
+        if (discarding) {
+          if (newline !== -1) discarding = false;
+        } else if (bytes + segment.length > maxLineBytes) {
+          resetLine();
+          onOversize();
+          if (newline === -1) discarding = true;
+        } else {
+          if (segment.length) chunks.push(segment);
+          bytes += segment.length;
+          if (newline !== -1) emitLine();
+        }
+        offset = newline === -1 ? buffer.length : newline + 1;
+      }
+    };
+    const cleanup = () => {
+      stream.off("data", onData);
+      stream.off("end", onEnd);
+      stream.off("close", onEnd);
+      stream.off("error", onError);
+    };
+    const onEnd = () => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      if (!discarding && bytes > 0) emitLine();
+      resolvePromise();
+    };
+    const onError = (error) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      rejectPromise(error);
+    };
+    stream.on("data", onData);
+    stream.once("end", onEnd);
+    stream.once("close", onEnd);
+    stream.once("error", onError);
+  });
 }
 
 function isJsonRpcMessage(value) {

package/src/shared/server-metadata.json

@@ -12,6 +12,7 @@
     "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.",
     "A named full profile is canonical: it always enables writes, shell execution, unrestricted paths, the full parent environment, absolute paths, and the complete tool catalog. Any explicit narrowing is stored as custom.",
+    "The full catalog is what the local daemon and relay advertise. A connector host or platform can expose only a subset to a particular session; Machine Bridge cannot observe, authorize, or override that host-side filtering.",
     "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 through the local machine-mcp CLI; under canonical full policy, generate_ssh_key_resource can generate and register an Ed25519 key without returning private content 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.",

package/src/shared/tool-catalog.json

@@ -638,7 +638,7 @@
   {
     "name": "generate_ssh_key_resource",
     "title": "Generate SSH key resource",
-    "description": "Generate or reuse an Ed25519 SSH key pair on the local machine and register the private key file as a local resource alias. The private key content is never returned; only local paths, public fingerprint, permissions, and registration status are reported. Available only under canonical full policy.",
+    "description": "Generate or reuse an Ed25519 SSH key pair on the local machine and register the private key file as a local resource alias. Private key content is never returned. Local paths are omitted unless expose_paths=true; fingerprint, permissions, and registration status are returned. Available only under canonical full policy.",
     "availability": "full",
     "annotations": {
       "readOnlyHint": false,
@@ -660,6 +660,10 @@
         "comment": {
           "type": "string",
           "maxLength": 256
+        },
+        "expose_paths": {
+          "type": "boolean",
+          "description": "Return local private/public key paths. Defaults to false."
         }
       },
       "required": [

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.6.2";
+const SERVER_VERSION = "0.8.0";
 const MCP_PROTOCOL_VERSION = String(serverMetadata.protocolVersion);
 const MCP_SUPPORTED_PROTOCOL_VERSIONS = serverMetadata.supportedProtocolVersions.map((value) => String(value));
 const JSONRPC_VERSION = "2.0";
@@ -27,6 +27,7 @@ const AUTH_FAILURE_WINDOW_SECONDS = 10 * 60;
 const AUTH_BLOCK_SECONDS = 15 * 60;
 const AUTH_FAILURE_LIMIT = 10;
 const AUTHORIZATION_FIELDS = new Set(["response_type", "client_id", "redirect_uri", "code_challenge", "code_challenge_method", "scope", "resource", "state"]);
+const UNSAFE_DISPLAY_CONTROLS = /[\u0000-\u001f\u007f\u200B-\u200F\u202A-\u202E\u2066-\u2069\uFEFF]/g;
 
 interface BridgeEnv {
   BRIDGE: DurableObjectNamespace<BridgeRoom>;
@@ -292,13 +293,20 @@ export class BridgeRoom extends DurableObject<BridgeEnv> {
   }
 
   async webSocketClose(ws: WebSocket): Promise<void> {
+    await this.cleanupDaemonSocket(ws, "daemon disconnected");
+  }
+
+  async webSocketError(ws: WebSocket, error: unknown): Promise<void> {
+    console.error(JSON.stringify({ level: "warn", message: "daemon_websocket_error", error_class: workerErrorClass(error) }));
+    await this.cleanupDaemonSocket(ws, "daemon transport error");
+  }
+
+  private async cleanupDaemonSocket(ws: WebSocket, message: string): Promise<void> {
     await this.scheduleCandidateAlarm();
-    const attachment = this.daemonAttachment(ws);
-    if (!attachment) return;
     for (const [id, pending] of this.pending) {
       if (pending.socket !== ws) continue;
       clearTimeout(pending.timeout);
-      pending.reject(new Error("daemon disconnected"));
+      pending.reject(new Error(message));
       this.pending.delete(id);
     }
   }
@@ -361,6 +369,7 @@ export class BridgeRoom extends DurableObject<BridgeEnv> {
     if (request.method === "ping") return rpcResult(request.id, {});
     if (request.method === "tools/list") return rpcResult(request.id, { tools: this.allTools() });
     if (request.method === "tools/call") {
+      if (request.id === undefined || request.id === null) return rpcError(null, -32600, "tools/call requires a non-null request id");
       const params = asObject(request.params);
       const name = requiredString(params, "name");
       const args = asObject(params.arguments);
@@ -376,13 +385,22 @@ export class BridgeRoom extends DurableObject<BridgeEnv> {
 
   private async callTool(name: string, args: Record<string, unknown>, base: string, requestKey?: string): Promise<unknown> {
     if (name === "server_info") {
+      const daemon = this.daemonStatus(true);
+      const tools = this.allTools().map((tool) => tool.name);
       return {
         name: SERVER_NAME,
         version: SERVER_VERSION,
         mcp_url: `${base}/mcp`,
         oauth: this.authorizationServerMetadata(base),
-        daemon: this.daemonStatus(true),
-        tools: this.allTools().map((tool) => tool.name),
+        daemon,
+        tools,
+        tool_delivery: {
+          full_profile_scope: "local-daemon-and-relay-advertisement",
+          daemon_advertised_tool_count: daemon.tool_count,
+          relay_advertised_tool_count: tools.length,
+          host_exposed_tools_known_to_server: false,
+          host_may_expose_subset: true,
+        },
       };
     }
     if (workspaceTools.some((tool) => tool.name === name)) {
@@ -657,13 +675,15 @@ export class BridgeRoom extends DurableObject<BridgeEnv> {
     if (redirectUris.length > 5) {
       return json({ error: "invalid_client_metadata", error_description: "redirect_uris must contain at most 5 entries" }, 400);
     }
-    const normalized = [...new Set(redirectUris.map((item) => String(item)))];
-    if (normalized.some((item) => item.length > 1024)) {
+    const suppliedRedirectUris = redirectUris.map((item) => String(item));
+    if (suppliedRedirectUris.some((item) => item.length > 1024)) {
       return json({ error: "invalid_client_metadata", error_description: "redirect_uri is too long" }, 400);
     }
-    if (!normalized.every(isAllowedRedirectUri)) {
-      return json({ error: "invalid_client_metadata", error_description: "redirect_uris must be https or local http" }, 400);
+    const canonicalRedirectUris = suppliedRedirectUris.map(normalizeRedirectUri);
+    if (canonicalRedirectUris.some((item) => item === null)) {
+      return json({ error: "invalid_client_metadata", error_description: "redirect_uris must be canonicalizable https or local http URLs without credentials or fragments" }, 400);
     }
+    const normalized = [...new Set(canonicalRedirectUris as string[])];
 
     return this.withOAuthLock(async () => {
       const store = await this.oauthStore();
@@ -725,7 +745,11 @@ export class BridgeRoom extends DurableObject<BridgeEnv> {
       .filter(([key]) => AUTHORIZATION_FIELDS.has(key))
       .map(([key, value]) => `<input type="hidden" name="${escapeHtml(key)}" value="${escapeHtml(String(value))}">`)
       .join("\n");
-    const resource = authorization?.requestedResource ?? String(submitted?.resource ?? url.searchParams.get("resource") ?? `${base}/mcp`);
+    const resource = normalizeDisplayText(
+      authorization?.requestedResource ?? String(submitted?.resource ?? url.searchParams.get("resource") ?? `${base}/mcp`),
+      1024,
+      `${base}/mcp`,
+    );
     const clientBlock = authorization
       ? `<p><strong>Client:</strong> ${escapeHtml(authorization.client.client_name)}</p>
     <p><strong>Redirect URI:</strong> <code>${escapeHtml(authorization.redirectUri)}</code></p>`
@@ -971,7 +995,7 @@ function isFreshDaemonCandidate(connectedAt: string): boolean {
 
 function sanitizeMetadataText(value: unknown, maxLength: number): string | undefined {
   if (typeof value !== "string") return undefined;
-  const normalized = value.replace(/[\u0000-\u001f\u007f]/g, " ").replace(/\s+/g, " ").trim();
+  const normalized = value.replace(UNSAFE_DISPLAY_CONTROLS, " ").replace(/\s+/g, " ").trim();
   return normalized ? normalized.slice(0, maxLength) : undefined;
 }
 
@@ -1272,15 +1296,15 @@ async function pkceS256(verifier: string): Promise<string> {
   return base64Url(new Uint8Array(digest));
 }
 
-function isAllowedRedirectUri(value: string): boolean {
+function normalizeRedirectUri(value: string): string | null {
   try {
     const url = new URL(value);
-    if (url.username || url.password || url.hash) return false;
-    if (url.protocol === "https:" && url.hostname) return true;
-    if (url.protocol === "http:" && isLoopbackHost(url.hostname)) return true;
-    return false;
+    if (url.username || url.password || url.hash) return null;
+    if (url.protocol === "https:" && url.hostname) return url.toString();
+    if (url.protocol === "http:" && isLoopbackHost(url.hostname)) return url.toString();
+    return null;
   } catch {
-    return false;
+    return null;
   }
 }
 
@@ -1359,9 +1383,9 @@ function searchParamsObject(params: URLSearchParams): Record<string, unknown> {
   return out;
 }
 
-function normalizeDisplayText(value: string, maxLength: number): string {
-  const normalized = value.replace(/[\u0000-\u001f\u007f]/g, " ").replace(/\s+/g, " ").trim();
-  return (normalized || "MCP Client").slice(0, maxLength);
+function normalizeDisplayText(value: string, maxLength: number, fallback = "MCP Client"): string {
+  const normalized = value.replace(UNSAFE_DISPLAY_CONTROLS, " ").replace(/\s+/g, " ").trim();
+  return (normalized || fallback).slice(0, maxLength);
 }
 
 function escapeHtml(value: string): string {

package/wrangler.jsonc

@@ -2,7 +2,7 @@
   "$schema": "./node_modules/wrangler/config-schema.json",
   "name": "machine-bridge-mcp",
   "main": "src/worker/index.ts",
-  "compatibility_date": "2026-07-09",
+  "compatibility_date": "2026-07-11",
   "compatibility_flags": ["nodejs_compat"],
   "workers_dev": true,
   "durable_objects": {