@hachej/boring-mcp 0.0.0

package/dist/server/index.js

@@ -0,0 +1,1623 @@
+// src/server/index.ts
+import { defineServerPlugin } from "@hachej/boring-workspace/server";
+
+// src/shared/index.ts
+var BORING_MCP_PLUGIN_ID = "boring-mcp";
+var BORING_MCP_SOURCES_TAB_PANEL_ID = "boring-mcp.sources.tab";
+var BORING_MCP_SOURCES_PANEL_ID = "boring-mcp.sources.panel";
+var MCP_ERROR_CODES = {
+  SOURCE_NOT_FOUND: "MCP_SOURCE_NOT_FOUND",
+  SOURCE_FORBIDDEN: "MCP_SOURCE_FORBIDDEN",
+  SOURCE_UNAVAILABLE: "MCP_SOURCE_UNAVAILABLE",
+  PROVIDER_CONFIG_INVALID: "MCP_PROVIDER_CONFIG_INVALID",
+  PROVIDER_TIMEOUT: "MCP_PROVIDER_TIMEOUT",
+  PROVIDER_ERROR: "MCP_PROVIDER_ERROR",
+  TOOL_NOT_FOUND: "MCP_TOOL_NOT_FOUND",
+  TOOL_NOT_ALLOWED: "MCP_TOOL_NOT_ALLOWED",
+  PROVIDER_TOOL_DRIFT: "MCP_PROVIDER_TOOL_DRIFT",
+  RESOURCE_LIMIT_EXCEEDED: "MCP_RESOURCE_LIMIT_EXCEEDED",
+  SECRET_LEAK_GUARD: "MCP_SECRET_LEAK_GUARD",
+  INPUT_INVALID: "MCP_INPUT_INVALID",
+  RESOURCE_URI_INVALID: "MCP_RESOURCE_URI_INVALID"
+};
+function toMcpSourceDto(source) {
+  return {
+    id: source.id,
+    provider: source.provider,
+    displayName: source.displayName,
+    status: source.status,
+    ownerKind: source.ownerKind,
+    credentialProvider: source.credentialProvider,
+    scopes: source.scopes,
+    providerAccountLabel: source.providerAccountLabel,
+    lastVerifiedAt: source.lastVerifiedAt,
+    createdAt: source.createdAt,
+    updatedAt: source.updatedAt
+  };
+}
+var McpError = class extends Error {
+  code;
+  details;
+  constructor(code, message, details) {
+    super(message);
+    this.name = "McpError";
+    this.code = code;
+    this.details = details;
+  }
+};
+var NOTION_MCP_TEMPLATE = {
+  id: "notion",
+  displayName: "Notion",
+  readOnlyDefault: true,
+  allowedTools: ["NOTION_SEARCH_NOTION_PAGE", "NOTION_GET_PAGE_MARKDOWN", "NOTION_RETRIEVE_PAGE"],
+  deniedTools: ["create_*", "update_*", "delete_*", "publish_*", "admin_*"],
+  allowedResourceUriPrefixes: ["notion:", "notion://"]
+};
+var AIRTABLE_MCP_TEMPLATE = {
+  id: "airtable",
+  displayName: "Airtable",
+  readOnlyDefault: true,
+  allowedTools: ["ping", "list_bases", "list_workspaces", "list_tables_for_base", "get_table_schema", "search_records"],
+  deniedTools: ["create_*", "update_*", "delete_*", "publish_*", "admin_*"],
+  allowedResourceUriPrefixes: ["airtable:", "airtable://"]
+};
+var DEFAULT_MCP_PROVIDER_TEMPLATES = [NOTION_MCP_TEMPLATE, AIRTABLE_MCP_TEMPLATE];
+function getMcpProviderTemplate(provider, templates = DEFAULT_MCP_PROVIDER_TEMPLATES) {
+  return templates.find((template) => template.id === provider);
+}
+var MCP_TOOL_NAME_PATTERN = /^[A-Za-z0-9_.:-]{1,128}$/;
+function validateMcpToolName(toolName) {
+  if (!MCP_TOOL_NAME_PATTERN.test(toolName)) {
+    throw new McpError(MCP_ERROR_CODES.INPUT_INVALID, "Invalid MCP tool name");
+  }
+}
+function wildcardMatch(pattern, value) {
+  if (!pattern.includes("*")) return pattern === value;
+  const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+  return new RegExp(`^${escaped}$`, "i").test(value);
+}
+function classifyMcpTool(template, toolName) {
+  validateMcpToolName(toolName);
+  if (template.deniedTools.some((pattern) => wildcardMatch(pattern, toolName))) {
+    return { allowed: false, risk: "write", reason: "Tool matches a denied write/admin pattern" };
+  }
+  if (template.allowedTools.some((pattern) => wildcardMatch(pattern, toolName))) {
+    return { allowed: true, risk: "read", reason: "Tool is on the read-only allowlist" };
+  }
+  return { allowed: false, risk: "unknown", reason: "Tool is not on the read-only allowlist" };
+}
+function classifyMcpTools(template, tools) {
+  return tools.map((tool2) => ({ ...tool2, decision: classifyMcpTool(template, tool2.name) }));
+}
+function assertMcpToolAllowed(template, toolName) {
+  const decision = classifyMcpTool(template, toolName);
+  if (!decision.allowed) throw new McpError(MCP_ERROR_CODES.TOOL_NOT_ALLOWED, decision.reason);
+}
+var REDACTION = "[REDACTED_MCP_SECRET]";
+var SECRET_KEY_PATTERN = /(api[_-]?key|access[_-]?token|refresh[_-]?token|id[_-]?token|oauth[_-]?token|authorization|cookie|client[_-]?secret|session[_-]?headers?|mcp[_-]?session|x-composio-mcp-session)/i;
+var SECRET_VALUE_PATTERN = /(Bearer\s+[A-Za-z0-9._~+\/-]{12,}|sk-[A-Za-z0-9_-]{12,}|(?:x-api-key|api[_-]?key|access[_-]?token|refresh[_-]?token|id[_-]?token|oauth[_-]?token|code|client[_-]?secret|session[_-]?headers?|mcp[_-]?session|x-composio-mcp-session)\s*[:=]\s*[^\s,&,}]+)/gi;
+function redactMcpSecrets(value) {
+  if (typeof value === "string") return value.replace(SECRET_VALUE_PATTERN, REDACTION);
+  if (Array.isArray(value)) return value.map(redactMcpSecrets);
+  if (!value || typeof value !== "object") return value;
+  return Object.fromEntries(Object.entries(value).map(([key, nested]) => [key, SECRET_KEY_PATTERN.test(key) ? REDACTION : redactMcpSecrets(nested)]));
+}
+function containsMcpSecret(value) {
+  const redacted = redactMcpSecrets(value);
+  return JSON.stringify(redacted) !== JSON.stringify(value);
+}
+function hasMcpCanaryText(value, canaries) {
+  return canaries.some((canary) => canary.trim() && value.includes(canary));
+}
+function containsMcpCanary(value, canaries) {
+  if (typeof value === "string") return hasMcpCanaryText(value, canaries);
+  if (Array.isArray(value)) return value.some((item) => containsMcpCanary(item, canaries));
+  if (!value || typeof value !== "object") return false;
+  return Object.entries(value).some(([key, nested]) => hasMcpCanaryText(key, canaries) || containsMcpCanary(nested, canaries));
+}
+function containsMcpSecretOrCanary(value, canaries) {
+  return containsMcpSecret(value) || containsMcpCanary(value, canaries);
+}
+function doctorMcpSource(source, templates = DEFAULT_MCP_PROVIDER_TEMPLATES) {
+  const issues = [];
+  if (!getMcpProviderTemplate(source.provider, templates)) {
+    issues.push({ level: "error", code: MCP_ERROR_CODES.PROVIDER_CONFIG_INVALID, message: "Unknown MCP provider template" });
+  }
+  if (source.status !== "connected") {
+    issues.push({ level: "warning", code: MCP_ERROR_CODES.SOURCE_UNAVAILABLE, message: "MCP source is not connected" });
+  }
+  return { ok: issues.every((issue2) => issue2.level !== "error"), sourceId: source.id, issues };
+}
+var McpAccessFacade = class {
+  constructor(params) {
+    this.params = params;
+  }
+  params;
+  async listSources(actor) {
+    return (await this.params.store.listSources(actor)).filter((source) => this.canAccessSource(actor, source));
+  }
+  async probeSource(actor, sourceId) {
+    const source = await this.requireAccessibleSource(actor, sourceId);
+    this.requireConnectedSource(source);
+    const template = this.requireTemplate(source);
+    const [tools, resources] = await Promise.all([
+      this.params.transport.listTools(source),
+      this.params.transport.listResources(source)
+    ]);
+    return {
+      sourceId: source.id,
+      provider: source.provider,
+      tools: classifyMcpTools(template, tools),
+      resources
+    };
+  }
+  async requireAccessibleSource(actor, sourceId) {
+    const source = await this.params.store.getSource(sourceId);
+    if (!source || source.workspaceId !== actor.workspaceId) {
+      throw new McpError(MCP_ERROR_CODES.SOURCE_NOT_FOUND, "MCP source not found");
+    }
+    if (!this.canAccessSource(actor, source)) throw new McpError(MCP_ERROR_CODES.SOURCE_NOT_FOUND, "MCP source not found");
+    return source;
+  }
+  canAccessSource(actor, source) {
+    if (source.workspaceId !== actor.workspaceId) return false;
+    return this.params.accessPolicy?.canAccessSource(actor, source) ?? (source.ownerKind === "user" && source.userId === actor.userId);
+  }
+  requireConnectedSource(source) {
+    if (source.status !== "connected") throw new McpError(MCP_ERROR_CODES.SOURCE_UNAVAILABLE, "MCP source is not connected");
+  }
+  requireTemplate(source) {
+    const template = getMcpProviderTemplate(source.provider, this.params.templates);
+    if (!template) throw new McpError(MCP_ERROR_CODES.PROVIDER_CONFIG_INVALID, "Unknown MCP provider");
+    return template;
+  }
+};
+
+// src/server/sourceAccess.ts
+var SOURCE_ID_PATTERN = /^[A-Za-z0-9_.:-]{1,160}$/;
+function validateMcpSourceId(sourceId) {
+  const trimmed = sourceId.trim();
+  if (!SOURCE_ID_PATTERN.test(trimmed)) throw new McpError(MCP_ERROR_CODES.SOURCE_NOT_FOUND, "MCP source not found");
+  return trimmed;
+}
+function isActorOwnedMcpSource(actor, source) {
+  return Boolean(source && source.workspaceId === actor.workspaceId && source.userId === actor.userId);
+}
+async function requireActorOwnedMcpSource(registry, actor, sourceId) {
+  const source = await registry.getSource(validateMcpSourceId(sourceId));
+  if (!isActorOwnedMcpSource(actor, source)) throw new McpError(MCP_ERROR_CODES.SOURCE_NOT_FOUND, "MCP source not found");
+  return source;
+}
+function assertMcpPublicPayloadSecretFree(value) {
+  if (containsMcpSecret(value)) throw new McpError(MCP_ERROR_CODES.SECRET_LEAK_GUARD, "MCP public payload contained secret material");
+}
+function createMcpSourceStatusPayload(source) {
+  const payload = {
+    source: toMcpSourceDto(source),
+    connectable: source.credentialProvider === "provider-managed" || source.credentialProvider === "composio-managed" || source.credentialProvider === "app-managed",
+    canProbe: source.status === "connected",
+    canDisconnect: source.status !== "unconfigured" && source.status !== "revoked"
+  };
+  assertMcpPublicPayloadSecretFree(payload);
+  return payload;
+}
+
+// src/server/agentBridge.ts
+var BORING_MCP_AGENT_BRIDGE_TOOL_NAMES = [
+  "mcp_servers_list",
+  "mcp_server_status",
+  "mcp_server_doctor",
+  "mcp_server_probe",
+  "mcp_tools_search",
+  "mcp_tool_describe",
+  "mcp_readonly_call"
+];
+var EMPTY_INPUT_SCHEMA = {
+  type: "object",
+  properties: {},
+  additionalProperties: false
+};
+var SOURCE_ID_INPUT_SCHEMA = {
+  type: "object",
+  properties: {
+    sourceId: { type: "string", description: "Stable boring-mcp source id." }
+  },
+  required: ["sourceId"],
+  additionalProperties: false
+};
+var TOOL_SEARCH_INPUT_SCHEMA = {
+  type: "object",
+  properties: {
+    sourceId: { type: "string", description: "Optional source id to search within." },
+    query: { type: "string", description: "Optional text query for tool name, summary, provider, or description." },
+    refresh: { type: "boolean", description: "Refresh provider tool metadata before searching." }
+  },
+  additionalProperties: false
+};
+var TOOL_DESCRIBE_INPUT_SCHEMA = {
+  type: "object",
+  properties: {
+    sourceId: { type: "string", description: "Stable boring-mcp source id." },
+    toolName: { type: "string", description: "Provider-native tool/action name." },
+    expectedSchemaHash: { type: "string", description: "Optional sha256 schema hash to detect drift." },
+    refresh: { type: "boolean", description: "Refresh provider tool metadata before describing." }
+  },
+  required: ["sourceId", "toolName"],
+  additionalProperties: false
+};
+var READONLY_CALL_INPUT_SCHEMA = {
+  type: "object",
+  properties: {
+    sourceId: { type: "string", description: "Stable boring-mcp source id." },
+    toolName: { type: "string", description: "Read-only provider-native tool/action name." },
+    input: { description: "JSON-safe provider input for the read-only tool." },
+    expectedSchemaHash: { type: "string", description: "Optional lowercase sha256 schema hash to detect drift before execution." }
+  },
+  required: ["sourceId", "toolName"],
+  additionalProperties: false
+};
+var BORING_MCP_AGENT_BRIDGE_TOOL_DEFINITIONS = [
+  { name: "mcp_servers_list", description: "List MCP sources available to the current actor.", inputSchema: EMPTY_INPUT_SCHEMA, readOnly: true },
+  { name: "mcp_server_status", description: "Get status and available actions for one MCP source.", inputSchema: SOURCE_ID_INPUT_SCHEMA, readOnly: true },
+  { name: "mcp_server_doctor", description: "Diagnose configuration/status issues for one MCP source without provider execution.", inputSchema: SOURCE_ID_INPUT_SCHEMA, readOnly: true },
+  { name: "mcp_server_probe", description: "Probe one connected MCP source for provider metadata and classified tools.", inputSchema: SOURCE_ID_INPUT_SCHEMA, readOnly: true },
+  { name: "mcp_tools_search", description: "Search normalized MCP tool catalog entries across connected sources or one source.", inputSchema: TOOL_SEARCH_INPUT_SCHEMA, readOnly: true },
+  { name: "mcp_tool_describe", description: "Describe one normalized MCP tool and report schema drift.", inputSchema: TOOL_DESCRIBE_INPUT_SCHEMA, readOnly: true },
+  { name: "mcp_readonly_call", description: "Execute one governed read-only MCP tool call.", inputSchema: READONLY_CALL_INPUT_SCHEMA, readOnly: true }
+];
+function requireActor(context) {
+  const actor = context?.actor;
+  if (!actor || typeof actor.userId !== "string" || typeof actor.workspaceId !== "string") {
+    throw new McpError(MCP_ERROR_CODES.INPUT_INVALID, "MCP bridge tools require an explicit actor");
+  }
+  return actor;
+}
+function inputRecord(input) {
+  if (!input || typeof input !== "object" || Array.isArray(input)) {
+    throw new McpError(MCP_ERROR_CODES.INPUT_INVALID, "MCP bridge input must be an object");
+  }
+  return input;
+}
+function optionalInputRecord(input) {
+  if (input === void 0) return {};
+  return inputRecord(input);
+}
+function stringField(record2, key) {
+  const value = record2[key];
+  if (typeof value !== "string") throw new McpError(MCP_ERROR_CODES.INPUT_INVALID, `MCP bridge ${key} must be a string`);
+  return value;
+}
+function optionalStringField(record2, key) {
+  const value = record2[key];
+  if (value === void 0) return void 0;
+  if (typeof value !== "string") throw new McpError(MCP_ERROR_CODES.INPUT_INVALID, `MCP bridge ${key} must be a string`);
+  return value;
+}
+function optionalBooleanField(record2, key) {
+  const value = record2[key];
+  if (value === void 0) return void 0;
+  if (typeof value !== "boolean") throw new McpError(MCP_ERROR_CODES.INPUT_INVALID, `MCP bridge ${key} must be a boolean`);
+  return value;
+}
+function parseEmptyInput(input) {
+  const record2 = optionalInputRecord(input);
+  if (Object.keys(record2).length > 0) throw new McpError(MCP_ERROR_CODES.INPUT_INVALID, "MCP bridge input must be empty");
+}
+function parseBridgeSourceId(sourceId) {
+  try {
+    return validateMcpSourceId(sourceId);
+  } catch {
+    throw new McpError(MCP_ERROR_CODES.INPUT_INVALID, "MCP bridge sourceId is invalid");
+  }
+}
+function parseSourceInput(input) {
+  const record2 = inputRecord(input);
+  return { sourceId: parseBridgeSourceId(stringField(record2, "sourceId")) };
+}
+function parseSearchInput(input) {
+  const record2 = optionalInputRecord(input);
+  const sourceId = optionalStringField(record2, "sourceId");
+  return {
+    sourceId: sourceId === void 0 ? void 0 : parseBridgeSourceId(sourceId),
+    query: optionalStringField(record2, "query"),
+    refresh: optionalBooleanField(record2, "refresh")
+  };
+}
+function parseDescribeInput(input) {
+  const record2 = inputRecord(input);
+  const toolName = stringField(record2, "toolName");
+  validateMcpToolName(toolName);
+  return {
+    sourceId: parseBridgeSourceId(stringField(record2, "sourceId")),
+    toolName,
+    expectedSchemaHash: optionalStringField(record2, "expectedSchemaHash"),
+    refresh: optionalBooleanField(record2, "refresh")
+  };
+}
+function parseReadonlyInput(input) {
+  const record2 = inputRecord(input);
+  const toolName = stringField(record2, "toolName");
+  validateMcpToolName(toolName);
+  const expectedSchemaHash = optionalStringField(record2, "expectedSchemaHash");
+  return {
+    sourceId: parseBridgeSourceId(stringField(record2, "sourceId")),
+    toolName,
+    input: record2.input,
+    expectedSchemaHash
+  };
+}
+async function invokeGuarded(fn) {
+  try {
+    const result = await fn();
+    assertMcpPublicPayloadSecretFree(result);
+    return result;
+  } catch (error) {
+    if (error instanceof McpError) {
+      const redactedDetails = redactMcpSecrets(error.details);
+      const safeMessage = containsMcpSecret(error.message) ? "MCP bridge tool failed" : error.message;
+      throw new McpError(error.code, safeMessage, redactedDetails);
+    }
+    const redacted = redactMcpSecrets(error instanceof Error ? { name: error.name, message: error.message } : error);
+    throw new McpError(MCP_ERROR_CODES.PROVIDER_ERROR, "MCP bridge tool failed", redacted);
+  }
+}
+function tool(definition, invoke) {
+  return {
+    ...definition,
+    async invoke(context, input) {
+      const actor = requireActor(context);
+      return invokeGuarded(() => invoke(actor, input));
+    }
+  };
+}
+function createBoringMcpAgentBridgeRegistry(handlers) {
+  const byName = Object.fromEntries(BORING_MCP_AGENT_BRIDGE_TOOL_DEFINITIONS.map((definition) => [definition.name, definition]));
+  return {
+    mcp_servers_list: tool(byName.mcp_servers_list, (actor, input) => {
+      parseEmptyInput(input);
+      return handlers.listSources(actor);
+    }),
+    mcp_server_status: tool(byName.mcp_server_status, (actor, input) => handlers.getSourceStatus(actor, parseSourceInput(input).sourceId)),
+    mcp_server_doctor: tool(byName.mcp_server_doctor, (actor, input) => handlers.doctorSource(actor, parseSourceInput(input).sourceId)),
+    mcp_server_probe: tool(byName.mcp_server_probe, (actor, input) => handlers.probeSource(actor, parseSourceInput(input).sourceId)),
+    mcp_tools_search: tool(byName.mcp_tools_search, (actor, input) => handlers.mcp_tools_search(actor, parseSearchInput(input))),
+    mcp_tool_describe: tool(byName.mcp_tool_describe, (actor, input) => handlers.mcp_tool_describe(actor, parseDescribeInput(input))),
+    mcp_readonly_call: tool(byName.mcp_readonly_call, (actor, input) => handlers.mcp_readonly_call(actor, parseReadonlyInput(input)))
+  };
+}
+function listBoringMcpAgentBridgeTools(registry) {
+  return BORING_MCP_AGENT_BRIDGE_TOOL_NAMES.map((name) => registry[name]);
+}
+
+// src/server/hardening.ts
+var InMemoryMcpRateBudgetGate = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  buckets = /* @__PURE__ */ new Map();
+  check(context) {
+    const now = Date.now();
+    const key = `${context.actor?.workspaceId ?? "unknown"}:${context.actor?.userId ?? "unknown"}:${context.sourceId}`;
+    const current = this.buckets.get(key);
+    const bucket = current && now - current.startedAt < this.options.windowMs ? current : { startedAt: now, calls: 0, toolCalls: 0 };
+    bucket.calls += 1;
+    if (context.operation === "callTool") bucket.toolCalls += 1;
+    this.buckets.set(key, bucket);
+    if (bucket.calls > this.options.maxCalls) {
+      throw new McpError(MCP_ERROR_CODES.RESOURCE_LIMIT_EXCEEDED, "MCP provider rate budget exceeded");
+    }
+    if (this.options.maxToolCalls !== void 0 && bucket.toolCalls > this.options.maxToolCalls) {
+      throw new McpError(MCP_ERROR_CODES.RESOURCE_LIMIT_EXCEEDED, "MCP provider tool-call budget exceeded");
+    }
+  }
+};
+function isAbortLike(error) {
+  return error instanceof Error && (error.name === "AbortError" || error.name === "TimeoutError");
+}
+async function withProviderTimeout(operation, timeoutMs) {
+  if (!timeoutMs || timeoutMs <= 0) return operation();
+  let timeout;
+  try {
+    return await Promise.race([
+      operation(),
+      new Promise((_, reject) => {
+        timeout = setTimeout(() => reject(new McpError(MCP_ERROR_CODES.PROVIDER_TIMEOUT, "MCP provider operation timed out")), timeoutMs);
+      })
+    ]);
+  } catch (error) {
+    if (error instanceof McpError && error.code === MCP_ERROR_CODES.PROVIDER_TIMEOUT) throw error;
+    if (isAbortLike(error)) throw new McpError(MCP_ERROR_CODES.PROVIDER_TIMEOUT, "MCP provider operation timed out");
+    throw error;
+  } finally {
+    if (timeout) clearTimeout(timeout);
+  }
+}
+async function withMetadataRetry(operation, retries) {
+  let lastError;
+  for (let attempt = 0; attempt <= retries; attempt += 1) {
+    try {
+      return await operation();
+    } catch (error) {
+      if (error instanceof McpError) throw error;
+      lastError = error;
+    }
+  }
+  throw lastError;
+}
+function normalizeProviderError(error) {
+  if (error instanceof McpError) {
+    const safeMessage = containsMcpSecret(error.message) ? "MCP provider operation failed" : error.message;
+    throw new McpError(error.code, safeMessage, redactMcpSecrets(error.details));
+  }
+  const details = redactMcpSecrets(error instanceof Error ? { name: error.name, message: error.message } : error);
+  throw new McpError(MCP_ERROR_CODES.PROVIDER_ERROR, "MCP provider operation failed", details);
+}
+function createHardenedMcpTransport(transport, options = {}, actor) {
+  async function guard(context, operation, retryMetadata = false) {
+    const run = async () => {
+      await options.gate?.check({ ...context, actor });
+      return withProviderTimeout(operation, options.timeoutMs);
+    };
+    try {
+      return retryMetadata ? await withMetadataRetry(run, options.metadataRetries ?? 0) : await run();
+    } catch (error) {
+      normalizeProviderError(error);
+    }
+  }
+  return {
+    listTools(source, input) {
+      return guard({ sourceId: source.id, operation: "listTools" }, () => transport.listTools(source, input), true);
+    },
+    listResources(source) {
+      return guard({ sourceId: source.id, operation: "listResources" }, () => transport.listResources(source), true);
+    },
+    readResource(source, uri) {
+      return guard({ sourceId: source.id, operation: "readResource" }, () => transport.readResource(source, uri), true);
+    },
+    callTool(source, toolName, input) {
+      return guard({ sourceId: source.id, operation: "callTool", toolName }, () => transport.callTool(source, toolName, input), false);
+    }
+  };
+}
+async function verifyMcpDisconnectResult(registry, actor, sourceId, disconnected) {
+  if (!isActorOwnedMcpSource(actor, disconnected)) {
+    throw new McpError(MCP_ERROR_CODES.SOURCE_NOT_FOUND, "MCP source not found");
+  }
+  const disconnectedSource = disconnected;
+  const latest = await registry.getSource(sourceId);
+  const source = isActorOwnedMcpSource(actor, latest) ? latest : disconnectedSource;
+  if (source.status === "connected") {
+    throw new McpError(MCP_ERROR_CODES.SOURCE_UNAVAILABLE, "MCP source disconnect verification failed");
+  }
+  const result = createMcpSourceStatusPayload(source);
+  assertMcpPublicPayloadSecretFree(result);
+  return result;
+}
+function issue(code, message) {
+  return { level: "error", code, message };
+}
+function evaluateBoringMcpLaunchGate(input) {
+  const issues = [];
+  if (input.pluginId !== BORING_MCP_PLUGIN_ID) issues.push(issue("MCP_LAUNCH_PLUGIN_MISSING", "boring-mcp plugin id is not enabled"));
+  if (!input.registry?.listSources || !input.registry.getSource || !input.registry.disconnectSource) issues.push(issue("MCP_LAUNCH_REGISTRY_INCOMPLETE", "source registry must support list/get/disconnect"));
+  if (!input.transport?.listTools || !input.transport.listResources || !input.transport.readResource || !input.transport.callTool) issues.push(issue("MCP_LAUNCH_TRANSPORT_MISSING", "MCP transport client is not configured"));
+  for (const name of BORING_MCP_AGENT_BRIDGE_TOOL_NAMES) {
+    if (!input.bridge?.[name]) issues.push(issue("MCP_LAUNCH_BRIDGE_TOOL_MISSING", `missing bridge tool ${name}`));
+  }
+  if (!input.templates?.length) issues.push(issue("MCP_LAUNCH_TEMPLATES_MISSING", "at least one provider template must be configured"));
+  if (!input.hardening?.gate) issues.push(issue("MCP_LAUNCH_RATE_BUDGET_MISSING", "rate/budget gate is not configured"));
+  if (!input.hardening?.timeoutMs || input.hardening.timeoutMs <= 0) issues.push(issue("MCP_LAUNCH_TIMEOUT_MISSING", "provider timeout is not configured"));
+  if (!input.maxReadonlyInputBytes || input.maxReadonlyInputBytes <= 0) issues.push(issue("MCP_LAUNCH_INPUT_LIMIT_MISSING", "read-only input byte limit is not configured"));
+  if (!input.docsReviewed) issues.push(issue("MCP_LAUNCH_OPERATOR_DOCS_MISSING", "operator smoke checklist has not been reviewed"));
+  if (containsMcpSecret(input)) issues.push(issue("MCP_LAUNCH_SECRET_LEAK", "launch gate input looked like it contained a secret"));
+  return { ok: issues.length === 0, issues };
+}
+
+// src/server/toolCatalog.ts
+import { createHash } from "crypto";
+var InMemoryMcpToolCatalogCache = class {
+  values = /* @__PURE__ */ new Map();
+  async get(actor, sourceId) {
+    return this.values.get(`${actor.workspaceId}:${actor.userId}:${sourceId}`);
+  }
+  async set(actor, sourceId, result) {
+    this.values.set(`${actor.workspaceId}:${actor.userId}:${sourceId}`, result);
+  }
+};
+function stableJson(value) {
+  if (Array.isArray(value)) return `[${value.map(stableJson).join(",")}]`;
+  if (!value || typeof value !== "object") return JSON.stringify(value);
+  return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${stableJson(value[key])}`).join(",")}}`;
+}
+function createMcpSchemaHash(schema) {
+  return `sha256:${createHash("sha256").update(stableJson(schema ?? {})).digest("hex")}`;
+}
+function displayName(toolName) {
+  return toolName.replace(/[_:.-]+/g, " ").replace(/\b\w/g, (char) => char.toUpperCase());
+}
+function sourceCatalogRevision(source) {
+  return createHash("sha256").update(JSON.stringify({
+    status: source.status,
+    updatedAt: source.updatedAt,
+    sessionId: source.connectorRef?.sessionId,
+    connectedAccountId: source.connectorRef?.connectedAccountId,
+    externalSourceId: source.connectorRef?.externalSourceId
+  })).digest("hex");
+}
+function normalizeMcpCatalogTool(sourceId, provider, tool2, templates) {
+  const template = getMcpProviderTemplate(provider, templates);
+  const decision = template ? classifyMcpTool(template, tool2.name) : { allowed: false, risk: "unknown", reason: "Tool provider has no read-only allowlist" };
+  const inputSchema = tool2.inputSchema ?? {};
+  return {
+    sourceId,
+    provider,
+    toolName: tool2.name,
+    displayName: displayName(tool2.name),
+    summary: tool2.description ?? displayName(tool2.name),
+    description: tool2.description,
+    inputSchema,
+    risk: decision.risk,
+    enabled: decision.allowed,
+    blockedReasons: decision.allowed ? [] : [decision.reason],
+    schemaHash: createMcpSchemaHash(inputSchema),
+    nativeRef: { provider, action: tool2.name }
+  };
+}
+function matchesQuery(entry, query) {
+  const normalized = query.trim().toLowerCase();
+  if (!normalized) return true;
+  return [entry.toolName, entry.displayName, entry.summary, entry.description, entry.provider].filter(Boolean).some((value) => String(value).toLowerCase().includes(normalized));
+}
+function assertConnectedSource(sourceId, status) {
+  if (status !== "connected") {
+    throw new McpError(MCP_ERROR_CODES.SOURCE_UNAVAILABLE, `MCP source ${sourceId} is not connected`);
+  }
+}
+function createBoringMcpToolCatalog(options) {
+  const cache = options.cache ?? new InMemoryMcpToolCatalogCache();
+  async function loadSourceCatalog(actor, sourceId, refresh, providerRefresh) {
+    const requestedSourceId = validateMcpSourceId(sourceId);
+    const source = await requireActorOwnedMcpSource(options.registry, actor, requestedSourceId);
+    const resolvedSourceId = validateMcpSourceId(source.id);
+    assertConnectedSource(resolvedSourceId, source.status);
+    const sourceRevision = sourceCatalogRevision(source);
+    if (!refresh && !providerRefresh) {
+      const cached = await cache.get(actor, resolvedSourceId);
+      if (cached && cached.provider === source.provider && cached.sourceRevision === sourceRevision) return cached;
+    }
+    const discoveredTools = await options.transport.listTools(source, { forceProviderRefresh: providerRefresh ?? refresh });
+    const tools = discoveredTools.map((tool2) => normalizeMcpCatalogTool(resolvedSourceId, source.provider, tool2, options.templates));
+    const snapshot = { sourceId: resolvedSourceId, provider: source.provider, sourceRevision, tools };
+    assertMcpPublicPayloadSecretFree(snapshot);
+    await cache.set(actor, resolvedSourceId, snapshot);
+    return snapshot;
+  }
+  return {
+    async searchTools(actor, input = {}) {
+      const sources = input.sourceId ? [{ id: validateMcpSourceId(input.sourceId) }] : (await options.registry.listSources(actor)).filter((source) => source.status === "connected");
+      const catalog = [];
+      for (const source of sources) {
+        const result = await loadSourceCatalog(actor, source.id, input.refresh, input.providerRefresh);
+        catalog.push(...result.tools);
+      }
+      const response = { tools: catalog.filter((entry) => matchesQuery(entry, input.query ?? "")) };
+      assertMcpPublicPayloadSecretFree(response);
+      return response;
+    },
+    async describeTool(actor, input) {
+      const result = await loadSourceCatalog(actor, input.sourceId, input.refresh, input.providerRefresh);
+      const tool2 = result.tools.find((candidate) => candidate.toolName === input.toolName);
+      if (!tool2) throw new McpError(MCP_ERROR_CODES.TOOL_NOT_FOUND, "MCP tool not found");
+      const schemaDrifted = Boolean(input.expectedSchemaHash && input.expectedSchemaHash !== tool2.schemaHash);
+      if (containsMcpSecret(tool2)) throw new McpError(MCP_ERROR_CODES.SECRET_LEAK_GUARD, "MCP tool metadata looked like it contained a secret");
+      const response = { tool: tool2, schemaDrifted };
+      assertMcpPublicPayloadSecretFree(response);
+      return response;
+    }
+  };
+}
+
+// src/server/readonlyCall.ts
+var DEFAULT_MAX_INPUT_BYTES = 64 * 1024;
+var INVALID_AUDIT_VALUE = "[invalid]";
+function isPlainRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+function normalizeJsonValue(value) {
+  if (value === null || typeof value === "string" || typeof value === "boolean") return value;
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) throw new McpError(MCP_ERROR_CODES.INPUT_INVALID, "MCP tool input must be JSON-safe");
+    return value;
+  }
+  if (Array.isArray(value)) return value.map(normalizeJsonValue);
+  if (isPlainRecord(value)) {
+    return Object.fromEntries(Object.entries(value).map(([key, nested]) => [key, normalizeJsonValue(nested)]));
+  }
+  throw new McpError(MCP_ERROR_CODES.INPUT_INVALID, "MCP tool input must be JSON-safe");
+}
+function inputSizeBytes(input) {
+  return new TextEncoder().encode(JSON.stringify(input)).byteLength;
+}
+function parseReadonlyCall(input, maxInputBytes) {
+  if (!isPlainRecord(input)) throw new McpError(MCP_ERROR_CODES.INPUT_INVALID, "MCP readonly call input must be an object");
+  if (typeof input.sourceId !== "string") throw new McpError(MCP_ERROR_CODES.INPUT_INVALID, "MCP sourceId must be a string");
+  if (typeof input.toolName !== "string") throw new McpError(MCP_ERROR_CODES.INPUT_INVALID, "MCP toolName must be a string");
+  if (input.expectedSchemaHash !== void 0 && (typeof input.expectedSchemaHash !== "string" || !isValidSchemaHash(input.expectedSchemaHash))) {
+    throw new McpError(MCP_ERROR_CODES.INPUT_INVALID, "MCP expectedSchemaHash must be a sha256 schema hash");
+  }
+  if (containsMcpSecret(input.sourceId) || containsMcpSecret(input.toolName)) {
+    throw new McpError(MCP_ERROR_CODES.INPUT_INVALID, "MCP readonly call identifiers looked like they contained a secret");
+  }
+  const toolInput = normalizeJsonValue(input.input ?? {});
+  if (inputSizeBytes(toolInput) > maxInputBytes) {
+    throw new McpError(MCP_ERROR_CODES.RESOURCE_LIMIT_EXCEEDED, "MCP tool input is too large");
+  }
+  if (containsMcpSecret(toolInput)) {
+    throw new McpError(MCP_ERROR_CODES.SECRET_LEAK_GUARD, "MCP tool input looked like it contained a secret");
+  }
+  const sourceId = validateMcpSourceId(input.sourceId);
+  validateMcpToolName(input.toolName);
+  return {
+    sourceId,
+    toolName: input.toolName,
+    expectedSchemaHash: input.expectedSchemaHash,
+    toolInput
+  };
+}
+function assertReadOnlyTool(tool2) {
+  if (!tool2.enabled || tool2.risk !== "read") {
+    throw new McpError(MCP_ERROR_CODES.TOOL_NOT_ALLOWED, tool2.blockedReasons[0] ?? "MCP tool is not allowed for read-only execution");
+  }
+}
+function assertSchemaCurrent(tool2, expectedSchemaHash) {
+  if (expectedSchemaHash && expectedSchemaHash !== tool2.schemaHash) {
+    throw new McpError(MCP_ERROR_CODES.PROVIDER_TOOL_DRIFT, "MCP tool schema changed before execution");
+  }
+}
+function assertTemplateAllowsReadonly(sourceProvider, toolName, templates) {
+  const template = getMcpProviderTemplate(sourceProvider, templates);
+  const decision = template ? classifyMcpTool(template, toolName) : { allowed: false, risk: "unknown", reason: "Tool provider has no read-only allowlist" };
+  if (!decision.allowed || decision.risk !== "read") throw new McpError(MCP_ERROR_CODES.TOOL_NOT_ALLOWED, decision.reason);
+}
+function auditEvent(actor, input, outcome, code) {
+  return {
+    operation: "mcp_readonly_call",
+    outcome,
+    workspaceId: actor.workspaceId,
+    userId: actor.userId,
+    sourceId: input.sourceId,
+    toolName: input.toolName,
+    expectedSchemaHash: input.expectedSchemaHash,
+    code
+  };
+}
+function toErrorCode(error) {
+  return error instanceof McpError ? error.code : MCP_ERROR_CODES.PROVIDER_ERROR;
+}
+function isValidSchemaHash(value) {
+  return /^sha256:[a-f0-9]{64}$/.test(value);
+}
+function auditSourceId(value) {
+  if (typeof value !== "string" || containsMcpSecret(value)) return INVALID_AUDIT_VALUE;
+  try {
+    return validateMcpSourceId(value);
+  } catch {
+    return INVALID_AUDIT_VALUE;
+  }
+}
+function auditToolName(value) {
+  if (typeof value !== "string" || containsMcpSecret(value)) return INVALID_AUDIT_VALUE;
+  try {
+    validateMcpToolName(value);
+    return value;
+  } catch {
+    return INVALID_AUDIT_VALUE;
+  }
+}
+function auditSchemaHash(value) {
+  return typeof value === "string" && !containsMcpSecret(value) && isValidSchemaHash(value) ? value : void 0;
+}
+function createBoringMcpReadonlyCaller(options) {
+  const catalog = createBoringMcpToolCatalog({ ...options, cache: options.catalogCache });
+  const maxInputBytes = options.maxInputBytes ?? DEFAULT_MAX_INPUT_BYTES;
+  async function record2(event) {
+    try {
+      await options.audit?.record(event);
+    } catch {
+    }
+  }
+  return {
+    async callReadonly(actor, input) {
+      const raw = isPlainRecord(input) ? input : {};
+      let request = {
+        sourceId: auditSourceId(raw.sourceId),
+        toolName: auditToolName(raw.toolName),
+        expectedSchemaHash: auditSchemaHash(raw.expectedSchemaHash)
+      };
+      let audited = false;
+      try {
+        const parsed = parseReadonlyCall(input, maxInputBytes);
+        request = parsed;
+        const source = await requireActorOwnedMcpSource(options.registry, actor, parsed.sourceId);
+        if (source.status !== "connected") throw new McpError(MCP_ERROR_CODES.SOURCE_UNAVAILABLE, "MCP source is not connected");
+        assertTemplateAllowsReadonly(source.provider, parsed.toolName, options.templates);
+        const described = await catalog.describeTool(actor, {
+          sourceId: parsed.sourceId,
+          toolName: parsed.toolName,
+          expectedSchemaHash: parsed.expectedSchemaHash,
+          refresh: true,
+          providerRefresh: Boolean(parsed.expectedSchemaHash)
+        });
+        assertReadOnlyTool(described.tool);
+        assertSchemaCurrent(described.tool, parsed.expectedSchemaHash);
+        let providerResult;
+        try {
+          providerResult = await options.transport.callTool(source, parsed.toolName, parsed.toolInput);
+        } catch (error) {
+          if (error instanceof McpError) {
+            const safeMessage = containsMcpSecret(error.message) ? "MCP provider tool call failed" : error.message;
+            await record2(auditEvent(actor, request, "failure", error.code));
+            audited = true;
+            throw new McpError(error.code, safeMessage, redactMcpSecrets(error.details));
+          }
+          const redacted2 = redactMcpSecrets(error instanceof Error ? { name: error.name, message: error.message } : error);
+          await record2(auditEvent(actor, request, "failure", MCP_ERROR_CODES.PROVIDER_ERROR));
+          audited = true;
+          throw new McpError(MCP_ERROR_CODES.PROVIDER_ERROR, "MCP provider tool call failed", redacted2);
+        }
+        const redacted = redactMcpSecrets(providerResult);
+        if (containsMcpSecret(providerResult)) {
+          await record2(auditEvent(actor, request, "failure", MCP_ERROR_CODES.SECRET_LEAK_GUARD));
+          audited = true;
+          throw new McpError(MCP_ERROR_CODES.SECRET_LEAK_GUARD, "MCP provider response looked like it contained a secret");
+        }
+        const response = { content: redacted };
+        assertMcpPublicPayloadSecretFree(response);
+        await record2(auditEvent(actor, request, "success"));
+        audited = true;
+        return response;
+      } catch (error) {
+        const code = toErrorCode(error);
+        if (!audited) {
+          await record2(auditEvent(actor, request, "blocked", code));
+        }
+        throw error;
+      }
+    }
+  };
+}
+
+// src/server/sourceHandlers.ts
+function createBoringMcpSourceHandlers(options) {
+  const catalogCache = new InMemoryMcpToolCatalogCache();
+  function transportFor(actor) {
+    return createHardenedMcpTransport(options.transport, options.hardening, actor);
+  }
+  function facadeFor(actor) {
+    return new McpAccessFacade({ store: options.registry, transport: transportFor(actor), templates: options.templates });
+  }
+  function catalogFor(actor) {
+    return createBoringMcpToolCatalog({ ...options, transport: transportFor(actor), cache: catalogCache });
+  }
+  function readonlyCallerFor(actor) {
+    return createBoringMcpReadonlyCaller({
+      registry: options.registry,
+      transport: transportFor(actor),
+      templates: options.templates,
+      maxInputBytes: options.maxReadonlyInputBytes,
+      audit: options.audit,
+      catalogCache
+    });
+  }
+  return {
+    async listSources(actor) {
+      const result = { sources: (await facadeFor(actor).listSources(actor)).map(toMcpSourceDto) };
+      assertMcpPublicPayloadSecretFree(result);
+      return result;
+    },
+    async getSourceStatus(actor, sourceId) {
+      const source = await requireActorOwnedMcpSource(options.registry, actor, sourceId);
+      return createMcpSourceStatusPayload(source);
+    },
+    async doctorSource(actor, sourceId) {
+      const source = await requireActorOwnedMcpSource(options.registry, actor, sourceId);
+      const result = doctorMcpSource(source, options.templates);
+      assertMcpPublicPayloadSecretFree(result);
+      return result;
+    },
+    async probeSource(actor, sourceId) {
+      const normalizedSourceId = validateMcpSourceId(sourceId);
+      const result = await facadeFor(actor).probeSource(actor, normalizedSourceId);
+      assertMcpPublicPayloadSecretFree(result);
+      return result;
+    },
+    async searchTools(actor, input) {
+      return catalogFor(actor).searchTools(actor, input);
+    },
+    async describeTool(actor, input) {
+      return catalogFor(actor).describeTool(actor, input);
+    },
+    async mcp_tools_search(actor, input) {
+      return catalogFor(actor).searchTools(actor, input);
+    },
+    async mcp_tool_describe(actor, input) {
+      return catalogFor(actor).describeTool(actor, input);
+    },
+    async callReadonly(actor, input) {
+      return readonlyCallerFor(actor).callReadonly(actor, input);
+    },
+    async mcp_readonly_call(actor, input) {
+      return readonlyCallerFor(actor).callReadonly(actor, input);
+    },
+    async disconnectSource(actor, sourceId) {
+      const normalizedSourceId = validateMcpSourceId(sourceId);
+      await requireActorOwnedMcpSource(options.registry, actor, normalizedSourceId);
+      if (!options.registry.disconnectSource) {
+        throw new McpError(MCP_ERROR_CODES.SOURCE_UNAVAILABLE, "MCP source disconnect is not configured");
+      }
+      const source = await options.registry.disconnectSource(actor, normalizedSourceId);
+      return verifyMcpDisconnectResult(options.registry, actor, normalizedSourceId, source);
+    }
+  };
+}
+
+// src/server/agentTools.ts
+function toolResult(value) {
+  return { content: [{ type: "text", text: JSON.stringify(value) }] };
+}
+function createBoringMcpAgentTools(options) {
+  const handlers = createBoringMcpSourceHandlers(options);
+  const bridge = createBoringMcpAgentBridgeRegistry(handlers);
+  return listBoringMcpAgentBridgeTools(bridge).map((tool2) => ({
+    name: tool2.name,
+    description: tool2.description,
+    parameters: tool2.inputSchema,
+    promptSnippet: `${tool2.name}: ${tool2.description}`,
+    async execute(params, ctx) {
+      const actor = await options.resolveActor(params, ctx);
+      return toolResult(await tool2.invoke({ actor }, params));
+    }
+  }));
+}
+
+// src/server/mcpSdkTransport.ts
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+async function resolveEndpoint(options, source) {
+  return typeof options.endpoint === "function" ? options.endpoint({ source }) : options.endpoint;
+}
+function normalizeUrl(value) {
+  try {
+    return value instanceof URL ? value : new URL(value);
+  } catch {
+    throw new McpError(MCP_ERROR_CODES.PROVIDER_CONFIG_INVALID, "Invalid MCP endpoint URL");
+  }
+}
+function normalizeHeaders(headers) {
+  if (!headers) return void 0;
+  return Object.fromEntries(Object.entries(headers).filter(([key, value]) => key.trim() && typeof value === "string"));
+}
+function normalizeError(error) {
+  if (error instanceof McpError) return error;
+  const message = error instanceof Error ? error.message : String(error);
+  return new McpError(MCP_ERROR_CODES.PROVIDER_ERROR, "MCP provider request failed", { message: redactMcpSecrets(message) });
+}
+async function withClient(options, source, run) {
+  const client = new Client({ name: options.clientName ?? "boring-mcp", version: options.clientVersion ?? "0.0.0" });
+  try {
+    const endpoint = await resolveEndpoint(options, source);
+    const transport = new StreamableHTTPClientTransport(normalizeUrl(endpoint.url), {
+      requestInit: { headers: normalizeHeaders(endpoint.headers) }
+    });
+    await client.connect(transport);
+    return await run(client);
+  } catch (error) {
+    throw normalizeError(error);
+  } finally {
+    await client.close().catch(() => void 0);
+  }
+}
+function normalizeTool(tool2) {
+  return { name: tool2.name, description: tool2.description, inputSchema: tool2.inputSchema };
+}
+function normalizeResource(resource) {
+  return { uri: resource.uri, name: resource.name, description: resource.description, mimeType: resource.mimeType };
+}
+function createMcpSdkStreamableHttpTransport(options) {
+  return {
+    async listTools(source) {
+      return withClient(options, source, async (client) => {
+        const result = await client.listTools();
+        return result.tools.map(normalizeTool);
+      });
+    },
+    async listResources(source) {
+      return withClient(options, source, async (client) => {
+        const result = await client.listResources();
+        return result.resources.map(normalizeResource);
+      });
+    },
+    async readResource(source, uri) {
+      return withClient(options, source, async (client) => client.readResource({ uri }));
+    },
+    async callTool(source, toolName, input) {
+      return withClient(options, source, async (client) => {
+        const result = await client.callTool({ name: toolName, arguments: input && typeof input === "object" ? input : {} });
+        return { content: result.content };
+      });
+    }
+  };
+}
+
+// src/server/composioManagedConnector.ts
+function trimTrailingSlash(value) {
+  return value.endsWith("/") ? value.slice(0, -1) : value;
+}
+function composioUserId(actor) {
+  return `${actor.workspaceId}:${actor.userId}`;
+}
+function actorForSource(source) {
+  return { userId: source.userId, workspaceId: source.workspaceId };
+}
+function providerError(message, details) {
+  return new McpError(MCP_ERROR_CODES.PROVIDER_ERROR, message, redactMcpSecrets(details));
+}
+function providerErrorStatus(error) {
+  if (!(error instanceof McpError) || error.code !== MCP_ERROR_CODES.PROVIDER_ERROR) return void 0;
+  const details = record(error.details);
+  return typeof details.status === "number" ? details.status : void 0;
+}
+function requireServerSecret(secret) {
+  if (secret.storage !== "server-env" && secret.storage !== "server-vault" || !secret.value) {
+    throw new McpError(MCP_ERROR_CODES.PROVIDER_CONFIG_INVALID, "Composio connector secret is not configured server-side");
+  }
+}
+async function readJsonResponse(response) {
+  const text = await response.text();
+  if (!text) return void 0;
+  try {
+    return JSON.parse(text);
+  } catch {
+    throw providerError("Composio returned non-JSON response", { status: response.status });
+  }
+}
+function record(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function array(value) {
+  return Array.isArray(value) ? value : [];
+}
+function optionalString(value) {
+  return typeof value === "string" && value.trim() ? value : void 0;
+}
+function optionalHeaders(value) {
+  const entries = Object.entries(record(value)).filter((entry) => typeof entry[1] === "string");
+  return entries.length ? Object.fromEntries(entries) : void 0;
+}
+function normalizeComposioMcpUrl(rawUrl, options) {
+  let parsed;
+  try {
+    parsed = new URL(rawUrl);
+  } catch {
+    throw providerError("Composio session response included an invalid MCP URL");
+  }
+  const loopback = parsed.hostname === "127.0.0.1" || parsed.hostname === "localhost" || parsed.hostname === "::1";
+  const allowedInsecureLoopback = options.allowInsecureMcpUrlsForTests && parsed.protocol === "http:" && loopback;
+  if (parsed.protocol !== "https:" && !allowedInsecureLoopback || parsed.username || parsed.password) {
+    throw new McpError(MCP_ERROR_CODES.PROVIDER_CONFIG_INVALID, "Composio MCP URL must be https and must not include credentials");
+  }
+  return parsed.toString();
+}
+function extractSession(payload, options) {
+  const root = record(payload);
+  const session = record(root.session ?? root.data ?? root);
+  const mcp = record(session.mcp);
+  const id = optionalString(session.id) ?? optionalString(session.session_id) ?? optionalString(root.id) ?? optionalString(root.session_id);
+  const url = optionalString(mcp.url);
+  if (!id || !url) throw providerError("Composio session response did not include an MCP session", payload);
+  return { id, mcp: { url: normalizeComposioMcpUrl(url, options), headers: optionalHeaders(mcp.headers) } };
+}
+function extractConnectUrl(payload) {
+  const root = record(payload);
+  const nested = record(root.data ?? root.connection_request ?? root.link ?? root);
+  return optionalString(root.redirect_url) ?? optionalString(root.redirectUrl) ?? optionalString(root.connect_url) ?? optionalString(root.connectUrl) ?? optionalString(root.url) ?? optionalString(nested.redirect_url) ?? optionalString(nested.redirectUrl) ?? optionalString(nested.connect_url) ?? optionalString(nested.connectUrl) ?? optionalString(nested.url);
+}
+function extractProviderAccountLabel(payload) {
+  const root = record(payload);
+  const nested = record(root.data ?? root.connected_account ?? root.account ?? root);
+  return optionalString(root.providerAccountLabel) ?? optionalString(root.provider_account_label) ?? optionalString(nested.label) ?? optionalString(nested.email) ?? optionalString(nested.name) ?? optionalString(nested.alias);
+}
+async function composioRequest(options, secret, method, path, body) {
+  requireServerSecret(secret);
+  const fetchImpl = options.fetch ?? globalThis.fetch;
+  if (!fetchImpl) throw new McpError(MCP_ERROR_CODES.PROVIDER_CONFIG_INVALID, "fetch is not available for Composio connector");
+  const response = await fetchImpl(`${trimTrailingSlash(options.apiBaseUrl ?? "https://backend.composio.dev")}${path}`, {
+    method,
+    headers: {
+      "content-type": "application/json",
+      "x-api-key": secret.value
+    },
+    body: body === void 0 ? void 0 : JSON.stringify(body)
+  });
+  const payload = await readJsonResponse(response);
+  if (!response.ok) throw providerError("Composio request failed", { status: response.status, payload });
+  return payload;
+}
+function composioPost(options, secret, path, body) {
+  return composioRequest(options, secret, "POST", path, body);
+}
+function composioGet(options, secret, path) {
+  return composioRequest(options, secret, "GET", path);
+}
+function composioDelete(options, secret, path) {
+  return composioRequest(options, secret, "DELETE", path);
+}
+async function resolveComposioMcpSession(options, input) {
+  const payload = await composioPost(options, input.secret, "/api/v3.1/tool_router/session", {
+    user_id: composioUserId(input.actor),
+    mcp: true,
+    toolkits: { enable: [input.config.toolkitId] },
+    manage_connections: {
+      enable: true,
+      enable_wait_for_connections: false,
+      callback_url: options.callbackUrl
+    }
+  });
+  return extractSession(payload, options);
+}
+async function createLink(options, secret, sessionId, config) {
+  return composioPost(options, secret, `/api/v3/tool_router/session/${encodeURIComponent(sessionId)}/link`, {
+    toolkit: config.toolkitId,
+    callback_url: options.callbackUrl
+  });
+}
+function accountIsForConfig(account, actor, config) {
+  const toolkit = record(account.toolkit);
+  return optionalString(toolkit.slug) === config.toolkitId && optionalString(account.user_id) === composioUserId(actor);
+}
+function summarizeAccount(account) {
+  const status = optionalString(account.status)?.toUpperCase();
+  const disabled = account.is_disabled === true || record(account.auth_config).is_disabled === true;
+  return {
+    id: optionalString(account.id) ?? optionalString(account.nanoid) ?? optionalString(account.word_id),
+    label: extractProviderAccountLabel(account),
+    active: !disabled && (status === "ACTIVE" || status === "CONNECTED" || status === "ENABLED")
+  };
+}
+async function findConnectedAccount(options, input) {
+  const params = new URLSearchParams({ user_id: composioUserId(input.actor), toolkit_slug: input.config.toolkitId });
+  const payload = await composioGet(options, input.secret, `/api/v3.1/connected_accounts?${params}`);
+  const items = array(record(payload).items).map(record).filter((account) => accountIsForConfig(account, input.actor, input.config)).map(summarizeAccount);
+  return items.find((account) => account.active) ?? items[0];
+}
+function composioMcpHeaders(session, secret) {
+  requireServerSecret(secret);
+  return { ...session.mcp.headers ?? {}, "x-api-key": secret.value };
+}
+function transportForSession(options, session, secret) {
+  return createMcpSdkStreamableHttpTransport({
+    endpoint: { url: session.mcp.url, headers: composioMcpHeaders(session, secret) },
+    clientName: options.clientName ?? "boring-mcp-composio",
+    clientVersion: options.clientVersion ?? "0.0.0"
+  });
+}
+var COMPOSIO_SEARCH_TOOLS = "COMPOSIO_SEARCH_TOOLS";
+var COMPOSIO_GET_TOOL_SCHEMAS = "COMPOSIO_GET_TOOL_SCHEMAS";
+var COMPOSIO_MULTI_EXECUTE_TOOL = "COMPOSIO_MULTI_EXECUTE_TOOL";
+function isComposioMetaTool(toolName) {
+  return toolName.startsWith("COMPOSIO_");
+}
+function safeTools(tools) {
+  return tools.filter((tool2) => !isComposioMetaTool(tool2.name));
+}
+function jsonFromTextContent(value) {
+  const root = record(value);
+  const content = array(root.content);
+  for (const item of content) {
+    const text = optionalString(record(item).text);
+    if (!text) continue;
+    try {
+      return JSON.parse(text);
+    } catch {
+    }
+  }
+  return void 0;
+}
+function concreteAllowedToolSlugs(provider) {
+  return getMcpProviderTemplate(provider)?.allowedTools.filter((toolName) => !toolName.includes("*")) ?? [];
+}
+function collectComposioToolSlugs(payload, toolkitId) {
+  const root = record(jsonFromTextContent(payload) ?? payload);
+  const data = record(root.data ?? root);
+  const seen = /* @__PURE__ */ new Set();
+  for (const item of array(data.results)) {
+    const result = record(item);
+    const toolkits = array(result.toolkits).filter((toolkit) => typeof toolkit === "string");
+    if (toolkits.length > 0 && !toolkits.some((toolkit) => toolkit.toLowerCase() === toolkitId.toLowerCase())) continue;
+    for (const slug of [...array(result.primary_tool_slugs), ...array(result.related_tool_slugs)]) {
+      if (typeof slug === "string" && slug.trim() && !isComposioMetaTool(slug)) seen.add(slug);
+    }
+  }
+  return [...seen].slice(0, 50);
+}
+function toolsFromComposioSchemas(payload, slugs) {
+  const root = record(jsonFromTextContent(payload) ?? payload);
+  const data = record(root.data ?? root);
+  const schemas = record(data.tool_schemas ?? root.tool_schemas);
+  const tools = [];
+  for (const slug of slugs) {
+    const rawSchema = schemas[slug];
+    if (!rawSchema || typeof rawSchema !== "object" || Array.isArray(rawSchema)) continue;
+    const schema = rawSchema;
+    tools.push({
+      name: optionalString(schema.tool_slug) ?? slug,
+      description: optionalString(schema.description),
+      inputSchema: schema.input_schema ?? {}
+    });
+  }
+  return tools;
+}
+async function discoverComposioToolkitTools(input) {
+  const searchResult = await input.transport.callTool(input.source, COMPOSIO_SEARCH_TOOLS, {
+    queries: [input.config.toolkitId],
+    session: input.session.id
+  });
+  const slugs = [...new Set([
+    ...collectComposioToolSlugs(searchResult, input.config.toolkitId),
+    ...concreteAllowedToolSlugs(input.source.provider)
+  ].filter((toolName) => !isComposioMetaTool(toolName)))];
+  if (slugs.length === 0) return [];
+  const schemaResult = await input.transport.callTool(input.source, COMPOSIO_GET_TOOL_SCHEMAS, {
+    tool_slugs: slugs,
+    session_id: input.session.id
+  });
+  return toolsFromComposioSchemas(schemaResult, slugs);
+}
+function createComposioManagedConnectorProvider(options = {}) {
+  return {
+    async startConnect({ actor, config, secret }) {
+      const session = await resolveComposioMcpSession(options, { actor, config, secret });
+      const link = await createLink(options, secret, session.id, config);
+      return {
+        connectorRef: { provider: config.provider, toolkitId: config.toolkitId, sessionId: session.id },
+        status: "unconfigured",
+        connectUrl: extractConnectUrl(link),
+        providerAccountLabel: extractProviderAccountLabel(link)
+      };
+    },
+    async refreshStatus({ actor, source, config, secret }) {
+      if (source.status === "revoked") {
+        return { status: "revoked", providerAccountLabel: source.providerAccountLabel, lastVerifiedAt: source.lastVerifiedAt, connectorRef: source.connectorRef };
+      }
+      const account = await findConnectedAccount(options, { actor, config, secret });
+      if (!account?.active) {
+        return {
+          status: source.status === "connected" ? "expired" : source.status,
+          providerAccountLabel: account?.label ?? source.providerAccountLabel,
+          lastVerifiedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          connectorRef: { ...source.connectorRef, provider: config.provider, toolkitId: config.toolkitId, connectedAccountId: account?.id }
+        };
+      }
+      const session = await resolveComposioMcpSession(options, { actor, config, secret });
+      return {
+        status: "connected",
+        providerAccountLabel: account.label ?? source.providerAccountLabel,
+        lastVerifiedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        connectorRef: { ...source.connectorRef, provider: config.provider, toolkitId: config.toolkitId, sessionId: session.id, connectedAccountId: account.id }
+      };
+    },
+    async probe({ actor, config, secret }) {
+      const session = await resolveComposioMcpSession(options, { actor, config, secret });
+      const transport = transportForSession(options, session, secret);
+      const source = {
+        id: `composio-probe:${actor.workspaceId}:${actor.userId}:${config.provider}`,
+        workspaceId: actor.workspaceId,
+        userId: actor.userId,
+        provider: config.provider,
+        displayName: config.displayName,
+        status: "connected",
+        ownerKind: "user",
+        credentialProvider: "composio-managed",
+        connectorRef: { provider: config.provider, toolkitId: config.toolkitId, sessionId: session.id }
+      };
+      const [tools, resources] = await Promise.all([
+        transport.listTools(source).then(safeTools),
+        transport.listResources(source).catch(() => [])
+      ]);
+      return { tools, resources };
+    },
+    async revoke({ actor, source, config, secret }) {
+      const connectedAccountId = source.connectorRef?.connectedAccountId ?? (await findConnectedAccount(options, { actor, config, secret }))?.id;
+      if (!connectedAccountId) return;
+      try {
+        await composioDelete(options, secret, `/api/v3.1/connected_accounts/${encodeURIComponent(connectedAccountId)}`);
+      } catch (error) {
+        if (providerErrorStatus(error) === 404) return;
+        throw error;
+      }
+    }
+  };
+}
+var COMPOSIO_TRANSPORT_SESSION_TTL_MS = 5 * 6e4;
+function providerErrorText(error) {
+  if (error instanceof McpError) {
+    const details = error.details;
+    if (details && typeof details === "object" && typeof details.message === "string") return details.message;
+  }
+  return error instanceof Error ? error.message : String(error);
+}
+function isUnsupportedResourcesError(error) {
+  const message = providerErrorText(error).toLowerCase();
+  return message.includes("does not support resources") || message.includes("method not found") || message.includes("resources/list") && (message.includes("not found") || message.includes("unsupported"));
+}
+function createComposioMcpTransport(options) {
+  const cache = /* @__PURE__ */ new Map();
+  const pendingSessions = /* @__PURE__ */ new Map();
+  function keyForSource(source) {
+    const connector = source.connectorRef;
+    return [
+      source.workspaceId,
+      source.userId,
+      source.provider,
+      source.id,
+      source.updatedAt,
+      connector?.sessionId ?? "",
+      connector?.connectedAccountId ?? "",
+      connector?.externalSourceId ?? ""
+    ].join(":");
+  }
+  async function createCacheEntry(source) {
+    const config = options.configs.find((entry2) => entry2.provider === source.provider);
+    if (!config) throw new McpError(MCP_ERROR_CODES.PROVIDER_CONFIG_INVALID, "Unknown Composio MCP provider", { reason: "unsupported_provider" });
+    const secret = await options.secretResolver.resolveSecret(source.provider);
+    const session = await resolveComposioMcpSession(options, { actor: actorForSource(source), config, secret });
+    const entry = { config, secret, session, expiresAt: Date.now() + COMPOSIO_TRANSPORT_SESSION_TTL_MS };
+    cache.set(keyForSource(source), entry);
+    return entry;
+  }
+  function pruneExpiredEntries(now = Date.now()) {
+    for (const [key, entry] of cache) {
+      if (entry.expiresAt <= now) cache.delete(key);
+    }
+  }
+  async function cachedContext(source) {
+    const key = keyForSource(source);
+    const now = Date.now();
+    pruneExpiredEntries(now);
+    const cached = cache.get(key);
+    if (cached && cached.expiresAt > now) {
+      return { key, entry: cached, transport: transportForSession(options, cached.session, cached.secret) };
+    }
+    const pending = pendingSessions.get(key) ?? createCacheEntry(source).finally(() => pendingSessions.delete(key));
+    pendingSessions.set(key, pending);
+    const entry = await pending;
+    return { key, entry, transport: transportForSession(options, entry.session, entry.secret) };
+  }
+  async function rawToolsFor(source, entry, transport) {
+    if (entry.rawTools) return entry.rawTools;
+    const tools = await transport.listTools(source);
+    entry.rawTools = tools;
+    return tools;
+  }
+  return {
+    async listTools(source, input) {
+      const { key, entry, transport } = await cachedContext(source);
+      if (input?.forceProviderRefresh) {
+        entry.rawTools = void 0;
+        entry.toolkitTools = void 0;
+      }
+      try {
+        const rawTools = await rawToolsFor(source, entry, transport);
+        const directTools = safeTools(rawTools);
+        if (directTools.length > 0 || !rawTools.some((tool2) => tool2.name === COMPOSIO_SEARCH_TOOLS) || !rawTools.some((tool2) => tool2.name === COMPOSIO_GET_TOOL_SCHEMAS)) {
+          return directTools;
+        }
+        entry.toolkitTools ??= await discoverComposioToolkitTools({ transport, source, config: entry.config, session: entry.session });
+        return entry.toolkitTools;
+      } catch (error) {
+        cache.delete(key);
+        throw error;
+      }
+    },
+    async listResources(source) {
+      const { key, transport } = await cachedContext(source);
+      try {
+        return await transport.listResources(source);
+      } catch (error) {
+        if (isUnsupportedResourcesError(error)) return [];
+        cache.delete(key);
+        throw error;
+      }
+    },
+    async readResource(source, uri) {
+      const { key, transport } = await cachedContext(source);
+      try {
+        return await transport.readResource(source, uri);
+      } catch (error) {
+        cache.delete(key);
+        throw error;
+      }
+    },
+    async callTool(source, toolName, input) {
+      if (isComposioMetaTool(toolName)) throw new McpError(MCP_ERROR_CODES.TOOL_NOT_ALLOWED, "Composio MCP management tools are not exposed");
+      const { key, entry, transport } = await cachedContext(source);
+      try {
+        const rawTools = await rawToolsFor(source, entry, transport);
+        if (rawTools.some((tool2) => tool2.name === toolName)) return await transport.callTool(source, toolName, input);
+        if (!rawTools.some((tool2) => tool2.name === COMPOSIO_MULTI_EXECUTE_TOOL)) return await transport.callTool(source, toolName, input);
+        return await transport.callTool(source, COMPOSIO_MULTI_EXECUTE_TOOL, {
+          tools: [{ tool_slug: toolName, arguments: input && typeof input === "object" ? input : {} }],
+          sync_response_to_workbench: false,
+          thought: `Execute ${toolName} through governed boring-mcp`,
+          current_step: "MCP_READONLY_CALL",
+          current_step_metric: "1/1 tools",
+          session_id: entry.session.id
+        });
+      } catch (error) {
+        cache.delete(key);
+        throw error;
+      }
+    }
+  };
+}
+
+// src/server/managedConnectorAdapter.ts
+import { createHash as createHash2 } from "crypto";
+function findConfig(configs, provider) {
+  return configs.find((config) => config.provider === provider);
+}
+function createManagedConnectorSourceId(actor, provider) {
+  const digest = createHash2("sha256").update(`${actor.workspaceId}\0${actor.userId}\0${provider}`).digest("hex").slice(0, 32);
+  return validateMcpSourceId(`managed:${provider}:${digest}`);
+}
+function createLegacyManagedConnectorSourceId(actor, provider) {
+  return validateMcpSourceId(`managed:${actor.workspaceId}:${actor.userId}:${provider}`);
+}
+function defaultSourceId(actor, config) {
+  return createManagedConnectorSourceId(actor, config.provider);
+}
+function assertSecretFree(value, canaries, code = MCP_ERROR_CODES.SECRET_LEAK_GUARD) {
+  if (containsMcpSecretOrCanary(value, canaries)) {
+    throw new McpError(code, "Managed connector response contained secret material");
+  }
+}
+function safeConnectUrl(rawUrl, config) {
+  if (!rawUrl) return void 0;
+  let parsed;
+  try {
+    parsed = new URL(rawUrl);
+  } catch {
+    throw new McpError(MCP_ERROR_CODES.PROVIDER_CONFIG_INVALID, "Managed connector returned an invalid connect URL");
+  }
+  if (parsed.protocol !== "https:" || parsed.username || parsed.password) {
+    throw new McpError(MCP_ERROR_CODES.PROVIDER_CONFIG_INVALID, "Managed connector returned an unsafe connect URL");
+  }
+  if (config.connectUrlOrigins?.length && !config.connectUrlOrigins.includes(parsed.origin)) {
+    throw new McpError(MCP_ERROR_CODES.PROVIDER_CONFIG_INVALID, "Managed connector returned an unapproved connect URL origin");
+  }
+  return parsed.toString();
+}
+function createManagedConnectorAdapter(options) {
+  const canaries = [...options.preflightEvidence?.redactionCanaries ?? [], ...options.redactionCanaries ?? []];
+  const templates = options.templates;
+  async function getSecret(provider) {
+    const secret = await options.secretResolver.resolveSecret(provider);
+    if (secret.storage !== "server-env" && secret.storage !== "server-vault" || !secret.value) {
+      throw new McpError(MCP_ERROR_CODES.PROVIDER_CONFIG_INVALID, "Managed connector secret is not configured");
+    }
+    return secret;
+  }
+  function requireConfig(provider) {
+    const config = findConfig(options.configs, provider);
+    const template = getMcpProviderTemplate(provider, templates);
+    if (!config || !template) throw new McpError(MCP_ERROR_CODES.PROVIDER_CONFIG_INVALID, "Unknown managed connector provider", { reason: "unsupported_provider" });
+    return { config, template };
+  }
+  return {
+    async startConnect(actor, input) {
+      const { config } = requireConfig(input.provider);
+      const sourceId = validateMcpSourceId((options.sourceIdFactory ?? defaultSourceId)(actor, config));
+      const secret = await getSecret(config.provider);
+      const secretCanaries = [...canaries, secret.value];
+      const response = await options.provider.startConnect({ actor, config, secret, sourceId });
+      const connectUrl = safeConnectUrl(response.connectUrl, config);
+      assertSecretFree({ ...response, connectUrl }, secretCanaries);
+      const source = {
+        id: sourceId,
+        workspaceId: actor.workspaceId,
+        userId: actor.userId,
+        provider: config.provider,
+        displayName: input.displayName ?? config.displayName,
+        status: response.status ?? "unconfigured",
+        ownerKind: "user",
+        credentialProvider: "composio-managed",
+        scopes: config.scopes ? [...config.scopes] : void 0,
+        providerAccountLabel: response.providerAccountLabel,
+        connectorRef: response.connectorRef
+      };
+      assertSecretFree(source, secretCanaries);
+      const saved = await options.registry.upsertSource(actor, source);
+      const result = { ...createMcpSourceStatusPayload(saved), connectUrl };
+      assertSecretFree(result, secretCanaries);
+      return result;
+    },
+    async refreshStatus(actor, sourceId) {
+      const source = await requireActorOwnedMcpSource(options.registry, actor, sourceId);
+      const { config } = requireConfig(source.provider);
+      const secret = await getSecret(config.provider);
+      const secretCanaries = [...canaries, secret.value];
+      const response = await options.provider.refreshStatus({ actor, source, config, secret });
+      assertSecretFree(response, secretCanaries);
+      const nextSource = {
+        ...source,
+        status: response.status,
+        providerAccountLabel: response.providerAccountLabel ?? source.providerAccountLabel,
+        connectorRef: response.connectorRef ?? source.connectorRef,
+        lastVerifiedAt: response.lastVerifiedAt
+      };
+      assertSecretFree(nextSource, secretCanaries);
+      const saved = await options.registry.upsertSource(actor, nextSource);
+      const result = createMcpSourceStatusPayload(saved);
+      assertSecretFree(result, secretCanaries);
+      return result;
+    },
+    async probeSource(actor, sourceId) {
+      const source = await requireActorOwnedMcpSource(options.registry, actor, sourceId);
+      if (source.status !== "connected") throw new McpError(MCP_ERROR_CODES.SOURCE_UNAVAILABLE, "MCP source is not connected");
+      const { config, template } = requireConfig(source.provider);
+      const secret = await getSecret(config.provider);
+      const response = await options.provider.probe({ actor, source, config, secret });
+      assertSecretFree(response, [...canaries, secret.value]);
+      const result = {
+        sourceId: source.id,
+        provider: source.provider,
+        tools: classifyMcpTools(template, response.tools),
+        resources: response.resources
+      };
+      assertSecretFree(result, [...canaries, secret.value]);
+      return result;
+    },
+    async disconnectSource(actor, sourceId) {
+      if (!options.registry.disconnectSource) throw new McpError(MCP_ERROR_CODES.SOURCE_UNAVAILABLE, "MCP source disconnect is not configured");
+      const source = await requireActorOwnedMcpSource(options.registry, actor, sourceId);
+      let secretCanaries = canaries;
+      if (options.provider.revoke) {
+        try {
+          const { config } = requireConfig(source.provider);
+          const secret = await getSecret(config.provider);
+          await options.provider.revoke({ actor, source, config, secret });
+          secretCanaries = [...canaries, secret.value];
+        } catch (error) {
+          if (!(error instanceof McpError && error.code === MCP_ERROR_CODES.PROVIDER_CONFIG_INVALID)) throw error;
+        }
+      }
+      const disconnected = await options.registry.disconnectSource(actor, source.id);
+      const result = await verifyMcpDisconnectResult(options.registry, actor, source.id, disconnected);
+      assertSecretFree(result, secretCanaries);
+      return result;
+    }
+  };
+}
+
+// src/server/managedConnectorPreflight.ts
+var VENDOR_RISK_FIELDS = [
+  "dpaStatus",
+  "subprocessorStatus",
+  "dataResidencyStatus",
+  "incidentHistoryStatus"
+];
+function check(id, ok, message, code = MCP_ERROR_CODES.PROVIDER_CONFIG_INVALID) {
+  return ok ? { id, ok, message } : { id, ok, code, message };
+}
+function hasText(value) {
+  return value.trim().length > 0;
+}
+function hasAcceptedGap(evidence, field) {
+  return evidence[field] === "approved" || Boolean(evidence.acceptedGaps?.some((gap) => gap.id === field && hasText(gap.owner) && hasText(gap.followUp) && hasText(gap.reason)));
+}
+function validateManagedConnectorPreflight(evidence) {
+  const hasBrowserSamples = evidence.browserDtoSamples.length > 0;
+  const hasLogSamples = evidence.redactedLogSamples.length > 0;
+  const hasProviderResultSamples = evidence.redactedProviderResultSamples.length > 0;
+  const hasCanaries = evidence.redactionCanaries.some(hasText);
+  const browserHasSecret = containsMcpSecretOrCanary(evidence.browserDtoSamples, evidence.redactionCanaries);
+  const logsHaveSecret = containsMcpSecretOrCanary(evidence.redactedLogSamples, evidence.redactionCanaries);
+  const providerResultsHaveSecret = containsMcpSecretOrCanary(evidence.redactedProviderResultSamples, evidence.redactionCanaries);
+  const vendorRiskOk = VENDOR_RISK_FIELDS.every((field) => hasAcceptedGap(evidence.vendorRisk, field));
+  const checks = [
+    check("isolated-test-project", evidence.isolatedTestProject, "Connector test project is isolated from production data"),
+    check("server-only-api-key", evidence.apiKeyStorage === "server-env" || evidence.apiKeyStorage === "server-vault", "Connector API key resolves only from server env/Vault"),
+    check("redaction-canaries-present", hasCanaries, "Explicit redaction canaries are provided for browser/log/provider-result evidence"),
+    check("browser-dto-secret-free", hasBrowserSamples && !browserHasSecret, "Browser DTO samples contain no API keys, OAuth tokens, cookies, MCP session headers, or seeded canaries", MCP_ERROR_CODES.SECRET_LEAK_GUARD),
+    check("log-redaction-canary", hasLogSamples && !logsHaveSecret, "Redacted log samples contain no connector/API/session/OAuth canaries", MCP_ERROR_CODES.SECRET_LEAK_GUARD),
+    check("provider-result-redaction-canary", hasProviderResultSamples && !providerResultsHaveSecret, "Redacted provider result samples contain no connector/API/session/OAuth canaries", MCP_ERROR_CODES.SECRET_LEAK_GUARD),
+    check("revoke-disconnect", evidence.revokeDisconnectVerified, "Revoke/disconnect behavior has been verified for the connector"),
+    check("connected-account-status", evidence.connectedAccountStatusVerified, "Connected-account status refresh behavior has been verified"),
+    check("vendor-risk", vendorRiskOk, "DPA, subprocessors, data residency, and incident-history risk are approved or owner-accepted")
+  ];
+  return { ok: checks.every((item) => item.ok), connectorName: evidence.connectorName, checks };
+}
+function assertManagedConnectorPreflight(evidence) {
+  const result = validateManagedConnectorPreflight(evidence);
+  if (!result.ok) {
+    const failed = result.checks.filter((item) => !item.ok).map((item) => item.id).join(", ");
+    throw new McpError(MCP_ERROR_CODES.PROVIDER_CONFIG_INVALID, `Managed connector preflight failed for ${result.connectorName}: ${failed}`, result);
+  }
+}
+
+// src/server/index.ts
+function createBoringMcpServerPlugin(options = {}) {
+  const hasAgentToolWiring = Boolean(options.registry && options.transport && options.resolveActor);
+  return defineServerPlugin({
+    id: BORING_MCP_PLUGIN_ID,
+    label: "Sources",
+    systemPrompt: options.systemPrompt ?? "Use boring-mcp bridge tools only when an app has enabled them. Treat MCP sources as read-only unless a tool is explicitly allowed.",
+    agentTools: hasAgentToolWiring ? createBoringMcpAgentTools({
+      registry: options.registry,
+      transport: options.transport,
+      resolveActor: options.resolveActor,
+      templates: options.templates,
+      maxReadonlyInputBytes: options.maxReadonlyInputBytes,
+      audit: options.audit,
+      hardening: options.hardening
+    }) : void 0
+  });
+}
+var server_default = createBoringMcpServerPlugin();
+export {
+  AIRTABLE_MCP_TEMPLATE,
+  BORING_MCP_AGENT_BRIDGE_TOOL_DEFINITIONS,
+  BORING_MCP_AGENT_BRIDGE_TOOL_NAMES,
+  BORING_MCP_PLUGIN_ID,
+  BORING_MCP_SOURCES_PANEL_ID,
+  BORING_MCP_SOURCES_TAB_PANEL_ID,
+  DEFAULT_MCP_PROVIDER_TEMPLATES,
+  InMemoryMcpRateBudgetGate,
+  InMemoryMcpToolCatalogCache,
+  MCP_ERROR_CODES,
+  MCP_TOOL_NAME_PATTERN,
+  McpAccessFacade,
+  McpError,
+  NOTION_MCP_TEMPLATE,
+  assertManagedConnectorPreflight,
+  assertMcpPublicPayloadSecretFree,
+  assertMcpToolAllowed,
+  classifyMcpTool,
+  classifyMcpTools,
+  containsMcpCanary,
+  containsMcpSecret,
+  containsMcpSecretOrCanary,
+  createBoringMcpAgentBridgeRegistry,
+  createBoringMcpAgentTools,
+  createBoringMcpReadonlyCaller,
+  createBoringMcpServerPlugin,
+  createBoringMcpSourceHandlers,
+  createBoringMcpToolCatalog,
+  createComposioManagedConnectorProvider,
+  createComposioMcpTransport,
+  createHardenedMcpTransport,
+  createLegacyManagedConnectorSourceId,
+  createManagedConnectorAdapter,
+  createManagedConnectorSourceId,
+  createMcpSchemaHash,
+  createMcpSdkStreamableHttpTransport,
+  createMcpSourceStatusPayload,
+  server_default as default,
+  doctorMcpSource,
+  evaluateBoringMcpLaunchGate,
+  getMcpProviderTemplate,
+  isActorOwnedMcpSource,
+  listBoringMcpAgentBridgeTools,
+  normalizeMcpCatalogTool,
+  redactMcpSecrets,
+  requireActorOwnedMcpSource,
+  resolveComposioMcpSession,
+  toMcpSourceDto,
+  validateManagedConnectorPreflight,
+  validateMcpSourceId,
+  validateMcpToolName,
+  verifyMcpDisconnectResult
+};