machine-bridge-mcp 3.0.0-beta.17 → 3.0.0-beta.21

package/src/worker/runtime-alarm.ts

@@ -4,13 +4,10 @@ import {
   daemonReadyDeadlineMs,
 } from "./daemon-liveness.ts";
 import type { DaemonSocketRegistry } from "./daemon-sockets.ts";
+import type { McpPendingCallStore, PendingStreamCallView } from "./mcp-pending-call-store.ts";
 import type { PendingCallRegistry } from "./pending-calls.ts";
 import { closeWebSocketQuietly, sendWebSocketQuietly } from "./websocket-protocol.ts";
-
-interface AlarmStorage {
-  setAlarm(scheduledTime: number | Date): Promise<void>;
-  deleteAlarm(): Promise<void>;
-}
+import { writeEarliestRuntimeAlarm, type AlarmStorage } from "./runtime-alarm-storage.ts";
 
 type InvalidateDaemonSocket = (
   socket: WebSocket,
@@ -22,14 +19,20 @@ type InvalidateDaemonSocket = (
 interface RuntimeAlarmContext {
   storage: AlarmStorage;
   pending: PendingCallRegistry;
+  durableCalls?: Pick<McpPendingCallStore, "due" | "nextDeadlineDelayMs">;
+  expireDurableCall?: (call: PendingStreamCallView) => Promise<void>;
   daemonRegistry: DaemonSocketRegistry;
   invalidateDaemonSocket: InvalidateDaemonSocket;
   onScheduleError: (error: unknown) => void;
+  onAlarmMutation?: (action: "set" | "delete" | "noop") => void;
 }
 
 export async function processRuntimeAlarm(context: RuntimeAlarmContext, now = Date.now()): Promise<void> {
   await context.pending.expireDue();
-  let nextDeadline = pendingAlarmDeadline(context.pending, now);
+  if (context.durableCalls && context.expireDurableCall) {
+    for (const call of await context.durableCalls.due(now)) await context.expireDurableCall(call);
+  }
+  let nextDeadline = await pendingAlarmDeadline(context, now);
   for (const socket of context.daemonRegistry.candidateSockets()) {
     const attachment = context.daemonRegistry.attachment(socket);
     const connectedAt = Date.parse(attachment?.connectedAt ?? "");
@@ -65,11 +68,17 @@ export async function processRuntimeAlarm(context: RuntimeAlarmContext, now = Da
     }
     nextDeadline = Math.min(nextDeadline, deadline);
   }
-  await writeRuntimeAlarm(context, nextDeadline, now);
+  await writeEarliestRuntimeAlarm({
+    storage: context.storage,
+    nextDeadline,
+    now,
+    onError: context.onScheduleError,
+    onMutation: context.onAlarmMutation,
+  });
 }
 
 export async function scheduleRuntimeAlarm(context: RuntimeAlarmContext, now = Date.now()): Promise<void> {
-  let nextDeadline = pendingAlarmDeadline(context.pending, now);
+  let nextDeadline = await pendingAlarmDeadline(context, now);
   for (const socket of context.daemonRegistry.candidateSockets()) {
     const connectedAt = Date.parse(context.daemonRegistry.attachment(socket)?.connectedAt ?? "");
     if (!Number.isFinite(connectedAt)) {
@@ -101,19 +110,20 @@ export async function scheduleRuntimeAlarm(context: RuntimeAlarmContext, now = D
     }
     nextDeadline = Math.min(nextDeadline, deadline);
   }
-  await writeRuntimeAlarm(context, nextDeadline, now);
+  await writeEarliestRuntimeAlarm({
+    storage: context.storage,
+    nextDeadline,
+    now,
+    onError: context.onScheduleError,
+    onMutation: context.onAlarmMutation,
+  });
 }
 
-function pendingAlarmDeadline(pending: PendingCallRegistry, now: number): number {
-  const delay = pending.nextDeadlineDelayMs();
+async function pendingAlarmDeadline(context: RuntimeAlarmContext, now: number): Promise<number> {
+  const transientDelay = context.pending.nextDeadlineDelayMs();
+  const durableDelay = context.durableCalls
+    ? await context.durableCalls.nextDeadlineDelayMs()
+    : Number.POSITIVE_INFINITY;
+  const delay = Math.min(transientDelay, durableDelay);
   return Number.isFinite(delay) ? now + Math.max(1, Math.ceil(delay)) : Number.POSITIVE_INFINITY;
 }
-
-async function writeRuntimeAlarm(context: RuntimeAlarmContext, nextDeadline: number, now: number): Promise<void> {
-  try {
-    if (Number.isFinite(nextDeadline)) await context.storage.setAlarm(Math.max(now, nextDeadline));
-    else await context.storage.deleteAlarm();
-  } catch (error) {
-    context.onScheduleError(error);
-  }
-}

package/src/worker/websocket-protocol.ts

@@ -21,6 +21,10 @@ export function sendWebSocketQuietly(ws: WebSocket, value: unknown): void {
   trySendWebSocket(ws, value);
 }
 
+export function daemonErrorCloseCode(errorCode: string): number {
+  return errorCode === "daemon_transport_error" || errorCode === "daemon_liveness_timeout" ? 1012 : 1008;
+}
+
 export function closeWebSocketQuietly(ws: WebSocket, code?: number, reason?: string): void {
   try {
     ws.close(code, reason);

package/src/worker/worker-edge-guard.ts

@@ -0,0 +1,81 @@
+import { applyCors, baseUrl, json } from "./http.ts";
+import { createThrottledEdgeLogger } from "./worker-edge-log.ts";
+
+type RateLimiter = { limit(input: { key: string }): Promise<{ success: boolean }> };
+const logLimiterFailure = createThrottledEdgeLogger();
+
+export async function admitStatefulRequest(request: Request, limiter: RateLimiter, extraOrigins = ""): Promise<Response | null> {
+  const key = `stateful:${new URL(request.url).host.toLowerCase()}`;
+  let result: { success: boolean };
+  try {
+    result = await limiter.limit({ key });
+  } catch {
+    logLimiterFailure("warn", "stateful.rate_limiter.unavailable");
+    return null;
+  }
+  if (result.success) return null;
+  return applyCors(json({
+    error: "rate_limit_exceeded",
+    message: "The remote bridge is temporarily limiting stateful requests.",
+    retryable: true,
+  }, 429, { "retry-after": "60" }), request, baseUrl(request), extraOrigins);
+}
+
+export function isDurableObjectQuotaError(error: unknown): boolean {
+  for (const current of boundedErrorChain(error)) {
+    const message = current instanceof Error ? current.message : String(current ?? "");
+    const code = typeof current === "object" && current !== null ? String((current as { code?: unknown }).code ?? "") : "";
+    if (/Exceeded allowed volume of requests in Durable Objects free tier/i.test(message)) return true;
+    if (/Durable Objects free tier/i.test(message) && /quota|limit|exceed|volume/i.test(message)) return true;
+    if (code === "ERR_DURABLE_OBJECT_QUOTA_EXCEEDED") return true;
+  }
+  return false;
+}
+
+export function durableObjectQuotaResponse(request: Request, extraOrigins = ""): Response {
+  return errorResponse(request, extraOrigins, 503, "durable_object_quota_exceeded",
+    "Durable Objects free-tier capacity is exhausted until the daily UTC reset.", "3600");
+}
+
+export function workerGatewayErrorResponse(request: Request, extraOrigins = ""): Response {
+  return errorResponse(request, extraOrigins, 502, "worker_gateway_error",
+    "The remote bridge could not reach its durable state owner.", "1");
+}
+
+export function outerWorkerErrorClass(error: unknown): string {
+  const parts: string[] = [];
+  for (const current of boundedErrorChain(error)) {
+    if (typeof current !== "object" || current === null) break;
+    const name = String((current as { name?: unknown }).name ?? "");
+    const code = String((current as { code?: unknown }).code ?? "");
+    if (name) parts.push(name);
+    if (code) parts.push(code);
+  }
+  return (parts.join(":") || "unknown").toLowerCase().replace(/[^a-z0-9._:-]/g, "_").slice(0, 160);
+}
+
+function errorResponse(request: Request, extraOrigins: string, status: number, error: string, message: string, retryAfter: string): Response {
+  return applyCors(json({ error, message, retryable: true }, status, { "retry-after": retryAfter }),
+    request, baseUrl(request), extraOrigins);
+}
+
+function boundedErrorChain(value: unknown): unknown[] {
+  const chain: unknown[] = [];
+  const seen = new WeakSet<object>();
+  let current: unknown = value;
+  while (current !== undefined && chain.length < 8) {
+    if (!isObjectLike(current)) {
+      chain.push(current);
+      break;
+    }
+    if (seen.has(current)) break;
+    seen.add(current);
+    chain.push(current);
+    current = (current as { cause?: unknown }).cause;
+  }
+  return chain;
+}
+
+function isObjectLike(value: unknown): value is object {
+  return typeof value === "object" && value !== null;
+}

package/src/worker/worker-edge-log.ts

@@ -0,0 +1,63 @@
+type EdgeLogLevel = "warn" | "error";
+type EdgeLogWriter = (level: EdgeLogLevel, text: string) => void;
+const SENSITIVE_FIELD = /(?:authorization|cookie|password|secret|token|key|credential|proof)/i;
+
+export function createThrottledEdgeLogger(options: {
+  intervalMs?: number;
+  now?: () => number;
+  write?: EdgeLogWriter;
+} = {}): (level: EdgeLogLevel, event: string, fields?: Record<string, unknown>) => boolean {
+  const intervalMs = positiveInterval(options.intervalMs, 60_000);
+  const now = options.now ?? Date.now;
+  const write = options.write ?? defaultWrite;
+  let nextAt = 0;
+  let suppressed = 0;
+  return (level, event, fields = {}) => {
+    const current = now();
+    if (current < nextAt) {
+      suppressed += 1;
+      return false;
+    }
+    const entry = {
+      ...safeFields(fields),
+      ...(suppressed > 0 ? { suppressed } : {}),
+      timestamp: new Date(current).toISOString(),
+      level,
+      component: "worker-edge",
+      event: safeName(event),
+    };
+    suppressed = 0;
+    nextAt = current + intervalMs;
+    write(level, JSON.stringify(entry));
+    return true;
+  };
+}
+
+function safeFields(fields: Record<string, unknown>): Record<string, unknown> {
+  const out: Record<string, unknown> = {};
+  for (const [key, value] of Object.entries(fields).slice(0, 16)) {
+    const name = safeName(key);
+    if (!name) continue;
+    if (SENSITIVE_FIELD.test(name)) {
+      out[name] = "<redacted>";
+      continue;
+    }
+    if (typeof value === "number" || typeof value === "boolean" || value === null) out[name] = value;
+    else if (typeof value === "string") out[name] = value.replace(/[\u0000-\u001f\u007f]/g, "_").slice(0, 160);
+  }
+  return out;
+}
+
+function safeName(value: unknown): string {
+  return String(value || "").toLowerCase().replace(/[^a-z0-9._-]/g, "_").slice(0, 96);
+}
+
+function positiveInterval(value: unknown, fallback: number): number {
+  const parsed = Number(value);
+  return Number.isFinite(parsed) && parsed > 0 ? Math.floor(parsed) : fallback;
+}
+
+function defaultWrite(level: EdgeLogLevel, text: string): void {
+  if (level === "error") console.error(text);
+  else console.warn(text);
+}

package/src/worker/worker-entry.ts

@@ -0,0 +1,50 @@
+import {
+  proxyMcpEventStream,
+  sanitizeBridgeRequest,
+} from "./mcp-stream-proxy.ts";
+import { respondWithoutDurableObject } from "./worker-static-routes.ts";
+import { createThrottledEdgeLogger } from "./worker-edge-log.ts";
+import {
+  admitStatefulRequest,
+  durableObjectQuotaResponse,
+  isDurableObjectQuotaError,
+  outerWorkerErrorClass,
+  workerGatewayErrorResponse,
+} from "./worker-edge-guard.ts";
+
+type OuterBridgeStub = { fetch(request: Request): Promise<Response> };
+type OuterBridgeNamespace = { getByName(name: string): OuterBridgeStub };
+
+export interface OuterWorkerEnv {
+  BRIDGE: OuterBridgeNamespace;
+  STATEFUL_RATE_LIMITER: RateLimit;
+  MBM_ALLOWED_ORIGINS?: string;
+}
+
+const logOuterFetchFailure = createThrottledEdgeLogger();
+
+export async function handleOuterWorkerFetch(
+  request: Request,
+  env: OuterWorkerEnv,
+  ctx: ExecutionContext,
+  identity: { server: string; version: string },
+): Promise<Response> {
+  const extraOrigins = env.MBM_ALLOWED_ORIGINS ?? "";
+  const staticResponse = respondWithoutDurableObject(request, identity, extraOrigins);
+  if (staticResponse) return staticResponse;
+
+  try {
+    const limited = await admitStatefulRequest(request, env.STATEFUL_RATE_LIMITER, extraOrigins);
+    if (limited) return limited;
+    const stub = env.BRIDGE.getByName("default");
+    const streamed = await proxyMcpEventStream({ request, bridge: stub, extraOrigins, ctx });
+    return streamed ?? stub.fetch(sanitizeBridgeRequest(request));
+  } catch (error) {
+    if (isDurableObjectQuotaError(error)) return durableObjectQuotaResponse(request, extraOrigins);
+    logOuterFetchFailure("error", "outer.fetch.failed", {
+      path: new URL(request.url).pathname,
+      error_class: outerWorkerErrorClass(error),
+    });
+    return workerGatewayErrorResponse(request, extraOrigins);
+  }
+}

package/src/worker/worker-metadata.ts

@@ -0,0 +1,39 @@
+import serverMetadata from "../shared/server-metadata.json" with { type: "json" };
+
+export type WorkerIdentity = { server: string; version: string };
+
+export function mcpMetadata(base: string, identity: WorkerIdentity): Record<string, unknown> {
+  return {
+    name: identity.server,
+    version: identity.version,
+    protocolVersion: String(serverMetadata.protocolVersion),
+    protocolVersions: serverMetadata.supportedProtocolVersions.map((value) => String(value)),
+    transport: { type: "streamable-http", url: `${base}/mcp` },
+    auth: { type: "oauth", authorization_servers: [base] },
+  };
+}
+
+export function authorizationServerMetadata(base: string, serverName: string): Record<string, unknown> {
+  return {
+    issuer: base,
+    authorization_endpoint: `${base}/oauth/authorize`,
+    token_endpoint: `${base}/oauth/token`,
+    registration_endpoint: `${base}/oauth/register`,
+    response_types_supported: ["code"],
+    grant_types_supported: ["authorization_code", "refresh_token"],
+    token_endpoint_auth_methods_supported: ["none"],
+    dpop_signing_alg_values_supported: ["ES256"],
+    code_challenge_methods_supported: ["S256"],
+    scopes_supported: [serverName, "offline_access"],
+  };
+}
+
+export function protectedResourceMetadata(base: string, serverName: string): Record<string, unknown> {
+  return {
+    resource: `${base}/mcp`,
+    authorization_servers: [base],
+    scopes_supported: [serverName, "offline_access"],
+    bearer_methods_supported: ["header"],
+    resource_name: serverName,
+  };
+}

package/src/worker/worker-static-routes.ts

@@ -1,60 +1,48 @@
+import { applyCors, baseUrl, corsPreflight, json, methodNotAllowed } from "./http.ts";
 import {
-  applyCors,
-  baseUrl,
-  corsPreflight,
-  json,
-  methodNotAllowed,
-} from "./http.ts";
+  authorizationServerMetadata, mcpMetadata, protectedResourceMetadata, type WorkerIdentity,
+} from "./worker-metadata.ts";
 
-export function respondWithoutDurableObject(
-  request: Request,
-  identity: { server: string; version: string },
-  extraOrigins = "",
-): Response | null {
+const STATEFUL_METHODS = new Map([
+  ["/admin/accounts", "GET, POST, PATCH, DELETE"],
+  ["/admin/accounts/rotate-password", "POST"],
+  ["/admin/clients", "GET, DELETE"],
+  ["/daemon/ws", "GET"],
+  ["/mcp", "GET, POST"],
+  ["/oauth/authorize", "GET, POST"],
+  ["/oauth/register", "POST"],
+  ["/oauth/token", "POST"],
+]);
+const AUTHORIZATION_METADATA_PATHS = new Set([
+  "/.well-known/oauth-authorization-server", "/.well-known/oauth-authorization-server/mcp",
+  "/.well-known/openid-configuration", "/.well-known/openid-configuration/mcp",
+]);
+const PROTECTED_RESOURCE_PATHS = new Set([
+  "/.well-known/oauth-protected-resource", "/.well-known/oauth-protected-resource/mcp",
+]);
+
+export function respondWithoutDurableObject(request: Request, identity: WorkerIdentity, extraOrigins = ""): Response | null {
   const url = new URL(request.url);
   const base = baseUrl(request);
   const path = url.pathname;
-  const serverName = identity.server;
-  const serverVersion = identity.version;
-
-  if (request.method === "OPTIONS" && request.headers.has("Origin")) {
-    // CORS preflight does not need Durable Object state and must not consume DO quota.
-    return corsPreflight(request, base, extraOrigins);
-  }
-
-  if (path === "/healthz") {
-    if (request.method !== "GET") return applyCors(methodNotAllowed("GET"), request, base, extraOrigins);
-    return applyCors(json({ ok: true, server: serverName, version: serverVersion }), request, base, extraOrigins);
+  if (request.method === "OPTIONS" && request.headers.has("Origin")) return corsPreflight(request, base, extraOrigins);
+  const statefulMethods = STATEFUL_METHODS.get(path);
+  if (statefulMethods) {
+    const allowed = new Set(statefulMethods.split(",").map((method) => method.trim()));
+    if (allowed.has(request.method)) return null;
+    return applyCors(methodNotAllowed(statefulMethods), request, base, extraOrigins);
   }
 
-  if (path === "/") {
-    if (request.method !== "GET") return applyCors(methodNotAllowed("GET"), request, base, extraOrigins);
-    return applyCors(
-      json({ ok: true, server: serverName, version: serverVersion, mcp: `${base}/mcp` }),
-      request,
-      base,
-      extraOrigins,
-    );
-  }
-
-  return null;
-}
-
-export function isDurableObjectQuotaError(error: unknown): boolean {
-  const message = error instanceof Error ? error.message : String(error ?? "");
-  return /Exceeded allowed volume of requests in Durable Objects free tier/i.test(message)
-    || /Durable Objects free tier/i.test(message);
+  let response: Response;
+  if (path === "/healthz") response = getOnly(request, json({ ok: true, server: identity.server, version: identity.version }));
+  else if (path === "/") response = getOnly(request, json({ ok: true, server: identity.server, version: identity.version, mcp: `${base}/mcp` }));
+  else if (path === "/.well-known/mcp.json") response = getOnly(request, json(mcpMetadata(base, identity)));
+  else if (AUTHORIZATION_METADATA_PATHS.has(path)) response = getOnly(request, json(authorizationServerMetadata(base, identity.server)));
+  else if (PROTECTED_RESOURCE_PATHS.has(path)) response = getOnly(request, json(protectedResourceMetadata(base, identity.server)));
+  else response = json({ error: "not_found" }, 404);
+  return applyCors(response, request, base, extraOrigins);
 }
 
-export function durableObjectQuotaResponse(request: Request, extraOrigins = ""): Response {
-  return applyCors(
-    json({
-      error: "durable_object_quota_exceeded",
-      message: "Durable Objects free-tier request volume is exhausted until the daily UTC reset.",
-      retryable: true,
-    }, 503),
-    request,
-    baseUrl(request),
-    extraOrigins,
-  );
+function getOnly(request: Request, response: Response): Response {
+  return request.method === "GET" ? response : methodNotAllowed("GET");
 }

package/wrangler.jsonc

@@ -5,6 +5,14 @@
   "compatibility_date": "2026-07-11",
   "compatibility_flags": ["nodejs_compat", "enable_request_signal", "request_signal_passthrough"],
   "workers_dev": true,
+  "preview_urls": false,
+  "ratelimits": [
+    {
+      "name": "STATEFUL_RATE_LIMITER",
+      "namespace_id": "4301701",
+      "simple": { "limit": 120, "period": 60 }
+    }
+  ],
   "durable_objects": {
     "bindings": [
       {