@payloadcms/plugin-mcp 0.0.1-alpha.0

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

@@ -0,0 +1,222 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
+import type { PayloadRequest } from 'payload'
+
+import { readdirSync, readFileSync, statSync } from 'fs'
+import { extname, join } from 'path'
+
+import { toolSchemas } from '../schemas.js'
+
+export const readCollections = (
+  req: PayloadRequest,
+  verboseLogs: boolean,
+  collectionsDirPath: string,
+  collectionName?: string,
+  includeContent: boolean = false,
+  includeCount: boolean = false,
+) => {
+  const payload = req.payload
+
+  if (verboseLogs) {
+    payload.logger.info(
+      `[payload-mcp] Reading collections${collectionName ? ` for: ${collectionName}` : ''}, includeContent: ${includeContent}, includeCount: ${includeCount}`,
+    )
+  }
+
+  try {
+    // Read specific Collection (optional)
+    if (collectionName) {
+      const fileName = `${collectionName.charAt(0).toUpperCase() + collectionName.slice(1)}.ts`
+      const filePath = join(collectionsDirPath, fileName)
+
+      if (!filePath.startsWith(collectionsDirPath)) {
+        payload.logger.error(`[payload-mcp] Invalid collection name attempted: ${collectionName}`)
+        return {
+          content: [{ type: 'text' as const, text: 'Error: Invalid collection name' }],
+        }
+      }
+
+      try {
+        const content = readFileSync(filePath, 'utf8')
+        if (verboseLogs) {
+          payload.logger.info(`[payload-mcp] Successfully read collection: ${collectionName}`)
+        }
+
+        return {
+          content: [
+            {
+              type: 'text' as const,
+              text: `Collection: ${collectionName}
+File: ${fileName}
+---
+${content}`,
+            },
+          ],
+        }
+      } catch (_error) {
+        payload.logger.warn(`[payload-mcp] Collection not found: ${collectionName}`)
+        return {
+          content: [
+            {
+              type: 'text' as const,
+              text: `Error: Collection '${collectionName}' not found`,
+            },
+          ],
+        }
+      }
+    }
+
+    // Read all Collections
+    const files = readdirSync(collectionsDirPath)
+      .filter((file) => extname(file) === '.ts')
+      .sort()
+
+    if (verboseLogs) {
+      payload.logger.info(`[payload-mcp] Found ${files.length} collection files in directory`)
+    }
+
+    if (files.length === 0) {
+      payload.logger.warn('[payload-mcp] No collection files found in src/collections directory')
+      return {
+        content: [
+          {
+            type: 'text' as const,
+            text: 'No collection files found in src/collections directory',
+          },
+        ],
+      }
+    }
+
+    const results = []
+
+    // Build complete table as a single markdown string
+    let tableContent = `Found ${files.length} collection file(s):\n\n`
+
+    // Build table header
+    let tableHeader = '| Collection | File | Size | Modified'
+    let tableSeparator = '|------------|------|------|----------'
+
+    if (includeCount) {
+      tableHeader += ' | Documents'
+      tableSeparator += ' |----------'
+    }
+    tableHeader += ' |'
+    tableSeparator += ' |'
+
+    tableContent += tableHeader + '\n'
+    tableContent += tableSeparator + '\n'
+
+    for (const file of files) {
+      const filePath = join(collectionsDirPath, file)
+      const stats = statSync(filePath)
+      const fileSize = stats.size
+      const lastModified = stats.mtime
+
+      const collectionName = file.replace('.ts', '')
+
+      // Build table row
+      let tableRow = `| **${collectionName}** | ${file} | ${fileSize.toLocaleString()} bytes | ${lastModified.toISOString()}`
+
+      // Add document count if requested
+      if (includeCount) {
+        try {
+          // For now, we'll skip document counting since we don't have access to payload instance
+          tableRow += ' | -'
+        } catch (error) {
+          tableRow += ` | Error: ${(error as Error).message}`
+        }
+      }
+      tableRow += ' |'
+
+      tableContent += tableRow + '\n'
+
+      if (includeContent) {
+        try {
+          const content = readFileSync(filePath, 'utf8')
+          tableContent += `\n**${collectionName} Content:**\n\`\`\`typescript\n${content}\n\`\`\`\n\n`
+        } catch (error) {
+          tableContent += `\nError reading content: ${(error as Error).message}\n\n`
+        }
+      }
+    }
+
+    results.push({
+      type: 'text' as const,
+      text: tableContent,
+    })
+
+    return {
+      content: results,
+    }
+  } catch (error) {
+    const errorMessage = (error as Error).message
+    payload.logger.error(`[payload-mcp] Error reading collections: ${errorMessage}`)
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: `❌ **Error reading collections**: ${errorMessage}`,
+        },
+      ],
+    }
+  }
+}
+
+// MCP Server tool registration
+export const findCollectionTool = (
+  server: McpServer,
+  req: PayloadRequest,
+  verboseLogs: boolean,
+  collectionsDirPath: string,
+) => {
+  const tool = (
+    collectionName?: string,
+    includeContent: boolean = false,
+    includeCount: boolean = false,
+  ) => {
+    const payload = req.payload
+
+    if (verboseLogs) {
+      payload.logger.info(
+        `[payload-mcp] Finding collections${collectionName ? ` for: ${collectionName}` : ''}, includeContent: ${includeContent}, includeCount: ${includeCount}`,
+      )
+    }
+
+    try {
+      const result = readCollections(
+        req,
+        verboseLogs,
+        collectionsDirPath,
+        collectionName,
+        includeContent,
+        includeCount,
+      )
+
+      if (verboseLogs) {
+        payload.logger.info(`[payload-mcp] Collection search completed`)
+      }
+
+      return result
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : 'Unknown error'
+      payload.logger.error(`[payload-mcp] Error finding collections: ${errorMessage}`)
+
+      return {
+        content: [
+          {
+            type: 'text' as const,
+            text: `Error finding collections: ${errorMessage}`,
+          },
+        ],
+      }
+    }
+  }
+
+  server.tool(
+    'findCollections',
+    toolSchemas.findCollections.description,
+    toolSchemas.findCollections.parameters.shape,
+    ({ collectionName, includeContent, includeCount }) => {
+      return tool(collectionName, includeContent, includeCount)
+    },
+  )
+}

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

@@ -0,0 +1,288 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
+import type { PayloadRequest } from 'payload'
+
+import { readFileSync, writeFileSync } from 'fs'
+import { join } from 'path'
+
+import {
+  addFieldsToCollection,
+  modifyFieldsInCollection,
+  removeFieldsFromCollection,
+} from '../../helpers/fields.js'
+import { validateCollectionFile } from '../../helpers/fileValidation.js'
+import { toolSchemas } from '../schemas.js'
+
+export const updateCollection = async (
+  req: PayloadRequest,
+  verboseLogs: boolean,
+  collectionsDirPath: string,
+  configFilePath: string,
+  collectionName: string,
+  updateType: string,
+  newFields?: any[],
+  fieldNamesToRemove?: string[],
+  fieldModifications?: any[],
+  configUpdates?: any,
+  newContent?: string,
+) => {
+  const payload = req.payload
+  if (verboseLogs) {
+    payload.logger.info(
+      `[payload-mcp] Updating collection: ${collectionName}, updateType: ${updateType}`,
+    )
+  }
+
+  const capitalizedName = collectionName.charAt(0).toUpperCase() + collectionName.slice(1)
+  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',
+        },
+      ],
+    }
+  }
+
+  try {
+    // Check if collection file exists
+    let currentContent: string
+    try {
+      currentContent = readFileSync(filePath, 'utf8')
+    } catch (_ignore) {
+      return {
+        content: [
+          {
+            type: 'text' as const,
+            text: `❌ **Error**: Collection file not found: ${fileName}`,
+          },
+        ],
+      }
+    }
+
+    let updatedContent: string
+    let updateSummary: string[] = []
+
+    switch (updateType) {
+      case 'add_field':
+        if (!newFields || newFields.length === 0) {
+          return {
+            content: [
+              {
+                type: 'text' as const,
+                text: '❌ **Error**: No fields provided for add_field update type',
+              },
+            ],
+          }
+        }
+        updatedContent = addFieldsToCollection(currentContent, newFields)
+        updateSummary = newFields.map((field: any) => `Added field: ${field.name} (${field.type})`)
+        break
+
+      case 'modify_field':
+        if (!fieldModifications || fieldModifications.length === 0) {
+          return {
+            content: [
+              {
+                type: 'text' as const,
+                text: '❌ **Error**: No field modifications provided for modify_field update type',
+              },
+            ],
+          }
+        }
+        updatedContent = modifyFieldsInCollection(currentContent, fieldModifications)
+        updateSummary = fieldModifications.map((mod: any) => `Modified field: ${mod.fieldName}`)
+        break
+
+      case 'remove_field':
+        if (!fieldNamesToRemove || fieldNamesToRemove.length === 0) {
+          return {
+            content: [
+              {
+                type: 'text' as const,
+                text: '❌ **Error**: No field names provided for remove_field update type',
+              },
+            ],
+          }
+        }
+        updatedContent = removeFieldsFromCollection(currentContent, fieldNamesToRemove)
+        updateSummary = fieldNamesToRemove.map((fieldName: string) => `Removed field: ${fieldName}`)
+        break
+
+      case 'replace_content':
+        if (!newContent) {
+          return {
+            content: [
+              {
+                type: 'text' as const,
+                text: '❌ **Error**: No new content provided for replace_content update type',
+              },
+            ],
+          }
+        }
+        updatedContent = newContent
+        updateSummary = ['Replaced entire collection content']
+        break
+
+      case 'update_config':
+        if (!configUpdates) {
+          return {
+            content: [
+              {
+                type: 'text' as const,
+                text: '❌ **Error**: No config updates provided for update_config update type',
+              },
+            ],
+          }
+        }
+        // For now, we'll use a simple approach since the config helper might not have this functionality
+        updatedContent = currentContent
+        updateSummary = Object.keys(configUpdates).map((key) => `Updated config: ${key}`)
+        break
+
+      default:
+        return {
+          content: [
+            {
+              type: 'text' as const,
+              text: `❌ **Error**: Unknown update type: ${updateType}`,
+            },
+          ],
+        }
+    }
+
+    // Write the updated content back to the file
+    writeFileSync(filePath, updatedContent, 'utf8')
+    if (verboseLogs) {
+      payload.logger.info(`[payload-mcp] Successfully updated collection file: ${filePath}`)
+    }
+
+    // Validate the updated file
+    const validationResult = await validateCollectionFile(fileName)
+    if (validationResult.error) {
+      return {
+        content: [
+          {
+            type: 'text' as const,
+            text: `❌ **Error**: Updated collection has validation issues:\n\n${validationResult.error}`,
+          },
+        ],
+      }
+    }
+
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: `✅ **Collection updated successfully!**
+
+**File**: \`${fileName}\`
+**Update Type**: ${updateType}
+
+**Changes Made**:
+${updateSummary.map((summary) => `- ${summary}`).join('\n')}
+
+**Updated Collection Code:**
+\`\`\`typescript
+${updatedContent}
+\`\`\``,
+        },
+      ],
+    }
+  } catch (error) {
+    const errorMessage = (error as Error).message
+    payload.logger.error(`[payload-mcp] Error updating collection: ${errorMessage}`)
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: `❌ **Error updating collection**: ${errorMessage}`,
+        },
+      ],
+    }
+  }
+}
+
+export const updateCollectionTool = (
+  server: McpServer,
+  req: PayloadRequest,
+  verboseLogs: boolean,
+  collectionsDirPath: string,
+  configFilePath: string,
+) => {
+  const tool = async ({
+    collectionName,
+    configUpdates,
+    fieldModifications,
+    fieldNamesToRemove,
+    newContent,
+    newFields,
+    updateType,
+  }: {
+    collectionName: string
+    configUpdates?: any
+    fieldModifications?: any[]
+    fieldNamesToRemove?: string[]
+    newContent?: string
+    newFields?: any[]
+    updateType: string
+  }) => {
+    const payload = req.payload
+
+    if (verboseLogs) {
+      payload.logger.info(
+        `[payload-mcp] Updating collection: ${collectionName}, updateType: ${updateType}`,
+      )
+    }
+
+    try {
+      const result = await updateCollection(
+        req,
+        verboseLogs,
+        collectionsDirPath,
+        configFilePath,
+        collectionName,
+        updateType,
+        newFields,
+        fieldNamesToRemove,
+        fieldModifications,
+        configUpdates,
+        newContent,
+      )
+
+      if (verboseLogs) {
+        payload.logger.info(`[payload-mcp] Collection update completed for: ${collectionName}`)
+      }
+
+      return result
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : 'Unknown error'
+      payload.logger.error(
+        `[payload-mcp] Error updating collection ${collectionName}: ${errorMessage}`,
+      )
+
+      return {
+        content: [
+          {
+            type: 'text' as const,
+            text: `Error updating collection "${collectionName}": ${errorMessage}`,
+          },
+        ],
+      }
+    }
+  }
+
+  server.tool(
+    'updateCollection',
+    toolSchemas.updateCollection.description,
+    toolSchemas.updateCollection.parameters.shape,
+    async (args) => {
+      return await tool(args)
+    },
+  )
+}

package/src/mcp/tools/config/find.ts

@@ -0,0 +1,126 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
+import type { PayloadRequest } from 'payload'
+
+import { readFileSync, statSync } from 'fs'
+
+import { toolSchemas } from '../schemas.js'
+
+export const readConfigFile = (
+  req: PayloadRequest,
+  verboseLogs: boolean,
+  configFilePath: string,
+  includeMetadata: boolean = false,
+) => {
+  const payload = req.payload
+  if (verboseLogs) {
+    payload.logger.info(`[payload-mcp] Reading config file, includeMetadata: ${includeMetadata}`)
+  }
+
+  try {
+    // Security check: ensure we're working with the specified config file
+    if (!configFilePath.startsWith(process.cwd()) && !configFilePath.startsWith('/')) {
+      payload.logger.error(`[payload-mcp] Invalid config path attempted: ${configFilePath}`)
+      return {
+        content: [
+          {
+            type: 'text' as const,
+            text: '❌ **Error**: Invalid config path',
+          },
+        ],
+      }
+    }
+
+    const content = readFileSync(configFilePath, 'utf8')
+    const stats = statSync(configFilePath)
+
+    if (verboseLogs) {
+      payload.logger.info(`[payload-mcp] Successfully read config file. Size: ${stats.size} bytes`)
+    }
+
+    let responseText = `# Payload Configuration
+
+**File**: \`${configFilePath}\``
+
+    if (includeMetadata) {
+      responseText += `
+**Size**: ${stats.size.toLocaleString()} bytes
+**Modified**: ${stats.mtime.toISOString()}
+**Created**: ${stats.birthtime.toISOString()}`
+    }
+
+    responseText += `
+---
+
+**Configuration Content:**
+\`\`\`typescript
+${content}
+\`\`\``
+
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: responseText,
+        },
+      ],
+    }
+  } catch (error) {
+    const errorMessage = (error as Error).message
+    payload.logger.error(`[payload-mcp] Error reading config file: ${errorMessage}`)
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: `❌ **Error reading config file**: ${errorMessage}`,
+        },
+      ],
+    }
+  }
+}
+
+// MCP Server tool registration
+export const findConfigTool = (
+  server: McpServer,
+  req: PayloadRequest,
+  verboseLogs: boolean,
+  configFilePath: string,
+) => {
+  const tool = (includeMetadata: boolean = false) => {
+    const payload = req.payload
+
+    if (verboseLogs) {
+      payload.logger.info(`[payload-mcp] Finding config, includeMetadata: ${includeMetadata}`)
+    }
+
+    try {
+      const result = readConfigFile(req, verboseLogs, configFilePath, includeMetadata)
+
+      if (verboseLogs) {
+        payload.logger.info(`[payload-mcp] Config search completed`)
+      }
+
+      return result
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : 'Unknown error'
+      payload.logger.error(`[payload-mcp] Error finding config: ${errorMessage}`)
+
+      return {
+        content: [
+          {
+            type: 'text' as const,
+            text: `Error finding config: ${errorMessage}`,
+          },
+        ],
+      }
+    }
+  }
+
+  server.tool(
+    'findConfig',
+    toolSchemas.findConfig.description,
+    toolSchemas.findConfig.parameters.shape,
+    ({ includeMetadata }) => {
+      return tool(includeMetadata)
+    },
+  )
+}