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

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

@@ -1,224 +0,0 @@
-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.registerTool(
-    'findCollections',
-    {
-      description: toolSchemas.findCollections.description,
-      inputSchema: toolSchemas.findCollections.parameters.shape,
-    },
-    ({ collectionName, includeContent, includeCount }) => {
-      return tool(collectionName, includeContent, includeCount)
-    },
-  )
-}

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

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

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

@@ -1,128 +0,0 @@
-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.registerTool(
-    'findConfig',
-    {
-      description: toolSchemas.findConfig.description,
-      inputSchema: toolSchemas.findConfig.parameters.shape,
-    },
-    ({ includeMetadata }) => {
-      return tool(includeMetadata)
-    },
-  )
-}