@mudraid/sidecar 1.1.0

package/dist/chunk-AHPE2F3B.js

@@ -0,0 +1,898 @@
+// src/config.ts
+var DEFAULT_MAX_BODY_BYTES = 1048576;
+
+// src/facts.ts
+function classifyJsonShape(body) {
+  if (body.length === 0) {
+    return { shape: "not_json", value: void 0 };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(body.toString("utf-8"));
+  } catch {
+    return { shape: "not_json", value: void 0 };
+  }
+  if (Array.isArray(parsed)) {
+    return { shape: "array", value: parsed };
+  }
+  if (parsed !== null && typeof parsed === "object") {
+    return { shape: "object", value: parsed };
+  }
+  return { shape: "scalar", value: parsed };
+}
+function readString(obj, key) {
+  const v = obj[key];
+  return typeof v === "string" ? v : null;
+}
+function buildFacts(inbound, config) {
+  const presentedHeaderNames = Object.keys(inbound.headers);
+  const { shape, value } = classifyJsonShape(inbound.body);
+  let jsonrpc = null;
+  let rpcMethod = null;
+  let toolName = null;
+  let actionMapped = false;
+  let action = null;
+  if (shape === "object") {
+    const obj = value;
+    jsonrpc = readString(obj, "jsonrpc");
+    rpcMethod = readString(obj, "method");
+    if (rpcMethod === "tools/call") {
+      const params = obj["params"];
+      if (params !== null && typeof params === "object") {
+        toolName = readString(params, "name");
+      }
+      if (toolName !== null && Object.prototype.hasOwnProperty.call(config.actionMap, toolName)) {
+        actionMapped = true;
+        action = config.actionMap[toolName] ?? toolName;
+      }
+    }
+  }
+  return {
+    protected: config.protectedSurface,
+    bundleActive: config.bundleActive,
+    method: inbound.method,
+    reservedHeadersPresented: presentedHeaderNames,
+    bodyReadable: inbound.bodyReadable,
+    bodyTooLarge: inbound.bodyTooLarge,
+    jsonShape: shape,
+    jsonrpc,
+    rpcMethod,
+    toolName,
+    actionMapped,
+    action
+  };
+}
+
+// ../mudraid-adapter-node/src/decideClient.ts
+function staticDecideClient(result) {
+  return async () => result;
+}
+function throwingDecideClient(error) {
+  return async () => {
+    throw error ?? new Error("decide transport failure");
+  };
+}
+
+// ../mudraid-adapter-node/src/httpAuthority.ts
+import { randomUUID } from "node:crypto";
+
+// ../mudraid-adapter-node/src/signedBundle.ts
+import { createHash, createPublicKey, verify } from "node:crypto";
+function object(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) throw new Error("Invalid object");
+  return value;
+}
+function canonicalJson(value) {
+  if (value === null || typeof value === "boolean") return JSON.stringify(value);
+  if (typeof value === "number") {
+    if (!Number.isSafeInteger(value)) throw new Error("Unsupported canonical number");
+    return JSON.stringify(value);
+  }
+  if (typeof value === "string") {
+    return JSON.stringify(value).replace(/[\u007f-\uffff]/g, (c) => `\\u${c.charCodeAt(0).toString(16).padStart(4, "0")}`);
+  }
+  if (Array.isArray(value)) return `[${value.map(canonicalJson).join(",")}]`;
+  const record = object(value);
+  const compare = (a, b) => {
+    const aa = Array.from(a, (c) => c.codePointAt(0));
+    const bb = Array.from(b, (c) => c.codePointAt(0));
+    for (let i = 0; i < Math.min(aa.length, bb.length); i++) {
+      if (aa[i] !== bb[i]) return aa[i] - bb[i];
+    }
+    return aa.length - bb.length;
+  };
+  return `{${Object.keys(record).sort(compare).map((k) => `${canonicalJson(k)}:${canonicalJson(record[k])}`).join(",")}}`;
+}
+function instant(value) {
+  if (typeof value !== "string" || !/(Z|[+-]\d{2}:\d{2})$/.test(value)) throw new Error("Invalid timestamp");
+  const time = Date.parse(value);
+  if (!Number.isFinite(time)) throw new Error("Invalid timestamp");
+  return time;
+}
+function verifyClaims(claims, encoded, pem) {
+  if (typeof encoded !== "string" || !/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(encoded) || !encoded) throw new Error("Invalid signature");
+  if (typeof pem !== "string") throw new Error("Unknown signing key");
+  const key = createPublicKey(pem);
+  if (key.asymmetricKeyType !== "rsa" || (key.asymmetricKeyDetails?.modulusLength ?? 0) < 2048) throw new Error("Invalid signing key");
+  if (!verify("RSA-SHA256", Buffer.from(canonicalJson(claims)), key, Buffer.from(encoded, "base64"))) throw new Error("Invalid signature");
+}
+function equal(actual, expected) {
+  if (actual !== expected) throw new Error("Bundle binding mismatch");
+}
+function freeze(value) {
+  if (value !== null && typeof value === "object") {
+    for (const child of Object.values(value)) freeze(child);
+    Object.freeze(value);
+  }
+  return value;
+}
+function verifyBundle(input, keys, binding, active, now = Date.now()) {
+  const envelope = object(input);
+  const payload = object(envelope["payload"]);
+  const claims = object(envelope["signature_claims"]);
+  const version = envelope["bundle_version"];
+  if (typeof version !== "number" || !Number.isSafeInteger(version) || version < 1) throw new Error("Invalid bundle version");
+  equal(envelope["schema_version"], "1.0");
+  equal(payload["schema_version"], "1.0");
+  equal(payload["bundle_version"], version);
+  const digest = createHash("sha256").update(canonicalJson(payload)).digest("hex");
+  equal(envelope["payload_digest"], digest);
+  const keyId = envelope["signature_key_id"];
+  if (typeof keyId !== "string" || !Object.hasOwn(keys, keyId)) throw new Error("Unknown signing key");
+  const profile = "mudraid.bundle.signature/1";
+  equal(envelope["signature_profile"], profile);
+  equal(envelope["signature_algorithm"], "RS256");
+  equal(claims["profile"], profile);
+  equal(claims["algorithm"], "RS256");
+  equal(claims["key_id"], keyId);
+  verifyClaims(claims, envelope["signature_value"], keys[keyId]);
+  equal(claims["payload_digest"], digest);
+  equal(claims["bundle_version"], version);
+  const content = object(payload["content"]);
+  const surface = object(content["surface"]);
+  for (const [field, expected] of [
+    ["platform_id", binding.platformId],
+    ["environment", binding.environment],
+    ["canonical_resource_uri", binding.resource]
+  ]) {
+    if (!expected.trim()) throw new Error("Unbound surface");
+    equal(surface[field], expected);
+    equal(claims[field], expected);
+  }
+  const starts = instant(claims["not_before"]);
+  const expires = instant(claims["expires_at"]);
+  if (starts > now || expires <= now || expires <= starts) throw new Error("Bundle outside validity window");
+  const evaluation = object(content["evaluation"]);
+  for (const [field, expected] of Object.entries({ mode: "live", on_timeout: "deny", on_error: "deny", on_unmapped_action: "deny", on_stale_bundle: "deny", forward: "once", decide_required: true, retry_forwarded_request: false })) equal(evaluation[field], expected);
+  const matcher = object(content["matcher"]);
+  equal(matcher["kind"], "mcp_tool_exact");
+  const entries = matcher["actions"];
+  if (!Array.isArray(entries) || entries.length === 0 || entries.length > 1e4) throw new Error("Invalid action map");
+  const actions = /* @__PURE__ */ Object.create(null);
+  for (const entry of entries) {
+    const action = object(entry);
+    const tool = action["tool_name"];
+    const actionKey = action["action_key"];
+    if (typeof tool !== "string" || !tool || Buffer.byteLength(tool) > 512 || Object.hasOwn(actions, tool)) throw new Error("Invalid or ambiguous tool");
+    if (typeof actionKey !== "string" || !actionKey || Buffer.byteLength(actionKey) > 512) throw new Error("Invalid action");
+    actions[tool] = JSON.parse(JSON.stringify(action));
+  }
+  if (active && (version < active.version || version === active.version && digest !== active.digest)) throw new Error("Bundle rollback or conflict");
+  return freeze({ version, digest, expiresAt: expires, surface: JSON.parse(JSON.stringify(surface)), actions });
+}
+
+// ../mudraid-adapter-node/src/executionBinding.ts
+import { createHash as createHash2 } from "node:crypto";
+var sha256 = (bytes) => createHash2("sha256").update(bytes).digest("hex");
+function bindExecution(snapshot, action, context) {
+  if (!(context.body instanceof Uint8Array) || context.body.byteLength > 8 * 1024 * 1024) throw new Error("Invalid request body");
+  if (!context.contentType || context.contentType.length > 256 || /[\r\n]/.test(context.contentType)) throw new Error("Invalid content type");
+  let token = context.presentedAuthorization.trim();
+  if (token.toLowerCase().startsWith("bearer ")) token = token.slice(7).trim();
+  if (!token) throw new Error("Missing caller");
+  const scopes = action["required_scopes"];
+  if (!Array.isArray(scopes) || scopes.some((scope) => typeof scope !== "string" || !/^[\x21\x23-\x5b\x5d-\x7e]+$/.test(scope))) throw new Error("Invalid action scopes");
+  const material = {
+    profile: "mudraid.execution.request/1",
+    body_sha256: sha256(context.body),
+    content_type: context.contentType,
+    http_method: context.httpMethod,
+    path: context.path,
+    caller_token_sha256: sha256(token),
+    platform_id: snapshot.surface["platform_id"],
+    environment: snapshot.surface["environment"],
+    resource: snapshot.surface["canonical_resource_uri"],
+    action_key: action["action_key"],
+    action_version: action["action_version"],
+    mapping_id: action["mapping_id"],
+    mapping_version: action["mapping_revision"],
+    bundle_version: snapshot.version,
+    bundle_payload_digest: snapshot.digest,
+    required_scopes: [...new Set(scopes)].sort()
+  };
+  if (Object.values(material).some((value) => value === void 0 || value === null || value === "")) throw new Error("Incomplete execution binding");
+  return { digest: sha256(canonicalJson(material)), execution: {
+    profile: material["profile"],
+    body_sha256: material["body_sha256"],
+    content_type: material["content_type"],
+    ...action["argument_profile"] == null ? {} : { body_base64: boundedArgumentBody(context.body) }
+  } };
+}
+function boundedArgumentBody(body) {
+  if (body.byteLength === 0 || body.byteLength > 65536) throw new Error("Argument body exceeds bounds");
+  return Buffer.from(body).toString("base64");
+}
+
+// ../mudraid-adapter-node/src/httpAuthority.ts
+function keyMap(entries) {
+  if (!Array.isArray(entries)) throw new Error("Invalid verification key set");
+  const keys = /* @__PURE__ */ Object.create(null);
+  for (const entry of entries) {
+    const row = object(entry);
+    if (typeof row["key_id"] !== "string" || typeof row["public_key_pem"] !== "string" || Object.hasOwn(keys, row["key_id"])) throw new Error("Invalid verification key");
+    keys[row["key_id"]] = row["public_key_pem"];
+  }
+  return keys;
+}
+var HttpAuthority = class {
+  base;
+  token;
+  binding;
+  timeout;
+  adapterType;
+  fetcher;
+  current;
+  lastAccepted;
+  decisionKeys = /* @__PURE__ */ Object.create(null);
+  refreshPending;
+  observed;
+  constructor(options) {
+    this.base = new URL(options.apiBase);
+    if (this.base.protocol !== "https:" || this.base.username || this.base.password || this.base.search || this.base.hash || this.base.pathname !== "/") throw new Error("Authority must be an HTTPS origin");
+    if (!options.adapterToken || options.adapterToken.length > 256 || /\s/.test(options.adapterToken)) throw new Error("Invalid adapter credential");
+    this.token = options.adapterToken;
+    this.adapterType = options.adapterType ?? "node_server_adapter";
+    this.binding = Object.freeze({ ...options.binding });
+    this.timeout = options.timeoutMs ?? 5e3;
+    if (!Number.isSafeInteger(this.timeout) || this.timeout < 1 || this.timeout > 3e4) throw new Error("Invalid authority timeout");
+    this.fetcher = options.fetch ?? globalThis.fetch;
+  }
+  get bundle() {
+    return this.current && this.current.expiresAt > Date.now() ? this.current : void 0;
+  }
+  async request(path, method, body, authenticated = true) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await this.fetcher(new URL(`/api/v1/adapter/enforcement/${path}`, this.base), {
+        method,
+        redirect: "error",
+        signal: controller.signal,
+        headers: { Accept: "application/json", ...authenticated ? { Authorization: `Bearer ${this.token}` } : {}, ...body === void 0 ? {} : { "Content-Type": "application/json" } },
+        ...body === void 0 ? {} : { body: JSON.stringify(body) }
+      });
+      if (!response.ok || !response.body) throw new Error("Authority unavailable");
+      const reader = response.body.getReader();
+      const chunks = [];
+      let size = 0;
+      try {
+        while (true) {
+          const item = await reader.read();
+          if (item.done) break;
+          size += item.value.byteLength;
+          if (size > 2 * 1024 * 1024) throw new Error("Authority response too large");
+          chunks.push(item.value);
+        }
+      } finally {
+        await reader.cancel();
+      }
+      return object(JSON.parse(Buffer.concat(chunks).toString("utf8")));
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  /** Single-flight refresh. A failed refresh never activates unverified data. */
+  refresh() {
+    if (!this.refreshPending) this.refreshPending = this.refreshOnce().finally(() => {
+      this.refreshPending = void 0;
+    });
+    return this.refreshPending;
+  }
+  async refreshOnce() {
+    try {
+      const heartbeat = await this.request("heartbeat", "POST");
+      if (heartbeat["platform_id"] !== this.binding.platformId) {
+        this.current = void 0;
+        return false;
+      }
+      const keyResponse = await this.request("keys", "GET", void 0, false);
+      const bundleKeys = keyMap(keyResponse["keys"]);
+      this.decisionKeys = /* @__PURE__ */ Object.create(null);
+      if (Array.isArray(keyResponse["key_sets"])) {
+        for (const item of keyResponse["key_sets"]) {
+          const set = object(item);
+          if (set["purpose"] === "enforcement_decision_signing") this.decisionKeys = keyMap(set["keys"]);
+        }
+      }
+      const served = await this.request("bundle", "GET");
+      const verified = verifyBundle(served, bundleKeys, this.binding, this.lastAccepted);
+      if (heartbeat["desired_bundle_version"] !== verified.version || heartbeat["desired_payload_digest"] !== verified.digest) throw new Error("Desired bundle mismatch");
+      this.current = verified;
+      this.lastAccepted = verified;
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const observedAt = this.observed?.version === verified.version && this.observed.digest === verified.digest ? this.observed.at : void 0;
+      await this.request("acknowledgements", "POST", {
+        report_id: randomUUID(),
+        received_version: verified.version,
+        received_at: now,
+        validated_version: verified.version,
+        validated_at: now,
+        active_version: verified.version,
+        active_at: now,
+        bundle_digest: verified.digest,
+        ...observedAt === void 0 ? {} : { first_observed_decision_at: observedAt }
+      });
+      return true;
+    } catch {
+      this.current = void 0;
+      return false;
+    }
+  }
+  async decide(toolName, context, snapshot = this.bundle) {
+    if (!snapshot || snapshot !== this.bundle) return { status: "unconfigured" };
+    const mapped = snapshot.actions[toolName];
+    if (!mapped) return { status: "deny", reason: "action_unmapped" };
+    if (!context.presentedAuthorization || context.presentedAuthorization.length > 8192) return { status: "deny", reason: "credential_missing" };
+    const decisionId = randomUUID();
+    const action = mapped["action_key"];
+    try {
+      const bound = bindExecution(snapshot, mapped, context);
+      const response = await this.request("decide", "POST", {
+        schema_version: "mudraid.enforce.decide-request/1",
+        decision_id: decisionId,
+        adapter: { type: this.adapterType, version: "1.1.0" },
+        bundle: { version: snapshot.version, payload_digest: snapshot.digest },
+        surface: snapshot.surface,
+        action: mapped,
+        request: { transport: "mcp_streamable_http", http_method: context.httpMethod, path: context.path },
+        presented_authorization: context.presentedAuthorization,
+        execution: bound.execution
+      });
+      if (response["schema_version"] !== "2.0" || response["decision_id"] !== decisionId) throw new Error("Unbound decision");
+      const now = Date.now();
+      const decidedAt = instant(response["decided_at"]);
+      if (decidedAt > now + 3e4 || now - decidedAt > 6e4) throw new Error("Stale decision");
+      if (instant(response["deadline_at"]) <= now) throw new Error("Expired decision");
+      const signature = object(response["signature"]);
+      const claims = object(signature["claims"]);
+      const keyId = signature["key_id"];
+      const profile = "mudraid.decision.signature/1";
+      if (typeof keyId !== "string" || !Object.hasOwn(this.decisionKeys, keyId) || signature["profile"] !== profile || signature["algorithm"] !== "RS256" || claims["profile"] !== profile || claims["algorithm"] !== "RS256" || claims["key_id"] !== keyId) throw new Error("Invalid decision signature");
+      verifyClaims(claims, signature["signature"], this.decisionKeys[keyId]);
+      if (claims["execution_request_digest"] !== bound.digest) throw new Error("Execution binding mismatch");
+      for (const field of ["decision_id", "decision", "outcome", "decided_at", "deadline_at"]) {
+        if ((claims[field] ?? null) !== (response[field] ?? null)) throw new Error("Altered decision");
+      }
+      const reason = object(response["reason"]);
+      if (claims["reason_primary"] !== reason["primary"]) throw new Error("Altered reason");
+      for (const [field, expected] of Object.entries({ platform_id: this.binding.platformId, environment: this.binding.environment, resource: this.binding.resource, action_key: action, bundle_version: snapshot.version })) {
+        if (claims[field] !== expected) throw new Error("Decision binding mismatch");
+      }
+      if (instant(claims["not_before"]) > now + 3e4 || instant(claims["expires_at"]) <= now) throw new Error("Invalid decision window");
+      if (snapshot !== this.bundle) throw new Error("Bundle changed during decision");
+      if (response["decision"] !== "allow" && response["decision"] !== "deny") throw new Error("Invalid decision outcome");
+      if (this.observed?.version !== snapshot.version || this.observed.digest !== snapshot.digest) {
+        this.observed = { version: snapshot.version, digest: snapshot.digest, at: new Date(now).toISOString() };
+      }
+      return { status: response["decision"], decisionId, ...typeof reason["primary"] === "string" ? { reason: reason["primary"] } : {} };
+    } catch {
+      return { status: "error" };
+    }
+  }
+};
+
+// ../mudraid-adapter-node/src/types.ts
+var RESERVED_HEADER_PREFIX = "x-mudraid-";
+var MAX_TOOL_NAME_LEN = 512;
+
+// ../mudraid-adapter-node/src/controlLoop.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+var CONTROL_VERBS = /* @__PURE__ */ new Set(["GET", "HEAD", "OPTIONS", "DELETE"]);
+var DEFAULT_PUBLIC_METHODS = /* @__PURE__ */ new Set([
+  "initialize",
+  "ping",
+  "tools/list"
+]);
+var DECIDE_UNAVAILABLE_REASONS = {
+  timeout: "deadline_exceeded",
+  error: "authority_source_unavailable",
+  unreachable: "authority_source_unavailable",
+  unconfigured: "adapter_config_stale",
+  credential_unconfigured: "adapter_config_stale"
+};
+var NON_DENY_REASONS = /* @__PURE__ */ new Set([
+  "authorized",
+  // allow
+  "adapter_config_stale",
+  // not_safely_decided
+  "deadline_exceeded",
+  // not_safely_decided
+  "authority_source_unavailable"
+  // not_safely_decided
+]);
+var DECIDE_DENY_DEFAULT_REASON = "policy_rule_denied";
+var NO_TRUSTED_CONTEXT = Object.freeze([]);
+function normalizeStrippedHeaders(reservedHeadersPresented, { protectedSurface }) {
+  if (!protectedSurface) {
+    return [];
+  }
+  return reservedHeadersPresented.filter(
+    (h) => h.toLowerCase().startsWith(RESERVED_HEADER_PREFIX)
+  );
+}
+function validToolName(name) {
+  if (typeof name !== "string") {
+    return false;
+  }
+  const byteLen = Buffer.byteLength(name, "utf-8");
+  return byteLen > 0 && byteLen <= MAX_TOOL_NAME_LEN;
+}
+function newDecisionId() {
+  return randomUUID2();
+}
+function deny(reasonCode, tier, httpStatus, adapterCode, message, stripped, outcome = "deny") {
+  return {
+    outcome,
+    reasonCode,
+    reasonTier: tier,
+    httpStatus,
+    adapterCode,
+    message,
+    strippedReservedHeaders: stripped,
+    trustedContext: NO_TRUSTED_CONTEXT
+  };
+}
+function passThrough(reasonCode, stripped) {
+  return {
+    outcome: "allow",
+    reasonCode,
+    reasonTier: "transport",
+    httpStatus: 200,
+    adapterCode: null,
+    message: "",
+    strippedReservedHeaders: stripped,
+    trustedContext: NO_TRUSTED_CONTEXT
+  };
+}
+function shouldForward(decision) {
+  return decision.outcome === "allow";
+}
+async function evaluateV2(facts, decide) {
+  const stripped = normalizeStrippedHeaders(facts.reservedHeadersPresented ?? [], {
+    protectedSurface: facts.protected
+  });
+  if (!facts.protected) {
+    return passThrough("surface_not_protected", stripped);
+  }
+  if (!facts.bundleActive) {
+    return deny(
+      "adapter_config_stale",
+      "authorization",
+      503,
+      "ENFORCE_NO_VALID_BUNDLE",
+      "no verified signed bundle is active; request cannot be safely decided",
+      stripped,
+      "not_safely_decided"
+    );
+  }
+  const method = (facts.method ?? "").toUpperCase();
+  if (CONTROL_VERBS.has(method)) {
+    return passThrough("control_plane_passthrough", stripped);
+  }
+  if (method !== "POST") {
+    return deny(
+      "method_not_allowed",
+      "transport",
+      405,
+      "ENFORCE_METHOD_NOT_ALLOWED",
+      "method not allowed on a protected MCP surface",
+      stripped
+    );
+  }
+  if (facts.bodyTooLarge === true) {
+    return deny(
+      "body_too_large",
+      "transport",
+      413,
+      "ENFORCE_BODY_TOO_LARGE",
+      "request body exceeds the bounded framing limit",
+      stripped
+    );
+  }
+  if (facts.bodyReadable === false) {
+    return deny(
+      "body_unreadable",
+      "transport",
+      400,
+      "ENFORCE_BODY_UNREADABLE",
+      "request body could not be read",
+      stripped
+    );
+  }
+  const jsonShape = facts.jsonShape ?? "object";
+  if (jsonShape === "array") {
+    return deny(
+      "batch_unsupported",
+      "transport",
+      400,
+      "ENFORCE_BATCH_UNSUPPORTED",
+      "JSON-RPC batch requests are not supported",
+      stripped
+    );
+  }
+  if (jsonShape !== "object") {
+    return deny(
+      "malformed_request",
+      "transport",
+      400,
+      "ENFORCE_MALFORMED_REQUEST",
+      "request body is not a single JSON-RPC 2.0 object",
+      stripped
+    );
+  }
+  const rpcMethod = facts.rpcMethod;
+  if (facts.jsonrpc !== "2.0" || typeof rpcMethod !== "string" || rpcMethod === "") {
+    return deny(
+      "malformed_request",
+      "transport",
+      400,
+      "ENFORCE_MALFORMED_REQUEST",
+      "request body is not a single JSON-RPC 2.0 object",
+      stripped
+    );
+  }
+  if (rpcMethod !== "tools/call") {
+    if (rpcMethod.startsWith("notifications/")) {
+      return passThrough("notification_passthrough", stripped);
+    }
+    if (DEFAULT_PUBLIC_METHODS.has(rpcMethod)) {
+      return passThrough("control_plane_passthrough", stripped);
+    }
+    return deny(
+      "message_not_allowed",
+      "transport",
+      403,
+      "ENFORCE_MESSAGE_NOT_ALLOWED",
+      "JSON-RPC method is not permitted on a protected surface",
+      stripped
+    );
+  }
+  if (!validToolName(facts.toolName)) {
+    return deny(
+      "malformed_request",
+      "transport",
+      400,
+      "ENFORCE_MALFORMED_REQUEST",
+      "tools/call params.name is missing or exceeds the action-name bound",
+      stripped
+    );
+  }
+  if (facts.actionMapped !== true) {
+    return deny(
+      "action_unmapped",
+      "authorization",
+      403,
+      "ENFORCE_ACTION_UNMAPPED",
+      "no exact canonical action is mapped for this tool",
+      stripped
+    );
+  }
+  const action = facts.action ?? facts.toolName;
+  let result;
+  try {
+    result = await decide(action);
+  } catch {
+    return deny(
+      "authority_source_unavailable",
+      "authorization",
+      503,
+      "ENFORCE_DECIDE_UNAVAILABLE",
+      "the authority could not be reached; request cannot be safely decided",
+      stripped,
+      "not_safely_decided"
+    );
+  }
+  if (result.status === "allow") {
+    const trusted = [
+      ["x-mudraid-action-key", action],
+      ["x-mudraid-decision-id", result.decisionId ?? newDecisionId()]
+    ];
+    return {
+      outcome: "allow",
+      reasonCode: "authorized",
+      reasonTier: "authorization",
+      httpStatus: 200,
+      adapterCode: null,
+      message: "",
+      strippedReservedHeaders: stripped,
+      trustedContext: trusted
+    };
+  }
+  if (result.status === "deny") {
+    let reason2 = result.reason ?? DECIDE_DENY_DEFAULT_REASON;
+    if (NON_DENY_REASONS.has(reason2)) {
+      reason2 = DECIDE_DENY_DEFAULT_REASON;
+    }
+    return deny(
+      reason2,
+      "authorization",
+      403,
+      "ENFORCE_DECISION_DENY",
+      "the authority denied this action",
+      stripped
+    );
+  }
+  const reason = DECIDE_UNAVAILABLE_REASONS[result.status] ?? "authority_source_unavailable";
+  return deny(
+    reason,
+    "authorization",
+    503,
+    "ENFORCE_DECIDE_UNAVAILABLE",
+    "the authority could not be reached; request cannot be safely decided",
+    stripped,
+    "not_safely_decided"
+  );
+}
+
+// src/proxy.ts
+function outgoingHeaders(inbound, decision) {
+  const stripped = new Set(decision.strippedReservedHeaders.map((h) => h.toLowerCase()));
+  const headers = {};
+  for (const [name, value] of Object.entries(inbound.headers)) {
+    if (value === void 0) {
+      continue;
+    }
+    if (stripped.has(name.toLowerCase())) {
+      continue;
+    }
+    headers[name] = value;
+  }
+  for (const [name, value] of decision.trustedContext) {
+    headers[name] = value;
+  }
+  return headers;
+}
+function denyBody(decision) {
+  const payload = {
+    error: "mudraid_enforced",
+    code: decision.adapterCode,
+    reason: decision.reasonCode,
+    message: decision.message
+  };
+  return Buffer.from(JSON.stringify(payload), "utf-8");
+}
+async function enforce(inbound, deps) {
+  inbound = { ...inbound, headers: Object.freeze({ ...inbound.headers }), body: Buffer.from(inbound.body) };
+  const snapshot = deps.authority?.bundle;
+  const config = deps.authority ? {
+    ...deps.config,
+    protectedSurface: true,
+    bundleActive: snapshot !== void 0,
+    actionMap: Object.fromEntries(Object.entries(snapshot?.actions ?? {}).map(([tool, action]) => [tool, String(action["action_key"])]))
+  } : deps.config;
+  const facts = buildFacts(inbound, config);
+  const decide = deps.authority ? () => deps.authority.decide(facts.toolName ?? "", {
+    presentedAuthorization: Object.entries(inbound.headers).find(([name]) => name.toLowerCase() === "authorization")?.[1] ?? "",
+    httpMethod: inbound.method,
+    path: inbound.path,
+    body: inbound.body,
+    contentType: Object.entries(inbound.headers).find(([name]) => name.toLowerCase() === "content-type")?.[1] ?? ""
+  }, snapshot) : deps.decide;
+  const decision = await evaluateV2(facts, decide);
+  if (!shouldForward(decision)) {
+    return {
+      status: decision.httpStatus,
+      headers: { "content-type": "application/json" },
+      body: denyBody(decision),
+      forwarded: false,
+      decision
+    };
+  }
+  const upstream = await deps.forwardUpstream({
+    method: inbound.method,
+    path: inbound.path,
+    headers: outgoingHeaders(inbound, decision),
+    body: inbound.body
+  });
+  return {
+    status: upstream.status,
+    headers: upstream.headers,
+    body: upstream.body,
+    forwarded: true,
+    decision
+  };
+}
+
+// src/upstream.ts
+function httpUpstreamForwarder(baseUrl) {
+  const base = new URL(baseUrl);
+  if (!["http:", "https:"].includes(base.protocol) || base.username || base.password || base.search || base.hash || base.pathname !== "/") {
+    throw new Error("Upstream must be an HTTP origin without embedded credentials");
+  }
+  const hopHeaders = /* @__PURE__ */ new Set(["connection", "keep-alive", "proxy-authenticate", "proxy-authorization", "te", "trailer", "transfer-encoding", "upgrade", "host", "content-length"]);
+  const excludedHeaders = (entries) => {
+    const excluded = new Set(hopHeaders);
+    for (const [name, value] of entries) {
+      if (name.toLowerCase() === "connection") {
+        for (const token of value.split(",")) excluded.add(token.trim().toLowerCase());
+      }
+    }
+    return excluded;
+  };
+  return async (req) => {
+    if (!req.path.startsWith("/") || req.path.startsWith("//") || req.path.includes("\\")) throw new Error("Invalid upstream path");
+    const url = new URL(req.path, base);
+    if (url.origin !== base.origin) throw new Error("Upstream origin changed");
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), 15e3);
+    try {
+      const requestExcluded = excludedHeaders(Object.entries(req.headers));
+      const requestHeaders = Object.fromEntries(Object.entries(req.headers).filter(([name]) => !requestExcluded.has(name.toLowerCase())));
+      const init = { method: req.method, headers: requestHeaders, redirect: "error", signal: controller.signal };
+      if (req.method !== "GET" && req.method !== "HEAD" && req.body.length > 0) init.body = new Uint8Array(req.body);
+      const resp = await fetch(url, init);
+      const chunks = [];
+      let total = 0;
+      if (resp.body) {
+        const reader = resp.body.getReader();
+        try {
+          while (true) {
+            const chunk = await reader.read();
+            if (chunk.done) break;
+            total += chunk.value.byteLength;
+            if (total > 8 * 1024 * 1024) throw new Error("Upstream response exceeds limit");
+            chunks.push(chunk.value);
+          }
+        } finally {
+          await reader.cancel();
+        }
+      }
+      const headers = {};
+      const responseExcluded = excludedHeaders(resp.headers.entries());
+      resp.headers.forEach((value, key) => {
+        if (!responseExcluded.has(key.toLowerCase()) && key.toLowerCase() !== "content-encoding") headers[key] = value;
+      });
+      return { status: resp.status, headers, body: Buffer.concat(chunks) };
+    } finally {
+      clearTimeout(timer);
+    }
+  };
+}
+
+// src/server.ts
+import { createServer } from "node:http";
+async function readBody(req, maxBytes) {
+  return new Promise((resolve) => {
+    const chunks = [];
+    let total = 0;
+    let tooLarge = false;
+    req.on("data", (chunk) => {
+      total += chunk.length;
+      if (total > maxBytes) {
+        tooLarge = true;
+        return;
+      }
+      chunks.push(chunk);
+    });
+    req.on("end", () => {
+      resolve({ body: Buffer.concat(chunks), bodyTooLarge: tooLarge, bodyReadable: true });
+    });
+    req.on("error", () => {
+      resolve({ body: Buffer.alloc(0), bodyTooLarge: tooLarge, bodyReadable: false });
+    });
+  });
+}
+function singleValuedHeaders(req) {
+  const out = {};
+  for (const [name, value] of Object.entries(req.headers)) {
+    out[name] = Array.isArray(value) ? value.join(", ") : value;
+  }
+  return out;
+}
+function createSidecarServer(deps, maxBodyBytes) {
+  return createServer((req, res) => {
+    void (async () => {
+      const { body, bodyTooLarge, bodyReadable } = await readBody(req, maxBodyBytes);
+      const inbound = {
+        method: req.method ?? "GET",
+        path: req.url ?? "/",
+        headers: singleValuedHeaders(req),
+        body,
+        bodyTooLarge,
+        bodyReadable
+      };
+      const result = await enforce(inbound, deps);
+      res.writeHead(result.status, { ...result.headers });
+      res.end(result.body);
+    })().catch(() => {
+      if (!res.headersSent) {
+        res.writeHead(503, { "content-type": "application/json" });
+      }
+      res.end(JSON.stringify({ error: "mudraid_enforced", code: "ENFORCE_DECIDE_UNAVAILABLE" }));
+    });
+  });
+}
+function positiveInteger(raw, name, maximum = Number.MAX_SAFE_INTEGER) {
+  const value = Number(raw);
+  if (!Number.isSafeInteger(value) || value < 1 || value > maximum) {
+    throw new Error(
+      `${name} must be a positive integer within its supported range`
+    );
+  }
+  return value;
+}
+function configFromEnv(env = process.env) {
+  const maxBodyBytes = positiveInteger(
+    env["MUDRAID_MAX_BODY_BYTES"] ?? String(DEFAULT_MAX_BODY_BYTES),
+    "MUDRAID_MAX_BODY_BYTES",
+    8 * 1024 * 1024
+  );
+  const port = positiveInteger(env["PORT"] ?? "8000", "PORT", 65535);
+  const config = {
+    upstreamBaseUrl: env["MUDRAID_UPSTREAM_URL"] ?? "http://127.0.0.1:8080",
+    protectedSurface: env["MUDRAID_PROTECTED_SURFACE"] !== "false",
+    // Only authority verification can activate configuration; environment
+    // flags cannot substitute for a verified signed bundle.
+    bundleActive: false,
+    actionMap: {},
+    maxBodyBytes
+  };
+  return { config, port, maxBodyBytes };
+}
+function authorityFromEnv(env = process.env) {
+  const fields = ["MUDRAID_API_URL", "MUDRAID_ADAPTER_TOKEN", "MUDRAID_PLATFORM_ID", "MUDRAID_ENVIRONMENT", "MUDRAID_RESOURCE_URI"];
+  if (!fields.some((field) => env[field])) return void 0;
+  if (fields.some((field) => !env[field]?.trim())) throw new Error("Incomplete sidecar authority configuration");
+  return new HttpAuthority({ adapterType: "node_sidecar", apiBase: env["MUDRAID_API_URL"], adapterToken: env["MUDRAID_ADAPTER_TOKEN"], binding: {
+    platformId: env["MUDRAID_PLATFORM_ID"],
+    environment: env["MUDRAID_ENVIRONMENT"],
+    resource: env["MUDRAID_RESOURCE_URI"]
+  } });
+}
+function main() {
+  const { config, port, maxBodyBytes } = configFromEnv();
+  const authority = authorityFromEnv();
+  const decide = staticDecideClient({ status: "unconfigured" });
+  const deps = {
+    config,
+    decide,
+    ...authority ? { authority } : {},
+    forwardUpstream: httpUpstreamForwarder(config.upstreamBaseUrl)
+  };
+  const server = createSidecarServer(deps, maxBodyBytes);
+  server.requestTimeout = 3e4;
+  server.headersTimeout = 1e4;
+  const refresh = authority ? setInterval(() => {
+    void authority.refresh();
+  }, 3e4) : void 0;
+  refresh?.unref();
+  server.on("close", () => {
+    if (refresh) clearInterval(refresh);
+  });
+  if (authority) void authority.refresh();
+  server.listen(port, () => {
+    console.log(`mudraid-sidecar listening on :${port}`);
+  });
+}
+
+export {
+  DEFAULT_MAX_BODY_BYTES,
+  buildFacts,
+  staticDecideClient,
+  throwingDecideClient,
+  HttpAuthority,
+  enforce,
+  httpUpstreamForwarder,
+  createSidecarServer,
+  main
+};