@payloadcms/plugin-mcp 3.86.0-internal.ac46214 → 4.0.0-internal.183b315

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

@@ -1,274 +0,0 @@
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
-import type { PayloadRequest } from 'payload'
-
-import { existsSync, readFileSync, writeFileSync } from 'fs'
-import { join } from 'path'
-
-import type { JobConfigUpdate, SchemaField, TaskSequenceItem } from '../../../types.js'
-
-import { toCamelCase } from '../../../utils/camelCase.js'
-import { validatePayloadFile } from '../../helpers/fileValidation.js'
-import { toolSchemas } from '../schemas.js'
-
-// Reusable function for updating jobs
-export const updateJob = async (
-  req: PayloadRequest,
-  verboseLogs: boolean,
-  jobsDir: string,
-  jobSlug: string,
-  updateType: string,
-  inputSchema?: SchemaField[],
-  outputSchema?: SchemaField[],
-  taskSequence?: TaskSequenceItem[],
-  configUpdate?: JobConfigUpdate,
-  handlerCode?: string,
-) => {
-  const payload = req.payload
-
-  if (verboseLogs) {
-    payload.logger.info(`[payload-mcp] Updating job: ${jobSlug} (${updateType})`)
-  }
-
-  try {
-    const camelCaseJobSlug = toCamelCase(jobSlug)
-
-    // Find the job file - check both tasks and workflows
-    let filePath: null | string = null
-    let jobType: 'task' | 'workflow' | null = null
-
-    const taskPath = join(jobsDir, 'tasks', `${camelCaseJobSlug}.ts`)
-    const workflowPath = join(jobsDir, 'workflows', `${camelCaseJobSlug}.ts`)
-
-    if (existsSync(taskPath)) {
-      filePath = taskPath
-      jobType = 'task'
-      if (verboseLogs) {
-        payload.logger.info(`[payload-mcp] Found task file: ${taskPath}`)
-      }
-    } else if (existsSync(workflowPath)) {
-      filePath = workflowPath
-      jobType = 'workflow'
-      if (verboseLogs) {
-        payload.logger.info(`[payload-mcp] Found workflow file: ${workflowPath}`)
-      }
-    } else {
-      throw new Error(`No task or workflow file found for job slug: ${jobSlug}`)
-    }
-
-    // Read the current file content
-    let content = readFileSync(filePath, 'utf8')
-    const originalContent = content
-
-    if (verboseLogs) {
-      payload.logger.info(`[payload-mcp] Applying update type: ${updateType}`)
-    }
-
-    // Apply updates based on type
-    switch (updateType) {
-      case 'change_config':
-        if (!configUpdate) {
-          throw new Error('config must be provided for change_config')
-        }
-
-        content = updateConfig(content, jobSlug, configUpdate)
-        if (verboseLogs) {
-          payload.logger.info(`[payload-mcp] Configuration updated successfully`)
-        }
-        break
-
-      case 'modify_schema':
-        if (!inputSchema && !outputSchema) {
-          throw new Error('Either inputSchema or outputSchema must be provided for modify_schema')
-        }
-
-        content = updateSchema(content, camelCaseJobSlug, inputSchema, outputSchema)
-        if (verboseLogs) {
-          payload.logger.info(`[payload-mcp] Schema updated successfully`)
-        }
-        break
-
-      case 'replace_handler':
-        if (!handlerCode) {
-          throw new Error('handlerCode must be provided for replace_handler')
-        }
-
-        content = updateHandler(content, handlerCode, jobType)
-        if (verboseLogs) {
-          payload.logger.info(`[payload-mcp] Handler code replaced successfully`)
-        }
-        break
-
-      case 'update_tasks':
-        if (!taskSequence) {
-          throw new Error('taskSequence must be provided for update_tasks')
-        }
-
-        if (jobType !== 'workflow') {
-          throw new Error('update_tasks is only supported for workflow jobs')
-        }
-
-        content = updateWorkflowTasks(content, taskSequence)
-        if (verboseLogs) {
-          payload.logger.info(`[payload-mcp] Workflow tasks updated successfully`)
-        }
-        break
-    }
-
-    // Only write if content changed
-    if (content !== originalContent) {
-      if (verboseLogs) {
-        payload.logger.info(`[payload-mcp] Writing updated content to file`)
-      }
-
-      // Write the updated content
-      writeFileSync(filePath, content)
-
-      // Validate the updated file
-      const fileName = `${camelCaseJobSlug}.ts`
-      const validationType = jobType === 'task' ? 'task' : 'workflow'
-
-      try {
-        const validationResult = await validatePayloadFile(fileName, validationType)
-
-        if (!validationResult.success) {
-          if (verboseLogs) {
-            payload.logger.warn(`[payload-mcp] Validation warning: ${validationResult.error}`)
-          }
-
-          return {
-            content: [
-              {
-                type: 'text' as const,
-                text: `⚠️ **Warning**: Job updated but validation failed:\n\n${validationResult.error}\n\nPlease review the generated code for any syntax errors.`,
-              },
-            ],
-          }
-        }
-
-        if (verboseLogs) {
-          payload.logger.info(`[payload-mcp] File validation successful`)
-        }
-      } catch (validationError) {
-        if (verboseLogs) {
-          payload.logger.warn(`[payload-mcp] Validation error: ${validationError}`)
-        }
-
-        return {
-          content: [
-            {
-              type: 'text' as const,
-              text: `⚠️ **Warning**: Job updated but validation could not be completed:\n\n${validationError}\n\nPlease review the generated code manually.`,
-            },
-          ],
-        }
-      }
-
-      return {
-        content: [
-          {
-            type: 'text' as const,
-            text: `✅ **Job updated successfully!**\n\n**Job**: \`${jobSlug}\`\n**Type**: \`${jobType}\`\n**Update**: \`${updateType}\`\n**File**: \`${fileName}\`\n\n**Next steps**:\n1. Restart your development server to load the updated job\n2. Test the updated functionality\n3. Verify the changes meet your requirements`,
-          },
-        ],
-      }
-    } else {
-      if (verboseLogs) {
-        payload.logger.info(`[payload-mcp] No changes detected, file not modified`)
-      }
-
-      return {
-        content: [
-          {
-            type: 'text' as const,
-            text: `ℹ️ **No changes made**: The job file was not modified as no changes were detected.\n\n**Job**: \`${jobSlug}\`\n**Type**: \`${jobType}\`\n**Update**: \`${updateType}\``,
-          },
-        ],
-      }
-    }
-  } catch (error) {
-    const errorMessage = (error as Error).message
-    payload.logger.error(`[payload-mcp] Error updating job: ${errorMessage}`)
-
-    return {
-      content: [
-        {
-          type: 'text' as const,
-          text: `❌ **Error updating job**: ${errorMessage}`,
-        },
-      ],
-    }
-  }
-}
-
-// Helper functions for different update types
-function updateSchema(
-  content: string,
-  _camelCaseJobSlug: string,
-  _inputSchema?: SchemaField[],
-  _outputSchema?: SchemaField[],
-): string {
-  // TODO: Implementation for schema updates
-  return content
-}
-
-function updateWorkflowTasks(content: string, _taskSequence: TaskSequenceItem[]): string {
-  // TODO: Implementation for updating workflow tasks
-  return content
-}
-
-function updateConfig(content: string, _jobSlug: string, _configUpdate: JobConfigUpdate): string {
-  // TODO: Implementation for updating job configuration
-  return content
-}
-
-function updateHandler(
-  content: string,
-  _handlerCode: string,
-  _jobType: 'task' | 'workflow',
-): string {
-  // TODO: Implementation for replacing handler code
-  return content
-}
-
-export const updateJobTool = (
-  server: McpServer,
-  req: PayloadRequest,
-  verboseLogs: boolean,
-  jobsDir: string,
-) => {
-  server.registerTool(
-    'updateJob',
-    {
-      description:
-        'Updates an existing Payload job with new configuration, schema, or handler code',
-      inputSchema: toolSchemas.updateJob.parameters.shape,
-    },
-    async ({
-      configUpdate,
-      handlerCode,
-      inputSchema,
-      jobSlug,
-      outputSchema,
-      taskSequence,
-      updateType,
-    }) => {
-      if (verboseLogs) {
-        req.payload.logger.info(
-          `[payload-mcp] Update Job Tool called with: ${jobSlug}, ${updateType}`,
-        )
-      }
-      return updateJob(
-        req,
-        verboseLogs,
-        jobsDir,
-        jobSlug,
-        updateType,
-        inputSchema as unknown as SchemaField[],
-        outputSchema as unknown as SchemaField[],
-        taskSequence,
-        configUpdate,
-        handlerCode,
-      )
-    },
-  )
-}

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

@@ -1,211 +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 {
-  getCollectionVirtualFieldNames,
-  stripVirtualFields,
-} from '../../../utils/getVirtualFieldNames.js'
-import { convertCollectionSchemaToZod } from '../../../utils/schemaConversion/convertCollectionSchemaToZod.js'
-import { transformPointDataToPayload } from '../../../utils/transformPointDataToPayload.js'
-import { toolSchemas } from '../schemas.js'
-export const createResourceTool = (
-  server: McpServer,
-  req: PayloadRequest,
-  user: TypedUser,
-  verboseLogs: boolean,
-  collectionSlug: string,
-  collections: MCPPluginConfig['collections'],
-  schema: JSONSchema4,
-) => {
-  const tool = async (
-    data: string,
-    depth: number = 0,
-    draft: boolean,
-    locale?: string,
-    fallbackLocale?: string,
-    select?: string,
-  ): Promise<{
-    content: Array<{
-      text: string
-      type: 'text'
-    }>
-  }> => {
-    const payload = req.payload
-
-    if (verboseLogs) {
-      payload.logger.info(
-        `[payload-mcp] Creating resource in collection: ${collectionSlug}${locale ? ` with locale: ${locale}` : ''}`,
-      )
-    }
-
-    try {
-      // Parse the data JSON
-      let parsedData: Record<string, unknown>
-      try {
-        parsedData = JSON.parse(data)
-
-        // Transform point fields from object format to tuple array
-        parsedData = transformPointDataToPayload(parsedData)
-
-        const virtualFieldNames = getCollectionVirtualFieldNames(payload.config, collectionSlug)
-        parsedData = stripVirtualFields(parsedData, virtualFieldNames)
-
-        if (verboseLogs) {
-          payload.logger.info(
-            `[payload-mcp] Parsed data for ${collectionSlug}: ${JSON.stringify(parsedData)}`,
-          )
-        }
-      } catch (_parseError) {
-        payload.logger.error(`[payload-mcp] Invalid JSON data provided: ${data}`)
-        return {
-          content: [{ type: 'text' as const, text: 'Error: Invalid JSON data provided' }],
-        }
-      }
-
-      let selectClause: SelectType | undefined
-      if (select) {
-        try {
-          selectClause = JSON.parse(select) as SelectType
-        } catch (_parseError) {
-          payload.logger.warn(`[payload-mcp] Invalid select clause JSON: ${select}`)
-          const response = {
-            content: [{ type: 'text' as const, text: 'Error: Invalid JSON in select clause' }],
-          }
-          return (collections?.[collectionSlug]?.overrideResponse?.(response, {}, req) ||
-            response) as {
-            content: Array<{
-              text: string
-              type: 'text'
-            }>
-          }
-        }
-      }
-
-      // Create the resource
-      const result = await payload.create({
-        collection: collectionSlug,
-        data: parsedData,
-        depth,
-        draft,
-        overrideAccess: false,
-        req,
-        user,
-        ...(locale && { locale }),
-        ...(fallbackLocale && { fallbackLocale }),
-        ...(selectClause && { select: selectClause }),
-      })
-
-      if (verboseLogs) {
-        payload.logger.info(
-          `[payload-mcp] Successfully created resource in ${collectionSlug} with ID: ${result.id}`,
-        )
-      }
-
-      const response = {
-        content: [
-          {
-            type: 'text' as const,
-            text: `Resource created successfully in collection "${collectionSlug}"!
-Created resource:
-\`\`\`json
-${JSON.stringify(result)}
-\`\`\``,
-          },
-        ],
-      }
-
-      return (collections?.[collectionSlug]?.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 creating resource in ${collectionSlug}: ${errorMessage}`,
-      )
-
-      const response = {
-        content: [
-          {
-            type: 'text' as const,
-            text: `Error creating resource in collection "${collectionSlug}": ${errorMessage}`,
-          },
-        ],
-      }
-
-      return (collections?.[collectionSlug]?.overrideResponse?.(response, {}, req) || response) as {
-        content: Array<{
-          text: string
-          type: 'text'
-        }>
-      }
-    }
-  }
-
-  if (collections?.[collectionSlug]?.enabled) {
-    const convertedFields = convertCollectionSchemaToZod(schema)
-
-    // Create a new schema that combines the converted fields with create-specific parameters
-    const createResourceSchema = z.object({
-      ...convertedFields.shape,
-      depth: z
-        .number()
-        .int()
-        .min(0)
-        .max(10)
-        .optional()
-        .default(0)
-        .describe('How many levels deep to populate relationships in response'),
-      draft: z
-        .boolean()
-        .optional()
-        .default(false)
-        .describe('Whether to create the document as a draft'),
-      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 create the document in (e.g., "en", "es"). Defaults to the default locale',
-        ),
-      select: z
-        .string()
-        .optional()
-        .describe(
-          'Optional: define exactly which fields you\'d like to create (JSON), e.g., \'{"title": "My Post"}\'',
-        ),
-    })
-
-    server.registerTool(
-      `create${collectionSlug.charAt(0).toUpperCase() + toCamelCase(collectionSlug).slice(1)}`,
-      {
-        description: `${collections?.[collectionSlug]?.description || toolSchemas.createResource.description.trim()}`,
-        inputSchema: createResourceSchema.shape,
-      },
-      async (params: Record<string, unknown>) => {
-        const { depth, draft, fallbackLocale, locale, select, ...fieldData } = params
-        const data = JSON.stringify(fieldData)
-        return await tool(
-          data,
-          depth as number,
-          draft as boolean,
-          locale as string | undefined,
-          fallbackLocale as string | undefined,
-          select as string | undefined,
-        )
-      },
-    )
-  }
-}

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

@@ -1,218 +0,0 @@
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
-import type { PayloadRequest, TypedUser } from 'payload'
-
-import type { MCPPluginConfig } from '../../../types.js'
-
-import { toCamelCase } from '../../../utils/camelCase.js'
-import { toolSchemas } from '../schemas.js'
-
-export const deleteResourceTool = (
-  server: McpServer,
-  req: PayloadRequest,
-  user: TypedUser,
-  verboseLogs: boolean,
-  collectionSlug: string,
-  collections: MCPPluginConfig['collections'],
-) => {
-  const tool = async (
-    id?: number | string,
-    where?: string,
-    depth: number = 0,
-    locale?: string,
-    fallbackLocale?: string,
-  ): Promise<{
-    content: Array<{
-      text: string
-      type: 'text'
-    }>
-  }> => {
-    const payload = req.payload
-
-    if (verboseLogs) {
-      payload.logger.info(
-        `[payload-mcp] Deleting resource from collection: ${collectionSlug}${id ? ` with ID: ${id}` : ' with where clause'}${locale ? `, locale: ${locale}` : ''}`,
-      )
-    }
-
-    try {
-      // Validate that either id or where is provided
-      if (!id && !where) {
-        payload.logger.error('[payload-mcp] Either id or where clause must be provided')
-        const response = {
-          content: [
-            { type: 'text' as const, text: 'Error: Either id or where clause must be provided' },
-          ],
-        }
-        return (collections?.[collectionSlug]?.overrideResponse?.(response, {}, req) ||
-          response) as {
-          content: Array<{
-            text: string
-            type: 'text'
-          }>
-        }
-      }
-
-      // Parse where clause if provided
-      let whereClause = {}
-      if (where) {
-        try {
-          whereClause = JSON.parse(where)
-          if (verboseLogs) {
-            payload.logger.info(`[payload-mcp] Using where clause: ${where}`)
-          }
-        } catch (_parseError) {
-          payload.logger.warn(`[payload-mcp] Invalid where clause JSON: ${where}`)
-          const response = {
-            content: [{ type: 'text' as const, text: 'Error: Invalid JSON in where clause' }],
-          }
-          return (collections?.[collectionSlug]?.overrideResponse?.(response, {}, req) ||
-            response) as {
-            content: Array<{
-              text: string
-              type: 'text'
-            }>
-          }
-        }
-      }
-
-      // Build delete options
-      const deleteOptions: Record<string, unknown> = {
-        collection: collectionSlug,
-        depth,
-        overrideAccess: false,
-        req,
-        user,
-        ...(locale && { locale }),
-        ...(fallbackLocale && { fallbackLocale }),
-      }
-
-      // Delete by ID or where clause
-      if (id) {
-        deleteOptions.id = id
-        if (verboseLogs) {
-          payload.logger.info(`[payload-mcp] Deleting single document with ID: ${id}`)
-        }
-      } else {
-        deleteOptions.where = whereClause
-        if (verboseLogs) {
-          payload.logger.info(`[payload-mcp] Deleting multiple documents with where clause`)
-        }
-      }
-
-      const result = await payload.delete(deleteOptions as Parameters<typeof payload.delete>[0])
-
-      // Handle different result types
-      if (id) {
-        // Single document deletion
-        if (verboseLogs) {
-          payload.logger.info(`[payload-mcp] Successfully deleted document with ID: ${id}`)
-        }
-
-        const response = {
-          content: [
-            {
-              type: 'text' as const,
-              text: `Document deleted successfully from collection "${collectionSlug}"!
-Deleted document:
-\`\`\`json
-${JSON.stringify(result)}
-\`\`\``,
-            },
-          ],
-        }
-
-        return (collections?.[collectionSlug]?.overrideResponse?.(response, result, req) ||
-          response) as {
-          content: Array<{
-            text: string
-            type: 'text'
-          }>
-        }
-      } else {
-        // Multiple documents deletion
-        const bulkResult = result as { docs?: unknown[]; errors?: unknown[] }
-        const docs = bulkResult.docs || []
-        const errors = bulkResult.errors || []
-
-        if (verboseLogs) {
-          payload.logger.info(
-            `[payload-mcp] Successfully deleted ${docs.length} documents, ${errors.length} errors`,
-          )
-        }
-
-        let responseText = `Document deleted successfully from collection "${collectionSlug}"!
-Deleted: ${docs.length} documents
-Errors: ${errors.length}
----`
-
-        if (docs.length > 0) {
-          responseText += `\n\nDeleted documents:
-\`\`\`json
-${JSON.stringify(docs)}
-\`\`\``
-        }
-
-        if (errors.length > 0) {
-          responseText += `\n\nErrors:
-\`\`\`json
-${JSON.stringify(errors)}
-\`\`\``
-        }
-
-        const response = {
-          content: [
-            {
-              type: 'text' as const,
-              text: responseText,
-            },
-          ],
-        }
-
-        return (collections?.[collectionSlug]?.overrideResponse?.(
-          response,
-          { docs, errors },
-          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 deleting resource from ${collectionSlug}: ${errorMessage}`,
-      )
-
-      const response = {
-        content: [
-          {
-            type: 'text' as const,
-            text: `Error deleting resource from collection "${collectionSlug}": ${errorMessage}`,
-          },
-        ],
-      }
-
-      return (collections?.[collectionSlug]?.overrideResponse?.(response, {}, req) || response) as {
-        content: Array<{
-          text: string
-          type: 'text'
-        }>
-      }
-    }
-  }
-
-  if (collections?.[collectionSlug]?.enabled) {
-    server.registerTool(
-      `delete${collectionSlug.charAt(0).toUpperCase() + toCamelCase(collectionSlug).slice(1)}`,
-      {
-        description: `${collections?.[collectionSlug]?.description || toolSchemas.deleteResource.description.trim()}`,
-        inputSchema: toolSchemas.deleteResource.parameters.shape,
-      },
-      async ({ id, depth, fallbackLocale, locale, where }) => {
-        return await tool(id, where, depth, locale, fallbackLocale)
-      },
-    )
-  }
-}