@smartbear/mcp 0.10.0 → 0.12.0

package/dist/qmetry/client/automation.js

@@ -0,0 +1,171 @@
+import { MCP_SERVER_NAME, MCP_SERVER_VERSION } from "../../common/info.js";
+import { QMETRY_DEFAULTS } from "../config/constants.js";
+import { QMETRY_PATHS } from "../config/rest-endpoints.js";
+import { DEFAULT_IMPORT_AUTOMATION_PAYLOAD } from "../types/automation.js";
+import { qmetryRequest } from "./api/client-api.js";
+import { handleQMetryApiError } from "./api/error-handler.js";
+/**
+ * Imports automation test results into QMetry
+ *
+ * This function handles file upload via FormData to import automation test results
+ * from various frameworks (TestNG, JUnit, Cucumber, Robot, etc.)
+ *
+ * CRITICAL NOTES:
+ * - User MUST provide a valid result file (.json, .xml, or .zip up to 30 MB)
+ * - File should be base64 encoded or provided as file path
+ * - EntityType is required and determines the framework format
+ * - Various parameters control test case/suite creation and linking behavior
+ *
+ * @param token - QMetry API authentication token
+ * @param baseUrl - QMetry instance base URL
+ * @param project - Project key (used in header, can be overridden by projectID in payload)
+ * @param payload - Import configuration including file data, entityType, and optional parameters
+ * @returns Promise resolving to import result with test suite and execution details
+ */
+export async function importAutomationResults(token, baseUrl, project, payload) {
+    // Merge with defaults
+    const finalPayload = {
+        ...DEFAULT_IMPORT_AUTOMATION_PAYLOAD,
+        ...payload,
+    };
+    // Create FormData for multipart/form-data upload
+    const formData = new FormData();
+    // Handle file upload
+    // The file should be provided as base64 string or file content
+    let fileBlob;
+    if (finalPayload.file.startsWith("data:")) {
+        // Base64 data URI format
+        const base64Data = finalPayload.file.split(",")[1];
+        const binaryData = atob(base64Data);
+        const bytes = new Uint8Array(binaryData.length);
+        for (let i = 0; i < binaryData.length; i++) {
+            bytes[i] = binaryData.charCodeAt(i);
+        }
+        fileBlob = new Blob([bytes]);
+    }
+    else if (finalPayload.file.startsWith("/") ||
+        finalPayload.file.includes(":\\")) {
+        // File path - read file from filesystem (Node.js only)
+        try {
+            const fs = await import("node:fs/promises");
+            const fileBuffer = await fs.readFile(finalPayload.file);
+            fileBlob = new Blob([new Uint8Array(fileBuffer)]);
+        }
+        catch (error) {
+            throw new Error(`Failed to read file from path: ${finalPayload.file}. Error: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    else {
+        // Assume raw base64 string
+        try {
+            const binaryData = atob(finalPayload.file);
+            const bytes = new Uint8Array(binaryData.length);
+            for (let i = 0; i < binaryData.length; i++) {
+                bytes[i] = binaryData.charCodeAt(i);
+            }
+            fileBlob = new Blob([bytes]);
+        }
+        catch (_error) {
+            throw new Error("Invalid file format. Please provide base64 encoded file content or file path.");
+        }
+    }
+    // Add file to FormData
+    formData.append("file", fileBlob, finalPayload.fileName);
+    // Add required entityType
+    formData.append("entityType", finalPayload.entityType);
+    // Add optional parameters
+    if (finalPayload.automationHierarchy) {
+        formData.append("automationHierarchy", finalPayload.automationHierarchy);
+    }
+    if (finalPayload.testsuiteName) {
+        formData.append("testsuiteName", finalPayload.testsuiteName);
+    }
+    if (finalPayload.testsuiteId) {
+        formData.append("testsuiteId", finalPayload.testsuiteId);
+    }
+    if (finalPayload.tsFolderPath) {
+        formData.append("tsFolderPath", finalPayload.tsFolderPath);
+    }
+    if (finalPayload.tcFolderPath) {
+        formData.append("tcFolderPath", finalPayload.tcFolderPath);
+    }
+    if (finalPayload.platformID) {
+        formData.append("platformID", finalPayload.platformID);
+    }
+    if (finalPayload.projectID) {
+        formData.append("projectID", finalPayload.projectID);
+    }
+    if (finalPayload.releaseID) {
+        formData.append("releaseID", finalPayload.releaseID);
+    }
+    if (finalPayload.cycleID) {
+        formData.append("cycleID", finalPayload.cycleID);
+    }
+    if (finalPayload.buildID) {
+        formData.append("buildID", finalPayload.buildID);
+    }
+    if (finalPayload.testcase_fields) {
+        formData.append("testcase_fields", finalPayload.testcase_fields);
+    }
+    if (finalPayload.testsuite_fields) {
+        formData.append("testsuite_fields", finalPayload.testsuite_fields);
+    }
+    if (finalPayload.skipWarning) {
+        formData.append("skipWarning", finalPayload.skipWarning);
+    }
+    if (finalPayload.is_matching_required) {
+        formData.append("is_matching_required", finalPayload.is_matching_required);
+    }
+    // Make API request
+    const url = `${baseUrl || QMETRY_DEFAULTS.BASE_URL}${QMETRY_PATHS.AUTOMATION.IMPORT_RESULTS}`;
+    const headers = {
+        apikey: token,
+        project: finalPayload.projectID || project || QMETRY_DEFAULTS.PROJECT_KEY,
+        "User-Agent": `${MCP_SERVER_NAME}/${MCP_SERVER_VERSION}`,
+        // Note: Content-Type will be set automatically by fetch for FormData
+    };
+    let res;
+    try {
+        res = await fetch(url, {
+            method: "POST",
+            headers,
+            body: formData,
+        });
+    }
+    catch (error) {
+        throw new Error(`Failed to import automation results. Network error: ${error instanceof Error ? error.message : String(error)}\n\nPlease check:\n- QMetry server is accessible\n- File size is under 30 MB\n- File format is .json, .xml, or .zip`);
+    }
+    if (!res.ok) {
+        await handleQMetryApiError(res, baseUrl || QMETRY_DEFAULTS.BASE_URL, project || QMETRY_DEFAULTS.PROJECT_KEY, QMETRY_PATHS.AUTOMATION.IMPORT_RESULTS);
+    }
+    return await res.json();
+}
+/**
+ * Fetches automation status by request ID from QMetry
+ * @param token - QMetry API authentication token
+ * @param baseUrl - QMetry instance base URL
+ * @param requestID - Numeric request ID from import automation response
+ * @returns Promise resolving to automation status
+ */
+export async function getAutomationStatus(token, baseUrl, project, requestID) {
+    let numericRequestID;
+    if (typeof requestID === "object" &&
+        requestID !== null &&
+        "requestID" in requestID &&
+        typeof requestID.requestID !== "undefined") {
+        numericRequestID = Number(requestID.requestID);
+    }
+    else {
+        numericRequestID = Number(requestID);
+    }
+    if (!numericRequestID || Number.isNaN(numericRequestID)) {
+        throw new Error("requestID must be a valid number");
+    }
+    return qmetryRequest({
+        method: "GET",
+        path: QMETRY_PATHS.AUTOMATION.GET_STATUS.replace(":requestID", String(numericRequestID)),
+        token,
+        baseUrl: baseUrl || QMETRY_DEFAULTS.BASE_URL,
+        project: project || QMETRY_DEFAULTS.PROJECT_KEY,
+    });
+}

package/dist/qmetry/client/handlers.js

@@ -1,9 +1,10 @@
 import { QMetryToolsHandlers } from "../config/constants.js";
+import { getAutomationStatus, importAutomationResults } from "./automation.js";
 import { createIssue, fetchIssues, fetchIssuesLinkedToTestCase, linkIssuesToTestcaseRun, updateIssue, } from "./issues.js";
-import { getBuilds, getPlatforms, getProjectInfo, getProjects, getReleasesCycles, } from "./project.js";
+import { createCycle, createRelease, getBuilds, getPlatforms, getProjectInfo, getProjects, getReleasesCycles, updateCycle, } from "./project.js";
 import { fetchRequirementDetails, fetchRequirements, fetchRequirementsLinkedToTestCase, } from "./requirement.js";
 import { createTestCases, fetchTestCaseDetails, fetchTestCaseExecutions, fetchTestCaseSteps, fetchTestCases, fetchTestCasesLinkedToRequirement, fetchTestCaseVersionDetails, linkRequirementToTestCase, updateTestCase, } from "./testcase.js";
-import { createTestSuites, fetchExecutionsByTestSuite, fetchLinkedIssuesByTestCaseRun, fetchTestCaseRunsByTestSuiteRun, fetchTestCasesByTestSuite, fetchTestSuites, fetchTestSuitesForTestCase, linkPlatformsToTestSuite, linkTestCasesToTestSuite, reqLinkedTestCasesToTestSuite, updateTestSuite, } from "./testsuite.js";
+import { bulkUpdateExecutionStatus, createTestSuites, fetchExecutionsByTestSuite, fetchLinkedIssuesByTestCaseRun, fetchTestCaseRunsByTestSuiteRun, fetchTestCasesByTestSuite, fetchTestSuites, fetchTestSuitesForTestCase, linkPlatformsToTestSuite, linkTestCasesToTestSuite, reqLinkedTestCasesToTestSuite, updateTestSuite, } from "./testsuite.js";
 export const QMETRY_HANDLER_MAP = {
     [QMetryToolsHandlers.FETCH_PROJECTS]: getProjects,
     [QMetryToolsHandlers.SET_PROJECT_INFO]: getProjectInfo,
@@ -11,6 +12,9 @@ export const QMETRY_HANDLER_MAP = {
     [QMetryToolsHandlers.FETCH_RELEASES_CYCLES]: getReleasesCycles,
     [QMetryToolsHandlers.FETCH_BUILDS]: getBuilds,
     [QMetryToolsHandlers.FETCH_PLATFORMS]: getPlatforms,
+    [QMetryToolsHandlers.CREATE_RELEASE]: createRelease,
+    [QMetryToolsHandlers.CREATE_CYCLE]: createCycle,
+    [QMetryToolsHandlers.UPDATE_CYCLE]: updateCycle,
     [QMetryToolsHandlers.CREATE_TEST_CASE]: createTestCases,
     [QMetryToolsHandlers.UPDATE_TEST_CASE]: updateTestCase,
     [QMetryToolsHandlers.FETCH_TEST_CASES]: fetchTestCases,
@@ -31,6 +35,7 @@ export const QMETRY_HANDLER_MAP = {
     [QMetryToolsHandlers.REQUIREMENTS_LINKED_TESTCASES_TO_TESTSUITE]: reqLinkedTestCasesToTestSuite,
     [QMetryToolsHandlers.FETCH_TESTCASES_BY_TESTSUITE]: fetchTestCasesByTestSuite,
     [QMetryToolsHandlers.FETCH_EXECUTIONS_BY_TESTSUITE]: fetchExecutionsByTestSuite,
+    [QMetryToolsHandlers.BULK_UPDATE_EXECUTION_STATUS]: bulkUpdateExecutionStatus,
     [QMetryToolsHandlers.FETCH_TESTCASE_RUNS_BY_TESTSUITE_RUN]: fetchTestCaseRunsByTestSuiteRun,
     [QMetryToolsHandlers.FETCH_LINKED_ISSUES_BY_TESTCASE_RUN]: fetchLinkedIssuesByTestCaseRun,
     [QMetryToolsHandlers.FETCH_ISSUES_LINKED_TO_TESTCASE]: fetchIssuesLinkedToTestCase,
@@ -39,4 +44,6 @@ export const QMETRY_HANDLER_MAP = {
     [QMetryToolsHandlers.FETCH_ISSUES]: fetchIssues,
     [QMetryToolsHandlers.LINK_ISSUES_TO_TESTCASE_RUN]: linkIssuesToTestcaseRun,
     [QMetryToolsHandlers.LINK_PLATFORMS_TO_TESTSUITE]: linkPlatformsToTestSuite,
+    [QMetryToolsHandlers.IMPORT_AUTOMATION_RESULTS]: importAutomationResults,
+    [QMetryToolsHandlers.FETCH_AUTOMATION_STATUS]: getAutomationStatus,
 };

package/dist/qmetry/client/project.js

@@ -1,7 +1,8 @@
 import { QMETRY_DEFAULTS } from "../config/constants.js";
 import { QMETRY_PATHS } from "../config/rest-endpoints.js";
-import { DEFAULT_FETCH_BUILD_PAYLOAD, DEFAULT_FETCH_PLATFORMS_PAYLOAD, DEFAULT_FETCH_PROJECTS_PAYLOAD, } from "../types/project.js";
+import { DEFAULT_CREATE_CYCLE_PAYLOAD, DEFAULT_CREATE_RELEASE_PAYLOAD, DEFAULT_FETCH_BUILD_PAYLOAD, DEFAULT_FETCH_PLATFORMS_PAYLOAD, DEFAULT_FETCH_PROJECTS_PAYLOAD, } from "../types/project.js";
 import { qmetryRequest } from "./api/client-api.js";
+import { resolveDefaults } from "./utils.js";
 /**
  * Retrieves project information from QMetry
  *
@@ -98,3 +99,88 @@ export async function getPlatforms(token, baseUrl, project, payload) {
         body,
     });
 }
+/**
+ * Creates a new release in QMetry with optional cycle
+ *
+ * @param token - QMetry API authentication token
+ * @param baseUrl - QMetry instance base URL
+ * @param project - Project key
+ * @param payload - Release and cycle data
+ * @returns Promise resolving to the created release information
+ */
+export async function createRelease(token, baseUrl, project, payload) {
+    const { resolvedBaseUrl, resolvedProject } = resolveDefaults(baseUrl, project);
+    const body = {
+        ...DEFAULT_CREATE_RELEASE_PAYLOAD,
+        ...payload,
+    };
+    if (typeof body.release.name !== "string") {
+        throw new Error("[createRelease] Missing or invalid required parameter: 'release.name'.");
+    }
+    if (body.cycle && typeof body.cycle.name !== "string") {
+        throw new Error("[createRelease] Missing or invalid required parameter: 'cycle.name'.");
+    }
+    return qmetryRequest({
+        method: "POST",
+        path: QMETRY_PATHS.PROJECT.CREATE_RELEASE,
+        token,
+        project: resolvedProject,
+        baseUrl: resolvedBaseUrl,
+        body,
+    });
+}
+/**
+ * Creates a new cycle within an existing release in QMetry
+ *
+ * @param token - QMetry API authentication token
+ * @param baseUrl - QMetry instance base URL
+ * @param project - Project key
+ * @param payload - Cycle data including releaseID
+ * @returns Promise resolving to the created cycle information
+ */
+export async function createCycle(token, baseUrl, project, payload) {
+    const { resolvedBaseUrl, resolvedProject } = resolveDefaults(baseUrl, project);
+    const body = {
+        ...DEFAULT_CREATE_CYCLE_PAYLOAD.cycle,
+        ...payload,
+    };
+    if (typeof body.cycle.name !== "string") {
+        throw new Error("[createCycle] Missing or invalid required parameter: 'cycle.name'.");
+    }
+    if (typeof body.cycle.releaseID !== "number") {
+        throw new Error("[createCycle] Missing or invalid required parameter: 'cycle.releaseID'.");
+    }
+    return qmetryRequest({
+        method: "POST",
+        path: QMETRY_PATHS.PROJECT.CREATE_CYCLE,
+        token,
+        project: resolvedProject,
+        baseUrl: resolvedBaseUrl,
+        body,
+    });
+}
+/**
+ * Updates an existing cycle in QMetry
+ * @param token - QMetry API token
+ * @param baseUrl - QMetry base URL
+ * @param project - Project key
+ * @param payload - Cycle data including buildID and releaseID for identification
+ * @returns Promise resolving to the updated cycle information
+ */
+export async function updateCycle(token, baseUrl, project, payload) {
+    const { resolvedBaseUrl, resolvedProject } = resolveDefaults(baseUrl, project);
+    if (typeof payload.cycle.buildID !== "number") {
+        throw new Error("[updateCycle] Missing or invalid required parameter: 'cycle.buildID'.");
+    }
+    if (typeof payload.cycle.releaseID !== "number") {
+        throw new Error("[updateCycle] Missing or invalid required parameter: 'cycle.releaseID'.");
+    }
+    return qmetryRequest({
+        method: "PUT",
+        path: QMETRY_PATHS.PROJECT.UPDATE_CYCLE,
+        token,
+        project: resolvedProject,
+        baseUrl: resolvedBaseUrl,
+        body: payload,
+    });
+}

package/dist/qmetry/client/testsuite.js

@@ -1,5 +1,5 @@
 import { QMETRY_PATHS } from "../config/rest-endpoints.js";
-import { DEFAULT_CREATE_TESTSUITE_PAYLOAD, DEFAULT_FETCH_EXECUTIONS_BY_TESTSUITE_PAYLOAD, DEFAULT_FETCH_LINKED_ISSUES_BY_TESTCASE_RUN_PAYLOAD, DEFAULT_FETCH_TESTCASE_RUNS_BY_TESTSUITE_RUN_PAYLOAD, DEFAULT_FETCH_TESTCASES_BY_TESTSUITE_PAYLOAD, DEFAULT_FETCH_TESTSUITES_FOR_TESTCASE_PAYLOAD, DEFAULT_FETCH_TESTSUITES_PAYLOAD, DEFAULT_LINKED_PLATFORMS_TO_TESTSUITE_PAYLOAD, DEFAULT_LINKED_TESTCASE_TO_TESTSUITE_PAYLOAD, DEFAULT_REQLINKED_TESTCASE_TO_TESTSUITE_PAYLOAD, DEFAULT_UPDATE_TESTSUITE_PAYLOAD, } from "../types/testsuite.js";
+import { DEFAULT_BULK_UPDATE_EXECUTION_STATUS_PAYLOAD, DEFAULT_CREATE_TESTSUITE_PAYLOAD, DEFAULT_FETCH_EXECUTIONS_BY_TESTSUITE_PAYLOAD, DEFAULT_FETCH_LINKED_ISSUES_BY_TESTCASE_RUN_PAYLOAD, DEFAULT_FETCH_TESTCASE_RUNS_BY_TESTSUITE_RUN_PAYLOAD, DEFAULT_FETCH_TESTCASES_BY_TESTSUITE_PAYLOAD, DEFAULT_FETCH_TESTSUITES_FOR_TESTCASE_PAYLOAD, DEFAULT_FETCH_TESTSUITES_PAYLOAD, DEFAULT_LINKED_PLATFORMS_TO_TESTSUITE_PAYLOAD, DEFAULT_LINKED_TESTCASE_TO_TESTSUITE_PAYLOAD, DEFAULT_REQLINKED_TESTCASE_TO_TESTSUITE_PAYLOAD, DEFAULT_UPDATE_TESTSUITE_PAYLOAD, } from "../types/testsuite.js";
 import { qmetryRequest } from "./api/client-api.js";
 import { resolveDefaults } from "./utils.js";
 /**
@@ -270,3 +270,39 @@ export async function linkPlatformsToTestSuite(token, baseUrl, project, payload)
         body,
     });
 }
+/**
+ * Bulk update execution status for test case runs.
+ * @throws If `entityIDs`, `entityType`, `qmTsRunId`, or `runStatusID` are missing/invalid.
+ */
+export async function bulkUpdateExecutionStatus(token, baseUrl, project, payload) {
+    const { resolvedBaseUrl, resolvedProject } = resolveDefaults(baseUrl, project);
+    const body = {
+        ...DEFAULT_BULK_UPDATE_EXECUTION_STATUS_PAYLOAD,
+        ...payload,
+    };
+    if (!body.entityIDs ||
+        typeof body.entityIDs !== "string" ||
+        body.entityIDs.trim().length === 0) {
+        throw new Error("[bulkUpdateExecutionStatus] Missing or invalid required parameter: 'entityIDs'. It must be a non-empty comma-separated string of Test Case Run IDs.");
+    }
+    if (!body.entityType ||
+        (body.entityType !== "TCR" && body.entityType !== "TCSR")) {
+        throw new Error("[bulkUpdateExecutionStatus] Missing or invalid required parameter: 'entityType'. Must be 'TCR' or 'TCSR'.");
+    }
+    if (!body.qmTsRunId ||
+        typeof body.qmTsRunId !== "string" ||
+        body.qmTsRunId.trim().length === 0) {
+        throw new Error("[bulkUpdateExecutionStatus] Missing or invalid required parameter: 'qmTsRunId'. It must be a non-empty string.");
+    }
+    if (typeof body.runStatusID !== "number") {
+        throw new Error("[bulkUpdateExecutionStatus] Missing or invalid required parameter: 'runStatusID'. It must be a number.");
+    }
+    return qmetryRequest({
+        method: "PUT",
+        path: QMETRY_PATHS.TESTSUITE.BULK_UPDATE_EXECUTION_STATUS,
+        token,
+        project: resolvedProject,
+        baseUrl: resolvedBaseUrl,
+        body,
+    });
+}

package/dist/qmetry/client/tools/automation-tools.js

@@ -0,0 +1,290 @@
+import { QMetryToolsHandlers } from "../../config/constants.js";
+import { FetchAutomationStatusPayloadSchema, ImportAutomationResultsPayloadSchema, } from "../../types/common.js";
+export const AUTOMATION_TOOLS = [
+    {
+        handler: QMetryToolsHandlers.IMPORT_AUTOMATION_RESULTS,
+        title: "Import Automation Test Results",
+        summary: "Import/Publish automation test results from TestNG, JUnit, Cucumber, Robot, HPUFT, or QAF frameworks into QMetry",
+        purpose: "Upload and import automation test result files to create test suites, test cases, and execution records in QMetry",
+        inputSchema: ImportAutomationResultsPayloadSchema,
+        useCases: [
+            "1. Import TestNG XML results after CI/CD pipeline execution",
+            "2. Publish JUnit test results to QMetry for tracking and reporting",
+            "3. Upload Cucumber JSON results with custom test suite organization",
+            "4. Import Robot Framework results with specific release/cycle mapping",
+            "5. Link automation results to existing test suites for version tracking",
+            "6. Create new test suites with custom names and folder structures",
+            "7. Map test results to specific platforms (browsers, OS, devices)",
+            "8. Associate imported results with releases, cycles, and builds",
+            "9. Bulk import multiple test results from ZIP archive",
+            "10. Configure test case/suite fields and user-defined fields during import",
+        ],
+        examples: [
+            {
+                description: "Basic TestNG result import",
+                parameters: {
+                    file: "<base64_encoded_testng_xml_content>",
+                    fileName: "testng-results.xml",
+                    entityType: "TESTNG",
+                },
+                expectedOutput: "Auto-generated test suite created with UTC timestamp, test cases auto-linked, execution results updated, 'No Platform' linked",
+            },
+            {
+                description: "JUnit results with custom test suite name",
+                parameters: {
+                    file: "<base64_encoded_junit_xml_content>",
+                    fileName: "junit-results.xml",
+                    entityType: "JUNIT",
+                    testsuiteName: "Regression Suite - Build 123",
+                    automationHierarchy: "1",
+                },
+                expectedOutput: "Test suite 'Regression Suite - Build 123' created with Test Case-Test Step hierarchy",
+            },
+            {
+                description: "Cucumber results with platform and release mapping",
+                parameters: {
+                    file: "<base64_encoded_cucumber_json_content>",
+                    fileName: "cucumber-results.json",
+                    entityType: "CUCUMBER",
+                    platformID: "Chrome 120",
+                    releaseID: "Release 2.0",
+                    cycleID: "Sprint 15",
+                    testsuiteName: "API Automation Tests",
+                },
+                expectedOutput: "Test suite created, linked to Chrome platform, Release 2.0, and Sprint 15 cycle",
+            },
+            {
+                description: "Reuse existing test suite",
+                parameters: {
+                    file: "<base64_encoded_testng_xml_content>",
+                    fileName: "testng-regression.xml",
+                    entityType: "TESTNG",
+                    testsuiteId: "PROJ-TS-42",
+                },
+                expectedOutput: "Test cases auto-linked to existing test suite PROJ-TS-42, execution results updated",
+            },
+            {
+                description: "Import with folder organization",
+                parameters: {
+                    file: "<base64_encoded_junit_xml_content>",
+                    fileName: "junit-results.xml",
+                    entityType: "JUNIT",
+                    tsFolderPath: "/Automation/Regression",
+                    tcFolderPath: "/Automation/API Tests",
+                    testsuiteName: "API Regression Suite",
+                },
+                expectedOutput: "Test suite created in '/Automation/Regression' folder, test cases in '/Automation/API Tests' folder",
+            },
+            {
+                description: "Import with test case custom fields",
+                parameters: {
+                    file: "<base64_encoded_testng_xml_content>",
+                    fileName: "testng-results.xml",
+                    entityType: "TESTNG",
+                    testcase_fields: JSON.stringify({
+                        priority: "High",
+                        testCaseType: "Automated",
+                        component: ["API", "Backend"],
+                        testcaseOwner: "john.doe",
+                        estimatedTime: "2h:30m:0s",
+                    }),
+                },
+                expectedOutput: "Test cases created with High priority, Automated type, API and Backend components",
+            },
+            {
+                description: "Import ZIP file with multiple results",
+                parameters: {
+                    file: "<base64_encoded_zip_content>",
+                    fileName: "test-results.zip",
+                    entityType: "JUNIT",
+                    testsuiteName: "Full Regression Suite",
+                    skipWarning: "1",
+                },
+                expectedOutput: "Multiple test results imported from ZIP, summaries truncated if >255 chars",
+            },
+            {
+                description: "Import with custom hierarchy for JUnit",
+                parameters: {
+                    file: "<base64_encoded_junit_xml_content>",
+                    fileName: "junit-results.xml",
+                    entityType: "JUNIT",
+                    automationHierarchy: "3",
+                    projectID: "PROJ",
+                },
+                expectedOutput: "Multiple test suites created per <testsuite> tag, test cases per <testcase> tag",
+            },
+            {
+                description: "Import with build and platform mapping",
+                parameters: {
+                    file: "<base64_encoded_testng_xml_content>",
+                    fileName: "testng-results.xml",
+                    entityType: "TESTNG",
+                    buildID: "Build-1.2.3",
+                    platformID: "Safari 17",
+                    releaseID: "Release 1.2",
+                    cycleID: "QA Cycle",
+                },
+                expectedOutput: "Results linked to Build 1.2.3, Safari 17 platform, Release 1.2, QA Cycle",
+            },
+            {
+                description: "Import with test suite and test case fields",
+                parameters: {
+                    file: "<base64_encoded_cucumber_json_content>",
+                    fileName: "cucumber-results.json",
+                    entityType: "CUCUMBER",
+                    testsuite_fields: JSON.stringify({
+                        testSuiteState: "In Progress",
+                        testsuiteOwner: "jane.smith",
+                        description: "Sprint 15 automation results",
+                    }),
+                    testcase_fields: JSON.stringify({
+                        priority: "Medium",
+                        component: ["UI", "Frontend"],
+                        userDefinedFields: {
+                            reviewedDate: "11-20-2024",
+                            environment: "Staging",
+                        },
+                    }),
+                },
+                expectedOutput: "Test suite and test cases created with custom fields and UDFs",
+            },
+        ],
+        hints: [
+            "1. CRITICAL: User MUST upload a valid result file before calling this tool",
+            "2. USER FILE UPLOAD REQUIRED: Ask user to provide file in chat - system will convert to base64",
+            "3. FILE REQUIREMENTS:",
+            "   - Supported extensions: .json, .xml, .zip",
+            "   - Maximum size: 30 MB",
+            "   - ZIP files must contain files matching the specified entityType format",
+            "4. REQUIRED PARAMETERS:",
+            "   - file: Base64 encoded content or file path",
+            "   - fileName: Original filename with extension",
+            "   - entityType: TESTNG, CUCUMBER, JUNIT, HPUFT, QAF, or ROBOT",
+            "5. ENTITY TYPES:",
+            "   - TESTNG: TestNG XML format",
+            "   - JUNIT: JUnit XML format",
+            "   - CUCUMBER: Cucumber JSON format",
+            "   - ROBOT: Robot Framework XML format",
+            "   - HPUFT: HP UFT format",
+            "   - QAF: QAF format",
+            "6. AUTOMATION HIERARCHY (TestNG/JUnit only):",
+            "   - TestNG:",
+            "     * 1 (default): <class name> = Test Case, <test-method> = Test Step",
+            "     * 2: <test-method> = Test Case only",
+            "     * 3: <name> under <test> = Test Case, <test-method> = Test Step",
+            "   - JUnit:",
+            "     * 1 (default): <testsuite> = Test Case, <testcase> = Test Step",
+            "     * 2: <testcase> = Test Case only",
+            "     * 3: <testsuite> = Test Suite, <testcase> = Test Case (creates multiple test suites)",
+            "7. TEST SUITE OPTIONS:",
+            "   - testsuiteName: Custom name for new test suite",
+            "   - testsuiteId: Reuse existing test suite by ID or Entity Key (e.g., 'PROJ-TS-42')",
+            "   - tsFolderPath: Create test suite in specific folder (e.g., '/Automation/Regression')",
+            "   - Note: testsuiteName/testsuiteId ignored if automationHierarchy=3 for JUnit or =2 for ROBOT",
+            "8. TEST CASE OPTIONS:",
+            "   - tcFolderPath: Create test cases in specific folder (e.g., '/Automation/API Tests')",
+            "   - Folders created automatically if they don't exist",
+            "9. LINKING OPTIONS:",
+            "   - platformID: Platform ID or name (e.g., 'Chrome 120', 'Safari 17')",
+            "   - projectID: Project ID, key, or name (overrides header project)",
+            "   - releaseID: Release ID or name (requires projectID)",
+            "   - cycleID: Cycle ID or name (requires releaseID and projectID)",
+            "   - buildID: Build ID or name",
+            "10. GET IDs FROM OTHER TOOLS:",
+            "    - Platform IDs: Use 'Platform/List' API (FETCH_PLATFORMS tool)",
+            "    - Project IDs: Use 'Project/List' API (FETCH_PROJECTS tool)",
+            "    - Release IDs: Use 'Release/List' API (FETCH_RELEASES_CYCLES tool)",
+            "    - Cycle IDs: Use 'Cycle/List' API (FETCH_RELEASES_CYCLES tool)",
+            "    - Build IDs: Use 'Build/List' API (FETCH_BUILDS tool)",
+            "    - Test Suite IDs: Use 'Testsuite/Fetch' API (FETCH_TEST_SUITES tool)",
+            "11. CUSTOM FIELDS (testcase_fields):",
+            "    - JSON string with system fields and UDFs",
+            "    - System fields: component, priority, testCaseState, testCaseType, testcaseOwner, estimatedTime, description",
+            '    - Example: {"component":["API"], "priority":"High", "testcaseOwner":"user"}',
+            "    - Ignored if reusing existing test case",
+            "12. CUSTOM FIELDS (testsuite_fields):",
+            "    - JSON string with system fields and UDFs",
+            "    - System fields: testSuiteState, testsuiteOwner, description",
+            '    - Example: {"testSuiteState":"Open", "testsuiteOwner":"user"}',
+            "    - Ignored if reusing existing test suite",
+            "13. USER DEFINED FIELDS (UDFs):",
+            "    - Include in testcase_fields or testsuite_fields under 'userDefinedFields' key",
+            '    - Example: {"userDefinedFields": {"reviewedDate": "11-20-2024", "environment": "Staging"}}',
+            "    - UDF types: STRING, LARGETEXT, LOOKUPLIST, MULTILOOKUPLIST, DATEPICKER, NUMBER",
+            "    - See tool metadata for UDF validation rules and auto-create behavior",
+            "14. SKIP WARNING OPTIONS:",
+            "    - skipWarning='0' (default): Fail import if test case summary >255 characters",
+            "    - skipWarning='1': Truncate summary to 255 characters and continue import",
+            "15. MATCHING BEHAVIOR:",
+            "    - is_matching_required='true' (default): Create new TC/version if summary/steps don't match",
+            "    - is_matching_required='false': Reuse existing TC version if entity key or summary matches",
+            "16. IMPORT BEHAVIOR EXAMPLES:",
+            "    - Only file + entityType → Auto-generated test suite, 'No Platform', test cases auto-linked",
+            "    - file + entityType + platformID → Auto-generated test suite with specified platform",
+            "    - file + entityType + testsuiteId → Results updated in existing test suite",
+            "    - file + entityType + platformID + testsuiteId → Results updated in existing test suite with platform",
+            "17. FOLDER CREATION:",
+            "    - If tsFolderPath or tcFolderPath specified and doesn't exist, it will be created automatically",
+            "    - Use forward slashes for folder paths (e.g., '/Parent/Child')",
+            "18. ESTIMATED TIME FORMAT:",
+            "    - Format: '2h:30m:15s' or '4h' or '7m' or '0s'",
+            "    - Range: 0 to 99999 minutes",
+            "19. OWNER FIELDS:",
+            "    - Use userAlias (username) not display name",
+            "    - testcaseOwner: User must have Test Case module rights",
+            "    - testsuiteOwner: User must have Test Suite module rights",
+            "    - Owner not set if user not found or lacks permissions",
+            "20. LOOKUPLIST/MULTILOOKUPLIST BEHAVIOR:",
+            "    - If value doesn't exist and auto-create is ON: Value added to list",
+            "    - If value doesn't exist and auto-create is OFF: Field blank or default value",
+            "    - MULTILOOKUPLIST: New values added, old values persist",
+            "21. MANDATORY FIELD VALIDATION:",
+            "    - If mandatory system/UDF field missing:",
+            "      * Auto-create OFF + value doesn't exist = Import FAIL",
+            "      * Auto-create ON + value doesn't exist = Import SUCCESS (value created)",
+            "      * Value exists = Import SUCCESS",
+            "22. ERROR HANDLING:",
+            "    - Check file size before upload (must be ≤30 MB)",
+            "    - Validate file extension matches entityType",
+            "    - Ensure required dependencies: cycleID requires releaseID and projectID",
+            "    - If import fails, check QMetry UI for detailed error messages",
+            "23. WORKFLOW:",
+            "    Step 1: Ask user to upload result file in chat",
+            "    Step 2: System converts file to base64",
+            "    Step 3: Collect entityType and optional parameters",
+            "    Step 4: Call this tool with file data and configuration",
+            "    Step 5: QMetry processes file and creates/updates test artifacts",
+            "    Step 6: Return import results with test suite and execution details",
+            "24. USER INTERACTION REQUIRED:",
+            "    - ALWAYS ask user to upload file before calling this tool",
+            "    - Display supported formats: .json, .xml, .zip (up to 30 MB)",
+            "    - Ask for entityType (framework used)",
+            "    - Ask for optional parameters based on user's needs",
+            "25. PERFORMANCE TIPS:",
+            "    - For large imports, consider using ZIP files",
+            "    - Reusing existing test suites is faster than creating new ones",
+            "    - Use automationHierarchy wisely to control test case/suite structure",
+        ],
+    },
+    {
+        handler: QMetryToolsHandlers.FETCH_AUTOMATION_STATUS,
+        title: "Fetch Automation Status",
+        summary: "Fetches the status of an automation import job by request ID.",
+        purpose: "Track the progress and result of an automation import operation in QMetry.",
+        inputSchema: FetchAutomationStatusPayloadSchema,
+        useCases: [
+            "1. Check if an automation import job is completed or still in progress.",
+            "2. Retrieve status, progress, and details for a specific automation import request.",
+            "3. Monitor automation result processing for CI/CD integrations.",
+        ],
+        examples: [
+            {
+                description: "Fetch status for request ID 12345",
+                parameters: {
+                    requestID: 12345,
+                },
+                expectedOutput: "Status, progress, and details of the automation import job for request ID 12345.",
+            },
+        ],
+    },
+];

package/dist/qmetry/client/tools/index.js

@@ -1,8 +1,10 @@
+export { AUTOMATION_TOOLS } from "./automation-tools.js";
 export { ISSUE_TOOLS } from "./issue-tools.js";
 export { PROJECT_TOOLS } from "./project-tools.js";
 export { REQUIREMENT_TOOLS } from "./requirement-tools.js";
 export { TESTCASE_TOOLS } from "./testcase-tools.js";
 export { TESTSUITE_TOOLS } from "./testsuite-tools.js";
+import { AUTOMATION_TOOLS } from "./automation-tools.js";
 import { ISSUE_TOOLS } from "./issue-tools.js";
 import { PROJECT_TOOLS } from "./project-tools.js";
 import { REQUIREMENT_TOOLS } from "./requirement-tools.js";
@@ -14,4 +16,5 @@ export const TOOLS = [
     ...REQUIREMENT_TOOLS,
     ...TESTSUITE_TOOLS,
     ...ISSUE_TOOLS,
+    ...AUTOMATION_TOOLS,
 ];