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

package/src/mcp/builtin/globals/findVersionByIDTool.ts

@@ -0,0 +1,64 @@
+import { findGlobalVersionByIDInputSchema } from 'payload'
+
+import { defaultAccess } from '../../../defaultAccess.js'
+import { defineGlobalTool } from '../../../defineTool.js'
+import { getLogger } from '../../../utils/getLogger.js'
+
+const DEFAULT_DESCRIPTION =
+  'Find a specific global version in any version-enabled global by passing the global slug and version ID.'
+
+export const findGlobalVersionByIDTool = defineGlobalTool({
+  access: (args) =>
+    defaultAccess(args) && Boolean(args.permissions?.globals?.[args.slug]?.readVersions),
+  annotations: {
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false,
+    readOnlyHint: true,
+    title: 'Find Global Version By ID',
+  },
+  description: DEFAULT_DESCRIPTION,
+  input: findGlobalVersionByIDInputSchema,
+}).handler(async ({ slug, authorizedMCP, input, req }) => {
+  const payload = req.payload
+  const logger = getLogger({ payload })
+  const { id, depth, fallbackLocale, locale, populate, select } = input
+
+  logger.info(`Finding version for global: ${slug} with ID: ${id}`)
+
+  try {
+    const result = await payload.findGlobalVersionByID({
+      id,
+      slug,
+      depth,
+      overrideAccess: authorizedMCP.overrideAccess,
+      req,
+      ...(fallbackLocale !== undefined ? { fallbackLocale } : {}),
+      ...(locale ? { locale } : {}),
+      ...(populate ? { populate } : {}),
+      ...(select ? { select } : {}),
+    })
+
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `Version "${id}" from global "${slug}":\n\`\`\`json\n${JSON.stringify(result)}\n\`\`\``,
+        },
+      ],
+      doc: result as unknown as Record<string, unknown>,
+    }
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : 'Unknown error'
+    logger.error(`Error finding version ${id} for global ${slug}: ${errorMessage}`)
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `❌ **Error finding version "${id}" for global "${slug}":** ${errorMessage}`,
+        },
+      ],
+      isError: true,
+    }
+  }
+})

package/src/mcp/builtin/globals/findVersionsTool.ts

@@ -0,0 +1,69 @@
+import { findGlobalVersionsInputSchema } from 'payload'
+
+import { defaultAccess } from '../../../defaultAccess.js'
+import { defineGlobalTool } from '../../../defineTool.js'
+import { getLogger } from '../../../utils/getLogger.js'
+
+const DEFAULT_DESCRIPTION =
+  'Find global versions in any version-enabled global by passing the global slug and optional where clause.'
+
+export const findGlobalVersionsTool = defineGlobalTool({
+  access: (args) =>
+    defaultAccess(args) && Boolean(args.permissions?.globals?.[args.slug]?.readVersions),
+  annotations: {
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false,
+    readOnlyHint: true,
+    title: 'Find Global Versions',
+  },
+  description: DEFAULT_DESCRIPTION,
+  input: findGlobalVersionsInputSchema,
+}).handler(async ({ slug, authorizedMCP, input, req }) => {
+  const payload = req.payload
+  const logger = getLogger({ payload })
+  const { depth, fallbackLocale, limit, locale, page, pagination, populate, select, sort, where } =
+    input
+
+  logger.info(`Finding versions for global: ${slug}, limit: ${limit}, page: ${page}`)
+
+  try {
+    const result = await payload.findGlobalVersions({
+      slug,
+      depth,
+      limit,
+      overrideAccess: authorizedMCP.overrideAccess,
+      page,
+      req,
+      ...(fallbackLocale !== undefined ? { fallbackLocale } : {}),
+      ...(locale ? { locale } : {}),
+      ...(pagination !== undefined ? { pagination } : {}),
+      ...(populate ? { populate } : {}),
+      ...(select ? { select } : {}),
+      ...(sort ? { sort } : {}),
+      ...(where ? { where } : {}),
+    })
+
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `Versions for global "${slug}":\n\`\`\`json\n${JSON.stringify(result)}\n\`\`\``,
+        },
+      ],
+      doc: result as unknown as Record<string, unknown>,
+    }
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : 'Unknown error'
+    logger.error(`Error finding versions for global ${slug}: ${errorMessage}`)
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `❌ **Error finding versions for global "${slug}":** ${errorMessage}`,
+        },
+      ],
+      isError: true,
+    }
+  }
+})

package/src/mcp/builtin/globals/getGlobalSchemaTool.ts

@@ -0,0 +1,73 @@
+import { getAccessResults, getGlobalInputSchema, getGlobalSchemaInputSchema } from 'payload'
+import { getLLMInstructions } from 'payload/internal'
+
+import { defaultAccess } from '../../../defaultAccess.js'
+import { defineGlobalTool } from '../../../defineTool.js'
+
+export const getGlobalSchemaTool = defineGlobalTool({
+  access: (args) => {
+    const permissions = args.permissions?.globals?.[args.slug]
+
+    return defaultAccess(args) && Boolean(permissions?.update)
+  },
+  annotations: {
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false,
+    readOnlyHint: true,
+    title: 'Get Global Schema',
+  },
+  description: 'Get the input schema and LLM instructions before updating a global.',
+  input: getGlobalSchemaInputSchema,
+}).handler(async ({ slug, authorizedMCP, req }) => {
+  const permissions = authorizedMCP.overrideAccess
+    ? null
+    : (await getAccessResults({ req })).globals?.[slug]
+
+  if (!authorizedMCP.overrideAccess && !permissions?.update) {
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `Error: MCP access to "getGlobalSchema" is not enabled for global "${slug}"`,
+        },
+      ],
+      isError: true,
+    }
+  }
+
+  const inputSchema = getGlobalInputSchema({
+    globalSlug: slug,
+    req,
+    ...(permissions ? { permissions } : {}),
+  })
+
+  if (!inputSchema) {
+    return {
+      content: [{ type: 'text', text: `Error: Global "${slug}" not found` }],
+      isError: true,
+    }
+  }
+
+  const instructions = await getLLMInstructions({
+    slug,
+    type: 'global',
+    overrideAccess: authorizedMCP.overrideAccess,
+    req,
+  })
+
+  return {
+    content: [
+      {
+        type: 'text',
+        text: `Schema for global "${slug}":\n\`\`\`json\n${JSON.stringify(inputSchema)}\n\`\`\``,
+      },
+      ...(instructions ? [{ type: 'text' as const, text: instructions }] : []),
+    ],
+    structuredContent: {
+      slug,
+      schema: inputSchema,
+      ...(instructions ? { instructions } : {}),
+    },
+  }
+})

package/src/mcp/builtin/globals/restoreVersionTool.ts

@@ -0,0 +1,68 @@
+import { restoreGlobalVersionInputSchema } from 'payload'
+
+import { defaultAccess } from '../../../defaultAccess.js'
+import { defineGlobalTool } from '../../../defineTool.js'
+import { getLogger } from '../../../utils/getLogger.js'
+
+const DEFAULT_DESCRIPTION =
+  'Restore a global from a previous version in any version-enabled global.'
+
+export const restoreGlobalVersionTool = defineGlobalTool({
+  access: (args) => defaultAccess(args) && Boolean(args.permissions?.globals?.[args.slug]?.update),
+  annotations: {
+    destructiveHint: true,
+    idempotentHint: false,
+    openWorldHint: false,
+    readOnlyHint: false,
+    title: 'Restore Global Version',
+  },
+  description: DEFAULT_DESCRIPTION,
+  input: restoreGlobalVersionInputSchema,
+}).handler(async ({ slug, authorizedMCP, input, req }) => {
+  const payload = req.payload
+  const logger = getLogger({ payload })
+  const { id, depth, fallbackLocale, locale, populate, select } = input
+
+  logger.info(`Restoring version for global: ${slug} with ID: ${id}`)
+
+  try {
+    const result = await payload.restoreGlobalVersion({
+      id: String(id),
+      slug,
+      depth,
+      overrideAccess: authorizedMCP.overrideAccess,
+      req,
+      ...(fallbackLocale !== undefined ? { fallbackLocale } : {}),
+      ...(locale ? { locale } : {}),
+      ...(populate ? { populate } : {}),
+      ...(select ? { select } : {}),
+    })
+    const resultObject = result as Record<string, unknown>
+    const restoredGlobal =
+      resultObject.version && typeof resultObject.version === 'object'
+        ? (resultObject.version as Record<string, unknown>)
+        : resultObject
+
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `Version "${id}" restored successfully for global "${slug}"!\nRestored global:\n\`\`\`json\n${JSON.stringify(restoredGlobal)}\n\`\`\``,
+        },
+      ],
+      doc: restoredGlobal,
+    }
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : 'Unknown error'
+    logger.error(`Error restoring version ${id} for global ${slug}: ${errorMessage}`)
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `❌ **Error restoring version "${id}" for global "${slug}":** ${errorMessage}`,
+        },
+      ],
+      isError: true,
+    }
+  }
+})

package/src/mcp/builtin/globals/updateTool.ts

@@ -0,0 +1,92 @@
+import {
+  getGlobalVirtualFieldNames,
+  stripVirtualFields,
+  transformPointDataToPayload,
+  updateGlobalInputSchema,
+  validateGlobalData,
+} from 'payload'
+
+import { defaultAccess } from '../../../defaultAccess.js'
+import { defineGlobalTool } from '../../../defineTool.js'
+import { getLogger } from '../../../utils/getLogger.js'
+import { formatEntityError } from '../formatEntityError.js'
+
+const DEFAULT_DESCRIPTION = 'Update any Payload global by passing the global slug and data.'
+
+export const updateGlobalTool = defineGlobalTool({
+  access: (args) => defaultAccess(args) && Boolean(args.permissions?.globals?.[args.slug]?.update),
+  annotations: {
+    destructiveHint: true,
+    idempotentHint: false,
+    openWorldHint: false,
+    readOnlyHint: false,
+    title: 'Update Global',
+  },
+  description: DEFAULT_DESCRIPTION,
+  input: updateGlobalInputSchema,
+}).handler(async ({ slug, authorizedMCP, input, req }) => {
+  const payload = req.payload
+  const logger = getLogger({ payload })
+
+  const {
+    data,
+    depth,
+    draft,
+    fallbackLocale,
+    locale,
+    overrideLock,
+    populate,
+    publishAllLocales,
+    select,
+    unpublishAllLocales,
+  } = input
+
+  logger.info(`Updating global: ${slug}, draft: ${draft}${locale ? `, locale: ${locale}` : ''}`)
+
+  try {
+    const virtualFieldNames = getGlobalVirtualFieldNames(payload.config, slug)
+    const inputData = stripVirtualFields(data, virtualFieldNames)
+    validateGlobalData({ slug, data: inputData, req })
+
+    const parsedData = transformPointDataToPayload(inputData)
+
+    const updateOptions: Parameters<typeof payload.updateGlobal>[0] = {
+      slug,
+      data: parsedData,
+      depth,
+      draft,
+      overrideAccess: authorizedMCP.overrideAccess,
+      overrideLock,
+      populate,
+      publishAllLocales,
+      req,
+      unpublishAllLocales,
+    }
+
+    if (locale) {
+      updateOptions.locale = locale
+    }
+    if (fallbackLocale !== undefined) {
+      updateOptions.fallbackLocale = fallbackLocale
+    }
+    if (select) {
+      updateOptions.select = select
+    }
+
+    const result = await payload.updateGlobal(updateOptions)
+
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `Global "${slug}" updated successfully!\n\`\`\`json\n${JSON.stringify(result)}\n\`\`\``,
+        },
+      ],
+      doc: result,
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : 'Unknown error'
+    logger.error(`Error updating global ${slug}: ${message}`)
+    return formatEntityError({ slug, action: 'updating', entity: 'global', error, req })
+  }
+})

package/src/mcp/builtinTools.ts

@@ -0,0 +1,161 @@
+import type { CollectionTool, GlobalTool, Tool } from '../types.js'
+
+import {
+  authCollectionTool,
+  forgotPasswordCollectionTool,
+  loginCollectionTool,
+  resetPasswordCollectionTool,
+  unlockCollectionTool,
+  verifyCollectionTool,
+} from './builtin/collections/authTools.js'
+import { countDocumentsTool } from './builtin/collections/countTool.js'
+import { countVersionsTool } from './builtin/collections/countVersionsTool.js'
+import { createDocumentsTool } from './builtin/collections/createTool.js'
+import { deleteDocumentsTool } from './builtin/collections/deleteTool.js'
+import { duplicateDocumentTool } from './builtin/collections/duplicateTool.js'
+import { findDistinctTool } from './builtin/collections/findDistinctTool.js'
+import { findDocumentsTool } from './builtin/collections/findTool.js'
+import { findVersionByIDTool } from './builtin/collections/findVersionByIDTool.js'
+import { findVersionsTool } from './builtin/collections/findVersionsTool.js'
+import { getCollectionSchemaTool } from './builtin/collections/getCollectionSchemaTool.js'
+import { restoreVersionTool } from './builtin/collections/restoreVersionTool.js'
+import { updateDocumentTool } from './builtin/collections/updateTool.js'
+import { getUploadInstructionsTool } from './builtin/collections/uploadInstructionsTool.js'
+import { getConfigInfoTool } from './builtin/getConfigInfoTool.js'
+import { countGlobalVersionsTool } from './builtin/globals/countVersionsTool.js'
+import { findGlobalTool } from './builtin/globals/findTool.js'
+import { findGlobalVersionByIDTool } from './builtin/globals/findVersionByIDTool.js'
+import { findGlobalVersionsTool } from './builtin/globals/findVersionsTool.js'
+import { getGlobalSchemaTool } from './builtin/globals/getGlobalSchemaTool.js'
+import { restoreGlobalVersionTool } from './builtin/globals/restoreVersionTool.js'
+import { updateGlobalTool } from './builtin/globals/updateTool.js'
+
+type CollectionBuiltin = {
+  mcpName: string
+  requiresDuplicateEnabled?: boolean
+  requiresUpload?: boolean
+  requiresVersions?: boolean
+  tool: CollectionTool
+}
+
+type GlobalBuiltin = {
+  mcpName: string
+  requiresVersions?: boolean
+  tool: GlobalTool
+}
+
+export const TOOL_BUILTINS = {
+  getConfigInfo: { mcpName: 'getConfigInfo', tool: getConfigInfoTool },
+} satisfies Record<string, { mcpName: string; tool: Tool }>
+
+/**
+ * The static built-in collection CRUD tools. Keys here are the source of truth
+ * for `MCPCollectionBuiltinName` — adding/removing an entry updates the type
+ * automatically.
+ */
+export const COLLECTION_BUILTINS = {
+  count: { mcpName: 'countDocuments', tool: countDocumentsTool },
+  countVersions: { mcpName: 'countVersions', requiresVersions: true, tool: countVersionsTool },
+  create: { mcpName: 'createDocuments', tool: createDocumentsTool },
+  delete: { mcpName: 'deleteDocuments', tool: deleteDocumentsTool },
+  duplicate: {
+    mcpName: 'duplicateDocument',
+    requiresDuplicateEnabled: true,
+    tool: duplicateDocumentTool,
+  },
+  find: { mcpName: 'findDocuments', tool: findDocumentsTool },
+  findDistinct: { mcpName: 'findDistinct', tool: findDistinctTool },
+  findVersionByID: {
+    mcpName: 'findVersionByID',
+    requiresVersions: true,
+    tool: findVersionByIDTool,
+  },
+  findVersions: { mcpName: 'findVersions', requiresVersions: true, tool: findVersionsTool },
+  getCollectionSchema: { mcpName: 'getCollectionSchema', tool: getCollectionSchemaTool },
+  getUploadInstructions: {
+    mcpName: 'getUploadInstructions',
+    requiresUpload: true,
+    tool: getUploadInstructionsTool,
+  },
+  restoreVersion: { mcpName: 'restoreVersion', requiresVersions: true, tool: restoreVersionTool },
+  update: { mcpName: 'updateDocument', tool: updateDocumentTool },
+} satisfies Record<string, CollectionBuiltin>
+
+/**
+ * The static auth tools surfaced under auth-enabled collections. Keys are the
+ * source of truth for `MCPCollectionAuthToolName`.
+ */
+export const COLLECTION_AUTH_BUILTINS = {
+  auth: { mcpName: 'auth', tool: authCollectionTool },
+  forgotPassword: {
+    mcpName: 'forgotPassword',
+    tool: forgotPasswordCollectionTool,
+  },
+  login: { mcpName: 'login', tool: loginCollectionTool },
+  resetPassword: {
+    mcpName: 'resetPassword',
+    tool: resetPasswordCollectionTool,
+  },
+  unlock: { mcpName: 'unlock', tool: unlockCollectionTool },
+  verify: { mcpName: 'verify', tool: verifyCollectionTool },
+} satisfies Record<string, { mcpName: string; tool: CollectionTool }>
+
+/**
+ * The static built-in global tools. Keys are the source of truth for
+ * `MCPGlobalBuiltinName`.
+ */
+export const GLOBAL_BUILTINS = {
+  countGlobalVersions: {
+    mcpName: 'countGlobalVersions',
+    requiresVersions: true,
+    tool: countGlobalVersionsTool,
+  },
+  find: { mcpName: 'findGlobal', tool: findGlobalTool },
+  findGlobalVersionByID: {
+    mcpName: 'findGlobalVersionByID',
+    requiresVersions: true,
+    tool: findGlobalVersionByIDTool,
+  },
+  findGlobalVersions: {
+    mcpName: 'findGlobalVersions',
+    requiresVersions: true,
+    tool: findGlobalVersionsTool,
+  },
+  getGlobalSchema: { mcpName: 'getGlobalSchema', tool: getGlobalSchemaTool },
+  restoreGlobalVersion: {
+    mcpName: 'restoreGlobalVersion',
+    requiresVersions: true,
+    tool: restoreGlobalVersionTool,
+  },
+  update: { mcpName: 'updateGlobal', tool: updateGlobalTool },
+} satisfies Record<string, GlobalBuiltin>
+
+export type MCPCollectionBuiltinName = keyof typeof COLLECTION_BUILTINS
+
+export type MCPCollectionAuthToolName = keyof typeof COLLECTION_AUTH_BUILTINS
+
+export type MCPGlobalBuiltinName = keyof typeof GLOBAL_BUILTINS
+
+export type MCPTopLevelBuiltinName = keyof typeof TOOL_BUILTINS
+
+/**
+ * Pre-typed `Object.entries` for each registry. The cast from `string` to the
+ * literal key union lives here once so consumers can iterate without their own
+ * cast — TypeScript's `Object.entries` always widens keys to `string`, which
+ * defeats the narrow type lookups on `MCPCollectionToolsMap`.
+ */
+export const TOOL_BUILTIN_ENTRIES = Object.entries(TOOL_BUILTINS) as Array<
+  [MCPTopLevelBuiltinName, (typeof TOOL_BUILTINS)[MCPTopLevelBuiltinName]]
+>
+
+export const COLLECTION_BUILTIN_ENTRIES = Object.entries(COLLECTION_BUILTINS) as Array<
+  [MCPCollectionBuiltinName, CollectionBuiltin]
+>
+
+export const COLLECTION_AUTH_BUILTIN_ENTRIES = Object.entries(COLLECTION_AUTH_BUILTINS) as Array<
+  [MCPCollectionAuthToolName, (typeof COLLECTION_AUTH_BUILTINS)[MCPCollectionAuthToolName]]
+>
+
+export const GLOBAL_BUILTIN_ENTRIES = Object.entries(GLOBAL_BUILTINS) as Array<
+  [MCPGlobalBuiltinName, GlobalBuiltin]
+>