@msalaam/xray-qe-toolkit 1.1.0

package/bin/cli.js

@@ -0,0 +1,137 @@
+#!/usr/bin/env node
+
+/**
+ * @msalaam/xray-qe-toolkit — CLI Entry Point
+ *
+ * Usage:
+ *   npx xqt <command> [options]
+ *
+ * Commands:
+ *   init               Scaffold tests.json, xray-mapping.json, knowledge/ folder, .env.example
+ *   gen-tests          Generate test cases from knowledge/ using AI
+ *   edit-json          Launch browser-based QE review gate editor
+ *   push-tests         Push / update tests in Xray Cloud
+ *   gen-postman        Generate Postman collection from tests.json (with optional AI)
+ *   create-execution   Create a new Test Execution in JIRA
+ *   import-results     Import JUnit/Newman results into Xray
+ *   gen-pipeline       Generate an Azure Pipelines YAML template
+ *   mcp-server         Start Model Context Protocol server for agent integration
+ */
+
+import { Command } from "commander";
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import path from "node:path";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const pkg = JSON.parse(readFileSync(path.join(__dirname, "..", "package.json"), "utf8"));
+
+const program = new Command();
+
+program
+  .name("xray-qe")
+  .description("QE workflow toolkit for Xray Cloud — test management, Postman generation, and CI integration")
+  .version(pkg.version)
+  .option("--verbose", "Enable debug output")
+  .option("--env <path>", "Custom path to .env file");
+
+// ─── Commands ──────────────────────────────────────────────────────────────────
+
+program
+  .command("init")
+  .description("Initialize a new project with knowledge/ folder, tests.json, xray-mapping.json, and .env.example")
+  .action(async (opts, cmd) => {
+    const mod = await import("../commands/init.js");
+    await mod.default(cmd.optsWithGlobals());
+  });
+
+program
+  .command("gen-tests")
+  .description("Generate test cases from knowledge/ folder using AI")
+  .option("--ai", "Enable AI-assisted generation (requires connected provider)")
+  .option("--spec <path>", "OpenAPI/Swagger spec file to analyze")
+  .option("--knowledge <path>", "Custom knowledge folder path")
+  .option("--ticket <key>", "JIRA ticket key to fetch and analyze")
+  .option("--prompt <text>", "Natural language prompt for test generation")
+  .action(async (opts, cmd) => {
+    const mod = await import("../commands/genTests.js");
+    await mod.default({ ...opts, ...cmd.optsWithGlobals() });
+  });
+
+program
+  .command("edit-json")
+  .description("Launch browser-based QE review gate editor for tests.json")
+  .option("--port <number>", "Port for the local editor server", "0")
+  .action(async (opts, cmd) => {
+    const mod = await import("../commands/editJson.js");
+    await mod.default({ ...opts, ...cmd.optsWithGlobals() });
+  });
+
+program
+  .command("push-tests")
+  .description("Push or update tests in Xray Cloud from tests.json")
+  .option("--testExecKey <key>", "Link tests to an existing Test Execution key instead of creating a new one")
+  .option("--skip-exec", "Push tests without creating or linking a Test Execution")
+  .action(async (opts, cmd) => {
+    const mod = await import("../commands/pushTests.js");
+    await mod.default({ ...opts, ...cmd.optsWithGlobals() });
+  });
+
+program
+  .command("gen-postman")
+  .description("Generate a Postman collection from tests.json (with optional AI enhancement)")
+  .option("--base-url <url>", "Base URL for API requests", "{{baseUrl}}")
+  .option("--ai", "Enable AI-assisted generation for better assertions")
+  .option("--spec <path>", "OpenAPI/Swagger spec file for schema-driven generation")
+  .option("--knowledge <path>", "Custom knowledge folder path")
+  .action(async (opts, cmd) => {
+    const mod = await import("../commands/genPostman.js");
+    await mod.default({ ...opts, ...cmd.optsWithGlobals() });
+  });
+
+program
+  .command("create-execution")
+  .description("Create a new Test Execution issue in JIRA")
+  .requiredOption("--summary <text>", "Test Execution summary/title")
+  .option("--description <text>", "Test Execution description")
+  .option("--issue <key>", "Parent issue key to link the execution to")
+  .action(async (opts, cmd) => {
+    const mod = await import("../commands/createExecution.js");
+    await mod.default({ ...opts, ...cmd.optsWithGlobals() });
+  });
+
+program
+  .command("import-results")
+  .description("Import JUnit/Newman XML results into Xray Cloud")
+  .requiredOption("--file <path>", "Path to the results XML file")
+  .requiredOption("--testExecKey <key>", "Test Execution key to associate results with")
+  .action(async (opts, cmd) => {
+    const mod = await import("../commands/importResults.js");
+    await mod.default({ ...opts, ...cmd.optsWithGlobals() });
+  });
+
+program
+  .command("gen-pipeline")
+  .description("Generate an Azure Pipelines YAML template")
+  .option("--output <path>", "Output file path", "azure-pipelines.yml")
+  .action(async (opts, cmd) => {
+    const mod = await import("../commands/genPipeline.js");
+    await mod.default({ ...opts, ...cmd.optsWithGlobals() });
+  });
+
+program
+  .command("mcp-server")
+  .description("Start Model Context Protocol server for Copilot agent integration")
+  .option("--port <number>", "Server port (default: stdio mode)")
+  .action(async (opts, cmd) => {
+    const mod = await import("../mcp/server.js");
+    await mod.default({ ...opts, ...cmd.optsWithGlobals() });
+  });
+
+// ─── Parse & run ───────────────────────────────────────────────────────────────
+
+program.parseAsync(process.argv).catch((err) => {
+  console.error(`\n❌ ${err.message}\n`);
+  process.exit(1);
+});

package/commands/createExecution.js

@@ -0,0 +1,46 @@
+/**
+ * Command: xray-qe create-execution --summary "..." [--description "..."] [--issue QE-123]
+ *
+ * Creates a standalone Test Execution issue in JIRA.
+ * Optionally links it to a parent issue via --issue.
+ */
+
+import logger, { setVerbose } from "../lib/logger.js";
+import { loadConfig, validateConfig } from "../lib/config.js";
+import { createIssue, linkIssues } from "../lib/xrayClient.js";
+
+export default async function createExecution(opts = {}) {
+  if (opts.verbose) setVerbose(true);
+
+  logger.rocket("@msalaam/xray-qe-toolkit — Create Execution\n");
+
+  const cfg = loadConfig({ envPath: opts.env });
+  validateConfig(cfg);
+
+  logger.pin(`Creating Test Execution: "${opts.summary}"...`);
+
+  const execution = await createIssue(cfg, "Test Execution", {
+    summary: opts.summary,
+    description: opts.description || opts.summary,
+  });
+
+  logger.success(`${execution.key} created`);
+  logger.link(`View: ${cfg.jiraUrl}/browse/${execution.key}`);
+
+  // Optionally link to parent issue
+  if (opts.issue) {
+    logger.blank();
+    logger.link(`Linking to ${opts.issue}...`);
+    try {
+      await linkIssues(cfg, execution.key, opts.issue);
+      logger.step(`Linked to ${opts.issue}`);
+    } catch (err) {
+      logger.warn(`Could not link: ${err.message}`);
+    }
+  }
+
+  logger.blank();
+  console.log(`Test Execution Key: ${execution.key}`);
+  console.log(`Test Execution ID:  ${execution.id}`);
+  logger.blank();
+}

package/commands/editJson.js

@@ -0,0 +1,165 @@
+/**
+ * Command: xray-qe edit-json [--port <number>]
+ *
+ * QE Review Gate — launches a local Express server with a browser-based
+ * JSON editor that lets QEs:
+ *   • View, add, edit, delete tests
+ *   • Tag test types (regression, edge, critical, etc.)
+ *   • Toggle skip/push per test
+ *   • Validate against tests.schema.json in real-time
+ *   • Save changes back to tests.json
+ *
+ * The command blocks until the QE clicks "Save & Exit" or closes the browser.
+ * Nothing is pushed to Xray until the QE explicitly runs push-tests.
+ */
+
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { createServer } from "node:http";
+import express from "express";
+import open from "open";
+import logger, { setVerbose } from "../lib/logger.js";
+import { loadConfig } from "../lib/config.js";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const UI_DIR = path.join(__dirname, "..", "ui", "editor");
+const SCHEMA_PATH = path.join(__dirname, "..", "schema", "tests.schema.json");
+
+export default async function editJson(opts = {}) {
+  if (opts.verbose) setVerbose(true);
+
+  logger.rocket("@msalaam/xray-qe-toolkit — QE Review Gate\n");
+
+  const cfg = loadConfig({ envPath: opts.env });
+  const testsPath = cfg.testsPath;
+
+  // If tests.json doesn't exist, create from template
+  if (!fs.existsSync(testsPath)) {
+    const templatePath = path.join(__dirname, "..", "templates", "tests.json");
+    fs.copyFileSync(templatePath, testsPath);
+    logger.info("Created tests.json from template");
+  }
+
+  // Create Express app
+  const app = express();
+  app.use(express.json({ limit: "10mb" }));
+
+  // Serve static UI files
+  app.use(express.static(UI_DIR));
+
+  // ─── API Routes ────────────────────────────────────────────────────────────
+
+  // GET /api/tests — read tests.json from disk
+  app.get("/api/tests", (req, res) => {
+    try {
+      const content = JSON.parse(fs.readFileSync(testsPath, "utf8"));
+      res.json(content);
+    } catch (err) {
+      res.status(500).json({ error: `Failed to read tests.json: ${err.message}` });
+    }
+  });
+
+  // PUT /api/tests — validate and write tests.json
+  app.put("/api/tests", (req, res) => {
+    try {
+      const data = req.body;
+
+      // Basic structural validation
+      if (!data || !Array.isArray(data.tests)) {
+        return res.status(400).json({ error: "Invalid structure: must have a tests array" });
+      }
+
+      // Check for duplicate test_ids
+      const ids = data.tests.map((t) => t.test_id);
+      const dupes = ids.filter((id, i) => ids.indexOf(id) !== i);
+      if (dupes.length > 0) {
+        return res.status(400).json({ error: `Duplicate test_id(s): ${[...new Set(dupes)].join(", ")}` });
+      }
+
+      fs.writeFileSync(testsPath, JSON.stringify(data, null, 2));
+      logger.save(`tests.json saved (${data.tests.length} tests)`);
+      res.json({ success: true, count: data.tests.length });
+    } catch (err) {
+      res.status(500).json({ error: `Failed to save: ${err.message}` });
+    }
+  });
+
+  // GET /api/schema — return the JSON schema for client-side validation
+  app.get("/api/schema", (req, res) => {
+    try {
+      const schema = JSON.parse(fs.readFileSync(SCHEMA_PATH, "utf8"));
+      res.json(schema);
+    } catch (err) {
+      res.status(500).json({ error: `Failed to read schema: ${err.message}` });
+    }
+  });
+
+  // GET /api/mapping — return current xray-mapping.json
+  app.get("/api/mapping", (req, res) => {
+    try {
+      if (fs.existsSync(cfg.mappingPath)) {
+        const mapping = JSON.parse(fs.readFileSync(cfg.mappingPath, "utf8"));
+        res.json(mapping);
+      } else {
+        res.json({});
+      }
+    } catch {
+      res.json({});
+    }
+  });
+
+  // POST /api/shutdown — graceful server shutdown
+  app.post("/api/shutdown", (req, res) => {
+    res.json({ success: true });
+    logger.blank();
+    logger.success("QE review gate complete — editor closed");
+    logger.info("Run 'npx xqt push-tests' to push changes to Xray\n");
+    // Give the response time to flush, then exit
+    setTimeout(() => {
+      server.close();
+      process.exit(0);
+    }, 500);
+  });
+
+  // ─── Start server ──────────────────────────────────────────────────────────
+
+  const port = parseInt(opts.port) || 0; // 0 = random available port
+  const server = createServer(app);
+
+  await new Promise((resolve, reject) => {
+    server.listen(port, "127.0.0.1", () => {
+      const addr = server.address();
+      const url = `http://127.0.0.1:${addr.port}`;
+
+      logger.success(`Editor running at ${url}`);
+      logger.info(`Editing: ${testsPath}`);
+      logger.blank();
+      console.log("   Open the URL above in your browser to review tests.");
+      console.log("   Click 'Save & Exit' when done. The server will shut down automatically.");
+      console.log("   Press Ctrl+C to cancel without saving.\n");
+
+      // Auto-open browser
+      open(url).catch(() => {
+        // Ignore errors if browser can't be opened (e.g., headless environment)
+        logger.warn("Could not auto-open browser. Open the URL manually.");
+      });
+
+      resolve();
+    });
+
+    server.on("error", reject);
+  });
+
+  // Keep process alive until shutdown
+  await new Promise((resolve) => {
+    server.on("close", resolve);
+    process.on("SIGINT", () => {
+      logger.blank();
+      logger.warn("Editor cancelled (Ctrl+C) — changes may not be saved");
+      server.close();
+      resolve();
+    });
+  });
+}

package/commands/genPipeline.js

@@ -0,0 +1,42 @@
+/**
+ * Command: xray-qe gen-pipeline [--output <path>]
+ *
+ * Copies the Azure Pipelines YAML template into the consuming project.
+ * The template runs Newman and imports results — no QE logic in CI.
+ */
+
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import logger, { setVerbose } from "../lib/logger.js";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+export default async function genPipeline(opts = {}) {
+  if (opts.verbose) setVerbose(true);
+
+  logger.rocket("@msalaam/xray-qe-toolkit — Generate Pipeline\n");
+
+  const templatePath = path.join(__dirname, "..", "templates", "azure-pipelines.yml");
+  const outputPath = path.resolve(opts.output || "azure-pipelines.yml");
+
+  if (fs.existsSync(outputPath)) {
+    logger.warn(`${path.basename(outputPath)} already exists — overwriting`);
+  }
+
+  fs.copyFileSync(templatePath, outputPath);
+
+  logger.success(`Pipeline template saved to ${path.basename(outputPath)}`);
+  logger.blank();
+
+  console.log("📖 Next steps:");
+  console.log("   1. Set pipeline variables in Azure DevOps:");
+  console.log("      XRAY_ID, XRAY_SECRET, JIRA_PROJECT_KEY, JIRA_URL,");
+  console.log("      JIRA_API_TOKEN, JIRA_EMAIL, TEST_EXEC_KEY");
+  console.log("   2. Commit the generated file to your repo");
+  console.log("   3. Create a pipeline in Azure DevOps pointing to this YAML");
+  console.log("");
+  console.log("⚠️  Remember: edit-json and QE review gates are NOT part of CI.");
+  console.log("   Run those steps locally before committing.\n");
+}

package/commands/genPostman.js

@@ -0,0 +1,70 @@
+/**
+ * Command: xray-qe gen-postman [--base-url <url>] [--ai] [--spec <path>] [--knowledge <path>]
+ *
+ * Generates a Postman Collection v2.1 JSON file from tests.json.
+ * Optionally uses xray-mapping.json to embed JIRA keys for better traceability.
+ * With --ai flag, enables AI-assisted generation (requires connected provider).
+ */
+
+import fs from "node:fs";
+import logger, { setVerbose } from "../lib/logger.js";
+import { loadConfig } from "../lib/config.js";
+import { generate } from "../lib/postmanGenerator.js";
+import { loadMapping } from "../lib/testCaseBuilder.js";
+
+export default async function genPostman(opts = {}) {
+  if (opts.verbose) setVerbose(true);
+
+  logger.rocket("@msalaam/xray-qe-toolkit — Generate Postman Collection\n");
+
+  const cfg = loadConfig({ envPath: opts.env });
+
+  if (!fs.existsSync(cfg.testsPath)) {
+    logger.error(`tests.json not found at ${cfg.testsPath}`);
+    logger.info("Run 'npx xray-qe init' to create a starter tests.json");
+    process.exit(1);
+  }
+
+  const testsConfig = JSON.parse(fs.readFileSync(cfg.testsPath, "utf8"));
+
+  // Load mapping to embed JIRA keys when available
+  const mapping = loadMapping(cfg.mappingPath);
+
+  // Filter out skipped tests
+  const filteredConfig = {
+    ...testsConfig,
+    tests: (testsConfig.tests || []).filter((t) => !t.skip),
+  };
+
+  // AI flag handling
+  if (opts.ai) {
+    logger.info("🤖 AI-assisted generation enabled");
+    logger.warn("AI provider not yet connected — using schema-driven generation as fallback");
+    logger.blank();
+  }
+
+  // Knowledge path override
+  const knowledgePath = opts.knowledge || cfg.knowledgePath;
+  if (opts.knowledge) {
+    logger.info(`Using custom knowledge path: ${knowledgePath}`);
+  }
+
+  // Spec file handling (schema-driven generation without AI)
+  if (opts.spec && fs.existsSync(opts.spec)) {
+    logger.info(`Using OpenAPI spec: ${opts.spec}`);
+    logger.info("📝 Schema-driven endpoint inference enabled");
+    // TODO: Parse OpenAPI spec and enhance endpoint/method/body inference
+    logger.blank();
+  }
+
+  generate(filteredConfig, cfg.collectionPath, {
+    baseUrl: opts.baseUrl || "{{baseUrl}}",
+    mapping: mapping,
+  });
+
+  logger.blank();
+  logger.success(`Collection saved to ${cfg.collectionPath}`);
+  logger.info("Import into Postman or run with Newman:");
+  console.log(`   npx newman run ${cfg.collectionPath}`);
+  logger.blank();
+}

package/commands/genTests.js

@@ -0,0 +1,138 @@
+/**
+ * Command: xray-qe gen-tests [--ai] [--spec <path>] [--knowledge <path>] [--ticket <key>] [--prompt <text>]
+ *
+ * Generate test cases from knowledge/ folder documentation and specifications.
+ * Uses AI to analyze specs, requirements, and business logic to create structured test definitions.
+ *
+ * Without --ai: Provides guidance on manual test creation.
+ * With --ai: Uses connected AI provider to generate tests from knowledge sources.
+ */
+
+import fs from "node:fs";
+import path from "node:path";
+import logger, { setVerbose } from "../lib/logger.js";
+import { loadConfig } from "../lib/config.js";
+
+export default async function genTests(opts = {}) {
+  if (opts.verbose) setVerbose(true);
+
+  logger.rocket("@msalaam/xray-qe-toolkit — Generate Test Cases\n");
+
+  const cfg = loadConfig({ envPath: opts.env });
+  const knowledgePath = opts.knowledge || cfg.knowledgePath;
+
+  // Check if knowledge folder exists
+  if (!fs.existsSync(knowledgePath)) {
+    logger.error(`Knowledge folder not found at ${knowledgePath}`);
+    logger.info("Run 'npx xray-qe init' to create the knowledge/ folder structure");
+    process.exit(1);
+  }
+
+  // Validate --ai flag requirement
+  if (!opts.ai) {
+    logger.error("AI-assisted generation is not enabled");
+    logger.info("Use the --ai flag to enable AI-powered test generation");
+    logger.blank();
+    console.log("📖 Manual test creation workflow:");
+    console.log("   1. Review documentation in knowledge/ folder");
+    console.log("   2. Create test cases manually: npx xray-qe edit-json");
+    console.log("   3. Or enable AI generation: npx xray-qe gen-tests --ai");
+    logger.blank();
+    process.exit(1);
+  }
+
+  logger.info("🤖 AI-assisted test generation enabled");
+  logger.blank();
+
+  // Scan knowledge folder for source documents
+  const sources = scanKnowledgeFolder(knowledgePath);
+
+  // Handle specific source flags
+  if (opts.spec && fs.existsSync(opts.spec)) {
+    logger.info(`📄 OpenAPI spec: ${opts.spec}`);
+    sources.apiSpecs.push(opts.spec);
+  }
+
+  if (opts.ticket) {
+    logger.info(`🎫 JIRA ticket: ${opts.ticket}`);
+    sources.tickets.push(opts.ticket);
+  }
+
+  if (opts.prompt) {
+    logger.info(`💬 Prompt: "${opts.prompt}"`);
+  }
+
+  logger.blank();
+  logger.info("📚 Knowledge sources discovered:");
+  console.log(`   API Specs:     ${sources.apiSpecs.length} file(s)`);
+  console.log(`   Requirements:  ${sources.requirements.length} file(s)`);
+  console.log(`   Tickets:       ${sources.tickets.length} file(s)`);
+  logger.blank();
+
+  if (sources.apiSpecs.length === 0 && sources.requirements.length === 0 && sources.tickets.length === 0) {
+    logger.warn("No knowledge sources found!");
+    logger.info("Add OpenAPI specs, requirements docs, or JIRA exports to knowledge/ folders");
+    logger.info("See knowledge/README.md for supported file types");
+    logger.blank();
+    process.exit(1);
+  }
+
+  // AI provider connection scaffold (not yet implemented)
+  logger.warn("⚠️  AI provider not yet connected");
+  logger.blank();
+  console.log("🔧 To connect an AI provider:");
+  console.log("   1. Implement AI provider integration in mcp/server.js");
+  console.log("   2. Configure provider credentials in .env");
+  console.log("   3. Or use the MCP server: npx xray-qe mcp-server");
+  console.log("   4. Or use VS Code @xray-qe chat participant");
+  logger.blank();
+  console.log("📋 For now, you can:");
+  console.log("   • Review knowledge sources and create tests manually via 'npx xray-qe edit-json'");
+  console.log("   • Use the browser-based editor to build your test suite");
+  console.log("   • Run 'npx xray-qe gen-postman --spec <file>' for schema-driven Postman generation");
+  logger.blank();
+
+  logger.info("Scaffold ready. Connect an AI provider to enable automated test generation.");
+  logger.blank();
+}
+
+/**
+ * Scan knowledge folder and return categorized file paths
+ */
+function scanKnowledgeFolder(knowledgePath) {
+  const sources = {
+    apiSpecs: [],
+    requirements: [],
+    tickets: [],
+  };
+
+  const apiSpecsDir = path.join(knowledgePath, "api-specs");
+  const requirementsDir = path.join(knowledgePath, "requirements");
+  const ticketsDir = path.join(knowledgePath, "tickets");
+
+  // Scan api-specs/
+  if (fs.existsSync(apiSpecsDir)) {
+    const files = fs.readdirSync(apiSpecsDir);
+    sources.apiSpecs = files
+      .filter((f) => /\.(yaml|yml|json|graphql|gql)$/i.test(f))
+      .map((f) => path.join(apiSpecsDir, f));
+  }
+
+  // Scan requirements/
+  if (fs.existsSync(requirementsDir)) {
+    const files = fs.readdirSync(requirementsDir);
+    sources.requirements = files
+      .filter((f) => /\.(md|txt|docx|pdf)$/i.test(f))
+      .map((f) => path.join(requirementsDir, f));
+  }
+
+  // Scan tickets/
+  if (fs.existsSync(ticketsDir)) {
+    const files = fs.readdirSync(ticketsDir);
+    sources.tickets = files
+      .filter((f) => /\.(json|xml|html|md|txt)$/i.test(f))
+      .map((f) => path.join(ticketsDir, f));
+  }
+
+  return sources;
+}

package/commands/importResults.js

@@ -0,0 +1,50 @@
+/**
+ * Command: xray-qe import-results --file <path> --testExecKey <key>
+ *
+ * Imports JUnit/Newman XML results into Xray Cloud and associates
+ * them with the specified Test Execution.
+ *
+ * Designed to run in CI — no human interaction required.
+ */
+
+import fs from "node:fs";
+import path from "node:path";
+import logger, { setVerbose } from "../lib/logger.js";
+import { loadConfig, validateConfig } from "../lib/config.js";
+import { authenticate, importResults as importResultsApi } from "../lib/xrayClient.js";
+
+export default async function importResults(opts = {}) {
+  if (opts.verbose) setVerbose(true);
+
+  logger.rocket("@msalaam/xray-qe-toolkit — Import Results\n");
+
+  const cfg = loadConfig({ envPath: opts.env });
+  validateConfig(cfg);
+
+  const filePath = path.resolve(opts.file);
+  if (!fs.existsSync(filePath)) {
+    logger.error(`Results file not found: ${filePath}`);
+    process.exit(1);
+  }
+
+  logger.info(`File: ${path.basename(filePath)}`);
+  logger.info(`Test Execution: ${opts.testExecKey}`);
+  logger.blank();
+
+  // Authenticate
+  const xrayToken = await authenticate(cfg);
+
+  // Read XML file
+  const xmlBuffer = fs.readFileSync(filePath);
+  logger.send(`Importing ${xmlBuffer.length} bytes to Xray...`);
+
+  const result = await importResultsApi(cfg, xrayToken, xmlBuffer, opts.testExecKey);
+
+  logger.success("Results imported successfully");
+
+  if (result?.key) {
+    logger.link(`View: ${cfg.jiraUrl}/browse/${result.key}`);
+  }
+
+  logger.blank();
+}