@plune-ai/cli 0.22.0 → 0.24.0

package/dist/reporter-core.js

@@ -1,5 +1,5 @@
 // src/reporter-core/session.ts
-import { createHash, randomUUID } from "crypto";
+import { createHash as createHash2, randomUUID } from "crypto";
 import { promises as disk } from "fs";
 import { basename as basename2, extname } from "path";
 import { TextDecoder } from "util";
@@ -470,6 +470,27 @@ function webLink(href) {
   return href !== void 0 && /^https?:\/\//i.test(href) && URL.canParse(href) ? href : void 0;
 }
 
+// src/reporter-core/files-batch.ts
+import { createHash } from "crypto";
+import { createReadStream as createReadStream2 } from "fs";
+var FILES_BATCH_MAX = 100;
+var DIRECT_BATCH_BYTES = 6 * 1024 * 1024;
+var BATCH_PIPELINES = 2;
+async function sha256File(path3) {
+  const hash = createHash("sha256");
+  for await (const part of createReadStream2(path3)) hash.update(part);
+  return hash.digest("hex");
+}
+var sha256Bytes = (bytes) => createHash("sha256").update(bytes).digest("hex");
+var BUCKET_CODES = /* @__PURE__ */ new Set([
+  "bucket_unreachable",
+  "not_connected",
+  "platform_not_configured",
+  "upload_expired",
+  "file_mismatch",
+  "file_missing"
+]);
+
 // src/reporter-core/fallback.ts
 import * as fs from "fs";
 import * as path2 from "path";
@@ -582,7 +603,7 @@ function tally(counts, noun) {
 }
 function boundKey(key) {
   if (key.value.length <= KEY_MAX) return key;
-  const digest = createHash("sha256").update(key.value).digest("hex").slice(0, 16);
+  const digest = createHash2("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}` };
@@ -644,6 +665,9 @@ async function startRun(passed, declared) {
   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,
@@ -827,6 +851,7 @@ async function startRun(passed, declared) {
     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);
@@ -868,6 +893,7 @@ async function startRun(passed, declared) {
     }
     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,
@@ -890,6 +916,7 @@ async function startRun(passed, declared) {
       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, codeOf(done2));
     countsOf(job.kind).uploaded += 1;
@@ -950,6 +977,245 @@ async function startRun(passed, declared) {
     }
     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 disk.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" : codeOf(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, codeOf(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" : codeOf(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 disk.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 = [];
@@ -975,18 +1241,8 @@ async function startRun(passed, declared) {
       }
     }
     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() {
@@ -1082,9 +1338,9 @@ async function startRun(passed, declared) {
     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 ")}`);
@@ -1143,9 +1399,9 @@ async function startRun(passed, declared) {
 }
 
 // src/util/hash.ts
-import { createHash as createHash2 } from "crypto";
+import { createHash as createHash3 } from "crypto";
 function sha256(input) {
-  return createHash2("sha256").update(input, "utf8").digest("hex");
+  return createHash3("sha256").update(input, "utf8").digest("hex");
 }
 
 // src/reporter-core/result-key.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plune-ai/cli",
-  "version": "0.22.0",
+  "version": "0.24.0",
   "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",