zephyr-scale-mcp-server 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Yong Wang
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,114 @@
+# Zephyr Scale MCP Server
+
+Model Context Protocol server for Zephyr Scale test management. Create, read, and manage test cases through the Atlassian REST API.
+
+## Quick Start
+
+### Option 1: Install from npm
+```bash
+npm install -g zephyr-scale-mcp-server
+```
+
+### Option 2: Build locally
+```bash
+# Clone and build
+git clone <repository-url>
+cd zephyr-scale-mcp-server
+npm install
+npm run build
+
+# Configure environment
+export ZEPHYR_API_KEY="your-api-token"
+export ZEPHYR_BASE_URL="https://your-company.atlassian.net"
+
+# Test the server
+node build/index.js
+```
+
+## MCP Configuration
+
+### For npm installation:
+```json
+{
+  "mcpServers": {
+    "zephyr-server": {
+      "command": "zephyr-scale-mcp",
+      "env": {
+        "ZEPHYR_API_KEY": "your-api-token",
+        "ZEPHYR_BASE_URL": "https://your-company.atlassian.net"
+      }
+    }
+  }
+}
+```
+
+### For local build:
+```json
+{
+  "mcpServers": {
+    "zephyr-server": {
+      "command": "node",
+      "args": ["/path/to/zephyr-scale-mcp-server/build/index.js"],
+      "env": {
+        "ZEPHYR_API_KEY": "your-api-token",
+        "ZEPHYR_BASE_URL": "https://your-company.atlassian.net"
+      }
+    }
+  }
+}
+```
+
+## Available Tools
+
+- `create_test_case` - Create STEP_BY_STEP or PLAIN_TEXT test cases
+- `create_test_case_with_bdd` - Create BDD/Gherkin test cases
+- `get_test_case` - Get test case details
+- `update_test_case_bdd` - Update BDD test cases
+- `create_folder` - Create test case folders
+- `get_test_run_cases` - Get test cases from test runs
+
+## Examples
+
+### Simple Test Case
+```json
+{
+  "project_key": "PROJ",
+  "name": "Login Test"
+}
+```
+
+### Step-by-Step Test Case
+```json
+{
+  "project_key": "PROJ",
+  "name": "User Login Flow",
+  "test_script_type": "STEP_BY_STEP",
+  "steps": [
+    {
+      "description": "Navigate to login page",
+      "testData": "URL: https://app.example.com/login",
+      "expectedResult": "Login form is displayed"
+    }
+  ]
+}
+```
+
+### BDD Test Case
+```json
+{
+  "project_key": "PROJ",
+  "name": "User Authentication",
+  "bdd_content": "**Given** a user with valid credentials\n**When** the user attempts to log in\n**Then** the user should be authenticated successfully"
+}
+```
+
+## Authentication
+
+Get your API token from:
+1. Atlassian account settings
+2. Security → API tokens
+3. Create new token for Zephyr Scale
+
+## License
+
+MIT

package/build/index.js

@@ -0,0 +1,561 @@
+#!/usr/bin/env node
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CallToolRequestSchema, ErrorCode, ListToolsRequestSchema, McpError, } from '@modelcontextprotocol/sdk/types.js';
+import axios from 'axios';
+const BASE_URL = process.env.ZEPHYR_BASE_URL;
+const ACCESS_TOKEN = process.env.ZEPHYR_API_KEY;
+if (!ACCESS_TOKEN) {
+    throw new Error('ZEPHYR_API_KEY environment variable is required');
+}
+const headers = {
+    'Accept': '*/*',
+    'Authorization': `Bearer ${ACCESS_TOKEN}`,
+    'Content-Type': 'application/json',
+};
+class ZephyrServer {
+    server;
+    axiosInstance;
+    constructor() {
+        this.server = new Server({
+            name: 'zephyr-server',
+            version: '0.1.0',
+        }, {
+            capabilities: {
+                tools: {},
+            },
+        });
+        this.axiosInstance = axios.create({
+            baseURL: BASE_URL,
+            headers,
+        });
+        this.setupToolHandlers();
+        this.server.onerror = (error) => console.error('[MCP Error]', error);
+        process.on('SIGINT', async () => {
+            await this.server.close();
+            process.exit(0);
+        });
+    }
+    setupToolHandlers() {
+        this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
+            tools: [
+                {
+                    name: 'get_test_case',
+                    description: 'Get detailed information about a specific test case',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            test_case_key: {
+                                type: 'string',
+                                description: 'Test case key (e.g., PROJ-T123)',
+                            },
+                        },
+                        required: ['test_case_key'],
+                    },
+                },
+                {
+                    name: 'create_test_case',
+                    description: 'Create a new test case with STEP_BY_STEP or PLAIN_TEXT content',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            project_key: {
+                                type: 'string',
+                                description: 'Project key (required)',
+                            },
+                            name: {
+                                type: 'string',
+                                description: 'Test case name (required)',
+                            },
+                            test_script_type: {
+                                type: 'string',
+                                description: 'Type of test script',
+                                enum: ['STEP_BY_STEP', 'PLAIN_TEXT'],
+                                default: 'STEP_BY_STEP',
+                            },
+                            steps: {
+                                type: 'array',
+                                description: 'Test steps for STEP_BY_STEP (array of objects with description, testData, expectedResult)',
+                                items: {
+                                    type: 'object',
+                                    properties: {
+                                        description: { type: 'string' },
+                                        testData: { type: 'string' },
+                                        expectedResult: { type: 'string' },
+                                        testCaseKey: { type: 'string' }
+                                    }
+                                }
+                            },
+                            plain_text: {
+                                type: 'string',
+                                description: 'Plain text content for PLAIN_TEXT type',
+                            },
+                            folder: {
+                                type: 'string',
+                                description: 'Folder path (optional)',
+                            },
+                            status: {
+                                type: 'string',
+                                description: 'Test case status (optional)',
+                                enum: ['Draft', 'Approved', 'Deprecated'],
+                                default: 'Draft',
+                            },
+                            priority: {
+                                type: 'string',
+                                description: 'Test case priority (optional)',
+                                enum: ['High', 'Medium', 'Low'],
+                                default: 'High',
+                            },
+                            precondition: {
+                                type: 'string',
+                                description: 'Test precondition (optional)',
+                            },
+                            objective: {
+                                type: 'string',
+                                description: 'Test objective (optional)',
+                            },
+                            component: {
+                                type: 'string',
+                                description: 'Component name (optional)',
+                            },
+                            owner: {
+                                type: 'string',
+                                description: 'Test case owner (optional)',
+                            },
+                            estimated_time: {
+                                type: 'number',
+                                description: 'Estimated time in milliseconds (optional)',
+                            },
+                            labels: {
+                                type: 'array',
+                                description: 'Array of labels (optional)',
+                                items: { type: 'string' }
+                            },
+                            issue_links: {
+                                type: 'array',
+                                description: 'Array of issue links (optional)',
+                                items: { type: 'string' }
+                            },
+                            custom_fields: {
+                                type: 'object',
+                                description: 'Custom fields object (optional)',
+                            },
+                        },
+                        required: ['project_key', 'name'],
+                    },
+                },
+                {
+                    name: 'create_test_case_with_bdd',
+                    description: 'Create a new test case with BDD content',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            project_key: {
+                                type: 'string',
+                                description: 'Project key (required)',
+                            },
+                            name: {
+                                type: 'string',
+                                description: 'Test case name (required)',
+                            },
+                            bdd_content: {
+                                type: 'string',
+                                description: 'BDD content in markdown format',
+                            },
+                            folder: {
+                                type: 'string',
+                                description: 'Folder name (optional)',
+                            },
+                            priority: {
+                                type: 'string',
+                                description: 'Test case priority (High, Medium, Low)',
+                                enum: ['High', 'Medium', 'Low'],
+                            },
+                        },
+                        required: ['project_key', 'name', 'bdd_content'],
+                    },
+                },
+                {
+                    name: 'update_test_case_bdd',
+                    description: 'Update an existing test case with BDD content',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            test_case_key: {
+                                type: 'string',
+                                description: 'Test case key to update',
+                            },
+                            bdd_content: {
+                                type: 'string',
+                                description: 'BDD content in markdown format',
+                            },
+                        },
+                        required: ['test_case_key', 'bdd_content'],
+                    },
+                },
+                {
+                    name: 'create_folder',
+                    description: 'Create a new folder in Zephyr Scale',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            project_key: {
+                                type: 'string',
+                                description: 'Project key (required)',
+                            },
+                            name: {
+                                type: 'string',
+                                description: 'Folder name (required)',
+                            },
+                            parent_folder_path: {
+                                type: 'string',
+                                description: 'Parent folder path (optional)',
+                            },
+                            folder_type: {
+                                type: 'string',
+                                description: 'Type of folder',
+                                enum: ['TEST_CASE', 'TEST_PLAN'],
+                                default: 'TEST_CASE',
+                            },
+                        },
+                        required: ['project_key', 'name'],
+                    },
+                },
+                {
+                    name: 'get_test_run_cases',
+                    description: 'Get test case keys from a test run',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            test_run_key: {
+                                type: 'string',
+                                description: 'Test run key (e.g., PROJ-C123)',
+                            },
+                        },
+                        required: ['test_run_key'],
+                    },
+                },
+            ],
+        }));
+        this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+            try {
+                switch (request.params.name) {
+                    case 'get_test_case':
+                        return await this.getTestCase(request.params.arguments);
+                    case 'create_test_case':
+                        return await this.createTestCase(request.params.arguments);
+                    case 'create_test_case_with_bdd':
+                        return await this.createTestCaseWithBdd(request.params.arguments);
+                    case 'update_test_case_bdd':
+                        return await this.updateTestCaseBdd(request.params.arguments);
+                    case 'create_folder':
+                        return await this.createFolder(request.params.arguments);
+                    case 'get_test_run_cases':
+                        return await this.getTestRunCases(request.params.arguments);
+                    default:
+                        throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${request.params.name}`);
+                }
+            }
+            catch (error) {
+                if (error instanceof McpError) {
+                    throw error;
+                }
+                return {
+                    content: [{ type: 'text', text: `Error: ${error instanceof Error ? error.message : String(error)}` }],
+                    isError: true,
+                };
+            }
+        });
+    }
+    async getTestCase(args) {
+        const { test_case_key } = args;
+        try {
+            const response = await this.axiosInstance.get(`/rest/atm/1.0/testcase/${test_case_key}`);
+            return {
+                content: [{ type: 'text', text: JSON.stringify(response.data, null, 2) }],
+            };
+        }
+        catch (error) {
+            throw new McpError(ErrorCode.InternalError, `Failed to get test case: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    convertToGherkin(bddContent) {
+        const bddLines = [];
+        const lines = bddContent.split('\n');
+        for (const line of lines) {
+            const trimmedLine = line.trim();
+            if (!trimmedLine || trimmedLine.startsWith('---'))
+                continue;
+            if (trimmedLine.startsWith('**Given**')) {
+                bddLines.push(`Given ${trimmedLine.replace('**Given**', '').trim()}`);
+            }
+            else if (trimmedLine.startsWith('**When**')) {
+                bddLines.push(`When ${trimmedLine.replace('**When**', '').trim()}`);
+            }
+            else if (trimmedLine.startsWith('**Then**')) {
+                bddLines.push(`Then ${trimmedLine.replace('**Then**', '').trim()}`);
+            }
+            else if (trimmedLine.startsWith('**And**')) {
+                bddLines.push(`And ${trimmedLine.replace('**And**', '').trim()}`);
+            }
+            else if (trimmedLine.startsWith('Given ') || trimmedLine.startsWith('When ') ||
+                trimmedLine.startsWith('Then ') || trimmedLine.startsWith('And ')) {
+                bddLines.push(trimmedLine);
+            }
+        }
+        return bddLines.length > 0 ? '    ' + bddLines.join('\n    ') : '';
+    }
+    async createTestCase(args) {
+        const { project_key, name, test_script_type = 'STEP_BY_STEP', steps, plain_text, folder, status = 'Draft', priority = 'High', precondition, objective, component, owner, estimated_time, labels, issue_links, custom_fields } = args;
+        // Map priority to custom priority
+        const customPriorityMapping = {
+            'High': 'P0',
+            'Medium': 'P1',
+            'Low': 'P2'
+        };
+        // Build the basic payload
+        const payload = {
+            projectKey: project_key,
+            name: name,
+            status: status,
+            priority: priority,
+            customFields: {
+                'Type': 'Functional',
+                'Priority': customPriorityMapping[priority] || 'P0',
+                'Execution Type': 'Manual - To Be Automated'
+            }
+        };
+        // Add optional fields
+        if (folder)
+            payload.folder = folder;
+        if (precondition)
+            payload.precondition = precondition;
+        if (objective)
+            payload.objective = objective;
+        if (component)
+            payload.component = component;
+        if (owner)
+            payload.owner = owner;
+        if (estimated_time)
+            payload.estimatedTime = estimated_time;
+        if (labels && labels.length > 0)
+            payload.labels = labels;
+        if (issue_links && issue_links.length > 0)
+            payload.issueLinks = issue_links;
+        // Merge custom fields if provided
+        if (custom_fields) {
+            payload.customFields = { ...payload.customFields, ...custom_fields };
+        }
+        // Handle test script based on type
+        if (test_script_type === 'STEP_BY_STEP' && steps && steps.length > 0) {
+            payload.testScript = {
+                type: 'STEP_BY_STEP',
+                steps: steps.map((step) => {
+                    const stepObj = {};
+                    if (step.description)
+                        stepObj.description = step.description;
+                    if (step.testData)
+                        stepObj.testData = step.testData;
+                    if (step.expectedResult)
+                        stepObj.expectedResult = step.expectedResult;
+                    if (step.testCaseKey)
+                        stepObj.testCaseKey = step.testCaseKey;
+                    return stepObj;
+                })
+            };
+        }
+        else if (test_script_type === 'PLAIN_TEXT' && plain_text) {
+            payload.testScript = {
+                type: 'PLAIN_TEXT',
+                text: plain_text
+            };
+        }
+        try {
+            const response = await this.axiosInstance.post('/rest/atm/1.0/testcase', payload);
+            if (response.status === 201) {
+                const testKey = response.data.key || 'Unknown';
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `✅ Test case created successfully: ${testKey}\n${JSON.stringify({
+                                key: testKey,
+                                type: test_script_type,
+                                steps: test_script_type === 'STEP_BY_STEP' ? steps?.length || 0 : undefined,
+                                plainText: test_script_type === 'PLAIN_TEXT' ? !!plain_text : undefined
+                            }, null, 2)}`,
+                        },
+                    ],
+                };
+            }
+            else {
+                throw new Error(`Unexpected status code: ${response.status}`);
+            }
+        }
+        catch (error) {
+            let errorMessage = 'Unknown error';
+            if (error instanceof Error && 'response' in error) {
+                const axiosError = error;
+                errorMessage = `Status: ${axiosError.response?.status}, Data: ${JSON.stringify(axiosError.response?.data)}`;
+            }
+            else if (error instanceof Error) {
+                errorMessage = error.message;
+            }
+            else {
+                errorMessage = String(error);
+            }
+            throw new McpError(ErrorCode.InternalError, `Failed to create test case: ${errorMessage}`);
+        }
+    }
+    async createTestCaseWithBdd(args) {
+        const { project_key, name, bdd_content, folder, priority = 'High' } = args;
+        const priorityMapping = {
+            'High': 'High',
+            'Medium': 'High',
+            'Low': 'High'
+        };
+        const customPriorityMapping = {
+            'High': 'P0',
+            'Medium': 'P1',
+            'Low': 'P2'
+        };
+        const payload = {
+            projectKey: project_key,
+            name: name,
+            status: 'Draft',
+            priority: priorityMapping[priority] || 'High',
+            customFields: {
+                'Type': 'Functional',
+                'Priority': customPriorityMapping[priority] || 'P0',
+                'Execution Type': 'Manual - To Be Automated'
+            }
+        };
+        if (folder) {
+            payload.folder = folder;
+        }
+        const gherkinContent = this.convertToGherkin(bdd_content);
+        if (gherkinContent) {
+            payload.testScript = {
+                type: 'BDD',
+                text: gherkinContent
+            };
+        }
+        try {
+            const response = await this.axiosInstance.post('/rest/atm/1.0/testcase', payload);
+            if (response.status === 201) {
+                const testKey = response.data.key || 'Unknown';
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `✅ Test case with BDD created successfully: ${testKey}\n${JSON.stringify({ key: testKey }, null, 2)}`,
+                        },
+                    ],
+                };
+            }
+            else {
+                throw new Error(`Unexpected status code: ${response.status}`);
+            }
+        }
+        catch (error) {
+            throw new McpError(ErrorCode.InternalError, `Failed to create test case with BDD: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    async updateTestCaseBdd(args) {
+        const { test_case_key, bdd_content } = args;
+        try {
+            // First get the current test case
+            const getResponse = await this.axiosInstance.get(`/rest/atm/1.0/testcase/${test_case_key}`);
+            if (getResponse.status !== 200) {
+                throw new Error(`Failed to get test case ${test_case_key}`);
+            }
+            const gherkinContent = this.convertToGherkin(bdd_content);
+            const payload = {
+                testScript: {
+                    type: 'BDD',
+                    text: gherkinContent
+                }
+            };
+            const updateResponse = await this.axiosInstance.put(`/rest/atm/1.0/testcase/${test_case_key}`, payload);
+            if (updateResponse.status === 200) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `✅ Updated ${test_case_key} with BDD content successfully`,
+                        },
+                    ],
+                };
+            }
+            else {
+                throw new Error(`Failed to update ${test_case_key}: ${updateResponse.status}`);
+            }
+        }
+        catch (error) {
+            throw new McpError(ErrorCode.InternalError, `Failed to update test case BDD: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    async createFolder(args) {
+        const { project_key, name, parent_folder_path, folder_type = 'TEST_CASE' } = args;
+        let folderName = name;
+        if (parent_folder_path && !name.startsWith('/')) {
+            const parentPath = parent_folder_path.startsWith('/') ? parent_folder_path : `/${parent_folder_path}`;
+            folderName = `${parentPath}/${name}`;
+        }
+        else if (!name.startsWith('/')) {
+            folderName = `/${name}`;
+        }
+        const payload = {
+            projectKey: project_key,
+            name: folderName,
+            type: folder_type,
+        };
+        try {
+            const response = await this.axiosInstance.post('/rest/atm/1.0/folder', payload);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `✅ Folder created successfully: ${response.data.name} (ID: ${response.data.id})\n${JSON.stringify(response.data, null, 2)}`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            throw new McpError(ErrorCode.InternalError, `Failed to create folder: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    async getTestRunCases(args) {
+        const { test_run_key } = args;
+        try {
+            const response = await this.axiosInstance.get(`/rest/atm/1.0/testrun/${test_run_key}`);
+            if (response.status === 200) {
+                const data = response.data;
+                const testCaseKeys = data.items.map((item) => item.testCaseKey);
+                const statuses = data.items.map((item) => item.status);
+                const runIds = data.items.map((item) => item.id);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `✅ Retrieved test cases from ${test_run_key}:\nTest Case Keys: ${JSON.stringify(testCaseKeys, null, 2)}\nStatuses: ${JSON.stringify(statuses, null, 2)}\nRun IDs: ${JSON.stringify(runIds, null, 2)}`,
+                        },
+                    ],
+                };
+            }
+            else {
+                throw new Error(`Failed to retrieve data: ${response.status}`);
+            }
+        }
+        catch (error) {
+            throw new McpError(ErrorCode.InternalError, `Failed to get test run cases: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    async run() {
+        const transport = new StdioServerTransport();
+        await this.server.connect(transport);
+        console.error('Zephyr MCP server running on stdio');
+    }
+}
+const server = new ZephyrServer();
+server.run().catch(console.error);

package/package.json

@@ -0,0 +1,66 @@
+{
+  "name": "zephyr-scale-mcp-server",
+  "version": "0.0.1",
+  "description": "Model Context Protocol (MCP) server for Zephyr Scale test case management with comprehensive STEP_BY_STEP, PLAIN_TEXT, and BDD support",
+  "type": "module",
+  "main": "./build/index.js",
+  "bin": {
+    "zephyr-scale-mcp": "./build/index.js"
+  },
+  "files": [
+    "build/",
+    "src/",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc && node -e \"require('fs').chmodSync('build/index.js', '755')\"",
+    "prepare": "npm run build",
+    "watch": "tsc --watch",
+    "start": "node build/index.js",
+    "inspector": "npx @modelcontextprotocol/inspector build/index.js",
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "zephyr",
+    "zephyr-scale",
+    "test-management",
+    "test-cases",
+    "atlassian",
+    "jira",
+    "bdd",
+    "testing",
+    "qa",
+    "automation"
+  ],
+  "author": {
+    "name": "Yong Wang",
+    "email": "your-email@example.com"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/your-username/zephyr-scale-mcp-server.git"
+  },
+  "bugs": {
+    "url": "https://github.com/your-username/zephyr-scale-mcp-server/issues"
+  },
+  "homepage": "https://github.com/your-username/zephyr-scale-mcp-server#readme",
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "0.6.0",
+    "axios": "^1.10.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.24",
+    "typescript": "^5.8.3"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/index.ts

@@ -0,0 +1,616 @@
+#!/usr/bin/env node
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import {
+  CallToolRequestSchema,
+  ErrorCode,
+  ListToolsRequestSchema,
+  McpError,
+} from '@modelcontextprotocol/sdk/types.js';
+import axios from 'axios';
+
+const BASE_URL = process.env.ZEPHYR_BASE_URL;
+const ACCESS_TOKEN = process.env.ZEPHYR_API_KEY;
+
+if (!ACCESS_TOKEN) {
+  throw new Error('ZEPHYR_API_KEY environment variable is required');
+}
+
+const headers = {
+  'Accept': '*/*',
+  'Authorization': `Bearer ${ACCESS_TOKEN}`,
+  'Content-Type': 'application/json',
+};
+
+class ZephyrServer {
+  private server: Server;
+  private axiosInstance;
+
+  constructor() {
+    this.server = new Server(
+      {
+        name: 'zephyr-server',
+        version: '0.1.0',
+      },
+      {
+        capabilities: {
+          tools: {},
+        },
+      }
+    );
+
+    this.axiosInstance = axios.create({
+      baseURL: BASE_URL,
+      headers,
+    });
+
+    this.setupToolHandlers();
+    
+    this.server.onerror = (error) => console.error('[MCP Error]', error);
+    process.on('SIGINT', async () => {
+      await this.server.close();
+      process.exit(0);
+    });
+  }
+
+  private setupToolHandlers() {
+    this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
+      tools: [
+        {
+          name: 'get_test_case',
+          description: 'Get detailed information about a specific test case',
+          inputSchema: {
+            type: 'object',
+            properties: {
+              test_case_key: {
+                type: 'string',
+                description: 'Test case key (e.g., PROJ-T123)',
+              },
+            },
+            required: ['test_case_key'],
+          },
+        },
+        {
+          name: 'create_test_case',
+          description: 'Create a new test case with STEP_BY_STEP or PLAIN_TEXT content',
+          inputSchema: {
+            type: 'object',
+            properties: {
+              project_key: {
+                type: 'string',
+                description: 'Project key (required)',
+              },
+              name: {
+                type: 'string',
+                description: 'Test case name (required)',
+              },
+              test_script_type: {
+                type: 'string',
+                description: 'Type of test script',
+                enum: ['STEP_BY_STEP', 'PLAIN_TEXT'],
+                default: 'STEP_BY_STEP',
+              },
+              steps: {
+                type: 'array',
+                description: 'Test steps for STEP_BY_STEP (array of objects with description, testData, expectedResult)',
+                items: {
+                  type: 'object',
+                  properties: {
+                    description: { type: 'string' },
+                    testData: { type: 'string' },
+                    expectedResult: { type: 'string' },
+                    testCaseKey: { type: 'string' }
+                  }
+                }
+              },
+              plain_text: {
+                type: 'string',
+                description: 'Plain text content for PLAIN_TEXT type',
+              },
+              folder: {
+                type: 'string',
+                description: 'Folder path (optional)',
+              },
+              status: {
+                type: 'string',
+                description: 'Test case status (optional)',
+                enum: ['Draft', 'Approved', 'Deprecated'],
+                default: 'Draft',
+              },
+              priority: {
+                type: 'string',
+                description: 'Test case priority (optional)',
+                enum: ['High', 'Medium', 'Low'],
+                default: 'High',
+              },
+              precondition: {
+                type: 'string',
+                description: 'Test precondition (optional)',
+              },
+              objective: {
+                type: 'string',
+                description: 'Test objective (optional)',
+              },
+              component: {
+                type: 'string',
+                description: 'Component name (optional)',
+              },
+              owner: {
+                type: 'string',
+                description: 'Test case owner (optional)',
+              },
+              estimated_time: {
+                type: 'number',
+                description: 'Estimated time in milliseconds (optional)',
+              },
+              labels: {
+                type: 'array',
+                description: 'Array of labels (optional)',
+                items: { type: 'string' }
+              },
+              issue_links: {
+                type: 'array',
+                description: 'Array of issue links (optional)',
+                items: { type: 'string' }
+              },
+              custom_fields: {
+                type: 'object',
+                description: 'Custom fields object (optional)',
+              },
+            },
+            required: ['project_key', 'name'],
+          },
+        },
+        {
+          name: 'create_test_case_with_bdd',
+          description: 'Create a new test case with BDD content',
+          inputSchema: {
+            type: 'object',
+            properties: {
+              project_key: {
+                type: 'string',
+                description: 'Project key (required)',
+              },
+              name: {
+                type: 'string',
+                description: 'Test case name (required)',
+              },
+              bdd_content: {
+                type: 'string',
+                description: 'BDD content in markdown format',
+              },
+              folder: {
+                type: 'string',
+                description: 'Folder name (optional)',
+              },
+              priority: {
+                type: 'string',
+                description: 'Test case priority (High, Medium, Low)',
+                enum: ['High', 'Medium', 'Low'],
+              },
+            },
+            required: ['project_key', 'name', 'bdd_content'],
+          },
+        },
+        {
+          name: 'update_test_case_bdd',
+          description: 'Update an existing test case with BDD content',
+          inputSchema: {
+            type: 'object',
+            properties: {
+              test_case_key: {
+                type: 'string',
+                description: 'Test case key to update',
+              },
+              bdd_content: {
+                type: 'string',
+                description: 'BDD content in markdown format',
+              },
+            },
+            required: ['test_case_key', 'bdd_content'],
+          },
+        },
+        {
+          name: 'create_folder',
+          description: 'Create a new folder in Zephyr Scale',
+          inputSchema: {
+            type: 'object',
+            properties: {
+              project_key: {
+                type: 'string',
+                description: 'Project key (required)',
+              },
+              name: {
+                type: 'string',
+                description: 'Folder name (required)',
+              },
+              parent_folder_path: {
+                type: 'string',
+                description: 'Parent folder path (optional)',
+              },
+              folder_type: {
+                type: 'string',
+                description: 'Type of folder',
+                enum: ['TEST_CASE', 'TEST_PLAN'],
+                default: 'TEST_CASE',
+              },
+            },
+            required: ['project_key', 'name'],
+          },
+        },
+        {
+          name: 'get_test_run_cases',
+          description: 'Get test case keys from a test run',
+          inputSchema: {
+            type: 'object',
+            properties: {
+              test_run_key: {
+                type: 'string',
+                description: 'Test run key (e.g., PROJ-C123)',
+              },
+            },
+            required: ['test_run_key'],
+          },
+        },
+      ],
+    }));
+
+    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+      try {
+        switch (request.params.name) {
+          case 'get_test_case':
+            return await this.getTestCase(request.params.arguments);
+          case 'create_test_case':
+            return await this.createTestCase(request.params.arguments);
+          case 'create_test_case_with_bdd':
+            return await this.createTestCaseWithBdd(request.params.arguments);
+          case 'update_test_case_bdd':
+            return await this.updateTestCaseBdd(request.params.arguments);
+          case 'create_folder':
+            return await this.createFolder(request.params.arguments);
+          case 'get_test_run_cases':
+            return await this.getTestRunCases(request.params.arguments);
+          default:
+            throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${request.params.name}`);
+        }
+      } catch (error) {
+        if (error instanceof McpError) {
+          throw error;
+        }
+        return {
+          content: [{ type: 'text', text: `Error: ${error instanceof Error ? error.message : String(error)}` }],
+          isError: true,
+        };
+      }
+    });
+  }
+
+  private async getTestCase(args: any) {
+    const { test_case_key } = args;
+    try {
+      const response = await this.axiosInstance.get(`/rest/atm/1.0/testcase/${test_case_key}`);
+      return {
+        content: [{ type: 'text', text: JSON.stringify(response.data, null, 2) }],
+      };
+    } catch (error) {
+      throw new McpError(ErrorCode.InternalError, `Failed to get test case: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+
+  private convertToGherkin(bddContent: string): string {
+    const bddLines: string[] = [];
+    const lines = bddContent.split('\n');
+    
+    for (const line of lines) {
+      const trimmedLine = line.trim();
+      if (!trimmedLine || trimmedLine.startsWith('---')) continue;
+      
+      if (trimmedLine.startsWith('**Given**')) {
+        bddLines.push(`Given ${trimmedLine.replace('**Given**', '').trim()}`);
+      } else if (trimmedLine.startsWith('**When**')) {
+        bddLines.push(`When ${trimmedLine.replace('**When**', '').trim()}`);
+      } else if (trimmedLine.startsWith('**Then**')) {
+        bddLines.push(`Then ${trimmedLine.replace('**Then**', '').trim()}`);
+      } else if (trimmedLine.startsWith('**And**')) {
+        bddLines.push(`And ${trimmedLine.replace('**And**', '').trim()}`);
+      } else if (trimmedLine.startsWith('Given ') || trimmedLine.startsWith('When ') || 
+                 trimmedLine.startsWith('Then ') || trimmedLine.startsWith('And ')) {
+        bddLines.push(trimmedLine);
+      }
+    }
+    
+    return bddLines.length > 0 ? '    ' + bddLines.join('\n    ') : '';
+  }
+
+  private async createTestCase(args: any) {
+    const { 
+      project_key, 
+      name, 
+      test_script_type = 'STEP_BY_STEP', 
+      steps, 
+      plain_text,
+      folder,
+      status = 'Draft',
+      priority = 'High',
+      precondition,
+      objective,
+      component,
+      owner,
+      estimated_time,
+      labels,
+      issue_links,
+      custom_fields
+    } = args;
+    
+    // Map priority to custom priority
+    const customPriorityMapping: { [key: string]: string } = {
+      'High': 'P0',
+      'Medium': 'P1',
+      'Low': 'P2'
+    };
+
+    // Build the basic payload
+    const payload: any = {
+      projectKey: project_key,
+      name: name,
+      status: status,
+      priority: priority,
+      customFields: {
+        'Type': 'Functional',
+        'Priority': customPriorityMapping[priority] || 'P0',
+        'Execution Type': 'Manual - To Be Automated'
+      }
+    };
+    
+    // Add optional fields
+    if (folder) payload.folder = folder;
+    if (precondition) payload.precondition = precondition;
+    if (objective) payload.objective = objective;
+    if (component) payload.component = component;
+    if (owner) payload.owner = owner;
+    if (estimated_time) payload.estimatedTime = estimated_time;
+    if (labels && labels.length > 0) payload.labels = labels;
+    if (issue_links && issue_links.length > 0) payload.issueLinks = issue_links;
+    
+    // Merge custom fields if provided
+    if (custom_fields) {
+      payload.customFields = { ...payload.customFields, ...custom_fields };
+    }
+    
+    // Handle test script based on type
+    if (test_script_type === 'STEP_BY_STEP' && steps && steps.length > 0) {
+      payload.testScript = {
+        type: 'STEP_BY_STEP',
+        steps: steps.map((step: any) => {
+          const stepObj: any = {};
+          if (step.description) stepObj.description = step.description;
+          if (step.testData) stepObj.testData = step.testData;
+          if (step.expectedResult) stepObj.expectedResult = step.expectedResult;
+          if (step.testCaseKey) stepObj.testCaseKey = step.testCaseKey;
+          return stepObj;
+        })
+      };
+    } else if (test_script_type === 'PLAIN_TEXT' && plain_text) {
+      payload.testScript = {
+        type: 'PLAIN_TEXT',
+        text: plain_text
+      };
+    }
+    
+    try {
+      const response = await this.axiosInstance.post('/rest/atm/1.0/testcase', payload);
+      
+      if (response.status === 201) {
+        const testKey = response.data.key || 'Unknown';
+        return {
+          content: [
+            {
+              type: 'text',
+              text: `✅ Test case created successfully: ${testKey}\n${JSON.stringify({ 
+                key: testKey, 
+                type: test_script_type,
+                steps: test_script_type === 'STEP_BY_STEP' ? steps?.length || 0 : undefined,
+                plainText: test_script_type === 'PLAIN_TEXT' ? !!plain_text : undefined
+              }, null, 2)}`,
+            },
+          ],
+        };
+      } else {
+        throw new Error(`Unexpected status code: ${response.status}`);
+      }
+    } catch (error) {
+      let errorMessage = 'Unknown error';
+      if (error instanceof Error && 'response' in error) {
+        const axiosError = error as any;
+        errorMessage = `Status: ${axiosError.response?.status}, Data: ${JSON.stringify(axiosError.response?.data)}`;
+      } else if (error instanceof Error) {
+        errorMessage = error.message;
+      } else {
+        errorMessage = String(error);
+      }
+      throw new McpError(
+        ErrorCode.InternalError,
+        `Failed to create test case: ${errorMessage}`
+      );
+    }
+  }
+
+  private async createTestCaseWithBdd(args: any) {
+    const { project_key, name, bdd_content, folder, priority = 'High' } = args;
+    
+    const priorityMapping: { [key: string]: string } = {
+      'High': 'High',
+      'Medium': 'High',
+      'Low': 'High'
+    };
+    
+    const customPriorityMapping: { [key: string]: string } = {
+      'High': 'P0',
+      'Medium': 'P1',
+      'Low': 'P2'
+    };
+    
+    const payload: any = {
+      projectKey: project_key,
+      name: name,
+      status: 'Draft',
+      priority: priorityMapping[priority] || 'High',
+      customFields: {
+        'Type': 'Functional',
+        'Priority': customPriorityMapping[priority] || 'P0',
+        'Execution Type': 'Manual - To Be Automated'
+      }
+    };
+    
+    if (folder) {
+      payload.folder = folder;
+    }
+    
+    const gherkinContent = this.convertToGherkin(bdd_content);
+    if (gherkinContent) {
+      payload.testScript = {
+        type: 'BDD',
+        text: gherkinContent
+      };
+    }
+    
+    try {
+      const response = await this.axiosInstance.post('/rest/atm/1.0/testcase', payload);
+      
+      if (response.status === 201) {
+        const testKey = response.data.key || 'Unknown';
+        return {
+          content: [
+            {
+              type: 'text',
+              text: `✅ Test case with BDD created successfully: ${testKey}\n${JSON.stringify({ key: testKey }, null, 2)}`,
+            },
+          ],
+        };
+      } else {
+        throw new Error(`Unexpected status code: ${response.status}`);
+      }
+    } catch (error) {
+      throw new McpError(
+        ErrorCode.InternalError,
+        `Failed to create test case with BDD: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+
+  private async updateTestCaseBdd(args: any) {
+    const { test_case_key, bdd_content } = args;
+    
+    try {
+      // First get the current test case
+      const getResponse = await this.axiosInstance.get(`/rest/atm/1.0/testcase/${test_case_key}`);
+      if (getResponse.status !== 200) {
+        throw new Error(`Failed to get test case ${test_case_key}`);
+      }
+      
+      const gherkinContent = this.convertToGherkin(bdd_content);
+      const payload = {
+        testScript: {
+          type: 'BDD',
+          text: gherkinContent
+        }
+      };
+      
+      const updateResponse = await this.axiosInstance.put(`/rest/atm/1.0/testcase/${test_case_key}`, payload);
+      
+      if (updateResponse.status === 200) {
+        return {
+          content: [
+            {
+              type: 'text',
+              text: `✅ Updated ${test_case_key} with BDD content successfully`,
+            },
+          ],
+        };
+      } else {
+        throw new Error(`Failed to update ${test_case_key}: ${updateResponse.status}`);
+      }
+    } catch (error) {
+      throw new McpError(
+        ErrorCode.InternalError,
+        `Failed to update test case BDD: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+
+  private async createFolder(args: any) {
+    const { project_key, name, parent_folder_path, folder_type = 'TEST_CASE' } = args;
+    
+    let folderName = name;
+    if (parent_folder_path && !name.startsWith('/')) {
+      const parentPath = parent_folder_path.startsWith('/') ? parent_folder_path : `/${parent_folder_path}`;
+      folderName = `${parentPath}/${name}`;
+    } else if (!name.startsWith('/')) {
+      folderName = `/${name}`;
+    }
+    
+    const payload = {
+      projectKey: project_key,
+      name: folderName,
+      type: folder_type,
+    };
+    
+    try {
+      const response = await this.axiosInstance.post('/rest/atm/1.0/folder', payload);
+      
+      return {
+        content: [
+          {
+            type: 'text',
+            text: `✅ Folder created successfully: ${response.data.name} (ID: ${response.data.id})\n${JSON.stringify(response.data, null, 2)}`,
+          },
+        ],
+      };
+    } catch (error) {
+      throw new McpError(
+        ErrorCode.InternalError,
+        `Failed to create folder: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+
+  private async getTestRunCases(args: any) {
+    const { test_run_key } = args;
+    
+    try {
+      const response = await this.axiosInstance.get(`/rest/atm/1.0/testrun/${test_run_key}`);
+      
+      if (response.status === 200) {
+        const data = response.data;
+        const testCaseKeys = data.items.map((item: any) => item.testCaseKey);
+        const statuses = data.items.map((item: any) => item.status);
+        const runIds = data.items.map((item: any) => item.id);
+        
+        return {
+          content: [
+            {
+              type: 'text',
+              text: `✅ Retrieved test cases from ${test_run_key}:\nTest Case Keys: ${JSON.stringify(testCaseKeys, null, 2)}\nStatuses: ${JSON.stringify(statuses, null, 2)}\nRun IDs: ${JSON.stringify(runIds, null, 2)}`,
+            },
+          ],
+        };
+      } else {
+        throw new Error(`Failed to retrieve data: ${response.status}`);
+      }
+    } catch (error) {
+      throw new McpError(
+        ErrorCode.InternalError,
+        `Failed to get test run cases: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+
+  async run() {
+    const transport = new StdioServerTransport();
+    await this.server.connect(transport);
+    console.error('Zephyr MCP server running on stdio');
+  }
+}
+
+const server = new ZephyrServer();
+server.run().catch(console.error);