@payloadcms/plugin-mcp 4.0.0-internal.5b1e7cd → 4.0.0-internal.c2b57ce

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

@@ -1,416 +0,0 @@
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
-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'
-
-const createOrUpdateJobFile = (
-  req: PayloadRequest,
-  verboseLogs: boolean,
-  jobsDir: string,
-  jobName: string,
-  jobType: 'task' | 'workflow',
-  jobSlug: string,
-  camelCaseJobSlug: string,
-) => {
-  const payload = req.payload
-  const jobFilePath = join(jobsDir, `${jobName}.ts`)
-  const importName = `${camelCaseJobSlug}${jobType === 'task' ? 'Task' : 'Workflow'}`
-  const importPath = `./${jobType === 'task' ? 'tasks' : 'workflows'}/${camelCaseJobSlug}`
-
-  if (verboseLogs) {
-    payload.logger.info(`[payload-mcp] Processing job file: ${jobFilePath}`)
-  }
-
-  if (existsSync(jobFilePath)) {
-    if (verboseLogs) {
-      payload.logger.info(`[payload-mcp] Updating existing job file: ${jobFilePath}`)
-    }
-
-    // Update existing job file
-    let content = readFileSync(jobFilePath, 'utf8')
-
-    // Add import if not already present
-    const importStatement = `import { ${importName} } from '${importPath}'`
-    if (!content.includes(importStatement)) {
-      if (verboseLogs) {
-        payload.logger.info(`[payload-mcp] Adding import: ${importStatement}`)
-      }
-
-      // Find the last import statement and add after it
-      const importRegex = /import\s+(?:\S.*)?from\s+['"].*['"];?\s*\n/g
-      let lastImportMatch
-      let match
-      while ((match = importRegex.exec(content)) !== null) {
-        lastImportMatch = match
-      }
-
-      if (lastImportMatch) {
-        const insertIndex = lastImportMatch.index + lastImportMatch[0].length
-        content =
-          content.slice(0, insertIndex) + importStatement + '\n' + content.slice(insertIndex)
-      } else {
-        // No imports found, add at the beginning
-        content = importStatement + '\n\n' + content
-      }
-    }
-
-    // Add to the appropriate array
-    const arrayName = jobType === 'task' ? 'tasks' : 'workflows'
-    const arrayRegex = new RegExp(`(${arrayName}:\\s*\\[)([^\\]]*)(\\])`, 's')
-    const arrayMatch = content.match(arrayRegex)
-
-    if (arrayMatch && arrayMatch[2]) {
-      const existingItems = arrayMatch[2].trim()
-      const newItem = existingItems ? `${existingItems},\n    ${importName}` : `\n    ${importName}`
-      content = content.replace(arrayRegex, `$1${newItem}\n  $3`)
-
-      if (verboseLogs) {
-        payload.logger.info(`[payload-mcp] Added ${importName} to ${arrayName} array`)
-      }
-    } else {
-      // Array doesn't exist, add it
-      const jobsConfigRegex = /(export\s+const\s.*JobsConfig\s*=\s*\{)([^}]*)(\})/s
-      const jobsConfigMatch = content.match(jobsConfigRegex)
-
-      if (jobsConfigMatch && jobsConfigMatch[2]) {
-        const existingConfig = jobsConfigMatch[2].trim()
-        const newConfig = existingConfig
-          ? `${existingConfig},\n  ${arrayName}: [\n    ${importName}\n  ]`
-          : `\n  ${arrayName}: [\n    ${importName}\n  ]`
-        content = content.replace(jobsConfigRegex, `$1${newConfig}\n$3`)
-
-        if (verboseLogs) {
-          payload.logger.info(`[payload-mcp] Created new ${arrayName} array with ${importName}`)
-        }
-      }
-    }
-
-    writeFileSync(jobFilePath, content)
-    if (verboseLogs) {
-      payload.logger.info(`[payload-mcp] Successfully updated job file: ${jobFilePath}`)
-    }
-  } else {
-    if (verboseLogs) {
-      payload.logger.info(`[payload-mcp] Creating new job file: ${jobFilePath}`)
-    }
-
-    // Create new job file
-    const camelCaseJobName = toCamelCase(jobName)
-    const jobFileContent = `import type { JobsConfig } from 'payload'
-import { ${importName} } from '${importPath}'
-
-export const ${camelCaseJobName}JobsConfig: JobsConfig = {
-  ${jobType === 'task' ? 'tasks' : 'workflows'}: [
-    ${importName}
-  ]
-}
-`
-    writeFileSync(jobFilePath, jobFileContent)
-    if (verboseLogs) {
-      payload.logger.info(`[payload-mcp] Successfully created new job file: ${jobFilePath}`)
-    }
-  }
-}
-
-// Reusable function for creating jobs
-export const createJob = async (
-  req: PayloadRequest,
-  verboseLogs: boolean,
-  jobsDir: string,
-  jobName: string,
-  jobType: 'task' | 'workflow',
-  jobSlug: string,
-  description: string,
-  inputSchema: any,
-  outputSchema: any,
-  jobData: Record<string, any>,
-) => {
-  const payload = req.payload
-
-  if (verboseLogs) {
-    payload.logger.info(`[payload-mcp] Creating ${jobType}: ${jobName}`)
-  }
-
-  try {
-    // Ensure jobs directory exists
-    if (!existsSync(jobsDir)) {
-      if (verboseLogs) {
-        payload.logger.info(`[payload-mcp] Creating jobs directory: ${jobsDir}`)
-      }
-      mkdirSync(jobsDir, { recursive: true })
-    }
-
-    // Ensure subdirectories exist
-    const tasksDir = join(jobsDir, 'tasks')
-    const workflowsDir = join(jobsDir, 'workflows')
-
-    if (!existsSync(tasksDir)) {
-      mkdirSync(tasksDir, { recursive: true })
-    }
-    if (!existsSync(workflowsDir)) {
-      mkdirSync(workflowsDir, { recursive: true })
-    }
-
-    const camelCaseJobSlug = toCamelCase(jobSlug)
-    const targetDir = jobType === 'task' ? tasksDir : workflowsDir
-    const fileName = `${camelCaseJobSlug}.ts`
-    const filePath = join(targetDir, fileName)
-
-    if (verboseLogs) {
-      payload.logger.info(`[payload-mcp] Target file path: ${filePath}`)
-    }
-
-    // Security check: ensure we're working with the jobs directory
-    if (!filePath.startsWith(jobsDir)) {
-      payload.logger.error(`[payload-mcp] Invalid job path attempted: ${filePath}`)
-      return {
-        content: [
-          {
-            type: 'text' as const,
-            text: '❌ **Error**: Invalid job path',
-          },
-        ],
-      }
-    }
-
-    // Check if file already exists
-    if (existsSync(filePath)) {
-      if (verboseLogs) {
-        payload.logger.info(`[payload-mcp] Job file already exists: ${fileName}`)
-      }
-      return {
-        content: [
-          {
-            type: 'text' as const,
-            text: `❌ **Error**: Job file already exists: ${fileName}`,
-          },
-        ],
-      }
-    }
-
-    // Generate job content based on type
-    let jobContent: string
-    if (jobType === 'task') {
-      jobContent = generateTaskContent(
-        jobName,
-        jobSlug,
-        description,
-        inputSchema,
-        outputSchema,
-        jobData,
-      )
-    } else {
-      jobContent = generateWorkflowContent(
-        jobName,
-        jobSlug,
-        description,
-        inputSchema,
-        outputSchema,
-        jobData,
-      )
-    }
-
-    // Write the job file
-    writeFileSync(filePath, jobContent, 'utf8')
-    if (verboseLogs) {
-      payload.logger.info(`[payload-mcp] Successfully created job file: ${filePath}`)
-    }
-
-    // Update the main job file
-    createOrUpdateJobFile(req, verboseLogs, jobsDir, jobName, jobType, jobSlug, camelCaseJobSlug)
-
-    // Validate the generated file
-    const validationResult = await validatePayloadFile(fileName, jobType)
-    if (validationResult.error) {
-      return {
-        content: [
-          {
-            type: 'text' as const,
-            text: `❌ **Error**: Generated job has validation issues:\n\n${validationResult.error}`,
-          },
-        ],
-      }
-    }
-
-    return {
-      content: [
-        {
-          type: 'text' as const,
-          text: `✅ **Job created successfully!**
-
-**File**: \`${fileName}\`
-**Type**: \`${jobType}\`
-**Slug**: \`${jobSlug}\`
-**Description**: ${description}
-
-**Generated Job Code:**
-\`\`\`typescript
-${jobContent}
-\`\`\``,
-        },
-      ],
-    }
-  } catch (error) {
-    const errorMessage = (error as Error).message
-    payload.logger.error(`[payload-mcp] Error creating job: ${errorMessage}`)
-
-    return {
-      content: [
-        {
-          type: 'text' as const,
-          text: `❌ **Error creating job**: ${errorMessage}`,
-        },
-      ],
-    }
-  }
-}
-
-// Helper function to generate task content
-function generateTaskContent(
-  _jobName: string,
-  jobSlug: string,
-  description: string,
-  inputSchema: any,
-  outputSchema: any,
-  _jobData: Record<string, any>,
-): string {
-  const camelCaseJobSlug = toCamelCase(jobSlug)
-
-  return `import type { Task } from 'payload'
-
-export const ${camelCaseJobSlug}Task: Task = {
-  slug: '${jobSlug}',
-  description: '${description}',
-  inputSchema: ${JSON.stringify(inputSchema, null, 2)},
-  outputSchema: ${JSON.stringify(outputSchema, null, 2)},
-  handler: async (input, context) => {
-    // TODO: Implement your task logic here
-    // Access input data: input.fieldName
-    // Access context: context.payload, context.req, etc.
-
-    // Example implementation:
-    const result = {
-      message: 'Task executed successfully',
-      input,
-      timestamp: new Date().toISOString(),
-    }
-
-    return result
-  },
-}
-`
-}
-
-// Helper function to generate workflow content
-function generateWorkflowContent(
-  _jobName: string,
-  jobSlug: string,
-  description: string,
-  inputSchema: any,
-  outputSchema: any,
-  _jobData: Record<string, any>,
-): string {
-  const camelCaseJobSlug = toCamelCase(jobSlug)
-
-  return `import type { Workflow } from 'payload'
-
-export const ${camelCaseJobSlug}Workflow: Workflow = {
-  slug: '${jobSlug}',
-  description: '${description}',
-  inputSchema: ${JSON.stringify(inputSchema, null, 2)},
-  outputSchema: ${JSON.stringify(outputSchema, null, 2)},
-  steps: [
-    // TODO: Define your workflow steps here
-    // Each step should be a function that returns a result
-    // Example:
-    // {
-    //   name: 'step1',
-    //   handler: async (input, context) => {
-    //     // Step logic here
-    //     return { result: 'step1 completed' }
-    //   }
-    // }
-  ],
-}
-`
-}
-
-export const createJobTool = (
-  server: McpServer,
-  req: PayloadRequest,
-  verboseLogs: boolean,
-  jobsDir: string,
-) => {
-  const tool = async (
-    jobName: string,
-    jobType: 'task' | 'workflow',
-    jobSlug: string,
-    description: string,
-    inputSchema: any = {},
-    outputSchema: any = {},
-    jobData: Record<string, any> = {},
-  ) => {
-    if (verboseLogs) {
-      req.payload.logger.info(
-        `[payload-mcp] Create Job Tool called with: ${jobName}, ${jobType}, ${jobSlug}`,
-      )
-    }
-
-    try {
-      const result = await createJob(
-        req,
-        verboseLogs,
-        jobsDir,
-        jobName,
-        jobType,
-        jobSlug,
-        description,
-        inputSchema,
-        outputSchema,
-        jobData,
-      )
-
-      if (verboseLogs) {
-        req.payload.logger.info(`[payload-mcp] Create 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 Create Job Tool: ${errorMessage}`)
-
-      return {
-        content: [
-          {
-            type: 'text' as const,
-            text: `❌ **Error in Create Job Tool**: ${errorMessage}`,
-          },
-        ],
-      }
-    }
-  }
-
-  server.registerTool(
-    'createJob',
-    {
-      description: 'Creates a new Payload job (task or workflow) with specified configuration',
-      inputSchema: toolSchemas.createJob.parameters.shape,
-    },
-    async (args) => {
-      return tool(
-        args.jobName,
-        args.jobType,
-        args.jobSlug,
-        args.description,
-        args.inputSchema,
-        args.outputSchema,
-        args.jobData,
-      )
-    },
-  )
-}

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

@@ -1,167 +0,0 @@
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
-import type { PayloadRequest } from 'payload'
-
-import { toolSchemas } from '../schemas.js'
-
-// Reusable function for running jobs
-export const runJob = async (
-  req: PayloadRequest,
-  verboseLogs: boolean,
-  jobSlug: string,
-  input: Record<string, unknown>,
-  queue?: string,
-  priority?: number,
-  delay?: number,
-) => {
-  const payload = req.payload
-
-  if (verboseLogs) {
-    payload.logger.info(`[payload-mcp] Running job: ${jobSlug}`)
-  }
-
-  try {
-    // Actually run the job using Payload's job queue
-    const jobQueueOptions: Record<string, unknown> = {
-      input,
-      task: jobSlug,
-    }
-
-    if (queue && queue !== 'default') {
-      jobQueueOptions.queue = queue
-      if (verboseLogs) {
-        payload.logger.info(`[payload-mcp] Using custom queue: ${queue}`)
-      }
-    }
-
-    if (priority && priority > 0) {
-      jobQueueOptions.priority = priority
-      if (verboseLogs) {
-        payload.logger.info(`[payload-mcp] Setting job priority: ${priority}`)
-      }
-    }
-
-    if (delay && delay > 0) {
-      jobQueueOptions.waitUntil = new Date(Date.now() + delay)
-      if (verboseLogs) {
-        payload.logger.info(`[payload-mcp] Setting job delay: ${delay}ms`)
-      }
-    }
-
-    if (verboseLogs) {
-      payload.logger.info(
-        `[payload-mcp] Queuing job with options: ${JSON.stringify(jobQueueOptions)}`,
-      )
-    }
-
-    const job = await payload.jobs.queue(
-      jobQueueOptions as Parameters<typeof payload.jobs.queue>[0],
-    )
-
-    const jobId = (job as { id?: string })?.id || 'unknown'
-
-    if (verboseLogs) {
-      payload.logger.info(`[payload-mcp] Job created successfully: ${jobId}`)
-    }
-
-    return {
-      content: [
-        {
-          type: 'text' as const,
-          text: `# Job Queued Successfully: ${jobSlug}
-
-## Job Details
-- **Job ID**: ${jobId}
-- **Job Slug**: ${jobSlug}
-- **Queue**: ${queue || 'default'}
-- **Priority**: ${priority || 'default'}
-- **Delay**: ${delay ? `${delay}ms` : 'none'}
-- **Status**: Queued and Running
-
-## Input Data
-\`\`\`json
-${JSON.stringify(input)}
-\`\`\`
-
-## Job Status
-The job has been successfully queued and will be processed according to the queue settings.
-
-## Monitoring the Job
-You can monitor the job status using:
-
-\`\`\`typescript
-// Check job status
-const jobStatus = await payload.jobs.status('${jobId}')
-console.log('Job status:', jobStatus)
-
-// Wait for completion
-const result = await payload.jobs.wait('${jobId}')
-console.log('Job result:', result)
-\`\`\`
-
-✅ Job successfully queued with ID: ${jobId}`,
-        },
-      ],
-    }
-  } catch (error) {
-    const errorMsg = (error as Error).message
-    payload.logger.error(`[payload-mcp] Error running job "${jobSlug}": ${errorMsg}`)
-
-    return {
-      content: [
-        {
-          type: 'text' as const,
-          text: `❌ Error running job "${jobSlug}": ${errorMsg}
-
-## Common Issues:
-1. **Job not found**: The job "${jobSlug}" may not be registered in your Payload configuration
-2. **Invalid input format**: Ensure the input matches the job's input schema
-3. **Queue not configured**: The queue "${queue || 'default'}" may not be properly set up
-4. **Permission issues**: Ensure proper access rights for job execution
-5. **Job handler error**: The job implementation may have errors
-
-## Input Data Provided:
-\`\`\`json
-${JSON.stringify(input)}
-\`\`\`
-
-## Next Steps:
-1. **Verify job exists**: Check that the job "${jobSlug}" is properly registered
-2. **Check input format**: Ensure the input data matches the expected schema
-3. **Review job configuration**: Verify the job is properly configured in your Payload setup
-4. **Check permissions**: Ensure you have the necessary permissions to run jobs
-5. **Review error logs**: Check the server logs for more detailed error information
-
-## Troubleshooting:
-- **Job not found**: Verify the job slug and check your jobs configuration
-- **Schema mismatch**: Ensure input data matches the job's input schema
-- **Queue issues**: Check that the specified queue is properly configured
-- **Permission errors**: Verify user permissions for job execution`,
-        },
-      ],
-    }
-  }
-}
-
-export const runJobTool = (server: McpServer, req: PayloadRequest, verboseLogs: boolean) => {
-  server.registerTool(
-    'runJob',
-    {
-      description: 'Runs a Payload job with specified input data and queue options',
-      inputSchema: toolSchemas.runJob.parameters.shape,
-    },
-    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,
-      )
-    },
-  )
-}