@payloadcms/plugin-mcp 3.78.0-internal-debug.f663370 → 3.78.0-internal.ab11ffa

package/src/mcp/helpers/config.ts

@@ -1,10 +1,4 @@
-import type {
-  AdminConfig,
-  CollectionConfigUpdates,
-  DatabaseConfig,
-  GeneralConfig,
-  PluginUpdates,
-} from '../../types.js'
+import type { AdminConfig, DatabaseConfig, PluginUpdates } from '../../types.js'
 
 /**
  * Adds a collection to the payload.config.ts file
@@ -217,110 +211,3 @@ export function updatePluginsConfig(content: string, pluginUpdates: PluginUpdate
 
   return content
 }
-
-/**
- * Updates general configuration options in payload.config.ts
- */
-export function updateGeneralConfig(content: string, generalConfig: GeneralConfig): string {
-  // Update various general configuration options
-  Object.entries(generalConfig).forEach(([key, value]) => {
-    if (value !== undefined && value !== null) {
-      const configRegex = new RegExp(`${key}:\\s*[^,}]*`, 'g')
-
-      if (content.match(configRegex)) {
-        if (typeof value === 'string') {
-          content = content.replace(configRegex, `${key}: '${value}'`)
-        } else if (typeof value === 'boolean') {
-          content = content.replace(configRegex, `${key}: ${value}`)
-        } else if (typeof value === 'object') {
-          content = content.replace(configRegex, `${key}: ${JSON.stringify(value, null, 2)}`)
-        }
-      } else {
-        // Add new config option
-        const configValue =
-          typeof value === 'string'
-            ? `'${value}'`
-            : typeof value === 'object'
-              ? JSON.stringify(value, null, 2)
-              : value
-        content = content.replace(
-          /export default buildConfig\(\{/,
-          `export default buildConfig({\n  ${key}: ${configValue},`,
-        )
-      }
-    }
-  })
-
-  return content
-}
-
-/**
- * Updates collection-level configuration in a collection file
- */
-export function updateCollectionConfig(
-  content: string,
-  updates: CollectionConfigUpdates,
-  collectionName: string,
-): string {
-  let updatedContent = content
-
-  if (updates.slug) {
-    updatedContent = updatedContent.replace(/slug:\s*'[^']*'/, `slug: '${updates.slug}'`)
-  }
-
-  if (updates.access) {
-    const accessRegex = /access:\s*\{[^}]*\}/
-    if (updatedContent.match(accessRegex)) {
-      // Update existing access config
-      Object.entries(updates.access).forEach(([key, value]) => {
-        if (value !== undefined) {
-          updatedContent = updatedContent.replace(
-            new RegExp(`${key}:\\s*[^,}]*`),
-            `${key}: ${value}`,
-          )
-        }
-      })
-    } else {
-      // Add access config
-      const accessConfig = Object.entries(updates.access)
-        .filter(([, value]) => value !== undefined)
-        .map(([key, value]) => `    ${key}: ${value}`)
-        .join(',\n')
-
-      updatedContent = updatedContent.replace(
-        /slug:\s*'[^']*',/,
-        `slug: '${collectionName}',\n  access: {\n${accessConfig}\n  },`,
-      )
-    }
-  }
-
-  if (updates.timestamps !== undefined) {
-    if (updatedContent.includes('timestamps:')) {
-      updatedContent = updatedContent.replace(
-        /timestamps:[^,}]*/,
-        `timestamps: ${updates.timestamps}`,
-      )
-    } else {
-      updatedContent = updatedContent.replace(
-        /fields:\s*\[/,
-        `timestamps: ${updates.timestamps},\n  fields: [`,
-      )
-    }
-  }
-
-  if (updates.versioning !== undefined) {
-    if (updatedContent.includes('versioning:')) {
-      updatedContent = updatedContent.replace(
-        /versioning:[^,}]*/,
-        `versioning: ${updates.versioning}`,
-      )
-    } else {
-      updatedContent = updatedContent.replace(
-        /fields:\s*\[/,
-        `versioning: ${updates.versioning},\n  fields: [`,
-      )
-    }
-  }
-
-  return updatedContent
-}

package/src/mcp/helpers/fields.ts

@@ -1,21 +1,51 @@
-type FieldDefinition = {
-  description?: string
-  name: string
-  options?: { label: string; value: string }[]
-  position?: 'main' | 'sidebar'
-  required?: boolean
-  type: string
+import type { FieldDefinition, FieldModification } from '../../types.js'
+
+/** Escapes a value for safe embedding inside a single-quoted TypeScript string literal. */
+function escapeSingleQuotedString(value: string): string {
+  return value
+    .replace(/\\/g, '\\\\')
+    .replace(/'/g, "\\'")
+    .replace(/\r/g, '\\r')
+    .replace(/\n/g, '\\n')
 }
 
-type FieldModification = {
-  changes: {
-    description?: string
-    options?: { label: string; value: string }[]
-    position?: 'main' | 'sidebar'
-    required?: boolean
-    type?: string
+/**
+ * Generates the TypeScript source string for a single field definition block.
+ * Used when writing collection files to disk.
+ */
+export function generateFieldDefinitionString(field: FieldDefinition): string {
+  const lines: string[] = []
+  lines.push(`    {`)
+  lines.push(`      name: '${escapeSingleQuotedString(field.name)}',`)
+  lines.push(`      type: '${escapeSingleQuotedString(field.type)}',`)
+
+  if (field.required) {
+    lines.push(`      required: true,`)
+  }
+
+  if (field.description || field.position) {
+    lines.push(`      admin: {`)
+    if (field.description) {
+      lines.push(`        description: '${escapeSingleQuotedString(field.description)}',`)
+    }
+    if (field.position) {
+      lines.push(`        position: '${escapeSingleQuotedString(field.position)}',`)
+    }
+    lines.push(`      },`)
   }
-  fieldName: string
+
+  if (field.options && field.type === 'select') {
+    lines.push(`      options: [`)
+    field.options.forEach((option) => {
+      lines.push(
+        `        { label: '${escapeSingleQuotedString(option.label)}', value: '${escapeSingleQuotedString(option.value)}' },`,
+      )
+    })
+    lines.push(`      ],`)
+  }
+
+  lines.push(`    },`)
+  return lines.join('\n')
 }
 
 /**
@@ -30,41 +60,7 @@ export function addFieldsToCollection(content: string, newFields: FieldDefinitio
     throw new Error('Could not find fields array in collection file')
   }
 
-  // Generate new field definitions
-  const newFieldDefinitions = newFields
-    .map((field) => {
-      const fieldConfig = []
-      fieldConfig.push(`    {`)
-      fieldConfig.push(`      name: '${field.name}',`)
-      fieldConfig.push(`      type: '${field.type}',`)
-
-      if (field.required) {
-        fieldConfig.push(`      required: true,`)
-      }
-
-      if (field.description || field.position) {
-        fieldConfig.push(`      admin: {`)
-        if (field.description) {
-          fieldConfig.push(`        description: '${field.description}',`)
-        }
-        if (field.position) {
-          fieldConfig.push(`        position: '${field.position}',`)
-        }
-        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')
-    })
-    .join('\n')
+  const newFieldDefinitions = newFields.map(generateFieldDefinitionString).join('\n')
 
   // Add new fields before the closing bracket
   const existingFields = match[1] || ''

package/src/mcp/helpers/fileValidation.ts

@@ -219,8 +219,8 @@ function validateCollectionConfig(config: CollectionConfig): ValidationResult<Co
   // Validate each field has required properties
   if (config.fields) {
     for (let i = 0; i < config.fields.length; i++) {
-      const field = config.fields[i] as Record<string, unknown>
-      if (!field) {
+      const field = config.fields[i]
+      if (!field || typeof field !== 'object') {
         return {
           error: `Field at index ${i} is not a valid object`,
           success: false,
@@ -228,9 +228,9 @@ function validateCollectionConfig(config: CollectionConfig): ValidationResult<Co
       }
 
       // Check if field has type property
-      if ('type' in field && field.type) {
+      if (!('type' in field) || !field.type) {
         return {
-          error: `Field at index ${i} has invalid type property`,
+          error: `Field at index ${i} is missing a valid type property`,
           success: false,
         }
       }
@@ -240,6 +240,29 @@ function validateCollectionConfig(config: CollectionConfig): ValidationResult<Co
   return { config, success: true }
 }
 
+/**
+ * Validates an array of schema fields (inputSchema / outputSchema).
+ * Returns an error string on the first invalid field, or null if all fields are valid.
+ */
+function validateSchemaFields(fields: TaskConfig['inputSchema'], label: string): null | string {
+  if (!fields || !Array.isArray(fields)) {
+    return null
+  }
+  for (let i = 0; i < fields.length; i++) {
+    const field = fields[i]
+    if (!field) {
+      return `${label} field at index ${i} is not a valid object`
+    }
+    if (!field.name) {
+      return `${label} field at index ${i} must have a valid name property`
+    }
+    if (!field.type) {
+      return `${label} field at index ${i} must have a valid type property`
+    }
+  }
+  return null
+}
+
 /**
  * Validate task configuration structure
  */
@@ -265,7 +288,6 @@ function validateTaskConfig(config: TaskConfig): ValidationResult<TaskConfig> {
     }
   }
 
-  // Validate optional properties
   if (config.retries !== undefined && config.retries < 0) {
     return {
       error: 'Task config retries must be a non-negative number',
@@ -273,57 +295,14 @@ function validateTaskConfig(config: TaskConfig): ValidationResult<TaskConfig> {
     }
   }
 
-  // Validate schemas if present
-  if (config.inputSchema && Array.isArray(config.inputSchema)) {
-    for (let i = 0; i < config.inputSchema.length; i++) {
-      const field = config.inputSchema[i]
-      if (!field) {
-        return {
-          error: `Input schema field at index ${i} is not a valid object`,
-          success: false,
-        }
-      }
-
-      if (!field.name) {
-        return {
-          error: `Input schema field at index ${i} must have a valid name property`,
-          success: false,
-        }
-      }
-
-      if (!field.type) {
-        return {
-          error: `Input schema field at index ${i} must have a valid type property`,
-          success: false,
-        }
-      }
-    }
+  const inputError = validateSchemaFields(config.inputSchema, 'Input schema')
+  if (inputError) {
+    return { error: inputError, success: false }
   }
 
-  if (config.outputSchema && Array.isArray(config.outputSchema)) {
-    for (let i = 0; i < config.outputSchema.length; i++) {
-      const field = config.outputSchema[i]
-      if (!field) {
-        return {
-          error: `Output schema field at index ${i} is not a valid object`,
-          success: false,
-        }
-      }
-
-      if (!field.name) {
-        return {
-          error: `Output schema field at index ${i} must have a valid name property`,
-          success: false,
-        }
-      }
-
-      if (!field.type) {
-        return {
-          error: `Output schema field at index ${i} must have a valid type property`,
-          success: false,
-        }
-      }
-    }
+  const outputError = validateSchemaFields(config.outputSchema, 'Output schema')
+  if (outputError) {
+    return { error: outputError, success: false }
   }
 
   return { config, success: true }
@@ -354,10 +333,9 @@ function validateWorkflowConfig(config: WorkflowConfig): ValidationResult<Workfl
     }
   }
 
-  // Validate optional properties
-  if (config.queue) {
+  if (config.queue !== undefined && typeof config.queue !== 'string') {
     return {
-      error: 'Workflow config queue must be a string',
+      error: 'Workflow config queue must be a string if provided',
       success: false,
     }
   }
@@ -369,49 +347,16 @@ function validateWorkflowConfig(config: WorkflowConfig): ValidationResult<Workfl
     }
   }
 
-  // Validate schema if present
-  if (config.inputSchema && Array.isArray(config.inputSchema)) {
-    for (let i = 0; i < config.inputSchema.length; i++) {
-      const field = config.inputSchema[i]
-      if (!field) {
-        return {
-          error: `Input schema field at index ${i} is not a valid object`,
-          success: false,
-        }
-      }
-
-      if (!field.name) {
-        return {
-          error: `Input schema field at index ${i} must have a valid name property`,
-          success: false,
-        }
-      }
-
-      if (!field.type) {
-        return {
-          error: `Input schema field at index ${i} must have a valid type property`,
-          success: false,
-        }
-      }
-    }
+  const inputError = validateSchemaFields(config.inputSchema, 'Input schema')
+  if (inputError) {
+    return { error: inputError, success: false }
   }
 
   return { config, success: true }
 }
 
-// Convenience functions for backward compatibility
 export const validateCollectionFile = async (
   fileName: string,
 ): Promise<ValidationResult<CollectionConfig>> => {
   return validatePayloadFile<CollectionConfig>(fileName, 'collection')
 }
-
-export const validateTaskFile = async (fileName: string): Promise<ValidationResult<TaskConfig>> => {
-  return validatePayloadFile<TaskConfig>(fileName, 'task')
-}
-
-export const validateWorkflowFile = async (
-  fileName: string,
-): Promise<ValidationResult<WorkflowConfig>> => {
-  return validatePayloadFile<WorkflowConfig>(fileName, 'workflow')
-}

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

@@ -4,6 +4,7 @@ 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'
 
@@ -34,36 +35,7 @@ export const createCollection = async (
     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')
+  const fieldDefinitions = fields.map(generateFieldDefinitionString).join('\n')
 
   // Generate collection file content
   const collectionContent = `import type { CollectionConfig } from 'payload'

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

@@ -4,27 +4,9 @@ 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'
 
-// 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,

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

@@ -21,7 +21,6 @@ export const updateConfig = (
   adminConfig?: any,
   databaseConfig?: any,
   pluginUpdates?: any,
-  generalConfig?: any,
   newContent?: string,
 ) => {
   const payload = req.payload
@@ -218,7 +217,6 @@ export const updateConfigTool = (
     adminConfig,
     collectionName,
     databaseConfig,
-    generalConfig,
     newContent,
     pluginUpdates,
     updateType,
@@ -226,7 +224,6 @@ export const updateConfigTool = (
     adminConfig?: any
     collectionName?: string
     databaseConfig?: any
-    generalConfig?: any
     newContent?: string
     pluginUpdates?: any
     updateType: string
@@ -247,7 +244,6 @@ export const updateConfigTool = (
         adminConfig,
         databaseConfig,
         pluginUpdates,
-        generalConfig,
         newContent,
       )
 

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

@@ -7,6 +7,10 @@ import { z } from 'zod'
 import type { PluginMCPServerConfig } 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'
 
@@ -45,6 +49,10 @@ export const updateGlobalTool = (
       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)}`,

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

@@ -4,6 +4,7 @@ import type { PayloadRequest } from 'payload'
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs'
 import { join } from 'path'
 
+import { toCamelCase } from '../../../utils/camelCase.js'
 import { validatePayloadFile } from '../../helpers/fileValidation.js'
 import { toolSchemas } from '../schemas.js'
 
@@ -271,12 +272,12 @@ ${jobContent}
 
 // Helper function to generate task content
 function generateTaskContent(
-  jobName: string,
+  _jobName: string,
   jobSlug: string,
   description: string,
   inputSchema: any,
   outputSchema: any,
-  jobData: Record<string, any>,
+  _jobData: Record<string, any>,
 ): string {
   const camelCaseJobSlug = toCamelCase(jobSlug)
 
@@ -307,12 +308,12 @@ export const ${camelCaseJobSlug}Task: Task = {
 
 // Helper function to generate workflow content
 function generateWorkflowContent(
-  jobName: string,
+  _jobName: string,
   jobSlug: string,
   description: string,
   inputSchema: any,
   outputSchema: any,
-  jobData: Record<string, any>,
+  _jobData: Record<string, any>,
 ): string {
   const camelCaseJobSlug = toCamelCase(jobSlug)
 
@@ -339,13 +340,6 @@ export const ${camelCaseJobSlug}Workflow: Workflow = {
 `
 }
 
-// Helper function to convert to camel case
-function toCamelCase(str: string): string {
-  return str
-    .replace(/[-_\s]+(.)?/g, (_, chr) => (chr ? chr.toUpperCase() : ''))
-    .replace(/^(.)/, (_, chr) => chr.toLowerCase())
-}
-
 export const createJobTool = (
   server: McpServer,
   req: PayloadRequest,

package/src/mcp/tools/job/run.ts

@@ -8,7 +8,7 @@ export const runJob = async (
   req: PayloadRequest,
   verboseLogs: boolean,
   jobSlug: string,
-  input: Record<string, any>,
+  input: Record<string, unknown>,
   queue?: string,
   priority?: number,
   delay?: number,
@@ -143,49 +143,25 @@ ${JSON.stringify(input, null, 2)}
 }
 
 export const runJobTool = (server: McpServer, req: PayloadRequest, verboseLogs: boolean) => {
-  const tool = async (
-    jobSlug: string,
-    input: Record<string, any>,
-    queue?: string,
-    priority?: number,
-    delay?: number,
-  ) => {
-    if (verboseLogs) {
-      req.payload.logger.info(`[payload-mcp] Run Job Tool called with: ${jobSlug}`)
-    }
-
-    try {
-      const result = await runJob(req, verboseLogs, jobSlug, input, queue, priority, delay)
-
-      if (verboseLogs) {
-        req.payload.logger.info(`[payload-mcp] Run Job Tool completed successfully`)
-      }
-
-      return result
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : 'Unknown error'
-      req.payload.logger.error(`[payload-mcp] Error in Run Job Tool: ${errorMessage}`)
-
-      return {
-        content: [
-          {
-            type: 'text' as const,
-            text: `❌ **Error in Run Job Tool**: ${errorMessage}`,
-          },
-        ],
-      }
-    }
-  }
-
   server.registerTool(
     'runJob',
     {
       description: 'Runs a Payload job with specified input data and queue options',
       inputSchema: toolSchemas.runJob.parameters.shape,
     },
-    async (args) => {
-      const { delay, input, jobSlug, priority, queue } = args
-      return await tool(jobSlug, input, queue, priority, delay)
+    async ({ delay, input, jobSlug, priority, queue }) => {
+      if (verboseLogs) {
+        req.payload.logger.info(`[payload-mcp] Run Job Tool called with: ${jobSlug}`)
+      }
+      return runJob(
+        req,
+        verboseLogs,
+        jobSlug,
+        input as Record<string, unknown>,
+        queue,
+        priority,
+        delay,
+      )
     },
   )
 }