@hachej/boring-mcp 0.0.0

package/dist/shared/index.d.ts

@@ -0,0 +1,213 @@
+declare const BORING_MCP_PLUGIN_ID = "boring-mcp";
+declare const BORING_MCP_SOURCES_TAB_PANEL_ID = "boring-mcp.sources.tab";
+declare const BORING_MCP_SOURCES_PANEL_ID = "boring-mcp.sources.panel";
+declare const MCP_ERROR_CODES: {
+    readonly SOURCE_NOT_FOUND: "MCP_SOURCE_NOT_FOUND";
+    readonly SOURCE_FORBIDDEN: "MCP_SOURCE_FORBIDDEN";
+    readonly SOURCE_UNAVAILABLE: "MCP_SOURCE_UNAVAILABLE";
+    readonly PROVIDER_CONFIG_INVALID: "MCP_PROVIDER_CONFIG_INVALID";
+    readonly PROVIDER_TIMEOUT: "MCP_PROVIDER_TIMEOUT";
+    readonly PROVIDER_ERROR: "MCP_PROVIDER_ERROR";
+    readonly TOOL_NOT_FOUND: "MCP_TOOL_NOT_FOUND";
+    readonly TOOL_NOT_ALLOWED: "MCP_TOOL_NOT_ALLOWED";
+    readonly PROVIDER_TOOL_DRIFT: "MCP_PROVIDER_TOOL_DRIFT";
+    readonly RESOURCE_LIMIT_EXCEEDED: "MCP_RESOURCE_LIMIT_EXCEEDED";
+    readonly SECRET_LEAK_GUARD: "MCP_SECRET_LEAK_GUARD";
+    readonly INPUT_INVALID: "MCP_INPUT_INVALID";
+    readonly RESOURCE_URI_INVALID: "MCP_RESOURCE_URI_INVALID";
+};
+type McpErrorCode = (typeof MCP_ERROR_CODES)[keyof typeof MCP_ERROR_CODES];
+type McpProviderId = "notion" | "airtable" | (string & {});
+type McpTransport = "streamable-http";
+type McpSourceStatus = "connected" | "expired" | "revoked" | "error" | "unconfigured";
+type McpToolRisk = "read" | "write" | "admin" | "unknown";
+type McpCredentialProvider = "provider-managed" | "composio-managed" | "app-managed" | "user-managed" | (string & {});
+type McpSourceOwnerKind = "user" | "company_context" | "team_context" | "project_context";
+interface McpActor {
+    userId: string;
+    workspaceId: string;
+    isAdmin?: boolean;
+}
+interface McpProviderTemplate {
+    id: McpProviderId;
+    displayName: string;
+    endpoint?: string;
+    transport?: McpTransport;
+    readOnlyDefault: boolean;
+    allowedTools: string[];
+    deniedTools: string[];
+    allowedResourceUriPrefixes?: string[];
+}
+interface McpConnectorRef {
+    provider: McpProviderId;
+    toolkitId?: string;
+    externalSourceId?: string;
+    connectedAccountId?: string;
+    sessionId?: string;
+}
+interface McpSource {
+    id: string;
+    workspaceId: string;
+    userId: string;
+    provider: McpProviderId;
+    displayName: string;
+    status: McpSourceStatus;
+    ownerKind: McpSourceOwnerKind;
+    credentialProvider: McpCredentialProvider;
+    scopes?: string[];
+    providerAccountLabel?: string;
+    connectorRef?: McpConnectorRef;
+    lastVerifiedAt?: string;
+    createdAt?: string;
+    updatedAt?: string;
+}
+type McpSourceDto = Pick<McpSource, "id" | "provider" | "displayName" | "status" | "ownerKind" | "credentialProvider" | "scopes" | "providerAccountLabel" | "lastVerifiedAt" | "createdAt" | "updatedAt">;
+interface McpDiscoveredTool {
+    name: string;
+    description?: string;
+    inputSchema?: unknown;
+}
+interface McpDiscoveredResource {
+    uri: string;
+    name?: string;
+    description?: string;
+    mimeType?: string;
+}
+interface McpToolDecision {
+    allowed: boolean;
+    risk: McpToolRisk;
+    reason: string;
+}
+interface McpProbeResult {
+    sourceId: string;
+    provider: McpProviderId;
+    tools: Array<McpDiscoveredTool & {
+        decision: McpToolDecision;
+    }>;
+    resources: McpDiscoveredResource[];
+}
+interface McpDoctorIssue {
+    level: "error" | "warning";
+    code: McpErrorCode;
+    message: string;
+}
+interface McpDoctorResult {
+    ok: boolean;
+    sourceId: string;
+    issues: McpDoctorIssue[];
+}
+interface McpToolCatalogEntry {
+    sourceId: string;
+    provider: McpProviderId;
+    toolName: string;
+    displayName: string;
+    summary: string;
+    description?: string;
+    inputSchema: unknown;
+    outputSchema?: unknown;
+    risk: McpToolRisk;
+    enabled: boolean;
+    blockedReasons: string[];
+    schemaHash: string;
+    nativeRef: {
+        provider: string;
+        toolkit?: string;
+        action: string;
+    };
+}
+type NormalizedMcpTool = McpToolCatalogEntry;
+interface McpToolSearchResult {
+    tools: McpToolCatalogEntry[];
+}
+interface McpToolDescribeResult {
+    tool: McpToolCatalogEntry;
+    schemaDrifted: boolean;
+}
+interface McpReadonlyCallInput {
+    sourceId: string;
+    toolName: string;
+    input?: unknown;
+    expectedSchemaHash?: string;
+}
+interface McpReadonlyCallResult {
+    content: unknown;
+}
+interface McpReadonlyCallAuditEvent {
+    operation: "mcp_readonly_call";
+    outcome: "success" | "blocked" | "failure";
+    workspaceId: string;
+    userId: string;
+    sourceId: string;
+    toolName: string;
+    expectedSchemaHash?: string;
+    code?: string;
+}
+interface McpToolCallResult {
+    content: unknown;
+}
+interface McpSourceStore {
+    listSources(actor: McpActor): Promise<McpSource[]>;
+    getSource(sourceId: string): Promise<McpSource | undefined>;
+}
+interface McpSourceRegistry extends McpSourceStore {
+    disconnectSource?(actor: McpActor, sourceId: string): Promise<McpSource | undefined>;
+}
+interface McpSourceStatusPayload {
+    source: McpSourceDto;
+    connectable: boolean;
+    canProbe: boolean;
+    canDisconnect: boolean;
+}
+declare function toMcpSourceDto(source: McpSource): McpSourceDto;
+interface McpTransportListToolsOptions {
+    /** Force bypassing provider-level metadata caches, not just local catalog caches. */
+    forceProviderRefresh?: boolean;
+}
+interface McpTransportClient {
+    listTools(source: McpSource, options?: McpTransportListToolsOptions): Promise<McpDiscoveredTool[]>;
+    listResources(source: McpSource): Promise<McpDiscoveredResource[]>;
+    readResource(source: McpSource, uri: string): Promise<unknown>;
+    callTool(source: McpSource, toolName: string, input: unknown): Promise<McpToolCallResult>;
+}
+interface McpSourceAccessPolicy {
+    canAccessSource(actor: McpActor, source: McpSource): boolean;
+}
+declare class McpError extends Error {
+    readonly code: McpErrorCode;
+    readonly details: unknown;
+    constructor(code: McpErrorCode, message: string, details?: unknown);
+}
+declare const NOTION_MCP_TEMPLATE: McpProviderTemplate;
+declare const AIRTABLE_MCP_TEMPLATE: McpProviderTemplate;
+declare const DEFAULT_MCP_PROVIDER_TEMPLATES: readonly [McpProviderTemplate, McpProviderTemplate];
+declare function getMcpProviderTemplate(provider: string, templates?: readonly McpProviderTemplate[]): McpProviderTemplate | undefined;
+declare const MCP_TOOL_NAME_PATTERN: RegExp;
+declare function validateMcpToolName(toolName: string): void;
+declare function classifyMcpTool(template: McpProviderTemplate, toolName: string): McpToolDecision;
+declare function classifyMcpTools(template: McpProviderTemplate, tools: readonly McpDiscoveredTool[]): Array<McpDiscoveredTool & {
+    decision: McpToolDecision;
+}>;
+declare function assertMcpToolAllowed(template: McpProviderTemplate, toolName: string): void;
+declare function redactMcpSecrets(value: unknown): unknown;
+declare function containsMcpSecret(value: unknown): boolean;
+declare function containsMcpCanary(value: unknown, canaries: readonly string[]): boolean;
+declare function containsMcpSecretOrCanary(value: unknown, canaries: readonly string[]): boolean;
+declare function doctorMcpSource(source: McpSource, templates?: readonly McpProviderTemplate[]): McpDoctorResult;
+declare class McpAccessFacade {
+    private readonly params;
+    constructor(params: {
+        store: McpSourceStore;
+        transport: McpTransportClient;
+        templates?: readonly McpProviderTemplate[];
+        maxInputBytes?: number;
+        accessPolicy?: McpSourceAccessPolicy;
+    });
+    listSources(actor: McpActor): Promise<McpSource[]>;
+    probeSource(actor: McpActor, sourceId: string): Promise<McpProbeResult>;
+    private requireAccessibleSource;
+    private canAccessSource;
+    private requireConnectedSource;
+    private requireTemplate;
+}
+
+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, type McpActor, type McpConnectorRef, type McpCredentialProvider, type McpDiscoveredResource, type McpDiscoveredTool, type McpDoctorIssue, type McpDoctorResult, McpError, type McpErrorCode, type McpProbeResult, type McpProviderId, type McpProviderTemplate, type McpReadonlyCallAuditEvent, type McpReadonlyCallInput, type McpReadonlyCallResult, type McpSource, type McpSourceAccessPolicy, type McpSourceDto, type McpSourceOwnerKind, type McpSourceRegistry, type McpSourceStatus, type McpSourceStatusPayload, type McpSourceStore, type McpToolCallResult, type McpToolCatalogEntry, type McpToolDecision, type McpToolDescribeResult, type McpToolRisk, type McpToolSearchResult, type McpTransport, type McpTransportClient, type McpTransportListToolsOptions, NOTION_MCP_TEMPLATE, type NormalizedMcpTool, assertMcpToolAllowed, classifyMcpTool, classifyMcpTools, containsMcpCanary, containsMcpSecret, containsMcpSecretOrCanary, doctorMcpSource, getMcpProviderTemplate, redactMcpSecrets, toMcpSourceDto, validateMcpToolName };

package/dist/shared/index.js

@@ -0,0 +1,194 @@
+// 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((tool) => ({ ...tool, decision: classifyMcpTool(template, tool.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((issue) => issue.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;
+  }
+};
+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,
+  McpError,
+  NOTION_MCP_TEMPLATE,
+  assertMcpToolAllowed,
+  classifyMcpTool,
+  classifyMcpTools,
+  containsMcpCanary,
+  containsMcpSecret,
+  containsMcpSecretOrCanary,
+  doctorMcpSource,
+  getMcpProviderTemplate,
+  redactMcpSecrets,
+  toMcpSourceDto,
+  validateMcpToolName
+};

package/package.json

@@ -0,0 +1,78 @@
+{
+  "name": "@hachej/boring-mcp",
+  "version": "0.0.0",
+  "type": "module",
+  "private": false,
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "description": "Reusable boring-ui MCP plugin foundation: generic MCP UI, policy, redaction, and facade contracts.",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/hachej/boring-ui"
+  },
+  "homepage": "https://github.com/hachej/boring-ui",
+  "boring": {
+    "id": "boring-mcp",
+    "label": "MCP",
+    "front": "dist/front/index.js",
+    "server": "dist/server/index.js"
+  },
+  "pi": {
+    "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."
+  },
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/front/index.d.ts",
+      "import": "./dist/front/index.js"
+    },
+    "./front": {
+      "types": "./dist/front/index.d.ts",
+      "import": "./dist/front/index.js"
+    },
+    "./server": {
+      "types": "./dist/server/index.d.ts",
+      "import": "./dist/server/index.js"
+    },
+    "./shared": {
+      "types": "./dist/shared/index.d.ts",
+      "import": "./dist/shared/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "sideEffects": false,
+  "scripts": {
+    "build": "tsup",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run --no-file-parallelism",
+    "lint": "pnpm run typecheck",
+    "clean": "rm -rf dist .tsbuildinfo"
+  },
+  "peerDependencies": {
+    "@hachej/boring-workspace": "workspace:*",
+    "react": "^18.0.0 || ^19.0.0",
+    "react-dom": "^18.0.0 || ^19.0.0"
+  },
+  "devDependencies": {
+    "@hachej/boring-workspace": "workspace:*",
+    "@testing-library/jest-dom": "^6.9.1",
+    "@testing-library/react": "^16.3.0",
+    "@types/node": "^22.20.0",
+    "@types/react": "^19.2.17",
+    "@types/react-dom": "^19.0.0",
+    "@vitejs/plugin-react": "^4.0.0",
+    "jsdom": "^29.1.1",
+    "react": "^19.2.7",
+    "react-dom": "^19.2.7",
+    "tsup": "^8.4.0",
+    "typescript": "~6.0.3",
+    "vitest": "^4.1.9"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0"
+  }
+}