code-engine-mcp-server 1.0.0

package/build/index.js

@@ -0,0 +1,1117 @@
+#!/usr/bin/env node
+/**
+ * Code Engine MCP Server
+ * Model Context Protocol server for IBM Code Engine and Docker/Podman integration
+ *
+ * Author: Markus van Kempen | markus.van.kempen@gmail.com
+ * Research | Floor 7½ 🏢🤏 | https://markusvankempen.github.io/
+ * No bug too small, no syntax too weird.
+ */
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CallToolRequestSchema, ListToolsRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import axios from 'axios';
+import { config as loadDotenv } from 'dotenv';
+import { resolve, dirname } from 'path';
+import { fileURLToPath } from 'url';
+// Load .env from the workspace root (parent of this package) and from the package dir
+const __dirname = dirname(fileURLToPath(import.meta.url));
+loadDotenv({ path: resolve(__dirname, '../../.env') });
+loadDotenv({ path: resolve(__dirname, '../.env') });
+const execAsync = promisify(exec);
+const CE_REGIONS = ['us-south', 'us-east', 'eu-de', 'eu-gb', 'jp-tok', 'jp-osa', 'au-syd', 'ca-tor', 'br-sao'];
+// Helper function to get IAM token
+async function getIAMToken(apiKey) {
+    const response = await axios.post('https://iam.cloud.ibm.com/identity/token', new URLSearchParams({
+        grant_type: 'urn:ibm:params:oauth:grant-type:apikey',
+        apikey: apiKey
+    }), { headers: { 'Content-Type': 'application/x-www-form-urlencoded' } });
+    return response.data.access_token;
+}
+// Helper: resolve which region a project lives in
+async function getProjectRegion(projectId, token) {
+    for (const region of CE_REGIONS) {
+        try {
+            await axios.get(`https://api.${region}.codeengine.cloud.ibm.com/v2/projects/${projectId}`, { headers: { Authorization: `Bearer ${token}` } });
+            return region;
+        }
+        catch {
+            // not in this region
+        }
+    }
+    throw new Error(`Project ${projectId} not found in any region`);
+}
+// Helper: get authenticated CE API base URL for a project
+async function ceApi(projectId, token) {
+    const region = await getProjectRegion(projectId, token);
+    return {
+        base: `https://api.${region}.codeengine.cloud.ibm.com/v2/projects/${projectId}`,
+        headers: { Authorization: `Bearer ${token}`, 'Content-Type': 'application/json' },
+    };
+}
+// Helper: get and validate API key
+function getApiKey() {
+    const apiKey = process.env.IBM_CLOUD_API_KEY || process.env.IBMCLOUD_API_KEY;
+    if (!apiKey)
+        throw new Error('IBM_CLOUD_API_KEY or IBMCLOUD_API_KEY environment variable not set');
+    return apiKey;
+}
+// Create MCP server
+const server = new Server({
+    name: 'code-engine-mcp-server',
+    version: '1.0.0',
+}, {
+    capabilities: {
+        tools: {},
+    },
+});
+// Docker/Podman Tools
+const containerTools = [
+    {
+        name: 'detect_container_runtime',
+        description: 'Detect available container runtime (Docker or Podman)',
+        inputSchema: {
+            type: 'object',
+            properties: {},
+        },
+    },
+    {
+        name: 'build_container_image',
+        description: 'Build a container image using Docker or Podman',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                dockerfile_path: { type: 'string', description: 'Path to Dockerfile' },
+                image_name: { type: 'string', description: 'Image name with tag' },
+                context_path: { type: 'string', description: 'Build context path' },
+                runtime: { type: 'string', enum: ['docker', 'podman'], description: 'Container runtime' },
+            },
+            required: ['dockerfile_path', 'image_name', 'context_path'],
+        },
+    },
+    {
+        name: 'push_container_image',
+        description: 'Push container image to registry',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                image_name: { type: 'string', description: 'Full image name with registry' },
+                runtime: { type: 'string', enum: ['docker', 'podman'] },
+            },
+            required: ['image_name'],
+        },
+    },
+    {
+        name: 'list_local_images',
+        description: 'List all local container images',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                runtime: { type: 'string', enum: ['docker', 'podman'] },
+            },
+        },
+    },
+    {
+        name: 'test_container_locally',
+        description: 'Run container locally for testing',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                image_name: { type: 'string' },
+                port_mapping: { type: 'string', description: 'Port mapping (e.g., 8080:8080)' },
+                env_vars: { type: 'object', description: 'Environment variables' },
+                runtime: { type: 'string', enum: ['docker', 'podman'] },
+            },
+            required: ['image_name'],
+        },
+    },
+    {
+        name: 'get_container_logs',
+        description: 'Get logs from a running container',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                container_id: { type: 'string' },
+                runtime: { type: 'string', enum: ['docker', 'podman'] },
+            },
+            required: ['container_id'],
+        },
+    },
+    {
+        name: 'stop_local_container',
+        description: 'Stop and remove a local container',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                container_id: { type: 'string' },
+                runtime: { type: 'string', enum: ['docker', 'podman'] },
+            },
+            required: ['container_id'],
+        },
+    },
+    {
+        name: 'list_local_containers',
+        description: 'List all local containers (running and stopped)',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                runtime: { type: 'string', enum: ['docker', 'podman'] },
+                all: { type: 'boolean', description: 'Include stopped containers' },
+            },
+        },
+    },
+];
+// Code Engine Tools
+const codeEngineTools = [
+    // --- Projects ---
+    {
+        name: 'ce_list_projects',
+        description: 'List all Code Engine projects across all or a specific region',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                region: { type: 'string', description: 'IBM Cloud region (omit to search all regions)' },
+            },
+        },
+    },
+    {
+        name: 'ce_get_project',
+        description: 'Get details of a specific Code Engine project',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                project_id: { type: 'string', description: 'Project ID (UUID)' },
+            },
+            required: ['project_id'],
+        },
+    },
+    {
+        name: 'ce_create_project',
+        description: 'Create a new Code Engine project',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                name: { type: 'string', description: 'Project name' },
+                region: { type: 'string', description: 'IBM Cloud region (e.g. us-south, ca-tor)' },
+                resource_group_id: { type: 'string', description: 'Resource group ID (optional)' },
+            },
+            required: ['name', 'region'],
+        },
+    },
+    {
+        name: 'ce_delete_project',
+        description: 'Delete a Code Engine project',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                project_id: { type: 'string' },
+            },
+            required: ['project_id'],
+        },
+    },
+    // --- Applications ---
+    {
+        name: 'ce_list_applications',
+        description: 'List applications in a Code Engine project',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                project_id: { type: 'string' },
+            },
+            required: ['project_id'],
+        },
+    },
+    {
+        name: 'ce_get_application',
+        description: 'Get details of a Code Engine application',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                project_id: { type: 'string' },
+                app_name: { type: 'string' },
+            },
+            required: ['project_id', 'app_name'],
+        },
+    },
+    {
+        name: 'ce_create_application',
+        description: 'Create a Code Engine application from a container image',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                project_id: { type: 'string' },
+                name: { type: 'string' },
+                image: { type: 'string', description: 'Container image reference' },
+                port: { type: 'number', description: 'Container port (default 8080)' },
+                scale_min_instances: { type: 'number', description: 'Min instances (default 0)' },
+                scale_max_instances: { type: 'number', description: 'Max instances (default 10)' },
+                scale_cpu_limit: { type: 'string', description: 'CPU limit (e.g. 1, 0.5)' },
+                scale_memory_limit: { type: 'string', description: 'Memory limit (e.g. 4G, 2G)' },
+                env_vars: { type: 'object', description: 'Key/value environment variables' },
+            },
+            required: ['project_id', 'name', 'image'],
+        },
+    },
+    {
+        name: 'ce_update_application',
+        description: 'Update an existing Code Engine application (image, scaling, etc.)',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                project_id: { type: 'string' },
+                app_name: { type: 'string' },
+                image: { type: 'string', description: 'New container image reference' },
+                scale_min_instances: { type: 'number' },
+                scale_max_instances: { type: 'number' },
+                scale_cpu_limit: { type: 'string' },
+                scale_memory_limit: { type: 'string' },
+            },
+            required: ['project_id', 'app_name'],
+        },
+    },
+    {
+        name: 'ce_delete_application',
+        description: 'Delete a Code Engine application',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                project_id: { type: 'string' },
+                app_name: { type: 'string' },
+            },
+            required: ['project_id', 'app_name'],
+        },
+    },
+    {
+        name: 'ce_list_app_instances',
+        description: 'List all running instances (pods) of a Code Engine application',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                project_id: { type: 'string' },
+                app_name: { type: 'string' },
+            },
+            required: ['project_id', 'app_name'],
+        },
+    },
+    {
+        name: 'ce_get_app_logs',
+        description: 'Get logs for a specific Code Engine application instance',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                project_id: { type: 'string' },
+                app_name: { type: 'string' },
+                instance_name: { type: 'string', description: 'Instance name (e.g. my-app-00001-deployment-abcde)' },
+            },
+            required: ['project_id', 'app_name', 'instance_name'],
+        },
+    },
+    // --- Builds ---
+    {
+        name: 'ce_list_builds',
+        description: 'List build configurations in a Code Engine project',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                project_id: { type: 'string' },
+            },
+            required: ['project_id'],
+        },
+    },
+    {
+        name: 'ce_create_build',
+        description: 'Create a build configuration for building container images from source',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                project_id: { type: 'string' },
+                name: { type: 'string', description: 'Build configuration name' },
+                output_image: { type: 'string', description: 'Output image reference (e.g. icr.io/ns/app:v1)' },
+                output_secret: { type: 'string', description: 'Registry secret name for push access' },
+                source_type: { type: 'string', enum: ['local', 'git'], description: 'Source type (default: local)' },
+                strategy_type: { type: 'string', enum: ['dockerfile', 'buildpacks'], description: 'Build strategy (default: dockerfile)' },
+                strategy_spec_file: { type: 'string', description: 'Dockerfile path (default: Dockerfile)' },
+                strategy_size: { type: 'string', enum: ['small', 'medium', 'large', 'xlarge'], description: 'Build size (default: medium)' },
+            },
+            required: ['project_id', 'name', 'output_image', 'output_secret'],
+        },
+    },
+    {
+        name: 'ce_get_build',
+        description: 'Get details of a specific Code Engine build configuration',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                project_id: { type: 'string' },
+                build_name: { type: 'string' },
+            },
+            required: ['project_id', 'build_name'],
+        },
+    },
+    {
+        name: 'ce_delete_build',
+        description: 'Delete a Code Engine build configuration',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                project_id: { type: 'string' },
+                build_name: { type: 'string' },
+            },
+            required: ['project_id', 'build_name'],
+        },
+    },
+    // --- Build Runs ---
+    {
+        name: 'ce_list_build_runs',
+        description: 'List build runs in a Code Engine project',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                project_id: { type: 'string' },
+            },
+            required: ['project_id'],
+        },
+    },
+    {
+        name: 'ce_create_build_run',
+        description: 'Start a new build run from an existing build configuration',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                project_id: { type: 'string' },
+                build_name: { type: 'string', description: 'Name of the build configuration to run' },
+                name: { type: 'string', description: 'Optional name for this build run' },
+            },
+            required: ['project_id', 'build_name'],
+        },
+    },
+    {
+        name: 'ce_get_build_run',
+        description: 'Get status and details of a build run',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                project_id: { type: 'string' },
+                build_run_name: { type: 'string' },
+            },
+            required: ['project_id', 'build_run_name'],
+        },
+    },
+    {
+        name: 'ce_delete_build_run',
+        description: 'Delete a Code Engine build run',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                project_id: { type: 'string' },
+                build_run_name: { type: 'string' },
+            },
+            required: ['project_id', 'build_run_name'],
+        },
+    },
+    // --- Jobs ---
+    {
+        name: 'ce_list_jobs',
+        description: 'List job definitions in a Code Engine project',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                project_id: { type: 'string' },
+            },
+            required: ['project_id'],
+        },
+    },
+    {
+        name: 'ce_create_job',
+        description: 'Create a job definition in Code Engine',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                project_id: { type: 'string' },
+                name: { type: 'string' },
+                image: { type: 'string', description: 'Container image reference' },
+                scale_array_spec: { type: 'string', description: 'Array indices (e.g. 0-9 for 10 instances)' },
+                scale_cpu_limit: { type: 'string' },
+                scale_memory_limit: { type: 'string' },
+                env_vars: { type: 'object' },
+            },
+            required: ['project_id', 'name', 'image'],
+        },
+    },
+    {
+        name: 'ce_create_job_run',
+        description: 'Submit a job run from an existing job definition',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                project_id: { type: 'string' },
+                job_name: { type: 'string', description: 'Job definition name to run' },
+                name: { type: 'string', description: 'Optional name for this job run' },
+            },
+            required: ['project_id', 'job_name'],
+        },
+    },
+    {
+        name: 'ce_get_job',
+        description: 'Get details of a specific Code Engine job definition',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                project_id: { type: 'string' },
+                job_name: { type: 'string' },
+            },
+            required: ['project_id', 'job_name'],
+        },
+    },
+    {
+        name: 'ce_delete_job',
+        description: 'Delete a Code Engine job definition',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                project_id: { type: 'string' },
+                job_name: { type: 'string' },
+            },
+            required: ['project_id', 'job_name'],
+        },
+    },
+    {
+        name: 'ce_list_job_runs',
+        description: 'List job runs in a Code Engine project',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                project_id: { type: 'string' },
+                job_name: { type: 'string', description: 'Filter by job definition name (optional)' },
+                limit: { type: 'number', description: 'Maximum results to return' },
+                start: { type: 'string', description: 'Pagination token' },
+            },
+            required: ['project_id'],
+        },
+    },
+    {
+        name: 'ce_get_job_run',
+        description: 'Get status and details of a job run',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                project_id: { type: 'string' },
+                job_run_name: { type: 'string' },
+            },
+            required: ['project_id', 'job_run_name'],
+        },
+    },
+    {
+        name: 'ce_delete_job_run',
+        description: 'Delete a Code Engine job run',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                project_id: { type: 'string' },
+                job_run_name: { type: 'string' },
+            },
+            required: ['project_id', 'job_run_name'],
+        },
+    },
+    // --- Secrets ---
+    {
+        name: 'ce_list_secrets',
+        description: 'List secrets in a Code Engine project',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                project_id: { type: 'string' },
+            },
+            required: ['project_id'],
+        },
+    },
+    {
+        name: 'ce_create_secret',
+        description: 'Create a secret in a Code Engine project (generic, registry, ssh_auth, etc.)',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                project_id: { type: 'string' },
+                name: { type: 'string' },
+                format: { type: 'string', enum: ['generic', 'ssh_auth', 'basic_auth', 'tls', 'registry'], description: 'Secret type' },
+                data: { type: 'object', description: 'Key/value pairs (values must be base64 encoded for binary formats)' },
+            },
+            required: ['project_id', 'name', 'format', 'data'],
+        },
+    },
+    {
+        name: 'ce_get_secret',
+        description: 'Get metadata for a specific secret (keys only, no values)',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                project_id: { type: 'string' },
+                secret_name: { type: 'string' },
+            },
+            required: ['project_id', 'secret_name'],
+        },
+    },
+    {
+        name: 'ce_delete_secret',
+        description: 'Delete a secret from a Code Engine project',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                project_id: { type: 'string' },
+                secret_name: { type: 'string' },
+            },
+            required: ['project_id', 'secret_name'],
+        },
+    },
+    // --- ConfigMaps ---
+    {
+        name: 'ce_list_config_maps',
+        description: 'List configmaps in a Code Engine project',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                project_id: { type: 'string' },
+            },
+            required: ['project_id'],
+        },
+    },
+    {
+        name: 'ce_create_config_map',
+        description: 'Create a configmap in a Code Engine project',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                project_id: { type: 'string' },
+                name: { type: 'string' },
+                data: { type: 'object', description: 'Key/value configuration data' },
+            },
+            required: ['project_id', 'name', 'data'],
+        },
+    },
+    {
+        name: 'ce_get_config_map',
+        description: 'Get details of a specific configmap in a Code Engine project',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                project_id: { type: 'string' },
+                config_map_name: { type: 'string' },
+            },
+            required: ['project_id', 'config_map_name'],
+        },
+    },
+    {
+        name: 'ce_delete_config_map',
+        description: 'Delete a configmap from a Code Engine project',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                project_id: { type: 'string' },
+                config_map_name: { type: 'string' },
+            },
+            required: ['project_id', 'config_map_name'],
+        },
+    },
+];
+// Register tools
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: [...containerTools, ...codeEngineTools],
+}));
+// Handle tool calls
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    if (!args) {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify({ error: 'Missing arguments' }),
+                },
+            ],
+            isError: true,
+        };
+    }
+    try {
+        switch (name) {
+            case 'detect_container_runtime': {
+                const { stdout: dockerVersion } = await execAsync('docker --version').catch(() => ({ stdout: '' }));
+                const { stdout: podmanVersion } = await execAsync('podman --version').catch(() => ({ stdout: '' }));
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({
+                                docker: dockerVersion ? dockerVersion.trim() : null,
+                                podman: podmanVersion ? podmanVersion.trim() : null,
+                                available: dockerVersion ? 'docker' : podmanVersion ? 'podman' : 'none',
+                            }, null, 2),
+                        },
+                    ],
+                };
+            }
+            case 'build_container_image': {
+                const runtime = args.runtime || 'docker';
+                const cmd = `${runtime} build -t ${args.image_name} -f ${args.dockerfile_path} ${args.context_path}`;
+                const { stdout, stderr } = await execAsync(cmd);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: true,
+                                command: cmd,
+                                output: stdout,
+                                error: stderr
+                            }, null, 2),
+                        },
+                    ],
+                };
+            }
+            case 'push_container_image': {
+                const runtime = args.runtime || 'docker';
+                const cmd = `${runtime} push ${args.image_name}`;
+                const { stdout, stderr } = await execAsync(cmd);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: true,
+                                command: cmd,
+                                output: stdout,
+                                error: stderr
+                            }, null, 2),
+                        },
+                    ],
+                };
+            }
+            case 'list_local_images': {
+                const runtime = args.runtime || 'docker';
+                const cmd = `${runtime} images --format "{{.Repository}}:{{.Tag}}\t{{.ID}}\t{{.Size}}"`;
+                const { stdout } = await execAsync(cmd);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: stdout,
+                        },
+                    ],
+                };
+            }
+            case 'test_container_locally': {
+                const runtime = args.runtime || 'docker';
+                let cmd = `${runtime} run -d`;
+                if (args.port_mapping) {
+                    cmd += ` -p ${args.port_mapping}`;
+                }
+                if (args.env_vars) {
+                    Object.entries(args.env_vars).forEach(([key, value]) => {
+                        cmd += ` -e ${key}="${value}"`;
+                    });
+                }
+                cmd += ` ${args.image_name}`;
+                const { stdout } = await execAsync(cmd);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({
+                                container_id: stdout.trim(),
+                                command: cmd,
+                                message: 'Container started successfully'
+                            }, null, 2),
+                        },
+                    ],
+                };
+            }
+            case 'get_container_logs': {
+                const runtime = args.runtime || 'docker';
+                const cmd = `${runtime} logs ${args.container_id}`;
+                const { stdout } = await execAsync(cmd);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: stdout,
+                        },
+                    ],
+                };
+            }
+            case 'stop_local_container': {
+                const runtime = args.runtime || 'docker';
+                const stopCmd = `${runtime} stop ${args.container_id}`;
+                const rmCmd = `${runtime} rm ${args.container_id}`;
+                await execAsync(stopCmd);
+                await execAsync(rmCmd);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: true,
+                                message: `Container ${args.container_id} stopped and removed`
+                            }, null, 2),
+                        },
+                    ],
+                };
+            }
+            case 'list_local_containers': {
+                const runtime = args.runtime || 'docker';
+                const allFlag = args.all ? '-a' : '';
+                const cmd = `${runtime} ps ${allFlag} --format "{{.ID}}\t{{.Image}}\t{{.Status}}\t{{.Ports}}"`;
+                const { stdout } = await execAsync(cmd);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: stdout,
+                        },
+                    ],
+                };
+            }
+            case 'ce_list_projects': {
+                const apiKey = getApiKey();
+                const token = await getIAMToken(apiKey);
+                const regionsToCheck = args.region ? [args.region] : CE_REGIONS;
+                const uniqueProjects = new Map();
+                await Promise.allSettled(regionsToCheck.map(async (reg) => {
+                    const response = await axios.get(`https://api.${reg}.codeengine.cloud.ibm.com/v2/projects`, { headers: { Authorization: `Bearer ${token}` } });
+                    if (response.data.projects) {
+                        response.data.projects.forEach((p) => {
+                            if (!uniqueProjects.has(p.id))
+                                uniqueProjects.set(p.id, { ...p, region: reg });
+                        });
+                    }
+                }));
+                const projects = Array.from(uniqueProjects.values());
+                return { content: [{ type: 'text', text: JSON.stringify({ projects, total: projects.length }, null, 2) }] };
+            }
+            case 'ce_get_project': {
+                const token = await getIAMToken(getApiKey());
+                const region = await getProjectRegion(args.project_id, token);
+                const response = await axios.get(`https://api.${region}.codeengine.cloud.ibm.com/v2/projects/${args.project_id}`, { headers: { Authorization: `Bearer ${token}` } });
+                return { content: [{ type: 'text', text: JSON.stringify({ ...response.data, region }, null, 2) }] };
+            }
+            case 'ce_create_project': {
+                const token = await getIAMToken(getApiKey());
+                const region = args.region;
+                const body = { name: args.name };
+                if (args.resource_group_id)
+                    body.resource_group_id = args.resource_group_id;
+                const response = await axios.post(`https://api.${region}.codeengine.cloud.ibm.com/v2/projects`, body, { headers: { Authorization: `Bearer ${token}`, 'Content-Type': 'application/json' } });
+                return { content: [{ type: 'text', text: JSON.stringify(response.data, null, 2) }] };
+            }
+            case 'ce_delete_project': {
+                const token = await getIAMToken(getApiKey());
+                const region = await getProjectRegion(args.project_id, token);
+                await axios.delete(`https://api.${region}.codeengine.cloud.ibm.com/v2/projects/${args.project_id}`, { headers: { Authorization: `Bearer ${token}` } });
+                return { content: [{ type: 'text', text: JSON.stringify({ success: true, message: `Project ${args.project_id} deleted` }, null, 2) }] };
+            }
+            case 'ce_list_applications': {
+                const token = await getIAMToken(getApiKey());
+                const { base, headers } = await ceApi(args.project_id, token);
+                const response = await axios.get(`${base}/apps`, { headers });
+                return { content: [{ type: 'text', text: JSON.stringify({ applications: response.data.apps || [], total: response.data.apps?.length || 0 }, null, 2) }] };
+            }
+            case 'ce_get_application': {
+                const token = await getIAMToken(getApiKey());
+                const { base, headers } = await ceApi(args.project_id, token);
+                const response = await axios.get(`${base}/apps/${args.app_name}`, { headers });
+                return { content: [{ type: 'text', text: JSON.stringify(response.data, null, 2) }] };
+            }
+            case 'ce_create_application': {
+                const token = await getIAMToken(getApiKey());
+                const { base, headers } = await ceApi(args.project_id, token);
+                const body = {
+                    name: args.name,
+                    image_reference: args.image,
+                    image_port: args.port ?? 8080,
+                    scale_min_instances: args.scale_min_instances ?? 0,
+                    scale_max_instances: args.scale_max_instances ?? 10,
+                    scale_cpu_limit: args.scale_cpu_limit ?? '1',
+                    scale_memory_limit: args.scale_memory_limit ?? '4G',
+                };
+                if (args.env_vars) {
+                    body.run_env_variables = Object.entries(args.env_vars).map(([name, value]) => ({
+                        type: 'literal', name, value,
+                    }));
+                }
+                const response = await axios.post(`${base}/apps`, body, { headers });
+                return { content: [{ type: 'text', text: JSON.stringify(response.data, null, 2) }] };
+            }
+            case 'ce_update_application': {
+                const token = await getIAMToken(getApiKey());
+                const { base } = await ceApi(args.project_id, token);
+                // CE PATCH requires If-Match with the current entity_tag
+                const current = await axios.get(`${base}/apps/${args.app_name}`, {
+                    headers: { Authorization: `Bearer ${token}` },
+                });
+                const entityTag = current.data.entity_tag ?? current.data.resource_version ?? '*';
+                const patch = {};
+                if (args.image)
+                    patch.image_reference = args.image;
+                if (args.scale_min_instances !== undefined)
+                    patch.scale_min_instances = args.scale_min_instances;
+                if (args.scale_max_instances !== undefined)
+                    patch.scale_max_instances = args.scale_max_instances;
+                if (args.scale_cpu_limit)
+                    patch.scale_cpu_limit = args.scale_cpu_limit;
+                if (args.scale_memory_limit)
+                    patch.scale_memory_limit = args.scale_memory_limit;
+                const response = await axios.patch(`${base}/apps/${args.app_name}`, patch, {
+                    headers: { Authorization: `Bearer ${token}`, 'Content-Type': 'application/merge-patch+json', 'If-Match': entityTag },
+                });
+                return { content: [{ type: 'text', text: JSON.stringify(response.data, null, 2) }] };
+            }
+            case 'ce_delete_application': {
+                const token = await getIAMToken(getApiKey());
+                const { base, headers } = await ceApi(args.project_id, token);
+                await axios.delete(`${base}/apps/${args.app_name}`, { headers });
+                return { content: [{ type: 'text', text: JSON.stringify({ success: true, message: `Application ${args.app_name} deleted` }, null, 2) }] };
+            }
+            case 'ce_list_app_instances': {
+                const token = await getIAMToken(getApiKey());
+                const { base, headers } = await ceApi(args.project_id, token);
+                const response = await axios.get(`${base}/apps/${args.app_name}/instances`, { headers });
+                return { content: [{ type: 'text', text: JSON.stringify({ instances: response.data.instances || [], total: response.data.instances?.length || 0 }, null, 2) }] };
+            }
+            case 'ce_get_app_logs': {
+                const token = await getIAMToken(getApiKey());
+                const { base, headers } = await ceApi(args.project_id, token);
+                try {
+                    const response = await axios.get(`${base}/apps/${args.app_name}/instances/${args.instance_name}/logs`, { headers });
+                    return { content: [{ type: 'text', text: JSON.stringify(response.data, null, 2) }] };
+                }
+                catch (err) {
+                    if (err.response?.status === 403) {
+                        return { content: [{ type: 'text', text: JSON.stringify({
+                                        note: 'App instance logs are not accessible via the Code Engine REST API v2. ' +
+                                            'Configure IBM Log Analysis (IBM Cloud Logging) for your project to retrieve logs via the IBM Cloud Logs API.',
+                                        docs: 'https://cloud.ibm.com/docs/codeengine?topic=codeengine-view-logs',
+                                        status: 403,
+                                    }, null, 2) }] };
+                    }
+                    throw err;
+                }
+            }
+            case 'ce_list_builds': {
+                const token = await getIAMToken(getApiKey());
+                const { base, headers } = await ceApi(args.project_id, token);
+                const response = await axios.get(`${base}/builds`, { headers });
+                return { content: [{ type: 'text', text: JSON.stringify({ builds: response.data.builds || [], total: response.data.builds?.length || 0 }, null, 2) }] };
+            }
+            case 'ce_get_build': {
+                const token = await getIAMToken(getApiKey());
+                const { base, headers } = await ceApi(args.project_id, token);
+                const response = await axios.get(`${base}/builds/${args.build_name}`, { headers });
+                return { content: [{ type: 'text', text: JSON.stringify(response.data, null, 2) }] };
+            }
+            case 'ce_delete_build': {
+                const token = await getIAMToken(getApiKey());
+                const { base, headers } = await ceApi(args.project_id, token);
+                await axios.delete(`${base}/builds/${args.build_name}`, { headers });
+                return { content: [{ type: 'text', text: JSON.stringify({ success: true, message: `Build ${args.build_name} deleted` }, null, 2) }] };
+            }
+            case 'ce_create_build': {
+                const token = await getIAMToken(getApiKey());
+                const { base, headers } = await ceApi(args.project_id, token);
+                const body = {
+                    name: args.name,
+                    output_image: args.output_image,
+                    output_secret: args.output_secret,
+                    source_type: args.source_type ?? 'local',
+                    strategy_type: args.strategy_type ?? 'dockerfile',
+                    strategy_spec_file: args.strategy_spec_file ?? 'Dockerfile',
+                    strategy_size: args.strategy_size ?? 'medium',
+                };
+                const response = await axios.post(`${base}/builds`, body, { headers });
+                return { content: [{ type: 'text', text: JSON.stringify(response.data, null, 2) }] };
+            }
+            case 'ce_list_build_runs': {
+                const token = await getIAMToken(getApiKey());
+                const { base, headers } = await ceApi(args.project_id, token);
+                const response = await axios.get(`${base}/build_runs`, { headers });
+                return { content: [{ type: 'text', text: JSON.stringify({ build_runs: response.data.build_runs || [], total: response.data.build_runs?.length || 0 }, null, 2) }] };
+            }
+            case 'ce_create_build_run': {
+                const token = await getIAMToken(getApiKey());
+                const { base, headers } = await ceApi(args.project_id, token);
+                const body = { build_name: args.build_name };
+                if (args.name)
+                    body.name = args.name;
+                const response = await axios.post(`${base}/build_runs`, body, { headers });
+                return { content: [{ type: 'text', text: JSON.stringify(response.data, null, 2) }] };
+            }
+            case 'ce_get_build_run': {
+                const token = await getIAMToken(getApiKey());
+                const { base, headers } = await ceApi(args.project_id, token);
+                const response = await axios.get(`${base}/build_runs/${args.build_run_name}`, { headers });
+                return { content: [{ type: 'text', text: JSON.stringify(response.data, null, 2) }] };
+            }
+            case 'ce_delete_build_run': {
+                const token = await getIAMToken(getApiKey());
+                const { base, headers } = await ceApi(args.project_id, token);
+                await axios.delete(`${base}/build_runs/${args.build_run_name}`, { headers });
+                return { content: [{ type: 'text', text: JSON.stringify({ success: true, message: `Build run ${args.build_run_name} deleted` }, null, 2) }] };
+            }
+            case 'ce_list_jobs': {
+                const token = await getIAMToken(getApiKey());
+                const { base, headers } = await ceApi(args.project_id, token);
+                const response = await axios.get(`${base}/jobs`, { headers });
+                return { content: [{ type: 'text', text: JSON.stringify({ jobs: response.data.jobs || [], total: response.data.jobs?.length || 0 }, null, 2) }] };
+            }
+            case 'ce_create_job': {
+                const token = await getIAMToken(getApiKey());
+                const { base, headers } = await ceApi(args.project_id, token);
+                const body = { name: args.name, image_reference: args.image, run_mode: 'task' };
+                if (args.scale_array_spec)
+                    body.scale_array_spec = args.scale_array_spec;
+                if (args.scale_cpu_limit)
+                    body.scale_cpu_limit = args.scale_cpu_limit;
+                if (args.scale_memory_limit)
+                    body.scale_memory_limit = args.scale_memory_limit;
+                if (args.env_vars) {
+                    body.run_env_variables = Object.entries(args.env_vars).map(([name, value]) => ({
+                        type: 'literal', name, value,
+                    }));
+                }
+                const response = await axios.post(`${base}/jobs`, body, { headers });
+                return { content: [{ type: 'text', text: JSON.stringify(response.data, null, 2) }] };
+            }
+            case 'ce_create_job_run': {
+                const token = await getIAMToken(getApiKey());
+                const { base, headers } = await ceApi(args.project_id, token);
+                const body = { job_name: args.job_name };
+                if (args.name)
+                    body.name = args.name;
+                const response = await axios.post(`${base}/job_runs`, body, { headers });
+                return { content: [{ type: 'text', text: JSON.stringify(response.data, null, 2) }] };
+            }
+            case 'ce_get_job': {
+                const token = await getIAMToken(getApiKey());
+                const { base, headers } = await ceApi(args.project_id, token);
+                const response = await axios.get(`${base}/jobs/${args.job_name}`, { headers });
+                return { content: [{ type: 'text', text: JSON.stringify(response.data, null, 2) }] };
+            }
+            case 'ce_delete_job': {
+                const token = await getIAMToken(getApiKey());
+                const { base, headers } = await ceApi(args.project_id, token);
+                await axios.delete(`${base}/jobs/${args.job_name}`, { headers });
+                return { content: [{ type: 'text', text: JSON.stringify({ success: true, message: `Job ${args.job_name} deleted` }, null, 2) }] };
+            }
+            case 'ce_list_job_runs': {
+                const token = await getIAMToken(getApiKey());
+                const { base, headers } = await ceApi(args.project_id, token);
+                const params = {};
+                if (args.job_name)
+                    params.job_name = args.job_name;
+                if (args.limit)
+                    params.limit = args.limit;
+                if (args.start)
+                    params.start = args.start;
+                const response = await axios.get(`${base}/job_runs`, { headers, params });
+                return { content: [{ type: 'text', text: JSON.stringify({ job_runs: response.data.job_runs || [], total: response.data.job_runs?.length || 0 }, null, 2) }] };
+            }
+            case 'ce_get_job_run': {
+                const token = await getIAMToken(getApiKey());
+                const { base, headers } = await ceApi(args.project_id, token);
+                const response = await axios.get(`${base}/job_runs/${args.job_run_name}`, { headers });
+                return { content: [{ type: 'text', text: JSON.stringify(response.data, null, 2) }] };
+            }
+            case 'ce_delete_job_run': {
+                const token = await getIAMToken(getApiKey());
+                const { base, headers } = await ceApi(args.project_id, token);
+                await axios.delete(`${base}/job_runs/${args.job_run_name}`, { headers });
+                return { content: [{ type: 'text', text: JSON.stringify({ success: true, message: `Job run ${args.job_run_name} deleted` }, null, 2) }] };
+            }
+            case 'ce_list_secrets': {
+                const token = await getIAMToken(getApiKey());
+                const { base, headers } = await ceApi(args.project_id, token);
+                const response = await axios.get(`${base}/secrets`, { headers });
+                // Omit secret data values from the listing for security
+                const secrets = (response.data.secrets || []).map((s) => ({
+                    name: s.name, format: s.format, created_at: s.created_at,
+                    keys: s.data ? Object.keys(s.data) : [],
+                }));
+                return { content: [{ type: 'text', text: JSON.stringify({ secrets, total: secrets.length }, null, 2) }] };
+            }
+            case 'ce_create_secret': {
+                const token = await getIAMToken(getApiKey());
+                const { base, headers } = await ceApi(args.project_id, token);
+                const body = { name: args.name, format: args.format, data: args.data };
+                const response = await axios.post(`${base}/secrets`, body, { headers });
+                return { content: [{ type: 'text', text: JSON.stringify({ name: response.data.name, format: response.data.format, created_at: response.data.created_at }, null, 2) }] };
+            }
+            case 'ce_get_secret': {
+                const token = await getIAMToken(getApiKey());
+                const { base, headers } = await ceApi(args.project_id, token);
+                const response = await axios.get(`${base}/secrets/${args.secret_name}`, { headers });
+                // Return metadata only — omit secret payload for security
+                const s = response.data;
+                return { content: [{ type: 'text', text: JSON.stringify({ name: s.name, format: s.format, created_at: s.created_at, keys: s.data ? Object.keys(s.data) : [] }, null, 2) }] };
+            }
+            case 'ce_delete_secret': {
+                const token = await getIAMToken(getApiKey());
+                const { base, headers } = await ceApi(args.project_id, token);
+                await axios.delete(`${base}/secrets/${args.secret_name}`, { headers });
+                return { content: [{ type: 'text', text: JSON.stringify({ success: true, message: `Secret ${args.secret_name} deleted` }, null, 2) }] };
+            }
+            case 'ce_list_config_maps': {
+                const token = await getIAMToken(getApiKey());
+                const { base, headers } = await ceApi(args.project_id, token);
+                const response = await axios.get(`${base}/config_maps`, { headers });
+                return { content: [{ type: 'text', text: JSON.stringify({ config_maps: response.data.config_maps || [], total: response.data.config_maps?.length || 0 }, null, 2) }] };
+            }
+            case 'ce_create_config_map': {
+                const token = await getIAMToken(getApiKey());
+                const { base, headers } = await ceApi(args.project_id, token);
+                const body = { name: args.name, data: args.data };
+                const response = await axios.post(`${base}/config_maps`, body, { headers });
+                return { content: [{ type: 'text', text: JSON.stringify(response.data, null, 2) }] };
+            }
+            case 'ce_get_config_map': {
+                const token = await getIAMToken(getApiKey());
+                const { base, headers } = await ceApi(args.project_id, token);
+                const response = await axios.get(`${base}/config_maps/${args.config_map_name}`, { headers });
+                return { content: [{ type: 'text', text: JSON.stringify(response.data, null, 2) }] };
+            }
+            case 'ce_delete_config_map': {
+                const token = await getIAMToken(getApiKey());
+                const { base, headers } = await ceApi(args.project_id, token);
+                await axios.delete(`${base}/config_maps/${args.config_map_name}`, { headers });
+                return { content: [{ type: 'text', text: JSON.stringify({ success: true, message: `ConfigMap ${args.config_map_name} deleted` }, null, 2) }] };
+            }
+            default:
+                throw new Error(`Unknown tool: ${name}`);
+        }
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify({
+                        error: error.message,
+                        stderr: error.stderr,
+                        stdout: error.stdout
+                    }, null, 2),
+                },
+            ],
+            isError: true,
+        };
+    }
+});
+// Start server
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error('Code Engine MCP Server running on stdio');
+}
+main().catch((error) => {
+    console.error('Server error:', error);
+    process.exit(1);
+});
+// Made by MVK
+//# sourceMappingURL=index.js.map