machine-bridge-mcp 0.16.0 → 0.16.2

package/src/worker/observability.ts

@@ -0,0 +1,111 @@
+const MAX_ERROR_CODES = 64;
+const MAX_TOOLS = 128;
+const SENSITIVE_FIELD = /(?:authorization|cookie|credential|password|secret|token|verifier|private[_-]?key)/i;
+
+export class WorkerObservability {
+  private readonly startedAt = Date.now();
+  private readonly requests = { total: 0, successful: 0, client_error: 0, server_error: 0 };
+  private readonly calls = { started: 0, completed: 0, failed: 0, cancelled: 0, timed_out: 0 };
+  private readonly sockets = { candidates: 0, authenticated: 0, disconnected: 0, protocol_errors: 0 };
+  private readonly errors = new Map<string, number>();
+  private readonly tools = new Map<string, { started: number; completed: number; failed: number; active: number }>();
+
+  requestFinished(status: number): void {
+    this.requests.total += 1;
+    if (status >= 500) this.requests.server_error += 1;
+    else if (status >= 400) this.requests.client_error += 1;
+    else this.requests.successful += 1;
+  }
+
+  callStarted(tool: string): void {
+    this.calls.started += 1;
+    const metric = this.toolMetric(tool);
+    metric.started += 1;
+    metric.active += 1;
+  }
+
+  callFinished(tool: string, code = ""): void {
+    const metric = this.toolMetric(tool);
+    metric.active = Math.max(0, metric.active - 1);
+    if (!code) {
+      this.calls.completed += 1;
+      metric.completed += 1;
+      return;
+    }
+    this.calls.failed += 1;
+    metric.failed += 1;
+    if (code === "cancelled") this.calls.cancelled += 1;
+    if (code === "timeout") this.calls.timed_out += 1;
+    this.incrementError(code);
+  }
+
+  socketCandidate(): void { this.sockets.candidates += 1; }
+  socketAuthenticated(): void { this.sockets.authenticated += 1; }
+  socketDisconnected(): void { this.sockets.disconnected += 1; }
+  socketProtocolError(code: string): void {
+    this.sockets.protocol_errors += 1;
+    this.incrementError(code || "protocol_error");
+  }
+
+  snapshot(): Record<string, unknown> {
+    return {
+      uptime_ms: Math.max(0, Date.now() - this.startedAt),
+      requests: { ...this.requests },
+      calls: { ...this.calls },
+      sockets: { ...this.sockets },
+      errors: Object.fromEntries([...this.errors.entries()].sort(([left], [right]) => left.localeCompare(right))),
+      tools: Object.fromEntries([...this.tools.entries()].sort(([left], [right]) => left.localeCompare(right)).map(([name, metric]) => [name, { ...metric }])),
+    };
+  }
+
+  event(level: "info" | "warn" | "error", event: string, fields: Record<string, unknown> = {}): void {
+    const entry = {
+      timestamp: new Date().toISOString(),
+      level,
+      component: "worker",
+      event: sanitizeName(event),
+      ...sanitizeFields(fields),
+    };
+    const text = JSON.stringify(entry);
+    if (level === "error") console.error(text);
+    else if (level === "warn") console.warn(text);
+    else console.log(text);
+  }
+
+  private toolMetric(tool: string): { started: number; completed: number; failed: number; active: number } {
+    const name = sanitizeName(tool) || "unknown";
+    if (!this.tools.has(name)) {
+      if (this.tools.size >= MAX_TOOLS) return this.toolMetric("other");
+      this.tools.set(name, { started: 0, completed: 0, failed: 0, active: 0 });
+    }
+    return this.tools.get(name)!;
+  }
+
+  private incrementError(code: string): void {
+    const key = sanitizeName(code) || "execution_failed";
+    if (!this.errors.has(key) && this.errors.size >= MAX_ERROR_CODES) {
+      this.errors.set("other", (this.errors.get("other") ?? 0) + 1);
+      return;
+    }
+    this.errors.set(key, (this.errors.get(key) ?? 0) + 1);
+  }
+}
+
+function sanitizeName(value: unknown): string {
+  return String(value || "").toLowerCase().replace(/[^a-z0-9._-]/g, "_").slice(0, 128);
+}
+
+function sanitizeFields(fields: Record<string, unknown>): Record<string, unknown> {
+  const out: Record<string, unknown> = {};
+  for (const [key, value] of Object.entries(fields).slice(0, 32)) {
+    const safeKey = sanitizeName(key);
+    if (!safeKey) continue;
+    if (SENSITIVE_FIELD.test(safeKey)) {
+      out[safeKey] = "<redacted>";
+      continue;
+    }
+    if (typeof value === "boolean" || typeof value === "number" || value === null) out[safeKey] = value;
+    else if (typeof value === "string") out[safeKey] = value.replace(/[\u0000-\u001f\u007f]/g, " ").slice(0, 256);
+  }
+  return out;
+}

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> : {};
+}