xray-mcp 1.0.0

package/dist/index.js

@@ -0,0 +1,851 @@
+#!/usr/bin/env node
+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 { XrayClient } from './xray-client.js';
+// Validate required environment variables
+const XRAY_CLIENT_ID = process.env.XRAY_CLIENT_ID;
+const XRAY_CLIENT_SECRET = process.env.XRAY_CLIENT_SECRET;
+if (!XRAY_CLIENT_ID || !XRAY_CLIENT_SECRET) {
+    console.error('Error: XRAY_CLIENT_ID and XRAY_CLIENT_SECRET must be set in environment variables');
+    process.exit(1);
+}
+// Initialize Xray client
+const xrayClient = new XrayClient({
+    clientId: XRAY_CLIENT_ID,
+    clientSecret: XRAY_CLIENT_SECRET,
+});
+// Define available tools
+const tools = [
+    {
+        name: 'create_test_case',
+        description: 'Create a new test case in Xray Cloud',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                projectKey: {
+                    type: 'string',
+                    description: 'The Jira project key (e.g., "PROJ")',
+                },
+                summary: {
+                    type: 'string',
+                    description: 'The test case summary/title',
+                },
+                description: {
+                    type: 'string',
+                    description: 'The test case description',
+                },
+                testType: {
+                    type: 'string',
+                    enum: ['Manual', 'Cucumber', 'Generic'],
+                    description: 'The type of test case',
+                    default: 'Manual',
+                },
+                labels: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Labels to attach to the test case',
+                },
+                priority: {
+                    type: 'string',
+                    description: 'Priority of the test case (e.g., "High", "Medium", "Low")',
+                },
+            },
+            required: ['projectKey', 'summary'],
+        },
+    },
+    {
+        name: 'get_test_case',
+        description: 'Get details of a specific test case by key',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                testKey: {
+                    type: 'string',
+                    description: 'The test case key (e.g., "PROJ-123")',
+                },
+            },
+            required: ['testKey'],
+        },
+    },
+    {
+        name: 'update_test_case',
+        description: 'Update an existing test case',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                testKey: {
+                    type: 'string',
+                    description: 'The test case key (e.g., "PROJ-123")',
+                },
+                summary: {
+                    type: 'string',
+                    description: 'New summary/title for the test case',
+                },
+                description: {
+                    type: 'string',
+                    description: 'New description for the test case',
+                },
+                labels: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'New labels for the test case',
+                },
+                priority: {
+                    type: 'string',
+                    description: 'New priority for the test case',
+                },
+            },
+            required: ['testKey'],
+        },
+    },
+    {
+        name: 'delete_test_case',
+        description: 'Delete a test case',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                testKey: {
+                    type: 'string',
+                    description: 'The test case key to delete (e.g., "PROJ-123")',
+                },
+            },
+            required: ['testKey'],
+        },
+    },
+    {
+        name: 'search_test_cases',
+        description: 'Search for test cases using JQL (Jira Query Language)',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                jql: {
+                    type: 'string',
+                    description: 'JQL query to search test cases (e.g., "project = PROJ AND labels = automation")',
+                },
+                maxResults: {
+                    type: 'number',
+                    description: 'Maximum number of results to return',
+                    default: 50,
+                },
+            },
+            required: ['jql'],
+        },
+    },
+    {
+        name: 'get_project_test_cases',
+        description: 'Get all test cases for a specific project',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                projectKey: {
+                    type: 'string',
+                    description: 'The Jira project key (e.g., "PROJ")',
+                },
+                maxResults: {
+                    type: 'number',
+                    description: 'Maximum number of results to return',
+                    default: 50,
+                },
+            },
+            required: ['projectKey'],
+        },
+    },
+    // Test Execution tools
+    {
+        name: 'create_test_execution',
+        description: 'Create a new test execution in Xray Cloud to run tests',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                projectKey: {
+                    type: 'string',
+                    description: 'The Jira project key (e.g., "PROJ")',
+                },
+                summary: {
+                    type: 'string',
+                    description: 'The test execution summary/title',
+                },
+                description: {
+                    type: 'string',
+                    description: 'The test execution description',
+                },
+                testIssueIds: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Array of test issue IDs to include in this execution (e.g., ["10001", "10002"])',
+                },
+                testEnvironments: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Array of test environments (e.g., ["Chrome", "iOS"])',
+                },
+            },
+            required: ['projectKey', 'summary'],
+        },
+    },
+    {
+        name: 'get_test_execution',
+        description: 'Get details of a specific test execution by key, including all test runs',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                testExecutionKey: {
+                    type: 'string',
+                    description: 'The test execution key (e.g., "PROJ-456")',
+                },
+            },
+            required: ['testExecutionKey'],
+        },
+    },
+    {
+        name: 'search_test_executions',
+        description: 'Search for test executions using JQL (Jira Query Language)',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                jql: {
+                    type: 'string',
+                    description: 'JQL query to search test executions (e.g., "project = PROJ AND created >= -7d")',
+                },
+                maxResults: {
+                    type: 'number',
+                    description: 'Maximum number of results to return',
+                    default: 50,
+                },
+            },
+            required: ['jql'],
+        },
+    },
+    {
+        name: 'get_project_test_executions',
+        description: 'Get all test executions for a specific project',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                projectKey: {
+                    type: 'string',
+                    description: 'The Jira project key (e.g., "PROJ")',
+                },
+                maxResults: {
+                    type: 'number',
+                    description: 'Maximum number of results to return',
+                    default: 50,
+                },
+            },
+            required: ['projectKey'],
+        },
+    },
+    {
+        name: 'update_test_run_status',
+        description: 'Update the status of a specific test run (e.g., mark as PASS or FAIL)',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                testRunId: {
+                    type: 'string',
+                    description: 'The test run ID (obtained from test execution details)',
+                },
+                status: {
+                    type: 'string',
+                    enum: ['TODO', 'EXECUTING', 'PASS', 'FAIL', 'ABORTED', 'PASSED', 'FAILED'],
+                    description: 'The new status for the test run',
+                },
+            },
+            required: ['testRunId', 'status'],
+        },
+    },
+    // Test Plan tools
+    {
+        name: 'create_test_plan',
+        description: 'Create a new test plan in Xray Cloud to organize tests',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                projectKey: {
+                    type: 'string',
+                    description: 'The Jira project key (e.g., "PROJ")',
+                },
+                summary: {
+                    type: 'string',
+                    description: 'The test plan summary/title',
+                },
+                description: {
+                    type: 'string',
+                    description: 'The test plan description',
+                },
+                testIssueIds: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Array of test issue IDs to include in this plan',
+                },
+            },
+            required: ['projectKey', 'summary'],
+        },
+    },
+    {
+        name: 'get_test_plan',
+        description: 'Get details of a specific test plan by key, including all tests',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                testPlanKey: {
+                    type: 'string',
+                    description: 'The test plan key (e.g., "PROJ-789")',
+                },
+            },
+            required: ['testPlanKey'],
+        },
+    },
+    {
+        name: 'search_test_plans',
+        description: 'Search for test plans using JQL (Jira Query Language)',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                jql: {
+                    type: 'string',
+                    description: 'JQL query to search test plans',
+                },
+                maxResults: {
+                    type: 'number',
+                    description: 'Maximum number of results to return',
+                    default: 50,
+                },
+            },
+            required: ['jql'],
+        },
+    },
+    {
+        name: 'get_project_test_plans',
+        description: 'Get all test plans for a specific project',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                projectKey: {
+                    type: 'string',
+                    description: 'The Jira project key (e.g., "PROJ")',
+                },
+                maxResults: {
+                    type: 'number',
+                    description: 'Maximum number of results to return',
+                    default: 50,
+                },
+            },
+            required: ['projectKey'],
+        },
+    },
+    {
+        name: 'add_tests_to_test_plan',
+        description: 'Add tests to an existing test plan',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                testPlanIssueId: {
+                    type: 'string',
+                    description: 'The test plan issue ID (not key)',
+                },
+                testIssueIds: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Array of test issue IDs to add',
+                },
+            },
+            required: ['testPlanIssueId', 'testIssueIds'],
+        },
+    },
+    {
+        name: 'remove_tests_from_test_plan',
+        description: 'Remove tests from an existing test plan',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                testPlanIssueId: {
+                    type: 'string',
+                    description: 'The test plan issue ID (not key)',
+                },
+                testIssueIds: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Array of test issue IDs to remove',
+                },
+            },
+            required: ['testPlanIssueId', 'testIssueIds'],
+        },
+    },
+    // Test Set tools
+    {
+        name: 'create_test_set',
+        description: 'Create a new test set in Xray Cloud to group related tests',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                projectKey: {
+                    type: 'string',
+                    description: 'The Jira project key (e.g., "PROJ")',
+                },
+                summary: {
+                    type: 'string',
+                    description: 'The test set summary/title',
+                },
+                description: {
+                    type: 'string',
+                    description: 'The test set description',
+                },
+                testIssueIds: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Array of test issue IDs to include in this set',
+                },
+            },
+            required: ['projectKey', 'summary'],
+        },
+    },
+    {
+        name: 'get_test_set',
+        description: 'Get details of a specific test set by key, including all tests',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                testSetKey: {
+                    type: 'string',
+                    description: 'The test set key (e.g., "PROJ-890")',
+                },
+            },
+            required: ['testSetKey'],
+        },
+    },
+    {
+        name: 'search_test_sets',
+        description: 'Search for test sets using JQL (Jira Query Language)',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                jql: {
+                    type: 'string',
+                    description: 'JQL query to search test sets',
+                },
+                maxResults: {
+                    type: 'number',
+                    description: 'Maximum number of results to return',
+                    default: 50,
+                },
+            },
+            required: ['jql'],
+        },
+    },
+    {
+        name: 'get_project_test_sets',
+        description: 'Get all test sets for a specific project',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                projectKey: {
+                    type: 'string',
+                    description: 'The Jira project key (e.g., "PROJ")',
+                },
+                maxResults: {
+                    type: 'number',
+                    description: 'Maximum number of results to return',
+                    default: 50,
+                },
+            },
+            required: ['projectKey'],
+        },
+    },
+    {
+        name: 'add_tests_to_test_set',
+        description: 'Add tests to an existing test set',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                testSetIssueId: {
+                    type: 'string',
+                    description: 'The test set issue ID (not key)',
+                },
+                testIssueIds: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Array of test issue IDs to add',
+                },
+            },
+            required: ['testSetIssueId', 'testIssueIds'],
+        },
+    },
+    {
+        name: 'remove_tests_from_test_set',
+        description: 'Remove tests from an existing test set',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                testSetIssueId: {
+                    type: 'string',
+                    description: 'The test set issue ID (not key)',
+                },
+                testIssueIds: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Array of test issue IDs to remove',
+                },
+            },
+            required: ['testSetIssueId', 'testIssueIds'],
+        },
+    },
+];
+// Create server instance
+const server = new Server({
+    name: 'xray-mcp-server',
+    version: '1.0.0',
+}, {
+    capabilities: {
+        tools: {},
+    },
+});
+// Handle tool listing
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return { tools };
+});
+// Handle tool execution
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    if (!args) {
+        throw new Error('Missing arguments');
+    }
+    try {
+        switch (name) {
+            case 'create_test_case': {
+                const testCase = {
+                    projectKey: args.projectKey,
+                    summary: args.summary,
+                    description: args.description,
+                    testType: args.testType,
+                    labels: args.labels,
+                    priority: args.priority,
+                };
+                const result = await xrayClient.createTestCase(testCase);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify(result, null, 2),
+                        },
+                    ],
+                };
+            }
+            case 'get_test_case': {
+                const result = await xrayClient.getTestCase(args.testKey);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify(result, null, 2),
+                        },
+                    ],
+                };
+            }
+            case 'update_test_case': {
+                const updates = {};
+                if (args.summary)
+                    updates.summary = args.summary;
+                if (args.description)
+                    updates.description = args.description;
+                if (args.labels)
+                    updates.labels = args.labels;
+                if (args.priority)
+                    updates.priority = args.priority;
+                await xrayClient.updateTestCase(args.testKey, updates);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `Test case ${args.testKey} updated successfully`,
+                        },
+                    ],
+                };
+            }
+            case 'delete_test_case': {
+                await xrayClient.deleteTestCase(args.testKey);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `Test case ${args.testKey} deleted successfully`,
+                        },
+                    ],
+                };
+            }
+            case 'search_test_cases': {
+                const result = await xrayClient.searchTestCases(args.jql, args.maxResults);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify(result, null, 2),
+                        },
+                    ],
+                };
+            }
+            case 'get_project_test_cases': {
+                const result = await xrayClient.getTestCasesByProject(args.projectKey, args.maxResults);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify(result, null, 2),
+                        },
+                    ],
+                };
+            }
+            // Test Execution handlers
+            case 'create_test_execution': {
+                const testExecution = {
+                    projectKey: args.projectKey,
+                    summary: args.summary,
+                    description: args.description,
+                    testIssueIds: args.testIssueIds,
+                    testEnvironments: args.testEnvironments,
+                };
+                const result = await xrayClient.createTestExecution(testExecution);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify(result, null, 2),
+                        },
+                    ],
+                };
+            }
+            case 'get_test_execution': {
+                const result = await xrayClient.getTestExecution(args.testExecutionKey);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify(result, null, 2),
+                        },
+                    ],
+                };
+            }
+            case 'search_test_executions': {
+                const result = await xrayClient.searchTestExecutions(args.jql, args.maxResults);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify(result, null, 2),
+                        },
+                    ],
+                };
+            }
+            case 'get_project_test_executions': {
+                const result = await xrayClient.getTestExecutionsByProject(args.projectKey, args.maxResults);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify(result, null, 2),
+                        },
+                    ],
+                };
+            }
+            case 'update_test_run_status': {
+                const result = await xrayClient.updateTestRunStatus(args.testRunId, args.status);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `Test run ${args.testRunId} status updated to ${args.status}: ${result}`,
+                        },
+                    ],
+                };
+            }
+            case 'create_test_plan': {
+                const testPlan = {
+                    projectKey: args.projectKey,
+                    summary: args.summary,
+                    description: args.description,
+                    testIssueIds: args.testIssueIds,
+                };
+                const result = await xrayClient.createTestPlan(testPlan);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify(result, null, 2),
+                        },
+                    ],
+                };
+            }
+            case 'get_test_plan': {
+                const result = await xrayClient.getTestPlan(args.testPlanKey);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify(result, null, 2),
+                        },
+                    ],
+                };
+            }
+            case 'search_test_plans': {
+                const result = await xrayClient.searchTestPlans(args.jql, args.maxResults);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify(result, null, 2),
+                        },
+                    ],
+                };
+            }
+            case 'get_project_test_plans': {
+                const result = await xrayClient.getTestPlansByProject(args.projectKey, args.maxResults);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify(result, null, 2),
+                        },
+                    ],
+                };
+            }
+            case 'add_tests_to_test_plan': {
+                const result = await xrayClient.addTestsToTestPlan(args.testPlanIssueId, args.testIssueIds);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify(result, null, 2),
+                        },
+                    ],
+                };
+            }
+            case 'remove_tests_from_test_plan': {
+                const result = await xrayClient.removeTestsFromTestPlan(args.testPlanIssueId, args.testIssueIds);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify(result, null, 2),
+                        },
+                    ],
+                };
+            }
+            case 'create_test_set': {
+                const testSet = {
+                    projectKey: args.projectKey,
+                    summary: args.summary,
+                    description: args.description,
+                    testIssueIds: args.testIssueIds,
+                };
+                const result = await xrayClient.createTestSet(testSet);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify(result, null, 2),
+                        },
+                    ],
+                };
+            }
+            case 'get_test_set': {
+                const result = await xrayClient.getTestSet(args.testSetKey);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify(result, null, 2),
+                        },
+                    ],
+                };
+            }
+            case 'search_test_sets': {
+                const result = await xrayClient.searchTestSets(args.jql, args.maxResults);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify(result, null, 2),
+                        },
+                    ],
+                };
+            }
+            case 'get_project_test_sets': {
+                const result = await xrayClient.getTestSetsByProject(args.projectKey, args.maxResults);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify(result, null, 2),
+                        },
+                    ],
+                };
+            }
+            case 'add_tests_to_test_set': {
+                const result = await xrayClient.addTestsToTestSet(args.testSetIssueId, args.testIssueIds);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify(result, null, 2),
+                        },
+                    ],
+                };
+            }
+            case 'remove_tests_from_test_set': {
+                const result = await xrayClient.removeTestsFromTestSet(args.testSetIssueId, args.testIssueIds);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify(result, null, 2),
+                        },
+                    ],
+                };
+            }
+            default:
+                throw new Error(`Unknown tool: ${name}`);
+        }
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Error: ${errorMessage}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+});
+// Start the server
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    // Handle EPIPE errors (broken pipe when client disconnects)
+    process.stdout.on('error', (err) => {
+        if (err.code === 'EPIPE') {
+            process.exit(0);
+        }
+    });
+    process.stderr.on('error', (err) => {
+        if (err.code === 'EPIPE') {
+            process.exit(0);
+        }
+    });
+    // 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 in MCP server:', error);
+    process.exit(1);
+});