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

package/src/mcp/builtin/collections/authTools.ts

@@ -0,0 +1,280 @@
+import { createPayloadRequest, strictObject, z } from 'payload'
+
+import type { MCPToolResponse } from '../../../types.js'
+
+import { defaultAccess } from '../../../defaultAccess.js'
+import { defineCollectionTool } from '../../../defineTool.js'
+import { getLogger } from '../../../utils/getLogger.js'
+
+/**
+ * Auth tools surfaced under `collections.<auth-collection>.tools`. Opt-in: they
+ * default off (an LLM with `login` access can probe passwords; not something
+ * to expose by default). Enable in plugin config via `tools: { login: true }`
+ * (or `{ description: '...' }`).
+ *
+ * `auth` (check current token) doesn't actually depend on the collection at
+ * runtime — `payload.auth({ headers })` is global — but it's grouped under the
+ * users collection so all auth-shaped tools live in one place.
+ */
+
+const emailSchema = z.email().check(z.describe('The user email address.'))
+
+const wrapError =
+  (name: string) =>
+  ({ slug, message }: { message: string; slug: string }): MCPToolResponse => {
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `❌ **Error in ${name}** on ${slug}: ${message}`,
+        },
+      ],
+    }
+  }
+
+export const authCollectionTool = defineCollectionTool({
+  annotations: {
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false,
+    readOnlyHint: true,
+    title: 'Check Auth Status',
+  },
+  description: 'Checks authentication status for the current user.',
+  input: strictObject({
+    headers: z
+      .optional(z.record(z.string(), z.string()))
+      .check(z.describe('Custom headers to send with the authentication request.')),
+  }),
+}).handler(async ({ slug, authorizedMCP, input, req }) => {
+  const logger = getLogger({ payload: req.payload })
+  try {
+    let authHeaders = new Headers()
+    if (input.headers) {
+      authHeaders = new Headers(input.headers)
+    }
+    const authReq = await createPayloadRequest({
+      payload: req.payload,
+      req: { headers: authHeaders },
+    })
+    const result = await req.payload.auth({ headers: authHeaders, req: authReq })
+
+    if (result.user) {
+      const authenticatedUser = result.user
+      // Auth strategies read users with trusted Local API access. Re-read the user with the MCP
+      // caller's access level before returning it to the client.
+      const user = await req.payload.findByID({
+        id: authenticatedUser.id,
+        collection: authenticatedUser.collection,
+        overrideAccess: authorizedMCP.overrideAccess,
+        req: authReq,
+      })
+      result.user = {
+        ...user,
+        _sid: authenticatedUser._sid,
+        _strategy: authenticatedUser._strategy,
+        collection: authenticatedUser.collection,
+      }
+    }
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `# Authentication Status\n\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 in auth tool on ${slug}: ${errorMessage}`)
+    return wrapError('auth')({ slug, message: errorMessage })
+  }
+})
+
+export const forgotPasswordCollectionTool = defineCollectionTool({
+  annotations: {
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: true,
+    readOnlyHint: false,
+    title: 'Forgot Password',
+  },
+  description: 'Sends a password reset email to a user.',
+  input: strictObject({
+    email: emailSchema,
+  }),
+}).handler(async ({ slug, input, req }) => {
+  const logger = getLogger({ payload: req.payload })
+  try {
+    await req.payload.forgotPassword({
+      collection: slug,
+      data: { email: input.email },
+      disableEmail: false,
+      overrideAccess: false,
+      req,
+    })
+    return {
+      content: [
+        {
+          type: 'text',
+          text: 'If an account matches that email, password reset instructions have been sent.',
+        },
+      ],
+    }
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : 'Unknown error'
+    logger.error(`Error in forgotPassword tool on ${slug}: ${errorMessage}`)
+    return wrapError('forgotPassword')({ slug, message: errorMessage })
+  }
+})
+
+export const loginCollectionTool = defineCollectionTool({
+  annotations: {
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: false,
+    readOnlyHint: false,
+    title: 'User Login',
+  },
+  description: 'Authenticates a user with email and password.',
+  input: strictObject({
+    depth: z
+      ._default(z.int().check(z.minimum(0), z.maximum(10)), 0)
+      .check(z.describe('Depth of population for relationships.')),
+    email: emailSchema,
+    password: z.string().check(z.describe('The user password.')),
+  }),
+}).handler(async ({ slug, authorizedMCP, input, req }) => {
+  const logger = getLogger({ payload: req.payload })
+  try {
+    const result = await req.payload.login({
+      collection: slug,
+      data: { email: input.email, password: input.password },
+      depth: input.depth,
+      overrideAccess: authorizedMCP.overrideAccess,
+    })
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `# Login Successful\n\n**User:** ${input.email}\n**Collection:** ${slug}\n\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 in login tool on ${slug}: ${errorMessage}`)
+    return wrapError('login')({ slug, message: errorMessage })
+  }
+})
+
+export const resetPasswordCollectionTool = defineCollectionTool({
+  annotations: {
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: false,
+    readOnlyHint: false,
+    title: 'Reset Password',
+  },
+  description: 'Resets a user password with a reset token.',
+  input: strictObject({
+    password: z.string().check(z.describe('The new password for the user.')),
+    token: z.string().check(z.describe('The password reset token sent to the user email.')),
+  }),
+}).handler(async ({ slug, authorizedMCP, input, req }) => {
+  const logger = getLogger({ payload: req.payload })
+  try {
+    const result = await req.payload.resetPassword({
+      collection: slug,
+      data: { password: input.password, token: input.token },
+      overrideAccess: authorizedMCP.overrideAccess,
+    })
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `# Password Reset Successful\n\n**Collection:** ${slug}\n\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 in resetPassword tool on ${slug}: ${errorMessage}`)
+    return wrapError('resetPassword')({ slug, message: errorMessage })
+  }
+})
+
+export const unlockCollectionTool = defineCollectionTool({
+  access: (args) =>
+    defaultAccess(args) && Boolean(args.permissions?.collections?.[args.slug]?.unlock),
+  annotations: {
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false,
+    readOnlyHint: false,
+    title: 'Unlock Account',
+  },
+  description: 'Unlocks a user account that has been locked due to failed login attempts.',
+  input: strictObject({ email: emailSchema }),
+}).handler(async ({ slug, authorizedMCP, input, req }) => {
+  const logger = getLogger({ payload: req.payload })
+  try {
+    const result = await req.payload.unlock({
+      collection: slug,
+      data: { email: input.email },
+      overrideAccess: authorizedMCP.overrideAccess,
+      req,
+    })
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `# Account Unlocked\n\n**Collection:** ${slug}\n**Email:** ${input.email}\n**Result:** ${result ? 'Success' : 'Failed'}`,
+        },
+      ],
+      doc: { result },
+    }
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : 'Unknown error'
+    logger.error(`Error in unlock tool on ${slug}: ${errorMessage}`)
+    return wrapError('unlock')({ slug, message: errorMessage })
+  }
+})
+
+export const verifyCollectionTool = defineCollectionTool({
+  annotations: {
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: false,
+    readOnlyHint: false,
+    title: 'Email Verification',
+  },
+  description: 'Verifies a user email with a verification token.',
+  input: strictObject({
+    token: z.string().check(z.describe('The verification token sent to the user email.')),
+  }),
+}).handler(async ({ slug, input, req }) => {
+  const logger = getLogger({ payload: req.payload })
+  try {
+    const result = await req.payload.verifyEmail({
+      collection: slug,
+      token: input.token,
+    })
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `# Email Verification Successful\n\n**Collection:** ${slug}\n**Result:** ${result ? 'Success' : 'Failed'}`,
+        },
+      ],
+      doc: { result },
+    }
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : 'Unknown error'
+    logger.error(`Error in verify tool on ${slug}: ${errorMessage}`)
+    return wrapError('verify')({ slug, message: errorMessage })
+  }
+})

package/src/mcp/builtin/collections/countTool.ts

@@ -0,0 +1,61 @@
+import { countDocumentsInputSchema } from 'payload'
+
+import { defaultAccess } from '../../../defaultAccess.js'
+import { defineCollectionTool } from '../../../defineTool.js'
+import { getLogger } from '../../../utils/getLogger.js'
+
+const DEFAULT_DESCRIPTION =
+  'Count documents in any collection by passing the collection slug and optional where clause.'
+
+export const countDocumentsTool = defineCollectionTool({
+  access: (args) =>
+    defaultAccess(args) && Boolean(args.permissions?.collections?.[args.slug]?.read),
+  annotations: {
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false,
+    readOnlyHint: true,
+    title: 'Count Documents',
+  },
+  description: DEFAULT_DESCRIPTION,
+  input: countDocumentsInputSchema,
+}).handler(async ({ slug, authorizedMCP, input, req }) => {
+  const payload = req.payload
+  const logger = getLogger({ payload })
+  const { locale, trash, where } = input
+
+  logger.info(`Counting documents in collection: ${slug}`)
+
+  try {
+    const result = await payload.count({
+      collection: slug,
+      overrideAccess: authorizedMCP.overrideAccess,
+      req,
+      ...(locale ? { locale } : {}),
+      ...(trash !== undefined ? { trash } : {}),
+      ...(where ? { where } : {}),
+    })
+
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `Collection "${slug}" contains ${result.totalDocs} matching documents.\n\`\`\`json\n${JSON.stringify(result)}\n\`\`\``,
+        },
+      ],
+      doc: result,
+    }
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : 'Unknown error'
+    logger.error(`Error counting documents in ${slug}: ${errorMessage}`)
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `❌ **Error counting documents in collection "${slug}":** ${errorMessage}`,
+        },
+      ],
+      isError: true,
+    }
+  }
+})

package/src/mcp/builtin/collections/countVersionsTool.ts

@@ -0,0 +1,60 @@
+import { countVersionsInputSchema } from 'payload'
+
+import { defaultAccess } from '../../../defaultAccess.js'
+import { defineCollectionTool } from '../../../defineTool.js'
+import { getLogger } from '../../../utils/getLogger.js'
+
+const DEFAULT_DESCRIPTION =
+  'Count document versions in any version-enabled collection by passing the collection slug and optional where clause.'
+
+export const countVersionsTool = defineCollectionTool({
+  access: (args) =>
+    defaultAccess(args) && Boolean(args.permissions?.collections?.[args.slug]?.readVersions),
+  annotations: {
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false,
+    readOnlyHint: true,
+    title: 'Count Versions',
+  },
+  description: DEFAULT_DESCRIPTION,
+  input: countVersionsInputSchema,
+}).handler(async ({ slug, authorizedMCP, input, req }) => {
+  const payload = req.payload
+  const logger = getLogger({ payload })
+  const { locale, where } = input
+
+  logger.info(`Counting versions in collection: ${slug}`)
+
+  try {
+    const result = await payload.countVersions({
+      collection: slug,
+      overrideAccess: authorizedMCP.overrideAccess,
+      req,
+      ...(locale ? { locale } : {}),
+      ...(where ? { where } : {}),
+    })
+
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `Collection "${slug}" contains ${result.totalDocs} matching versions.\n\`\`\`json\n${JSON.stringify(result)}\n\`\`\``,
+        },
+      ],
+      doc: result,
+    }
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : 'Unknown error'
+    logger.error(`Error counting versions in ${slug}: ${errorMessage}`)
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `❌ **Error counting versions in collection "${slug}":** ${errorMessage}`,
+        },
+      ],
+      isError: true,
+    }
+  }
+})

package/src/mcp/builtin/collections/createTool.ts

@@ -0,0 +1,143 @@
+import {
+  createDocumentsInputSchema,
+  getCollectionVirtualFieldNames,
+  hasDraftValidationEnabled,
+  stripVirtualFields,
+  transformPointDataToPayload,
+  validateCollectionData,
+} from 'payload'
+
+import { defaultAccess } from '../../../defaultAccess.js'
+import { defineCollectionTool } from '../../../defineTool.js'
+import { getLogger } from '../../../utils/getLogger.js'
+import { formatEntityError } from '../formatEntityError.js'
+import { fileInputSchema, resolveFile } from './fileInput.js'
+
+const DEFAULT_DESCRIPTION =
+  'Create one or more documents. Each can have different data or a file. Prefer uploadReference after upload, externalURL for URLs, or base64 for small local files.'
+
+export const createDocumentsTool = defineCollectionTool({
+  access: (args) =>
+    defaultAccess(args) && Boolean(args.permissions?.collections?.[args.slug]?.create),
+  annotations: {
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: false,
+    readOnlyHint: false,
+    title: 'Create Documents',
+  },
+  description: DEFAULT_DESCRIPTION,
+  input: createDocumentsInputSchema({ file: fileInputSchema }),
+}).handler(async ({ slug, authorizedMCP, input, req }) => {
+  const payload = req.payload
+  const collectionConfig = payload.collections[slug]?.config
+  const logger = getLogger({ payload })
+  const {
+    depth,
+    documents,
+    draft,
+    fallbackLocale,
+    locale,
+    populate,
+    publishAllLocales,
+    returning,
+    select,
+  } = input
+  const shouldUsePartialSchema =
+    draft === true && collectionConfig !== undefined && !hasDraftValidationEnabled(collectionConfig)
+
+  logger.info(`Creating ${documents.length} documents in collection: ${slug}`)
+
+  try {
+    const virtualFieldNames = getCollectionVirtualFieldNames(payload.config, slug)
+    const docs: Array<
+      { doc: Record<string, unknown>; index: number } | { id: number | string; index: number }
+    > = []
+    const errors: Array<{ index: number; message: string }> = []
+    let validationSchema: Record<string, unknown> | undefined
+
+    for (const [index, document] of documents.entries()) {
+      try {
+        const inputData = stripVirtualFields(document.data, virtualFieldNames)
+        validateCollectionData({
+          slug,
+          data: inputData,
+          partial: shouldUsePartialSchema,
+          req,
+        })
+
+        const parsedData = transformPointDataToPayload(inputData)
+        const file = await resolveFile({ slug, input: document.file, req })
+        const result = await payload.create({
+          collection: slug,
+          data: parsedData,
+          depth,
+          draft,
+          overrideAccess: authorizedMCP.overrideAccess,
+          populate,
+          publishAllLocales,
+          req,
+          ...(file ? { file } : {}),
+          ...(locale ? { locale } : {}),
+          ...(fallbackLocale !== undefined ? { fallbackLocale } : {}),
+          select: returning ? select : { id: true },
+        })
+
+        docs.push(returning ? { doc: result, index } : { id: result.id, index })
+      } catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown error'
+        const formattedError = formatEntityError({
+          slug,
+          action: 'creating',
+          entity: 'collection',
+          error,
+          req,
+        })
+        const structuredContent = formattedError.structuredContent as
+          | { schema?: unknown }
+          | undefined
+        const schema = structuredContent?.schema
+        const errorContent = formattedError.content[0]
+        const formattedMessage =
+          errorContent?.type === 'text'
+            ? (errorContent.text.split('\n\nUse this schema')[0] ?? message)
+            : message
+
+        if (!validationSchema && schema && typeof schema === 'object') {
+          validationSchema = schema as Record<string, unknown>
+        }
+
+        logger.error(`Error creating document at index ${index} in ${slug}: ${message}`)
+        errors.push({ index, message: formattedMessage })
+      }
+    }
+
+    const batchResult = { docs, errors }
+    const retryMessage = errors.length > 0 ? '\nRetry failed indexes only.' : ''
+    const schemaMessage = validationSchema
+      ? `\n\nUse this schema for data:\n\`\`\`json\n${JSON.stringify(validationSchema)}\n\`\`\``
+      : ''
+    const structuredContent = validationSchema
+      ? { ...batchResult, schema: validationSchema }
+      : batchResult
+
+    logger.info(`Created ${docs.length} of ${documents.length} documents in ${slug}`)
+
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `Created ${docs.length} of ${documents.length} documents in collection "${slug}".${retryMessage}\nResults:\n\`\`\`json\n${JSON.stringify(batchResult)}\n\`\`\`${schemaMessage}`,
+        },
+      ],
+      doc: structuredContent as unknown as Record<string, unknown>,
+      isError: docs.length === 0 && errors.length > 0,
+      structuredContent,
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : 'Unknown error'
+
+    logger.error(`Error creating documents in ${slug}: ${message}`)
+    return formatEntityError({ slug, action: 'creating', entity: 'collection', error, req })
+  }
+})

package/src/mcp/builtin/collections/deleteTool.ts

@@ -0,0 +1,97 @@
+import { deleteDocumentsInputSchema, parseDocumentID } from 'payload'
+
+import { defaultAccess } from '../../../defaultAccess.js'
+import { defineCollectionTool } from '../../../defineTool.js'
+import { getLogger } from '../../../utils/getLogger.js'
+
+const DEFAULT_DESCRIPTION =
+  'Delete documents in any collection by passing the collection slug and ID or where clause.'
+
+export const deleteDocumentsTool = defineCollectionTool({
+  access: (args) =>
+    defaultAccess(args) && Boolean(args.permissions?.collections?.[args.slug]?.delete),
+  annotations: {
+    destructiveHint: true,
+    idempotentHint: false,
+    openWorldHint: false,
+    readOnlyHint: false,
+    title: 'Delete Documents',
+  },
+  description: DEFAULT_DESCRIPTION,
+  input: deleteDocumentsInputSchema,
+}).handler(async ({ slug, authorizedMCP, input, req }) => {
+  const payload = req.payload
+  const logger = getLogger({ payload })
+
+  const { id, depth, fallbackLocale, locale, where } = input
+
+  logger.info(
+    `Deleting document from collection: ${slug}${id ? ` with ID: ${id}` : ' with where clause'}${locale ? `, locale: ${locale}` : ''}`,
+  )
+
+  try {
+    if (id !== undefined) {
+      const result = await payload.delete({
+        id: parseDocumentID({ id, collectionSlug: slug, payload }),
+        collection: slug,
+        depth,
+        overrideAccess: authorizedMCP.overrideAccess,
+        req,
+        ...(locale && { locale }),
+        ...(fallbackLocale !== undefined && { fallbackLocale }),
+      })
+
+      return {
+        content: [
+          {
+            type: 'text',
+            text: `Document deleted successfully from collection "${slug}"!\nDeleted document:\n\`\`\`json\n${JSON.stringify(result)}\n\`\`\``,
+          },
+        ],
+        doc: result,
+      }
+    }
+
+    if (where === undefined) {
+      return {
+        content: [{ type: 'text', text: 'Error: Either id or where clause must be provided' }],
+      }
+    }
+
+    const result = await payload.delete({
+      collection: slug,
+      depth,
+      overrideAccess: authorizedMCP.overrideAccess,
+      req,
+      where,
+      ...(locale && { locale }),
+      ...(fallbackLocale !== undefined && { fallbackLocale }),
+    })
+    const docs = result.docs || []
+    const errors = result.errors || []
+
+    let responseText = `Document deleted successfully from collection "${slug}"!\nDeleted: ${docs.length} documents\nErrors: ${errors.length}\n---`
+    if (docs.length > 0) {
+      responseText += `\n\nDeleted documents:\n\`\`\`json\n${JSON.stringify(docs)}\n\`\`\``
+    }
+    if (errors.length > 0) {
+      responseText += `\n\nErrors:\n\`\`\`json\n${JSON.stringify(errors)}\n\`\`\``
+    }
+
+    return {
+      content: [{ type: 'text', text: responseText }],
+      doc: { docs, errors } as unknown as Record<string, unknown>,
+    }
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : 'Unknown error'
+    logger.error(`Error deleting document from ${slug}: ${errorMessage}`)
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `Error deleting document from collection "${slug}": ${errorMessage}`,
+        },
+      ],
+    }
+  }
+})