bamboo-mcp-server 1.0.0

package/dist/tools/builds.js

@@ -0,0 +1,221 @@
+import { z } from 'zod';
+export function registerBuildTools(server, client) {
+    // Trigger build
+    server.tool('bamboo_trigger_build', 'Trigger a build for a Bamboo plan', {
+        plan_key: z.string().describe('The plan key to build (e.g., "PROJ-PLAN")'),
+        stage: z.string().optional().describe('Specific stage to execute'),
+        execute_all_stages: z.boolean().optional().describe('Execute all stages (default: true)'),
+        custom_revision: z.string().optional().describe('Custom VCS revision to build'),
+        variables: z.record(z.string()).optional().describe('Bamboo variables to pass to the build (key-value pairs)'),
+    }, async ({ plan_key, stage, execute_all_stages, custom_revision, variables }) => {
+        try {
+            const result = await client.triggerBuild(plan_key, {
+                stage,
+                executeAllStages: execute_all_stages,
+                customRevision: custom_revision,
+                variables,
+            });
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(result, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    // Stop build
+    server.tool('bamboo_stop_build', 'Stop a running build for a Bamboo plan', {
+        plan_key: z.string().describe('The plan key to stop (e.g., "PROJ-PLAN")'),
+    }, async ({ plan_key }) => {
+        try {
+            const result = await client.stopBuild(plan_key);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(result, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    // Get build result
+    server.tool('bamboo_get_build_result', 'Get the result of a specific build', {
+        build_key: z.string().describe('The build result key (e.g., "PROJ-PLAN-123")'),
+        expand: z.string().optional().describe('Fields to expand (e.g., "changes,artifacts,testResults")'),
+    }, async ({ build_key, expand }) => {
+        try {
+            const result = await client.getBuildResult(build_key, expand);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(result, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    // Get latest build result
+    server.tool('bamboo_get_latest_result', 'Get the latest build result for a plan', {
+        plan_key: z.string().describe('The plan key (e.g., "PROJ-PLAN")'),
+        expand: z.string().optional().describe('Fields to expand (e.g., "changes,artifacts,testResults")'),
+    }, async ({ plan_key, expand }) => {
+        try {
+            const result = await client.getLatestBuildResult(plan_key, expand);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(result, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    // List build results
+    server.tool('bamboo_list_build_results', 'List build results with optional filters', {
+        project_key: z.string().optional().describe('Filter by project key'),
+        plan_key: z.string().optional().describe('Filter by plan key (requires project_key)'),
+        build_state: z.string().optional().describe('Filter by build state (e.g., "Successful", "Failed")'),
+        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)'),
+        expand: z.string().optional().describe('Fields to expand in the response'),
+        include_all_states: z.boolean().optional().describe('Include all build states including in-progress'),
+    }, async ({ project_key, plan_key, build_state, start_index, max_results, expand, include_all_states }) => {
+        try {
+            const results = await client.listBuildResults({
+                projectKey: project_key,
+                planKey: plan_key,
+                buildState: build_state,
+                startIndex: start_index,
+                maxResults: max_results,
+                expand,
+                includeAllStates: include_all_states,
+            });
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(results, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    // Get build logs
+    server.tool('bamboo_get_build_logs', 'Get the build logs for a specific build. Returns log file URLs that can be accessed via browser.', {
+        build_key: z.string().describe('The build result key (e.g., "PROJ-PLAN-123")'),
+        job_key: z.string().optional().describe('Specific job key to get logs for'),
+    }, async ({ build_key, job_key }) => {
+        try {
+            const logs = await client.getBuildLogs(build_key, job_key);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(logs, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    // Get build result with log content
+    server.tool('bamboo_get_build_result_logs', 'Get build result with actual log content. For plan builds, fetches logs from all jobs. For job builds, returns logs directly.', {
+        build_key: z.string().describe('The build result key - can be plan level (e.g., "PROJ-PLAN-123") or job level (e.g., "PROJ-PLAN-JOB1-123")'),
+        max_log_lines: z.number().optional().describe('Maximum number of log lines per job (default: 100)'),
+    }, async ({ build_key, max_log_lines }) => {
+        try {
+            const result = await client.getBuildResultWithLogs(build_key, {
+                maxLogLines: max_log_lines,
+            });
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(result, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+}

package/dist/tools/deployments.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 registerDeploymentTools(server: McpServer, client: BambooClient): void;

package/dist/tools/deployments.js

@@ -0,0 +1,147 @@
+import { z } from 'zod';
+export function registerDeploymentTools(server, client) {
+    // List deployment projects
+    server.tool('bamboo_list_deployment_projects', 'List all Bamboo deployment projects', {}, async () => {
+        try {
+            const projects = await client.listDeploymentProjects();
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(projects, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    // Get deployment project
+    server.tool('bamboo_get_deployment_project', 'Get details of a specific deployment project', {
+        project_id: z.string().describe('The deployment project ID'),
+    }, async ({ project_id }) => {
+        try {
+            const project = await client.getDeploymentProject(project_id);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(project, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    // Trigger deployment
+    server.tool('bamboo_trigger_deployment', 'Trigger a deployment to an environment', {
+        version_id: z.string().describe('The release version ID to deploy'),
+        environment_id: z.string().describe('The target environment ID'),
+    }, async ({ version_id, environment_id }) => {
+        try {
+            const result = await client.triggerDeployment(version_id, environment_id);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(result, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    // Get deployment results
+    server.tool('bamboo_get_deployment_results', 'Get deployment results for an environment', {
+        environment_id: z.string().describe('The environment ID'),
+        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 ({ environment_id, start_index, max_results }) => {
+        try {
+            const results = await client.getDeploymentResults(environment_id, {
+                startIndex: start_index,
+                maxResults: max_results,
+            });
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(results, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    // Get deployment result with logs
+    server.tool('bamboo_get_deployment_result', 'Get a specific deployment result with optional logs', {
+        deployment_result_id: z.string().describe('The deployment result ID'),
+        include_logs: z.boolean().optional().describe('Include log entries (default: false)'),
+        max_log_lines: z.number().optional().describe('Maximum number of log lines to return, most recent first (default: 100)'),
+    }, async ({ deployment_result_id, include_logs, max_log_lines }) => {
+        try {
+            const result = await client.getDeploymentResult(deployment_result_id, {
+                includeLogs: include_logs,
+                maxLogLines: max_log_lines,
+            });
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(result, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+}

package/dist/tools/plans.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 registerPlanTools(server: McpServer, client: BambooClient): void;

package/dist/tools/plans.js

@@ -0,0 +1,152 @@
+import { z } from 'zod';
+export function registerPlanTools(server, client) {
+    // List plans
+    server.tool('bamboo_list_plans', 'List all Bamboo build plans', {
+        expand: z.string().optional().describe('Fields to expand in the response (e.g., "plans.plan.stages")'),
+        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 ({ expand, start_index, max_results }) => {
+        try {
+            const plans = await client.listPlans({
+                expand,
+                startIndex: start_index,
+                maxResults: max_results,
+            });
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(plans, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    // Get plan
+    server.tool('bamboo_get_plan', 'Get details of a specific Bamboo build plan by key', {
+        plan_key: z.string().describe('The plan key (e.g., "PROJ-PLAN")'),
+        expand: z.string().optional().describe('Fields to expand in the response'),
+    }, async ({ plan_key, expand }) => {
+        try {
+            const plan = await client.getPlan(plan_key, expand);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(plan, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    // Search plans
+    server.tool('bamboo_search_plans', 'Search for Bamboo build plans by name', {
+        name: z.string().describe('The plan name to search for'),
+        fuzzy: z.boolean().optional().describe('Enable fuzzy matching (default: true)'),
+        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 ({ name, fuzzy, start_index, max_results }) => {
+        try {
+            const plans = await client.searchPlans(name, {
+                fuzzy,
+                startIndex: start_index,
+                maxResults: max_results,
+            });
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(plans, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    // Enable plan
+    server.tool('bamboo_enable_plan', 'Enable a Bamboo build plan', {
+        plan_key: z.string().describe('The plan key to enable (e.g., "PROJ-PLAN")'),
+    }, async ({ plan_key }) => {
+        try {
+            await client.enablePlan(plan_key);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Plan ${plan_key} has been enabled successfully.`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    // Disable plan
+    server.tool('bamboo_disable_plan', 'Disable a Bamboo build plan', {
+        plan_key: z.string().describe('The plan key to disable (e.g., "PROJ-PLAN")'),
+    }, async ({ plan_key }) => {
+        try {
+            await client.disablePlan(plan_key);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Plan ${plan_key} has been disabled successfully.`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+}

package/dist/tools/projects.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 registerProjectTools(server: McpServer, client: BambooClient): void;

package/dist/tools/projects.js

@@ -0,0 +1,64 @@
+import { z } from 'zod';
+export function registerProjectTools(server, client) {
+    // List projects
+    server.tool('bamboo_list_projects', 'List all Bamboo projects', {
+        expand: z.string().optional().describe('Fields to expand in the response (e.g., "projects.project.plans")'),
+        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 ({ expand, start_index, max_results }) => {
+        try {
+            const projects = await client.listProjects({
+                expand,
+                startIndex: start_index,
+                maxResults: max_results,
+            });
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(projects, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    // Get project
+    server.tool('bamboo_get_project', 'Get details of a specific Bamboo project by key', {
+        project_key: z.string().describe('The project key (e.g., "PROJ")'),
+        expand: z.string().optional().describe('Fields to expand in the response'),
+    }, async ({ project_key, expand }) => {
+        try {
+            const project = await client.getProject(project_key, expand);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(project, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+}

package/dist/tools/queue.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 registerQueueTools(server: McpServer, client: BambooClient): void;

package/dist/tools/queue.js

@@ -0,0 +1,55 @@
+import { z } from 'zod';
+export function registerQueueTools(server, client) {
+    // Get build queue
+    server.tool('bamboo_get_build_queue', 'Get the current Bamboo build queue', {
+        expand: z.string().optional().describe('Fields to expand (default: "queuedBuilds")'),
+    }, async ({ expand }) => {
+        try {
+            const queue = await client.getBuildQueue(expand);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(queue, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    // Get deployment queue
+    server.tool('bamboo_get_deployment_queue', 'Get the current Bamboo deployment queue', {}, async () => {
+        try {
+            const queue = await client.getDeploymentQueue();
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(queue, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+}

package/dist/tools/server.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 registerServerTools(server: McpServer, client: BambooClient): void;