bamboo-mcp-server 1.0.0

package/dist/bamboo-client.js

@@ -0,0 +1,363 @@
+import { ProxyAgent, fetch as undiciFetch } from 'undici';
+export class BambooClient {
+    baseUrl;
+    token;
+    proxyAgent;
+    constructor(config) {
+        this.baseUrl = config.baseUrl.replace(/\/$/, ''); // Remove trailing slash
+        this.token = config.token;
+        if (config.proxyUrl) {
+            this.proxyAgent = new ProxyAgent(config.proxyUrl);
+        }
+    }
+    async request(endpoint, options = {}) {
+        const url = `${this.baseUrl}/rest/api/latest${endpoint}`;
+        const headers = {
+            'Authorization': `Bearer ${this.token}`,
+            'Accept': 'application/json',
+            'Content-Type': 'application/json',
+            ...(options.headers || {}),
+        };
+        const fetchOptions = {
+            ...options,
+            headers,
+        };
+        // Add proxy agent if configured
+        if (this.proxyAgent) {
+            fetchOptions.dispatcher = this.proxyAgent;
+        }
+        const response = await undiciFetch(url, fetchOptions);
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`Bamboo API error (${response.status}): ${errorText}`);
+        }
+        // Handle empty responses
+        const text = await response.text();
+        if (!text) {
+            return {};
+        }
+        return JSON.parse(text);
+    }
+    // Server endpoints
+    async getServerInfo() {
+        return this.request('/info');
+    }
+    async healthCheck() {
+        return this.request('/server');
+    }
+    // Project endpoints
+    async listProjects(params) {
+        const searchParams = new URLSearchParams();
+        if (params?.expand)
+            searchParams.set('expand', params.expand);
+        if (params?.startIndex)
+            searchParams.set('start-index', String(params.startIndex));
+        if (params?.maxResults)
+            searchParams.set('max-result', String(params.maxResults));
+        const query = searchParams.toString();
+        return this.request(`/project${query ? `?${query}` : ''}`);
+    }
+    async getProject(projectKey, expand) {
+        const query = expand ? `?expand=${expand}` : '';
+        return this.request(`/project/${projectKey}${query}`);
+    }
+    // Plan endpoints
+    async listPlans(params) {
+        const searchParams = new URLSearchParams();
+        if (params?.expand)
+            searchParams.set('expand', params.expand);
+        if (params?.startIndex)
+            searchParams.set('start-index', String(params.startIndex));
+        if (params?.maxResults)
+            searchParams.set('max-result', String(params.maxResults));
+        const query = searchParams.toString();
+        return this.request(`/plan${query ? `?${query}` : ''}`);
+    }
+    async getPlan(planKey, expand) {
+        const query = expand ? `?expand=${expand}` : '';
+        return this.request(`/plan/${planKey}${query}`);
+    }
+    async searchPlans(name, params) {
+        const searchParams = new URLSearchParams();
+        searchParams.set('searchTerm', name);
+        if (params?.fuzzy !== undefined)
+            searchParams.set('fuzzy', String(params.fuzzy));
+        if (params?.startIndex)
+            searchParams.set('start-index', String(params.startIndex));
+        if (params?.maxResults)
+            searchParams.set('max-result', String(params.maxResults));
+        return this.request(`/search/plans?${searchParams.toString()}`);
+    }
+    async enablePlan(planKey) {
+        return this.request(`/plan/${planKey}/enable`, { method: 'POST' });
+    }
+    async disablePlan(planKey) {
+        return this.request(`/plan/${planKey}/enable`, { method: 'DELETE' });
+    }
+    // Branch endpoints
+    async listPlanBranches(planKey, params) {
+        const searchParams = new URLSearchParams();
+        if (params?.enabledOnly !== undefined)
+            searchParams.set('enabledOnly', String(params.enabledOnly));
+        if (params?.startIndex)
+            searchParams.set('start-index', String(params.startIndex));
+        if (params?.maxResults)
+            searchParams.set('max-result', String(params.maxResults));
+        const query = searchParams.toString();
+        return this.request(`/plan/${planKey}/branch${query ? `?${query}` : ''}`);
+    }
+    async getPlanBranch(planKey, branchName) {
+        return this.request(`/plan/${planKey}/branch/${encodeURIComponent(branchName)}`);
+    }
+    // Build endpoints
+    async triggerBuild(planKey, params) {
+        const searchParams = new URLSearchParams();
+        if (params?.stage)
+            searchParams.set('stage', params.stage);
+        if (params?.executeAllStages !== undefined) {
+            searchParams.set('executeAllStages', String(params.executeAllStages));
+        }
+        if (params?.customRevision)
+            searchParams.set('customRevision', params.customRevision);
+        // Add bamboo variables
+        if (params?.variables) {
+            for (const [key, value] of Object.entries(params.variables)) {
+                searchParams.set(`bamboo.variable.${key}`, value);
+            }
+        }
+        const query = searchParams.toString();
+        return this.request(`/queue/${planKey}${query ? `?${query}` : ''}`, { method: 'POST' });
+    }
+    async stopBuild(planKey) {
+        // To stop a build, we need to DELETE the job keys (not the plan key)
+        // First, check if the plan is currently building
+        const plan = await this.request(`/plan/${planKey}`);
+        if (!plan.isBuilding) {
+            return {
+                message: `Plan ${planKey} is not currently building`,
+                success: false
+            };
+        }
+        // Get the list of results including in-progress builds
+        const results = await this.request(`/result/${planKey}?includeAllStates=true&max-result=5`);
+        // Find the in-progress build
+        const runningBuild = results.results?.result?.find(r => r.lifeCycleState === 'InProgress');
+        if (!runningBuild) {
+            return {
+                message: `No running build found for plan ${planKey}`,
+                success: false
+            };
+        }
+        // Get the running build with job details
+        const buildResult = await this.request(`/result/${runningBuild.key}?expand=stages.stage.results.result`);
+        // Find all jobs and stop them
+        const stoppedJobs = [];
+        const failedJobs = [];
+        if (buildResult.stages?.stage) {
+            for (const stage of buildResult.stages.stage) {
+                if (stage.results?.result) {
+                    for (const job of stage.results.result) {
+                        if (job.lifeCycleState === 'InProgress' || job.lifeCycleState === 'Pending' || job.lifeCycleState === 'Queued') {
+                            try {
+                                await this.request(`/queue/${job.key}`, { method: 'DELETE' });
+                                stoppedJobs.push(job.key);
+                            }
+                            catch {
+                                failedJobs.push(job.key);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return {
+            message: stoppedJobs.length > 0
+                ? `Stopped ${stoppedJobs.length} job(s) for build ${runningBuild.key}`
+                : `No running jobs found to stop for build ${runningBuild.key}`,
+            buildKey: runningBuild.key,
+            stoppedJobs,
+            failedJobs,
+            success: stoppedJobs.length > 0
+        };
+    }
+    async getBuildResult(buildKey, expand) {
+        const query = expand ? `?expand=${expand}` : '';
+        return this.request(`/result/${buildKey}${query}`);
+    }
+    async getLatestBuildResult(planKey, expand) {
+        const query = expand ? `?expand=${expand}` : '';
+        return this.request(`/result/${planKey}/latest${query}`);
+    }
+    async listBuildResults(params) {
+        const searchParams = new URLSearchParams();
+        if (params?.buildState)
+            searchParams.set('buildstate', params.buildState);
+        if (params?.startIndex)
+            searchParams.set('start-index', String(params.startIndex));
+        if (params?.maxResults)
+            searchParams.set('max-result', String(params.maxResults));
+        if (params?.expand)
+            searchParams.set('expand', params.expand);
+        if (params?.includeAllStates)
+            searchParams.set('includeAllStates', 'true');
+        let endpoint = '/result';
+        if (params?.projectKey && params?.planKey) {
+            endpoint = `/result/${params.projectKey}-${params.planKey}`;
+        }
+        else if (params?.projectKey) {
+            endpoint = `/result/${params.projectKey}`;
+        }
+        const query = searchParams.toString();
+        return this.request(`${endpoint}${query ? `?${query}` : ''}`);
+    }
+    async getBuildLogs(buildKey, jobKey) {
+        // Build logs are obtained by getting the job result with logFiles expand
+        // The buildKey should be a job result key (e.g., PROJ-PLAN-JOB1-123)
+        // If only a plan result key is provided (e.g., PROJ-PLAN-123), we need to find the job keys first
+        if (jobKey) {
+            // If job key provided, construct the full job result key
+            const jobResultKey = `${buildKey.replace(/-\d+$/, '')}-${jobKey}-${buildKey.split('-').pop()}`;
+            const result = await this.request(`/result/${jobResultKey}?expand=logFiles`);
+            return {
+                buildKey: jobResultKey,
+                logFiles: result.logFiles || [],
+                message: result.logFiles?.length
+                    ? 'Log files are available via the URLs below. These require browser authentication to download.'
+                    : 'No log files found for this build.'
+            };
+        }
+        // Try to get the build result with stages to find job results
+        const result = await this.request(`/result/${buildKey}?expand=stages.stage.results.result`);
+        // Extract log files from all jobs
+        const allLogs = [];
+        if (result.stages?.stage) {
+            for (const stage of result.stages.stage) {
+                if (stage.results?.result) {
+                    for (const job of stage.results.result) {
+                        if (job.logFiles && job.logFiles.length > 0) {
+                            allLogs.push({
+                                jobKey: job.key,
+                                logFiles: job.logFiles
+                            });
+                        }
+                    }
+                }
+            }
+        }
+        return {
+            buildKey,
+            jobs: allLogs,
+            message: allLogs.length
+                ? 'Log files are available via the URLs below. These require browser authentication to download.'
+                : 'No log files found for this build.'
+        };
+    }
+    async getBuildResultWithLogs(buildKey, params) {
+        // First, try to get the result with logEntries (works for job-level keys)
+        const maxResult = params?.maxLogLines || 100;
+        const result = await this.request(`/result/${buildKey}?expand=logEntries,stages.stage.results.result&max-result=${maxResult}`);
+        // If logEntries exists and has entries, this is a job result - return directly
+        if (result.logEntries?.logEntry && result.logEntries.logEntry.length > 0) {
+            return result;
+        }
+        // This is a plan result - fetch logs from all jobs
+        const jobLogs = [];
+        if (result.stages?.stage) {
+            for (const stage of result.stages.stage) {
+                if (stage.results?.result) {
+                    for (const job of stage.results.result) {
+                        // Fetch logs for each job
+                        const jobResult = await this.request(`/result/${job.key}?expand=logEntries&max-result=${maxResult}`);
+                        jobLogs.push({
+                            jobKey: job.key,
+                            jobName: job.key.split('-').slice(-2, -1)[0], // Extract job name from key
+                            buildState: jobResult.buildState,
+                            logEntries: {
+                                size: jobResult.logEntries?.size || 0,
+                                logs: (jobResult.logEntries?.logEntry || []).map(entry => ({
+                                    date: entry.formattedDate,
+                                    log: entry.unstyledLog
+                                }))
+                            }
+                        });
+                    }
+                }
+            }
+        }
+        return {
+            key: result.key,
+            buildState: result.buildState,
+            lifeCycleState: result.lifeCycleState,
+            isJobResult: false,
+            jobs: jobLogs,
+            totalLogEntries: jobLogs.reduce((sum, job) => sum + job.logEntries.size, 0)
+        };
+    }
+    // Queue endpoints
+    async getBuildQueue(expand) {
+        const query = expand ? `?expand=${expand}` : '?expand=queuedBuilds';
+        return this.request(`/queue${query}`);
+    }
+    async getDeploymentQueue() {
+        // Note: The deployment queue endpoint is not available in all Bamboo versions
+        // We'll try to get it from the deployment dashboard instead
+        try {
+            // Try the standard endpoint first
+            return await this.request('/deploy/queue?expand=queuedDeployments');
+        }
+        catch {
+            // If that fails, return info about checking deployment results instead
+            return {
+                message: 'Deployment queue endpoint not available in this Bamboo version. Use bamboo_get_deployment_results to check deployment status for specific environments.',
+                available: false
+            };
+        }
+    }
+    // Deployment endpoints
+    async listDeploymentProjects() {
+        return this.request('/deploy/project/all');
+    }
+    async getDeploymentProject(projectId) {
+        return this.request(`/deploy/project/${projectId}`);
+    }
+    async triggerDeployment(versionId, environmentId) {
+        return this.request(`/queue/deployment?versionId=${versionId}&environmentId=${environmentId}`, { method: 'POST' });
+    }
+    async getDeploymentResults(environmentId, params) {
+        const searchParams = new URLSearchParams();
+        if (params?.startIndex)
+            searchParams.set('start-index', String(params.startIndex));
+        if (params?.maxResults)
+            searchParams.set('max-result', String(params.maxResults));
+        const query = searchParams.toString();
+        return this.request(`/deploy/environment/${environmentId}/results${query ? `?${query}` : ''}`);
+    }
+    async getDeploymentResult(deploymentResultId, params) {
+        const searchParams = new URLSearchParams();
+        if (params?.includeLogs) {
+            searchParams.set('includeLogs', 'true');
+            if (params?.maxLogLines) {
+                searchParams.set('max-result', String(params.maxLogLines));
+            }
+        }
+        const query = searchParams.toString();
+        return this.request(`/deploy/result/${deploymentResultId}${query ? `?${query}` : ''}`);
+    }
+}
+// Factory function to create client from environment variables
+export function createBambooClientFromEnv() {
+    const baseUrl = process.env.BAMBOO_URL;
+    const token = process.env.BAMBOO_TOKEN;
+    const proxyUrl = process.env.BAMBOO_PROXY;
+    if (!baseUrl) {
+        throw new Error('BAMBOO_URL environment variable is required');
+    }
+    if (!token) {
+        throw new Error('BAMBOO_TOKEN environment variable is required');
+    }
+    return new BambooClient({
+        baseUrl,
+        token,
+        proxyUrl,
+    });
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,44 @@
+#!/usr/bin/env node
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { createBambooClientFromEnv } from './bamboo-client.js';
+import { registerServerTools } from './tools/server.js';
+import { registerProjectTools } from './tools/projects.js';
+import { registerPlanTools } from './tools/plans.js';
+import { registerBranchTools } from './tools/branches.js';
+import { registerBuildTools } from './tools/builds.js';
+import { registerQueueTools } from './tools/queue.js';
+import { registerDeploymentTools } from './tools/deployments.js';
+async function main() {
+    // Create the Bamboo client from environment variables
+    const client = createBambooClientFromEnv();
+    // Create the MCP server
+    const server = new McpServer({
+        name: 'bamboo-mcp-server',
+        version: '1.0.0',
+    });
+    // Register all tools
+    registerServerTools(server, client);
+    registerProjectTools(server, client);
+    registerPlanTools(server, client);
+    registerBranchTools(server, client);
+    registerBuildTools(server, client);
+    registerQueueTools(server, client);
+    registerDeploymentTools(server, client);
+    // Connect via stdio transport
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    // Handle graceful shutdown
+    process.on('SIGINT', async () => {
+        await server.close();
+        process.exit(0);
+    });
+    process.on('SIGTERM', async () => {
+        await server.close();
+        process.exit(0);
+    });
+}
+main().catch((error) => {
+    console.error('Fatal error:', error);
+    process.exit(1);
+});

package/dist/tools/branches.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { BambooClient } from '../bamboo-client.js';
+export declare function registerBranchTools(server: McpServer, client: BambooClient): void;

package/dist/tools/branches.js

@@ -0,0 +1,65 @@
+import { z } from 'zod';
+export function registerBranchTools(server, client) {
+    // List plan branches
+    server.tool('bamboo_list_plan_branches', 'List all branches for a Bamboo build plan', {
+        plan_key: z.string().describe('The plan key (e.g., "PROJ-PLAN")'),
+        enabled_only: z.boolean().optional().describe('Only return enabled branches'),
+        start_index: z.number().optional().describe('Starting index for pagination (default: 0)'),
+        max_results: z.number().optional().describe('Maximum number of results to return (default: 25)'),
+    }, async ({ plan_key, enabled_only, start_index, max_results }) => {
+        try {
+            const branches = await client.listPlanBranches(plan_key, {
+                enabledOnly: enabled_only,
+                startIndex: start_index,
+                maxResults: max_results,
+            });
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(branches, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    // Get plan branch
+    server.tool('bamboo_get_plan_branch', 'Get details of a specific plan branch', {
+        plan_key: z.string().describe('The plan key (e.g., "PROJ-PLAN")'),
+        branch_name: z.string().describe('The branch name'),
+    }, async ({ plan_key, branch_name }) => {
+        try {
+            const branch = await client.getPlanBranch(plan_key, branch_name);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(branch, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+}

package/dist/tools/builds.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { BambooClient } from '../bamboo-client.js';
+export declare function registerBuildTools(server: McpServer, client: BambooClient): void;