@automatify-au/cli 0.1.8 → 0.1.10

package/README.md

@@ -142,6 +142,7 @@ All TestOps commands are invoked as `automatify testops <command>`:
 - `allure`
   - `automatify testops allure upload ABC-123 ./allure-report.zip --dry-run`
   - `automatify testops allure upload ABC-123 ./allure-report.zip`
+  - `automatify testops allure download ABC-123 --output-dir ./downloads`
 - `auto`
   - `automatify testops auto --dry-run`
   - `automatify testops auto`
@@ -150,6 +151,7 @@ All TestOps commands are invoked as `automatify testops <command>`:
 
 Purpose:
 - upload an already generated Allure HTML report ZIP to a Jira issue as evidence.
+- download an uploaded Allure HTML report ZIP from a Jira issue for local inspection.
 - parse `widgets/summary.json` from the ZIP and add a concise Jira comment with result counts.
 - keep the flow Java-free and backend-free; this command does not generate Allure reports from raw `allure-results`.
 
@@ -183,6 +185,8 @@ Upload without a Jira comment:
 automatify testops allure upload ABC-123 ./allure-report.zip --no-comment
 ```
 
+Normal output prints the Jira issue, attachment filename, attachment id, and attachment URL when Jira returns them.
+
 Machine-readable output:
 ```bash
 automatify testops allure upload ABC-123 ./allure-report.zip --dry-run --json
@@ -214,6 +218,22 @@ After a real upload, JSON output includes Jira attachment metadata when Jira ret
 }
 ```
 
+Download the latest Allure report ZIP attachment from a Jira issue:
+```bash
+automatify testops allure download ABC-123 --output-dir ./downloads
+```
+
+Download selection rules:
+- `--attachment-id <id>` downloads one exact Jira attachment.
+- `--filename <name>` downloads the newest attachment with that filename.
+- without either flag, the CLI chooses the newest `allure-report*.zip` attachment, then falls back to the newest `.zip` attachment.
+- existing local files are not overwritten unless `--force` is passed.
+
+Download dry run / JSON:
+```bash
+automatify testops allure download ABC-123 --dry-run --json
+```
+
 ### Optional gated maintenance commands
 
 - `sync`

package/dist/automatify.cjs

@@ -12448,6 +12448,7 @@ function createAutoHandler(deps = {}) {
 
 // src/allure.ts
 var import_node_path8 = __toESM(require("node:path"), 1);
+var import_node_fs7 = 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`, {
@@ -12643,9 +12700,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("--")) {
@@ -12688,6 +12748,23 @@ function normalizeError(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 [
@@ -12700,6 +12777,76 @@ function formatHumanSummary(summary) {
     `Unknown: ${counts.unknown}`
   ];
 }
+function formatHumanAttachment(attachment) {
+  const lines = [`Attachment: ${attachment.filename}`];
+  if (attachment.id) {
+    lines.push(`Attachment ID: ${attachment.id}`);
+  }
+  if (attachment.content) {
+    lines.push(`Attachment URL: ${attachment.content}`);
+  } else if (attachment.self) {
+    lines.push(`Attachment API URL: ${attachment.self}`);
+  }
+  return lines;
+}
+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 buildJsonOutput(params) {
   const attachment = {
     filename: params.attachment.filename
@@ -12738,12 +12885,18 @@ function createAllureHandler(deps = {}) {
   const parseZip = deps.parseAllureReportZip ?? parseAllureReportZip;
   const uploadAttachment = deps.uploadIssueAttachment ?? uploadIssueAttachment;
   const createComment = deps.addIssueComment ?? addIssueComment;
+  const listAttachments = deps.listIssueAttachments ?? listIssueAttachments;
+  const downloadAttachment = deps.downloadIssueAttachment ?? downloadIssueAttachment;
   return async (request) => {
     const [subcommand, ...subArgs] = request.args;
-    if (subcommand !== "upload") {
+    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]"
+        ]
       };
     }
     const parsed = parseArgs2(subArgs);
@@ -12751,12 +12904,102 @@ function createAllureHandler(deps = {}) {
     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_path8.default.resolve(cwd, parsed.flags["--output-dir"] ?? ".");
+        const outputPath = import_node_path8.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_fs7.mkdirSync)(outputDir, { recursive: true });
+        if ((0, import_node_fs7.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: ${normalizeError(error)}`]
+        };
+      }
+    }
     const [issueKey, zipPathInput] = parsed.positionals;
     if (!issueKey || !zipPathInput || parsed.positionals.length > 2) {
       return {
@@ -12764,26 +13007,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 resolved = resolveJiraConfig(parsed, env, cwd);
     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) {
+    if (!resolved.config) {
       return {
         exitCode: ExitCode.ValidationError,
-        stderr: credentialErrors.map((line) => `ERROR: ${line}`)
+        stderr: resolved.errors.map((line) => `ERROR: ${line}`)
       };
     }
     let summary;
@@ -12822,18 +13052,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,
@@ -12863,6 +13089,7 @@ function createAllureHandler(deps = {}) {
           ...verbose ? [`Summary path: ${summary.summaryPath}`] : [],
           "",
           `Uploaded to Jira issue ${issueKey}.`,
+          ...formatHumanAttachment(attachment),
           commentAdded ? "Comment added." : "Comment skipped."
         ]
       };
@@ -12876,7 +13103,7 @@ function createAllureHandler(deps = {}) {
 }
 
 // src/bdd.ts
-var import_node_fs7 = require("node:fs");
+var import_node_fs8 = require("node:fs");
 var import_node_path9 = __toESM(require("node:path"), 1);
 var import_yazl = __toESM(require_yazl(), 1);
 
@@ -13299,7 +13526,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_fs8.createWriteStream)(archivePath));
     output.on("close", () => resolve());
     output.on("error", reject);
     zip.outputStream.on("error", reject);
@@ -13329,10 +13556,10 @@ 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_fs8.mkdirSync)(targetPath, options));
+  const readFile = deps.readFile ?? ((filePath) => (0, import_node_fs8.readFileSync)(filePath, "utf8"));
+  const readDir = deps.readDir ?? ((dirPath) => (0, import_node_fs8.readdirSync)(dirPath));
+  const writeFile = deps.writeFile ?? ((filePath, content) => (0, import_node_fs8.writeFileSync)(filePath, content, "utf8"));
   const createZipArchive = deps.createZipArchive ?? defaultCreateZipArchive;
   return async (request, context) => {
     const [subcommand, ...restArgs] = request.args;
@@ -14546,7 +14773,7 @@ function createDoctorHandler(deps = {}) {
 }
 
 // src/ingestFeature.ts
-var import_node_fs8 = require("node:fs");
+var import_node_fs9 = require("node:fs");
 var import_node_path10 = __toESM(require("node:path"), 1);
 var CONFIG_FLAGS6 = /* @__PURE__ */ new Set([
   "--config",
@@ -14633,8 +14860,8 @@ 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_fs9.readFileSync)(filePath, "utf8"));
+  const readStdin = deps.readStdin ?? (() => (0, import_node_fs9.readFileSync)(0, "utf8"));
   const cwd = deps.cwd ?? process.cwd();
   const env = deps.env ?? process.env;
   return async (request, context) => {
@@ -14773,7 +15000,7 @@ function createIngestFeatureHandler(deps = {}) {
 }
 
 // src/runUpload.ts
-var import_node_fs9 = require("node:fs");
+var import_node_fs10 = require("node:fs");
 var import_node_path11 = __toESM(require("node:path"), 1);
 var STEP_RESULTS = [
   StepResult.Passed,
@@ -14915,8 +15142,8 @@ 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_fs10.readFileSync)(filePath, "utf8"));
+  const readStdin = deps.readStdin ?? (() => (0, import_node_fs10.readFileSync)(0, "utf8"));
   const cwd = deps.cwd ?? process.cwd();
   const env = deps.env ?? process.env;
   return async (request, context) => {
@@ -15766,8 +15993,8 @@ function createSyncHandler(deps = {}) {
 var COMMAND_REGISTRY = [
   {
     name: "allure",
-    description: "Allure evidence upload commands for Jira issues",
-    subcommands: ["upload"],
+    description: "Allure evidence upload/download commands for Jira issues",
+    subcommands: ["upload", "download"],
     handler: createAllureHandler()
   },
   {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@automatify-au/cli",
-  "version": "0.1.8",
+  "version": "0.1.10",
   "description": "Forge-first CLI for Automatify Jira TestOps",
   "type": "module",
   "bin": {