@aaronsb/jira-cloud-mcp 0.2.7 → 0.3.0

package/build/index.js

@@ -1,14 +1,17 @@
 #!/usr/bin/env node
+import { createRequire } from 'module';
 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 { fieldDiscovery } from './client/field-discovery.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 { handleBoardRequest } from './handlers/board-handlers.js';
+import { handleFilterRequest } from './handlers/filter-handlers.js';
+import { handleIssueRequest } from './handlers/issue-handlers.js';
+import { handleProjectRequest } from './handlers/project-handlers.js';
+import { createQueueHandler } from './handlers/queue-handler.js';
 import { setupResourceHandlers } from './handlers/resource-handlers.js';
-import { setupSprintHandlers } from './handlers/sprint-handlers.js';
+import { handleSprintRequest } from './handlers/sprint-handlers.js';
 import { toolSchemas } from './schemas/tool-schemas.js';
 // Jira credentials from environment variables
 const JIRA_EMAIL = process.env.JIRA_EMAIL;
@@ -17,16 +20,17 @@ 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');
 }
+const require = createRequire(import.meta.url);
+const { version } = require('../package.json');
 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',
+            version,
         }, {
             capabilities: {
                 tools: {},
@@ -39,6 +43,8 @@ class JiraServer {
             apiToken: JIRA_API_TOKEN,
         });
         this.setupHandlers();
+        // Start async field discovery (non-blocking)
+        fieldDiscovery.startAsync(this.jiraClient.v3Client);
         this.server.onerror = (error) => console.error('[MCP Error]', error);
         process.on('SIGINT', async () => {
             await this.server.close();
@@ -49,8 +55,6 @@ class JiraServer {
         // 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,
@@ -74,49 +78,22 @@ class JiraServer {
             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}`);
+                const toolHandlers = {
+                    manage_jira_issue: handleIssueRequest,
+                    manage_jira_project: handleProjectRequest,
+                    manage_jira_board: handleBoardRequest,
+                    manage_jira_sprint: handleSprintRequest,
+                    manage_jira_filter: handleFilterRequest,
+                };
+                const handlers = {
+                    ...toolHandlers,
+                    queue_jira_operations: createQueueHandler(toolHandlers, JIRA_HOST),
+                };
+                const handler = handlers[name];
+                if (!handler) {
                     throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${name}`);
                 }
-                // Ensure we always return a valid response
+                const response = await handler(this.jiraClient, request);
                 if (!response) {
                     throw new McpError(ErrorCode.InternalError, `No response from handler for tool: ${name}`);
                 }
@@ -127,7 +104,38 @@ class JiraServer {
                 if (error instanceof McpError) {
                     throw error;
                 }
-                throw new McpError(ErrorCode.InternalError, 'Internal server error');
+                // Surface Jira permission errors with actionable guidance
+                const status = error?.response?.status
+                    ?? error?.status;
+                const jiraMessage = error?.response?.data?.errorMessages?.[0]
+                    ?? error?.response?.data?.message
+                    ?? error?.message
+                    ?? '';
+                if (status === 403) {
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: [
+                                    `**Jira denied this operation:** ${jiraMessage || 'Insufficient permissions.'}`,
+                                    '',
+                                    'This is controlled by your Jira project\'s permission scheme.',
+                                    'Contact your Jira admin to request the necessary permission,',
+                                    'or ask them to perform the operation for you.',
+                                ].join('\n'),
+                            }],
+                        isError: true,
+                    };
+                }
+                if (status === 404) {
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: `**Not found:** ${jiraMessage || 'The requested resource does not exist or you do not have permission to view it.'}`,
+                            }],
+                        isError: true,
+                    };
+                }
+                throw new McpError(ErrorCode.InternalError, jiraMessage || 'Internal server error');
             }
         });
     }

package/build/mcp/markdown-renderer.js

@@ -131,6 +131,17 @@ export function renderIssue(issue, transitions) {
             lines.push(`  ... and ${issue.comments.length - 3} more comments`);
         }
     }
+    // Custom fields (from catalog discovery)
+    if (issue.customFieldValues && issue.customFieldValues.length > 0) {
+        lines.push('');
+        lines.push('## Custom Fields');
+        for (const cf of issue.customFieldValues) {
+            const displayValue = Array.isArray(cf.value)
+                ? cf.value.join(', ')
+                : String(cf.value);
+            lines.push(`- **${cf.name}** (${cf.type}): ${displayValue}`);
+        }
+    }
     // Available transitions
     if (transitions && transitions.length > 0) {
         lines.push('');