@plune-ai/cli 0.31.0 → 0.32.1

package/README.md

@@ -122,7 +122,7 @@ the last resort, used only when `PLUNE_TOKEN` is set nowhere else. Nothing write
 | `plune login` | Save a [Plune platform](https://plune.ai/platform) API token so `sync` and `ingest` can reach it. The token is **checked against the API before it is saved**, so a wrong one fails here rather than two commands later. Get one at `https://beta.plune.ai` → Account → API tokens. Flags: `--token <token>` (omit to paste it or pipe it via stdin), `--skip-verify` (save without checking, for offline setup). In CI, skip this step: every platform command reads `PLUNE_TOKEN` from the environment first, and the saved login only when it is not set. |
 | `plune logout` | Remove the saved token. |
 | `plune sync` | Upload the latest local run to the platform. Flags: `--file <path>` to send a specific run JSON, `--fail-on-failures` to read the run's summary back once after the upload and exit with [the gate](#a-release-gate---fail-on-failures)'s code. Each upload carries an `Idempotency-Key` (SHA-256 of the body), so sending the same run again returns the same run rather than creating a second one. Against a platform with `POST /v1/jobs` the upload is also reported as a job (kind `sync`, counting the run's rows) that ends completed, or failed with the error text if the sync fails; an older platform without the route is not told, and a job report never fails the sync: when the sync goes through, one the platform did not take is said in one line on stderr. |
-| `plune run import <file>` | Turn a **JUnit XML** or **Playwright JSON** report, or an **Allure `allure-results` folder**, into a run in Plune. Needs no provider key — nothing is generated. Flags: `--format junit\|playwright-json\|allure` (detected from the file when omitted; a folder is Allure), `--name <text>` to call the run something other than the [folder-based default](#what-the-run-is-called), `--key <externalKey>` to land several reports in one run (with `PLUNE_SHARED_RUN=1` — see below), `--create` to offer unmatched tests to the review queue, `--fail-on-missing-attachments` to exit 1 when a file a JUnit report names with `[[ATTACHMENT\|path]]`, or an Allure result names as a `source`, is not there (the results are sent either way), `--upload-concurrency <n>` for files uploaded at once ([1 to 32, default 16](#many-screenshots-upload-concurrency-and-retries)), `--fail-on-failures` to exit with [the gate](#a-release-gate---fail-on-failures)'s code on the summary the platform froze when this import finished the run. |
+| `plune run import <file \| folder>` | Turn a **JUnit XML** or **Playwright JSON** report, a **folder of JUnit XML files** (Maven Surefire's `target/surefire-reports`, Gradle's `build/test-results/test`), or an **Allure `allure-results` folder**, into a run in Plune. Needs no provider key — nothing is generated. Flags: `--format junit\|playwright-json\|allure` (detected when omitted: a folder with a `*-result.json` is Allure, any other folder is read as the JUnit `*.xml` files in it), `--name <text>` to call the run something other than the [folder-based default](#what-the-run-is-called), `--key <externalKey>` to land several reports in one run (with `PLUNE_SHARED_RUN=1` — see below), `--create` to offer unmatched tests to the review queue, `--fail-on-missing-attachments` to exit 1 when a file a JUnit report names with `[[ATTACHMENT\|path]]`, or an Allure result names as a `source`, is not there (the results are sent either way), `--upload-concurrency <n>` for files uploaded at once ([1 to 32, default 16](#many-screenshots-upload-concurrency-and-retries)), `--fail-on-failures` to exit with [the gate](#a-release-gate---fail-on-failures)'s code on the summary the platform froze when this import finished the run. |
 | `plune run start` | Open a platform run — or join the one already carrying `--key` — and print its id. Flags: `--key <externalKey>` (generated when absent), `--name <text>` to call the run something other than the [default](#what-the-run-is-called), `--json` for one machine-readable line. |
 | `plune run finish <id>` | Close a platform run. This is what the reporter tells you to do for a run it had to leave open. Flags: `--terminate` to record it as cut short, `--reason <text>`, `--fail-on-failures` to exit with [the gate](#a-release-gate---fail-on-failures)'s code on the summary the platform froze. |
 | `plune run exec -- <command>` | Open a run, run the command inside it, close the run — and exit with whatever the command returned. Sets `PLUNE_SHARED_RUN` for you, so anything reporting inside joins that run. Flags: `--key <externalKey>`, `--name <text>` (as on `run start`), `--fail-on-failures` to exit with [the gate](#a-release-gate---fail-on-failures)'s code instead — or with the command's own when no result reached the run. |
@@ -239,6 +239,7 @@ costs nothing beyond a Plune token.
 ```bash
 plune login                           # once, on your machine; in CI export PLUNE_TOKEN instead
 plune run import ./junit.xml          # Jest, Vitest, pytest, PHPUnit, Surefire, Cypress, …
+plune run import target/surefire-reports   # or a folder of JUnit files: Maven, Gradle — see Java below
 plune run import ./playwright.json    # or Playwright's own JSON report
 plune run import ./allure-results     # or the folder an Allure adapter wrote — see below
 ```
@@ -301,13 +302,15 @@ pytest --junitxml=report.xml -o junit_logging=system-out
 plune run import report.xml
 ```
 
-Java, JUnit 5 (Maven Surefire writes the test's output into its testcase):
+Java, JUnit 5 (Maven Surefire writes the test's output into its testcase; Gradle only with
+`reports.junitXml.outputPerTestCase = true`). The path counts from the folder the XML file is in
+(`target/surefire-reports`, `build/test-results/test`), so the file has to be below it:
 
 ```java
 @Test
 void checkout() {
-    // ...
-    System.out.println("[[ATTACHMENT|target/artifacts/checkout.png]]");
+    // ... save the screenshot as target/surefire-reports/artifacts/checkout.png
+    System.out.println("[[ATTACHMENT|artifacts/checkout.png]]");
 }
 ```
 
@@ -330,7 +333,7 @@ For Jest, use Allure below.
 
 Every Allure adapter (pytest, JUnit 5, TestNG, Playwright, Cypress, Jest, Vitest, WebdriverIO, .NET) writes
 the same folder: a `*-result.json` per test, a `*-container.json` per suite, and the files the tests attached.
-Point `plune run import` at the folder (a folder is read as Allure, no flag needed). Each test arrives with its
+Point `plune run import` at the folder (a folder with a `*-result.json` in it is read as Allure, no flag needed). Each test arrives with its
 name, its status as Allure shows it (`passed`, `failed`, `broken`, `skipped`), its time, the failure message and
 trace, and its steps; a test run again (same `historyId`) is one test with attempts, the last one counting.
 The files come from the test, from its steps and from its fixtures (`befores`, `afters`), each with the
@@ -354,11 +357,36 @@ def test_checkout(page):
         allure.attach.file("artifacts/checkout.png", name="checkout", attachment_type=allure.attachment_type.PNG)
 ```
 
-Java, JUnit 5 (`allure-junit5`, with the AspectJ agent from Allure's setup; the results folder is
-`target/allure-results` unless `allure.results.directory` says otherwise):
+Java. Maven Surefire and Gradle write JUnit XML on their own, a `TEST-<class>.xml` per class, so a Java suite
+needs no Allure: point the import at the folder.
 
 ```bash
 mvn test
+plune run import target/surefire-reports
+
+./gradlew test
+plune run import build/test-results/test
+```
+
+Every `*.xml` in the folder that is a JUnit report is read, in the order of the file names, and together they make
+one run. The folder's other files and its subfolders (Gradle's `binary/`) are not opened; an `*.xml` that is not a
+JUnit report is skipped with a line in the output. Each test arrives with its class and name as the key
+(`cart.CartTest#addsAnItem` from Surefire; Gradle keeps the brackets, `cart.CartTest#addsAnItem()`), its status
+(`pass`, `failure`, `error`, `skipped`), the failure's message, type and stack trace, and its duration. Gradle writes
+a `timestamp` on the suite, and a test's span starts there; Surefire writes none, so a Maven test's span ends when the
+import reads the report (plune-ai/plune#2310). A file reaches a test only
+through a `[[ATTACHMENT|path]]` line in its own output, [as above](#files-from-a-junit-report), the path counted from
+the folder the XML file is in. Gradle puts that output in the test's testcase only with
+`reports.junitXml.outputPerTestCase = true` (by default it writes it once per suite).
+
+Allure adds the steps, and files attached without printing a line. The JUnit 5 adapter is
+`io.qameta.allure:allure-jupiter` (from 2.35.1, `allure-junit5` is only a relocation to it, with no jar), with the
+AspectJ agent from Allure's setup. It writes `allure-results` in the working folder; to have it in the build's
+output, set `allure.results.directory` (in `src/test/resources/allure.properties`, or as a system property) to
+`target/allure-results` for Maven or `build/allure-results` for Gradle:
+
+```bash
+mvn test                                  # with allure.results.directory=target/allure-results
 plune run import target/allure-results
 ```
 
@@ -372,11 +400,13 @@ void checkout() {
 Jest has no per-test output in JUnit; `allure-jest` gives it one (`allure.attachment(...)` in a test or a step).
 Tests are matched to Plune cases by the same key as a JUnit report's, `classname#name`, where the adapter's
 names allow it (pytest, JUnit 5, Playwright); for Vitest, Jest and Cypress the key is the runner, the file and the
-test's full name (`vt:test/cart.test.js#cart adds an item`, `jest:…`, `cy:…`). A file whose name starts with `_`
+test's full name (`vt:test/cart.test.js#cart adds an item`, `jest:…`, `cy:…`). For JUnit 5 the name carries the
+method's parentheses in Allure and in Gradle's JUnit XML (`shop.CartTest#coupon()`) but not in Surefire's
+(`shop.CartTest#coupon`), so a project that moves between Allure and Surefire meets its cases under other keys. A file whose name starts with `_`
 is not sent: the core hides it as Playwright's own reports do, and Allure has no such convention, so name
 attachments without a leading underscore.
 
-Check that the output reaches the report: Gradle writes it only with `reports.junitXml.outputPerTestCase = true`,
+For a JUnit report, check that the output reaches the report: Gradle writes it only with `reports.junitXml.outputPerTestCase = true`,
 and Maven Surefire moves it out of the XML when `redirectTestOutputToFile` is `true`. As in the Playwright
 reporter, a file whose name starts with an underscore is skipped, and a file several tests name is uploaded once per test.
 

package/dist/cli.cjs

@@ -2565,7 +2565,7 @@ function createClient(opts) {
   }
   const base = opts.apiUrl.replace(/\/+$/, "");
   const scrub = (text2) => opts.token === "" ? text2 : text2.split(opts.token).join("***");
-  async function send(method, path18, payload, retries = DEFAULT_RETRIES) {
+  async function send(method, path19, payload, retries = DEFAULT_RETRIES) {
     let last = {
       kind: "unavailable",
       status: null,
@@ -2576,7 +2576,7 @@ function createClient(opts) {
       await respectPause(mine);
       let res;
       try {
-        res = await doFetch(`${base}${path18}`, {
+        res = await doFetch(`${base}${path19}`, {
           method,
           headers: { "content-type": payload?.type ?? "application/json", authorization: `Bearer ${opts.token}` },
           // A DELETE carries none. Sending `"undefined"` as a body is what a naive
@@ -2615,10 +2615,10 @@ function createClient(opts) {
     return { ok: false, ...last };
   }
   return {
-    post: (path18, body, retries) => send("POST", path18, { body: JSON.stringify(body), type: "application/json" }, retries),
-    upload: (path18, bytes, contentType) => send("POST", path18, { body: bytes, type: contentType }, uploadRetries ?? DEFAULT_RETRIES),
-    del: (path18) => send("DELETE", path18),
-    get: (path18) => send("GET", path18),
+    post: (path19, body, retries) => send("POST", path19, { body: JSON.stringify(body), type: "application/json" }, retries),
+    upload: (path19, bytes, contentType) => send("POST", path19, { body: bytes, type: contentType }, uploadRetries ?? DEFAULT_RETRIES),
+    del: (path19) => send("DELETE", path19),
+    get: (path19) => send("GET", path19),
     async put(url, headers, source) {
       const putRetries = uploadRetries ?? 3;
       let last = { ok: false, status: null, code: "network" };
@@ -2899,12 +2899,12 @@ function machineless(raw, repoRoot, home) {
   if (repoRoot === void 0) text2 = text2.replace(ANY_HOME, "~");
   return text2;
 }
-function pathIn(path18) {
-  const parts = path18.split(/[\\/]+/);
+function pathIn(path19) {
+  const parts = path19.split(/[\\/]+/);
   while (parts.length > 1 && parts.at(-1) === "") parts.pop();
   if (!parts.some((part) => part !== "" && !/^[A-Za-z]:$/.test(part))) return void 0;
   const joined = parts.map((part) => part.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("[\\\\/]+");
-  const escaped = /^\/(?!\/)/.test(path18) ? joined.replace("[\\\\/]+", "\\\\*\\/") : joined;
+  const escaped = /^\/(?!\/)/.test(path19) ? joined.replace("[\\\\/]+", "\\\\*\\/") : joined;
   const url = "(?:(?:file|webpack|webpack-internal):(?:\\\\*\\/){2,3})?";
   return new RegExp(`${url}${escaped}`, /^[A-Za-z]:$/.test(parts[0]) ? "gi" : "g");
 }
@@ -2950,12 +2950,12 @@ function placeOf(error, testFile) {
 }
 function fileOf(raw) {
   if (!raw.startsWith("file://")) return raw;
-  let path18 = raw.slice("file://".length);
+  let path19 = raw.slice("file://".length);
   try {
-    path18 = decodeURIComponent(path18);
+    path19 = decodeURIComponent(path19);
   } catch {
   }
-  return /^\/[A-Za-z]:\//.test(path18) ? path18.slice(1) : path18;
+  return /^\/[A-Za-z]:\//.test(path19) ? path19.slice(1) : path19;
 }
 function fromRoot(place, root) {
   if (place === void 0 || root === void 0 || !Number.isInteger(place.line) || place.line < 1) return void 0;
@@ -2995,14 +2995,14 @@ var init_failure_detail = __esm({
     FRAME = /^\s+at (?:.*? \()?(.+?):(\d+):(\d+)\)?$/;
     FRAME_MAX = 8192;
     firstLine = (text2) => (0, import_node_util.stripVTControlCharacters)(text2).split("\n").map((line) => line.trim()).find((line) => line !== "");
-    normal = (path18) => import_node_path2.posix.normalize(path18.replace(/\\/g, "/")).replace(/^([a-z]):/, (_, drive) => `${drive.toUpperCase()}:`);
+    normal = (path19) => import_node_path2.posix.normalize(path19.replace(/\\/g, "/")).replace(/^([a-z]):/, (_, drive) => `${drive.toUpperCase()}:`);
   }
 });
 
 // src/reporter-core/files-batch.ts
-async function sha256File(path18) {
+async function sha256File(path19) {
   const hash = (0, import_node_crypto2.createHash)("sha256");
-  for await (const part of (0, import_node_fs4.createReadStream)(path18)) hash.update(part);
+  for await (const part of (0, import_node_fs4.createReadStream)(path19)) hash.update(part);
   return hash.digest("hex");
 }
 var import_node_crypto2, import_node_fs4, FILES_BATCH_MAX, DIRECT_BATCH_BYTES, BATCH_PIPELINES, sha256Bytes, BUCKET_CODES;
@@ -4632,10 +4632,10 @@ function platformGet(deps) {
   const token = (deps.loadToken ?? loadToken)();
   if (token === null) throw new NotLoggedInError();
   const doFetch = deps.fetchImpl ?? fetch;
-  return async (path18) => {
+  return async (path19) => {
     let res;
     try {
-      res = await doFetch(`${apiUrl}${path18}`, { headers: { authorization: `Bearer ${token}` } });
+      res = await doFetch(`${apiUrl}${path19}`, { headers: { authorization: `Bearer ${token}` } });
     } catch {
       throw new SyncNetworkError(apiUrl);
     }
@@ -4976,9 +4976,9 @@ var init_attachments = __esm({
 });
 
 // src/importers/allure.ts
-function isFolder(path18) {
+function isFolder(path19) {
   try {
-    return fs11.statSync(path18).isDirectory();
+    return fs11.statSync(path19).isDirectory();
   } catch {
     return false;
   }
@@ -5345,7 +5345,7 @@ var init_xml = __esm({
     init_failure_detail();
     XmlParseError = class extends Error {
       constructor(file, line, detail) {
-        super(`${file}:${line} \u2014 ${detail}`);
+        super(`${printable(file)}:${line} \u2014 ${detail}`);
         this.file = file;
         this.line = line;
         this.name = "XmlParseError";
@@ -5406,23 +5406,28 @@ function specRefOf(test, suite, classname) {
   }
   return classname === "" ? void 0 : classname;
 }
-function executionOf(test, suite) {
-  const stamp = suite?.attrs["timestamp"];
-  if (stamp === void 0 || stamp === "") return void 0;
-  const started = new Date(stamp);
-  if (Number.isNaN(started.getTime())) return void 0;
+function executionOf(test, suite, now) {
   const seconds = Number.parseFloat(test.attrs["time"] ?? "");
-  const durationMs = Number.isFinite(seconds) && seconds >= 0 ? Math.round(seconds * 1e3) : 0;
+  const timed = Number.isFinite(seconds) && seconds >= 0;
+  const durationMs = timed ? Math.round(seconds * 1e3) : 0;
+  const stamp = suite?.attrs["timestamp"];
+  const dated = stamp === void 0 || stamp === "" ? void 0 : new Date(stamp);
+  let started;
+  if (dated !== void 0 && !Number.isNaN(dated.getTime())) started = dated;
+  else if (timed) started = new Date(now.getTime() - durationMs);
+  else return void 0;
+  const finished = new Date(started.getTime() + durationMs);
+  if (Number.isNaN(started.getTime()) || Number.isNaN(finished.getTime())) return void 0;
   return {
     startedAt: started.toISOString(),
-    finishedAt: new Date(started.getTime() + durationMs).toISOString(),
+    finishedAt: finished.toISOString(),
     durationMs,
     // The base format has no reruns. Surefire's `<rerunFailure>` does, and reading it is work for
     // the day somebody asks; reporting 0 says «first attempt», which is true of every case here.
     retry: 0
   };
 }
-function readJUnit(source, file, missing = [], notes = []) {
+function readJUnit(source, file, missing = [], notes = [], now = /* @__PURE__ */ new Date()) {
   const doc = parseXml(source, file);
   const { lexical, real: folder } = reportFolders(file);
   const found = [];
@@ -5436,7 +5441,7 @@ function readJUnit(source, file, missing = [], notes = []) {
     const stated = TOKEN2.exec(playwright?.titles.at(-1) ?? name)?.[1];
     const specRef = specRefOf(test, suite, classname);
     const errorContext = errorTextOf(detail);
-    const execution = executionOf(test, suite);
+    const execution = executionOf(test, suite, now);
     const title = titleOf(classname, name);
     const rkey = resultKey(key.value, 0);
     const files = filesOfTest(test, folder, title, missing, { lexical, resultKey: rkey, notes });
@@ -5486,10 +5491,10 @@ function attemptOf(result, file, ctx) {
       ...typeof at?.file === "string" && typeof at.line === "number" ? { location: { file: at.file, line: at.line, ...typeof at.column === "number" ? { column: at.column } : {} } } : {}
     })),
     steps: steps(result.steps),
-    attachments: (result.attachments ?? []).map(({ name, contentType, path: path18, body }) => ({
+    attachments: (result.attachments ?? []).map(({ name, contentType, path: path19, body }) => ({
       name: name ?? "",
       ...contentType !== void 0 ? { contentType } : {},
-      ...path18 !== void 0 ? { path: path18 } : {},
+      ...path19 !== void 0 ? { path: path19 } : {},
       // Decoded only where the platform would take it (plune-ai/plune#928): a report of screenshots kept as
       // bodies is megabytes of base64 that nothing here will read.
       ...typeof body === "string" && isTextType(contentType) ? { body: Buffer.from(body, "base64") } : {}
@@ -5628,12 +5633,40 @@ function detectFormat(source, file) {
   );
 }
 function readFolder(dir, format) {
-  if (format !== void 0 && format !== "allure") {
-    throw new UnknownFormatError(dir, `this is a folder, and only allure-results is read from one, not ${format}.`);
+  if (format === "playwright-json") {
+    throw new UnknownFormatError(dir, "this is a folder, and only allure-results or JUnit XML files are read from one, not playwright-json.");
   }
   const missing = [];
   const notes = [];
-  return { format: "allure", results: readAllure(dir, missing, notes), missing, notes };
+  if (format === "allure" || format === void 0 && namesIn(dir, RESULT).length > 0) {
+    return { format: "allure", results: readAllure(dir, missing, notes), missing, notes };
+  }
+  const results = [];
+  const skipped = [];
+  let reports = 0;
+  for (const name of namesIn(dir, /\.xml$/)) {
+    const file = path13.join(dir, name);
+    let source;
+    try {
+      source = fs12.readFileSync(file, "utf8");
+    } catch {
+      throw new RunCommandError(`Cannot read ${printable(file)}.`);
+    }
+    if (!looksLikeJUnit(source)) {
+      skipped.push(name);
+      notes.push(`plune: ${printable(file)} is not a JUnit report \u2014 skipped.`);
+      continue;
+    }
+    reports += 1;
+    for (const r of readJUnit(source, file, missing, notes)) results.push(r);
+  }
+  if (reports === 0) {
+    const names = skipped.slice(0, 3).map(printable).join(", ") + (skipped.length > 3 ? ` and ${skipped.length - 3} more` : "");
+    throw new AllureReportError(
+      `${printable(dir)} \u2014 no ${format === void 0 ? "*-result.json files and no " : ""}JUnit XML files in it${skipped.length > 0 ? ` (skipped, not JUnit: ${names})` : ""}, so there is no report to read. Point at the folder an Allure adapter wrote (pytest --alluredir, allure-results), the one Maven or Gradle wrote (target/surefire-reports, build/test-results/test), or at a JUnit or Playwright JSON file.`
+    );
+  }
+  return { format: "junit", results, missing, notes };
 }
 function readReport(source, file, format) {
   const chosen2 = format ?? detectFormat(source, file);
@@ -5643,11 +5676,15 @@ function readReport(source, file, format) {
   if (chosen2 === "junit") return { format: chosen2, results: readJUnit(source, file, missing, notes), missing, notes };
   return { format: chosen2, ...readPlaywrightJson(source, file), missing, notes };
 }
-var IMPORT_FORMATS, UnknownFormatError;
+var fs12, path13, IMPORT_FORMATS, UnknownFormatError;
 var init_importers = __esm({
   "src/importers/index.ts"() {
     "use strict";
     init_cjs_shims();
+    fs12 = __toESM(require("fs"), 1);
+    path13 = __toESM(require("path"), 1);
+    init_run_lifecycle();
+    init_failure_detail();
     init_allure();
     init_junit();
     init_playwright_json();
@@ -5694,9 +5731,9 @@ async function handleRunImport(options) {
   } else {
     let source;
     try {
-      source = fs12.readFileSync(options.file, "utf8");
+      source = fs13.readFileSync(options.file, "utf8");
     } catch {
-      throw new RunCommandError(`Cannot read ${options.file}.`);
+      throw new RunCommandError(`Cannot read ${printable(options.file)}.`);
     }
     read = readReport(source, options.file, options.format);
   }
@@ -5847,12 +5884,12 @@ function describe(result, apiUrl) {
   if (result.runId !== null) lines.push(runUrl2(apiUrl, result.runId));
   return lines;
 }
-var fs12, ImportTimeoutError, NEXT;
+var fs13, ImportTimeoutError, NEXT;
 var init_run_import = __esm({
   "src/cli/commands/run-import.ts"() {
     "use strict";
     init_cjs_shims();
-    fs12 = __toESM(require("fs"), 1);
+    fs13 = __toESM(require("fs"), 1);
     init_session();
     init_failure_detail();
     init_importers();
@@ -5884,10 +5921,10 @@ function isRunResult(v) {
 }
 function handleReport(opts = {}) {
   const cwd = opts.cwd ?? process.cwd();
-  const file = path13.join(cwd, ".plune", "last-run.json");
+  const file = path14.join(cwd, ".plune", "last-run.json");
   let raw;
   try {
-    raw = fs13.readFileSync(file, "utf8");
+    raw = fs14.readFileSync(file, "utf8");
   } catch {
     throw new ReportNotFoundError('No saved run found. Run "plune run" first.');
   }
@@ -5902,13 +5939,13 @@ function handleReport(opts = {}) {
   }
   return parsed;
 }
-var fs13, path13, ReportNotFoundError;
+var fs14, path14, ReportNotFoundError;
 var init_report = __esm({
   "src/cli/commands/report.ts"() {
     "use strict";
     init_cjs_shims();
-    fs13 = __toESM(require("fs"), 1);
-    path13 = __toESM(require("path"), 1);
+    fs14 = __toESM(require("fs"), 1);
+    path14 = __toESM(require("path"), 1);
     ReportNotFoundError = class extends Error {
       code = "NO_SAVED_RUN";
       constructor(message) {
@@ -5978,7 +6015,7 @@ function isRunResult2(v) {
 function loadRunResult(file, label) {
   let raw;
   try {
-    raw = fs14.readFileSync(file, "utf8");
+    raw = fs15.readFileSync(file, "utf8");
   } catch {
     throw new DiffInputError(`Cannot read ${label} run file: ${file}`);
   }
@@ -5998,12 +6035,12 @@ function handleDiff(opts) {
   const current = loadRunResult(opts.currentPath, "current");
   return diffRuns(baseline, current);
 }
-var fs14, DiffInputError;
+var fs15, DiffInputError;
 var init_diff2 = __esm({
   "src/cli/commands/diff.ts"() {
     "use strict";
     init_cjs_shims();
-    fs14 = __toESM(require("fs"), 1);
+    fs15 = __toESM(require("fs"), 1);
     init_diff();
     DiffInputError = class extends Error {
       code = "DIFF_INPUT";
@@ -6128,8 +6165,8 @@ async function runInitWizard(cwd) {
     process.exit(1);
     return;
   }
-  const outputPath = path14.join(cwd, "plune.yaml");
-  if (fs15.existsSync(outputPath)) {
+  const outputPath = path15.join(cwd, "plune.yaml");
+  if (fs16.existsSync(outputPath)) {
     const overwrite = await clack.confirm({
       message: "plune.yaml already exists. Overwrite?"
     });
@@ -6168,18 +6205,18 @@ async function runInitWizard(cwd) {
 `;
   const spin = clack.spinner();
   spin.start("Writing plune.yaml\u2026");
-  fs15.writeFileSync(outputPath, header + "\n" + (0, import_yaml2.stringify)(config), "utf8");
+  fs16.writeFileSync(outputPath, header + "\n" + (0, import_yaml2.stringify)(config), "utf8");
   spin.stop("plune.yaml created!");
   clack.outro("plune.yaml is ready.");
 }
-var clack, fs15, path14, import_yaml2;
+var clack, fs16, path15, import_yaml2;
 var init_wizard = __esm({
   "src/config/init/wizard.ts"() {
     "use strict";
     init_cjs_shims();
     clack = __toESM(require("@clack/prompts"), 1);
-    fs15 = __toESM(require("fs"), 1);
-    path14 = __toESM(require("path"), 1);
+    fs16 = __toESM(require("fs"), 1);
+    path15 = __toESM(require("path"), 1);
     import_yaml2 = require("yaml");
     init_errors();
   }
@@ -6187,21 +6224,21 @@ var init_wizard = __esm({
 
 // src/cli/templates/index.ts
 function writeTemplateFile(cwd, rel, content, force) {
-  const target = path15.join(cwd, rel);
-  if (!force && fs16.existsSync(target)) {
+  const target = path16.join(cwd, rel);
+  if (!force && fs17.existsSync(target)) {
     return "skipped";
   }
-  fs16.mkdirSync(path15.dirname(target), { recursive: true });
-  fs16.writeFileSync(target, content, "utf8");
+  fs17.mkdirSync(path16.dirname(target), { recursive: true });
+  fs17.writeFileSync(target, content, "utf8");
   return "written";
 }
-var fs16, path15, ENV_EXAMPLE_TPL, EXAMPLE_JSONL_TPL, PLUNE_YAML_TPL;
+var fs17, path16, ENV_EXAMPLE_TPL, EXAMPLE_JSONL_TPL, PLUNE_YAML_TPL;
 var init_templates = __esm({
   "src/cli/templates/index.ts"() {
     "use strict";
     init_cjs_shims();
-    fs16 = __toESM(require("fs"), 1);
-    path15 = __toESM(require("path"), 1);
+    fs17 = __toESM(require("fs"), 1);
+    path16 = __toESM(require("path"), 1);
     ENV_EXAMPLE_TPL = `# Copy this file to .env and replace the placeholders with your real keys.
 # .env is gitignored; .env.example is safe to commit.
 # Plune reads whichever key matches your configured provider.
@@ -6381,14 +6418,14 @@ var init_logout = __esm({
 
 // src/cli/commands/cairn-artifact.ts
 async function findLatestCairnRun(runsDir = "runs") {
-  const entries = await fs17.readdir(runsDir, { withFileTypes: true }).catch(() => null);
+  const entries = await fs18.readdir(runsDir, { withFileTypes: true }).catch(() => null);
   if (entries === null) throw new NoCairnRunsError(runsDir);
   let newest;
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
-    const dir = path16.join(runsDir, entry.name);
+    const dir = path17.join(runsDir, entry.name);
     try {
-      const report = await fs17.lstat(path16.join(dir, "report.json"));
+      const report = await fs18.lstat(path17.join(dir, "report.json"));
       if (!report.isFile()) continue;
       if (newest === void 0 || report.mtimeMs > newest.at) {
         newest = { dir, at: report.mtimeMs };
@@ -6401,13 +6438,13 @@ async function findLatestCairnRun(runsDir = "runs") {
 }
 async function readJson(file) {
   try {
-    return JSON.parse(await fs17.readFile(file, "utf8"));
+    return JSON.parse(await fs18.readFile(file, "utf8"));
   } catch {
     return void 0;
   }
 }
 async function defaultReadEvidence(dir) {
-  const raw = await readJson(path16.join(dir, "api-evidence.json"));
+  const raw = await readJson(path17.join(dir, "api-evidence.json"));
   if (!Array.isArray(raw)) return void 0;
   return raw.map((r) => {
     const rec = asRecord(r);
@@ -6450,7 +6487,7 @@ function casesFromApi(report, verdicts) {
   });
 }
 async function readCairnRun(dir, deps = {}) {
-  const raw = await readJson(path16.join(dir, "report.json"));
+  const raw = await readJson(path17.join(dir, "report.json"));
   if (raw === void 0) throw new CairnRunNotFoundError(dir);
   const report = asRecord(raw);
   if (report["schemaVersion"] !== SUPPORTED_ARTIFACT_VERSION) {
@@ -6480,20 +6517,20 @@ async function readCairnRun(dir, deps = {}) {
   return {
     schemaVersion: INGEST_SCHEMA_VERSION,
     run: {
-      runId: str(report["runId"], path16.basename(dir)),
+      runId: str(report["runId"], path17.basename(dir)),
       mode,
       target: str(report["url"], "unknown")
     },
     cases
   };
 }
-var fs17, path16, SUPPORTED_ARTIFACT_VERSION, INGEST_SCHEMA_VERSION, NoCairnRunsError, CairnRunNotFoundError, CairnRunVersionError, CairnRunPartialError, CairnEvidenceAmbiguousError, asRecord, str;
+var fs18, path17, SUPPORTED_ARTIFACT_VERSION, INGEST_SCHEMA_VERSION, NoCairnRunsError, CairnRunNotFoundError, CairnRunVersionError, CairnRunPartialError, CairnEvidenceAmbiguousError, asRecord, str;
 var init_cairn_artifact = __esm({
   "src/cli/commands/cairn-artifact.ts"() {
     "use strict";
     init_cjs_shims();
-    fs17 = __toESM(require("fs/promises"), 1);
-    path16 = __toESM(require("path"), 1);
+    fs18 = __toESM(require("fs/promises"), 1);
+    path17 = __toESM(require("path"), 1);
     SUPPORTED_ARTIFACT_VERSION = 1;
     INGEST_SCHEMA_VERSION = 1;
     NoCairnRunsError = class extends Error {
@@ -6565,7 +6602,7 @@ async function handleIngest(deps) {
   const doFetch = deps.fetchImpl ?? fetch;
   const endpoint = `${apiUrl}/v1/ingest/cairn`;
   const job = new JobReporter(doFetch, apiUrl, token, "ingest");
-  await job.open(path17.basename(path17.resolve(dir)), payload.cases.length);
+  await job.open(path18.basename(path18.resolve(dir)), payload.cases.length);
   try {
     const result = await upload();
     await job.uploaded({ subjectId: result.runId || void 0 });
@@ -6624,12 +6661,12 @@ function formatIngestResult(r) {
   return `${lines.join("\n")}
 `;
 }
-var path17, IngestNotLoggedInError, IngestTokenRejectedError, IngestNetworkError, IngestHttpError;
+var path18, IngestNotLoggedInError, IngestTokenRejectedError, IngestNetworkError, IngestHttpError;
 var init_ingest = __esm({
   "src/cli/commands/ingest.ts"() {
     "use strict";
     init_cjs_shims();
-    path17 = __toESM(require("path"), 1);
+    path18 = __toESM(require("path"), 1);
     init_api_url();
     init_credentials();
     init_cairn_artifact();
@@ -7577,7 +7614,13 @@ ${missed.map((m) => `  - ${m}`).join("\n")}
       await failRunCommand(err, verboseOf(command));
     }
   });
-  runCommand.command("import").argument("<file>", "A JUnit XML or Playwright JSON report, or an Allure allure-results folder").description("Turn a report another runner wrote into a run in Plune \u2014 no provider key needed").option("--format <fmt>", "junit | playwright-json | allure; detected from the file (a folder is allure) when omitted").option("--key <externalKey>", "The key several jobs share so their reports land in one run").option("--name <text>", "What to call the run in the list (default: the folder name, the time and where it ran; PLUNE_RUN_TITLE sets it too)").option("--create", "Offer tests nothing matched to the review queue", false).option(
+  runCommand.command("import").argument(
+    "<file>",
+    "A JUnit XML or Playwright JSON report, a folder of JUnit XML files (target/surefire-reports, build/test-results/test), or an Allure allure-results folder"
+  ).description("Turn a report another runner wrote into a run in Plune \u2014 no provider key needed").option(
+    "--format <fmt>",
+    "junit | playwright-json | allure; detected when omitted (a folder with a *-result.json is allure, any other folder is its *.xml files as junit)"
+  ).option("--key <externalKey>", "The key several jobs share so their reports land in one run").option("--name <text>", "What to call the run in the list (default: the folder name, the time and where it ran; PLUNE_RUN_TITLE sets it too)").option("--create", "Offer tests nothing matched to the review queue", false).option(
     "--fail-on-missing-attachments",
     "Exit 1 when a file the report names ([[ATTACHMENT|path]] in JUnit, a source in allure-results) is not there; the results are sent either way",
     false
@@ -7707,10 +7750,10 @@ ${missed.map((m) => `  - ${m}`).join("\n")}
     const { handleLogin: handleLogin2, reportLoginFailure: reportLoginFailure2 } = await Promise.resolve().then(() => (init_login(), login_exports));
     try {
       const token = options.token ?? await readTokenFromStdin();
-      const { path: path18, verified } = await handleLogin2({ token, skipVerify: options.skipVerify });
+      const { path: path19, verified } = await handleLogin2({ token, skipVerify: options.skipVerify });
       process.stdout.write(
-        verified ? `Logged in. Token checked against the API and saved to ${path18}
-` : `Token saved to ${path18} WITHOUT being checked (--skip-verify).
+        verified ? `Logged in. Token checked against the API and saved to ${path19}
+` : `Token saved to ${path19} WITHOUT being checked (--skip-verify).
 `
       );
     } catch (err) {
@@ -7727,9 +7770,9 @@ ${missed.map((m) => `  - ${m}`).join("\n")}
     const verbose = command.optsWithGlobals().verbose === true;
     const { handleLogout: handleLogout2 } = await Promise.resolve().then(() => (init_logout(), logout_exports));
     try {
-      const { removed, path: path18 } = handleLogout2();
+      const { removed, path: path19 } = handleLogout2();
       process.stdout.write(
-        removed ? `Logged out. Removed ${path18}
+        removed ? `Logged out. Removed ${path19}
 ` : "Not logged in \u2014 nothing to remove.\n"
       );
     } catch (err) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plune-ai/cli",
-  "version": "0.31.0",
+  "version": "0.32.1",
   "description": "AI-powered assertion testing for LLM apps — write assertions, run them against any provider, get a pass/fail report (local, CI, or diff).",
   "keywords": [
     "ai",