@payloadcms/plugin-mcp 4.0.0-internal.d28e9fb → 4.0.0-internal.d7d662c

package/src/mcp/sanitizeMCPConfig.ts

@@ -0,0 +1,282 @@
+import type {
+  CollectionConfig,
+  Config,
+  GlobalConfig,
+  SanitizedCollectionConfig,
+  SanitizedConfig,
+  SanitizedGlobalConfig,
+} from 'payload'
+
+import type {
+  CollectionMCPItem,
+  CollectionTool,
+  GlobalMCPItem,
+  GlobalTool,
+  MCPItem,
+  MCPPluginConfig,
+  SanitizedMCPPluginConfig,
+} from '../types.js'
+
+import { defaultAccess } from '../defaultAccess.js'
+import {
+  COLLECTION_AUTH_BUILTIN_ENTRIES,
+  COLLECTION_AUTH_BUILTINS,
+  COLLECTION_BUILTIN_ENTRIES,
+  COLLECTION_BUILTINS,
+  GLOBAL_BUILTIN_ENTRIES,
+  GLOBAL_BUILTINS,
+  TOOL_BUILTIN_ENTRIES,
+  TOOL_BUILTINS,
+} from './builtinTools.js'
+
+/**
+ * Converts the user-configured `MCPPluginConfig` into a `SanitizedMCPPluginConfig`:
+ *  - Flattens `tools` / `prompts` / `resources` / per-collection / per-global
+ *    tool maps into a single `items` array.
+ *  - Applies built-in tools for collections and globals, respecting opt-out user overrides.
+ *
+ * Called once during plugin init. After that, `plugins['@payloadcms/plugin-mcp']
+ * ?.options` holds the sanitized result
+ */
+export const sanitizeMCPConfig = ({
+  config,
+  pluginConfig,
+}: {
+  config: Config | SanitizedConfig
+  pluginConfig: MCPPluginConfig
+}): SanitizedMCPPluginConfig => {
+  const items: MCPItem[] = []
+
+  for (const collection of config.collections ?? []) {
+    items.push(...sanitizeCollectionConfig({ collection, pluginConfig }))
+  }
+
+  for (const global of config.globals ?? []) {
+    items.push(...sanitizeGlobalConfig({ global, pluginConfig }))
+  }
+
+  for (const [configKey, { mcpName, tool }] of TOOL_BUILTIN_ENTRIES) {
+    items.push({
+      type: 'tool',
+      configKey,
+      label: tool.annotations?.title ?? configKey,
+      mcpName,
+      tool: { ...tool, access: tool.access ?? defaultAccess },
+    })
+  }
+
+  for (const [configKey, tool] of Object.entries(pluginConfig.tools ?? {})) {
+    if (configKey in TOOL_BUILTINS) {
+      continue
+    }
+    items.push({
+      type: 'tool',
+      configKey,
+      label: tool.annotations?.title ?? configKey,
+      mcpName: configKey,
+      tool: { ...tool, access: tool.access ?? defaultAccess },
+    })
+  }
+
+  for (const [configKey, prompt] of Object.entries(pluginConfig.prompts ?? {})) {
+    items.push({
+      type: 'prompt',
+      configKey,
+      label: prompt.title ?? configKey,
+      mcpName: configKey,
+      prompt: { ...prompt, access: prompt.access ?? defaultAccess },
+    })
+  }
+
+  for (const [configKey, resource] of Object.entries(pluginConfig.resources ?? {})) {
+    items.push({
+      type: 'resource',
+      configKey,
+      label: resource.title ?? configKey,
+      mcpName: configKey,
+      resource: { ...resource, access: resource.access ?? defaultAccess },
+    })
+  }
+
+  return {
+    disabled: pluginConfig.disabled,
+    hooks: pluginConfig.hooks,
+    items,
+    mcp: pluginConfig.mcp,
+    oauth: pluginConfig.oauth,
+    overrideGetAuthorizedMCP: pluginConfig.overrideGetAuthorizedMCP,
+  }
+}
+
+const sanitizeCollectionConfig = ({
+  collection,
+  pluginConfig,
+}: {
+  collection: CollectionConfig | SanitizedCollectionConfig
+  pluginConfig: MCPPluginConfig
+}): CollectionMCPItem[] => {
+  const slug = collection.slug
+  const collectionPluginConfig = pluginConfig.collections?.[slug]
+  const items: CollectionMCPItem[] = []
+  /**
+   * Payload disables duplicate for auth collections by default unless the
+   * collection explicitly opts back in with `disableDuplicate: false`.
+   */
+  const isDuplicateDisabled =
+    collection.disableDuplicate === true ||
+    (Boolean(collection.auth) && collection.disableDuplicate !== false)
+
+  for (const [
+    toolKey,
+    { mcpName, requiresDuplicateEnabled, requiresUpload, requiresVersions, tool },
+  ] of COLLECTION_BUILTIN_ENTRIES) {
+    if (requiresVersions && !collection.versions) {
+      continue
+    }
+    if (requiresDuplicateEnabled && isDuplicateDisabled) {
+      continue
+    }
+    if (requiresUpload && !collection.upload) {
+      continue
+    }
+    const matchedConfigEntry = collectionPluginConfig?.tools?.[toolKey]
+    if (matchedConfigEntry === false) {
+      continue
+    }
+    const override = typeof matchedConfigEntry === 'object' ? matchedConfigEntry : undefined
+    const annotations = { ...tool.annotations, ...override?.annotations }
+    items.push({
+      type: 'collectionTool',
+      collectionSlug: slug,
+      configKey: toolKey,
+      label: annotations.title ?? toolKey,
+      mcpName,
+      tool: {
+        ...tool,
+        access: override?.access ?? tool.access ?? defaultAccess,
+        annotations,
+        description: override?.description ?? tool.description,
+        overrideResponse:
+          override?.overrideResponse ??
+          collectionPluginConfig?.overrideResponse ??
+          tool.overrideResponse,
+      },
+    })
+  }
+
+  if (collection.auth) {
+    for (const [authToolKey, { mcpName, tool }] of COLLECTION_AUTH_BUILTIN_ENTRIES) {
+      const matchedConfigEntry = collectionPluginConfig?.tools?.[authToolKey]
+      if (!matchedConfigEntry) {
+        continue
+      }
+      // `true` means "enable, no override"; only the object form carries fields.
+      const override = typeof matchedConfigEntry === 'object' ? matchedConfigEntry : undefined
+      const annotations = { ...tool.annotations, ...override?.annotations }
+      items.push({
+        type: 'collectionTool',
+        collectionSlug: slug,
+        configKey: authToolKey,
+        label: annotations.title ?? authToolKey,
+        mcpName,
+        tool: {
+          ...tool,
+          access: override?.access ?? tool.access ?? defaultAccess,
+          annotations,
+          description: override?.description ?? tool.description,
+          overrideResponse:
+            override?.overrideResponse ??
+            collectionPluginConfig?.overrideResponse ??
+            tool.overrideResponse,
+        },
+      })
+    }
+  }
+
+  // Cast: builtin keys are filtered out below, so the remaining values are
+  // always custom tools (`CollectionTool`) or undefined
+  const customEntries = Object.entries(collectionPluginConfig?.tools ?? {}) as Array<
+    [string, CollectionTool | undefined]
+  >
+  for (const [configKey, customTool] of customEntries) {
+    if (configKey in COLLECTION_BUILTINS || configKey in COLLECTION_AUTH_BUILTINS) {
+      continue
+    }
+    if (!customTool) {
+      continue
+    }
+    items.push({
+      type: 'collectionTool',
+      collectionSlug: slug,
+      configKey,
+      label: customTool.annotations?.title ?? configKey,
+      mcpName: configKey,
+      tool: { ...customTool, access: customTool.access ?? defaultAccess },
+    })
+  }
+
+  return items
+}
+
+const sanitizeGlobalConfig = ({
+  global,
+  pluginConfig,
+}: {
+  global: GlobalConfig | SanitizedGlobalConfig
+  pluginConfig: MCPPluginConfig
+}): GlobalMCPItem[] => {
+  const slug = global.slug
+  const globalPluginConfig = pluginConfig.globals?.[slug]
+  const items: GlobalMCPItem[] = []
+
+  for (const [toolKey, { mcpName, requiresVersions, tool }] of GLOBAL_BUILTIN_ENTRIES) {
+    if (requiresVersions && !global.versions) {
+      continue
+    }
+    const matchedConfigEntry = globalPluginConfig?.tools?.[toolKey]
+    if (matchedConfigEntry === false) {
+      continue
+    }
+    const override = typeof matchedConfigEntry === 'object' ? matchedConfigEntry : undefined
+    const annotations = { ...tool.annotations, ...override?.annotations }
+    items.push({
+      type: 'globalTool',
+      configKey: toolKey,
+      globalSlug: slug,
+      label: annotations.title ?? toolKey,
+      mcpName,
+      tool: {
+        ...tool,
+        access: override?.access ?? tool.access ?? defaultAccess,
+        annotations,
+        description: override?.description ?? tool.description,
+        overrideResponse:
+          override?.overrideResponse ??
+          globalPluginConfig?.overrideResponse ??
+          tool.overrideResponse,
+      },
+    })
+  }
+
+  const customEntries = Object.entries(globalPluginConfig?.tools ?? {}) as Array<
+    [string, GlobalTool | undefined]
+  >
+  for (const [configKey, customTool] of customEntries) {
+    if (configKey in GLOBAL_BUILTINS) {
+      continue
+    }
+    if (!customTool) {
+      continue
+    }
+    items.push({
+      type: 'globalTool',
+      configKey,
+      globalSlug: slug,
+      label: customTool.annotations?.title ?? configKey,
+      mcpName: configKey,
+      tool: { ...customTool, access: customTool.access ?? defaultAccess },
+    })
+  }
+
+  return items
+}

package/src/stdio.ts

@@ -0,0 +1,131 @@
+import type { Config, Plugin, SanitizedConfig } from 'payload'
+
+/* eslint-disable no-console */
+import { serveStdio } from '@modelcontextprotocol/server/stdio'
+import { fileURLToPath, pathToFileURL } from 'node:url'
+import { createPayloadRequest, getPayload } from 'payload'
+import { findConfig, loadEnv } from 'payload/node'
+
+import type { SanitizedMCPPluginConfig } from './types.js'
+
+import { getAuthorizedMCP } from './endpoint/access.js'
+import { buildMcpServer } from './mcp/buildMcpServer.js'
+import { sanitizeMCPConfig } from './mcp/sanitizeMCPConfig.js'
+import { getPluginConfig } from './utils/getPluginConfig.js'
+import { resolveProjectRoot } from './utils/resolveProjectRoot.js'
+
+/**
+ * Starts Payload's MCP server over stdin and stdout.
+ *
+ * Set `PAYLOAD_MCP_AUTHORIZATION` to authenticate. In development,
+ * `PAYLOAD_MCP_OVERRIDE_ACCESS=true` skips access checks.
+ */
+export const runMcpStdio = async (): Promise<void> => {
+  // MCP clients may start this command from another folder. Move to the Payload
+  // project so findConfig() can find the config.
+  const projectRoot = resolveProjectRoot(fileURLToPath(import.meta.url))
+  if (projectRoot) {
+    process.chdir(projectRoot)
+  }
+
+  loadEnv()
+  const configPath = findConfig()
+  const configModule = await import(pathToFileURL(configPath).toString())
+  const config = (await (configModule.default ?? configModule)) as SanitizedConfig
+
+  /**
+   * stdout is only for MCP messages. The spec says the server must not write
+   * logs there and may write them to stderr instead.
+   *
+   * The 2.0 client library recovers from stray stdout logs, but that behavior is not
+   * guaranteed. Move Payload logs to stderr so Payload does not add invalid data
+   * to stdout. Keep options from configurable loggers. Replace pre-built loggers
+   * because their output cannot be redirected.
+   *
+   * @see https://modelcontextprotocol.io/specification/2025-11-25/basic/transports#stdio
+   */
+  const loggerConfig: { logger?: Config['logger'] } = config
+  if (
+    loggerConfig.logger &&
+    typeof loggerConfig.logger === 'object' &&
+    'options' in loggerConfig.logger
+  ) {
+    loggerConfig.logger.destination = process.stderr
+  } else {
+    loggerConfig.logger = { destination: process.stderr, options: {} }
+  }
+
+  const payload = await getPayload({ config, cron: false, disableOnInit: true })
+
+  let pluginConfig: SanitizedMCPPluginConfig
+  try {
+    pluginConfig = getPluginConfig({ config: payload.config })
+  } catch {
+    // The command also works when mcpPlugin() is not in the Payload config.
+    pluginConfig = sanitizeMCPConfig({ config: payload.config, pluginConfig: {} })
+
+    const fallbackPlugin: Plugin = (config) => config
+    Object.assign(fallbackPlugin, {
+      slug: '@payloadcms/plugin-mcp',
+      sanitizedOptions: pluginConfig,
+    })
+    payload.config.plugins ??= []
+    payload.config.plugins.push(fallbackPlugin)
+  }
+
+  const overrideAccessEnv = process.env.PAYLOAD_MCP_OVERRIDE_ACCESS
+  let overrideAccess = false
+
+  if (overrideAccessEnv === 'true') {
+    overrideAccess = true
+  } else if (overrideAccessEnv && overrideAccessEnv !== 'false') {
+    throw new Error('PAYLOAD_MCP_OVERRIDE_ACCESS must be "true" or "false".')
+  }
+
+  if (overrideAccess && process.env.NODE_ENV !== 'development') {
+    throw new Error('PAYLOAD_MCP_OVERRIDE_ACCESS is only available in development.')
+  }
+
+  const headers = new Headers()
+  if (process.env.PAYLOAD_MCP_AUTHORIZATION) {
+    headers.set('Authorization', process.env.PAYLOAD_MCP_AUTHORIZATION)
+  }
+
+  const req = await createPayloadRequest({ payload, req: { headers } })
+  req.payloadAPI = 'MCP' as const
+  const authorizedMCP = await getAuthorizedMCP({ overrideAccess, req })
+
+  const stdioServer = serveStdio(() => buildMcpServer({ authorizedMCP, pluginConfig, req }), {
+    onerror: (err) => {
+      // MCP messages use stdout, so write SDK errors to stderr.
+      console.error('[payload-mcp] error serving MCP over stdio:', err)
+    },
+  })
+
+  // Close the MCP server and Payload when the client disconnects or the process stops.
+  let isShuttingDown = false
+  const shutdown = async () => {
+    if (isShuttingDown) {
+      return
+    }
+    isShuttingDown = true
+
+    try {
+      await stdioServer.close()
+    } catch (err) {
+      console.error('[payload-mcp] error closing server:', err)
+    }
+
+    try {
+      await payload.destroy()
+    } catch (err) {
+      console.error('[payload-mcp] error destroying payload:', err)
+    }
+
+    process.exit(0)
+  }
+
+  process.once('SIGINT', () => void shutdown())
+  process.once('SIGTERM', () => void shutdown())
+  process.stdin.once('close', () => void shutdown())
+}