@plune-ai/cli 0.22.0 → 0.24.0

package/README.md

@@ -119,7 +119,7 @@ the last resort, used only when `PLUNE_TOKEN` is set nowhere else. Nothing write
 | `plune init` | Scaffold `plune.yaml`, a sample dataset, and `.env.example`. Flags: `--yes` (non-interactive), `--force`. |
 | `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. |
+| `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. |
 | `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), `--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 4](#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), `--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. |
@@ -324,8 +324,13 @@ without closing.
 
 ### Many screenshots: upload concurrency and retries
 
-Every file is its own request, so a report with thousands of screenshots is bound by the round trip, not
-by bandwidth. Files go four at a time by default; raise it on a runner with a slow link:
+Files go to Plune up to 100 to a request: `uploads-batch` announces them (with the SHA-256 of each, read as a stream,
+so a file the platform already has is answered `exists` and is not sent again), the bytes go straight to your bucket
+(or, for a project without one, 100 files or 6 MiB at a time through `direct-batch`), and `complete-batch` confirms
+them. Every file has its own verdict: one that is refused is reported and the rest of its request goes through. A
+report of 2760 screenshots is about 56 requests to Plune instead of 5500. The bytes themselves still go one request each,
+so the PUTs to a bucket are bound by the round trip, not by bandwidth: four at a time by default, raise it on a runner
+with a slow link:
 
 ```bash
 PLUNE_UPLOAD_CONCURRENCY=16 plune run import ./playwright.json     # 1 to 32, default 4
@@ -336,11 +341,14 @@ When the platform answers 429 with a `Retry-After` (seconds or an HTTP date, nev
 the request is tried again after that time plus up to half as much, and every other request of the import
 waits through the same pause. `PLUNE_UPLOAD_RETRIES` (0 to 20, default 6) says how many times; a 429 that
 names no time is the quota and is not retried. A platform that is down (a 5xx or no answer) is still tried
-twice (three times for a bucket). A file that stays refused is reported without it, never fails the import,
-and is counted in the line printed before the summary:
-`plune: files — 2758 uploaded, 0 skipped, 14 retried, 0 dropped, in 41.2 s (16 at once)`.
-A value outside the range is ignored with a warning, and the default is used. The Playwright reporter reads
-the same variables.
+twice (three times for a bucket). A 429 on a whole request waits the same way; a file that the bucket did not
+answer for at `complete` is confirmed again, on its own. A file that stays refused is reported without it, never fails
+the import, and is counted in the line printed before the summary:
+`plune: files — 2758 uploaded, 0 skipped, 0 already there (skipped), 14 retried, 0 dropped, in 41.2 s (16 at once, 56 request(s) to Plune)`.
+`already there` are the files Plune had from an earlier import of the same report (same result, name, type and bytes):
+none of them is sent again. Against a platform older than the bulk routes (it answers 404 to `uploads-batch`) the CLI
+sends one request per file, as before; it decides by that answer, not by a version. A value outside the range is
+ignored with a warning, and the default is used. The Playwright reporter reads the same variables.
 
 ### When a test is deleted
 

package/dist/cli.cjs

@@ -2789,6 +2789,34 @@ var init_failure_detail = __esm({
   }
 });
 
+// src/reporter-core/files-batch.ts
+async function sha256File(path17) {
+  const hash = (0, import_node_crypto2.createHash)("sha256");
+  for await (const part of (0, import_node_fs4.createReadStream)(path17)) 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;
+var init_files_batch = __esm({
+  "src/reporter-core/files-batch.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_node_crypto2 = require("crypto");
+    import_node_fs4 = require("fs");
+    FILES_BATCH_MAX = 100;
+    DIRECT_BATCH_BYTES = 6 * 1024 * 1024;
+    BATCH_PIPELINES = 2;
+    sha256Bytes = (bytes) => (0, import_node_crypto2.createHash)("sha256").update(bytes).digest("hex");
+    BUCKET_CODES = /* @__PURE__ */ new Set([
+      "bucket_unreachable",
+      "not_connected",
+      "platform_not_configured",
+      "upload_expired",
+      "file_mismatch",
+      "file_missing"
+    ]);
+  }
+});
+
 // src/reporter-core/session.ts
 function nameOf(file) {
   const own = file.name.split(/[\\/]/).pop()?.trim() || (file.path === void 0 ? "" : (0, import_node_path3.basename)(file.path));
@@ -2840,7 +2868,7 @@ function tally(counts, noun) {
 }
 function boundKey(key) {
   if (key.value.length <= KEY_MAX) return key;
-  const digest = (0, import_node_crypto2.createHash)("sha256").update(key.value).digest("hex").slice(0, 16);
+  const digest = (0, import_node_crypto3.createHash)("sha256").update(key.value).digest("hex").slice(0, 16);
   let head = key.value.slice(0, KEY_MAX - digest.length - 1);
   if (/[\uD800-\uDBFF]$/.test(head)) head = head.slice(0, -1);
   return { ...key, value: `${head}#${digest}` };
@@ -2892,7 +2920,7 @@ async function startRun(passed, declared2) {
 `));
   const fallbackPath = cfg.fallbackPath ?? DEFAULT_FALLBACK_PATH;
   const externalKey = cfg.externalKey ?? null;
-  const sessionMarker = (0, import_node_crypto2.randomUUID)();
+  const sessionMarker = (0, import_node_crypto3.randomUUID)();
   const batchSize = Math.min(cfg.batchSize ?? BATCH_DEFAULT, BATCH_MAX);
   const offerDiscovered = cfg.offerDiscovered ?? false;
   const token = cfg.token ?? loadToken() ?? "";
@@ -2900,6 +2928,9 @@ async function startRun(passed, declared2) {
   const uploadRetries = Math.min(Math.max(Math.floor(cfg.uploadRetries ?? UPLOAD_RETRIES.default), UPLOAD_RETRIES.min), UPLOAD_RETRIES.max);
   let retried = 0;
   let uploadMs = 0;
+  let requests = 0;
+  let existed = 0;
+  let batchMissing = false;
   const client = createClient({
     apiUrl: resolveApiUrl(cfg.apiUrl),
     token,
@@ -3083,6 +3114,7 @@ async function startRun(passed, declared2) {
     else log(`plune: ${KINDS[kind].label} "${name}" not uploaded \u2014 ${SKIPPED[why]}.`);
   }
   function ask(job, size) {
+    requests += 1;
     return client.post(`/v1/results/${encodeURIComponent(job.id)}/files/uploads`, {
       files: [{ name: job.name, contentType: job.type, size }]
     }, uploadRetries);
@@ -3117,13 +3149,14 @@ async function startRun(passed, declared2) {
     if (job.body !== void 0) bytes = job.body;
     else {
       try {
-        bytes = await import_node_fs4.promises.readFile(job.path);
+        bytes = await import_node_fs5.promises.readFile(job.path);
       } catch {
         return skip(kind, job.name, "missing");
       }
     }
     const refusal = kind === "text" ? textRefusal(bytes) : void 0;
     if (refusal !== void 0) return skip(kind, job.name, refusal);
+    requests += 1;
     const out = await client.upload(
       `/v1/results/${encodeURIComponent(job.id)}/files?name=${encodeURIComponent(job.name)}`,
       bytes,
@@ -3146,6 +3179,7 @@ async function startRun(passed, declared2) {
       if (fresh === void 0) return failedToBucket(job, "bad_answer");
       link = fresh;
     }
+    requests += 1;
     const done2 = await client.post(`/v1/files/${encodeURIComponent(link.id)}/complete`, {}, uploadRetries);
     if (!done2.ok) return failedToBucket(job, codeOf2(done2));
     countsOf(job.kind).uploaded += 1;
@@ -3170,7 +3204,7 @@ async function startRun(passed, declared2) {
     else if (job.path === void 0) return void skip(kind, job.name, "missing");
     else {
       try {
-        size = (await import_node_fs4.promises.stat(job.path)).size;
+        size = (await import_node_fs5.promises.stat(job.path)).size;
       } catch {
         return void skip(kind, job.name, "missing");
       }
@@ -3206,6 +3240,245 @@ async function startRun(passed, declared2) {
     }
     return () => uploadToBucket(job, size, link);
   }
+  async function uploadEach(jobs) {
+    const byResult = /* @__PURE__ */ new Map();
+    for (const job of jobs) byResult.set(job.id, [...byResult.get(job.id) ?? [], job]);
+    await Promise.all(
+      [...byResult.values()].map(async (group) => {
+        const work = [];
+        for (const job of group) {
+          const act = await plan(job);
+          if (act !== void 0) work.push(gated(act));
+        }
+        await Promise.all(work);
+      })
+    );
+  }
+  async function measure(job) {
+    let size;
+    if (job.body !== void 0) size = job.body.length;
+    else if (job.path === void 0) return void skip(job.kind, job.name, "missing");
+    else {
+      try {
+        size = (await import_node_fs5.promises.stat(job.path)).size;
+      } catch {
+        return void skip(job.kind, job.name, "missing");
+      }
+    }
+    if (size === 0) return void skip(job.kind, job.name, "empty");
+    return size;
+  }
+  const routeMissing = (out) => !out.ok && out.status === 404 && out.detail === "" && out.code === void 0;
+  function takeRoom(job) {
+    if (job.kind === "file") {
+      skip(job.kind, job.name, "noStorage");
+      return false;
+    }
+    const roomKey = `${job.id}/${job.kind}`;
+    const left = rooms.get(roomKey) ?? KINDS[job.kind].room;
+    if (left === 0) {
+      skip(job.kind, job.name, KINDS[job.kind].limit);
+      return false;
+    }
+    rooms.set(roomKey, left - 1);
+    return true;
+  }
+  function refusedItem(job, size, item) {
+    const code = item.code ?? "refused";
+    if (code === "duplicate") existed += 1;
+    else if (code === "no_storage") skip(job.kind, job.name, refusedHere(job, size) ?? "noStorage");
+    else if (code === "too_many_files") skip(job.kind, job.name, KINDS[job.kind].limit);
+    else if (BUCKET_CODES.has(code)) failedToBucket(job, code);
+    else failed(job, code);
+  }
+  const itemPause = (round) => new Promise((r) => setTimeout(r, Math.min(250 * 2 ** round, 4e3)));
+  async function batchOf(jobs) {
+    if (batchMissing) return uploadEach(jobs);
+    const sized = [];
+    for (const job of jobs) {
+      const size = await measure(job);
+      if (size === void 0) continue;
+      try {
+        sized.push({ job, size, sha256: job.body !== void 0 ? sha256Bytes(job.body) : await sha256File(job.path) });
+      } catch {
+        skip(job.kind, job.name, "missing");
+      }
+    }
+    if (sized.length === 0) return;
+    const announced = await gated(() => {
+      requests += 1;
+      return client.post(
+        "/v1/files/uploads-batch",
+        { items: sized.map((s) => ({ resultId: s.job.id, name: s.job.name, contentType: s.job.type, size: s.size, sha256: s.sha256 })) },
+        uploadRetries
+      );
+    });
+    if (routeMissing(announced)) {
+      batchMissing = true;
+      return uploadEach(sized.map((s) => s.job));
+    }
+    const verdicts = announced.ok ? announced.body?.items : void 0;
+    if (!announced.ok || !Array.isArray(verdicts) || verdicts.length !== sized.length) {
+      for (const s of sized) {
+        if (announced.ok) failed(s.job, "bad_answer");
+        else if (announced.code !== void 0) failedToBucket(s.job, announced.code);
+        else failed(s.job, announced.detail || announced.kind);
+      }
+      return;
+    }
+    const puts = [];
+    const directs = [];
+    sized.forEach((s, i) => {
+      const v = verdicts[i] ?? {};
+      if (v.status === "exists") existed += 1;
+      else if (v.status === "direct") {
+        if (takeRoom(s.job)) directs.push(s);
+      } else if (v.status === "upload") {
+        const link = linkOf(v);
+        if (link === void 0) return failed(s.job, "bad_answer");
+        if (!bucketSeen) {
+          bucketSeen = true;
+          log(BUCKET_FOUND);
+        }
+        puts.push({ s, link });
+      } else if (v.status === "refused") refusedItem(s.job, s.size, v);
+      else failed(s.job, "bad_answer");
+    });
+    const toComplete = [];
+    await Promise.all(
+      puts.map(
+        ({ s, link: first }) => gated(async () => {
+          const source = s.job.body !== void 0 ? { body: s.job.body } : { path: s.job.path, size: s.size };
+          let link = first;
+          for (let renewed = false; ; ) {
+            const put = await client.put(link.url, link.headers, source);
+            if (put.ok) break;
+            if (put.status !== 403 || renewed) return failedToBucket(s.job, put.code);
+            renewed = true;
+            requests += 1;
+            const again = await client.post(
+              "/v1/files/uploads-batch",
+              { items: [{ resultId: s.job.id, name: s.job.name, contentType: s.job.type, size: s.size, sha256: s.sha256 }] },
+              uploadRetries
+            );
+            const fresh = again.ok ? linkOf(again.body?.items?.[0]) : void 0;
+            if (fresh === void 0) return failedToBucket(s.job, again.ok ? "bad_answer" : codeOf2(again));
+            link = fresh;
+          }
+          toComplete.push({ job: s.job, id: link.id });
+        })
+      )
+    );
+    await complete(toComplete);
+    await sendDirect(directs);
+  }
+  async function complete(items) {
+    for (let round = 0; items.length > 0; round += 1) {
+      const out = await gated(() => {
+        requests += 1;
+        return client.post("/v1/files/complete-batch", { ids: items.map((i) => i.id) }, uploadRetries);
+      });
+      if (routeMissing(out)) {
+        await Promise.all(
+          items.map(
+            (i) => gated(async () => {
+              requests += 1;
+              const one = await client.post(`/v1/files/${encodeURIComponent(i.id)}/complete`, {}, uploadRetries);
+              if (one.ok) countsOf(i.job.kind).uploaded += 1;
+              else failedToBucket(i.job, codeOf2(one));
+            })
+          )
+        );
+        return;
+      }
+      const verdicts = out.ok ? out.body?.items : void 0;
+      if (!out.ok || !Array.isArray(verdicts) || verdicts.length !== items.length) {
+        for (const i of items) failedToBucket(i.job, out.ok ? "bad_answer" : codeOf2(out));
+        return;
+      }
+      const again = [];
+      items.forEach((i, at) => {
+        const v = verdicts[at] ?? {};
+        if (v.status === "ready") countsOf(i.job.kind).uploaded += 1;
+        else if (v.retryable === true && round < Math.min(uploadRetries, 3)) again.push(i);
+        else refusedItem(i.job, 0, v.status === "refused" ? v : { code: "bad_answer" });
+      });
+      items = again;
+      if (items.length > 0) {
+        retried += items.length;
+        await itemPause(round);
+      }
+    }
+  }
+  async function sendDirect(items) {
+    const groups = [];
+    let bytes = 0;
+    for (const item of items) {
+      const group = groups[groups.length - 1];
+      if (group === void 0 || group.length >= FILES_BATCH_MAX || bytes + item.size > DIRECT_BATCH_BYTES) {
+        groups.push([item]);
+        bytes = item.size;
+      } else {
+        group.push(item);
+        bytes += item.size;
+      }
+    }
+    for (const group of groups) {
+      const body = [];
+      const sent = [];
+      for (const { job, size } of group) {
+        const { kind } = job;
+        if (size > KINDS[kind].bytes) {
+          skip(kind, job.name, KINDS[kind].size);
+          continue;
+        }
+        let data;
+        try {
+          data = job.body ?? await import_node_fs5.promises.readFile(job.path);
+        } catch {
+          skip(kind, job.name, "missing");
+          continue;
+        }
+        const refusal = kind === "text" ? textRefusal(data) : void 0;
+        if (refusal !== void 0) {
+          skip(kind, job.name, refusal);
+          continue;
+        }
+        body.push({ resultId: job.id, name: job.name, contentType: job.type, data: data.toString("base64") });
+        sent.push({ job, size });
+      }
+      if (body.length === 0) continue;
+      const out = await gated(() => {
+        requests += 1;
+        return client.post("/v1/files/direct-batch", { items: body }, uploadRetries);
+      });
+      if (routeMissing(out)) {
+        batchMissing = true;
+        for (const { job, size } of sent) await gated(() => uploadDirect(job, size));
+        continue;
+      }
+      const verdicts = out.ok ? out.body?.items : void 0;
+      if (!out.ok || !Array.isArray(verdicts) || verdicts.length !== sent.length) {
+        for (const { job } of sent) failed(job, out.ok ? "bad_answer" : out.detail || out.kind);
+        continue;
+      }
+      sent.forEach(({ job }, i) => {
+        const v = verdicts[i] ?? {};
+        if (v.status === "stored") countsOf(job.kind).uploaded += 1;
+        else if (v.status === "exists") existed += 1;
+        else refusedItem(job, 0, v.status === "refused" ? v : { code: "bad_answer" });
+      });
+    }
+  }
+  async function uploadBatched(jobs) {
+    const batches = chunk(jobs, FILES_BATCH_MAX);
+    let next = 0;
+    await Promise.all(
+      Array.from({ length: Math.min(BATCH_PIPELINES, batches.length) }, async () => {
+        for (let at = next++; at < batches.length; at = next++) await batchOf(batches[at]);
+      })
+    );
+  }
   async function upload(items, filesByKey) {
     if (filesByKey.size === 0 || !Array.isArray(items)) return;
     const jobs = [];
@@ -3231,18 +3504,8 @@ async function startRun(passed, declared2) {
       }
     }
     const started = Date.now();
-    const byResult = /* @__PURE__ */ new Map();
-    for (const job of jobs) byResult.set(job.id, [...byResult.get(job.id) ?? [], job]);
-    await Promise.all(
-      [...byResult.values()].map(async (group) => {
-        const work = [];
-        for (const job of group) {
-          const act = await plan(job);
-          if (act !== void 0) work.push(gated(act));
-        }
-        await Promise.all(work);
-      })
-    );
+    if (batchMissing) await uploadEach(jobs);
+    else await uploadBatched(jobs);
     uploadMs += Date.now() - started;
   }
   async function flush() {
@@ -3338,9 +3601,9 @@ async function startRun(passed, declared2) {
     if (shortened.size > 0) parts.push(`${shortened.size} test name(s) shortened to fit a key`);
     const files = [stats.screenshots, stats.textFiles, stats.otherFiles];
     const total = (what) => files.reduce((n, counts) => n + counts[what], 0);
-    if (total("uploaded") + total("skipped") + total("failed") > 0) {
+    if (total("uploaded") + total("skipped") + total("failed") + existed > 0) {
       log(
-        `plune: files \u2014 ${total("uploaded")} uploaded, ${total("skipped")} skipped, ${retried} retried, ${total("failed")} dropped, in ${(uploadMs / 1e3).toFixed(1)} s (${uploadsAtOnce} at once)`
+        `plune: files \u2014 ${total("uploaded")} uploaded, ${total("skipped")} skipped, ${existed} already there (skipped), ${retried} retried, ${total("failed")} dropped, in ${(uploadMs / 1e3).toFixed(1)} s (${uploadsAtOnce} at once, ${requests} request(s) to Plune)`
       );
     }
     log(`plune: ${parts.join(" \xB7 ")}`);
@@ -3397,13 +3660,13 @@ async function startRun(passed, declared2) {
     }
   };
 }
-var import_node_crypto2, import_node_fs4, import_node_path3, import_node_util2, RESOLVE_CHUNK, BATCH_MAX, DISCOVER_MAX, BATCH_DEFAULT, EXPECTED_MAX, KEY_MAX, TITLE_MAX, COUNTED, SCREENSHOT_TYPES, SCREENSHOT_BYTES, SCREENSHOTS_PER_RESULT, TEXT_BYTES, TEXTS_PER_RESULT, UTF8, TYPE_BY_EXTENSION, METADATA_TYPE2, NAME_MAX, SKIPPED, BUCKET_FOUND, KINDS, codeOf2, BATCH_BYTES, ENVELOPE_BYTES;
+var import_node_crypto3, import_node_fs5, import_node_path3, import_node_util2, RESOLVE_CHUNK, BATCH_MAX, DISCOVER_MAX, BATCH_DEFAULT, EXPECTED_MAX, KEY_MAX, TITLE_MAX, COUNTED, SCREENSHOT_TYPES, SCREENSHOT_BYTES, SCREENSHOTS_PER_RESULT, TEXT_BYTES, TEXTS_PER_RESULT, UTF8, TYPE_BY_EXTENSION, METADATA_TYPE2, NAME_MAX, SKIPPED, BUCKET_FOUND, KINDS, codeOf2, BATCH_BYTES, ENVELOPE_BYTES;
 var init_session = __esm({
   "src/reporter-core/session.ts"() {
     "use strict";
     init_cjs_shims();
-    import_node_crypto2 = require("crypto");
-    import_node_fs4 = require("fs");
+    import_node_crypto3 = require("crypto");
+    import_node_fs5 = require("fs");
     import_node_path3 = require("path");
     import_node_util2 = require("util");
     init_api_url();
@@ -3411,6 +3674,7 @@ var init_session = __esm({
     init_client();
     init_env2();
     init_failure_detail();
+    init_files_batch();
     init_fallback();
     RESOLVE_CHUNK = 500;
     BATCH_MAX = 500;
@@ -3822,12 +4086,18 @@ async function handleSync(deps = {}) {
   const run = readRun(cwd, deps.file);
   const doFetch = deps.fetchImpl ?? fetch;
   const endpoint = `${apiUrl}/v1/runs`;
+  const payload = JSON.stringify(run);
+  const idempotencyKey = (0, import_node_crypto4.createHash)("sha256").update(payload).digest("hex");
   let res;
   try {
     res = await doFetch(endpoint, {
       method: "POST",
-      headers: { "content-type": "application/json", authorization: `Bearer ${token}` },
-      body: JSON.stringify(run)
+      headers: {
+        "content-type": "application/json",
+        authorization: `Bearer ${token}`,
+        "idempotency-key": idempotencyKey
+      },
+      body: payload
     });
   } catch {
     throw new SyncNetworkError(apiUrl);
@@ -3863,11 +4133,12 @@ function reportSyncFailure(err, write) {
   }
   return null;
 }
-var fs8, path9, NotLoggedInError, TokenRejectedError, SyncFileError, SyncNetworkError, SyncHttpError;
+var import_node_crypto4, fs8, path9, NotLoggedInError, TokenRejectedError, SyncFileError, SyncNetworkError, SyncHttpError;
 var init_sync = __esm({
   "src/cli/commands/sync.ts"() {
     "use strict";
     init_cjs_shims();
+    import_node_crypto4 = require("crypto");
     fs8 = __toESM(require("fs"), 1);
     path9 = __toESM(require("path"), 1);
     init_run_result_schema();
@@ -4878,7 +5149,7 @@ function readPlaywrightJson(source, file) {
   const { config, suites } = parsed;
   const rootDir = typeof config?.rootDir === "string" ? config.rootDir : void 0;
   const buildHref = config?.metadata?.ci?.buildHref;
-  const repoRoot = rootDir !== void 0 && (0, import_node_fs5.existsSync)(rootDir) ? repoRootOf(rootDir) : void 0;
+  const repoRoot = rootDir !== void 0 && (0, import_node_fs6.existsSync)(rootDir) ? repoRootOf(rootDir) : void 0;
   const ctx = {
     ...rootDir !== void 0 ? { rootDir } : {},
     ...repoRoot !== void 0 ? { repoRoot } : {},
@@ -4897,12 +5168,12 @@ function readPlaywrightJson(source, file) {
 function looksLikePlaywrightJson(source) {
   return /^\s*\{/.test(source) && source.includes('"suites"');
 }
-var import_node_fs5, SOURCE3, TOKEN3, NOT_FAILED, JsonReportError;
+var import_node_fs6, SOURCE3, TOKEN3, NOT_FAILED, JsonReportError;
 var init_playwright_json = __esm({
   "src/importers/playwright-json.ts"() {
     "use strict";
     init_cjs_shims();
-    import_node_fs5 = require("fs");
+    import_node_fs6 = require("fs");
     init_failure_detail();
     init_result_key();
     SOURCE3 = "playwright";
@@ -5099,7 +5370,10 @@ function describe(result, apiUrl) {
     );
   }
   if (result.offered > 0) {
-    lines.push(`${result.offered} unknown test(s) offered to the review queue.`);
+    const source = result.format === "playwright-json" ? "playwright" : result.format;
+    lines.push(
+      `${result.offered} unknown test(s) offered to the review queue. They wait there for a decision and do not count on the run until approved. To skip review for this source, add \`${source}\` under Settings \u2192 Trusted sources.`
+    );
   } else if (result.unresolved > 0 && result.created === 0 && !result.offering) {
     lines.push("Nothing was offered to the review queue \u2014 pass --create to propose the unmatched tests.");
   } else if (result.unresolved > 0 && result.created === 0 && result.unoffered === 0) {
@@ -5930,11 +6204,11 @@ module.exports = __toCommonJS(cli_exports);
 init_cjs_shims();
 init_api_url();
 var import_commander = require("commander");
-var import_node_fs6 = require("fs");
+var import_node_fs7 = require("fs");
 var import_node_path4 = require("path");
 var import_node_url = require("url");
 var __dirname = (0, import_node_path4.dirname)((0, import_node_url.fileURLToPath)(importMetaUrl));
-var pkg = JSON.parse((0, import_node_fs6.readFileSync)((0, import_node_path4.join)(__dirname, "..", "package.json"), "utf-8"));
+var pkg = JSON.parse((0, import_node_fs7.readFileSync)((0, import_node_path4.join)(__dirname, "..", "package.json"), "utf-8"));
 function toFormat(s) {
   return s === "json" || s === "markdown" ? s : "console";
 }
@@ -5943,7 +6217,7 @@ function shouldColor(outputPath) {
 }
 function writeReport(text2, outputPath) {
   if (outputPath !== void 0) {
-    (0, import_node_fs6.writeFileSync)(outputPath, text2);
+    (0, import_node_fs7.writeFileSync)(outputPath, text2);
   } else {
     process.stdout.write(text2 + "\n");
   }
@@ -6170,7 +6444,7 @@ function createProgram() {
     false
   ).option(
     "--upload-concurrency <n>",
-    "Files uploaded at once, 1 to 32 (default 4; PLUNE_UPLOAD_CONCURRENCY sets it too). A 429 is retried PLUNE_UPLOAD_RETRIES times (default 6)",
+    "File uploads in flight at once, 1 to 32 (default 4; PLUNE_UPLOAD_CONCURRENCY sets it too). Files are announced and confirmed up to 100 to a request; a 429 is retried PLUNE_UPLOAD_RETRIES times (default 6)",
     (v) => {
       if (!/^\d+$/.test(v) || Number(v) < 1 || Number(v) > 32) throw new import_commander.InvalidArgumentError("a whole number from 1 to 32.");
       return Number(v);
@@ -6442,7 +6716,7 @@ function isMainModule() {
   const entry = process.argv[1];
   if (entry === void 0) return false;
   try {
-    return (0, import_node_fs6.realpathSync)(entry) === (0, import_node_fs6.realpathSync)((0, import_node_url.fileURLToPath)(importMetaUrl));
+    return (0, import_node_fs7.realpathSync)(entry) === (0, import_node_fs7.realpathSync)((0, import_node_url.fileURLToPath)(importMetaUrl));
   } catch {
     return false;
   }

package/dist/index.cjs

@@ -1610,6 +1610,7 @@ async function handleRun(options, depsFactory) {
 }
 
 // src/cli/commands/sync.ts
+var import_node_crypto2 = require("crypto");
 var fs6 = __toESM(require("fs"), 1);
 var path5 = __toESM(require("path"), 1);
 
@@ -1794,12 +1795,18 @@ async function handleSync(deps = {}) {
   const run = readRun(cwd, deps.file);
   const doFetch = deps.fetchImpl ?? fetch;
   const endpoint = `${apiUrl}/v1/runs`;
+  const payload = JSON.stringify(run);
+  const idempotencyKey = (0, import_node_crypto2.createHash)("sha256").update(payload).digest("hex");
   let res;
   try {
     res = await doFetch(endpoint, {
       method: "POST",
-      headers: { "content-type": "application/json", authorization: `Bearer ${token}` },
-      body: JSON.stringify(run)
+      headers: {
+        "content-type": "application/json",
+        authorization: `Bearer ${token}`,
+        "idempotency-key": idempotencyKey
+      },
+      body: payload
     });
   } catch {
     throw new SyncNetworkError(apiUrl);

package/dist/index.js

@@ -1554,6 +1554,7 @@ async function handleRun(options, depsFactory) {
 }
 
 // src/cli/commands/sync.ts
+import { createHash as createHash2 } from "crypto";
 import * as fs6 from "fs";
 import * as path5 from "path";
 
@@ -1738,12 +1739,18 @@ async function handleSync(deps = {}) {
   const run = readRun(cwd, deps.file);
   const doFetch = deps.fetchImpl ?? fetch;
   const endpoint = `${apiUrl}/v1/runs`;
+  const payload = JSON.stringify(run);
+  const idempotencyKey = createHash2("sha256").update(payload).digest("hex");
   let res;
   try {
     res = await doFetch(endpoint, {
       method: "POST",
-      headers: { "content-type": "application/json", authorization: `Bearer ${token}` },
-      body: JSON.stringify(run)
+      headers: {
+        "content-type": "application/json",
+        authorization: `Bearer ${token}`,
+        "idempotency-key": idempotencyKey
+      },
+      body: payload
     });
   } catch {
     throw new SyncNetworkError(apiUrl);