@payloadcms/plugin-mcp 4.0.0-internal.e16cf59 → 4.0.0-internal.e38d3ac

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

@@ -0,0 +1,105 @@
+import type { PopulateType, SelectType } from 'payload'
+
+import { z } from 'zod'
+
+import { defaultAccess } from '../../../defaultAccess.js'
+import { defineGlobalTool } from '../../../defineTool.js'
+import { getLogger } from '../../../utils/getLogger.js'
+
+const DEFAULT_DESCRIPTION = 'Find any Payload global by passing the global slug.'
+
+export const findGlobalTool = defineGlobalTool({
+  access: (args) =>
+    defaultAccess(args) && Boolean(args.permissions?.globals?.[args.globalSlug]?.read),
+  annotations: {
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false,
+    readOnlyHint: true,
+    title: 'Find Global',
+  },
+  description: DEFAULT_DESCRIPTION,
+  input: z.object({
+    depth: z
+      .number()
+      .int()
+      .min(0)
+      .max(10)
+      .describe('Depth of population for relationships')
+      .optional()
+      .default(0),
+    fallbackLocale: z
+      .string()
+      .describe('Optional: fallback locale code to use when requested locale is not available')
+      .optional(),
+    locale: z
+      .string()
+      .describe(
+        'Optional: locale code to retrieve data in (e.g., "en", "es"). Use "all" to retrieve all locales for localized fields',
+      )
+      .optional(),
+    populate: z
+      .record(z.string(), z.unknown())
+      .describe(
+        'Optional: control which fields to include from populated relationship or upload documents.',
+      )
+      .optional(),
+    select: z
+      .record(z.string(), z.unknown())
+      .describe(
+        'Optional: define exactly which fields you\'d like to return in the response, e.g., {"title": true}',
+      )
+      .optional(),
+  }),
+}).handler(async ({ authorizedMCP, globalSlug, input, req }) => {
+  const payload = req.payload
+  const logger = getLogger({ payload })
+
+  const { depth, fallbackLocale, locale, populate, select } = input
+
+  logger.info(
+    `Reading global: ${globalSlug}, depth: ${depth}${locale ? `, locale: ${locale}` : ''}`,
+  )
+
+  try {
+    const findOptions: Parameters<typeof payload.findGlobal>[0] = {
+      slug: globalSlug,
+      depth,
+      overrideAccess: authorizedMCP.overrideAccess,
+      req,
+    }
+
+    if (locale) {
+      findOptions.locale = locale
+    }
+    if (fallbackLocale) {
+      findOptions.fallbackLocale = fallbackLocale
+    }
+    if (select) {
+      findOptions.select = select as SelectType
+    }
+    if (populate) {
+      findOptions.populate = populate as PopulateType
+    }
+
+    const result = await payload.findGlobal(findOptions)
+
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `Global "${globalSlug}":\n\`\`\`json\n${JSON.stringify(result)}\n\`\`\``,
+        },
+      ],
+      doc: result as Record<string, unknown>,
+    }
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : 'Unknown error'
+    logger.error(`Error reading global ${globalSlug}: ${errorMessage}`)
+    return {
+      content: [
+        { type: 'text', text: `❌ **Error reading global "${globalSlug}":** ${errorMessage}` },
+      ],
+    }
+  }
+})

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

@@ -0,0 +1,103 @@
+import type { PopulateType, SelectType } from 'payload'
+
+import { z } from 'zod'
+
+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.globalSlug]?.readVersions),
+  annotations: {
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false,
+    readOnlyHint: true,
+    title: 'Find Global Version By ID',
+  },
+  description: DEFAULT_DESCRIPTION,
+  input: z.object({
+    id: z.string().describe('The ID of the global version to retrieve'),
+    depth: z
+      .number()
+      .int()
+      .min(0)
+      .max(10)
+      .describe('How many levels deep to populate relationships in the global version document')
+      .optional()
+      .default(0),
+    fallbackLocale: z
+      .string()
+      .describe('Optional: fallback locale code to use when requested locale is not available')
+      .optional(),
+    locale: z
+      .string()
+      .describe(
+        'Optional: locale code to retrieve data in (e.g., "en", "es"). Use "all" to retrieve all locales for localized fields',
+      )
+      .optional(),
+    populate: z
+      .record(z.string(), z.unknown())
+      .describe(
+        'Optional: control which fields to include from populated relationship or upload documents.',
+      )
+      .optional(),
+    select: z
+      .record(z.string(), z.unknown())
+      .describe(
+        'Optional: define exactly which fields you\'d like to return in the response, e.g., {"version.siteName": true}',
+      )
+      .optional(),
+    showHiddenFields: z
+      .boolean()
+      .describe('Optional: include hidden fields in the returned global version document')
+      .optional(),
+  }),
+}).handler(async ({ authorizedMCP, globalSlug, input, req }) => {
+  const payload = req.payload
+  const logger = getLogger({ payload })
+  const { id, depth, fallbackLocale, locale, populate, select, showHiddenFields } = input
+
+  logger.info(`Finding version for global: ${globalSlug} with ID: ${id}`)
+
+  try {
+    const result = await payload.findGlobalVersionByID({
+      id,
+      slug: globalSlug,
+      depth,
+      overrideAccess: authorizedMCP.overrideAccess,
+      req,
+      ...(fallbackLocale ? { fallbackLocale } : {}),
+      ...(locale ? { locale } : {}),
+      ...(populate ? { populate: populate as PopulateType } : {}),
+      ...(select ? { select: select as SelectType } : {}),
+      ...(showHiddenFields !== undefined ? { showHiddenFields } : {}),
+    })
+
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `Version "${id}" from global "${globalSlug}":\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 ${globalSlug}: ${errorMessage}`)
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `❌ **Error finding version "${id}" for global "${globalSlug}":** ${errorMessage}`,
+        },
+      ],
+      isError: true,
+    }
+  }
+})

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

@@ -0,0 +1,147 @@
+import type { PopulateType, SelectType } from 'payload'
+
+import { z } from 'zod'
+
+import { defaultAccess } from '../../../defaultAccess.js'
+import { defineGlobalTool } from '../../../defineTool.js'
+import { getLogger } from '../../../utils/getLogger.js'
+import { whereSchema } from '../../../utils/whereSchema.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.globalSlug]?.readVersions),
+  annotations: {
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false,
+    readOnlyHint: true,
+    title: 'Find Global Versions',
+  },
+  description: DEFAULT_DESCRIPTION,
+  input: z.object({
+    depth: z
+      .number()
+      .int()
+      .min(0)
+      .max(10)
+      .describe('How many levels deep to populate relationships in global version documents')
+      .optional()
+      .default(0),
+    fallbackLocale: z
+      .string()
+      .describe('Optional: fallback locale code to use when requested locale is not available')
+      .optional(),
+    limit: z
+      .number()
+      .int()
+      .min(1)
+      .max(100)
+      .describe('Maximum number of versions to return (default: 10, max: 100)')
+      .optional()
+      .default(10),
+    locale: z
+      .string()
+      .describe(
+        'Optional: locale code to retrieve data in (e.g., "en", "es"). Use "all" to retrieve all locales for localized fields',
+      )
+      .optional(),
+    page: z
+      .number()
+      .int()
+      .min(1)
+      .describe('Page number for pagination (default: 1)')
+      .optional()
+      .default(1),
+    pagination: z
+      .boolean()
+      .describe('Optional: set to false to skip the count query overhead')
+      .optional(),
+    populate: z
+      .record(z.string(), z.unknown())
+      .describe(
+        'Optional: control which fields to include from populated relationship or upload documents.',
+      )
+      .optional(),
+    select: z
+      .record(z.string(), z.unknown())
+      .describe(
+        'Optional: define exactly which fields you\'d like to return in the response, e.g., {"version.siteName": true}',
+      )
+      .optional(),
+    showHiddenFields: z
+      .boolean()
+      .describe('Optional: include hidden fields in returned global version documents')
+      .optional(),
+    sort: z
+      .string()
+      .describe('Field to sort by (e.g., "-updatedAt", "-version.updatedAt" for descending)')
+      .optional(),
+    where: whereSchema
+      .describe(
+        'Optional: where clause for filtering versions. Version document fields are usually under "version". Example: {"version.siteName":{"contains":"test"}}',
+      )
+      .optional(),
+  }),
+}).handler(async ({ authorizedMCP, globalSlug, input, req }) => {
+  const payload = req.payload
+  const logger = getLogger({ payload })
+  const {
+    depth,
+    fallbackLocale,
+    limit,
+    locale,
+    page,
+    pagination,
+    populate,
+    select,
+    showHiddenFields,
+    sort,
+    where,
+  } = input
+
+  logger.info(`Finding versions for global: ${globalSlug}, limit: ${limit}, page: ${page}`)
+
+  try {
+    const result = await payload.findGlobalVersions({
+      slug: globalSlug,
+      depth,
+      limit,
+      overrideAccess: authorizedMCP.overrideAccess,
+      page,
+      req,
+      ...(fallbackLocale ? { fallbackLocale } : {}),
+      ...(locale ? { locale } : {}),
+      ...(pagination !== undefined ? { pagination } : {}),
+      ...(populate ? { populate: populate as PopulateType } : {}),
+      ...(select ? { select: select as SelectType } : {}),
+      ...(showHiddenFields !== undefined ? { showHiddenFields } : {}),
+      ...(sort ? { sort } : {}),
+      ...(where ? { where } : {}),
+    })
+
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `Versions for global "${globalSlug}":\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 ${globalSlug}: ${errorMessage}`)
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `❌ **Error finding versions for global "${globalSlug}":** ${errorMessage}`,
+        },
+      ],
+      isError: true,
+    }
+  }
+})

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

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

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

@@ -0,0 +1,99 @@
+import type { PopulateType } from 'payload'
+
+import { z } from 'zod'
+
+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.globalSlug]?.update),
+  annotations: {
+    destructiveHint: true,
+    idempotentHint: false,
+    openWorldHint: false,
+    readOnlyHint: false,
+    title: 'Restore Global Version',
+  },
+  description: DEFAULT_DESCRIPTION,
+  input: z.object({
+    id: z.string().describe('The ID of the global version to restore'),
+    depth: z
+      .number()
+      .int()
+      .min(0)
+      .max(10)
+      .describe('How many levels deep to populate relationships in response')
+      .optional()
+      .default(0),
+    fallbackLocale: z
+      .string()
+      .describe('Optional: fallback locale code to use when requested locale is not available')
+      .optional(),
+    locale: z
+      .string()
+      .describe('Optional: locale code to restore in (e.g., "en", "es")')
+      .optional(),
+    populate: z
+      .record(z.string(), z.unknown())
+      .describe(
+        'Optional: control which fields to include from populated relationship or upload documents.',
+      )
+      .optional(),
+    showHiddenFields: z
+      .boolean()
+      .describe('Optional: include hidden fields in the restored global response')
+      .optional(),
+  }),
+}).handler(async ({ authorizedMCP, globalSlug, input, req }) => {
+  const payload = req.payload
+  const logger = getLogger({ payload })
+  const { id, depth, fallbackLocale, locale, populate, showHiddenFields } = input
+
+  logger.info(`Restoring version for global: ${globalSlug} with ID: ${id}`)
+
+  try {
+    const result = await payload.restoreGlobalVersion({
+      id,
+      slug: globalSlug,
+      depth,
+      overrideAccess: authorizedMCP.overrideAccess,
+      req,
+      ...(fallbackLocale ? { fallbackLocale } : {}),
+      ...(locale ? { locale } : {}),
+      ...(populate ? { populate: populate as PopulateType } : {}),
+      ...(showHiddenFields !== undefined ? { showHiddenFields } : {}),
+    })
+    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 "${globalSlug}"!\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 ${globalSlug}: ${errorMessage}`)
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `❌ **Error restoring version "${id}" for global "${globalSlug}":** ${errorMessage}`,
+        },
+      ],
+      isError: true,
+    }
+  }
+})

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

@@ -0,0 +1,115 @@
+import type { SelectType } from 'payload'
+
+import { z } from 'zod'
+
+import { defaultAccess } from '../../../defaultAccess.js'
+import { defineGlobalTool } from '../../../defineTool.js'
+import { getLogger } from '../../../utils/getLogger.js'
+import {
+  getGlobalVirtualFieldNames,
+  stripVirtualFields,
+} from '../../../utils/getVirtualFieldNames.js'
+import { transformPointDataToPayload } from '../../../utils/transformPointDataToPayload.js'
+import { validateGlobalData } from '../validateEntityData.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.globalSlug]?.update),
+  annotations: {
+    destructiveHint: true,
+    idempotentHint: false,
+    openWorldHint: false,
+    readOnlyHint: false,
+    title: 'Update Global',
+  },
+  description: DEFAULT_DESCRIPTION,
+  input: z.object({
+    data: z.record(z.string(), z.unknown()).describe('The global fields to update'),
+    depth: z
+      .number()
+      .describe('Optional: Depth of relationships to populate')
+      .optional()
+      .default(0),
+    draft: z
+      .boolean()
+      .describe('Optional: Whether to save as draft (default: false)')
+      .optional()
+      .default(false),
+    fallbackLocale: z
+      .string()
+      .describe('Optional: fallback locale code to use when requested locale is not available')
+      .optional(),
+    locale: z
+      .string()
+      .describe(
+        'Optional: locale code to update data in (e.g., "en", "es"). Use "all" to update all locales for localized fields',
+      )
+      .optional(),
+    select: z
+      .record(z.string(), z.unknown())
+      .describe(
+        'Optional: define exactly which fields you\'d like to return in the response, e.g., {"siteName": true}',
+      )
+      .optional(),
+  }),
+}).handler(async ({ authorizedMCP, globalSlug, input, req }) => {
+  const payload = req.payload
+  const logger = getLogger({ payload })
+
+  const { data, depth, draft, fallbackLocale, locale, select } = input
+
+  logger.info(
+    `Updating global: ${globalSlug}, draft: ${draft}${locale ? `, locale: ${locale}` : ''}`,
+  )
+
+  try {
+    const virtualFieldNames = getGlobalVirtualFieldNames(payload.config, globalSlug)
+    const inputData = stripVirtualFields(data, virtualFieldNames)
+    const validationError = validateGlobalData({ data: inputData, globalSlug, req })
+
+    if (validationError) {
+      return validationError
+    }
+
+    const parsedData = transformPointDataToPayload(inputData)
+
+    const updateOptions: Parameters<typeof payload.updateGlobal>[0] = {
+      slug: globalSlug,
+      data: parsedData,
+      depth,
+      draft,
+      overrideAccess: authorizedMCP.overrideAccess,
+      req,
+    }
+
+    if (locale) {
+      updateOptions.locale = locale
+    }
+    if (fallbackLocale) {
+      updateOptions.fallbackLocale = fallbackLocale
+    }
+    if (select) {
+      updateOptions.select = select as SelectType
+    }
+
+    const result = await payload.updateGlobal(updateOptions)
+
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `Global "${globalSlug}" updated successfully!\n\`\`\`json\n${JSON.stringify(result)}\n\`\`\``,
+        },
+      ],
+      doc: result as Record<string, unknown>,
+    }
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : 'Unknown error'
+    logger.error(`Error updating global ${globalSlug}: ${errorMessage}`)
+    return {
+      content: [{ type: 'text', text: `Error updating global "${globalSlug}": ${errorMessage}` }],
+    }
+  }
+})