@automatify-au/cli 0.1.9 → 0.1.11

package/dist/automatify.cjs

@@ -2894,8 +2894,8 @@ var require_utils = __commonJS({
       var result = transform[inputType][outputType](input);
       return result;
     };
-    exports2.resolve = function(path12) {
-      var parts = path12.split("/");
+    exports2.resolve = function(path14) {
+      var parts = path14.split("/");
       var result = [];
       for (var index = 0; index < parts.length; index++) {
         var part = parts[index];
@@ -8748,18 +8748,18 @@ var require_object = __commonJS({
       var object = new ZipObject(name, zipObjectContent, o);
       this.files[name] = object;
     };
-    var parentFolder = function(path12) {
-      if (path12.slice(-1) === "/") {
-        path12 = path12.substring(0, path12.length - 1);
+    var parentFolder = function(path14) {
+      if (path14.slice(-1) === "/") {
+        path14 = path14.substring(0, path14.length - 1);
       }
-      var lastSlash = path12.lastIndexOf("/");
-      return lastSlash > 0 ? path12.substring(0, lastSlash) : "";
+      var lastSlash = path14.lastIndexOf("/");
+      return lastSlash > 0 ? path14.substring(0, lastSlash) : "";
     };
-    var forceTrailingSlash = function(path12) {
-      if (path12.slice(-1) !== "/") {
-        path12 += "/";
+    var forceTrailingSlash = function(path14) {
+      if (path14.slice(-1) !== "/") {
+        path14 += "/";
       }
-      return path12;
+      return path14;
     };
     var folderAdd = function(name, createFolders) {
       createFolders = typeof createFolders !== "undefined" ? createFolders : defaults.createFolders;
@@ -9725,9 +9725,9 @@ var require_load = __commonJS({
 var require_lib3 = __commonJS({
   "../../node_modules/.pnpm/jszip@3.10.1/node_modules/jszip/lib/index.js"(exports2, module2) {
     "use strict";
-    function JSZip2() {
-      if (!(this instanceof JSZip2)) {
-        return new JSZip2();
+    function JSZip3() {
+      if (!(this instanceof JSZip3)) {
+        return new JSZip3();
       }
       if (arguments.length) {
         throw new Error("The constructor with parameters has been removed in JSZip 3.0, please check the upgrade guide.");
@@ -9736,7 +9736,7 @@ var require_lib3 = __commonJS({
       this.comment = null;
       this.root = "";
       this.clone = function() {
-        var newObj = new JSZip2();
+        var newObj = new JSZip3();
         for (var i in this) {
           if (typeof this[i] !== "function") {
             newObj[i] = this[i];
@@ -9745,16 +9745,16 @@ var require_lib3 = __commonJS({
         return newObj;
       };
     }
-    JSZip2.prototype = require_object();
-    JSZip2.prototype.loadAsync = require_load();
-    JSZip2.support = require_support();
-    JSZip2.defaults = require_defaults();
-    JSZip2.version = "3.10.1";
-    JSZip2.loadAsync = function(content, options) {
-      return new JSZip2().loadAsync(content, options);
+    JSZip3.prototype = require_object();
+    JSZip3.prototype.loadAsync = require_load();
+    JSZip3.support = require_support();
+    JSZip3.defaults = require_defaults();
+    JSZip3.version = "3.10.1";
+    JSZip3.loadAsync = function(content, options) {
+      return new JSZip3().loadAsync(content, options);
     };
-    JSZip2.external = require_external();
-    module2.exports = JSZip2;
+    JSZip3.external = require_external();
+    module2.exports = JSZip3;
   }
 });
 
@@ -12447,7 +12447,8 @@ function createAutoHandler(deps = {}) {
 }
 
 // src/allure.ts
-var import_node_path8 = __toESM(require("node:path"), 1);
+var import_node_path10 = __toESM(require("node:path"), 1);
+var import_node_fs9 = require("node:fs");
 
 // ../../packages/jira-client/src/adf.ts
 function paragraph(text = "") {
@@ -12533,6 +12534,62 @@ async function uploadIssueAttachment(params) {
     size: typeof first?.size === "number" ? first.size : fileStat.size
   };
 }
+function parseIssueAttachment(value) {
+  if (!value || typeof value !== "object") {
+    return void 0;
+  }
+  const item = value;
+  if (typeof item.id !== "string" || typeof item.filename !== "string") {
+    return void 0;
+  }
+  return {
+    id: item.id,
+    filename: item.filename,
+    self: typeof item.self === "string" ? item.self : void 0,
+    content: typeof item.content === "string" ? item.content : void 0,
+    size: typeof item.size === "number" ? item.size : void 0,
+    created: typeof item.created === "string" ? item.created : void 0
+  };
+}
+async function listIssueAttachments(params) {
+  const site = normalizeSite(params.site);
+  const response = await fetch(`${site}/rest/api/3/issue/${encodeURIComponent(params.issueKey)}?fields=attachment`, {
+    headers: {
+      authorization: authHeader(params.email, params.apiToken),
+      accept: "application/json"
+    }
+  });
+  if (!response.ok) {
+    throw new Error(`Jira attachment listing failed: ${await readError(response)}`);
+  }
+  const parsed = await response.json();
+  const attachments = Array.isArray(parsed.fields?.attachment) ? parsed.fields.attachment : [];
+  return attachments.map(parseIssueAttachment).filter((item) => Boolean(item));
+}
+async function downloadIssueAttachment(params) {
+  const url = params.attachment.content;
+  if (!url) {
+    throw new Error(`Jira attachment ${params.attachment.id} does not include a downloadable URL.`);
+  }
+  const response = await fetch(url, {
+    headers: {
+      authorization: authHeader(params.email, params.apiToken)
+    }
+  });
+  if (!response.ok) {
+    throw new Error(`Jira attachment download failed: ${await readError(response)}`);
+  }
+  const bytes = new Uint8Array(await response.arrayBuffer());
+  (0, import_node_fs5.writeFileSync)(params.outputPath, bytes);
+  return {
+    filename: params.attachment.filename,
+    id: params.attachment.id,
+    outputPath: params.outputPath,
+    self: params.attachment.self,
+    content: params.attachment.content,
+    size: bytes.byteLength
+  };
+}
 async function addIssueComment(params) {
   const site = normalizeSite(params.site);
   const response = await fetch(`${site}/rest/api/3/issue/${encodeURIComponent(params.issueKey)}/comment`, {
@@ -12624,6 +12681,438 @@ async function parseAllureReportZip(zipPath) {
   };
 }
 
+// ../../packages/allure-core/src/extractAllureZip.ts
+var import_node_fs7 = require("node:fs");
+var import_node_path8 = __toESM(require("node:path"), 1);
+var import_jszip2 = __toESM(require_lib3(), 1);
+var INDEX_HTML = "index.html";
+var MISSING_INDEX_ERROR = "Could not find index.html. Please provide a generated Allure HTML report ZIP, not raw allure-results.";
+function findIndexEntry(paths) {
+  return paths.find((entryPath) => entryPath === INDEX_HTML) ?? paths.find((entryPath) => entryPath === `allure-report/${INDEX_HTML}`) ?? paths.find((entryPath) => entryPath.endsWith(`/${INDEX_HTML}`));
+}
+function ensureInsideRoot(rootDir, candidate) {
+  const resolved = import_node_path8.default.resolve(rootDir, candidate);
+  const rootWithSep = rootDir.endsWith(import_node_path8.default.sep) ? rootDir : rootDir + import_node_path8.default.sep;
+  if (resolved !== rootDir && !resolved.startsWith(rootWithSep)) {
+    throw new Error(`Refusing to write zip entry outside extract directory: ${candidate}`);
+  }
+  return resolved;
+}
+async function extractAllureReportZip(zipPath, extractDir) {
+  if (!(0, import_node_fs7.existsSync)(zipPath)) {
+    throw new Error(`Allure report ZIP not found: ${zipPath}`);
+  }
+  if (import_node_path8.default.extname(zipPath).toLowerCase() !== ".zip") {
+    throw new Error("Allure report must be a .zip file.");
+  }
+  const zip = await import_jszip2.default.loadAsync((0, import_node_fs7.readFileSync)(zipPath));
+  const entries = Object.entries(zip.files);
+  const filePaths = entries.filter(([, file]) => !file.dir).map(([entryPath]) => entryPath);
+  const indexEntry = findIndexEntry(filePaths);
+  if (!indexEntry) {
+    throw new Error(MISSING_INDEX_ERROR);
+  }
+  const resolvedExtract = import_node_path8.default.resolve(extractDir);
+  (0, import_node_fs7.mkdirSync)(resolvedExtract, { recursive: true });
+  for (const [entryPath, file] of entries) {
+    const target = ensureInsideRoot(resolvedExtract, entryPath);
+    if (file.dir) {
+      (0, import_node_fs7.mkdirSync)(target, { recursive: true });
+      continue;
+    }
+    (0, import_node_fs7.mkdirSync)(import_node_path8.default.dirname(target), { recursive: true });
+    const buffer = await file.async("nodebuffer");
+    (0, import_node_fs7.writeFileSync)(target, buffer);
+  }
+  const indexAbsolute = import_node_path8.default.join(resolvedExtract, indexEntry);
+  const rootDir = import_node_path8.default.dirname(indexAbsolute);
+  return {
+    zipPath,
+    extractDir: resolvedExtract,
+    rootDir,
+    indexPath: indexAbsolute
+  };
+}
+
+// src/allureOpen.ts
+var import_node_fs8 = require("node:fs");
+var import_promises = require("node:fs/promises");
+var import_node_http = __toESM(require("node:http"), 1);
+var import_node_os = require("node:os");
+var import_node_path9 = __toESM(require("node:path"), 1);
+var import_node_child_process2 = require("node:child_process");
+function parseArgs2(args) {
+  const positionals = [];
+  const flags = {};
+  const boolFlags = /* @__PURE__ */ new Set();
+  const unknownFlags = [];
+  const valuedFlags = /* @__PURE__ */ new Set(["--port", "--host", "--extract-to"]);
+  const supportedBoolFlags = /* @__PURE__ */ new Set(["--keep", "--no-open", "--json", "--dry-run", "--verbose"]);
+  for (let i = 0; i < args.length; i += 1) {
+    const token = args[i];
+    if (!token.startsWith("--")) {
+      positionals.push(token);
+      continue;
+    }
+    if (supportedBoolFlags.has(token)) {
+      boolFlags.add(token);
+      continue;
+    }
+    if (!valuedFlags.has(token)) {
+      unknownFlags.push(token);
+      continue;
+    }
+    const value = args[i + 1];
+    if (!value || value.startsWith("--")) {
+      unknownFlags.push(token);
+      continue;
+    }
+    flags[token] = value;
+    i += 1;
+  }
+  return { positionals, flags, boolFlags, unknownFlags };
+}
+function parsePort(raw) {
+  if (raw === void 0) {
+    return { value: 0 };
+  }
+  const parsed = Number(raw);
+  if (!Number.isInteger(parsed) || parsed < 0 || parsed > 65535) {
+    return { value: 0, error: `Invalid --port value: ${raw}. Must be an integer between 0 and 65535.` };
+  }
+  return { value: parsed };
+}
+function normalizeError(error) {
+  return error instanceof Error ? error.message : "Unknown Allure open error.";
+}
+var MIME_TYPES = {
+  ".html": "text/html; charset=utf-8",
+  ".htm": "text/html; charset=utf-8",
+  ".js": "application/javascript; charset=utf-8",
+  ".mjs": "application/javascript; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".ico": "image/x-icon",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2",
+  ".ttf": "font/ttf",
+  ".otf": "font/otf",
+  ".eot": "application/vnd.ms-fontobject",
+  ".map": "application/json; charset=utf-8",
+  ".txt": "text/plain; charset=utf-8"
+};
+function contentTypeFor(filePath) {
+  return MIME_TYPES[import_node_path9.default.extname(filePath).toLowerCase()] ?? "application/octet-stream";
+}
+function resolveRequestedPath(rootDir, urlPath) {
+  let decoded;
+  try {
+    decoded = decodeURIComponent(urlPath.split("?")[0].split("#")[0]);
+  } catch {
+    return void 0;
+  }
+  const normalized = import_node_path9.default.normalize(decoded);
+  const trimmed = normalized.replace(/^[/\\]+/, "");
+  const candidate = import_node_path9.default.resolve(rootDir, trimmed);
+  const rootWithSep = rootDir.endsWith(import_node_path9.default.sep) ? rootDir : rootDir + import_node_path9.default.sep;
+  if (candidate !== rootDir && !candidate.startsWith(rootWithSep)) {
+    return void 0;
+  }
+  return candidate;
+}
+function createStaticServerStarter() {
+  return async ({ rootDir, host, port }) => {
+    const server = import_node_http.default.createServer((req, res) => {
+      if (!req.url || req.method !== "GET" && req.method !== "HEAD") {
+        res.statusCode = 405;
+        res.end("Method Not Allowed");
+        return;
+      }
+      const resolved = resolveRequestedPath(rootDir, req.url);
+      if (!resolved) {
+        res.statusCode = 400;
+        res.end("Bad Request");
+        return;
+      }
+      let target = resolved;
+      try {
+        const stat = (0, import_node_fs8.statSync)(target);
+        if (stat.isDirectory()) {
+          target = import_node_path9.default.join(target, "index.html");
+        }
+      } catch {
+        res.statusCode = 404;
+        res.end("Not Found");
+        return;
+      }
+      if (!(0, import_node_fs8.existsSync)(target)) {
+        res.statusCode = 404;
+        res.end("Not Found");
+        return;
+      }
+      res.setHeader("Content-Type", contentTypeFor(target));
+      if (req.method === "HEAD") {
+        res.statusCode = 200;
+        res.end();
+        return;
+      }
+      const stream = (0, import_node_fs8.createReadStream)(target);
+      stream.on("error", () => {
+        res.statusCode = 500;
+        res.end("Internal Server Error");
+      });
+      stream.pipe(res);
+    });
+    await new Promise((resolve, reject) => {
+      const onError = (err) => {
+        server.off("listening", onListening);
+        reject(err);
+      };
+      const onListening = () => {
+        server.off("error", onError);
+        resolve();
+      };
+      server.once("error", onError);
+      server.once("listening", onListening);
+      server.listen(port, host);
+    });
+    const address = server.address();
+    const actualPort = typeof address === "object" && address ? address.port : port;
+    const displayHost = host === "0.0.0.0" ? "127.0.0.1" : host;
+    const url = `http://${displayHost}:${actualPort}/`;
+    return {
+      url,
+      port: actualPort,
+      host,
+      close: () => new Promise((resolve, reject) => {
+        server.close((err) => err ? reject(err) : resolve());
+      })
+    };
+  };
+}
+function createOsBrowserOpener() {
+  return async (url) => {
+    const platform = process.platform;
+    let command;
+    let args;
+    if (platform === "darwin") {
+      command = "open";
+      args = [url];
+    } else if (platform === "win32") {
+      command = "cmd";
+      args = ["/c", "start", "", url];
+    } else {
+      command = "xdg-open";
+      args = [url];
+    }
+    try {
+      const child = (0, import_node_child_process2.spawn)(command, args, { stdio: "ignore", detached: true });
+      child.on("error", () => void 0);
+      child.unref();
+    } catch {
+    }
+  };
+}
+function waitForProcessSignals() {
+  return new Promise((resolve) => {
+    const cleanup = () => {
+      process.off("SIGINT", onSignal);
+      process.off("SIGTERM", onSignal);
+      resolve();
+    };
+    const onSignal = () => {
+      cleanup();
+    };
+    process.once("SIGINT", onSignal);
+    process.once("SIGTERM", onSignal);
+  });
+}
+function buildJsonOutput(params) {
+  const output = {
+    zipPath: params.zipPath,
+    dryRun: params.dryRun,
+    served: params.served,
+    opened: params.opened,
+    keep: params.keep,
+    extractDir: params.extractDir,
+    rootDir: params.rootDir,
+    indexPath: params.indexPath,
+    summary: {
+      total: params.summary.counts.total,
+      passed: params.summary.counts.passed,
+      failed: params.summary.counts.failed,
+      broken: params.summary.counts.broken,
+      skipped: params.summary.counts.skipped,
+      unknown: params.summary.counts.unknown
+    }
+  };
+  if (params.url) {
+    output.url = params.url;
+  }
+  if (params.port !== void 0) {
+    output.port = params.port;
+  }
+  if (params.host !== void 0) {
+    output.host = params.host;
+  }
+  return output;
+}
+function createAllureOpenHandler(deps = {}) {
+  const cwd = deps.cwd ?? process.cwd();
+  const parseZip = deps.parseAllureReportZip ?? parseAllureReportZip;
+  const extractZip = deps.extractAllureReportZip ?? extractAllureReportZip;
+  const createTempDir = deps.createTempDir ?? (() => (0, import_promises.mkdtemp)(import_node_path9.default.join((0, import_node_os.tmpdir)(), "automatify-allure-open-")));
+  const startServer = deps.startServer ?? createStaticServerStarter();
+  const openInBrowser = deps.openInBrowser ?? createOsBrowserOpener();
+  const waitForShutdown = deps.waitForShutdown ?? waitForProcessSignals;
+  const removeDir = deps.removeDir ?? ((dir) => (0, import_promises.rm)(dir, { recursive: true, force: true }));
+  const logger = deps.logger ?? console;
+  return async (request) => {
+    const parsed = parseArgs2(request.args);
+    const useJson = parsed.boolFlags.has("--json");
+    const dryRun = parsed.boolFlags.has("--dry-run");
+    const verbose = parsed.boolFlags.has("--verbose");
+    const keep = parsed.boolFlags.has("--keep");
+    const noOpen = parsed.boolFlags.has("--no-open");
+    const userExtractDir = parsed.flags["--extract-to"];
+    if (parsed.unknownFlags.length > 0) {
+      return {
+        exitCode: ExitCode.UsageError,
+        stderr: [`ERROR: Unknown or invalid flags: ${parsed.unknownFlags.join(", ")}`]
+      };
+    }
+    const [zipPathInput] = parsed.positionals;
+    if (!zipPathInput || parsed.positionals.length > 1) {
+      return {
+        exitCode: ExitCode.UsageError,
+        stderr: ["Usage: automatify testops allure open <zipPath> [options]"]
+      };
+    }
+    const portResult = parsePort(parsed.flags["--port"]);
+    if (portResult.error) {
+      return {
+        exitCode: ExitCode.UsageError,
+        stderr: [`ERROR: ${portResult.error}`]
+      };
+    }
+    const host = parsed.flags["--host"] ?? "127.0.0.1";
+    const zipPath = import_node_path9.default.resolve(cwd, zipPathInput);
+    let summary;
+    try {
+      summary = await parseZip(zipPath);
+    } catch (error) {
+      return {
+        exitCode: ExitCode.ValidationError,
+        stderr: [`ERROR: ${normalizeError(error)}`]
+      };
+    }
+    const extractDirRaw = userExtractDir ? import_node_path9.default.resolve(cwd, userExtractDir) : await createTempDir();
+    if (dryRun) {
+      const indexPath = import_node_path9.default.join(extractDirRaw, "index.html");
+      if (useJson) {
+        return {
+          exitCode: ExitCode.Success,
+          stdout: toJsonLine(buildJsonOutput({
+            zipPath,
+            dryRun: true,
+            served: false,
+            opened: false,
+            keep,
+            extractDir: extractDirRaw,
+            rootDir: extractDirRaw,
+            indexPath,
+            summary
+          }))
+        };
+      }
+      return {
+        exitCode: ExitCode.Success,
+        stdout: [
+          `Allure report ZIP: ${zipPath}`,
+          `Total: ${summary.counts.total} (passed ${summary.counts.passed}, failed ${summary.counts.failed}, broken ${summary.counts.broken}, skipped ${summary.counts.skipped}, unknown ${summary.counts.unknown})`,
+          `Dry run: would extract to ${extractDirRaw} and serve on http://${host}:${portResult.value === 0 ? "<auto>" : portResult.value}/`
+        ]
+      };
+    }
+    let extractResult;
+    try {
+      extractResult = await extractZip(zipPath, extractDirRaw);
+    } catch (error) {
+      if (!userExtractDir) {
+        await removeDir(extractDirRaw).catch(() => void 0);
+      }
+      return {
+        exitCode: ExitCode.ValidationError,
+        stderr: [`ERROR: ${normalizeError(error)}`]
+      };
+    }
+    let serverHandle;
+    try {
+      serverHandle = await startServer({
+        rootDir: extractResult.rootDir,
+        host,
+        port: portResult.value
+      });
+    } catch (error) {
+      if (!keep && !userExtractDir) {
+        await removeDir(extractResult.extractDir).catch(() => void 0);
+      }
+      return {
+        exitCode: ExitCode.TransportError,
+        stderr: [`ERROR: Could not start static server: ${normalizeError(error)}`]
+      };
+    }
+    let opened = false;
+    if (!noOpen) {
+      try {
+        await openInBrowser(serverHandle.url);
+        opened = true;
+      } catch {
+        opened = false;
+      }
+    }
+    if (useJson) {
+      logger.log(JSON.stringify(buildJsonOutput({
+        zipPath,
+        dryRun: false,
+        served: true,
+        opened,
+        keep,
+        extractDir: extractResult.extractDir,
+        rootDir: extractResult.rootDir,
+        indexPath: extractResult.indexPath,
+        url: serverHandle.url,
+        port: serverHandle.port,
+        host: serverHandle.host,
+        summary
+      })));
+    } else {
+      logger.log(`Allure report extracted to ${extractResult.extractDir}.`);
+      if (verbose) {
+        logger.log(`Index: ${extractResult.indexPath}`);
+      }
+      logger.log(`Serving at ${serverHandle.url}`);
+      logger.log(opened ? "Opened in your default browser." : "Browser open skipped.");
+      logger.log("Press Ctrl+C to stop the server.");
+    }
+    await waitForShutdown();
+    try {
+      await serverHandle.close();
+    } catch {
+    }
+    if (!keep && !userExtractDir) {
+      await removeDir(extractResult.extractDir).catch(() => void 0);
+    }
+    return { exitCode: ExitCode.Success };
+  };
+}
+
 // src/allure.ts
 var CONFIG_FLAGS2 = /* @__PURE__ */ new Set([
   "--config",
@@ -12634,7 +13123,7 @@ var CONFIG_FLAGS2 = /* @__PURE__ */ new Set([
   "--jira-email",
   "--jira-api-token"
 ]);
-function parseArgs2(args) {
+function parseArgs3(args) {
   const positionals = [];
   const flags = {};
   const boolFlags = /* @__PURE__ */ new Set();
@@ -12643,9 +13132,12 @@ function parseArgs2(args) {
     "--site",
     "--email",
     "--api-token",
+    "--attachment-id",
+    "--filename",
+    "--output-dir",
     ...CONFIG_FLAGS2
   ]);
-  const supportedBoolFlags = /* @__PURE__ */ new Set(["--no-comment", "--comment", "--json", "--dry-run", "--verbose"]);
+  const supportedBoolFlags = /* @__PURE__ */ new Set(["--no-comment", "--comment", "--json", "--dry-run", "--verbose", "--force"]);
   for (let i = 0; i < args.length; i += 1) {
     const token = args[i];
     if (!token.startsWith("--")) {
@@ -12682,12 +13174,29 @@ function pickConfigArgs2(parsed) {
 function normalizeSite2(value) {
   return value.trim().replace(/\/+$/, "");
 }
-function normalizeError(error) {
+function normalizeError2(error) {
   return error instanceof Error ? error.message : "Unknown Allure upload error.";
 }
 function hasCredential(value) {
   return value.trim().length > 0;
 }
+function resolveJiraConfig(parsed, env, cwd) {
+  const config = resolveCliConfig(pickConfigArgs2(parsed), env, cwd);
+  const site = normalizeSite2(parsed.flags["--site"] ?? env.JIRA_SITE ?? config.values.baseUrl);
+  const email = (parsed.flags["--email"] ?? config.values.jiraEmail).trim();
+  const apiToken = (parsed.flags["--api-token"] ?? config.values.jiraApiToken).trim();
+  const errors = [];
+  if (!hasCredential(site)) {
+    errors.push("Missing Jira site. Pass --site, set JIRA_SITE/JIRA_BASE_URL, or configure baseUrl.");
+  }
+  if (!hasCredential(email)) {
+    errors.push("Missing Jira email. Pass --email or set JIRA_EMAIL.");
+  }
+  if (!hasCredential(apiToken)) {
+    errors.push("Missing Jira API token. Pass --api-token or set JIRA_API_TOKEN.");
+  }
+  return errors.length > 0 ? { errors } : { config: { site, email, apiToken }, errors: [] };
+}
 function formatHumanSummary(summary) {
   const counts = summary.counts;
   return [
@@ -12712,7 +13221,65 @@ function formatHumanAttachment(attachment) {
   }
   return lines;
 }
-function buildJsonOutput(params) {
+function isAllureReportZip(attachment) {
+  const filename = attachment.filename.toLowerCase();
+  return filename.endsWith(".zip") && filename.includes("allure-report");
+}
+function isZip(attachment) {
+  return attachment.filename.toLowerCase().endsWith(".zip");
+}
+function sortNewestFirst(attachments) {
+  return [...attachments].sort((left, right) => {
+    const leftTime = left.created ? Date.parse(left.created) : 0;
+    const rightTime = right.created ? Date.parse(right.created) : 0;
+    if (rightTime !== leftTime) {
+      return rightTime - leftTime;
+    }
+    return right.id.localeCompare(left.id);
+  });
+}
+function selectAllureAttachment(params) {
+  const { attachments, attachmentId, filename } = params;
+  if (attachmentId) {
+    const match = attachments.find((attachment) => attachment.id === attachmentId);
+    if (!match) {
+      throw new Error(`Could not find Jira attachment with id ${attachmentId}.`);
+    }
+    return match;
+  }
+  if (filename) {
+    const matches = sortNewestFirst(attachments.filter((attachment) => attachment.filename === filename));
+    if (matches.length === 0) {
+      throw new Error(`Could not find Jira attachment named ${filename}.`);
+    }
+    return matches[0];
+  }
+  const allureMatches = sortNewestFirst(attachments.filter(isAllureReportZip));
+  if (allureMatches.length > 0) {
+    return allureMatches[0];
+  }
+  const zipMatches = sortNewestFirst(attachments.filter(isZip));
+  if (zipMatches.length > 0) {
+    return zipMatches[0];
+  }
+  throw new Error("Could not find an Allure report ZIP attachment on this Jira issue.");
+}
+function buildDownloadJsonOutput(params) {
+  return {
+    issueKey: params.issueKey,
+    dryRun: params.dryRun,
+    downloaded: params.downloaded,
+    attachment: {
+      filename: params.attachment.filename,
+      id: params.attachment.id,
+      ...params.attachment.self ? { self: params.attachment.self } : {},
+      ...params.attachment.content ? { content: params.attachment.content } : {},
+      ...typeof params.attachment.size === "number" ? { size: params.attachment.size } : {}
+    },
+    outputPath: params.outputPath
+  };
+}
+function buildJsonOutput2(params) {
   const attachment = {
     filename: params.attachment.filename
   };
@@ -12750,25 +13317,126 @@ function createAllureHandler(deps = {}) {
   const parseZip = deps.parseAllureReportZip ?? parseAllureReportZip;
   const uploadAttachment = deps.uploadIssueAttachment ?? uploadIssueAttachment;
   const createComment = deps.addIssueComment ?? addIssueComment;
-  return async (request) => {
+  const listAttachments = deps.listIssueAttachments ?? listIssueAttachments;
+  const downloadAttachment = deps.downloadIssueAttachment ?? downloadIssueAttachment;
+  const openHandler = createAllureOpenHandler({ cwd });
+  return async (request, context) => {
     const [subcommand, ...subArgs] = request.args;
-    if (subcommand !== "upload") {
+    if (subcommand === "open") {
+      return openHandler({ ...request, args: subArgs }, context);
+    }
+    if (subcommand !== "upload" && subcommand !== "download") {
       return {
         exitCode: ExitCode.UsageError,
-        stderr: ["Usage: automatify testops allure upload <issueKey> <zipPath> [options]"]
+        stderr: [
+          "Usage:",
+          "  automatify testops allure upload <issueKey> <zipPath> [options]",
+          "  automatify testops allure download <issueKey> [options]",
+          "  automatify testops allure open <zipPath> [options]"
+        ]
       };
     }
-    const parsed = parseArgs2(subArgs);
+    const parsed = parseArgs3(subArgs);
     const useJson = parsed.boolFlags.has("--json");
     const dryRun = parsed.boolFlags.has("--dry-run");
     const verbose = parsed.boolFlags.has("--verbose");
     const addComment = !parsed.boolFlags.has("--no-comment");
+    const force = parsed.boolFlags.has("--force");
     if (parsed.unknownFlags.length > 0) {
       return {
         exitCode: ExitCode.UsageError,
         stderr: [`ERROR: Unknown or invalid flags: ${parsed.unknownFlags.join(", ")}`]
       };
     }
+    if (subcommand === "download") {
+      const [issueKey2] = parsed.positionals;
+      if (!issueKey2 || parsed.positionals.length > 1) {
+        return {
+          exitCode: ExitCode.UsageError,
+          stderr: ["Usage: automatify testops allure download <issueKey> [options]"]
+        };
+      }
+      const resolved2 = resolveJiraConfig(parsed, env, cwd);
+      if (!resolved2.config) {
+        return {
+          exitCode: ExitCode.ValidationError,
+          stderr: resolved2.errors.map((line) => `ERROR: ${line}`)
+        };
+      }
+      try {
+        const attachments = await listAttachments({
+          ...resolved2.config,
+          issueKey: issueKey2
+        });
+        const selected = selectAllureAttachment({
+          attachments,
+          attachmentId: parsed.flags["--attachment-id"],
+          filename: parsed.flags["--filename"]
+        });
+        const outputDir = import_node_path10.default.resolve(cwd, parsed.flags["--output-dir"] ?? ".");
+        const outputPath = import_node_path10.default.join(outputDir, selected.filename);
+        if (dryRun) {
+          if (useJson) {
+            return {
+              exitCode: ExitCode.Success,
+              stdout: toJsonLine(buildDownloadJsonOutput({
+                issueKey: issueKey2,
+                dryRun: true,
+                downloaded: false,
+                attachment: selected,
+                outputPath
+              }))
+            };
+          }
+          return {
+            exitCode: ExitCode.Success,
+            stdout: [
+              `Selected Jira attachment ${selected.filename} (${selected.id}) from issue ${issueKey2}.`,
+              ...verbose && selected.created ? [`Created: ${selected.created}`] : [],
+              `Dry run: would download to ${outputPath}.`
+            ]
+          };
+        }
+        (0, import_node_fs9.mkdirSync)(outputDir, { recursive: true });
+        if ((0, import_node_fs9.existsSync)(outputPath) && !force) {
+          return {
+            exitCode: ExitCode.ValidationError,
+            stderr: [`ERROR: Output file already exists: ${outputPath}. Pass --force to overwrite.`]
+          };
+        }
+        const downloaded = await downloadAttachment({
+          ...resolved2.config,
+          attachment: selected,
+          outputPath
+        });
+        if (useJson) {
+          return {
+            exitCode: ExitCode.Success,
+            stdout: toJsonLine(buildDownloadJsonOutput({
+              issueKey: issueKey2,
+              dryRun: false,
+              downloaded: true,
+              attachment: downloaded,
+              outputPath
+            }))
+          };
+        }
+        return {
+          exitCode: ExitCode.Success,
+          stdout: [
+            `Downloaded Allure report attachment from Jira issue ${issueKey2}.`,
+            `Attachment: ${downloaded.filename}`,
+            `Attachment ID: ${downloaded.id}`,
+            `Saved to: ${downloaded.outputPath}`
+          ]
+        };
+      } catch (error) {
+        return {
+          exitCode: ExitCode.RemoteError,
+          stderr: [`ERROR: ${normalizeError2(error)}`]
+        };
+      }
+    }
     const [issueKey, zipPathInput] = parsed.positionals;
     if (!issueKey || !zipPathInput || parsed.positionals.length > 2) {
       return {
@@ -12776,26 +13444,13 @@ function createAllureHandler(deps = {}) {
         stderr: ["Usage: automatify testops allure upload <issueKey> <zipPath> [options]"]
       };
     }
-    const config = resolveCliConfig(pickConfigArgs2(parsed), env, cwd);
-    const site = normalizeSite2(parsed.flags["--site"] ?? env.JIRA_SITE ?? config.values.baseUrl);
-    const email = (parsed.flags["--email"] ?? config.values.jiraEmail).trim();
-    const apiToken = (parsed.flags["--api-token"] ?? config.values.jiraApiToken).trim();
-    const zipPath = import_node_path8.default.resolve(cwd, zipPathInput);
-    const attachmentFilename = import_node_path8.default.basename(zipPath);
-    const credentialErrors = [];
-    if (!hasCredential(site)) {
-      credentialErrors.push("Missing Jira site. Pass --site, set JIRA_SITE/JIRA_BASE_URL, or configure baseUrl.");
-    }
-    if (!hasCredential(email)) {
-      credentialErrors.push("Missing Jira email. Pass --email or set JIRA_EMAIL.");
-    }
-    if (!hasCredential(apiToken)) {
-      credentialErrors.push("Missing Jira API token. Pass --api-token or set JIRA_API_TOKEN.");
-    }
-    if (credentialErrors.length > 0) {
+    const resolved = resolveJiraConfig(parsed, env, cwd);
+    const zipPath = import_node_path10.default.resolve(cwd, zipPathInput);
+    const attachmentFilename = import_node_path10.default.basename(zipPath);
+    if (!resolved.config) {
       return {
         exitCode: ExitCode.ValidationError,
-        stderr: credentialErrors.map((line) => `ERROR: ${line}`)
+        stderr: resolved.errors.map((line) => `ERROR: ${line}`)
       };
     }
     let summary;
@@ -12804,14 +13459,14 @@ function createAllureHandler(deps = {}) {
     } catch (error) {
       return {
         exitCode: ExitCode.ValidationError,
-        stderr: [`ERROR: ${normalizeError(error)}`]
+        stderr: [`ERROR: ${normalizeError2(error)}`]
       };
     }
     if (dryRun) {
       if (useJson) {
         return {
           exitCode: ExitCode.Success,
-          stdout: toJsonLine(buildJsonOutput({
+          stdout: toJsonLine(buildJsonOutput2({
             issueKey,
             uploaded: false,
             commentAdded: false,
@@ -12834,18 +13489,14 @@ function createAllureHandler(deps = {}) {
     }
     try {
       const attachment = await uploadAttachment({
-        site,
-        email,
-        apiToken,
+        ...resolved.config,
         issueKey,
         filePath: zipPath
       });
       let commentAdded = false;
       if (addComment) {
         await createComment({
-          site,
-          email,
-          apiToken,
+          ...resolved.config,
           issueKey,
           body: buildAllureEvidenceCommentAdf({
             counts: summary.counts,
@@ -12858,7 +13509,7 @@ function createAllureHandler(deps = {}) {
       if (useJson) {
         return {
           exitCode: ExitCode.Success,
-          stdout: toJsonLine(buildJsonOutput({
+          stdout: toJsonLine(buildJsonOutput2({
             issueKey,
             uploaded: true,
             commentAdded,
@@ -12882,15 +13533,15 @@ function createAllureHandler(deps = {}) {
     } catch (error) {
       return {
         exitCode: ExitCode.RemoteError,
-        stderr: [`ERROR: ${normalizeError(error)}`]
+        stderr: [`ERROR: ${normalizeError2(error)}`]
       };
     }
   };
 }
 
 // src/bdd.ts
-var import_node_fs7 = require("node:fs");
-var import_node_path9 = __toESM(require("node:path"), 1);
+var import_node_fs10 = require("node:fs");
+var import_node_path11 = __toESM(require("node:path"), 1);
 var import_yazl = __toESM(require_yazl(), 1);
 
 // src/forgeClient.ts
@@ -13055,7 +13706,7 @@ var CONFIG_FLAGS3 = /* @__PURE__ */ new Set([
   "--jira-email",
   "--jira-api-token"
 ]);
-function parseArgs3(args) {
+function parseArgs4(args) {
   const flags = {};
   const boolFlags = /* @__PURE__ */ new Set();
   const unknownFlags = [];
@@ -13102,7 +13753,7 @@ function pickConfigArgs3(parsed) {
   }
   return args;
 }
-function normalizeError2(error) {
+function normalizeError3(error) {
   if (error instanceof ForgeClientError) {
     return `${error.code}: ${error.message}`;
   }
@@ -13194,7 +13845,7 @@ function parseScenarioFeatureFile(raw, filePath) {
   }
   const scenarioTag = tags.map((tag) => tag.match(SCENARIO_METADATA_PATTERN)).find((match) => Boolean(match));
   const scenarioKeyFromTag = scenarioTag?.[1]?.trim().toUpperCase() ?? "";
-  const fileKeyMatch = import_node_path9.default.basename(filePath ?? "").match(/^(SC-\d+)\.feature$/i);
+  const fileKeyMatch = import_node_path11.default.basename(filePath ?? "").match(/^(SC-\d+)\.feature$/i);
   const scenarioKeyFromFile = fileKeyMatch?.[1]?.trim().toUpperCase() ?? "";
   const scenarioKey = scenarioKeyFromTag || scenarioKeyFromFile;
   if (scenarioKeyFromTag && scenarioKeyFromFile && scenarioKeyFromTag !== scenarioKeyFromFile) {
@@ -13312,7 +13963,7 @@ function toJsonExportManifestItems(items) {
 async function defaultCreateZipArchive(archivePath, entries) {
   await new Promise((resolve, reject) => {
     const zip = new import_yazl.ZipFile();
-    const output = zip.outputStream.pipe((0, import_node_fs7.createWriteStream)(archivePath));
+    const output = zip.outputStream.pipe((0, import_node_fs10.createWriteStream)(archivePath));
     output.on("close", () => resolve());
     output.on("error", reject);
     zip.outputStream.on("error", reject);
@@ -13342,14 +13993,14 @@ function missingProjectResponse() {
 function createBddHandler(deps = {}) {
   const cwd = deps.cwd ?? process.cwd();
   const env = deps.env ?? process.env;
-  const mkdir = deps.mkdir ?? ((targetPath, options) => (0, import_node_fs7.mkdirSync)(targetPath, options));
-  const readFile = deps.readFile ?? ((filePath) => (0, import_node_fs7.readFileSync)(filePath, "utf8"));
-  const readDir = deps.readDir ?? ((dirPath) => (0, import_node_fs7.readdirSync)(dirPath));
-  const writeFile = deps.writeFile ?? ((filePath, content) => (0, import_node_fs7.writeFileSync)(filePath, content, "utf8"));
+  const mkdir = deps.mkdir ?? ((targetPath, options) => (0, import_node_fs10.mkdirSync)(targetPath, options));
+  const readFile = deps.readFile ?? ((filePath) => (0, import_node_fs10.readFileSync)(filePath, "utf8"));
+  const readDir = deps.readDir ?? ((dirPath) => (0, import_node_fs10.readdirSync)(dirPath));
+  const writeFile = deps.writeFile ?? ((filePath, content) => (0, import_node_fs10.writeFileSync)(filePath, content, "utf8"));
   const createZipArchive = deps.createZipArchive ?? defaultCreateZipArchive;
   return async (request, context) => {
     const [subcommand, ...restArgs] = request.args;
-    const parsed = parseArgs3(restArgs);
+    const parsed = parseArgs4(restArgs);
     const requestedFormat = (parsed.flags["--format"] ?? "").trim().toLowerCase();
     const outputFormat = parsed.boolFlags.has("--json") ? "json" : parsed.boolFlags.has("--feature") ? "feature" : requestedFormat || "text";
     const config = resolveCliConfig(pickConfigArgs3(parsed), env, cwd);
@@ -13389,7 +14040,7 @@ function createBddHandler(deps = {}) {
           stderr: ["ERROR: Missing required --output-dir for testops bdd features export."]
         };
       }
-      const outputDir = import_node_path9.default.resolve(cwd, outputDirFlag);
+      const outputDir = import_node_path11.default.resolve(cwd, outputDirFlag);
       try {
         const result = await context.invokeForgeContract("listBddFeatures", {
           context: {
@@ -13425,7 +14076,7 @@ function createBddHandler(deps = {}) {
 `
         }));
         for (let index = 0; index < features.length; index += 1) {
-          writeFile(import_node_path9.default.join(outputDir, fileNames[index]), exportEntries[index].content);
+          writeFile(import_node_path11.default.join(outputDir, fileNames[index]), exportEntries[index].content);
         }
         const manifest = {
           action: "bdd-features-export",
@@ -13438,7 +14089,7 @@ function createBddHandler(deps = {}) {
         };
         const manifestContent = `${JSON.stringify(manifest, null, 2)}
 `;
-        writeFile(import_node_path9.default.join(outputDir, "manifest.json"), manifestContent);
+        writeFile(import_node_path11.default.join(outputDir, "manifest.json"), manifestContent);
         const archivePath = `${outputDir}.zip`;
         if (zipRequested) {
           await createZipArchive(archivePath, [
@@ -13477,7 +14128,7 @@ function createBddHandler(deps = {}) {
       } catch (error) {
         return {
           exitCode: ExitCode.TransportError,
-          stderr: [`ERROR: ${normalizeError2(error)}`]
+          stderr: [`ERROR: ${normalizeError3(error)}`]
         };
       }
     }
@@ -13508,7 +14159,7 @@ function createBddHandler(deps = {}) {
               stderr: ["ERROR: Missing required --output-dir for testops bdd scenarios export."]
             };
           }
-          const outputDir = import_node_path9.default.resolve(cwd, outputDirFlag);
+          const outputDir = import_node_path11.default.resolve(cwd, outputDirFlag);
           const zipRequested = parsed.boolFlags.has("--zip");
           try {
             const scenariosResult = await context.invokeForgeContract("listBddScenarios", {
@@ -13543,7 +14194,7 @@ function createBddHandler(deps = {}) {
               const fileName = scenarioToExportFileName(scenario);
               const fileContent = `${scenarioToFeatureLines(scenario).join("\n")}
 `;
-              writeFile(import_node_path9.default.join(outputDir, fileName), fileContent);
+              writeFile(import_node_path11.default.join(outputDir, fileName), fileContent);
               return {
                 scenario,
                 fileName,
@@ -13569,7 +14220,7 @@ function createBddHandler(deps = {}) {
             };
             const manifestContent = `${JSON.stringify(manifest, null, 2)}
 `;
-            writeFile(import_node_path9.default.join(outputDir, "manifest.json"), manifestContent);
+            writeFile(import_node_path11.default.join(outputDir, "manifest.json"), manifestContent);
             const archivePath = `${outputDir}.zip`;
             if (zipRequested) {
               await createZipArchive(archivePath, [
@@ -13612,13 +14263,13 @@ function createBddHandler(deps = {}) {
           } catch (error) {
             return {
               exitCode: ExitCode.TransportError,
-              stderr: [`ERROR: ${normalizeError2(error)}`]
+              stderr: [`ERROR: ${normalizeError3(error)}`]
             };
           }
         }
         if (nested === "import") {
-          const sourceFile = parsed.flags["--file"] ? import_node_path9.default.resolve(cwd, parsed.flags["--file"]) : "";
-          const inputDir = parsed.flags["--input-dir"] ? import_node_path9.default.resolve(cwd, parsed.flags["--input-dir"]) : "";
+          const sourceFile = parsed.flags["--file"] ? import_node_path11.default.resolve(cwd, parsed.flags["--file"]) : "";
+          const inputDir = parsed.flags["--input-dir"] ? import_node_path11.default.resolve(cwd, parsed.flags["--input-dir"]) : "";
           const dryRun = parsed.boolFlags.has("--dry-run");
           if (!sourceFile && !inputDir) {
             return {
@@ -13627,7 +14278,7 @@ function createBddHandler(deps = {}) {
             };
           }
           try {
-            const scenarioFiles = sourceFile ? [sourceFile] : readDir(inputDir).filter((entry) => entry.toLowerCase().endsWith(".feature")).map((entry) => import_node_path9.default.join(inputDir, entry)).sort((left, right) => left.localeCompare(right));
+            const scenarioFiles = sourceFile ? [sourceFile] : readDir(inputDir).filter((entry) => entry.toLowerCase().endsWith(".feature")).map((entry) => import_node_path11.default.join(inputDir, entry)).sort((left, right) => left.localeCompare(right));
             if (scenarioFiles.length === 0) {
               return {
                 exitCode: ExitCode.ValidationError,
@@ -13766,7 +14417,7 @@ function createBddHandler(deps = {}) {
           } catch (error) {
             return {
               exitCode: ExitCode.TransportError,
-              stderr: [`ERROR: ${normalizeError2(error)}`]
+              stderr: [`ERROR: ${normalizeError3(error)}`]
             };
           }
         }
@@ -13869,7 +14520,7 @@ function createBddHandler(deps = {}) {
         } catch (error) {
           return {
             exitCode: ExitCode.TransportError,
-            stderr: [`ERROR: ${normalizeError2(error)}`]
+            stderr: [`ERROR: ${normalizeError3(error)}`]
           };
         }
       }
@@ -13922,7 +14573,7 @@ function createBddHandler(deps = {}) {
       } catch (error) {
         return {
           exitCode: ExitCode.TransportError,
-          stderr: [`ERROR: ${normalizeError2(error)}`]
+          stderr: [`ERROR: ${normalizeError3(error)}`]
         };
       }
     }
@@ -13943,7 +14594,7 @@ var CONFIG_FLAGS4 = /* @__PURE__ */ new Set([
   "--jira-email",
   "--jira-api-token"
 ]);
-function parseArgs4(args) {
+function parseArgs5(args) {
   const flags = {};
   const boolFlags = /* @__PURE__ */ new Set();
   const unknownFlags = [];
@@ -13981,7 +14632,7 @@ function pickConfigArgs4(parsed) {
   }
   return args;
 }
-function normalizeError3(error) {
+function normalizeError4(error) {
   if (error instanceof ForgeClientError) {
     return `${error.code}: ${error.message}`;
   }
@@ -14115,7 +14766,7 @@ function createCasesHandler(deps = {}) {
   const env = deps.env ?? process.env;
   return async (request, context) => {
     const [subcommand, ...restArgs] = request.args;
-    const parsed = parseArgs4(restArgs);
+    const parsed = parseArgs5(restArgs);
     const useJson = parsed.boolFlags.has("--json");
     const config = resolveCliConfig(pickConfigArgs4(parsed), env, cwd);
     const projectKey = config.values.projectKey;
@@ -14162,7 +14813,7 @@ function createCasesHandler(deps = {}) {
       } catch (error) {
         return {
           exitCode: ExitCode.TransportError,
-          stderr: [`ERROR: ${normalizeError3(error)}`]
+          stderr: [`ERROR: ${normalizeError4(error)}`]
         };
       }
     }
@@ -14204,7 +14855,7 @@ function createCasesHandler(deps = {}) {
       } catch (error) {
         return {
           exitCode: ExitCode.TransportError,
-          stderr: [`ERROR: ${normalizeError3(error)}`]
+          stderr: [`ERROR: ${normalizeError4(error)}`]
         };
       }
     }
@@ -14267,7 +14918,7 @@ function createCasesHandler(deps = {}) {
       } catch (error) {
         return {
           exitCode: ExitCode.TransportError,
-          stderr: [`ERROR: ${normalizeError3(error)}`]
+          stderr: [`ERROR: ${normalizeError4(error)}`]
         };
       }
     }
@@ -14330,7 +14981,7 @@ function createCasesHandler(deps = {}) {
       } catch (error) {
         return {
           exitCode: ExitCode.TransportError,
-          stderr: [`ERROR: ${normalizeError3(error)}`]
+          stderr: [`ERROR: ${normalizeError4(error)}`]
         };
       }
     }
@@ -14342,6 +14993,7 @@ function createCasesHandler(deps = {}) {
 }
 
 // src/doctor.ts
+var import_node_child_process3 = require("node:child_process");
 var CONFIG_FLAGS5 = /* @__PURE__ */ new Set([
   "--config",
   "--base-url",
@@ -14351,11 +15003,16 @@ var CONFIG_FLAGS5 = /* @__PURE__ */ new Set([
   "--jira-email",
   "--jira-api-token"
 ]);
-function parseArgs5(args) {
+var DIRECT_JIRA_FLAGS = /* @__PURE__ */ new Set([
+  "--site",
+  "--email",
+  "--api-token"
+]);
+function parseArgs6(args) {
   const flags = {};
   const boolFlags = /* @__PURE__ */ new Set();
   const unknownFlags = [];
-  const valuedFlags = /* @__PURE__ */ new Set([...CONFIG_FLAGS5]);
+  const valuedFlags = /* @__PURE__ */ new Set([...CONFIG_FLAGS5, ...DIRECT_JIRA_FLAGS]);
   const supportedBoolFlags = /* @__PURE__ */ new Set(["--json", "--check-context"]);
   for (let i = 0; i < args.length; i += 1) {
     const token = args[i];
@@ -14421,6 +15078,49 @@ function checkFromServiceResult(result) {
     message: `Forge endpoint reachable (service returned ${result.error.code}).`
   };
 }
+function normalizeSite3(value) {
+  return value.trim().replace(/\/+$/, "");
+}
+function hasValue(value) {
+  return value.trim().length > 0;
+}
+function resolveAllureJiraConfig(parsed, env, cwd) {
+  const resolution = resolveCliConfig(pickConfigArgs5(parsed), env, cwd);
+  const site = normalizeSite3(parsed.flags["--site"] ?? env.JIRA_SITE ?? resolution.values.baseUrl);
+  const email = (parsed.flags["--email"] ?? resolution.values.jiraEmail).trim();
+  const apiToken = (parsed.flags["--api-token"] ?? resolution.values.jiraApiToken).trim();
+  const issueKey = (parsed.flags["--issue-key"] ?? "").trim();
+  const errors = [];
+  if (!hasValue(site)) {
+    errors.push("Missing Jira site. Pass --site, set JIRA_SITE/JIRA_BASE_URL, or configure baseUrl.");
+  }
+  if (!hasValue(email)) {
+    errors.push("Missing Jira email. Pass --email or set JIRA_EMAIL.");
+  }
+  if (!hasValue(apiToken)) {
+    errors.push("Missing Jira API token. Pass --api-token or set JIRA_API_TOKEN.");
+  }
+  return { site, email, apiToken, issueKey, errors };
+}
+function commandCheck(deps, command, args, passMessage, warnMessage) {
+  try {
+    deps.execFileSync(command, [...args], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    return {
+      name: command,
+      status: "pass",
+      message: passMessage
+    };
+  } catch {
+    return {
+      name: command,
+      status: "warn",
+      message: warnMessage
+    };
+  }
+}
 function toJsonPayload(summary) {
   return {
     status: summary.status,
@@ -14453,9 +15153,11 @@ function toHumanLines2(summary) {
 function createDoctorHandler(deps = {}) {
   const cwd = deps.cwd ?? process.cwd();
   const env = deps.env ?? process.env;
+  const runCommand = deps.execFileSync ?? import_node_child_process3.execFileSync;
+  const listAttachments = deps.listIssueAttachments ?? listIssueAttachments;
   return async (request, context) => {
-    const [, ...subArgs] = request.args;
-    const parsed = parseArgs5(subArgs);
+    const [subcommand, ...subArgs] = request.args;
+    const parsed = parseArgs6(subArgs);
     const useJson = parsed.boolFlags.has("--json");
     const enforceContextCheck = parsed.boolFlags.has("--check-context");
     const checks = [];
@@ -14471,6 +15173,70 @@ function createDoctorHandler(deps = {}) {
         stdout: useJson ? toJsonLine(toJsonPayload(summary2)) : toHumanLines2(summary2)
       };
     }
+    if (subcommand === "allure") {
+      const config = resolveAllureJiraConfig(parsed, env, cwd);
+      checks.push({
+        name: "allure_jira_credentials",
+        status: config.errors.length === 0 ? "pass" : "fail",
+        message: config.errors.length === 0 ? "Jira site, email, and API token are configured for Allure upload/download." : config.errors.join(" ")
+      });
+      if (config.issueKey && config.errors.length === 0) {
+        try {
+          const attachments = await listAttachments({
+            site: config.site,
+            email: config.email,
+            apiToken: config.apiToken,
+            issueKey: config.issueKey
+          });
+          checks.push({
+            name: "allure_jira_issue_access",
+            status: "pass",
+            message: `Jira issue ${config.issueKey} is reachable; ${attachments.length} attachment(s) visible.`
+          });
+        } catch (error) {
+          checks.push({
+            name: "allure_jira_issue_access",
+            status: "fail",
+            message: normalizeConnectivityError(error)
+          });
+        }
+      } else if (!config.issueKey) {
+        checks.push({
+          name: "allure_jira_issue_access",
+          status: "skip",
+          message: "Issue access check skipped. Pass --issue-key to verify Jira read/download access for a specific issue."
+        });
+      }
+      checks.push(commandCheck(
+        { execFileSync: runCommand },
+        "unzip",
+        ["-v"],
+        "unzip is available for manual ZIP inspection.",
+        "unzip was not found. The future built-in opener can avoid this, but manual inspection will be less convenient."
+      ));
+      checks.push(commandCheck(
+        { execFileSync: runCommand },
+        "java",
+        ["-version"],
+        "Java is available for optional raw allure-results workflows.",
+        "Java was not found. This does not block generated Allure HTML ZIP upload/download/open; it only matters for raw allure-results generation."
+      ));
+      checks.push(commandCheck(
+        { execFileSync: runCommand },
+        "allure",
+        ["--version"],
+        "Allure CLI is available for optional raw allure-results workflows.",
+        "Allure CLI was not found. This does not block generated Allure HTML ZIP upload/download/open."
+      ));
+      const summary2 = {
+        status: computeOverallStatus(checks),
+        checks
+      };
+      return {
+        exitCode: pickDoctorExitCode(summary2),
+        stdout: useJson ? toJsonLine(toJsonPayload(summary2)) : toHumanLines2(summary2)
+      };
+    }
     const configArgs = pickConfigArgs5(parsed);
     const resolution = resolveCliConfig(configArgs, env, cwd);
     const configValidation = validateCliConfigResolution(resolution);
@@ -14559,8 +15325,8 @@ function createDoctorHandler(deps = {}) {
 }
 
 // src/ingestFeature.ts
-var import_node_fs8 = require("node:fs");
-var import_node_path10 = __toESM(require("node:path"), 1);
+var import_node_fs11 = require("node:fs");
+var import_node_path12 = __toESM(require("node:path"), 1);
 var CONFIG_FLAGS6 = /* @__PURE__ */ new Set([
   "--config",
   "--base-url",
@@ -14570,7 +15336,7 @@ var CONFIG_FLAGS6 = /* @__PURE__ */ new Set([
   "--jira-email",
   "--jira-api-token"
 ]);
-function parseArgs6(args) {
+function parseArgs7(args) {
   const flags = {};
   const boolFlags = /* @__PURE__ */ new Set();
   const unknownFlags = [];
@@ -14636,7 +15402,7 @@ function summarizeSuccess(result) {
   }
   return lines;
 }
-function normalizeError4(error) {
+function normalizeError5(error) {
   if (error instanceof ForgeClientError) {
     return `${error.code}: ${error.message}`;
   }
@@ -14646,18 +15412,18 @@ function normalizeError4(error) {
   return "Unknown ingest error.";
 }
 function createIngestFeatureHandler(deps = {}) {
-  const readFile = deps.readFile ?? ((filePath) => (0, import_node_fs8.readFileSync)(filePath, "utf8"));
-  const readStdin = deps.readStdin ?? (() => (0, import_node_fs8.readFileSync)(0, "utf8"));
+  const readFile = deps.readFile ?? ((filePath) => (0, import_node_fs11.readFileSync)(filePath, "utf8"));
+  const readStdin = deps.readStdin ?? (() => (0, import_node_fs11.readFileSync)(0, "utf8"));
   const cwd = deps.cwd ?? process.cwd();
   const env = deps.env ?? process.env;
   return async (request, context) => {
     const [, ...subArgs] = request.args;
-    const parsed = parseArgs6(subArgs);
+    const parsed = parseArgs7(subArgs);
     const configArgs = pickConfigArgs6(parsed);
     const config = resolveCliConfig(configArgs, env, cwd);
     const projectKey = config.values.projectKey;
     const issueKey = config.values.issueKey;
-    const sourceFile = parsed.flags["--file"] ? import_node_path10.default.resolve(cwd, parsed.flags["--file"]) : "";
+    const sourceFile = parsed.flags["--file"] ? import_node_path12.default.resolve(cwd, parsed.flags["--file"]) : "";
     const useStdin = parsed.boolFlags.has("--stdin");
     const useJson = parsed.boolFlags.has("--json");
     const sourceCount = Number(Boolean(sourceFile)) + Number(useStdin);
@@ -14673,7 +15439,7 @@ function createIngestFeatureHandler(deps = {}) {
     } catch (error) {
       return {
         exitCode: ExitCode.InternalError,
-        stderr: [`ERROR: Failed to read feature source: ${normalizeError4(error)}`]
+        stderr: [`ERROR: Failed to read feature source: ${normalizeError5(error)}`]
       };
     }
     const name = (parsed.flags["--name"] ?? deriveNameFromGherkin(gherkin)).trim();
@@ -14768,7 +15534,7 @@ function createIngestFeatureHandler(deps = {}) {
             status: "failed",
             featureName: name,
             source: useStdin ? "stdin" : sourceFile,
-            errorMessage: normalizeError4(error)
+            errorMessage: normalizeError5(error)
           })
         };
       }
@@ -14779,15 +15545,15 @@ function createIngestFeatureHandler(deps = {}) {
           `Feature: ${name}`,
           `Source: ${useStdin ? "stdin" : sourceFile}`
         ],
-        stderr: [`ERROR: ${normalizeError4(error)}`]
+        stderr: [`ERROR: ${normalizeError5(error)}`]
       };
     }
   };
 }
 
 // src/runUpload.ts
-var import_node_fs9 = require("node:fs");
-var import_node_path11 = __toESM(require("node:path"), 1);
+var import_node_fs12 = require("node:fs");
+var import_node_path13 = __toESM(require("node:path"), 1);
 var STEP_RESULTS = [
   StepResult.Passed,
   StepResult.Failed,
@@ -14803,7 +15569,7 @@ var CONFIG_FLAGS7 = /* @__PURE__ */ new Set([
   "--jira-email",
   "--jira-api-token"
 ]);
-function parseArgs7(args) {
+function parseArgs8(args) {
   const flags = {};
   const boolFlags = /* @__PURE__ */ new Set();
   const unknownFlags = [];
@@ -14849,7 +15615,7 @@ function pickConfigArgs7(parsed) {
   }
   return configArgs;
 }
-function normalizeError5(error) {
+function normalizeError6(error) {
   if (error instanceof ForgeClientError) {
     return `${error.code}: ${error.message}`;
   }
@@ -14928,19 +15694,19 @@ function summarizeRunResult(result) {
   return lines;
 }
 function createRunUploadHandler(deps = {}) {
-  const readFile = deps.readFile ?? ((filePath) => (0, import_node_fs9.readFileSync)(filePath, "utf8"));
-  const readStdin = deps.readStdin ?? (() => (0, import_node_fs9.readFileSync)(0, "utf8"));
+  const readFile = deps.readFile ?? ((filePath) => (0, import_node_fs12.readFileSync)(filePath, "utf8"));
+  const readStdin = deps.readStdin ?? (() => (0, import_node_fs12.readFileSync)(0, "utf8"));
   const cwd = deps.cwd ?? process.cwd();
   const env = deps.env ?? process.env;
   return async (request, context) => {
     const [, ...subArgs] = request.args;
-    const parsed = parseArgs7(subArgs);
+    const parsed = parseArgs8(subArgs);
     const configArgs = pickConfigArgs7(parsed);
     const config = resolveCliConfig(configArgs, env, cwd);
     const projectKey = config.values.projectKey;
     const issueKey = config.values.issueKey;
     const testCaseKey = parsed.flags["--test-case-key"]?.trim().toUpperCase() ?? "";
-    const sourceFile = parsed.flags["--file"] ? import_node_path11.default.resolve(cwd, parsed.flags["--file"]) : "";
+    const sourceFile = parsed.flags["--file"] ? import_node_path13.default.resolve(cwd, parsed.flags["--file"]) : "";
     const useStdin = parsed.boolFlags.has("--stdin");
     const useJson = parsed.boolFlags.has("--json");
     const sourceCount = Number(Boolean(sourceFile)) + Number(useStdin);
@@ -14968,7 +15734,7 @@ function createRunUploadHandler(deps = {}) {
     } catch (error) {
       return {
         exitCode: ExitCode.InternalError,
-        stderr: [`ERROR: Failed to read run payload source: ${normalizeError5(error)}`]
+        stderr: [`ERROR: Failed to read run payload source: ${normalizeError6(error)}`]
       };
     }
     const payloadFromSource = parseRunPayload(raw);
@@ -14998,7 +15764,7 @@ function createRunUploadHandler(deps = {}) {
       } catch (error) {
         return {
           exitCode: ExitCode.TransportError,
-          stderr: [`ERROR: ${normalizeError5(error)}`]
+          stderr: [`ERROR: ${normalizeError6(error)}`]
         };
       }
     }
@@ -15078,7 +15844,7 @@ function createRunUploadHandler(deps = {}) {
             featureName: runInput.featureName,
             scenarioName: runInput.scenarioName,
             executedAt: runInput.executedAt,
-            errorMessage: normalizeError5(error)
+            errorMessage: normalizeError6(error)
           })
         };
       }
@@ -15090,7 +15856,7 @@ function createRunUploadHandler(deps = {}) {
           `Scenario: ${runInput.scenarioName}`,
           `ExecutedAt: ${runInput.executedAt}`
         ],
-        stderr: [`ERROR: ${normalizeError5(error)}`]
+        stderr: [`ERROR: ${normalizeError6(error)}`]
       };
     }
   };
@@ -15106,7 +15872,7 @@ var CONFIG_FLAGS8 = /* @__PURE__ */ new Set([
   "--jira-email",
   "--jira-api-token"
 ]);
-function parseArgs8(args) {
+function parseArgs9(args) {
   const flags = {};
   const boolFlags = /* @__PURE__ */ new Set();
   const unknownFlags = [];
@@ -15144,7 +15910,7 @@ function pickConfigArgs8(parsed) {
   }
   return args;
 }
-function normalizeError6(error) {
+function normalizeError7(error) {
   if (error instanceof ForgeClientError) {
     return `${error.code}: ${error.message}`;
   }
@@ -15208,7 +15974,7 @@ function createRunsHandler(deps = {}) {
   const env = deps.env ?? process.env;
   return async (request, context) => {
     const [subcommand, ...restArgs] = request.args;
-    const parsed = parseArgs8(restArgs);
+    const parsed = parseArgs9(restArgs);
     const useJson = parsed.boolFlags.has("--json");
     const config = resolveCliConfig(pickConfigArgs8(parsed), env, cwd);
     const projectKey = config.values.projectKey;
@@ -15262,7 +16028,7 @@ function createRunsHandler(deps = {}) {
       } catch (error) {
         return {
           exitCode: ExitCode.TransportError,
-          stderr: [`ERROR: ${normalizeError6(error)}`]
+          stderr: [`ERROR: ${normalizeError7(error)}`]
         };
       }
     }
@@ -15283,7 +16049,7 @@ var CONFIG_FLAGS9 = /* @__PURE__ */ new Set([
   "--jira-email",
   "--jira-api-token"
 ]);
-function parseArgs9(args) {
+function parseArgs10(args) {
   const flags = {};
   const boolFlags = /* @__PURE__ */ new Set();
   const unknownFlags = [];
@@ -15321,7 +16087,7 @@ function pickConfigArgs9(parsed) {
   }
   return args;
 }
-function normalizeError7(error) {
+function normalizeError8(error) {
   if (error instanceof ForgeClientError) {
     return `${error.code}: ${error.message}`;
   }
@@ -15403,7 +16169,7 @@ function createSuitesHandler(deps = {}) {
   const env = deps.env ?? process.env;
   return async (request, context) => {
     const [subcommand, ...restArgs] = request.args;
-    const parsed = parseArgs9(restArgs);
+    const parsed = parseArgs10(restArgs);
     const useJson = parsed.boolFlags.has("--json");
     const config = resolveCliConfig(pickConfigArgs9(parsed), env, cwd);
     const projectKey = config.values.projectKey;
@@ -15450,7 +16216,7 @@ function createSuitesHandler(deps = {}) {
       } catch (error) {
         return {
           exitCode: ExitCode.TransportError,
-          stderr: [`ERROR: ${normalizeError7(error)}`]
+          stderr: [`ERROR: ${normalizeError8(error)}`]
         };
       }
     }
@@ -15491,7 +16257,7 @@ function createSuitesHandler(deps = {}) {
       } catch (error) {
         return {
           exitCode: ExitCode.TransportError,
-          stderr: [`ERROR: ${normalizeError7(error)}`]
+          stderr: [`ERROR: ${normalizeError8(error)}`]
         };
       }
     }
@@ -15555,7 +16321,7 @@ function createSuitesHandler(deps = {}) {
       } catch (error) {
         return {
           exitCode: ExitCode.TransportError,
-          stderr: [`ERROR: ${normalizeError7(error)}`]
+          stderr: [`ERROR: ${normalizeError8(error)}`]
         };
       }
     }
@@ -15577,7 +16343,7 @@ var CONFIG_FLAGS10 = /* @__PURE__ */ new Set([
   "--jira-api-token"
 ]);
 var RECONCILE_CONFIRM_TOKEN = "RECONCILE";
-function parseArgs10(args) {
+function parseArgs11(args) {
   const flags = {};
   const boolFlags = /* @__PURE__ */ new Set();
   const unknownFlags = [];
@@ -15615,7 +16381,7 @@ function pickConfigArgs10(parsed) {
   }
   return args;
 }
-function normalizeError8(error) {
+function normalizeError9(error) {
   if (error instanceof ForgeClientError) {
     return `${error.code}: ${error.message}`;
   }
@@ -15666,7 +16432,7 @@ function createSyncHandler(deps = {}) {
   const env = deps.env ?? process.env;
   return async (request, context) => {
     const [subcommand, ...restArgs] = request.args;
-    const parsed = parseArgs10(restArgs);
+    const parsed = parseArgs11(restArgs);
     const useJson = parsed.boolFlags.has("--json");
     const config = resolveCliConfig(pickConfigArgs10(parsed), env, cwd);
     const projectKey = config.values.projectKey;
@@ -15718,7 +16484,7 @@ function createSyncHandler(deps = {}) {
       } catch (error) {
         return {
           exitCode: ExitCode.TransportError,
-          stderr: [`ERROR: ${normalizeError8(error)}`]
+          stderr: [`ERROR: ${normalizeError9(error)}`]
         };
       }
     }
@@ -15764,7 +16530,7 @@ function createSyncHandler(deps = {}) {
       } catch (error) {
         return {
           exitCode: ExitCode.TransportError,
-          stderr: [`ERROR: ${normalizeError8(error)}`]
+          stderr: [`ERROR: ${normalizeError9(error)}`]
         };
       }
     }
@@ -15779,8 +16545,8 @@ function createSyncHandler(deps = {}) {
 var COMMAND_REGISTRY = [
   {
     name: "allure",
-    description: "Allure evidence upload commands for Jira issues",
-    subcommands: ["upload"],
+    description: "Allure evidence upload/download/open commands for Jira issues",
+    subcommands: ["upload", "download", "open"],
     handler: createAllureHandler()
   },
   {
@@ -15835,7 +16601,7 @@ var COMMAND_REGISTRY = [
   {
     name: "doctor",
     description: "Preflight and health checks",
-    subcommands: ["check"],
+    subcommands: ["check", "allure"],
     handler: createDoctorHandler()
   },
   {
@@ -16020,6 +16786,7 @@ function showTopLevelHelp() {
     "",
     "Available products:",
     "  testops       TestOps \u2014 test management, BDD, execution, reporting",
+    "  allure        Allure evidence diagnostics and local report workflows (doctor, open)",
     "",
     "Boundary:",
     "  Thin client over Forge contracts or Jira Cloud APIs.",
@@ -16029,6 +16796,29 @@ function showTopLevelHelp() {
     console.log(line);
   }
 }
+function showAllureHelp() {
+  const lines = [
+    "Automatify Allure",
+    "",
+    "Usage:",
+    "  automatify allure doctor [options]",
+    "  automatify allure open <zipPath> [options]",
+    "",
+    "Commands:",
+    "  doctor        Check local Allure/Jira readiness",
+    "  open          Extract a generated Allure HTML report ZIP and serve it locally",
+    "",
+    "Examples:",
+    "  automatify allure doctor",
+    "  automatify allure doctor --json",
+    "  automatify allure doctor --issue-key ABC-123",
+    "  automatify allure open ./allure-report.zip",
+    "  automatify allure open ./allure-report.zip --port 8080 --no-open"
+  ];
+  for (const line of lines) {
+    console.log(line);
+  }
+}
 async function main() {
   const args = process.argv.slice(2);
   const [productArg, ...restArgs] = args;
@@ -16037,6 +16827,28 @@ async function main() {
     process.exitCode = 0;
     return;
   }
+  if (productArg === "allure") {
+    const [commandArg, ...commandRest] = restArgs;
+    if (!commandArg || commandArg === "--help" || commandArg === "-h" || commandArg === "help") {
+      showAllureHelp();
+      process.exitCode = 0;
+      return;
+    }
+    if (commandArg === "doctor") {
+      const exitCode2 = await runCli(["doctor", "allure", ...commandRest]);
+      process.exitCode = exitCode2;
+      return;
+    }
+    if (commandArg === "open") {
+      const exitCode2 = await runCli(["allure", "open", ...commandRest]);
+      process.exitCode = exitCode2;
+      return;
+    }
+    console.error(`Unknown allure command: ${commandArg}`);
+    console.error("Run `automatify allure --help` to see available commands.");
+    process.exitCode = 1;
+    return;
+  }
   if (productArg !== "testops") {
     console.error(`Unknown product: ${productArg}`);
     console.error("Run `automatify --help` to see available products.");