@payloadcms/plugin-mcp 4.0.0-internal.38b7f1d → 4.0.0-internal.40de3ec

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

@@ -1,280 +0,0 @@
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
-import type { PayloadRequest } from 'payload'
-
-import { readFileSync, writeFileSync } from 'fs'
-
-import {
-  addCollectionToConfig,
-  removeCollectionFromConfig,
-  updateAdminConfig,
-  updateDatabaseConfig,
-  updatePluginsConfig,
-} from '../../helpers/config.js'
-import { toolSchemas } from '../schemas.js'
-
-export const updateConfig = (
-  req: PayloadRequest,
-  verboseLogs: boolean,
-  configFilePath: string,
-  updateType: string,
-  collectionName?: string,
-  adminConfig?: any,
-  databaseConfig?: any,
-  pluginUpdates?: any,
-  newContent?: string,
-) => {
-  const payload = req.payload
-  if (verboseLogs) {
-    payload.logger.info(`[payload-mcp] Updating config with update type: ${updateType}`)
-  }
-
-  // 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',
-        },
-      ],
-    }
-  }
-
-  try {
-    // Read current config
-    let currentContent: string
-    try {
-      currentContent = readFileSync(configFilePath, 'utf8')
-    } catch (_ignore) {
-      return {
-        content: [
-          {
-            type: 'text' as const,
-            text: `❌ **Error**: Config file not found: ${configFilePath}`,
-          },
-        ],
-      }
-    }
-
-    let updatedContent: string
-    let updateSummary: string[] = []
-
-    switch (updateType) {
-      case 'add_collection':
-        if (!collectionName) {
-          return {
-            content: [
-              {
-                type: 'text' as const,
-                text: '❌ **Error**: No collection name provided for add_collection update type',
-              },
-            ],
-          }
-        }
-        updatedContent = addCollectionToConfig(currentContent, collectionName)
-        updateSummary = [`Added collection: ${collectionName}`]
-        break
-
-      case 'remove_collection':
-        if (!collectionName) {
-          return {
-            content: [
-              {
-                type: 'text' as const,
-                text: '❌ **Error**: No collection name provided for remove_collection update type',
-              },
-            ],
-          }
-        }
-        updatedContent = removeCollectionFromConfig(currentContent, collectionName)
-        updateSummary = [`Removed collection: ${collectionName}`]
-        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 config content']
-        break
-
-      case 'update_admin':
-        if (!adminConfig) {
-          return {
-            content: [
-              {
-                type: 'text' as const,
-                text: '❌ **Error**: No admin config provided for update_admin update type',
-              },
-            ],
-          }
-        }
-        updatedContent = updateAdminConfig(currentContent, adminConfig)
-        updateSummary = Object.keys(adminConfig).map((key) => `Updated admin config: ${key}`)
-        break
-
-      case 'update_database':
-        if (!databaseConfig) {
-          return {
-            content: [
-              {
-                type: 'text' as const,
-                text: '❌ **Error**: No database config provided for update_database update type',
-              },
-            ],
-          }
-        }
-        updatedContent = updateDatabaseConfig(currentContent, databaseConfig)
-        updateSummary = Object.keys(databaseConfig).map((key) => `Updated database config: ${key}`)
-        break
-
-      case 'update_plugins':
-        if (!pluginUpdates) {
-          return {
-            content: [
-              {
-                type: 'text' as const,
-                text: '❌ **Error**: No plugin updates provided for update_plugins update type',
-              },
-            ],
-          }
-        }
-        updatedContent = updatePluginsConfig(currentContent, pluginUpdates)
-        updateSummary = []
-        if (pluginUpdates.add) {
-          updateSummary.push(`Added plugins: ${pluginUpdates.add.join(', ')}`)
-        }
-        if (pluginUpdates.remove) {
-          updateSummary.push(`Removed plugins: ${pluginUpdates.remove.join(', ')}`)
-        }
-        break
-
-      default:
-        return {
-          content: [
-            {
-              type: 'text' as const,
-              text: `❌ **Error**: Unknown update type: ${updateType}`,
-            },
-          ],
-        }
-    }
-
-    // Write the updated content back to the file
-    writeFileSync(configFilePath, updatedContent, 'utf8')
-    if (verboseLogs) {
-      payload.logger.info(`[payload-mcp] Successfully updated config file: ${configFilePath}`)
-    }
-
-    return {
-      content: [
-        {
-          type: 'text' as const,
-          text: `✅ **Config updated successfully!**
-
-**File**: \`${configFilePath}\`
-**Update Type**: ${updateType}
-
-**Changes Made**:
-${updateSummary.map((summary) => `- ${summary}`).join('\n')}
-
-**Updated Config Content:**
-\`\`\`typescript
-${updatedContent}
-\`\`\``,
-        },
-      ],
-    }
-  } catch (error) {
-    const errorMessage = (error as Error).message
-    payload.logger.error(`[payload-mcp] Error updating config: ${errorMessage}`)
-    return {
-      content: [
-        {
-          type: 'text' as const,
-          text: `❌ **Error updating config**: ${errorMessage}`,
-        },
-      ],
-    }
-  }
-}
-
-export const updateConfigTool = (
-  server: McpServer,
-  req: PayloadRequest,
-  verboseLogs: boolean,
-  configFilePath: string,
-) => {
-  const tool = ({
-    adminConfig,
-    collectionName,
-    databaseConfig,
-    newContent,
-    pluginUpdates,
-    updateType,
-  }: {
-    adminConfig?: any
-    collectionName?: string
-    databaseConfig?: any
-    newContent?: string
-    pluginUpdates?: any
-    updateType: string
-  }) => {
-    const payload = req.payload
-
-    if (verboseLogs) {
-      payload.logger.info(`[payload-mcp] Updating config: ${updateType}`)
-    }
-
-    try {
-      const result = updateConfig(
-        req,
-        verboseLogs,
-        configFilePath,
-        updateType,
-        collectionName,
-        adminConfig,
-        databaseConfig,
-        pluginUpdates,
-        newContent,
-      )
-
-      if (verboseLogs) {
-        payload.logger.info(`[payload-mcp] Config update completed for: ${updateType}`)
-      }
-
-      return result
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : 'Unknown error'
-      payload.logger.error(`[payload-mcp] Error updating config: ${errorMessage}`)
-
-      return {
-        content: [
-          {
-            type: 'text' as const,
-            text: `Error updating config: ${errorMessage}`,
-          },
-        ],
-      }
-    }
-  }
-
-  server.registerTool(
-    'updateConfig',
-    {
-      description: toolSchemas.updateConfig.description,
-      inputSchema: toolSchemas.updateConfig.parameters.shape,
-    },
-    (args) => {
-      return tool(args)
-    },
-  )
-}

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

@@ -1,128 +0,0 @@
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
-import type { PayloadRequest, SelectType, TypedUser } from 'payload'
-
-import type { MCPPluginConfig } from '../../../types.js'
-
-import { toCamelCase } from '../../../utils/camelCase.js'
-import { toolSchemas } from '../schemas.js'
-
-export const findGlobalTool = (
-  server: McpServer,
-  req: PayloadRequest,
-  user: TypedUser,
-  verboseLogs: boolean,
-  globalSlug: string,
-  globals: MCPPluginConfig['globals'],
-) => {
-  const tool = async (
-    depth: number = 0,
-    locale?: string,
-    fallbackLocale?: string,
-    select?: string,
-  ): Promise<{
-    content: Array<{
-      text: string
-      type: 'text'
-    }>
-  }> => {
-    const payload = req.payload
-
-    if (verboseLogs) {
-      payload.logger.info(
-        `[payload-mcp] Reading global: ${globalSlug}, depth: ${depth}${locale ? `, locale: ${locale}` : ''}`,
-      )
-    }
-
-    try {
-      const findOptions: Parameters<typeof payload.findGlobal>[0] = {
-        slug: globalSlug,
-        depth,
-        user,
-      }
-
-      let selectClause: SelectType | undefined
-      if (select) {
-        try {
-          selectClause = JSON.parse(select) as SelectType
-        } catch (_parseError) {
-          payload.logger.warn(`[payload-mcp] Invalid select clause JSON for global: ${select}`)
-          const response = {
-            content: [{ type: 'text' as const, text: 'Error: Invalid JSON in select clause' }],
-          }
-          return (globals?.[globalSlug]?.overrideResponse?.(response, {}, req) || response) as {
-            content: Array<{
-              text: string
-              type: 'text'
-            }>
-          }
-        }
-      }
-
-      // Add locale parameters if provided
-      if (locale) {
-        findOptions.locale = locale
-      }
-      if (fallbackLocale) {
-        findOptions.fallbackLocale = fallbackLocale
-      }
-      if (selectClause) {
-        findOptions.select = selectClause
-      }
-
-      const result = await payload.findGlobal(findOptions)
-
-      if (verboseLogs) {
-        payload.logger.info(`[payload-mcp] Found global: ${globalSlug}`)
-      }
-
-      const response = {
-        content: [
-          {
-            type: 'text' as const,
-            text: `Global "${globalSlug}":
-\`\`\`json
-${JSON.stringify(result)}
-\`\`\``,
-          },
-        ],
-      }
-
-      return (globals?.[globalSlug]?.overrideResponse?.(response, result, req) || response) as {
-        content: Array<{
-          text: string
-          type: 'text'
-        }>
-      }
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : 'Unknown error'
-      payload.logger.error(`[payload-mcp] Error reading global ${globalSlug}: ${errorMessage}`)
-      const response = {
-        content: [
-          {
-            type: 'text' as const,
-            text: `❌ **Error reading global "${globalSlug}":** ${errorMessage}`,
-          },
-        ],
-      }
-      return (globals?.[globalSlug]?.overrideResponse?.(response, {}, req) || response) as {
-        content: Array<{
-          text: string
-          type: 'text'
-        }>
-      }
-    }
-  }
-
-  if (globals?.[globalSlug]?.enabled) {
-    server.registerTool(
-      `find${globalSlug.charAt(0).toUpperCase() + toCamelCase(globalSlug).slice(1)}`,
-      {
-        description: `${toolSchemas.findGlobal.description.trim()}\n\n${globals?.[globalSlug]?.description || ''}`,
-        inputSchema: toolSchemas.findGlobal.parameters.shape,
-      },
-      async ({ depth, fallbackLocale, locale, select }) => {
-        return await tool(depth, locale, fallbackLocale, select)
-      },
-    )
-  }
-}

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

@@ -1,207 +0,0 @@
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
-import type { JSONSchema4 } from 'json-schema'
-import type { PayloadRequest, SelectType, TypedUser } from 'payload'
-
-import { z } from 'zod'
-
-import type { MCPPluginConfig } from '../../../types.js'
-
-import { toCamelCase } from '../../../utils/camelCase.js'
-import {
-  getGlobalVirtualFieldNames,
-  stripVirtualFields,
-} from '../../../utils/getVirtualFieldNames.js'
-import { convertCollectionSchemaToZod } from '../../../utils/schemaConversion/convertCollectionSchemaToZod.js'
-import { toolSchemas } from '../schemas.js'
-
-export const updateGlobalTool = (
-  server: McpServer,
-  req: PayloadRequest,
-  user: TypedUser,
-  verboseLogs: boolean,
-  globalSlug: string,
-  globals: MCPPluginConfig['globals'],
-  schema: JSONSchema4,
-) => {
-  const tool = async (
-    data: string,
-    draft: boolean = false,
-    depth: number = 0,
-    locale?: string,
-    fallbackLocale?: string,
-    select?: string,
-  ): Promise<{
-    content: Array<{
-      text: string
-      type: 'text'
-    }>
-  }> => {
-    const payload = req.payload
-
-    if (verboseLogs) {
-      payload.logger.info(
-        `[payload-mcp] Updating global: ${globalSlug}, draft: ${draft}${locale ? `, locale: ${locale}` : ''}`,
-      )
-    }
-
-    try {
-      // Parse the data JSON
-      let parsedData: Record<string, unknown>
-      try {
-        parsedData = JSON.parse(data)
-
-        const virtualFieldNames = getGlobalVirtualFieldNames(payload.config, globalSlug)
-        parsedData = stripVirtualFields(parsedData, virtualFieldNames)
-
-        if (verboseLogs) {
-          payload.logger.info(
-            `[payload-mcp] Parsed data for ${globalSlug}: ${JSON.stringify(parsedData)}`,
-          )
-        }
-      } catch (_parseError) {
-        payload.logger.error(`[payload-mcp] Invalid JSON data provided: ${data}`)
-        const response = {
-          content: [{ type: 'text' as const, text: 'Error: Invalid JSON data provided' }],
-        }
-        return (globals?.[globalSlug]?.overrideResponse?.(response, {}, req) || response) as {
-          content: Array<{
-            text: string
-            type: 'text'
-          }>
-        }
-      }
-
-      let selectClause: SelectType | undefined
-      if (select) {
-        try {
-          selectClause = JSON.parse(select) as SelectType
-        } catch (_parseError) {
-          payload.logger.warn(`[payload-mcp] Invalid select clause JSON for global: ${select}`)
-          const response = {
-            content: [{ type: 'text' as const, text: 'Error: Invalid JSON in select clause' }],
-          }
-          return (globals?.[globalSlug]?.overrideResponse?.(response, {}, req) || response) as {
-            content: Array<{
-              text: string
-              type: 'text'
-            }>
-          }
-        }
-      }
-
-      const updateOptions: Parameters<typeof payload.updateGlobal>[0] = {
-        slug: globalSlug,
-        data: parsedData,
-        depth,
-        draft,
-        user,
-      }
-
-      // Add locale parameters if provided
-      if (locale) {
-        updateOptions.locale = locale
-      }
-      if (fallbackLocale) {
-        updateOptions.fallbackLocale = fallbackLocale
-      }
-      if (selectClause) {
-        updateOptions.select = selectClause
-      }
-
-      const result = await payload.updateGlobal(updateOptions)
-
-      if (verboseLogs) {
-        payload.logger.info(`[payload-mcp] Successfully updated global: ${globalSlug}`)
-      }
-
-      const response = {
-        content: [
-          {
-            type: 'text' as const,
-            text: `Global "${globalSlug}" updated successfully!
-\`\`\`json
-${JSON.stringify(result)}
-\`\`\``,
-          },
-        ],
-      }
-
-      return (globals?.[globalSlug]?.overrideResponse?.(response, result, req) || response) as {
-        content: Array<{
-          text: string
-          type: 'text'
-        }>
-      }
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : 'Unknown error'
-      payload.logger.error(`[payload-mcp] Error updating global ${globalSlug}: ${errorMessage}`)
-
-      const response = {
-        content: [
-          {
-            type: 'text' as const,
-            text: `Error updating global "${globalSlug}": ${errorMessage}`,
-          },
-        ],
-      }
-
-      return (globals?.[globalSlug]?.overrideResponse?.(response, {}, req) || response) as {
-        content: Array<{
-          text: string
-          type: 'text'
-        }>
-      }
-    }
-  }
-
-  if (globals?.[globalSlug]?.enabled) {
-    const convertedFields = convertCollectionSchemaToZod(schema)
-
-    // Make all fields optional for partial updates (PATCH-style)
-    const optionalFields = Object.fromEntries(
-      Object.entries(convertedFields.shape).map(([key, value]) => [key, (value as any).optional()]),
-    )
-
-    const updateGlobalSchema = z.object({
-      ...optionalFields,
-      depth: z.number().optional().describe('Optional: Depth of relationships to populate'),
-      draft: z.boolean().optional().describe('Optional: Whether to save as draft (default: false)'),
-      fallbackLocale: z
-        .string()
-        .optional()
-        .describe('Optional: fallback locale code to use when requested locale is not available'),
-      locale: z
-        .string()
-        .optional()
-        .describe(
-          'Optional: locale code to update data in (e.g., "en", "es"). Use "all" to update all locales for localized fields',
-        ),
-      select: z
-        .string()
-        .optional()
-        .describe(
-          'Optional: define exactly which fields you\'d like to return in the response (JSON), e.g., \'{"siteName": "My Site"}\'',
-        ),
-    })
-
-    server.registerTool(
-      `update${globalSlug.charAt(0).toUpperCase() + toCamelCase(globalSlug).slice(1)}`,
-      {
-        description: `${toolSchemas.updateGlobal.description.trim()}\n\n${globals?.[globalSlug]?.description || ''}`,
-        inputSchema: updateGlobalSchema.shape,
-      },
-      async (params: Record<string, unknown>) => {
-        const { depth, draft, fallbackLocale, locale, select, ...rest } = params
-        const data = JSON.stringify(rest)
-        return await tool(
-          data,
-          draft as boolean,
-          depth as number,
-          locale as string,
-          fallbackLocale as string,
-          select as string | undefined,
-        )
-      },
-    )
-  }
-}