@uarlouski/testrail-mcp-server 1.3.0 → 1.4.0

package/README.md

@@ -1,41 +1,103 @@
-# TestRail MCP Server
+<p align="center">
+  <h1 align="center">TestRail MCP Server</h1>
+  <p align="center">
+    A Model Context Protocol (MCP) server that connects AI assistants to TestRail test management — search, create, update, and execute test cases using natural language.
+  </p>
+</p>
+
+<p align="center">
+  <a href="https://www.npmjs.com/package/@uarlouski/testrail-mcp-server"><img src="https://badge.fury.io/js/@uarlouski%2Ftestrail-mcp-server.svg" alt="npm version"></a>
+  <a href="https://www.npmjs.com/package/@uarlouski/testrail-mcp-server"><img src="https://img.shields.io/npm/dm/@uarlouski/testrail-mcp-server.svg" alt="npm downloads"></a>
+  <a href="https://github.com/uarlouski/testrail-mcp-server/actions/workflows/ci.yml"><img src="https://github.com/uarlouski/testrail-mcp-server/actions/workflows/ci.yml/badge.svg" alt="CI"></a>
+  <a href="https://opensource.org/licenses/Apache-2.0"><img src="https://img.shields.io/badge/License-Apache_2.0-blue.svg" alt="License"></a>
+  <a href="https://www.typescriptlang.org/"><img src="https://img.shields.io/badge/TypeScript-5.9-blue.svg" alt="TypeScript"></a>
+  <a href="https://github.com/uarlouski/testrail-mcp-server"><img src="https://img.shields.io/github/stars/uarlouski/testrail-mcp-server.svg?style=social&label=Star" alt="GitHub stars"></a>
+</p>
 
-[![npm version](https://badge.fury.io/js/@uarlouski%2Ftestrail-mcp-server.svg)](https://www.npmjs.com/package/@uarlouski/testrail-mcp-server)
-[![npm downloads](https://img.shields.io/npm/dm/@uarlouski/testrail-mcp-server.svg)](https://www.npmjs.com/package/@uarlouski/testrail-mcp-server)
-[![CI](https://github.com/uarlouski/testrail-mcp-server/actions/workflows/ci.yml/badge.svg)](https://github.com/uarlouski/testrail-mcp-server/actions/workflows/ci.yml)
-[![License](https://img.shields.io/badge/License-Apache_2.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
-[![TypeScript](https://img.shields.io/badge/TypeScript-5.9.3-blue.svg)](https://www.typescriptlang.org/)
-[![GitHub stars](https://img.shields.io/github/stars/uarlouski/testrail-mcp-server.svg?style=social&label=Star)](https://github.com/uarlouski/testrail-mcp-server)
+---
+
+## Why TestRail MCP Server?
+
+Managing test cases manually is tedious. With the TestRail MCP Server, your AI assistant (Claude, Cursor, Windsurf, or any MCP-compliant client) talks directly to TestRail. Ask it to find test cases, create new ones, kick off test runs, or report results — all through natural conversation.
+
+**No context switching. No copy-pasting. Just ask.**
+
+## ✨ Features
 
+| Category | Capabilities |
+|----------|-------------|
+| **🔍 Discovery** | Browse projects, suites, and sections to map your test organization |
+| **📋 Case Management** | Fetch, create, update, and bulk-edit test cases with full custom field support |
+| **▶️ Test Execution** | Create runs, record results, attach files, and track test statuses |
+| **🧠 Context-Aware** | Exposes templates, field definitions, priorities, and case types so LLMs generate valid, well-structured test cases |
 
-A powerful **Model Context Protocol (MCP)** server for seamless integration between **Large Language Models (LLMs)** and **TestRail** test case management.
+## 🚀 Quick Start
 
-This MCP server enables AI assistants like **Claude**, **Cursor**, **Windsurf**, and other MCP-compliant clients to interact directly with your TestRail instance. Streamline your QA workflows by allowing your AI to search, retrieve, create, and update test cases, plans, and runs.
+### 1. Get Your TestRail API Key
 
-## 🚀 Features
+Navigate to **My Settings → API Keys** in your TestRail instance and generate a new key.
 
-- **AI-Powered Test Management**: Bridge the gap between AI and your QA process.
-- **Smart Discovery**: List projects, suites, and sections to help LLMs understand your test organization.
-- **Comprehensive Case Operations**: Fetch, create, and update test cases with full support for custom fields.
-- **Context-Aware**: Designed to provide LLMs with the right context (templates, field options) for accurate test generation.
+### 2. Configure Your MCP Client
 
-## ⚙️ Usage
+Add the server to your MCP client configuration. Below are examples for popular clients.
+
+<details>
+<summary><strong>Claude Desktop</strong></summary>
+
+Edit your `claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "testrail": {
+      "command": "npx",
+      "args": ["-y", "@uarlouski/testrail-mcp-server@latest"],
+      "env": {
+        "TESTRAIL_INSTANCE_URL": "https://your-instance.testrail.io",
+        "TESTRAIL_USERNAME": "your@email.com",
+        "TESTRAIL_API_KEY": "your-api-key"
+      }
+    }
+  }
+}
+```
+
+</details>
+
+<details>
+<summary><strong>Cursor</strong></summary>
+
+Open **Settings → MCP** and add a new server:
+
+```json
+{
+  "mcpServers": {
+    "testrail": {
+      "command": "npx",
+      "args": ["-y", "@uarlouski/testrail-mcp-server@latest"],
+      "env": {
+        "TESTRAIL_INSTANCE_URL": "https://your-instance.testrail.io",
+        "TESTRAIL_USERNAME": "your@email.com",
+        "TESTRAIL_API_KEY": "your-api-key"
+      }
+    }
+  }
+}
+```
 
-Configure the server in your MCP client settings (e.g., `claude_desktop_config.json` or Cursor settings).
+</details>
 
-### Claude Desktop / General MCP Clients
+<details>
+<summary><strong>Windsurf</strong></summary>
 
-Add the following to your configuration file:
+Add to your Windsurf MCP configuration:
 
 ```json
 {
   "mcpServers": {
     "testrail": {
       "command": "npx",
-      "args": [
-        "-y",
-        "@uarlouski/testrail-mcp-server@latest"
-      ],
+      "args": ["-y", "@uarlouski/testrail-mcp-server@latest"],
       "env": {
         "TESTRAIL_INSTANCE_URL": "https://your-instance.testrail.io",
         "TESTRAIL_USERNAME": "your@email.com",
@@ -46,42 +108,110 @@ Add the following to your configuration file:
 }
 ```
 
-### Environment Variables
+</details>
+
+<details>
+<summary><strong>Other MCP Clients</strong></summary>
+
+Any MCP-compliant client can use this server. The configuration pattern is the same — point it at the `npx` command with the required environment variables.
+
+</details>
+
+### 3. Start Using It
+
+Once configured, ask your AI assistant things like:
+
+- *"List all projects in TestRail"*
+- *"Show me the test cases in suite 1 of project 3"*
+- *"Create a test case for login validation with steps"*
+- *"Start a new test run with cases from section 5"*
+- *"Mark test 42 as passed with a comment"*
+
+## ⚙️ Configuration
 
-| Variable | Description | Required |
-|----------|-------------|:--------:|
-| `TESTRAIL_INSTANCE_URL` | The URL of your TestRail instance (e.g., `https://example.testrail.io`) | Yes |
-| `TESTRAIL_USERNAME` | Your TestRail email address | Yes |
-| `TESTRAIL_API_KEY` | Your TestRail API key (generate in My Settings > API Keys) | Yes |
+| Environment Variable | Description | Required |
+|---------------------|-------------|:--------:|
+| `TESTRAIL_INSTANCE_URL` | Your TestRail instance URL (e.g., `https://example.testrail.io`) | ✅ |
+| `TESTRAIL_USERNAME` | Your TestRail email address | ✅ |
+| `TESTRAIL_API_KEY` | Your TestRail API key ([how to get one](https://support.testrail.com/hc/en-us/articles/7077039051412-Accessing-the-TestRail-API)) | ✅ |
 
 ## 🛠️ Available Tools
 
-This MCP server exposes the following tools to the LLM:
+### Discovery
 
 | Tool | Description |
 |------|-------------|
-| `get_projects` | **Discovery**: List all available projects in the TestRail instance to establish context. |
-| `get_suites` | **Discovery**: Retrieve test suites for a given project (if not in single-suite mode). |
-| `get_sections` | **Structure**: navigate the folder/section hierarchy of a test suite. |
-| `get_cases` | **Search**: Query test cases with filtering (priority, template, type, etc.) and pagination. |
-| `get_case` | **Detail**: Fetch comprehensive details of a specific test case, including steps and custom fields. |
-| `create_case` | **Authoring**: Create new test cases. *Tip: The model should check templates and fields first to ensure validity.* |
-| `update_case` | **Maintenance**: Modify existing test case fields, title, or steps. |
-| `update_cases` | **Bulk Edit**: Update multiple cases simultaneously for efficient refactoring. |
-| `add_run` | **Test Execution**: Create a new test run in TestRail. |
-| `get_tests` | **Test Execution**: Get tests for a test run, optionally filtered by status. |
-| `add_results` | **Test Execution**: Add one or more test results to a test run. |
-| `add_attachment_to_run` | **Test Execution**: Add an attachment (file or zipped folder) to a test run. |
-| `get_statuses` | **Metadata**: Get all available test statuses (e.g. Passed, Failed, Blocked). |
-| `get_case_fields` | **Metadata**: Retrieve definitions of custom fields to understand available inputs. |
-| `get_templates` | **Metadata**: List available case templates to ensure correct case creation structure. |
-| `get_priorities` | **Metadata**: List available priority levels. |
-| `get_case_types` | **Metadata**: List available case types (e.g., Automated, Manual). |
+| `get_projects` | List all available projects in your TestRail instance |
+| `get_sections` | Navigate the folder/section hierarchy of a test suite |
+
+### Test Case Management
+
+| Tool | Description |
+|------|-------------|
+| `get_cases` | Query test cases with filtering by priority, template, type, and more — supports pagination and recursive section fetching |
+| `get_case` | Fetch complete details of a specific test case including steps and custom fields |
+| `create_case` | Create a new test case with full custom field support |
+| `update_case` | Modify an existing test case's fields, title, or steps |
+| `update_cases` | Bulk-update multiple test cases simultaneously |
+
+### Test Execution
+
+| Tool | Description |
+|------|-------------|
+| `add_run` | Create a new test run in TestRail |
+| `get_tests` | Get tests for a run, optionally filtered by status |
+| `add_results` | Submit one or more test results to a run |
+| `add_attachment_to_run` | Attach a file or zipped folder to a test run |
+
+### Metadata
+
+| Tool | Description |
+|------|-------------|
+| `get_statuses` | List all available test statuses (Passed, Failed, Blocked, etc.) |
+| `get_case_fields` | Retrieve custom field definitions and dropdown options |
+| `get_templates` | List available case templates for correct case structure |
+
+## 🏗️ Development
+
+### Prerequisites
+
+- [Node.js](https://nodejs.org/) 18+
+- npm
+
+### Setup
+
+```bash
+git clone https://github.com/uarlouski/testrail-mcp-server.git
+cd testrail-mcp-server
+npm install
+```
+
+### Build
+
+```bash
+npm run build
+```
+
+### Run Tests
+
+```bash
+npm test
+```
+
+## 🤝 Contributing
+
+Contributions are welcome! Please feel free to open an [issue](https://github.com/uarlouski/testrail-mcp-server/issues) or submit a pull request.
 
 ## 📜 License
 
-This project is licensed under the Apache 2.0 License - see the [LICENSE](LICENSE) file for details.
+This project is licensed under the [Apache License 2.0](LICENSE).
 
 ---
 
-*Keywords: TestRail, MCP, Model Context Protocol, LLM, AI, Claude, Cursor, Windsurf, Test Management, QA, Automation, Testing, API*
+<p align="center">
+  <b>TestRail MCP Server</b> · Built with the <a href="https://modelcontextprotocol.io">Model Context Protocol</a>
+</p>
+
+<p align="center">
+  <sub>Keywords: TestRail MCP Server, Model Context Protocol, TestRail API integration, AI test management, LLM testing tools, Claude TestRail, Cursor TestRail, Windsurf TestRail, test case automation, QA AI assistant, MCP server for testing, TestRail plugin, test run management, AI-powered QA</sub>
+</p>

package/dist/client/testrail.js

@@ -0,0 +1,184 @@
+import * as fs from "fs";
+const API_INDEX = '/index.php?';
+const API_BASE_V2 = `${API_INDEX}/api/v2`;
+export class TestRailClient {
+    baseUrl;
+    headers;
+    auth;
+    prioritiesPromise = null;
+    caseTypesPromise = null;
+    caseFieldsPromise = null;
+    statusesPromise = null;
+    projectsPromise = null;
+    templatesPromiseMap = new Map();
+    constructor(baseUrl, email, apiKey) {
+        this.baseUrl = baseUrl.replace(/\/$/, "");
+        const auth = Buffer.from(`${email}:${apiKey}`).toString('base64');
+        this.auth = `Basic ${auth}`;
+        this.headers = {
+            "Content-Type": "application/json",
+            "Authorization": this.auth,
+        };
+    }
+    async getCase(caseId) {
+        return this.get(`${API_BASE_V2}/get_case/${caseId}`);
+    }
+    async getCasesRecursively(projectId, sectionId, filter, excludedSectionNames) {
+        const sections = await this.getSections(projectId);
+        const sectionIds = this.getSubSectionIds(sections, sectionId, excludedSectionNames);
+        sectionIds.push(sectionId);
+        const promises = sectionIds.map(id => this.getCases(projectId, id, filter));
+        const results = await Promise.all(promises);
+        return results.flat();
+    }
+    getSubSectionIds(sections, parentId, excludedSectionNames) {
+        const children = sections.filter(s => s.parent_id === parentId);
+        const validChildren = children.filter(s => !excludedSectionNames?.includes(s.name));
+        let ids = validChildren.map(s => s.id);
+        for (const child of validChildren) {
+            ids = ids.concat(this.getSubSectionIds(sections, child.id, excludedSectionNames));
+        }
+        return ids;
+    }
+    async getCases(projectId, sectionId, filter) {
+        let url = `${API_BASE_V2}/get_cases/${projectId}`;
+        if (sectionId) {
+            url += `&section_id=${sectionId}`;
+        }
+        if (filter) {
+            for (const [key, value] of Object.entries(filter)) {
+                url += `&${key}=${encodeURIComponent(value)}`;
+            }
+        }
+        const allCases = [];
+        let nextUrl = url;
+        while (nextUrl) {
+            const response = await this.get(nextUrl);
+            allCases.push(...response.cases);
+            nextUrl = response._links?.next;
+            if (nextUrl) {
+                nextUrl = `${API_INDEX}${nextUrl}`;
+            }
+        }
+        return allCases;
+    }
+    async getSection(sectionId) {
+        return this.get(`${API_BASE_V2}/get_section/${sectionId}`);
+    }
+    async getPriorities() {
+        if (!this.prioritiesPromise) {
+            this.prioritiesPromise = this.get(`${API_BASE_V2}/get_priorities`);
+        }
+        return this.prioritiesPromise;
+    }
+    async getCaseTypes() {
+        if (!this.caseTypesPromise) {
+            this.caseTypesPromise = this.get(`${API_BASE_V2}/get_case_types`);
+        }
+        return this.caseTypesPromise;
+    }
+    async getCaseFields() {
+        if (!this.caseFieldsPromise) {
+            this.caseFieldsPromise = this.get(`${API_BASE_V2}/get_case_fields`);
+        }
+        return this.caseFieldsPromise;
+    }
+    async getStatuses() {
+        if (!this.statusesPromise) {
+            this.statusesPromise = this.get(`${API_BASE_V2}/get_statuses`);
+        }
+        return this.statusesPromise;
+    }
+    async getTemplates(projectId) {
+        if (!this.templatesPromiseMap.has(projectId.toString())) {
+            this.templatesPromiseMap.set(projectId.toString(), this.get(`${API_BASE_V2}/get_templates/${projectId}`));
+        }
+        return this.templatesPromiseMap.get(projectId.toString());
+    }
+    async updateCase(caseId, fields) {
+        return this.post(`${API_BASE_V2}/update_case/${caseId}`, fields);
+    }
+    async updateCases(suiteId, caseIds, fields) {
+        const response = await this.post(`${API_BASE_V2}/update_cases/${suiteId}`, {
+            case_ids: caseIds,
+            ...fields,
+        });
+        return response.updated_cases;
+    }
+    async createCase(sectionId, fields) {
+        return this.post(`${API_BASE_V2}/add_case/${sectionId}`, fields);
+    }
+    async addRun(projectId, fields) {
+        return this.post(`${API_BASE_V2}/add_run/${projectId}`, fields);
+    }
+    async getSections(projectId) {
+        const response = await this.get(`${API_BASE_V2}/get_sections/${projectId}`);
+        return response.sections;
+    }
+    async getProjects() {
+        if (!this.projectsPromise) {
+            this.projectsPromise = this.get(`${API_BASE_V2}/get_projects`)
+                .then(response => response.projects);
+        }
+        return this.projectsPromise;
+    }
+    async getTests(runId, statusId) {
+        let url = `${API_BASE_V2}/get_tests/${runId}`;
+        if (statusId && statusId.length > 0) {
+            url += `&status_id=${statusId.join(',')}`;
+        }
+        const allTests = [];
+        let nextUrl = url;
+        while (nextUrl) {
+            const response = await this.get(nextUrl);
+            allTests.push(...response.tests);
+            nextUrl = response._links?.next;
+            if (nextUrl) {
+                nextUrl = `${API_INDEX}${nextUrl}`;
+            }
+        }
+        return allTests;
+    }
+    async addResults(runId, results) {
+        return this.post(`${API_BASE_V2}/add_results/${runId}`, { results });
+    }
+    async addAttachmentToRun(runId, filePath, filename) {
+        const fileBuffer = await fs.promises.readFile(filePath);
+        const blob = new Blob([fileBuffer]);
+        const formData = new FormData();
+        formData.append('attachment', blob, filename);
+        const headers = {
+            'Authorization': this.auth,
+        };
+        return this._executeRequest('POST', `${API_BASE_V2}/add_attachment_to_run/${runId}`, headers, formData);
+    }
+    async get(endpoint) {
+        return this.executeRequest('GET', endpoint);
+    }
+    async post(endpoint, data) {
+        return this.executeRequest('POST', endpoint, data);
+    }
+    async executeRequest(method, endpoint, data) {
+        let jsonData = undefined;
+        if (data) {
+            jsonData = JSON.stringify(data);
+        }
+        return this._executeRequest(method, endpoint, this.headers, jsonData);
+    }
+    async _executeRequest(method, endpoint, headers, body) {
+        const url = `${this.baseUrl}${endpoint}`;
+        const params = {
+            method,
+            headers,
+            body,
+        };
+        const response = await fetch(url, params);
+        if (!response.ok) {
+            let errorMessage = `TestRail: ${response.status} ${response.statusText}`;
+            const errorText = await response.text();
+            errorMessage += ` - ${errorText}`;
+            throw new Error(errorMessage);
+        }
+        return await response.json();
+    }
+}

package/{src/index.ts → dist/index.js}

@@ -1,3 +1,4 @@
+#!/usr/bin/env node
 import "dotenv/config";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
@@ -17,23 +18,18 @@ import { getTestsTool } from "./tools/get_tests.js";
 import { addResultsTool } from "./tools/add_results.js";
 import { addAttachmentToRunTool } from "./tools/add_attachment_to_run.js";
 import { removeNullish } from "./utils/sanitizer.js";
-
 const TESTRAIL_INSTANCE_URL = process.env.TESTRAIL_INSTANCE_URL;
 const TESTRAIL_USERNAME = process.env.TESTRAIL_USERNAME;
 const TESTRAIL_API_KEY = process.env.TESTRAIL_API_KEY;
-
 if (!TESTRAIL_INSTANCE_URL || !TESTRAIL_USERNAME || !TESTRAIL_API_KEY) {
     console.error("Error: TESTRAIL_INSTANCE_URL, TESTRAIL_USERNAME, and TESTRAIL_API_KEY environment variables are required.");
     process.exit(1);
 }
-
 const server = new McpServer({
     name: "TestRail MCP Server",
-    version: "1.3.0",
+    version: "1.4.0",
 });
-
 const client = new TestRailClient(TESTRAIL_INSTANCE_URL, TESTRAIL_USERNAME, TESTRAIL_API_KEY);
-
 const tools = [
     getProjectsTool,
     getCaseTool,
@@ -49,37 +45,31 @@ const tools = [
     getTestsTool,
     addResultsTool,
     addAttachmentToRunTool,
-]
-
+];
 for (const tool of tools) {
-    server.registerTool(
-        tool.name,
-        {
-            description: tool.description,
-            inputSchema: tool.parameters,
-        },
-        async (args: any) => {
-            try {
-                const output: Record<string, any> = await tool.handler(args, client);
-                const sanitized = removeNullish(output);
-
-                return {
-                    content: [
-                        {
-                            type: "text" as const,
-                            text: JSON.stringify(sanitized),
-                        },
-                    ],
-                } as any;
-            } catch (error: any) {
-                return {
-                    content: [{ type: "text", text: `Error: ${error.message}` }],
-                    isError: true,
-                };
-            }
+    server.registerTool(tool.name, {
+        description: tool.description,
+        inputSchema: tool.parameters,
+    }, async (args) => {
+        try {
+            const output = await tool.handler(args, client);
+            const sanitized = removeNullish(output);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(sanitized),
+                    },
+                ],
+            };
         }
-    );
+        catch (error) {
+            return {
+                content: [{ type: "text", text: `Error: ${error.message}` }],
+                isError: true,
+            };
+        }
+    });
 }
-
 const transport = new StdioServerTransport();
 await server.connect(transport);

package/{src/tools/add_attachment_to_run.ts → dist/tools/add_attachment_to_run.js}

@@ -1,59 +1,49 @@
-import { TestRailClient } from "../client/testrail.js";
 import { z } from "zod";
 import { AttachmentSchema } from "../types/testrail.js";
 import * as fs from "fs";
 import * as path from "path";
 import * as os from "os";
 import archiver from "archiver";
-import { ToolDefinition } from "../types/custom.js";
-
 const parameters = {
-    run_id: z.string().describe("The ID of the test run to attach the file to"),
+    run_id: z.number().describe("The ID of the test run to attach the file to"),
     file_path: z.string().describe("The path to the file or directory to attach. Directories will be automatically zipped."),
-}
-
-export const addAttachmentToRunTool: ToolDefinition<typeof parameters, TestRailClient> = {
+};
+export const addAttachmentToRunTool = {
     name: "add_attachment_to_run",
     description: "Add an attachment to a test run in TestRail. If the file_path points to a directory, it will be automatically zipped before uploading. Maximum upload size is 256MB.",
     parameters,
-    handler: async ({ run_id, file_path }, client: TestRailClient) => {
+    handler: async ({ run_id, file_path }, client) => {
         if (!fs.existsSync(file_path)) {
             throw new Error(`File or directory not found: ${file_path}`);
         }
-
         const stats = fs.statSync(file_path);
-        let uploadPath: string = file_path;
-        let filename: string = path.basename(file_path);
+        let uploadPath = file_path;
+        let filename = path.basename(file_path);
         let isTemporary = false;
-
         if (stats.isDirectory()) {
             const basename = path.basename(file_path);
             const tempDir = os.tmpdir();
             const zipPath = path.join(tempDir, `${basename}-${Date.now()}.zip`);
-
-            await new Promise<void>((resolve, reject) => {
+            await new Promise((resolve, reject) => {
                 const output = fs.createWriteStream(zipPath);
                 const archive = archiver('zip', {
                     zlib: { level: 9 }
                 });
-
                 output.on('close', () => resolve());
                 archive.on('error', (err) => reject(err));
-
                 archive.pipe(output);
                 archive.directory(file_path, basename);
                 archive.finalize();
             });
-
             uploadPath = zipPath;
             filename = `${basename}.zip`;
             isTemporary = true;
         }
-
         try {
-            const result = await client.addAttachmentToRun(Number(run_id), uploadPath, filename);
+            const result = await client.addAttachmentToRun(run_id, uploadPath, filename);
             return AttachmentSchema.parse(result);
-        } finally {
+        }
+        finally {
             if (isTemporary && fs.existsSync(uploadPath)) {
                 fs.unlinkSync(uploadPath);
             }

package/{src/tools/add_results.ts → dist/tools/add_results.js}

@@ -1,8 +1,5 @@
-import { TestRailClient } from "../client/testrail.js";
 import { z } from "zod";
 import { ResultSchema } from "../types/testrail.js";
-import { ToolDefinition } from "../types/custom.js";
-
 const parameters = {
     run_id: z.number().describe("The ID of the test run"),
     results: z.array(z.object({
@@ -11,13 +8,12 @@ const parameters = {
         comment: z.string().optional().describe("Optional comment/description for the result"),
         defects: z.string().optional().describe("Optional comma-separated list of defect IDs"),
     })).describe("Array of results to add. Each result must have test_id and status_id"),
-}
-
-export const addResultsTool: ToolDefinition<typeof parameters, TestRailClient> = {
+};
+export const addResultsTool = {
     name: "add_results",
     description: "Add one or more test results to a test run",
     parameters,
-    handler: async ({ run_id, results }, client: TestRailClient) => {
+    handler: async ({ run_id, results }, client) => {
         const response = await client.addResults(run_id, results);
         return {
             success: true,

package/{src/tools/add_run.ts → dist/tools/add_run.js}

@@ -1,24 +1,19 @@
-import { TestRailClient } from "../client/testrail.js";
 import { z } from "zod";
 import { RunSchema } from "../types/testrail.js";
-import { ToolDefinition } from "../types/custom.js";
-
 const parameters = {
-    project_id: z.string().describe("The ID of the project. Use get_projects to find available projects"),
+    project_id: z.number().describe("The ID of the project. Use get_projects to find available projects"),
     name: z.string().optional().describe("The name of the test run"),
     description: z.string().optional().describe("The description of the test run"),
     case_ids: z.array(z.number()).describe("Array of case IDs to include in the run. After creating the run, use get_tests with the returned run_id to retrieve test IDs for result submission")
-}
-
-export const addRunTool: ToolDefinition<typeof parameters, TestRailClient> = {
+};
+export const addRunTool = {
     name: "add_run",
     description: "Create a new test run in TestRail",
     parameters,
-    handler: async ({ project_id, ...fields }, client: TestRailClient) => {
-        const caseData = await client.getCase(String(fields.case_ids[0]));
+    handler: async ({ project_id, ...fields }, client) => {
+        const caseData = await client.getCase(fields.case_ids[0]);
         const params = { suite_id: caseData.suite_id, include_all: false, ...fields };
         const run = await client.addRun(project_id, params);
-
         return RunSchema.parse(run);
     },
 };