@payloadcms/plugin-mcp 0.0.1-alpha.0

package/src/mcp/tools/auth/resetPassword.ts

@@ -0,0 +1,59 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
+import type { PayloadRequest } from 'payload'
+
+import { toolSchemas } from '../schemas.js'
+
+export const resetPasswordTool = (server: McpServer, req: PayloadRequest, verboseLogs: boolean) => {
+  const tool = async (collection: string, token: string, password: string) => {
+    const payload = req.payload
+
+    if (verboseLogs) {
+      payload.logger.info(`[payload-mcp] Resetting password for user in collection: ${collection}`)
+    }
+
+    try {
+      const result = await payload.resetPassword({
+        collection,
+        data: {
+          password,
+          token,
+        },
+        overrideAccess: true,
+      })
+
+      if (verboseLogs) {
+        payload.logger.info('[payload-mcp] Password reset completed successfully')
+      }
+
+      return {
+        content: [
+          {
+            type: 'text' as const,
+            text: `# Password Reset Successful\n\n**Collection:** ${collection}\n**Token:** ${token}\n\n\`\`\`json\n${JSON.stringify(result, null, 2)}\n\`\`\``,
+          },
+        ],
+      }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : 'Unknown error'
+      payload.logger.error(`[payload-mcp] Error resetting password: ${errorMessage}`)
+
+      return {
+        content: [
+          {
+            type: 'text' as const,
+            text: `❌ **Error resetting password**: ${errorMessage}`,
+          },
+        ],
+      }
+    }
+  }
+
+  server.tool(
+    'resetPassword',
+    toolSchemas.resetPassword.description,
+    toolSchemas.resetPassword.parameters.shape,
+    async ({ collection, password, token }) => {
+      return await tool(collection, token, password)
+    },
+  )
+}

package/src/mcp/tools/auth/unlock.ts

@@ -0,0 +1,62 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
+import type { PayloadRequest } from 'payload'
+
+import { toolSchemas } from '../schemas.js'
+
+export const unlockTool = (server: McpServer, req: PayloadRequest, verboseLogs: boolean) => {
+  const tool = async (collection: string, email: string) => {
+    const payload = req.payload
+
+    if (verboseLogs) {
+      payload.logger.info(
+        `[payload-mcp] Unlocking user account for user: ${email} in collection: ${collection}`,
+      )
+    }
+
+    try {
+      const result = await payload.unlock({
+        collection,
+        data: {
+          email,
+        },
+        overrideAccess: true,
+      })
+
+      if (verboseLogs) {
+        payload.logger.info(`[payload-mcp] User account unlocked successfully for user: ${email}`)
+      }
+
+      return {
+        content: [
+          {
+            type: 'text' as const,
+            text: `# User Account Unlocked\n\n**User:** ${email}\n**Collection:** ${collection}\n\n\`\`\`json\n${JSON.stringify(result, null, 2)}\n\`\`\``,
+          },
+        ],
+      }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : 'Unknown error'
+      payload.logger.error(
+        `[payload-mcp] Error unlocking user account for user ${email}: ${errorMessage}`,
+      )
+
+      return {
+        content: [
+          {
+            type: 'text' as const,
+            text: `❌ **Error unlocking user account for user "${email}"**: ${errorMessage}`,
+          },
+        ],
+      }
+    }
+  }
+
+  server.tool(
+    'unlock',
+    toolSchemas.unlock.description,
+    toolSchemas.unlock.parameters.shape,
+    async ({ collection, email }) => {
+      return await tool(collection, email)
+    },
+  )
+}

package/src/mcp/tools/auth/verify.ts

@@ -0,0 +1,55 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
+import type { PayloadRequest } from 'payload'
+
+import { toolSchemas } from '../schemas.js'
+
+export const verifyTool = (server: McpServer, req: PayloadRequest, verboseLogs: boolean) => {
+  const tool = async (collection: string, token: string) => {
+    const payload = req.payload
+
+    if (verboseLogs) {
+      payload.logger.info(`[payload-mcp] Verifying user account for collection: ${collection}`)
+    }
+
+    try {
+      const result = await payload.verifyEmail({
+        collection,
+        token,
+      })
+
+      if (verboseLogs) {
+        payload.logger.info('[payload-mcp] Email verification completed successfully')
+      }
+
+      return {
+        content: [
+          {
+            type: 'text' as const,
+            text: `# Email Verification Successful\n\n**Collection:** ${collection}\n**Token:** ${token}\n**Result:** ${result ? 'Success' : 'Failed'}`,
+          },
+        ],
+      }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : 'Unknown error'
+      payload.logger.error(`[payload-mcp] Error verifying email: ${errorMessage}`)
+
+      return {
+        content: [
+          {
+            type: 'text' as const,
+            text: `❌ **Error verifying email**: ${errorMessage}`,
+          },
+        ],
+      }
+    }
+  }
+
+  server.tool(
+    'verify',
+    toolSchemas.verify.description,
+    toolSchemas.verify.parameters.shape,
+    async ({ collection, token }) => {
+      return await tool(collection, token)
+    },
+  )
+}

package/src/mcp/tools/collection/create.ts

@@ -0,0 +1,236 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
+import type { PayloadRequest } from 'payload'
+
+import { writeFileSync } from 'fs'
+import { join } from 'path'
+
+import { validateCollectionFile } from '../../helpers/fileValidation.js'
+import { toolSchemas } from '../schemas.js'
+
+export const createCollection = async (
+  req: PayloadRequest,
+  verboseLogs: boolean,
+  collectionsDirPath: string,
+  configFilePath: string,
+  collectionName: string,
+  collectionDescription: string | undefined,
+  fields: any[],
+  hasUpload: boolean | undefined,
+) => {
+  const payload = req.payload
+  if (verboseLogs) {
+    payload.logger.info(
+      `[payload-mcp] Creating collection: ${collectionName} with ${fields.length} fields`,
+    )
+  }
+
+  const capitalizedName = collectionName.charAt(0).toUpperCase() + collectionName.slice(1)
+  const slug = collectionName
+    .replace(/([A-Z])/g, '-$1')
+    .toLowerCase()
+    .replace(/^-/, '')
+
+  if (verboseLogs) {
+    payload.logger.info(`[payload-mcp] Generated slug: ${slug} for collection: ${collectionName}`)
+  }
+
+  // Generate TypeScript field definitions more systematically
+  const generateFieldDefinition = (field: any) => {
+    const fieldConfig = []
+    fieldConfig.push(`    {`)
+    fieldConfig.push(`      name: '${field.name}',`)
+    fieldConfig.push(`      type: '${field.type}',`)
+
+    if (field.required) {
+      fieldConfig.push(`      required: true,`)
+    }
+
+    if (field.description) {
+      fieldConfig.push(`      admin: {`)
+      fieldConfig.push(`        description: '${field.description}',`)
+      fieldConfig.push(`      },`)
+    }
+
+    if (field.options && field.type === 'select') {
+      fieldConfig.push(`      options: [`)
+      field.options.forEach((option: { label: string; value: string }) => {
+        fieldConfig.push(`        { label: '${option.label}', value: '${option.value}' },`)
+      })
+      fieldConfig.push(`      ],`)
+    }
+
+    fieldConfig.push(`    },`)
+    return fieldConfig.join('\n')
+  }
+
+  const fieldDefinitions = fields.map(generateFieldDefinition).join('\n')
+
+  // Generate collection file content
+  const collectionContent = `import type { CollectionConfig } from 'payload'
+
+export const ${capitalizedName}: CollectionConfig = {
+  slug: '${slug}',${
+    collectionDescription
+      ? `
+  admin: {
+    description: '${collectionDescription}',
+  },`
+      : ''
+  }${
+    hasUpload
+      ? `
+  upload: true,`
+      : ''
+  }
+  fields: [
+${fieldDefinitions}
+  ],
+}
+`
+
+  try {
+    // Validate the collection name and path
+    const fileName = `${capitalizedName}.ts`
+    const filePath = join(collectionsDirPath, fileName)
+
+    // Security check: ensure we're working with the collections directory
+    if (!filePath.startsWith(collectionsDirPath)) {
+      payload.logger.error(`[payload-mcp] Invalid collection path attempted: ${filePath}`)
+      return {
+        content: [
+          {
+            type: 'text' as const,
+            text: '❌ **Error**: Invalid collection path',
+          },
+        ],
+      }
+    }
+
+    // Check if file already exists
+    try {
+      const fs = await import('fs')
+      if (fs.existsSync(filePath)) {
+        return {
+          content: [
+            {
+              type: 'text' as const,
+              text: `❌ **Error**: Collection file already exists: ${fileName}`,
+            },
+          ],
+        }
+      }
+    } catch (_ignore) {
+      // File doesn't exist, which is what we want
+    }
+
+    // Write the collection file
+    writeFileSync(filePath, collectionContent, 'utf8')
+    if (verboseLogs) {
+      payload.logger.info(`[payload-mcp] Successfully created collection file: ${filePath}`)
+    }
+
+    // Validate the generated file
+    const validationResult = await validateCollectionFile(fileName)
+    if (validationResult.error) {
+      return {
+        content: [
+          {
+            type: 'text' as const,
+            text: `❌ **Error**: Generated collection has validation issues:\n\n${validationResult.error}`,
+          },
+        ],
+      }
+    }
+
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: `✅ **Collection created successfully!**
+**File**: \`${fileName}\`
+**Collection Config:**
+\`\`\`typescript
+${collectionContent}
+\`\`\``,
+        },
+      ],
+    }
+  } catch (error) {
+    const errorMessage = (error as Error).message
+    payload.logger.error(`[payload-mcp] Error creating collection: ${errorMessage}`)
+
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: `❌ **Error creating collection**: ${errorMessage}`,
+        },
+      ],
+    }
+  }
+}
+
+export const createCollectionTool = (
+  server: McpServer,
+  req: PayloadRequest,
+  verboseLogs: boolean,
+  collectionsDirPath: string,
+  configFilePath: string,
+) => {
+  const tool = async (
+    collectionName: string,
+    collectionDescription?: string,
+    fields: any[] = [],
+    hasUpload?: boolean,
+  ) => {
+    const payload = req.payload
+
+    if (verboseLogs) {
+      payload.logger.info(
+        `[payload-mcp] Creating collection: ${collectionName}, fields: ${fields.length}, upload: ${hasUpload}`,
+      )
+    }
+
+    try {
+      const result = await createCollection(
+        req,
+        verboseLogs,
+        collectionsDirPath,
+        configFilePath,
+        collectionName,
+        collectionDescription,
+        fields,
+        hasUpload,
+      )
+
+      if (verboseLogs) {
+        payload.logger.info(`[payload-mcp] Collection creation completed for: ${collectionName}`)
+      }
+
+      return result
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : 'Unknown error'
+      payload.logger.error(
+        `[payload-mcp] Error creating collection ${collectionName}: ${errorMessage}`,
+      )
+
+      return {
+        content: [
+          {
+            type: 'text' as const,
+            text: `Error creating collection "${collectionName}": ${errorMessage}`,
+          },
+        ],
+      }
+    }
+  }
+
+  server.tool(
+    'createCollection',
+    toolSchemas.createCollection.description,
+    toolSchemas.createCollection.parameters.shape,
+    async ({ collectionDescription, collectionName, fields, hasUpload }) => {
+      return await tool(collectionName, collectionDescription, fields, hasUpload)
+    },
+  )
+}

package/src/mcp/tools/collection/delete.ts

@@ -0,0 +1,227 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
+import type { PayloadRequest } from 'payload'
+
+import { readFileSync, unlinkSync, writeFileSync } from 'fs'
+import { join } from 'path'
+
+import { toolSchemas } from '../schemas.js'
+
+// Helper function for removing collection from config
+const removeCollectionFromConfig = (configContent: string, collectionName: string): string => {
+  // Simple implementation - find and remove the collection import and reference
+  let updatedContent = configContent
+
+  // Remove import statement
+  const importRegex = new RegExp(
+    `import\\s*{\\s*${collectionName}\\s*}\\s*from\\s*['"]\\./collections/${collectionName}['"];?\\s*\\n?`,
+    'g',
+  )
+  updatedContent = updatedContent.replace(importRegex, '')
+
+  // Remove from collections array
+  const collectionsRegex = new RegExp(`\\s*${collectionName},?\\s*`, 'g')
+  updatedContent = updatedContent.replace(collectionsRegex, '')
+
+  return updatedContent
+}
+
+export const deleteCollection = (
+  req: PayloadRequest,
+  verboseLogs: boolean,
+  collectionsDirPath: string,
+  configFilePath: string,
+  collectionName: string,
+  confirmDeletion: boolean,
+  updateConfig: boolean,
+) => {
+  const payload = req.payload
+
+  if (verboseLogs) {
+    payload.logger.info(`[payload-mcp] Attempting to delete collection: ${collectionName}`)
+  }
+
+  if (!confirmDeletion) {
+    payload.logger.warn(`[payload-mcp] Deletion cancelled for collection: ${collectionName}`)
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: `❌ **Deletion cancelled**. Set confirmDeletion to true to proceed with deleting collection "${collectionName}".`,
+        },
+      ],
+    }
+  }
+
+  const capitalizedName = collectionName.charAt(0).toUpperCase() + collectionName.slice(1)
+  const collectionFilePath = join(collectionsDirPath, `${capitalizedName}.ts`)
+
+  // Security check: ensure we're working with the collections directory
+  if (!collectionFilePath.startsWith(collectionsDirPath)) {
+    payload.logger.error(`[payload-mcp] Invalid collection path attempted: ${collectionFilePath}`)
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: '❌ **Error**: Invalid collection path',
+        },
+      ],
+    }
+  }
+
+  try {
+    // Check if collection file exists
+    let fileExists = false
+    try {
+      readFileSync(collectionFilePath, 'utf8')
+      fileExists = true
+    } catch {
+      payload.logger.warn(`[payload-mcp] Collection file does not exist: ${collectionFilePath}`)
+    }
+
+    // Read current config if we need to update it
+    let configContent = ''
+    let configExists = false
+    if (updateConfig) {
+      try {
+        configContent = readFileSync(configFilePath, 'utf8')
+        configExists = true
+      } catch {
+        payload.logger.warn(`[payload-mcp] Config file does not exist: ${configFilePath}`)
+      }
+    }
+
+    let responseText = ''
+    let operationsPerformed = 0
+
+    // Delete the collection file
+    if (fileExists) {
+      try {
+        unlinkSync(collectionFilePath)
+        if (verboseLogs) {
+          payload.logger.info(
+            `[payload-mcp] Successfully deleted collection file: ${collectionFilePath}`,
+          )
+        }
+        responseText += `✅ Deleted collection file: \`${capitalizedName}.ts\`\n`
+        operationsPerformed++
+      } catch (error) {
+        const errorMessage = (error as Error).message
+        payload.logger.error(`[payload-mcp] Error deleting collection file: ${errorMessage}`)
+        responseText += `❌ Error deleting collection file: ${errorMessage}\n`
+      }
+    } else {
+      responseText += `⚠️ Collection file not found: \`${capitalizedName}.ts\`\n`
+    }
+
+    // Update the config file if requested and it exists
+    if (updateConfig && configExists) {
+      try {
+        const updatedConfigContent = removeCollectionFromConfig(configContent, capitalizedName)
+        writeFileSync(configFilePath, updatedConfigContent, 'utf8')
+        if (verboseLogs) {
+          payload.logger.info(`[payload-mcp] Successfully updated config file: ${configFilePath}`)
+        }
+        responseText += `✅ Updated payload.config.ts to remove collection reference\n`
+        operationsPerformed++
+      } catch (error) {
+        const errorMessage = (error as Error).message
+        payload.logger.error(`[payload-mcp] Error updating config file: ${errorMessage}`)
+        responseText += `❌ Error updating config file: ${errorMessage}\n`
+      }
+    } else if (updateConfig && !configExists) {
+      responseText += `⚠️ Config file not found: payload.config.ts\n`
+    }
+
+    // Summary
+    if (operationsPerformed > 0) {
+      responseText += `\n✅ **Collection deletion completed!**`
+    } else {
+      responseText += `\n⚠️ **No operations performed**
+
+The collection file may not have existed or there were errors during deletion.`
+    }
+
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: responseText,
+        },
+      ],
+    }
+  } catch (error) {
+    const errorMessage = (error as Error).message
+    payload.logger.error(`[payload-mcp] Error during collection deletion: ${errorMessage}`)
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: `❌ **Error during collection deletion**: ${errorMessage}`,
+        },
+      ],
+    }
+  }
+}
+
+export const deleteCollectionTool = (
+  server: McpServer,
+  req: PayloadRequest,
+  verboseLogs: boolean,
+  collectionsDirPath: string,
+  configFilePath: string,
+) => {
+  const tool = (
+    collectionName: string,
+    confirmDeletion: boolean,
+    updateConfig: boolean = false,
+  ) => {
+    const payload = req.payload
+
+    if (verboseLogs) {
+      payload.logger.info(
+        `[payload-mcp] Deleting collection: ${collectionName}, confirmDeletion: ${confirmDeletion}, updateConfig: ${updateConfig}`,
+      )
+    }
+
+    try {
+      const result = deleteCollection(
+        req,
+        verboseLogs,
+        collectionsDirPath,
+        configFilePath,
+        collectionName,
+        confirmDeletion,
+        updateConfig,
+      )
+
+      if (verboseLogs) {
+        payload.logger.info(`[payload-mcp] Collection deletion completed for: ${collectionName}`)
+      }
+
+      return result
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : 'Unknown error'
+      payload.logger.error(
+        `[payload-mcp] Error deleting collection ${collectionName}: ${errorMessage}`,
+      )
+
+      return {
+        content: [
+          {
+            type: 'text' as const,
+            text: `Error deleting collection "${collectionName}": ${errorMessage}`,
+          },
+        ],
+      }
+    }
+  }
+
+  server.tool(
+    'deleteCollection',
+    toolSchemas.deleteCollection.description,
+    toolSchemas.deleteCollection.parameters.shape,
+    ({ collectionName, confirmDeletion, updateConfig }) => {
+      return tool(collectionName, confirmDeletion, updateConfig)
+    },
+  )
+}