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

package/src/worker/daemon-socket-attachment.ts

@@ -0,0 +1,52 @@
+import { sanitizeDaemonChallengeAttachment } from "./daemon-auth.ts";
+import type { DaemonRole } from "./daemon-liveness.ts";
+import { sanitizeMetadataText } from "./http.ts";
+import { sanitizeDaemonPolicy, sanitizeDaemonTools, type DaemonPolicy } from "./policy.ts";
+
+export interface DaemonAttachment {
+  role: DaemonRole;
+  connectedAt: string;
+  lastSeenAt?: string;
+  probeId?: string;
+  instanceId?: string;
+  connectionId?: string;
+  policy?: DaemonPolicy;
+  tools?: string[];
+  authChallenge?: string;
+  authIssuedAt?: number;
+  authExpiresAt?: number;
+  workerOrigin?: string;
+  authSessionPublicKeyJson?: string;
+  authSessionKeyId?: string;
+  authCertificateExpiresAt?: number;
+}
+
+export function sanitizeDaemonAttachment(value: unknown): DaemonAttachment | undefined {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return undefined;
+  const candidate = value as Partial<DaemonAttachment>;
+  if (!["candidate", "probing", "expired", "daemon"].includes(String(candidate.role))) return undefined;
+  const policy = sanitizeDaemonPolicy(candidate.policy);
+  return {
+    role: candidate.role as DaemonRole,
+    connectedAt: sanitizeMetadataText(candidate.connectedAt, 64) ?? "",
+    lastSeenAt: sanitizeMetadataText(candidate.lastSeenAt, 64),
+    probeId: sanitizeProbeId(candidate.probeId),
+    instanceId: sanitizeDaemonInstanceId(candidate.instanceId),
+    connectionId: sanitizeConnectionId(candidate.connectionId),
+    policy,
+    tools: sanitizeDaemonTools(candidate.tools, policy),
+    ...sanitizeDaemonChallengeAttachment(candidate as Record<string, unknown>),
+  };
+}
+
+function sanitizeProbeId(value: unknown): string | undefined {
+  return typeof value === "string" && /^probe_[A-Za-z0-9_-]{8,240}$/.test(value) ? value : undefined;
+}
+
+function sanitizeDaemonInstanceId(value: unknown): string | undefined {
+  return typeof value === "string" && /^daemon_[A-Za-z0-9_-]{16,96}$/.test(value) ? value : undefined;
+}
+
+function sanitizeConnectionId(value: unknown): string | undefined {
+  return typeof value === "string" && /^connection_[A-Za-z0-9_-]{43}$/.test(value) ? value : undefined;
+}

package/src/worker/daemon-sockets.ts

@@ -1,24 +1,7 @@
 import { isLiveDaemonAttachment, withDaemonLastSeenAt, type DaemonRole } from "./daemon-liveness.ts";
-import { sanitizeMetadataText } from "./http.ts";
-import { sanitizeDaemonPolicy, sanitizeDaemonTools, type DaemonPolicy } from "./policy.ts";
-import { sanitizeDaemonChallengeAttachment, type DaemonChallenge } from "./daemon-auth.ts";
-export interface DaemonAttachment {
-  role: DaemonRole;
-  connectedAt: string;
-  lastSeenAt?: string;
-  probeId?: string;
-  instanceId?: string;
-  policy?: DaemonPolicy;
-  tools?: string[];
-  authChallenge?: string;
-  authIssuedAt?: number;
-  authExpiresAt?: number;
-  workerOrigin?: string;
-  authSessionPublicKeyJson?: string;
-  authSessionKeyId?: string;
-  authCertificateExpiresAt?: number;
-}
-
+import type { DaemonPolicy } from "./policy.ts";
+import type { DaemonChallenge } from "./daemon-auth.ts";
+import { sanitizeDaemonAttachment, type DaemonAttachment } from "./daemon-socket-attachment.ts";
 interface WebSocketContext {
   getWebSockets(): WebSocket[];
 }
@@ -28,21 +11,7 @@ export class DaemonSocketRegistry {
   constructor(context: WebSocketContext) { this.context = context; }
 
   attachment(socket: WebSocket): DaemonAttachment | undefined {
-    const raw = socket.deserializeAttachment();
-    if (!raw || typeof raw !== "object") return undefined;
-    const candidate = raw as Partial<DaemonAttachment>;
-    if (!["candidate", "probing", "expired", "daemon"].includes(String(candidate.role))) return undefined;
-    const policy = sanitizeDaemonPolicy(candidate.policy);
-    return {
-      role: candidate.role as DaemonRole,
-      connectedAt: sanitizeMetadataText(candidate.connectedAt, 64) ?? "",
-      lastSeenAt: sanitizeMetadataText(candidate.lastSeenAt, 64),
-      probeId: sanitizeProbeId(candidate.probeId),
-      instanceId: sanitizeDaemonInstanceId(candidate.instanceId),
-      policy,
-      tools: sanitizeDaemonTools(candidate.tools, policy),
-      ...sanitizeDaemonChallengeAttachment(candidate as Record<string, unknown>),
-    };
+    return sanitizeDaemonAttachment(socket.deserializeAttachment());
   }
 
   readyAttachment(socket: WebSocket): DaemonAttachment | undefined {
@@ -68,11 +37,13 @@ export class DaemonSocketRegistry {
     socket: WebSocket,
     challenge: DaemonChallenge,
     preflight: { sessionPublicKeyJson: string; sessionKeyId: string; certificateExpiresAt: number },
+    connectionId: string,
     connectedAt = new Date().toISOString(),
   ): void {
     socket.serializeAttachment({
       role: "candidate",
       connectedAt,
+      connectionId,
       authChallenge: challenge.challenge,
       authIssuedAt: challenge.issuedAt,
       authExpiresAt: challenge.expiresAt,
@@ -83,10 +54,11 @@ export class DaemonSocketRegistry {
     } satisfies DaemonAttachment);
   }
 
-  beginProbe(socket: WebSocket, values: { connectedAt: string; probeId: string; instanceId: string; policy: DaemonPolicy; tools: string[] }): void {
+  beginProbe(socket: WebSocket, values: { connectedAt: string; probeId: string; instanceId: string; connectionId: string; policy: DaemonPolicy; tools: string[] }): void {
     socket.serializeAttachment({
       role: "probing", connectedAt: values.connectedAt, lastSeenAt: values.connectedAt,
-      probeId: values.probeId, instanceId: values.instanceId, policy: values.policy, tools: values.tools,
+      probeId: values.probeId, instanceId: values.instanceId, connectionId: values.connectionId,
+      policy: values.policy, tools: values.tools,
     } satisfies DaemonAttachment);
   }
 
@@ -111,10 +83,17 @@ export class DaemonSocketRegistry {
     const attachment = this.attachment(socket);
     if (!attachment) return;
     socket.serializeAttachment({
-      role: "expired", connectedAt: attachment.connectedAt, lastSeenAt: attachment.lastSeenAt, instanceId: attachment.instanceId,
+      role: "expired", connectedAt: attachment.connectedAt, lastSeenAt: attachment.lastSeenAt,
+      instanceId: attachment.instanceId, connectionId: attachment.connectionId,
     } satisfies DaemonAttachment);
   }
 
+  socketForConnectionId(connectionId: string): WebSocket | undefined {
+    if (!connectionId) return undefined;
+    return this.context.getWebSockets().find((socket) =>
+      this.attachment(socket)?.connectionId === connectionId && socket.readyState === WebSocket.OPEN);
+  }
+
   private openSockets(role: DaemonRole): WebSocket[] {
     return this.context.getWebSockets().filter((socket) => this.attachment(socket)?.role === role && socket.readyState === WebSocket.OPEN);
   }
@@ -123,13 +102,3 @@ export class DaemonSocketRegistry {
     return Date.parse(this.attachment(socket)?.connectedAt ?? "") || 0;
   }
 }
-
-function sanitizeProbeId(value: unknown): string | undefined {
-  if (typeof value !== "string" || !/^probe_[A-Za-z0-9_-]{8,240}$/.test(value)) return undefined;
-  return value;
-}
-
-function sanitizeDaemonInstanceId(value: unknown): string | undefined {
-  if (typeof value !== "string" || !/^daemon_[A-Za-z0-9_-]{16,96}$/.test(value)) return undefined;
-  return value;
-}

package/src/worker/durable-stream-calls.ts

@@ -0,0 +1,129 @@
+import { daemonLastSeenMs } from "./daemon-liveness.ts";
+import type { DaemonSocketRegistry } from "./daemon-sockets.ts";
+import { publicWorkerToolError, WorkerToolError } from "./errors.ts";
+import { workerErrorClass } from "./http.ts";
+import type { PendingCallOutcome } from "./pending-call-contract.ts";
+import type { McpPendingCallStore, PendingStreamCallView } from "./mcp-pending-call-store.ts";
+import { streamTerminalMessage } from "./mcp-stream-dispatch.ts";
+import { transformDurableStreamOutcome } from "./durable-stream-result.ts";
+import type { WorkerObservability } from "./observability.ts";
+import { sendWebSocketQuietly } from "./websocket-protocol.ts";
+
+type InvalidateDaemonSocket = (
+  socket: WebSocket,
+  message: string,
+  closeReason: string,
+  errorCode?: string,
+) => Promise<void>;
+
+type TransientPendingSnapshot = {
+  active: number;
+  detached: number;
+  request_keys: number;
+  oldest_ms: number;
+  by_tool: Record<string, number>;
+};
+
+export class DurableStreamCallCoordinator {
+  private readonly calls: McpPendingCallStore;
+  private readonly daemonRegistry: DaemonSocketRegistry;
+  private readonly observability: WorkerObservability;
+  private readonly maximumPendingCalls: number;
+  private readonly invalidateDaemonSocket: InvalidateDaemonSocket;
+
+  constructor(
+    calls: McpPendingCallStore,
+    daemonRegistry: DaemonSocketRegistry,
+    observability: WorkerObservability,
+    maximumPendingCalls: number,
+    invalidateDaemonSocket: InvalidateDaemonSocket,
+  ) {
+    this.calls = calls;
+    this.daemonRegistry = daemonRegistry;
+    this.observability = observability;
+    this.maximumPendingCalls = maximumPendingCalls;
+    this.invalidateDaemonSocket = invalidateDaemonSocket;
+  }
+
+  async snapshot(transient: TransientPendingSnapshot): Promise<Record<string, unknown>> {
+    const durable = await this.calls.snapshot(this.maximumPendingCalls);
+    const byTool = Object.assign(Object.create(null) as Record<string, number>, transient.by_tool);
+    for (const [tool, count] of Object.entries(durable.by_tool)) byTool[tool] = (byTool[tool] ?? 0) + count;
+    return {
+      active: transient.active + durable.active,
+      detached: transient.detached + durable.detached,
+      request_keys: transient.request_keys + durable.request_keys,
+      maximum: this.maximumPendingCalls,
+      oldest_ms: Math.max(transient.oldest_ms, durable.oldest_ms),
+      by_tool: byTool,
+      transient: transient.active,
+      durable_streams: durable.active,
+    };
+  }
+
+  async settle(
+    callId: string,
+    connectionId: string,
+    outcome: PendingCallOutcome,
+    knownCall?: PendingStreamCallView,
+  ): Promise<boolean> {
+    const call = knownCall ?? await this.calls.get(callId);
+    if (!call || call.connection_id !== connectionId) return false;
+    const normalized = transformDurableStreamOutcome(call, outcome);
+    const code = normalized.ok ? "" : publicWorkerToolError(normalized.error).code;
+    try {
+      const completed = await this.calls.complete(
+        callId,
+        connectionId,
+        streamTerminalMessage(call.requestId, normalized),
+      );
+      if (!completed) return false;
+    } catch (error) {
+      this.observability.event("error", "mcp.stream.persist.failed", { error_class: workerErrorClass(error) });
+    }
+    this.observability.callFinished(call.tool, code);
+    return true;
+  }
+
+  async expire(call: PendingStreamCallView): Promise<void> {
+    const socket = call.state === "attached" ? this.daemonRegistry.socketForConnectionId(call.connection_id) : undefined;
+    if (socket) {
+      sendWebSocketQuietly(socket, { type: "cancel_call", id: call.call_id });
+      const silentForMs = Date.now() - daemonLastSeenMs(this.daemonRegistry.readyAttachment(socket));
+      if (!Number.isFinite(silentForMs) || silentForMs > 45_000) {
+        void this.invalidateDaemonSocket(socket, "daemon became unresponsive", "daemon liveness timeout");
+      }
+    }
+    const error = call.state === "attached"
+      ? new WorkerToolError("timeout", `daemon tool timed out: ${call.tool}`, true)
+      : new WorkerToolError("unavailable", "daemon disconnected; reconnect grace expired", true);
+    await this.settle(call.call_id, call.connection_id, { ok: false, error }, call);
+  }
+
+  async expireDue(now = Date.now()): Promise<number> {
+    const due = await this.calls.due(now);
+    for (const call of due) await this.expire(call);
+    return due.length;
+  }
+
+  async cancel(requestKey: string): Promise<boolean> {
+    const call = await this.calls.getByRequestKey(requestKey);
+    if (!call) return false;
+    const socket = call.state === "attached" ? this.daemonRegistry.socketForConnectionId(call.connection_id) : undefined;
+    if (socket) sendWebSocketQuietly(socket, { type: "cancel_call", id: call.call_id });
+    return this.settle(
+      call.call_id,
+      call.connection_id,
+      { ok: false, error: new WorkerToolError("cancelled", "tool call cancelled by client") },
+      call,
+    );
+  }
+
+  detach(connectionId: string, graceMs: number): Promise<number> {
+    return this.calls.detach(connectionId, graceMs);
+  }
+
+  rebind(daemonInstanceId: string, connectionId: string): Promise<string[]> {
+    return this.calls.rebind(daemonInstanceId, connectionId);
+  }
+}

package/src/worker/durable-stream-result.ts

@@ -0,0 +1,22 @@
+import { decorateProjectOverview } from "./authority.ts";
+import type { PendingCallOutcome } from "./pending-call-contract.ts";
+import type { PendingStreamCallView } from "./mcp-pending-call-store.ts";
+
+export function transformDurableStreamOutcome(
+  call: PendingStreamCallView,
+  outcome: PendingCallOutcome,
+): PendingCallOutcome {
+  if (!outcome.ok || call.transform?.kind !== "project_overview") return outcome;
+  try {
+    return {
+      ok: true,
+      value: decorateProjectOverview(outcome.value, {
+        accountId: call.transform.account_id,
+        accountVersion: call.transform.account_version,
+        role: call.transform.role,
+      }),
+    };
+  } catch (error) {
+    return { ok: false, error: error instanceof Error ? error : new Error("stream result transformation failed") };
+  }
+}

package/src/worker/http.ts

@@ -143,41 +143,55 @@ export async function parseRequestBody(request: Request, limit: number): Promise
 export async function discardRequestBody(request: Pick<Request, "body" | "headers">, limit: number): Promise<{ bytes_read: number; exceeded: boolean }> {
   const boundedLimit = normalizeBodyLimit(limit);
   const declaredLength = Number(request.headers.get("content-length") ?? "0");
-  let exceeded = Number.isFinite(declaredLength) && declaredLength > boundedLimit;
-  let observed = 0;
-  if (!request.body) return { bytes_read: 0, exceeded };
+  const declaredExceeded = Number.isFinite(declaredLength) && declaredLength > boundedLimit;
+  if (!request.body) return { bytes_read: 0, exceeded: declaredExceeded };
   const reader = request.body.getReader();
+  let observed = 0;
   try {
+    if (declaredExceeded) {
+      await cancelBodyReader(reader);
+      return { bytes_read: 0, exceeded: true };
+    }
     for (;;) {
       const { done, value } = await reader.read();
-      if (done) break;
+      if (done) return { bytes_read: observed, exceeded: false };
       if (!value) continue;
       observed = Math.min(boundedLimit + 1, observed + value.byteLength);
-      if (observed > boundedLimit) exceeded = true;
+      if (observed > boundedLimit) {
+        await cancelBodyReader(reader);
+        return { bytes_read: observed, exceeded: true };
+      }
     }
   } finally {
     reader.releaseLock();
   }
-  return { bytes_read: observed, exceeded };
 }
 
 export async function readBoundedText(request: Request, limit: number): Promise<string> {
   const boundedLimit = normalizeBodyLimit(limit);
   const declaredLength = Number(request.headers.get("content-length") ?? "0");
-  let exceeded = Number.isFinite(declaredLength) && declaredLength > boundedLimit;
+  const declaredExceeded = Number.isFinite(declaredLength) && declaredLength > boundedLimit;
   const reader = request.body?.getReader();
   if (!reader) return "";
   const chunks: Uint8Array[] = [];
   let observed = 0;
+  let exceeded = declaredExceeded;
   try {
-    for (;;) {
-      const { done, value } = await reader.read();
-      if (done) break;
-      if (!value) continue;
-      const nextObserved = Math.min(boundedLimit + 1, observed + value.byteLength);
-      if (!exceeded && observed + value.byteLength <= boundedLimit) chunks.push(value);
-      else exceeded = true;
-      observed = nextObserved;
+    if (declaredExceeded) await cancelBodyReader(reader);
+    else {
+      for (;;) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        if (!value) continue;
+        const nextObserved = Math.min(boundedLimit + 1, observed + value.byteLength);
+        if (observed + value.byteLength <= boundedLimit) chunks.push(value);
+        else {
+          exceeded = true;
+          await cancelBodyReader(reader);
+        }
+        observed = nextObserved;
+        if (exceeded) break;
+      }
     }
   } finally {
     reader.releaseLock();
@@ -196,6 +210,14 @@ export async function readBoundedText(request: Request, limit: number): Promise<
   }
 }
 
+async function cancelBodyReader(reader: ReadableStreamDefaultReader<Uint8Array>): Promise<void> {
+  try {
+    await reader.cancel("request body limit reached");
+  } catch {
+    // Cancellation is cleanup after the size decision; it must not replace the bounded response.
+  }
+}
+
 function normalizeBodyLimit(value: number): number {
   const parsed = Number(value);
   return Number.isFinite(parsed) && parsed >= 0 ? Math.floor(parsed) : 0;