@hachej/boring-mcp 0.0.0

package/dist/server/index.d.ts

@@ -0,0 +1,374 @@
+import * as _hachej_boring_workspace from '@hachej/boring-workspace';
+import { ToolExecContext, AgentTool } from '@hachej/boring-workspace';
+import { McpActor, McpProviderId, McpToolCatalogEntry, McpToolSearchResult, McpToolDescribeResult, McpSourceRegistry, McpTransportClient, McpProviderTemplate, McpDiscoveredTool, McpReadonlyCallAuditEvent, McpReadonlyCallInput, McpReadonlyCallResult, McpSourceDto, McpSourceStatusPayload, McpDoctorResult, McpProbeResult, McpSource, McpErrorCode, McpConnectorRef, McpSourceStatus, McpDiscoveredResource } from '../shared/index.js';
+export { AIRTABLE_MCP_TEMPLATE, BORING_MCP_PLUGIN_ID, BORING_MCP_SOURCES_PANEL_ID, BORING_MCP_SOURCES_TAB_PANEL_ID, DEFAULT_MCP_PROVIDER_TEMPLATES, MCP_ERROR_CODES, MCP_TOOL_NAME_PATTERN, McpAccessFacade, McpCredentialProvider, McpDoctorIssue, McpError, McpSourceAccessPolicy, McpSourceOwnerKind, McpSourceStore, McpToolCallResult, McpToolDecision, McpToolRisk, McpTransport, McpTransportListToolsOptions, NOTION_MCP_TEMPLATE, NormalizedMcpTool, assertMcpToolAllowed, classifyMcpTool, classifyMcpTools, containsMcpCanary, containsMcpSecret, containsMcpSecretOrCanary, doctorMcpSource, getMcpProviderTemplate, redactMcpSecrets, toMcpSourceDto, validateMcpToolName } from '../shared/index.js';
+
+interface McpToolCatalogSnapshot {
+    sourceId: string;
+    provider: McpProviderId;
+    sourceRevision: string;
+    tools: McpToolCatalogEntry[];
+}
+interface McpToolCatalogCache {
+    get(actor: McpActor, sourceId: string): Promise<McpToolCatalogSnapshot | undefined>;
+    set(actor: McpActor, sourceId: string, result: McpToolCatalogSnapshot): Promise<void>;
+}
+interface BoringMcpToolCatalogOptions {
+    registry: McpSourceRegistry;
+    transport: McpTransportClient;
+    templates?: readonly McpProviderTemplate[];
+    cache?: McpToolCatalogCache;
+}
+interface McpToolsSearchInput {
+    sourceId?: string;
+    query?: string;
+    refresh?: boolean;
+    providerRefresh?: boolean;
+}
+interface McpToolDescribeInput {
+    sourceId: string;
+    toolName: string;
+    expectedSchemaHash?: string;
+    refresh?: boolean;
+    providerRefresh?: boolean;
+}
+interface BoringMcpToolCatalog {
+    searchTools(actor: McpActor, input?: McpToolsSearchInput): Promise<McpToolSearchResult>;
+    describeTool(actor: McpActor, input: McpToolDescribeInput): Promise<McpToolDescribeResult>;
+}
+declare class InMemoryMcpToolCatalogCache implements McpToolCatalogCache {
+    private readonly values;
+    get(actor: McpActor, sourceId: string): Promise<McpToolCatalogSnapshot | undefined>;
+    set(actor: McpActor, sourceId: string, result: McpToolCatalogSnapshot): Promise<void>;
+}
+declare function createMcpSchemaHash(schema: unknown): string;
+declare function normalizeMcpCatalogTool(sourceId: string, provider: McpProviderId, tool: McpDiscoveredTool, templates?: readonly McpProviderTemplate[]): McpToolCatalogEntry;
+declare function createBoringMcpToolCatalog(options: BoringMcpToolCatalogOptions): BoringMcpToolCatalog;
+
+interface McpReadonlyCallAuditSink {
+    record(event: McpReadonlyCallAuditEvent): void | Promise<void>;
+}
+interface BoringMcpReadonlyCallOptions {
+    registry: McpSourceRegistry;
+    transport: McpTransportClient;
+    templates?: readonly McpProviderTemplate[];
+    maxInputBytes?: number;
+    audit?: McpReadonlyCallAuditSink;
+    catalogCache?: McpToolCatalogCache;
+}
+interface BoringMcpReadonlyCaller {
+    callReadonly(actor: McpActor, input: McpReadonlyCallInput): Promise<McpReadonlyCallResult>;
+}
+declare function createBoringMcpReadonlyCaller(options: BoringMcpReadonlyCallOptions): BoringMcpReadonlyCaller;
+
+interface BoringMcpSourceHandlersOptions {
+    registry: McpSourceRegistry;
+    transport: McpTransportClient;
+    templates?: readonly McpProviderTemplate[];
+    maxReadonlyInputBytes?: number;
+    audit?: McpReadonlyCallAuditSink;
+    hardening?: McpProviderHardeningOptions;
+}
+interface BoringMcpSourceHandlers {
+    listSources(actor: McpActor): Promise<{
+        sources: McpSourceDto[];
+    }>;
+    getSourceStatus(actor: McpActor, sourceId: string): Promise<McpSourceStatusPayload>;
+    doctorSource(actor: McpActor, sourceId: string): Promise<McpDoctorResult>;
+    probeSource(actor: McpActor, sourceId: string): Promise<McpProbeResult>;
+    searchTools(actor: McpActor, input?: McpToolsSearchInput): Promise<McpToolSearchResult>;
+    describeTool(actor: McpActor, input: McpToolDescribeInput): Promise<McpToolDescribeResult>;
+    mcp_tools_search(actor: McpActor, input?: McpToolsSearchInput): Promise<McpToolSearchResult>;
+    mcp_tool_describe(actor: McpActor, input: McpToolDescribeInput): Promise<McpToolDescribeResult>;
+    callReadonly(actor: McpActor, input: McpReadonlyCallInput): Promise<McpReadonlyCallResult>;
+    mcp_readonly_call(actor: McpActor, input: McpReadonlyCallInput): Promise<McpReadonlyCallResult>;
+    disconnectSource(actor: McpActor, sourceId: string): Promise<McpSourceStatusPayload>;
+}
+declare function createBoringMcpSourceHandlers(options: BoringMcpSourceHandlersOptions): BoringMcpSourceHandlers;
+
+declare const BORING_MCP_AGENT_BRIDGE_TOOL_NAMES: readonly ["mcp_servers_list", "mcp_server_status", "mcp_server_doctor", "mcp_server_probe", "mcp_tools_search", "mcp_tool_describe", "mcp_readonly_call"];
+type BoringMcpAgentBridgeToolName = (typeof BORING_MCP_AGENT_BRIDGE_TOOL_NAMES)[number];
+interface BoringMcpAgentBridgeContext {
+    actor: McpActor;
+}
+interface BoringMcpAgentBridgeToolDefinition {
+    name: BoringMcpAgentBridgeToolName;
+    description: string;
+    inputSchema: Record<string, unknown>;
+    readOnly: true;
+}
+interface BoringMcpAgentBridgeTool<TInput = unknown, TResult = unknown> extends BoringMcpAgentBridgeToolDefinition {
+    invoke(context: BoringMcpAgentBridgeContext, input: TInput): Promise<TResult>;
+}
+type BoringMcpAgentBridgeRegistry = Record<BoringMcpAgentBridgeToolName, BoringMcpAgentBridgeTool>;
+declare const BORING_MCP_AGENT_BRIDGE_TOOL_DEFINITIONS: readonly BoringMcpAgentBridgeToolDefinition[];
+declare function createBoringMcpAgentBridgeRegistry(handlers: BoringMcpSourceHandlers): BoringMcpAgentBridgeRegistry;
+declare function listBoringMcpAgentBridgeTools(registry: BoringMcpAgentBridgeRegistry): BoringMcpAgentBridgeTool[];
+
+type McpProviderOperation = "listTools" | "listResources" | "readResource" | "callTool";
+interface McpProviderCallContext {
+    actor?: McpActor;
+    sourceId: string;
+    operation: McpProviderOperation;
+    toolName?: string;
+}
+interface McpProviderRateBudgetGate {
+    check(context: McpProviderCallContext): void | Promise<void>;
+}
+interface McpProviderHardeningOptions {
+    timeoutMs?: number;
+    metadataRetries?: number;
+    gate?: McpProviderRateBudgetGate;
+}
+interface InMemoryMcpRateBudgetGateOptions {
+    maxCalls: number;
+    windowMs: number;
+    maxToolCalls?: number;
+}
+declare class InMemoryMcpRateBudgetGate implements McpProviderRateBudgetGate {
+    private readonly options;
+    private readonly buckets;
+    constructor(options: InMemoryMcpRateBudgetGateOptions);
+    check(context: McpProviderCallContext): void;
+}
+declare function createHardenedMcpTransport(transport: McpTransportClient, options?: McpProviderHardeningOptions, actor?: McpActor): McpTransportClient;
+declare function verifyMcpDisconnectResult(registry: McpSourceRegistry, actor: McpActor, sourceId: string, disconnected: McpSource | undefined): Promise<McpSourceStatusPayload>;
+interface BoringMcpLaunchGateInput {
+    pluginId?: string;
+    registry?: McpSourceRegistry;
+    transport?: McpTransportClient;
+    bridge?: Partial<BoringMcpAgentBridgeRegistry>;
+    templates?: readonly McpProviderTemplate[];
+    hardening?: McpProviderHardeningOptions;
+    maxReadonlyInputBytes?: number;
+    docsReviewed?: boolean;
+}
+type BoringMcpLaunchGateIssueCode = "MCP_LAUNCH_PLUGIN_MISSING" | "MCP_LAUNCH_REGISTRY_INCOMPLETE" | "MCP_LAUNCH_TRANSPORT_MISSING" | "MCP_LAUNCH_BRIDGE_TOOL_MISSING" | "MCP_LAUNCH_TEMPLATES_MISSING" | "MCP_LAUNCH_RATE_BUDGET_MISSING" | "MCP_LAUNCH_TIMEOUT_MISSING" | "MCP_LAUNCH_INPUT_LIMIT_MISSING" | "MCP_LAUNCH_OPERATOR_DOCS_MISSING" | "MCP_LAUNCH_SECRET_LEAK";
+interface BoringMcpLaunchGateIssue {
+    level: "error";
+    code: BoringMcpLaunchGateIssueCode;
+    message: string;
+}
+interface BoringMcpLaunchGateResult {
+    ok: boolean;
+    issues: BoringMcpLaunchGateIssue[];
+}
+declare function evaluateBoringMcpLaunchGate(input: BoringMcpLaunchGateInput): BoringMcpLaunchGateResult;
+
+type BoringMcpAgentToolActorResolver = (params: Record<string, unknown>, ctx: ToolExecContext) => McpActor | Promise<McpActor>;
+interface CreateBoringMcpAgentToolsOptions {
+    registry: McpSourceRegistry;
+    transport: McpTransportClient;
+    resolveActor: BoringMcpAgentToolActorResolver;
+    templates?: readonly McpProviderTemplate[];
+    maxReadonlyInputBytes?: number;
+    audit?: McpReadonlyCallAuditSink;
+    hardening?: McpProviderHardeningOptions;
+}
+declare function createBoringMcpAgentTools(options: CreateBoringMcpAgentToolsOptions): AgentTool[];
+
+type ManagedConnectorSecretStorage = "server-env" | "server-vault";
+type ManagedConnectorRiskStatus = "approved" | "owner-accepted-gap";
+interface ManagedConnectorAcceptedGap {
+    id: string;
+    owner: string;
+    followUp: string;
+    reason: string;
+}
+interface ManagedConnectorVendorRiskEvidence {
+    dpaStatus: ManagedConnectorRiskStatus;
+    subprocessorStatus: ManagedConnectorRiskStatus;
+    dataResidencyStatus: ManagedConnectorRiskStatus;
+    incidentHistoryStatus: ManagedConnectorRiskStatus;
+    acceptedGaps?: readonly ManagedConnectorAcceptedGap[];
+}
+interface ManagedConnectorPreflightEvidence {
+    connectorName: string;
+    isolatedTestProject: boolean;
+    apiKeyStorage: ManagedConnectorSecretStorage;
+    browserDtoSamples: readonly unknown[];
+    redactedLogSamples: readonly unknown[];
+    redactedProviderResultSamples: readonly unknown[];
+    redactionCanaries: readonly string[];
+    revokeDisconnectVerified: boolean;
+    connectedAccountStatusVerified: boolean;
+    vendorRisk: ManagedConnectorVendorRiskEvidence;
+}
+interface ManagedConnectorPreflightCheck {
+    id: string;
+    ok: boolean;
+    code?: McpErrorCode;
+    message: string;
+}
+interface ManagedConnectorPreflightResult {
+    ok: boolean;
+    connectorName: string;
+    checks: ManagedConnectorPreflightCheck[];
+}
+declare function validateManagedConnectorPreflight(evidence: ManagedConnectorPreflightEvidence): ManagedConnectorPreflightResult;
+declare function assertManagedConnectorPreflight(evidence: ManagedConnectorPreflightEvidence): void;
+
+interface ManagedConnectorSecret {
+    storage: ManagedConnectorSecretStorage;
+    value: string;
+}
+interface ManagedConnectorSecretResolver {
+    resolveSecret(provider: McpProviderId): Promise<ManagedConnectorSecret>;
+}
+interface ManagedConnectorConfig {
+    provider: McpProviderId;
+    displayName: string;
+    toolkitId: string;
+    scopes?: readonly string[];
+    connectUrlOrigins?: readonly string[];
+}
+interface ManagedConnectorSourceRegistry extends McpSourceRegistry {
+    upsertSource(actor: McpActor, source: McpSource): Promise<McpSource>;
+}
+interface ManagedConnectorStartInput {
+    provider: McpProviderId;
+    displayName?: string;
+}
+interface ManagedConnectorStartResponse {
+    connectorRef: McpConnectorRef;
+    status?: Exclude<McpSourceStatus, "connected">;
+    connectUrl?: string;
+    providerAccountLabel?: string;
+}
+interface ManagedConnectorStatusResponse {
+    status: McpSourceStatus;
+    providerAccountLabel?: string;
+    lastVerifiedAt?: string;
+    connectorRef?: McpConnectorRef;
+}
+interface ManagedConnectorProbeResponse {
+    tools: McpDiscoveredTool[];
+    resources: McpDiscoveredResource[];
+}
+interface ManagedConnectorProvider {
+    startConnect(args: {
+        actor: McpActor;
+        config: ManagedConnectorConfig;
+        secret: ManagedConnectorSecret;
+        sourceId: string;
+    }): Promise<ManagedConnectorStartResponse>;
+    refreshStatus(args: {
+        actor: McpActor;
+        source: McpSource;
+        config: ManagedConnectorConfig;
+        secret: ManagedConnectorSecret;
+    }): Promise<ManagedConnectorStatusResponse>;
+    probe(args: {
+        actor: McpActor;
+        source: McpSource;
+        config: ManagedConnectorConfig;
+        secret: ManagedConnectorSecret;
+    }): Promise<ManagedConnectorProbeResponse>;
+    revoke?(args: {
+        actor: McpActor;
+        source: McpSource;
+        config: ManagedConnectorConfig;
+        secret: ManagedConnectorSecret;
+    }): Promise<void>;
+}
+interface ManagedConnectorAdapterOptions {
+    registry: ManagedConnectorSourceRegistry;
+    provider: ManagedConnectorProvider;
+    secretResolver: ManagedConnectorSecretResolver;
+    configs: readonly ManagedConnectorConfig[];
+    preflightEvidence?: ManagedConnectorPreflightEvidence;
+    templates?: readonly McpProviderTemplate[];
+    redactionCanaries?: readonly string[];
+    sourceIdFactory?: (actor: McpActor, config: ManagedConnectorConfig) => string;
+}
+interface ManagedConnectorAdapter {
+    startConnect(actor: McpActor, input: ManagedConnectorStartInput): Promise<ManagedConnectorStartResult>;
+    refreshStatus(actor: McpActor, sourceId: string): Promise<McpSourceStatusPayload>;
+    probeSource(actor: McpActor, sourceId: string): Promise<McpProbeResult>;
+    disconnectSource(actor: McpActor, sourceId: string): Promise<McpSourceStatusPayload>;
+}
+interface ManagedConnectorStartResult extends McpSourceStatusPayload {
+    connectUrl?: string;
+}
+declare function createManagedConnectorSourceId(actor: McpActor, provider: McpProviderId): string;
+declare function createLegacyManagedConnectorSourceId(actor: McpActor, provider: McpProviderId): string;
+declare function createManagedConnectorAdapter(options: ManagedConnectorAdapterOptions): ManagedConnectorAdapter;
+
+interface ComposioMcpSession {
+    id: string;
+    mcp: {
+        url: string;
+        headers?: Record<string, string>;
+    };
+}
+interface ComposioManagedConnectorProviderOptions {
+    /** Defaults to Composio production API. Override in tests or private deployments. */
+    apiBaseUrl?: string;
+    /** Defaults to global fetch. */
+    fetch?: typeof fetch;
+    /** Optional redirect URL Composio should use after hosted auth completes. */
+    callbackUrl?: string;
+    /** Optional client metadata for the MCP SDK client used during probe/transport calls. */
+    clientName?: string;
+    clientVersion?: string;
+    /** Test-only escape hatch for loopback fake MCP servers. Production Composio MCP URLs must be https. */
+    allowInsecureMcpUrlsForTests?: boolean;
+}
+interface ResolveComposioMcpSessionInput {
+    actor: McpActor;
+    config: ManagedConnectorConfig;
+    secret: ManagedConnectorSecret;
+}
+declare function resolveComposioMcpSession(options: ComposioManagedConnectorProviderOptions, input: ResolveComposioMcpSessionInput): Promise<ComposioMcpSession>;
+declare function createComposioManagedConnectorProvider(options?: ComposioManagedConnectorProviderOptions): ManagedConnectorProvider;
+declare function createComposioMcpTransport(options: ComposioManagedConnectorProviderOptions & {
+    secretResolver: {
+        resolveSecret(provider: string): Promise<ManagedConnectorSecret>;
+    };
+    configs: readonly ManagedConnectorConfig[];
+}): McpTransportClient;
+
+interface McpSdkEndpointResolverInput {
+    source: McpSource;
+}
+interface McpSdkEndpoint {
+    url: string | URL;
+    headers?: Record<string, string>;
+}
+interface McpSdkTransportOptions {
+    endpoint: McpSdkEndpoint | ((input: McpSdkEndpointResolverInput) => McpSdkEndpoint | Promise<McpSdkEndpoint>);
+    clientName?: string;
+    clientVersion?: string;
+}
+declare function createMcpSdkStreamableHttpTransport(options: McpSdkTransportOptions): McpTransportClient;
+
+declare function validateMcpSourceId(sourceId: string): string;
+declare function isActorOwnedMcpSource(actor: McpActor, source: McpSource | undefined): source is McpSource;
+declare function requireActorOwnedMcpSource(registry: McpSourceRegistry, actor: McpActor, sourceId: string): Promise<McpSource>;
+declare function assertMcpPublicPayloadSecretFree(value: unknown): void;
+declare function createMcpSourceStatusPayload(source: McpSource): McpSourceStatusPayload;
+
+interface CreateBoringMcpServerPluginOptions {
+    systemPrompt?: string;
+    registry?: McpSourceRegistry;
+    transport?: McpTransportClient;
+    resolveActor?: BoringMcpAgentToolActorResolver;
+    templates?: readonly McpProviderTemplate[];
+    maxReadonlyInputBytes?: number;
+    audit?: McpReadonlyCallAuditSink;
+    hardening?: McpProviderHardeningOptions;
+}
+declare function createBoringMcpServerPlugin(options?: CreateBoringMcpServerPluginOptions): {
+    id: string;
+    label: string;
+    systemPrompt: string;
+    agentTools: _hachej_boring_workspace.AgentTool[] | undefined;
+};
+declare const _default: {
+    id: string;
+    label: string;
+    systemPrompt: string;
+    agentTools: _hachej_boring_workspace.AgentTool[] | undefined;
+};
+
+export { BORING_MCP_AGENT_BRIDGE_TOOL_DEFINITIONS, BORING_MCP_AGENT_BRIDGE_TOOL_NAMES, type BoringMcpAgentBridgeContext, type BoringMcpAgentBridgeRegistry, type BoringMcpAgentBridgeTool, type BoringMcpAgentBridgeToolDefinition, type BoringMcpAgentBridgeToolName, type BoringMcpAgentToolActorResolver, type BoringMcpLaunchGateInput, type BoringMcpLaunchGateIssue, type BoringMcpLaunchGateIssueCode, type BoringMcpLaunchGateResult, type BoringMcpReadonlyCallOptions, type BoringMcpReadonlyCaller, type BoringMcpSourceHandlers, type BoringMcpSourceHandlersOptions, type BoringMcpToolCatalog, type BoringMcpToolCatalogOptions, type ComposioManagedConnectorProviderOptions, type ComposioMcpSession, type CreateBoringMcpAgentToolsOptions, type CreateBoringMcpServerPluginOptions, InMemoryMcpRateBudgetGate, type InMemoryMcpRateBudgetGateOptions, InMemoryMcpToolCatalogCache, type ManagedConnectorAcceptedGap, type ManagedConnectorAdapter, type ManagedConnectorAdapterOptions, type ManagedConnectorConfig, type ManagedConnectorPreflightCheck, type ManagedConnectorPreflightEvidence, type ManagedConnectorPreflightResult, type ManagedConnectorProbeResponse, type ManagedConnectorProvider, type ManagedConnectorRiskStatus, type ManagedConnectorSecret, type ManagedConnectorSecretResolver, type ManagedConnectorSecretStorage, type ManagedConnectorSourceRegistry, type ManagedConnectorStartInput, type ManagedConnectorStartResponse, type ManagedConnectorStartResult, type ManagedConnectorStatusResponse, type ManagedConnectorVendorRiskEvidence, McpActor, McpConnectorRef, McpDiscoveredResource, McpDiscoveredTool, McpDoctorResult, McpErrorCode, McpProbeResult, type McpProviderCallContext, type McpProviderHardeningOptions, McpProviderId, type McpProviderOperation, type McpProviderRateBudgetGate, McpProviderTemplate, McpReadonlyCallAuditEvent, type McpReadonlyCallAuditSink, McpReadonlyCallInput, McpReadonlyCallResult, type McpSdkEndpoint, type McpSdkEndpointResolverInput, type McpSdkTransportOptions, McpSource, McpSourceDto, McpSourceRegistry, McpSourceStatus, McpSourceStatusPayload, type McpToolCatalogCache, McpToolCatalogEntry, type McpToolDescribeInput, McpToolDescribeResult, McpToolSearchResult, type McpToolsSearchInput, McpTransportClient, type ResolveComposioMcpSessionInput, assertManagedConnectorPreflight, assertMcpPublicPayloadSecretFree, createBoringMcpAgentBridgeRegistry, createBoringMcpAgentTools, createBoringMcpReadonlyCaller, createBoringMcpServerPlugin, createBoringMcpSourceHandlers, createBoringMcpToolCatalog, createComposioManagedConnectorProvider, createComposioMcpTransport, createHardenedMcpTransport, createLegacyManagedConnectorSourceId, createManagedConnectorAdapter, createManagedConnectorSourceId, createMcpSchemaHash, createMcpSdkStreamableHttpTransport, createMcpSourceStatusPayload, _default as default, evaluateBoringMcpLaunchGate, isActorOwnedMcpSource, listBoringMcpAgentBridgeTools, normalizeMcpCatalogTool, requireActorOwnedMcpSource, resolveComposioMcpSession, validateManagedConnectorPreflight, validateMcpSourceId, verifyMcpDisconnectResult };