@testomatio/mcp 1.0.14 → 2.0.0-beta.8

package/package.json

@@ -1,26 +1,15 @@
 {
   "name": "@testomatio/mcp",
-  "version": "1.0.14",
+  "version": "2.0.0-beta.8",
   "description": "Model Context Protocol server for Testomatio API",
-  "main": "index.js",
+  "main": "src/index.js",
   "bin": {
     "testomatio-mcp": "index.js"
   },
   "type": "module",
   "scripts": {
     "start": "node index.js",
-    "dev": "node index.js",
-    "test": "node --experimental-vm-modules node_modules/.bin/jest",
-    "test:unit": "node --experimental-vm-modules node_modules/.bin/jest",
-    "test:integration": "node --experimental-vm-modules node_modules/.bin/jest --config jest.integration.config.js",
-    "test:e2e": "node --experimental-vm-modules node_modules/.bin/jest --config jest.e2e.config.js",
-    "test:watch": "node --experimental-vm-modules node_modules/.bin/jest --watch",
-    "test:integration:watch": "node --experimental-vm-modules node_modules/.bin/jest --config jest.integration.config.js --watch",
-    "test:e2e:watch": "node --experimental-vm-modules node_modules/.bin/jest --config jest.e2e.config.js --watch",
-    "test:coverage": "node --experimental-vm-modules node_modules/.bin/jest --coverage",
-    "test:coverage:integration": "node --experimental-vm-modules node_modules/.bin/jest --config jest.integration.config.js --coverage",
-    "test:coverage:e2e": "node --experimental-vm-modules node_modules/.bin/jest --config jest.e2e.config.js --coverage",
-    "test:all": "npm run test:unit && npm run test:integration && npm run test:e2e"
+    "dev": "node index.js"
   },
   "keywords": [
     "testomatio",
@@ -32,6 +21,10 @@
   ],
   "author": "Testomatio Team",
   "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/testomatio/mcp"
+  },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^0.4.0",
     "commander": "^12.0.0",
@@ -39,13 +32,11 @@
   },
   "files": [
     "index.js",
+    "src",
     "README.md"
   ],
   "engines": {
     "node": ">=18.0.0"
   },
-  "devDependencies": {
-    "ajv": "^8.17.1",
-    "jest": "^30.2.0"
-  }
+  "devDependencies": {}
 }

package/src/api/http-client.js

@@ -0,0 +1,68 @@
+import { ApiError } from '../core/errors.js';
+
+function buildUrl(baseUrl, path, query = {}) {
+  const url = new URL(path, `${baseUrl}/`);
+
+  Object.entries(query).forEach(([key, value]) => {
+    if (value === undefined || value === null || value === '') {
+      return;
+    }
+
+    if (Array.isArray(value)) {
+      value.forEach((item) => url.searchParams.append(key, String(item)));
+      return;
+    }
+
+    url.searchParams.append(key, String(value));
+  });
+
+  return url.toString();
+}
+
+export class HttpClient {
+  constructor({ baseUrl, token, logger }) {
+    this.baseUrl = baseUrl;
+    this.token = token;
+    this.logger = logger;
+  }
+
+  async request(method, path, { query, body } = {}) {
+    const url = buildUrl(this.baseUrl, path, query);
+
+    const headers = {
+      Accept: 'application/json',
+      Authorization: `Bearer ${this.token}`,
+    };
+
+    const options = {
+      method,
+      headers,
+    };
+
+    if (body !== undefined) {
+      headers['Content-Type'] = 'application/json';
+      options.body = JSON.stringify(body);
+    }
+
+    this.logger.debug('HTTP request', { method, url });
+    const response = await fetch(url, options);
+    const text = await response.text();
+
+    let payload;
+    try {
+      payload = text ? JSON.parse(text) : {};
+    } catch {
+      payload = { raw: text };
+    }
+
+    if (!response.ok) {
+      throw new ApiError(`Request failed with status ${response.status}`, {
+        status: response.status,
+        url,
+        payload,
+      });
+    }
+
+    return payload;
+  }
+}

package/src/api/testomatio-client.js

@@ -0,0 +1,46 @@
+import { HttpClient } from './http-client.js';
+
+export class TestomatioApiClient {
+  constructor({ baseUrl, projectId, token, logger }) {
+    this.projectId = projectId;
+    this.http = new HttpClient({
+      baseUrl,
+      token,
+      logger,
+    });
+  }
+
+  buildPath(resource, id = '') {
+    const safeResource = String(resource).replace(/^\/+|\/+$/g, '');
+    const safeId = id ? `/${String(id).replace(/^\/+|\/+$/g, '')}` : '';
+    return `/api/v2/${this.projectId}/${safeResource}${safeId}`;
+  }
+
+  list(resource, query = {}) {
+    return this.http.request('GET', this.buildPath(resource), { query });
+  }
+
+  get(resource, id, query = {}) {
+    return this.http.request('GET', this.buildPath(resource, id), { query });
+  }
+
+  create(resource, body = {}) {
+    return this.http.request('POST', this.buildPath(resource), { body });
+  }
+
+  createWithQuery(resource, { query = {}, body = {} } = {}) {
+    return this.http.request('POST', this.buildPath(resource), { query, body });
+  }
+
+  update(resource, id, body = {}) {
+    return this.http.request('PUT', this.buildPath(resource, id), { body });
+  }
+
+  delete(resource, id, query = {}) {
+    return this.http.request('DELETE', this.buildPath(resource, id), { query });
+  }
+
+  search(resource, query = {}) {
+    return this.list(resource, query);
+  }
+}

package/src/cli/main.js

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import { createApplication } from '../index.js';
+import { ConfigurationError } from '../core/errors.js';
+import { getPackageVersion } from '../config/package-version.js';
+
+export function parseArgs(argv = process.argv) {
+  const command = new Command();
+
+  command
+    .name('testomatio-mcp')
+    .description('Model Context Protocol server for Testomatio API v2')
+    .version(getPackageVersion())
+    .option('-t, --token <token>', 'Testomatio Project token')
+    .option('-p, --project <project>', 'Project ID')
+    .option('--base-url <url>', 'Base URL for Testomatio API')
+    .parse(argv);
+
+  return command.opts();
+}
+
+export async function main(argv = process.argv) {
+  try {
+    const options = parseArgs(argv);
+    const app = createApplication(options);
+    await app.mcpServer.run();
+  } catch (error) {
+    if (error instanceof ConfigurationError) {
+      console.error(`Configuration error: ${error.message}`);
+      process.exit(1);
+    }
+
+    console.error('Failed to start server:', error.message || error);
+    process.exit(1);
+  }
+}

package/src/config/constants.js

@@ -0,0 +1,3 @@
+export const DEFAULT_BASE_URL = 'https://app.testomat.io';
+
+export const DEFAULT_TOOL_RESPONSE = 'Tool is declared but has no handler implementation.';

package/src/config/load-config.js

@@ -0,0 +1,37 @@
+import { DEFAULT_BASE_URL } from './constants.js';
+import { ConfigurationError } from '../core/errors.js';
+
+function normalizeString(value) {
+  return typeof value === 'string' ? value.trim() : '';
+}
+
+function normalizeBaseUrl(value) {
+  const normalized = normalizeString(value);
+  return normalized.replace(/\/+$/, '');
+}
+
+export function loadConfig(argvOptions = {}) {
+  const token = normalizeString(
+    argvOptions.token || process.env.TESTOMATIO_PROJECT_TOKEN || process.env.TESTOMATIO_API_TOKEN
+  );
+  const projectId = normalizeString(argvOptions.project || process.env.TESTOMATIO_PROJECT_ID);
+  const baseUrl = normalizeBaseUrl(argvOptions.baseUrl || process.env.TESTOMATIO_BASE_URL || DEFAULT_BASE_URL);
+
+  if (!token) {
+    throw new ConfigurationError(
+      'Project token is required. Use --token <token> or set TESTOMATIO_PROJECT_TOKEN (or TESTOMATIO_API_TOKEN).'
+    );
+  }
+
+  if (!projectId) {
+    throw new ConfigurationError(
+      'Project ID is required. Use --project <project_id> or set TESTOMATIO_PROJECT_ID'
+    );
+  }
+
+  return {
+    token,
+    projectId,
+    baseUrl,
+  };
+}

package/src/config/package-version.js

@@ -0,0 +1,19 @@
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+let cachedVersion;
+
+export function getPackageVersion() {
+  if (cachedVersion) {
+    return cachedVersion;
+  }
+
+  const __filename = fileURLToPath(import.meta.url);
+  const __dirname = path.dirname(__filename);
+  const packageJsonPath = path.resolve(__dirname, '../../package.json');
+  const raw = fs.readFileSync(packageJsonPath, 'utf8');
+  const pkg = JSON.parse(raw);
+  cachedVersion = pkg.version || '0.0.0';
+  return cachedVersion;
+}

package/src/core/errors.js

@@ -0,0 +1,24 @@
+export class ConfigurationError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'ConfigurationError';
+  }
+}
+
+export class ApiError extends Error {
+  constructor(message, details = {}) {
+    super(message);
+    this.name = 'ApiError';
+    this.status = details.status;
+    this.url = details.url;
+    this.payload = details.payload;
+  }
+}
+
+export class NotImplementedToolError extends Error {
+  constructor(toolName) {
+    super(`Tool "${toolName}" is not registered in this MCP server`);
+    this.name = 'NotImplementedToolError';
+    this.toolName = toolName;
+  }
+}

package/src/core/logger.js

@@ -0,0 +1,31 @@
+function shouldLog(level, currentLevel) {
+  const order = ['error', 'warn', 'info', 'debug'];
+  return order.indexOf(level) <= order.indexOf(currentLevel);
+}
+
+export function createLogger(level = process.env.LOG_LEVEL || 'info') {
+  const currentLevel = String(level).toLowerCase();
+
+  return {
+    error(message, meta) {
+      if (shouldLog('error', currentLevel)) {
+        console.error(`[error] ${message}`, meta || '');
+      }
+    },
+    warn(message, meta) {
+      if (shouldLog('warn', currentLevel)) {
+        console.error(`[warn] ${message}`, meta || '');
+      }
+    },
+    info(message, meta) {
+      if (shouldLog('info', currentLevel)) {
+        console.error(`[info] ${message}`, meta || '');
+      }
+    },
+    debug(message, meta) {
+      if (shouldLog('debug', currentLevel)) {
+        console.error(`[debug] ${message}`, meta || '');
+      }
+    },
+  };
+}

package/src/helpers/mcp-response.js

@@ -0,0 +1,11 @@
+export function textResponse(text) {
+  return {
+    content: [
+      {
+        type: 'text',
+        text,
+      },
+    ],
+  };
+}
+

package/src/index.js

@@ -0,0 +1,20 @@
+import { TestomatioApiClient } from './api/testomatio-client.js';
+import { loadConfig } from './config/load-config.js';
+import { createLogger } from './core/logger.js';
+import { TestomatioMCPServer } from './mcp/server.js';
+
+export { TestomatioMCPServer };
+
+export function createApplication(argvOptions = {}) {
+  const config = loadConfig(argvOptions);
+  const logger = createLogger();
+  const apiClient = new TestomatioApiClient({ ...config, logger });
+  const mcpServer = new TestomatioMCPServer({ config, apiClient, logger });
+
+  return {
+    config,
+    logger,
+    apiClient,
+    mcpServer,
+  };
+}

package/src/mcp/configs/entity-crud-config.js

@@ -0,0 +1,99 @@
+export const ENTITY_CRUD_CONFIGS = [
+  {
+    toolPrefix: 'tests',
+    resource: 'tests',
+    idArg: 'test_id',
+    listMethod: 'listTests',
+    searchMethod: 'searchTests',
+    payloadBuilder: 'buildTestPayload',
+    wrapperKey: 'test',
+    createMode: 'wrapped',
+    updateMode: 'wrapped',
+  },
+  {
+    toolPrefix: 'suites',
+    resource: 'suites',
+    idArg: 'suite_id',
+    listMethod: 'listSuites',
+    searchMethod: 'searchSuites',
+    payloadBuilder: 'buildSuitePayload',
+    wrapperKey: 'suite',
+    createMode: 'wrapped',
+    updateMode: 'wrapped',
+  },
+  {
+    toolPrefix: 'runs',
+    resource: 'runs',
+    idArg: 'run_id',
+    listMethod: 'listRuns',
+    searchMethod: 'searchRuns',
+    createMode: 'run',
+    updateMode: 'run',
+  },
+  {
+    toolPrefix: 'testruns',
+    resource: 'testruns',
+    idArg: 'testrun_id',
+    listMethod: 'listTestruns',
+    searchMethod: 'searchTestruns',
+    payloadBuilder: 'buildTestrunPayload',
+    wrapperKey: 'testrun',
+    createMode: 'wrapped',
+    updateMode: 'wrapped',
+  },
+  {
+    toolPrefix: 'rungroups',
+    resource: 'rungroups',
+    idArg: 'rungroup_id',
+    listMethod: 'listRungroups',
+    searchMethod: 'searchRungroups',
+    payloadBuilder: 'buildRungroupPayload',
+    wrapperKey: 'rungroup',
+    createMode: 'wrapped',
+    updateMode: 'wrapped',
+  },
+  {
+    toolPrefix: 'steps',
+    resource: 'steps',
+    idArg: 'step_id',
+    listMethod: 'listSteps',
+    searchMethod: 'searchSteps',
+    payloadBuilder: 'buildStepPayload',
+    wrapperKey: 'step',
+    createMode: 'wrapped',
+    updateMode: 'wrapped',
+  },
+  {
+    toolPrefix: 'snippets',
+    resource: 'snippets',
+    idArg: 'snippet_id',
+    listMethod: 'listSnippets',
+    searchMethod: 'searchSnippets',
+    payloadBuilder: 'buildSnippetPayload',
+    wrapperKey: 'snippet',
+    createMode: 'wrapped',
+    updateMode: 'wrapped',
+  },
+  {
+    toolPrefix: 'labels',
+    resource: 'labels',
+    idArg: 'label_id',
+    listMethod: 'listLabels',
+    searchMethod: 'searchLabels',
+    payloadBuilder: 'buildLabelPayload',
+    wrapperKey: 'label',
+    createMode: 'wrapped',
+    updateMode: 'wrapped',
+  },
+  {
+    toolPrefix: 'plans',
+    resource: 'plans',
+    idArg: 'plan_id',
+    listMethod: 'listPlans',
+    searchMethod: 'searchPlans',
+    payloadBuilder: 'buildPlanPayload',
+    wrapperKey: 'plan',
+    createMode: 'wrapped',
+    updateMode: 'wrapped',
+  },
+];

package/src/mcp/configs/issues-config.js

@@ -0,0 +1,9 @@
+export const ISSUE_RESOURCE_KEYS = ['test_id', 'suite_id', 'run_id', 'testrun_id', 'plan_id'];
+
+export const ISSUE_SCOPED_TOOL_CONFIGS = [
+  { toolPrefix: 'tests', resourceKey: 'test_id' },
+  { toolPrefix: 'suites', resourceKey: 'suite_id' },
+  { toolPrefix: 'runs', resourceKey: 'run_id' },
+  { toolPrefix: 'testruns', resourceKey: 'testrun_id' },
+  { toolPrefix: 'plans', resourceKey: 'plan_id' },
+];

package/src/mcp/definitions/issues.js

@@ -0,0 +1,131 @@
+export const ISSUES_TOOLS = [
+  {
+    "name": "issues_list",
+    "description": "List linked issues (/api/v2/{project_id}/issues)",
+    "inputSchema": {
+      "type": "object",
+      "properties": {
+        "page": {
+          "type": "integer",
+          "minimum": 1
+        },
+        "per_page": {
+          "type": "integer",
+          "minimum": 1,
+          "maximum": 100
+        },
+        "test_id": {
+          "type": "string"
+        },
+        "suite_id": {
+          "type": "string"
+        },
+        "run_id": {
+          "type": "string"
+        },
+        "testrun_id": {
+          "type": "integer"
+        },
+        "plan_id": {
+          "type": "string"
+        },
+        "source": {
+          "type": "string"
+        }
+      },
+      "additionalProperties": false
+    }
+  },
+  {
+    "name": "issues_create",
+    "description": "Link issue to resource (/api/v2/{project_id}/issues)",
+    "inputSchema": {
+      "type": "object",
+      "properties": {
+        "test_id": {
+          "type": "string"
+        },
+        "suite_id": {
+          "type": "string"
+        },
+        "run_id": {
+          "type": "string"
+        },
+        "testrun_id": {
+          "type": "integer"
+        },
+        "plan_id": {
+          "type": "string"
+        },
+        "url": {
+          "type": "string"
+        },
+        "jira_id": {
+          "type": "string"
+        }
+      },
+      "additionalProperties": false
+    }
+  },
+  {
+    "name": "issues_delete",
+    "description": "Unlink issue (/api/v2/{project_id}/issues/{id})",
+    "inputSchema": {
+      "type": "object",
+      "properties": {
+        "issue_id": {
+          "type": "integer"
+        },
+        "type": {
+          "type": "string",
+          "enum": [
+            "issue",
+            "jira_issue"
+          ]
+        }
+      },
+      "required": [
+        "issue_id",
+        "type"
+      ],
+      "additionalProperties": false
+    }
+  },
+  {
+    "name": "issues_search",
+    "description": "Search issues (delegates to issues_list filters)",
+    "inputSchema": {
+      "type": "object",
+      "properties": {
+        "page": {
+          "type": "integer",
+          "minimum": 1
+        },
+        "per_page": {
+          "type": "integer",
+          "minimum": 1,
+          "maximum": 100
+        },
+        "test_id": {
+          "type": "string"
+        },
+        "suite_id": {
+          "type": "string"
+        },
+        "run_id": {
+          "type": "string"
+        },
+        "testrun_id": {
+          "type": "integer"
+        },
+        "plan_id": {
+          "type": "string"
+        },
+        "source": {
+          "type": "string"
+        }
+      },
+      "additionalProperties": false
+    }
+  }
+];