@payloadcms/plugin-mcp 4.0.0-internal.c2b57ce → 4.0.0-internal.c6494b5

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

@@ -1,96 +1,66 @@
-import type { SelectType } from 'payload'
-
-import { z } from 'zod'
+import { findGlobalInputSchema } from 'payload'
 
+import { defaultAccess } from '../../../defaultAccess.js'
 import { defineGlobalTool } from '../../../defineTool.js'
 import { getLogger } from '../../../utils/getLogger.js'
-import { localAPIDefaults } from '../../../utils/localAPIDefaults.js'
 
-const DEFAULT_DESCRIPTION = 'Find a Payload global singleton configuration.'
+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.slug]?.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(),
-    select: z
-      .string()
-      .describe(
-        "Optional: define exactly which fields you'd like to return in the response (JSON), e.g., '{\"title\": true}'",
-      )
-      .optional(),
-  }),
-}).handler(async ({ authorizedMCP, globalSlug, input, req }) => {
+  input: findGlobalInputSchema,
+}).handler(async ({ slug, authorizedMCP, input, req }) => {
   const payload = req.payload
   const logger = getLogger({ payload })
 
-  const { depth, fallbackLocale, locale, select } = input
+  const { depth, fallbackLocale, locale, populate, select } = input
 
-  logger.info(
-    `Reading global: ${globalSlug}, depth: ${depth}${locale ? `, locale: ${locale}` : ''}`,
-  )
+  logger.info(`Reading global: ${slug}, depth: ${depth}${locale ? `, locale: ${locale}` : ''}`)
 
   try {
     const findOptions: Parameters<typeof payload.findGlobal>[0] = {
-      slug: globalSlug,
+      slug,
       depth,
-      ...localAPIDefaults(authorizedMCP),
-    }
-
-    let selectClause: SelectType | undefined
-    if (select) {
-      try {
-        selectClause = JSON.parse(select) as SelectType
-      } catch {
-        logger.warn(`Invalid select clause JSON for global: ${select}`)
-        return { content: [{ type: 'text', text: 'Error: Invalid JSON in select clause' }] }
-      }
+      overrideAccess: authorizedMCP.overrideAccess,
+      req,
     }
 
     if (locale) {
       findOptions.locale = locale
     }
-    if (fallbackLocale) {
+    if (fallbackLocale !== undefined) {
       findOptions.fallbackLocale = fallbackLocale
     }
-    if (selectClause) {
-      findOptions.select = selectClause
+    if (select) {
+      findOptions.select = select
+    }
+    if (populate) {
+      findOptions.populate = populate
     }
-
     const result = await payload.findGlobal(findOptions)
 
     return {
       content: [
         {
           type: 'text',
-          text: `Global "${globalSlug}":\n\`\`\`json\n${JSON.stringify(result)}\n\`\`\``,
+          text: `Global "${slug}":\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}`)
+    logger.error(`Error reading global ${slug}: ${errorMessage}`)
     return {
-      content: [
-        { type: 'text', text: `❌ **Error reading global "${globalSlug}":** ${errorMessage}` },
-      ],
+      content: [{ type: 'text', text: `❌ **Error reading global "${slug}":** ${errorMessage}` }],
     }
   }
 })

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

@@ -1,100 +1,76 @@
-import type { SelectType } from 'payload'
-
-import { z } from 'zod'
-
-import { defineGlobalTool } from '../../../defineTool.js'
-import { getLogger } from '../../../utils/getLogger.js'
 import {
   getGlobalVirtualFieldNames,
   stripVirtualFields,
-} from '../../../utils/getVirtualFieldNames.js'
-import { localAPIDefaults } from '../../../utils/localAPIDefaults.js'
-import { prepareCollectionSchema } from '../../../utils/schemaConversion/prepareCollectionSchema.js'
+  transformPointDataToPayload,
+  updateGlobalInputSchema,
+  validateGlobalData,
+} from 'payload'
 
-const DEFAULT_DESCRIPTION = 'Update a Payload global singleton configuration.'
+import { defaultAccess } from '../../../defaultAccess.js'
+import { defineGlobalTool } from '../../../defineTool.js'
+import { getLogger } from '../../../utils/getLogger.js'
+import { formatEntityError } from '../formatEntityError.js'
 
-export const updateGlobalTool = defineGlobalTool({
-  description: DEFAULT_DESCRIPTION,
-  input: ({ globalSchema }) => {
-    const partialSchema = prepareCollectionSchema(globalSchema)
-    // Global updates do not require all required fields to be passed => delete .required.
-    //
-    // Local API equivalent: packages/payload/src/global/operations/local/update.ts#BaseOptions#data:
-    // data: DeepPartial<Omit<DataFromGlobalSlug<TSlug>, 'id'>>
-    delete partialSchema.required
+const DEFAULT_DESCRIPTION = 'Update any Payload global by passing the global slug and data.'
 
-    return z.object({
-      data: z
-        .fromJSONSchema(partialSchema as unknown as z.core.JSONSchema.JSONSchema)
-        .describe('The 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
-        .string()
-        .describe(
-          'Optional: define exactly which fields you\'d like to return in the response (JSON), e.g., \'{"siteName": "My Site"}\'',
-        )
-        .optional(),
-    })
+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',
   },
-}).handler(async ({ authorizedMCP, globalSlug, input, req }) => {
+  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, select } = input
+  const {
+    data,
+    depth,
+    draft,
+    fallbackLocale,
+    locale,
+    overrideLock,
+    populate,
+    publishAllLocales,
+    select,
+    unpublishAllLocales,
+  } = input
 
-  logger.info(
-    `Updating global: ${globalSlug}, draft: ${draft}${locale ? `, locale: ${locale}` : ''}`,
-  )
+  logger.info(`Updating global: ${slug}, draft: ${draft}${locale ? `, locale: ${locale}` : ''}`)
 
   try {
-    const virtualFieldNames = getGlobalVirtualFieldNames(payload.config, globalSlug)
-    const parsedData = stripVirtualFields(data as Record<string, unknown>, virtualFieldNames)
+    const virtualFieldNames = getGlobalVirtualFieldNames(payload.config, slug)
+    const inputData = stripVirtualFields(data, virtualFieldNames)
+    validateGlobalData({ slug, data: inputData, req })
 
-    let selectClause: SelectType | undefined
-    if (select) {
-      try {
-        selectClause = JSON.parse(select) as SelectType
-      } catch {
-        logger.warn(`Invalid select clause JSON for global: ${select}`)
-        return { content: [{ type: 'text', text: 'Error: Invalid JSON in select clause' }] }
-      }
-    }
+    const parsedData = transformPointDataToPayload(inputData)
 
     const updateOptions: Parameters<typeof payload.updateGlobal>[0] = {
-      slug: globalSlug,
+      slug,
       data: parsedData,
       depth,
       draft,
-      ...localAPIDefaults(authorizedMCP),
+      overrideAccess: authorizedMCP.overrideAccess,
+      overrideLock,
+      populate,
+      publishAllLocales,
+      req,
+      unpublishAllLocales,
     }
 
     if (locale) {
       updateOptions.locale = locale
     }
-    if (fallbackLocale) {
+    if (fallbackLocale !== undefined) {
       updateOptions.fallbackLocale = fallbackLocale
     }
-    if (selectClause) {
-      updateOptions.select = selectClause
+    if (select) {
+      updateOptions.select = select
     }
 
     const result = await payload.updateGlobal(updateOptions)
@@ -103,16 +79,14 @@ export const updateGlobalTool = defineGlobalTool({
       content: [
         {
           type: 'text',
-          text: `Global "${globalSlug}" updated successfully!\n\`\`\`json\n${JSON.stringify(result)}\n\`\`\``,
+          text: `Global "${slug}" 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}` }],
-    }
+    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 })
   }
 })