@payloadcms/plugin-mcp 4.0.0-internal.5b1e7cd → 4.0.0-internal.5f0cd13

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

@@ -1,64 +0,0 @@
-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)}\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.registerTool(
-    'unlock',
-    {
-      description: toolSchemas.unlock.description,
-      inputSchema: toolSchemas.unlock.parameters.shape,
-    },
-    async ({ collection, email }) => {
-      return await tool(collection, email)
-    },
-  )
-}

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

@@ -1,57 +0,0 @@
-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.registerTool(
-    'verify',
-    {
-      description: toolSchemas.verify.description,
-      inputSchema: toolSchemas.verify.parameters.shape,
-    },
-    async ({ collection, token }) => {
-      return await tool(collection, token)
-    },
-  )
-}

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

@@ -1,210 +0,0 @@
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
-import type { PayloadRequest } from 'payload'
-
-import { writeFileSync } from 'fs'
-import { join } from 'path'
-
-import { generateFieldDefinitionString } from '../../helpers/fields.js'
-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}`)
-  }
-
-  const fieldDefinitions = fields.map(generateFieldDefinitionString).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.registerTool(
-    'createCollection',
-    {
-      description: toolSchemas.createCollection.description,
-      inputSchema: toolSchemas.createCollection.parameters.shape,
-    },
-    async ({ collectionDescription, collectionName, fields, hasUpload }) => {
-      return await tool(collectionName, collectionDescription, fields, hasUpload)
-    },
-  )
-}

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

@@ -1,211 +0,0 @@
-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 { removeCollectionFromConfig } from '../../helpers/config.js'
-import { toolSchemas } from '../schemas.js'
-
-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.registerTool(
-    'deleteCollection',
-    {
-      description: toolSchemas.deleteCollection.description,
-      inputSchema: toolSchemas.deleteCollection.parameters.shape,
-    },
-    ({ collectionName, confirmDeletion, updateConfig }) => {
-      return tool(collectionName, confirmDeletion, updateConfig)
-    },
-  )
-}