flowviant 0.103.0 → 0.105.0

package/bin/lib/artifactReporter.mjs

@@ -0,0 +1,163 @@
+/**
+ * THE ARTIFACT REPORTER — the queued POST to `/fleet/artifact` and its bounded
+ * retries (2026-09-26, split out of artifacts.mjs — SOLID F051).
+ *
+ * Network delivery is its own reason to change, apart from what is on the disk
+ * (artifacts.mjs) and how a page is screenshotted (artifactPreview.mjs). The
+ * reporter imports neither: it is HANDED the three functions it runs —
+ * `listChanged(placeDir, before)` (what the turn wrote), `buildUpload(entry,
+ * owner, scrub, secretIn)` (one scrubbed body) and `renderPreview(bytes)` (the
+ * screenshot) — so the delivery rules below are tested against a fake server
+ * and a fake renderer, and a new source of bodies would not edit this file.
+ *
+ * ── DELIVERY ──
+ *
+ * A 2xx is delivered. A 4xx (other than 408/429) is TREATED AS DELIVERED — an
+ * older SERVER 404s the whole route, and holding bodies it will refuse forever
+ * would be the trace relay's wedge wearing a retry's clothes; a refusal of one
+ * file (ended session, wrong owner) is equally permanent. A 5xx, 408, 429 or a
+ * network error keeps the STORED BODY — the fields and the bytes as they were
+ * scrubbed — and retries it on the next report beat, the settle's shape, at
+ * most `MAX_TRIES` times; a newer copy of the same file replaces a held one.
+ *
+ * A PREVIEW THAT FAILS NEVER STOPS THE ARTIFACT: an HTML body goes out with
+ * `renderState: 'unavailable'` and no preview, the renderer's explicit answer.
+ */
+
+import { fleetEndpoint } from './fleetWire.mjs';
+
+/** A held upload is tried this many times in all, then dropped with a line. */
+const MAX_TRIES = 4;
+/** Held bodies across every owner — each can be two megabytes. */
+const MAX_PENDING = 40;
+
+/**
+ * The reporter a work manager holds for its life. `report` is called once per
+ * finished turn and never awaited by the turn (a slow uplink must not hold the
+ * next turn behind a readout); `retryPending` rides the settle retry beat.
+ */
+export function createArtifactReporter({
+  fleetUrl,
+  token,
+  userAgent,
+  scrub,
+  secretIn,
+  fetchImpl,
+  log = () => {},
+  listChanged,
+  buildUpload,
+  renderPreview,
+}) {
+  const url = fleetEndpoint('artifact', fleetUrl);
+  const doFetch = fetchImpl ?? ((...a) => fetch(...a));
+  const pending = new Map(); // `${owner}:${name}` -> { body, tries }
+
+  /** true = settled (delivered or permanently refused); false = hold it. */
+  const post = async (body) => {
+    const form = new FormData();
+    for (const [k, v] of Object.entries(body.fields)) form.set(k, v);
+    if (body.bytes) form.set('file', new Blob([body.bytes]), body.fields.name);
+    if (body.preview) form.set('preview', new Blob([body.preview], { type: 'image/png' }), 'preview.png');
+    try {
+      const res = await doFetch(url, {
+        method: 'POST',
+        headers: { Authorization: `Bearer ${token}`, 'User-Agent': userAgent },
+        signal: AbortSignal.timeout(30_000),
+        body: form,
+      });
+      return (
+        res.ok || (res.status >= 400 && res.status < 500 && res.status !== 408 && res.status !== 429)
+      );
+    } catch {
+      return false;
+    }
+  };
+
+  const hold = (key, body, tries) => {
+    if (tries >= MAX_TRIES) {
+      pending.delete(key);
+      log(`artifact ${body.fields.name}: not delivered after ${tries} tries — dropped`);
+      return;
+    }
+    pending.delete(key); // re-insert at the tail, so the cap sheds the oldest
+    pending.set(key, { body, tries });
+    while (pending.size > MAX_PENDING) {
+      const shed = pending.keys().next().value;
+      pending.delete(shed);
+      if (!chains.has(shed)) genOf.delete(shed);
+    }
+  };
+
+  // ONE COPY OF A FILE IS IN FLIGHT AT A TIME, AND ONLY THE NEWEST MAY
+  // DECIDE. Each report of a (owner, name) takes a fresh generation, and every
+  // post for that key is chained behind the previous one — so a slow retry of
+  // an OLD body can neither land on the server after the newer copy (the
+  // server upserts by name, so the last write wins) nor re-hold itself over
+  // the newer one when it fails. A body superseded before it went out is not
+  // sent at all; one superseded while in flight has its answer discarded.
+  let generation = 0;
+  const genOf = new Map(); // key -> the generation allowed to decide
+  const chains = new Map(); // key -> the tail of that key's post chain
+
+  const send = (key, body, tries, gen) => {
+    const run = (chains.get(key) ?? Promise.resolve()).then(async () => {
+      if (genOf.get(key) !== gen) return; // superseded before it went out
+      const ok = await post(body);
+      if (genOf.get(key) !== gen) return; // a newer copy decides for this key
+      if (ok) pending.delete(key);
+      else hold(key, body, tries + 1);
+    });
+    const tail = run.catch(() => {});
+    chains.set(key, tail);
+    tail.then(() => {
+      if (chains.get(key) !== tail) return;
+      chains.delete(key);
+      if (!pending.has(key)) genOf.delete(key); // settled: nothing left to order
+    });
+    return run;
+  };
+
+  let retrying = false;
+  const retryPending = async () => {
+    if (retrying || pending.size === 0) return;
+    retrying = true;
+    try {
+      for (const [key, held] of [...pending]) {
+        if (pending.get(key) !== held) continue; // superseded meanwhile
+        await send(key, held.body, held.tries, genOf.get(key));
+      }
+    } finally {
+      retrying = false;
+    }
+  };
+
+  /** Upload what this turn changed in `placeDir`. Resolves to the number of
+   *  bodies SENT this call (delivered or held), for the tests and the log. */
+  const report = async ({ placeDir, before, sessionId, agentId, turnId }) => {
+    if (!placeDir || (!sessionId && !agentId)) return 0;
+    const changed = listChanged(placeDir, before);
+    let n = 0;
+    for (const entry of changed) {
+      const body = buildUpload(entry, { sessionId, agentId, turnId }, scrub, secretIn);
+      if (!body) continue;
+      if (body.withheld) {
+        log(`artifact ${entry.name}: not uploaded — it contains the value of ${body.withheld} from this machine's environment`);
+        continue;
+      }
+      if (body.bytes && /\.html?$/i.test(entry.name)) {
+        const measured = await renderPreview(body.bytes);
+        body.fields.renderState = measured.renderState;
+        if (measured.preview) body.preview = measured.preview;
+      }
+      const key = `${sessionId ?? agentId}:${entry.name}`;
+      pending.delete(key); // this copy supersedes a held older one
+      const gen = ++generation;
+      genOf.set(key, gen); // …and one still in flight
+      await send(key, body, 0, gen);
+      n++;
+    }
+    return n;
+  };
+
+  return { report, retryPending, pendingCount: () => pending.size };
+}

package/bin/lib/artifacts.mjs

@@ -28,7 +28,8 @@
  *
  * ── THE BOUNDS ──
  *
- * Regular files only, DEPTH ONE, `lstat` and never followed: a symlink an
+ * Regular files only, to DEPTH FOUR (relative paths, 0.99.0 — a bundle's
+ * sidecars), `lstat` and never followed: a symlink an
  * agent planted at `.flowviant/artifacts/x.txt -> ~/.ssh/id_ed25519` is
  * reported as nothing, and the read itself opens with `O_NOFOLLOW` so a swap
  * between the lstat and the open cannot turn one into a follow. The directory
@@ -51,7 +52,7 @@
  * any of them. What they cannot be is REWRITTEN: `envScrub` swapping bytes
  * inside one corrupts it, and a corrupted binary served as the thing the agent
  * made is worse than none. So each binary is checked against the same scrub
- * list as exact byte substrings (`secretIn`, env.mjs) before it is uploaded,
+ * list as exact byte substrings (`secretIn`, uplinkScrub.mjs) before it is uploaded,
  * and a hit SKIPS the file with a warn line naming it and the variable — never
  * a redacted copy, never a by-name row the page would draw as a file it merely
  * could not show. STATED: a value inside a deflated stream is not a substring
@@ -60,73 +61,49 @@
  * The SERVER computes the sha256 of what it stored; the one sent here is for
  * the log.
  *
- * ── DELIVERY ──
+ * ── DELIVERY LIVES NEXT DOOR (2026-09-26) ──
  *
- * A 2xx is delivered. A 4xx (other than 408/429) is TREATED AS DELIVERED — an
- * older SERVER 404s the whole route, and holding bodies it will refuse forever
- * would be the trace relay's wedge wearing a retry's clothes; a refusal of one
- * file (ended session, wrong owner) is equally permanent. A 5xx, 408, 429 or a
- * network error keeps the STORED BODY — the fields and the bytes as they were
- * scrubbed — and retries it on the next report beat, the settle's shape, at
- * most `MAX_TRIES` times; a newer copy of the same file replaces a held one.
+ * This module is the DISK half: scan, diff against the snapshot, and prepare
+ * one upload body (scrubbed text, withheld binaries). The screenshot of an
+ * HTML page is `artifactPreview.mjs` (a browser); the queued POST with its
+ * bounded retries is `artifactReporter.mjs` (the network). Three reasons to
+ * change, three files — split from one 439-line module (SOLID F051).
  *
  * NO VERSION FLOOR: a daemon→server report on a new endpoint. The prompt
  * paragraph is gated instead, on the roster's `artifactsAccepted` — a server
  * that cannot show an artifact must not have the CLI told it will.
  */
 
-import { constants, closeSync, fstatSync, lstatSync, openSync, readdirSync, readSync, mkdtempSync, writeFileSync, readFileSync, rmSync } from 'node:fs';
+import { constants, closeSync, fstatSync, lstatSync, openSync, readdirSync, readSync } from 'node:fs';
 import { createHash } from 'node:crypto';
 import { join } from 'node:path';
-import { tmpdir } from 'node:os';
-import { pathToFileURL } from 'node:url';
-import { captureScreenshot } from './shot.mjs';
+import { cutKeepingExtension } from './safeFileName.mjs';
+import {
+  ARTIFACT_BINARY_MODEL_EXTS,
+  ARTIFACT_BINARY_MODEL_MAX_BYTES,
+  ARTIFACT_MAX_BYTES,
+  ARTIFACT_MAX_PER_OWNER,
+  ARTIFACT_TYPES,
+} from './artifactPolicy.mjs';
 
 /** Relative to the directory the turn stands in. Under `.flowviant/`, which
  *  the exclude file already hides from git (`excludeInWorktree`). */
 export const ARTIFACT_DIR = '.flowviant/artifacts';
-/** The server's per-file ceiling, re-checked here. */
-export const ARTIFACT_MAX_BYTES = 2 * 1024 * 1024;
-export const ARTIFACT_BINARY_MODEL_MAX_BYTES = 20 * 1024 * 1024;
-export const DESIGN_PREVIEW_MAX_BYTES = 2 * 1024 * 1024;
-const PREVIEW_CSP = "default-src 'none'; script-src 'unsafe-inline' https://cdnjs.cloudflare.com https://cdn.jsdelivr.net/npm/ https://unpkg.com; style-src 'unsafe-inline' https://cdnjs.cloudflare.com https://cdn.jsdelivr.net/npm/ https://unpkg.com https://fonts.googleapis.com; img-src data: blob:; font-src data: https://fonts.gstatic.com; connect-src 'none'; frame-src 'none'; object-src 'none'; base-uri 'none'; form-action 'none'";
-export const artifactMaxBytesFor = (name) => /\.(?:glb|bin)$/i.test(name)
-  ? ARTIFACT_BINARY_MODEL_MAX_BYTES : ARTIFACT_MAX_BYTES;
-/** Listed per scan, newest first — the server keeps as many per owner. */
-export const ARTIFACT_MAX_FILES = 40;
-/** A held upload is tried this many times in all, then dropped with a line. */
-const MAX_TRIES = 4;
-/** Held bodies across every owner — each can be two megabytes. */
-const MAX_PENDING = 40;
-
-/** The allowlist, by extension. The server's `ARTIFACT_TYPES`, repeated. */
-export const ARTIFACT_TYPES = {
-  html: { mime: 'text/html', text: true },
-  htm: { mime: 'text/html', text: true },
-  md: { mime: 'text/markdown', text: true },
-  svg: { mime: 'image/svg+xml', text: true },
-  png: { mime: 'image/png', text: false },
-  jpg: { mime: 'image/jpeg', text: false },
-  jpeg: { mime: 'image/jpeg', text: false },
-  gif: { mime: 'image/gif', text: false },
-  webp: { mime: 'image/webp', text: false },
-  json: { mime: 'application/json', text: true },
-  csv: { mime: 'text/csv', text: true },
-  txt: { mime: 'text/plain', text: true },
-  // DOCUMENTS (0.97.0): a Word file, a deck, a sheet or a PDF — what the
-  // machine's docx/pptx/xlsx/pdf skills write. Binary, so never REWRITTEN (a
-  // scrub inside a zip or a PDF corrupts it) but checked for a known secret's
-  // bytes and withheld on a hit — see the header. Under the same cap. The app
-  // offers the first three as a download and frames the PDF.
-  docx: { mime: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document', text: false },
-  pptx: { mime: 'application/vnd.openxmlformats-officedocument.presentationml.presentation', text: false },
-  xlsx: { mime: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet', text: false },
-  pdf: { mime: 'application/pdf', text: false },
-  gltf: { mime: 'model/gltf+json', text: true },
-  obj: { mime: 'model/obj', text: true },
-  glb: { mime: 'model/gltf-binary', text: false },
-  bin: { mime: 'application/octet-stream', text: false },
+/**
+ * THE ALLOWLIST AND THE CEILINGS are the server's, from its GENERATED snapshot
+ * (`artifactPolicy.mjs`, rendered from packages/shared/src/schemas/
+ * artifact.schema.ts — 2026-09-26, SOLID F044). They were hand-repeated here,
+ * and a type added on one side only was either reported by name while the
+ * server could serve it, or sent as a type the server refuses. Re-checked here
+ * all the same: this is somebody's disk, and one place checking is one deploy
+ * from zero.
+ */
+export const artifactMaxBytesFor = (name) => {
+  const ext = String(name).slice(String(name).lastIndexOf('.') + 1).toLowerCase();
+  return ARTIFACT_BINARY_MODEL_EXTS.includes(ext) ? ARTIFACT_BINARY_MODEL_MAX_BYTES : ARTIFACT_MAX_BYTES;
 };
+/** Listed per scan, newest first — the server keeps as many per owner. */
+export const ARTIFACT_MAX_FILES = ARTIFACT_MAX_PER_OWNER;
 
 export function artifactTypeFor(name) {
   const dot = String(name).lastIndexOf('.');
@@ -193,6 +170,12 @@ export function changedArtifacts(before, entries) {
   return entries.filter((e) => before?.get(e.name) !== sigOf(e));
 }
 
+/** What the turn wrote in `placeDir` since `before` — the scanner the reporter
+ *  is handed (`artifactReporter.mjs`), as one function. */
+export function changedSince(placeDir, before) {
+  return changedArtifacts(before, scanArtifacts(placeDir));
+}
+
 /** Read a regular file WITHOUT following a symlink planted after the lstat. */
 function readNoFollow(path, limit) {
   const fd = openSync(path, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
@@ -212,38 +195,23 @@ function readNoFollow(path, limit) {
   }
 }
 
-/** FNV-1a, 32-bit, as 8 hex — verbatim against the server's `fnv1a8`
- *  (apps/api/src/routes/sessionsAttachments.routes.ts). */
-function artifactFnv1a8(s) {
-  let h = 0x811c9dc5;
-  for (let i = 0; i < s.length; i++) {
-    h ^= s.charCodeAt(i);
-    h = Math.imul(h, 0x01000193);
-  }
-  return (h >>> 0).toString(16).padStart(8, '0');
-}
-const ARTIFACT_SAFE_EXT_RE = /^[A-Za-z0-9]{1,10}$/;
 /**
- * `safeFileName`, verbatim in effect (apps/api/src/routes/sessionsAttachments.
- * routes.ts): keeps the extension through a cut. Applied to each relative
+ * `safeFileName`'s CUT (bin/lib/safeFileName.mjs — `cutKeepingExtension`, the
+ * server's rule): keeps the extension through a cut. Applied to each relative
  * path component, so a model under `scene/` keeps that relation to its page.
- * This only differs from a component on an over-long name — but that is exactly the case the
- * server's own `safeFileName(rawName)` would otherwise re-cut DIFFERENTLY
- * from whatever this reported, since a bare truncation and an
- * extension-preserving one disagree past 80 characters. Applying the same
- * rule here means the server's re-application is a no-op and the name a
- * design or research delivery is judged by is the one this machine reported.
+ * The context rule around the cut is this lane's own: a component that is
+ * already safe — spaces included — passes through untouched, because a bundle
+ * path names files the page references by exactly that spelling. The cut only
+ * differs from the component on an over-long name — but that is exactly the
+ * case the server's own `safeFileName(rawName)` would otherwise re-cut
+ * DIFFERENTLY from whatever this reported, so applying the same cut here means
+ * the server's re-application is a no-op and the name a design or research
+ * delivery is judged by is the one this machine reported.
  */
 function safeArtifactName(raw) {
   if (typeof raw === 'string' && raw.length <= 80 && /^[A-Za-z0-9][A-Za-z0-9._ -]*$/.test(raw) && !raw.endsWith('.')) return raw;
   const clean = String(raw ?? '').replace(/[^A-Za-z0-9._-]/g, '_');
-  if (clean.length <= 80) return clean || 'artifact';
-  const dot = clean.lastIndexOf('.');
-  const ext = dot > 0 && ARTIFACT_SAFE_EXT_RE.test(clean.slice(dot + 1)) ? clean.slice(dot + 1) : '';
-  const stem = ext ? clean.slice(0, dot) : clean;
-  const tag = `-${artifactFnv1a8(clean)}`;
-  const room = 80 - tag.length - (ext ? ext.length + 1 : 0);
-  return `${stem.slice(0, room)}${tag}${ext ? `.${ext}` : ''}`;
+  return clean ? cutKeepingExtension(clean) : 'artifact';
 }
 
 /**
@@ -290,150 +258,3 @@ export function buildArtifactUpload(entry, { sessionId, agentId, turnId }, scrub
     bytes,
   };
 }
-
-/** Render the scrubbed HTML, never the checkout's unsanitized source. A
- * failed browser measurement is explicit; older daemon reports are absent. */
-export async function renderDesignPreview(bytes, capture = captureScreenshot) {
-  const dir = mkdtempSync(join(tmpdir(), 'flowviant-design-'));
-  try {
-    const html = join(dir, 'design.html');
-    const png = join(dir, 'design.png');
-    // A fresh Chrome profile has no Flowviant credentials. Put the artifact
-    // box's network fence before any model-written markup executes.
-    writeFileSync(html, Buffer.concat([
-      Buffer.from(`<meta http-equiv="Content-Security-Policy" content="${PREVIEW_CSP}">`),
-      bytes,
-    ]));
-    const result = await capture({ url: pathToFileURL(html).href, out: png, width: 720, height: 450, timeoutMs: 15_000 });
-    if (!result.ok) return { renderState: 'unavailable' };
-    const image = readFileSync(png);
-    if (image.byteLength > DESIGN_PREVIEW_MAX_BYTES || !image.subarray(0, 8).equals(Buffer.from([137,80,78,71,13,10,26,10]))) {
-      return { renderState: 'unavailable' };
-    }
-    return { renderState: 'rendered', preview: image };
-  } catch {
-    return { renderState: 'unavailable' };
-  } finally {
-    rmSync(dir, { recursive: true, force: true });
-  }
-}
-
-/**
- * The reporter a work manager holds for its life. `report` is called once per
- * finished turn and never awaited by the turn (a slow uplink must not hold the
- * next turn behind a readout); `retryPending` rides the settle retry beat.
- */
-export function createArtifactReporter({ fleetUrl, token, userAgent, scrub, secretIn, fetchImpl, log = () => {} }) {
-  const url = String(fleetUrl).replace(/\/agents\/?$/, '/artifact');
-  const doFetch = fetchImpl ?? ((...a) => fetch(...a));
-  const pending = new Map(); // `${owner}:${name}` -> { body, tries }
-
-  /** true = settled (delivered or permanently refused); false = hold it. */
-  const post = async (body) => {
-    const form = new FormData();
-    for (const [k, v] of Object.entries(body.fields)) form.set(k, v);
-    if (body.bytes) form.set('file', new Blob([body.bytes]), body.fields.name);
-    if (body.preview) form.set('preview', new Blob([body.preview], { type: 'image/png' }), 'preview.png');
-    try {
-      const res = await doFetch(url, {
-        method: 'POST',
-        headers: { Authorization: `Bearer ${token}`, 'User-Agent': userAgent },
-        signal: AbortSignal.timeout(30_000),
-        body: form,
-      });
-      return (
-        res.ok || (res.status >= 400 && res.status < 500 && res.status !== 408 && res.status !== 429)
-      );
-    } catch {
-      return false;
-    }
-  };
-
-  const hold = (key, body, tries) => {
-    if (tries >= MAX_TRIES) {
-      pending.delete(key);
-      log(`artifact ${body.fields.name}: not delivered after ${tries} tries — dropped`);
-      return;
-    }
-    pending.delete(key); // re-insert at the tail, so the cap sheds the oldest
-    pending.set(key, { body, tries });
-    while (pending.size > MAX_PENDING) {
-      const shed = pending.keys().next().value;
-      pending.delete(shed);
-      if (!chains.has(shed)) genOf.delete(shed);
-    }
-  };
-
-  // ONE COPY OF A FILE IS IN FLIGHT AT A TIME, AND ONLY THE NEWEST MAY
-  // DECIDE. Each report of a (owner, name) takes a fresh generation, and every
-  // post for that key is chained behind the previous one — so a slow retry of
-  // an OLD body can neither land on the server after the newer copy (the
-  // server upserts by name, so the last write wins) nor re-hold itself over
-  // the newer one when it fails. A body superseded before it went out is not
-  // sent at all; one superseded while in flight has its answer discarded.
-  let generation = 0;
-  const genOf = new Map(); // key -> the generation allowed to decide
-  const chains = new Map(); // key -> the tail of that key's post chain
-
-  const send = (key, body, tries, gen) => {
-    const run = (chains.get(key) ?? Promise.resolve()).then(async () => {
-      if (genOf.get(key) !== gen) return; // superseded before it went out
-      const ok = await post(body);
-      if (genOf.get(key) !== gen) return; // a newer copy decides for this key
-      if (ok) pending.delete(key);
-      else hold(key, body, tries + 1);
-    });
-    const tail = run.catch(() => {});
-    chains.set(key, tail);
-    tail.then(() => {
-      if (chains.get(key) !== tail) return;
-      chains.delete(key);
-      if (!pending.has(key)) genOf.delete(key); // settled: nothing left to order
-    });
-    return run;
-  };
-
-  let retrying = false;
-  const retryPending = async () => {
-    if (retrying || pending.size === 0) return;
-    retrying = true;
-    try {
-      for (const [key, held] of [...pending]) {
-        if (pending.get(key) !== held) continue; // superseded meanwhile
-        await send(key, held.body, held.tries, genOf.get(key));
-      }
-    } finally {
-      retrying = false;
-    }
-  };
-
-  /** Upload what this turn changed in `placeDir`. Resolves to the number of
-   *  bodies SENT this call (delivered or held), for the tests and the log. */
-  const report = async ({ placeDir, before, sessionId, agentId, turnId }) => {
-    if (!placeDir || (!sessionId && !agentId)) return 0;
-    const changed = changedArtifacts(before, scanArtifacts(placeDir));
-    let n = 0;
-    for (const entry of changed) {
-      const body = buildArtifactUpload(entry, { sessionId, agentId, turnId }, scrub, secretIn);
-      if (!body) continue;
-      if (body.withheld) {
-        log(`artifact ${entry.name}: not uploaded — it contains the value of ${body.withheld} from this machine's environment`);
-        continue;
-      }
-      if (body.bytes && /\.html?$/i.test(entry.name)) {
-        const measured = await renderDesignPreview(body.bytes);
-        body.fields.renderState = measured.renderState;
-        if (measured.preview) body.preview = measured.preview;
-      }
-      const key = `${sessionId ?? agentId}:${entry.name}`;
-      pending.delete(key); // this copy supersedes a held older one
-      const gen = ++generation;
-      genOf.set(key, gen); // …and one still in flight
-      await send(key, body, 0, gen);
-      n++;
-    }
-    return n;
-  };
-
-  return { report, retryPending, pendingCount: () => pending.size };
-}

package/bin/lib/authReject.mjs

@@ -21,12 +21,24 @@
  */
 export async function credentialRejected(res) {
   if (res?.status !== 401 && res?.status !== 403) return false;
-  const type = String(res.headers?.get?.('content-type') ?? '');
-  if (!/\bapplication\/json\b/i.test(type)) return false;
+  let body;
   try {
-    const body = await res.json();
-    return Boolean(body) && body.success === false;
+    body = await res.json();
   } catch {
     return false; // not the API's envelope — an edge page mislabelled as JSON
   }
+  return isCredentialRejection(res.status, res.headers?.get?.('content-type'), body);
+}
+
+/**
+ * THE SAME TEST, ON A BODY ALREADY READ — for a caller that parsed the answer
+ * before it knew it was a refusal (deployWire.mjs reads every `/fleet/deploy-*`
+ * answer once). The rule is this one: a 401/403, labelled JSON, wearing the
+ * API's `{ success: false }` envelope. A body that did not parse is passed as
+ * anything but that envelope and answers false.
+ */
+export function isCredentialRejection(status, contentType, body) {
+  if (status !== 401 && status !== 403) return false;
+  if (!/\bapplication\/json\b/i.test(String(contentType ?? ''))) return false;
+  return Boolean(body) && typeof body === 'object' && body.success === false;
 }