@aaronsb/jira-cloud-mcp 0.1.0

package/build/health-check.js

@@ -0,0 +1,67 @@
+#!/usr/bin/env node
+import axios from 'axios';
+/**
+ * Health check script for container monitoring
+ * Verifies:
+ * 1. Environment variables are set
+ * 2. Jira API is accessible
+ * 3. Required directories exist and are writable
+ */
+export async function checkEnvironmentVariables() {
+    const required = ['JIRA_API_TOKEN', 'JIRA_EMAIL', 'JIRA_HOST'];
+    const missing = required.filter(v => !process.env[v]);
+    if (missing.length > 0) {
+        console.error(`Missing required environment variables: ${missing.join(', ')}`);
+        return false;
+    }
+    return true;
+}
+export async function checkJiraAccess() {
+    const baseURL = `https://${process.env.JIRA_HOST}/rest/api/3`;
+    const auth = {
+        username: process.env.JIRA_EMAIL,
+        password: process.env.JIRA_API_TOKEN
+    };
+    try {
+        await axios.get(`${baseURL}/myself`, { auth });
+        return true;
+    }
+    catch (error) {
+        console.error('Failed to access Jira API:', error);
+        return false;
+    }
+}
+export async function checkDirectories() {
+    const fs = await import('fs/promises');
+    const directories = ['/app/config', '/app/logs'];
+    try {
+        for (const dir of directories) {
+            await fs.access(dir, fs.constants.W_OK);
+        }
+        return true;
+    }
+    catch (error) {
+        console.error('Directory check failed:', error);
+        return false;
+    }
+}
+export async function main() {
+    try {
+        const envCheck = await checkEnvironmentVariables();
+        const jiraCheck = await checkJiraAccess();
+        const dirCheck = await checkDirectories();
+        if (envCheck && jiraCheck && dirCheck) {
+            console.log('Health check passed');
+            process.exit(0);
+        }
+        else {
+            console.error('Health check failed');
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        console.error('Health check error:', error);
+        process.exit(1);
+    }
+}
+main();

package/build/index.js

@@ -0,0 +1,141 @@
+#!/usr/bin/env node
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CallToolRequestSchema, ErrorCode, ListResourcesRequestSchema, ListResourceTemplatesRequestSchema, ListToolsRequestSchema, McpError, ReadResourceRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+import { JiraClient } from './client/jira-client.js';
+import { setupBoardHandlers } from './handlers/board-handlers.js';
+import { setupFilterHandlers } from './handlers/filter-handlers.js';
+import { setupIssueHandlers } from './handlers/issue-handlers.js';
+import { setupProjectHandlers } from './handlers/project-handlers.js';
+import { setupResourceHandlers } from './handlers/resource-handlers.js';
+import { setupSprintHandlers } from './handlers/sprint-handlers.js';
+import { toolSchemas } from './schemas/tool-schemas.js';
+// Jira credentials from environment variables
+const JIRA_EMAIL = process.env.JIRA_EMAIL;
+const JIRA_API_TOKEN = process.env.JIRA_API_TOKEN;
+const JIRA_HOST = process.env.JIRA_HOST;
+if (!JIRA_EMAIL || !JIRA_API_TOKEN || !JIRA_HOST) {
+    throw new Error('Missing required Jira credentials in environment variables');
+}
+class JiraServer {
+    server;
+    jiraClient;
+    constructor() {
+        // Use environment-provided name or default to 'jira-cloud'
+        const serverName = process.env.MCP_SERVER_NAME || 'jira-cloud';
+        console.error(`Initializing Jira MCP server: ${serverName}`);
+        this.server = new Server({
+            name: serverName,
+            version: '0.1.0',
+        }, {
+            capabilities: {
+                tools: {},
+                resources: {},
+            },
+        });
+        this.jiraClient = new JiraClient({
+            host: JIRA_HOST,
+            email: JIRA_EMAIL,
+            apiToken: JIRA_API_TOKEN,
+        });
+        this.setupHandlers();
+        this.server.onerror = (error) => console.error('[MCP Error]', error);
+        process.on('SIGINT', async () => {
+            await this.server.close();
+            process.exit(0);
+        });
+    }
+    setupHandlers() {
+        // Set up required MCP protocol handlers
+        this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
+            tools: Object.entries(toolSchemas)
+                // Filter out the deprecated search_jira_issues tool
+                .filter(([key]) => key !== 'search_jira_issues')
+                .map(([key, schema]) => ({
+                name: key,
+                description: schema.description,
+                inputSchema: {
+                    type: 'object',
+                    properties: schema.inputSchema.properties,
+                    ...(('required' in schema.inputSchema) ? { required: schema.inputSchema.required } : {}),
+                },
+            })),
+        }));
+        // Set up resource handlers
+        const resourceHandlers = setupResourceHandlers(this.jiraClient);
+        this.server.setRequestHandler(ListResourcesRequestSchema, resourceHandlers.listResources);
+        this.server.setRequestHandler(ListResourceTemplatesRequestSchema, resourceHandlers.listResourceTemplates);
+        this.server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+            return resourceHandlers.readResource(request.params.uri);
+        });
+        // Set up tool handlers
+        this.server.setRequestHandler(CallToolRequestSchema, async (request, _extra) => {
+            console.error('Received request:', JSON.stringify(request, null, 2));
+            const { name } = request.params;
+            console.error(`Handling tool request: ${name}`);
+            try {
+                let response;
+                // Issue-related tools
+                if (['manage_jira_issue'].includes(name)) {
+                    response = await setupIssueHandlers(this.server, this.jiraClient, request);
+                }
+                // Project-related tools
+                else if (['manage_jira_project'].includes(name)) {
+                    response = await setupProjectHandlers(this.server, this.jiraClient, request);
+                }
+                // Board-related tools
+                else if (['manage_jira_board'].includes(name)) {
+                    response = await setupBoardHandlers(this.server, this.jiraClient, request);
+                }
+                // Sprint-related tools
+                else if (['manage_jira_sprint'].includes(name)) {
+                    response = await setupSprintHandlers(this.server, this.jiraClient, request);
+                }
+                // Filter-related tools
+                else if (['manage_jira_filter'].includes(name)) {
+                    response = await setupFilterHandlers(this.server, this.jiraClient, request);
+                }
+                // Legacy search tool - redirect to filter handler with execute_jql operation
+                else if (name === 'search_jira_issues') {
+                    console.error('Redirecting deprecated search_jira_issues to manage_jira_filter with execute_jql operation');
+                    // Transform the request to use manage_jira_filter with execute_jql operation
+                    const transformedRequest = {
+                        ...request,
+                        params: {
+                            ...request.params,
+                            name: 'manage_jira_filter',
+                            arguments: {
+                                ...request.params.arguments,
+                                operation: 'execute_jql'
+                            }
+                        }
+                    };
+                    response = await setupFilterHandlers(this.server, this.jiraClient, transformedRequest);
+                }
+                else {
+                    console.error(`Unknown tool requested: ${name}`);
+                    throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${name}`);
+                }
+                // Ensure we always return a valid response
+                if (!response) {
+                    throw new McpError(ErrorCode.InternalError, `No response from handler for tool: ${name}`);
+                }
+                return response;
+            }
+            catch (error) {
+                console.error('Error handling request:', error);
+                if (error instanceof McpError) {
+                    throw error;
+                }
+                throw new McpError(ErrorCode.InternalError, 'Internal server error');
+            }
+        });
+    }
+    async run() {
+        const transport = new StdioServerTransport();
+        await this.server.connect(transport);
+        console.error('Jira MCP server running on stdio');
+    }
+}
+const server = new JiraServer();
+server.run().catch(console.error);

package/build/schemas/request-schemas.js

@@ -0,0 +1,187 @@
+import { z } from 'zod';
+// Sprint Management Schemas
+export const CreateJiraSprintSchema = z.object({
+    method: z.literal('tools/call'),
+    params: z.object({
+        name: z.literal('create_jira_sprint'),
+        arguments: z.object({
+            boardId: z.number(),
+            name: z.string(),
+            startDate: z.string().optional(),
+            endDate: z.string().optional(),
+            goal: z.string().optional(),
+        }),
+    }),
+});
+export const GetJiraSprintSchema = z.object({
+    method: z.literal('tools/call'),
+    params: z.object({
+        name: z.literal('get_jira_sprint'),
+        arguments: z.object({
+            sprintId: z.number(),
+            expand: z.array(z.string()).optional(),
+        }),
+    }),
+});
+export const ListJiraSprintsSchema = z.object({
+    method: z.literal('tools/call'),
+    params: z.object({
+        name: z.literal('list_jira_sprints'),
+        arguments: z.object({
+            boardId: z.number(),
+            state: z.enum(['future', 'active', 'closed']).optional(),
+            startAt: z.number().optional(),
+            maxResults: z.number().optional(),
+            expand: z.array(z.string()).optional(),
+        }),
+    }),
+});
+export const UpdateJiraSprintSchema = z.object({
+    method: z.literal('tools/call'),
+    params: z.object({
+        name: z.literal('update_jira_sprint'),
+        arguments: z.object({
+            sprintId: z.number(),
+            name: z.string().optional(),
+            goal: z.string().optional(),
+            startDate: z.string().optional(),
+            endDate: z.string().optional(),
+            state: z.enum(['future', 'active', 'closed']).optional(),
+        }),
+    }),
+});
+export const DeleteJiraSprintSchema = z.object({
+    method: z.literal('tools/call'),
+    params: z.object({
+        name: z.literal('delete_jira_sprint'),
+        arguments: z.object({
+            sprintId: z.number(),
+        }),
+    }),
+});
+export const UpdateSprintIssuesSchema = z.object({
+    method: z.literal('tools/call'),
+    params: z.object({
+        name: z.literal('update_sprint_issues'),
+        arguments: z.object({
+            sprintId: z.number(),
+            add: z.array(z.string()).optional(),
+            remove: z.array(z.string()).optional(),
+        }),
+    }),
+});
+// Consolidated API request schemas
+export const GetJiraIssueSchema = z.object({
+    method: z.literal('tools/call'),
+    params: z.object({
+        name: z.literal('get_jira_issue'),
+        arguments: z.object({
+            issueKey: z.string(),
+            expand: z.array(z.string()).optional(),
+        }),
+    }),
+});
+export const GetJiraProjectSchema = z.object({
+    method: z.literal('tools/call'),
+    params: z.object({
+        name: z.literal('get_jira_project'),
+        arguments: z.object({
+            projectKey: z.string(),
+            expand: z.array(z.string()).optional(),
+            include_status_counts: z.boolean().optional(),
+        }),
+    }),
+});
+export const GetJiraBoardSchema = z.object({
+    method: z.literal('tools/call'),
+    params: z.object({
+        name: z.literal('get_jira_board'),
+        arguments: z.object({
+            boardId: z.number(),
+            expand: z.array(z.string()).optional(),
+        }),
+    }),
+});
+export const SearchJiraIssuesSchema = z.object({
+    method: z.literal('tools/call'),
+    params: z.object({
+        name: z.literal('search_jira_issues'),
+        arguments: z.object({
+            jql: z.string(),
+            startAt: z.number().optional(),
+            maxResults: z.number().optional(),
+            expand: z.array(z.string()).optional(),
+        }),
+    }),
+});
+export const ListJiraProjectsSchema = z.object({
+    method: z.literal('tools/call'),
+    params: z.object({
+        name: z.literal('list_jira_projects'),
+        arguments: z.object({
+            include_status_counts: z.boolean().optional(),
+        }),
+    }),
+});
+export const ListJiraBoardsSchema = z.object({
+    method: z.literal('tools/call'),
+    params: z.object({
+        name: z.literal('list_jira_boards'),
+        arguments: z.object({
+            include_sprints: z.boolean().optional(),
+        }),
+    }),
+});
+export const CreateJiraIssueSchema = z.object({
+    method: z.literal('tools/call'),
+    params: z.object({
+        name: z.literal('create_jira_issue'),
+        arguments: z.object({
+            projectKey: z.string(),
+            summary: z.string(),
+            description: z.string().optional(),
+            issueType: z.string(),
+            priority: z.string().optional(),
+            assignee: z.string().optional(),
+            labels: z.array(z.string()).optional(),
+            customFields: z.record(z.any()).optional(),
+        }),
+    }),
+});
+export const UpdateJiraIssueSchema = z.object({
+    method: z.literal('tools/call'),
+    params: z.object({
+        name: z.literal('update_jira_issue'),
+        arguments: z.object({
+            issueKey: z.string(),
+            summary: z.string().optional(),
+            description: z.string().optional(),
+            parent: z.union([z.string(), z.null()]).optional(),
+            assignee: z.string().optional(),
+            priority: z.string().optional(),
+            labels: z.array(z.string()).optional(),
+            customFields: z.record(z.any()).optional(),
+        }),
+    }),
+});
+export const TransitionJiraIssueSchema = z.object({
+    method: z.literal('tools/call'),
+    params: z.object({
+        name: z.literal('transition_jira_issue'),
+        arguments: z.object({
+            issueKey: z.string(),
+            transitionId: z.string(),
+            comment: z.string().optional(),
+        }),
+    }),
+});
+export const AddJiraCommentSchema = z.object({
+    method: z.literal('tools/call'),
+    params: z.object({
+        name: z.literal('add_jira_comment'),
+        arguments: z.object({
+            issueKey: z.string(),
+            body: z.string(),
+        }),
+    }),
+});