@payloadcms/plugin-mcp 4.0.0-internal.fa345ef → 4.0.0-internal.fec2230

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

@@ -1,24 +1,23 @@
-import type { PopulateType, SelectType } from 'payload'
-
-import { z } from 'zod'
+import {
+  duplicateDocumentInputSchema,
+  getCollectionVirtualFieldNames,
+  parseDocumentID,
+  stripVirtualFields,
+  transformPointDataToPayload,
+  validateCollectionData,
+} from 'payload'
 
 import { defaultAccess } from '../../../defaultAccess.js'
 import { defineCollectionTool } from '../../../defineTool.js'
 import { getLogger } from '../../../utils/getLogger.js'
-import {
-  getCollectionVirtualFieldNames,
-  stripVirtualFields,
-} from '../../../utils/getVirtualFieldNames.js'
-import { localAPIDefaults } from '../../../utils/localAPIDefaults.js'
-import { transformPointDataToPayload } from '../../../utils/transformPointDataToPayload.js'
-import { formatCollectionError } from './formatCollectionError.js'
+import { formatEntityError } from '../formatEntityError.js'
 
 const DEFAULT_DESCRIPTION =
   'Duplicate a document in any collection by passing the collection slug and source document ID.'
 
 export const duplicateDocumentTool = defineCollectionTool({
   access: (args) =>
-    defaultAccess(args) && Boolean(args.permissions?.collections?.[args.collectionSlug]?.create),
+    defaultAccess(args) && Boolean(args.permissions?.collections?.[args.slug]?.create),
   annotations: {
     destructiveHint: false,
     idempotentHint: false,
@@ -27,109 +26,59 @@ export const duplicateDocumentTool = defineCollectionTool({
     title: 'Duplicate Document',
   },
   description: DEFAULT_DESCRIPTION,
-  input: z.object({
-    id: z.union([z.string(), z.number()]).describe('The ID of the document to duplicate'),
-    data: z
-      .record(z.string(), z.unknown())
-      .describe('Optional: fields to override on the duplicated document')
-      .optional(),
-    depth: z
-      .number()
-      .int()
-      .min(0)
-      .max(10)
-      .describe('How many levels deep to populate relationships in response')
-      .optional()
-      .default(0),
-    draft: z
-      .boolean()
-      .describe('Whether to create the duplicate as a draft')
-      .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 duplicate in (e.g., "en", "es"). Defaults to the default locale',
-      )
-      .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(),
-    selectedLocales: z
-      .array(z.string())
-      .describe('Optional: localized field locales to include in the duplicated document')
-      .optional(),
-    showHiddenFields: z
-      .boolean()
-      .describe('Optional: include hidden fields in the duplicated document response')
-      .optional(),
-  }),
-}).handler(async ({ authorizedMCP, collectionSlug, input, req }) => {
+  input: duplicateDocumentInputSchema,
+}).handler(async ({ slug, authorizedMCP, input, req }) => {
   const payload = req.payload
   const logger = getLogger({ payload })
-  const {
-    id,
-    data,
-    depth,
-    draft,
-    fallbackLocale,
-    locale,
-    populate,
-    select,
-    selectedLocales,
-    showHiddenFields,
-  } = input
+  const { id, data, depth, draft, fallbackLocale, locale, populate, select, selectedLocales } =
+    input
 
-  logger.info(`Duplicating document in collection: ${collectionSlug} with ID: ${id}`)
+  logger.info(`Duplicating document in collection: ${slug} with ID: ${id}`)
 
   try {
-    const virtualFieldNames = getCollectionVirtualFieldNames(payload.config, collectionSlug)
+    const virtualFieldNames = getCollectionVirtualFieldNames(payload.config, slug)
     const inputData = data ? stripVirtualFields(data, virtualFieldNames) : undefined
+
+    if (inputData) {
+      validateCollectionData({
+        slug,
+        data: inputData,
+        partial: true,
+        req,
+      })
+    }
+
     const parsedData = inputData ? transformPointDataToPayload(inputData) : undefined
 
     const result = await payload.duplicate({
-      id,
-      collection: collectionSlug,
+      id: parseDocumentID({ id, collectionSlug: slug, payload }),
+      collection: slug,
       depth,
       draft,
+      overrideAccess: authorizedMCP.overrideAccess,
       req,
-      ...localAPIDefaults(authorizedMCP),
       ...(parsedData ? { data: parsedData } : {}),
       ...(locale ? { locale } : {}),
-      ...(fallbackLocale ? { fallbackLocale } : {}),
-      ...(populate ? { populate: populate as PopulateType } : {}),
-      ...(select ? { select: select as SelectType } : {}),
+      ...(fallbackLocale !== undefined ? { fallbackLocale } : {}),
+      ...(populate ? { populate } : {}),
+      ...(select ? { select } : {}),
       ...(selectedLocales ? { selectedLocales } : {}),
-      ...(showHiddenFields !== undefined ? { showHiddenFields } : {}),
     })
 
-    logger.info(`Successfully duplicated document in ${collectionSlug} from ID: ${id}`)
+    logger.info(`Successfully duplicated document in ${slug} from ID: ${id}`)
 
     return {
       content: [
         {
           type: 'text',
-          text: `Document duplicated successfully in collection "${collectionSlug}"!\nDuplicated document:\n\`\`\`json\n${JSON.stringify(result)}\n\`\`\``,
+          text: `Document duplicated successfully in collection "${slug}"!\nDuplicated document:\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 duplicating document in ${collectionSlug}: ${errorMessage}`)
-    return formatCollectionError({ action: 'duplicating', collectionSlug, error, req })
+    logger.error(`Error duplicating document in ${slug}: ${errorMessage}`)
+    return formatEntityError({ slug, action: 'duplicating', entity: 'collection', error, req })
   }
 })

package/src/mcp/builtin/collections/fileInput.spec.ts

@@ -0,0 +1,93 @@
+import type { PayloadRequest } from 'payload'
+
+import { describe, expect, it } from 'vitest'
+
+import { fileInputSchema, resolveFile } from './fileInput.js'
+
+describe('MCP file input', () => {
+  it('should reject malformed MIME types', () => {
+    const result = fileInputSchema.safeParse({
+      data: 'aGVsbG8=',
+      mimeType: 'text/plain\r\nx-test: value',
+      name: 'hello.txt',
+      source: 'base64',
+    })
+
+    expect(result.success).toBe(false)
+  })
+
+  it('should accept a prepared upload', () => {
+    const result = fileInputSchema.safeParse({
+      file: {
+        filename: 'image.png',
+        mimeType: 'image/png',
+        size: 123,
+        uploadReference: { uploadId: 'upload-id' },
+      },
+      source: 'uploadReference',
+    })
+
+    expect(result.success).toBe(true)
+  })
+
+  it('should reject oversized base64 files', async () => {
+    const req = createRequest({ maxFileSize: 4 })
+
+    await expect(
+      resolveFile({
+        slug: 'media',
+        input: {
+          data: Buffer.from('hello').toString('base64'),
+          mimeType: 'text/plain',
+          name: 'hello.txt',
+          source: 'base64',
+        },
+        req,
+      }),
+    ).rejects.toThrow('File exceeds the 4 byte upload limit.')
+  })
+
+  it('should reject URLs outside the collection allowlist', async () => {
+    const req = createRequest({
+      allowList: [{ hostname: 'assets.example.com', protocol: 'https' }],
+    })
+
+    await expect(
+      resolveFile({
+        slug: 'media',
+        input: {
+          source: 'externalURL',
+          url: 'https://example.com/image.png',
+        },
+        req,
+      }),
+    ).rejects.toThrow('The provided file URL is not allowed.')
+  })
+})
+
+function createRequest({
+  allowList,
+  maxFileSize,
+}: {
+  allowList?: Array<{ hostname: string; protocol: 'http' | 'https' }>
+  maxFileSize?: number
+}): PayloadRequest {
+  return {
+    payload: {
+      collections: {
+        media: {
+          config: {
+            upload: allowList ? { pasteURL: { allowList } } : {},
+          },
+        },
+      },
+      config: {
+        upload: {
+          limits: {
+            fileSize: maxFileSize,
+          },
+        },
+      },
+    },
+  } as unknown as PayloadRequest
+}

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

@@ -0,0 +1,127 @@
+import type { CollectionSlug, File, PayloadRequest } from 'payload'
+
+import { APIError, z } from 'payload'
+import {
+  externalURLInputSchema,
+  getFileFromUploadInstructions,
+  resolveURLUploadInput,
+} from 'payload/internal'
+import { sanitizeFilename } from 'payload/shared'
+
+const mimeTypeSchema = z
+  .string()
+  .check(
+    z.regex(
+      /^[!#$%&'*+.^`|~\w-]+\/[!#$%&'*+.^`|~\w-]+$/,
+      'MIME type must use the type/subtype format',
+    ),
+  )
+
+const uploadFileSchema = z.strictObject({
+  filename: z.string(),
+  mimeType: z.string(),
+  size: z.int().check(z.nonnegative()),
+  uploadReference: z.record(z.string(), z.unknown()),
+})
+
+export const fileInputSchema = z
+  .discriminatedUnion('source', [
+    z.strictObject({
+      name: z.string().check(z.minLength(1), z.describe('The file name, including its extension.')),
+      data: z
+        .string()
+        .check(z.describe('The base64-encoded file bytes, without a data URL prefix.')),
+      mimeType: mimeTypeSchema.check(z.describe('The file MIME type, for example image/png.')),
+      source: z.literal('base64'),
+    }),
+    externalURLInputSchema,
+    z.strictObject({
+      file: uploadFileSchema.check(z.describe('getUploadInstructions file field post-upload.')),
+      source: z.literal('uploadReference'),
+    }),
+  ])
+  .check(
+    z.describe(
+      'A file for an upload collection. Prefer uploadReference after its upload succeeds; use base64 only for small local files or externalURL for an online file.',
+    ),
+  )
+
+type FileInput = z.infer<typeof fileInputSchema>
+
+export async function resolveFile({
+  slug,
+  input,
+  req,
+}: {
+  input?: FileInput
+  req: PayloadRequest
+  slug: CollectionSlug
+}): Promise<File | undefined> {
+  if (!input) {
+    return undefined
+  }
+
+  if (input.source === 'uploadReference') {
+    try {
+      return await getFileFromUploadInstructions({ collectionSlug: slug, file: input.file, req })
+    } catch (error) {
+      if (error instanceof Error && error.message === 'Staged upload was not found.') {
+        throw new APIError(
+          'Staged upload not found. Complete the upload action first, or use base64 for small local files.',
+          400,
+        )
+      }
+      throw error
+    }
+  }
+
+  if (input.source === 'externalURL') {
+    return resolveURLUploadInput({ slug, input, req })
+  }
+
+  const uploadConfig = req.payload.collections[slug]?.config.upload
+
+  if (!uploadConfig) {
+    throw new APIError(`Collection "${slug}" does not support file uploads.`, 400)
+  }
+
+  const maxFileSize = req.payload.config.upload.limits?.fileSize
+  const data = decodeBase64({ maxFileSize, value: input.data })
+  const file: File = {
+    name: sanitizeFilename(input.name),
+    data,
+    mimetype: input.mimeType,
+    size: data.length,
+  }
+
+  if (maxFileSize !== undefined && Number.isFinite(maxFileSize) && file.size > maxFileSize) {
+    throw new APIError(`File exceeds the ${maxFileSize} byte upload limit.`, 400)
+  }
+
+  return file
+}
+
+function decodeBase64({ maxFileSize, value }: { maxFileSize?: number; value: string }): Buffer {
+  const normalized = value.replace(/\s/g, '')
+
+  if (!/^[a-z0-9+/]*={0,2}$/i.test(normalized) || normalized.length % 4 === 1) {
+    throw new APIError('File data must be valid base64.', 400)
+  }
+
+  if (maxFileSize !== undefined && Number.isFinite(maxFileSize)) {
+    const paddingLength = normalized.endsWith('==') ? 2 : normalized.endsWith('=') ? 1 : 0
+    const decodedSize = Math.floor((normalized.length * 3) / 4) - paddingLength
+
+    if (decodedSize > maxFileSize) {
+      throw new APIError(`File exceeds the ${maxFileSize} byte upload limit.`, 400)
+    }
+  }
+
+  const data = Buffer.from(normalized, 'base64')
+
+  if (data.toString('base64').replace(/=+$/, '') !== normalized.replace(/=+$/, '')) {
+    throw new APIError('File data must be valid base64.', 400)
+  }
+
+  return data
+}

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

@@ -1,19 +1,15 @@
-import type { PopulateType } from 'payload'
-
-import { z } from 'zod'
+import { findDistinctInputSchema } from 'payload'
 
 import { defaultAccess } from '../../../defaultAccess.js'
 import { defineCollectionTool } from '../../../defineTool.js'
 import { getLogger } from '../../../utils/getLogger.js'
-import { localAPIDefaults } from '../../../utils/localAPIDefaults.js'
-import { whereSchema } from '../../../utils/whereSchema.js'
 
 const DEFAULT_DESCRIPTION =
   'Find distinct values for a field in any collection by passing the collection slug and field path.'
 
 export const findDistinctTool = defineCollectionTool({
   access: (args) =>
-    defaultAccess(args) && Boolean(args.permissions?.collections?.[args.collectionSlug]?.read),
+    defaultAccess(args) && Boolean(args.permissions?.collections?.[args.slug]?.read),
   annotations: {
     destructiveHint: false,
     idempotentHint: true,
@@ -22,73 +18,25 @@ export const findDistinctTool = defineCollectionTool({
     title: 'Find Distinct',
   },
   description: DEFAULT_DESCRIPTION,
-  input: z.object({
-    depth: z
-      .number()
-      .int()
-      .min(0)
-      .max(10)
-      .describe('How many levels deep to populate relationships in distinct values')
-      .optional()
-      .default(0),
-    field: z.string().describe('The field path to get distinct values for'),
-    limit: z
-      .number()
-      .int()
-      .min(1)
-      .max(100)
-      .describe('Maximum number of distinct values to return (max: 100)')
-      .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(),
-    page: z.number().int().min(1).describe('Page number for pagination').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 distinct query')
-      .optional(),
-    sort: z
-      .string()
-      .describe('Field to sort by (e.g., "createdAt", "-updatedAt" for descending)')
-      .optional(),
-    trash: z
-      .boolean()
-      .describe('Optional: include soft-deleted documents when trash is enabled on the collection')
-      .optional(),
-    where: whereSchema
-      .describe(
-        'Optional: where clause for filtering. Use field names with Payload operators, and/or arrays for grouping. Example: {"title":{"contains":"test"}}',
-      )
-      .optional(),
-  }),
-}).handler(async ({ authorizedMCP, collectionSlug, input, req }) => {
+  input: findDistinctInputSchema,
+}).handler(async ({ slug, authorizedMCP, input, req }) => {
   const payload = req.payload
   const logger = getLogger({ payload })
-  const { depth, field, limit, locale, page, populate, showHiddenFields, sort, trash, where } = input
+  const { depth, field, limit, locale, page, populate, sort, trash, where } = input
 
-  logger.info(`Finding distinct values in collection: ${collectionSlug}, field: ${field}`)
+  logger.info(`Finding distinct values in collection: ${slug}, field: ${field}`)
 
   try {
     const result = await payload.findDistinct({
-      collection: collectionSlug,
+      collection: slug,
       depth,
       field,
+      overrideAccess: authorizedMCP.overrideAccess,
       req,
-      ...localAPIDefaults(authorizedMCP),
       ...(limit ? { limit } : {}),
       ...(locale ? { locale } : {}),
       ...(page ? { page } : {}),
-      ...(populate ? { populate: populate as PopulateType } : {}),
-      ...(showHiddenFields !== undefined ? { showHiddenFields } : {}),
+      ...(populate ? { populate } : {}),
       ...(sort ? { sort } : {}),
       ...(trash !== undefined ? { trash } : {}),
       ...(where ? { where } : {}),
@@ -98,19 +46,19 @@ export const findDistinctTool = defineCollectionTool({
       content: [
         {
           type: 'text',
-          text: `Distinct values for "${field}" in collection "${collectionSlug}":\n\`\`\`json\n${JSON.stringify(result)}\n\`\`\``,
+          text: `Distinct values for "${field}" in collection "${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 distinct values in ${collectionSlug}: ${errorMessage}`)
+    logger.error(`Error finding distinct values in ${slug}: ${errorMessage}`)
     return {
       content: [
         {
           type: 'text',
-          text: `❌ **Error finding distinct values in collection "${collectionSlug}":** ${errorMessage}`,
+          text: `❌ **Error finding distinct values in collection "${slug}":** ${errorMessage}`,
         },
       ],
       isError: true,