zephyr-scale-mcp-server 0.0.4 → 0.1.0

package/README.md

@@ -4,35 +4,23 @@ Model Context Protocol server for Zephyr Scale test management. Create, read, an
 
 ## Quick Start
 
-### Option 1: Install from npm
-```bash
-npm install -g zephyr-scale-mcp-server
-```
+### Option 1: Using npx (Recommended - No installation required)
+Just configure your MCP client with the npx command below.
 
-### Option 2: Build locally
+### Option 2: Install from npm
 ```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
+npm install -g zephyr-scale-mcp-server
 ```
 
 ## MCP Configuration
 
-### For npm installation:
+### Option 1: Using npx (Recommended - No installation required)
 ```json
 {
   "mcpServers": {
     "zephyr-server": {
-      "command": "zephyr-scale-mcp",
+      "command": "npx",
+      "args": ["zephyr-scale-mcp-server@latest"],
       "env": {
         "ZEPHYR_API_KEY": "your-api-token",
         "ZEPHYR_BASE_URL": "https://your-company.atlassian.net"
@@ -42,13 +30,18 @@ node build/index.js
 }
 ```
 
-### For local build:
+### Option 2: Using global npm installation
+First install the package globally:
+```bash
+npm install -g zephyr-scale-mcp-server
+```
+
+Then configure:
 ```json
 {
   "mcpServers": {
     "zephyr-server": {
-      "command": "node",
-      "args": ["/path/to/zephyr-scale-mcp-server/build/index.js"],
+      "command": "zephyr-scale-mcp",
       "env": {
         "ZEPHYR_API_KEY": "your-api-token",
         "ZEPHYR_BASE_URL": "https://your-company.atlassian.net"
@@ -60,13 +53,15 @@ node build/index.js
 
 ## 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
+- `get_test_case` - Get detailed information about a specific test case
+- `create_test_case` - Create a new test case with STEP_BY_STEP or PLAIN_TEXT content
+- `create_test_case_with_bdd` - Create a new test case with BDD content
+- `update_test_case_bdd` - Update an existing test case with BDD content
 - `delete_test_case` - Delete a specific test case
-- `create_folder` - Create test case folders
-- `get_test_run_cases` - Get test cases from test runs
+- `create_folder` - Create a new folder in Zephyr Scale
+- `get_test_run_cases` - Get test case keys from a test run
+- `create_test_run` - Create a new test run
+- `get_test_run` - Get detailed information about a specific test run
 
 ## Examples
 
@@ -110,37 +105,24 @@ node build/index.js
 }
 ```
 
-## Verification
-
-After installation, verify the package works:
-
-```bash
-# Check installation
-which zephyr-scale-mcp
-# Should show: /opt/homebrew/bin/zephyr-scale-mcp (or similar path)
-
-# Test with environment variables
-export ZEPHYR_API_KEY="your-api-token"
-export ZEPHYR_BASE_URL="https://your-company.atlassian.net"
-zephyr-scale-mcp
-# Should start the MCP server (Ctrl+C to exit)
+### Create Test Run
+```json
+{
+  "project_key": "PROJ",
+  "name": "Sprint 1 Test Run",
+  "test_case_keys": ["PROJ-T123", "PROJ-T124", "PROJ-T125"],
+  "environment": "Production",
+  "description": "Testing core functionality for Sprint 1"
+}
 ```
 
-### MCP Integration Test
-
-Once configured in your MCP client, test with:
-
+### Get Test Run
 ```json
 {
-  "tool": "get_test_case",
-  "arguments": {
-    "test_case_key": "PROJ-T123"
-  }
+  "test_run_key": "PROJ-R456"
 }
 ```
 
-Expected response includes test case details, BDD scripts, and metadata.
-
 ## Authentication
 
 Get your API token from:

package/build/index.js

@@ -249,6 +249,71 @@ class ZephyrServer {
                         required: ['test_case_key'],
                     },
                 },
+                {
+                    name: 'create_test_run',
+                    description: 'Create a new test run',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            project_key: {
+                                type: 'string',
+                                description: 'Project key (required)',
+                            },
+                            name: {
+                                type: 'string',
+                                description: 'Test run name (required)',
+                            },
+                            test_case_keys: {
+                                type: 'array',
+                                description: 'Array of test case keys to include in the test run',
+                                items: { type: 'string' }
+                            },
+                            folder: {
+                                type: 'string',
+                                description: 'Folder path (optional)',
+                            },
+                            planned_start_date: {
+                                type: 'string',
+                                description: 'Planned start date in ISO format (optional)',
+                            },
+                            planned_end_date: {
+                                type: 'string',
+                                description: 'Planned end date in ISO format (optional)',
+                            },
+                            description: {
+                                type: 'string',
+                                description: 'Test run description (optional)',
+                            },
+                            owner: {
+                                type: 'string',
+                                description: 'Test run owner (optional)',
+                            },
+                            environment: {
+                                type: 'string',
+                                description: 'Test environment (optional)',
+                            },
+                            custom_fields: {
+                                type: 'object',
+                                description: 'Custom fields object (optional)',
+                            },
+                        },
+                        required: ['project_key', 'name'],
+                    },
+                },
+                {
+                    name: 'get_test_run',
+                    description: 'Get detailed information about a specific test run',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            test_run_key: {
+                                type: 'string',
+                                description: 'Test run key (e.g., PROJ-R123)',
+                            },
+                        },
+                        required: ['test_run_key'],
+                    },
+                },
             ],
         }));
         this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
@@ -268,6 +333,10 @@ class ZephyrServer {
                         return await this.getTestRunCases(request.params.arguments);
                     case 'delete_test_case':
                         return await this.deleteTestCase(request.params.arguments);
+                    case 'create_test_run':
+                        return await this.createTestRun(request.params.arguments);
+                    case 'get_test_run':
+                        return await this.getTestRun(request.params.arguments);
                     default:
                         throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${request.params.name}`);
                 }
@@ -605,6 +674,108 @@ class ZephyrServer {
             throw new McpError(ErrorCode.InternalError, `Failed to delete test case: ${errorMessage}`);
         }
     }
+    async createTestRun(args) {
+        const { project_key, name, test_case_keys, folder, planned_start_date, planned_end_date, description, owner, environment, custom_fields } = args;
+        // Build the basic payload
+        const payload = {
+            projectKey: project_key,
+            name: name,
+        };
+        // Add optional fields
+        if (test_case_keys && test_case_keys.length > 0) {
+            payload.items = test_case_keys.map((testCaseKey) => ({
+                testCaseKey: testCaseKey
+            }));
+        }
+        if (folder)
+            payload.folder = folder;
+        if (planned_start_date)
+            payload.plannedStartDate = planned_start_date;
+        if (planned_end_date)
+            payload.plannedEndDate = planned_end_date;
+        if (description)
+            payload.description = description;
+        if (owner)
+            payload.owner = owner;
+        if (environment)
+            payload.environment = environment;
+        if (custom_fields)
+            payload.customFields = custom_fields;
+        try {
+            const response = await this.axiosInstance.post('/rest/atm/1.0/testrun', payload);
+            if (response.status === 201) {
+                const testRunKey = response.data.key || 'Unknown';
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `✅ Test run created successfully: ${testRunKey}\n${JSON.stringify({
+                                key: testRunKey,
+                                name: name,
+                                testCaseCount: test_case_keys?.length || 0,
+                                environment: environment || 'Not specified'
+                            }, 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 run: ${errorMessage}`);
+        }
+    }
+    async getTestRun(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) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify(response.data, null, 2),
+                        },
+                    ],
+                };
+            }
+            else {
+                throw new Error(`Failed to retrieve test run: ${response.status}`);
+            }
+        }
+        catch (error) {
+            let errorMessage = 'Unknown error';
+            if (error instanceof Error && 'response' in error) {
+                const axiosError = error;
+                if (axiosError.response?.status === 404) {
+                    errorMessage = `Test run ${test_run_key} not found`;
+                }
+                else {
+                    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 get test run: ${errorMessage}`);
+        }
+    }
     async run() {
         const transport = new StdioServerTransport();
         await this.server.connect(transport);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zephyr-scale-mcp-server",
-  "version": "0.0.4",
+  "version": "0.1.0",
   "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",

package/src/index.ts

@@ -266,6 +266,71 @@ class ZephyrServer {
             required: ['test_case_key'],
           },
         },
+        {
+          name: 'create_test_run',
+          description: 'Create a new test run',
+          inputSchema: {
+            type: 'object',
+            properties: {
+              project_key: {
+                type: 'string',
+                description: 'Project key (required)',
+              },
+              name: {
+                type: 'string',
+                description: 'Test run name (required)',
+              },
+              test_case_keys: {
+                type: 'array',
+                description: 'Array of test case keys to include in the test run',
+                items: { type: 'string' }
+              },
+              folder: {
+                type: 'string',
+                description: 'Folder path (optional)',
+              },
+              planned_start_date: {
+                type: 'string',
+                description: 'Planned start date in ISO format (optional)',
+              },
+              planned_end_date: {
+                type: 'string',
+                description: 'Planned end date in ISO format (optional)',
+              },
+              description: {
+                type: 'string',
+                description: 'Test run description (optional)',
+              },
+              owner: {
+                type: 'string',
+                description: 'Test run owner (optional)',
+              },
+              environment: {
+                type: 'string',
+                description: 'Test environment (optional)',
+              },
+              custom_fields: {
+                type: 'object',
+                description: 'Custom fields object (optional)',
+              },
+            },
+            required: ['project_key', 'name'],
+          },
+        },
+        {
+          name: 'get_test_run',
+          description: 'Get detailed information about a specific test run',
+          inputSchema: {
+            type: 'object',
+            properties: {
+              test_run_key: {
+                type: 'string',
+                description: 'Test run key (e.g., PROJ-R123)',
+              },
+            },
+            required: ['test_run_key'],
+          },
+        },
       ],
     }));
 
@@ -286,6 +351,10 @@ class ZephyrServer {
             return await this.getTestRunCases(request.params.arguments);
           case 'delete_test_case':
             return await this.deleteTestCase(request.params.arguments);
+          case 'create_test_run':
+            return await this.createTestRun(request.params.arguments);
+          case 'get_test_run':
+            return await this.getTestRun(request.params.arguments);
           default:
             throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${request.params.name}`);
         }
@@ -660,6 +729,117 @@ class ZephyrServer {
     }
   }
 
+  private async createTestRun(args: any) {
+    const { 
+      project_key, 
+      name, 
+      test_case_keys,
+      folder,
+      planned_start_date,
+      planned_end_date,
+      description,
+      owner,
+      environment,
+      custom_fields
+    } = args;
+    
+    // Build the basic payload
+    const payload: any = {
+      projectKey: project_key,
+      name: name,
+    };
+    
+    // Add optional fields
+    if (test_case_keys && test_case_keys.length > 0) {
+      payload.items = test_case_keys.map((testCaseKey: string) => ({
+        testCaseKey: testCaseKey
+      }));
+    }
+    if (folder) payload.folder = folder;
+    if (planned_start_date) payload.plannedStartDate = planned_start_date;
+    if (planned_end_date) payload.plannedEndDate = planned_end_date;
+    if (description) payload.description = description;
+    if (owner) payload.owner = owner;
+    if (environment) payload.environment = environment;
+    if (custom_fields) payload.customFields = custom_fields;
+    
+    try {
+      const response = await this.axiosInstance.post('/rest/atm/1.0/testrun', payload);
+      
+      if (response.status === 201) {
+        const testRunKey = response.data.key || 'Unknown';
+        return {
+          content: [
+            {
+              type: 'text',
+              text: `✅ Test run created successfully: ${testRunKey}\n${JSON.stringify({ 
+                key: testRunKey,
+                name: name,
+                testCaseCount: test_case_keys?.length || 0,
+                environment: environment || 'Not specified'
+              }, 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 run: ${errorMessage}`
+      );
+    }
+  }
+
+  private async getTestRun(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) {
+        return {
+          content: [
+            {
+              type: 'text',
+              text: JSON.stringify(response.data, null, 2),
+            },
+          ],
+        };
+      } else {
+        throw new Error(`Failed to retrieve test run: ${response.status}`);
+      }
+    } catch (error) {
+      let errorMessage = 'Unknown error';
+      if (error instanceof Error && 'response' in error) {
+        const axiosError = error as any;
+        if (axiosError.response?.status === 404) {
+          errorMessage = `Test run ${test_run_key} not found`;
+        } else {
+          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 get test run: ${errorMessage}`
+      );
+    }
+  }
+
   async run() {
     const transport = new StdioServerTransport();
     await this.server.connect(transport);