machine-bridge-mcp 0.16.1 → 0.17.0

package/src/worker/pending-calls.ts

@@ -0,0 +1,109 @@
+export interface PendingCallRecord {
+  id: string;
+  socket: WebSocket;
+  clientRequestKey?: string;
+  timeout: ReturnType<typeof setTimeout>;
+  resolve: (value: unknown) => void;
+  reject: (error: Error) => void;
+}
+
+interface RegisterPendingCall {
+  id: string;
+  socket: WebSocket;
+  clientRequestKey?: string;
+  timeoutMs: number;
+  onTimeout: (record: PendingCallRecord) => Error;
+}
+
+export class PendingCallRegistry {
+  private readonly maximum: number;
+  private readonly byId = new Map<string, PendingCallRecord>();
+  private readonly byRequestKey = new Map<string, string>();
+
+  constructor(maximum: number) {
+    this.maximum = maximum;
+  }
+
+  get size(): number {
+    return this.byId.size;
+  }
+
+  hasRequestKey(requestKey?: string): boolean {
+    return Boolean(requestKey && this.byRequestKey.has(requestKey));
+  }
+
+  register(input: RegisterPendingCall): Promise<unknown> {
+    if (this.byId.size >= this.maximum) throw new Error("too many concurrent daemon tool calls");
+    if (this.byId.has(input.id)) throw new Error("duplicate internal daemon call id");
+    if (input.clientRequestKey && this.byRequestKey.has(input.clientRequestKey)) {
+      throw new Error("duplicate in-flight JSON-RPC request id for this access token");
+    }
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        const record = this.take(input.id);
+        if (!record) return;
+        let error: unknown;
+        try { error = input.onTimeout(record); }
+        catch { error = new Error("pending daemon call timed out"); }
+        reject(error instanceof Error ? error : new Error("pending daemon call timed out"));
+      }, input.timeoutMs);
+      const record: PendingCallRecord = {
+        id: input.id,
+        socket: input.socket,
+        clientRequestKey: input.clientRequestKey,
+        timeout,
+        resolve,
+        reject,
+      };
+      this.byId.set(input.id, record);
+      if (input.clientRequestKey) this.byRequestKey.set(input.clientRequestKey, input.id);
+    });
+  }
+
+  resolve(id: string, socket: WebSocket, value: unknown): boolean {
+    const record = this.byId.get(id);
+    if (!record || record.socket !== socket) return false;
+    this.take(id)?.resolve(value);
+    return true;
+  }
+
+  reject(id: string, error: Error, socket?: WebSocket): boolean {
+    const record = this.byId.get(id);
+    if (!record || (socket && record.socket !== socket)) return false;
+    this.take(id)?.reject(error);
+    return true;
+  }
+
+  cancelRequest(requestKey: string, onCancel: (record: PendingCallRecord) => Error): boolean {
+    const id = this.byRequestKey.get(requestKey);
+    if (!id) return false;
+    const record = this.take(id);
+    if (!record) return false;
+    record.reject(onCancel(record));
+    return true;
+  }
+
+  rejectSocket(socket: WebSocket, createError: (record: PendingCallRecord) => Error): number {
+    const ids = [...this.byId.values()].filter((record) => record.socket === socket).map((record) => record.id);
+    for (const id of ids) {
+      const record = this.take(id);
+      if (record) record.reject(createError(record));
+    }
+    return ids.length;
+  }
+
+  snapshot(): { active: number; request_keys: number; maximum: number } {
+    return { active: this.byId.size, request_keys: this.byRequestKey.size, maximum: this.maximum };
+  }
+
+  private take(id: string): PendingCallRecord | undefined {
+    const record = this.byId.get(id);
+    if (!record) return undefined;
+    clearTimeout(record.timeout);
+    this.byId.delete(id);
+    if (record.clientRequestKey && this.byRequestKey.get(record.clientRequestKey) === id) {
+      this.byRequestKey.delete(record.clientRequestKey);
+    }
+    return record;
+  }
+}

package/src/worker/policy.ts

@@ -0,0 +1,79 @@
+import contract from "../shared/policy-contract.json" with { type: "json" };
+import toolCatalog from "../shared/tool-catalog.json" with { type: "json" };
+
+export type DaemonPolicy = {
+  profile: string;
+  origin: string;
+  revision: number;
+  allowWrite: boolean;
+  allowExec: boolean;
+  execMode: "off" | "direct" | "shell";
+  unrestrictedPaths: boolean;
+  minimalEnv: boolean;
+  exposeAbsolutePaths: boolean;
+};
+
+type ToolDefinition = Record<string, unknown> & { name: string; availability?: string };
+type AvailabilityRequirement = {
+  profile?: string;
+  allowWrite?: boolean;
+  execModes?: string[];
+  unrestrictedPaths?: boolean;
+  minimalEnv?: boolean;
+  exposeAbsolutePaths?: boolean;
+};
+
+const tools = toolCatalog as ToolDefinition[];
+const definitions = new Map(tools.map((tool) => [tool.name, tool]));
+const origins = new Set(contract.origins.map(String));
+const availability = contract.availability as Record<string, AvailabilityRequirement>;
+
+export function sanitizeDaemonPolicy(value: unknown): DaemonPolicy {
+  const policy = asObject(value);
+  const execMode: DaemonPolicy["execMode"] = policy.execMode === "shell" || policy.execMode === "direct" ? policy.execMode : "off";
+  const origin = sanitizeMetadataText(policy.origin, 32);
+  return {
+    profile: sanitizeMetadataText(policy.profile, 32) ?? "custom",
+    origin: origins.has(origin ?? "") ? origin! : "custom",
+    revision: Number.isInteger(policy.revision) && Number(policy.revision) > 0
+      ? Math.min(Number(policy.revision), 1_000_000)
+      : Number(contract.revision),
+    allowWrite: policy.allowWrite === true,
+    allowExec: execMode !== "off",
+    execMode,
+    unrestrictedPaths: policy.unrestrictedPaths === true,
+    minimalEnv: policy.minimalEnv !== false,
+    exposeAbsolutePaths: policy.exposeAbsolutePaths === true,
+  };
+}
+
+export function policyAllowsAvailability(policy: DaemonPolicy, name: unknown): boolean {
+  const requirement = availability[String(name || "")];
+  if (!requirement) return false;
+  if (requirement.profile && policy.profile !== requirement.profile) return false;
+  if (requirement.allowWrite === true && policy.allowWrite !== true) return false;
+  if (Array.isArray(requirement.execModes) && !requirement.execModes.includes(policy.execMode)) return false;
+  if (typeof requirement.unrestrictedPaths === "boolean" && policy.unrestrictedPaths !== requirement.unrestrictedPaths) return false;
+  if (typeof requirement.minimalEnv === "boolean" && policy.minimalEnv !== requirement.minimalEnv) return false;
+  if (typeof requirement.exposeAbsolutePaths === "boolean" && policy.exposeAbsolutePaths !== requirement.exposeAbsolutePaths) return false;
+  return true;
+}
+
+export function sanitizeDaemonTools(value: unknown, policy: DaemonPolicy): string[] {
+  if (!Array.isArray(value)) return [];
+  return [...new Set(value.filter((item): item is string => {
+    if (typeof item !== "string" || item === "server_info") return false;
+    const definition = definitions.get(item);
+    return Boolean(definition && policyAllowsAvailability(policy, definition.availability));
+  }))];
+}
+
+function sanitizeMetadataText(value: unknown, maxLength: number): string | undefined {
+  if (typeof value !== "string") return undefined;
+  const normalized = value.replace(/[\u0000-\u001f\u007f\u200B-\u200F\u202A-\u202E\u2066-\u2069\uFEFF]/g, " ").replace(/\s+/g, " ").trim();
+  return normalized ? normalized.slice(0, maxLength) : undefined;
+}
+
+function asObject(value: unknown): Record<string, unknown> {
+  return value && typeof value === "object" && !Array.isArray(value) ? value as Record<string, unknown> : {};
+}

package/tsconfig.json

@@ -17,7 +17,7 @@
   },
   "include": [
     "src/worker/**/*.ts",
-    "src/worker/**/*.d.ts",
+    ".wrangler/worker-configuration.d.ts",
     "src/shared/**/*.json"
   ]
 }