iteration-cli 0.14.0 → 0.14.2

package/dist/cli.js

@@ -936,7 +936,7 @@ import { spawnSync } from "node:child_process";
 import os9 from "node:os";
 import path24 from "node:path";
 import { promises as fs20 } from "node:fs";
-import { createInterface as createInterface3 } from "node:readline/promises";
+import { createInterface as createInterface2 } from "node:readline/promises";
 import { parseArgs } from "node:util";
 
 // ../../node_modules/.pnpm/zod@4.6.4/node_modules/zod/v4/core/util.js
@@ -10790,11 +10790,10 @@ async function cursorHookFiles(dataDirectory2) {
 }
 
 // src/storage.ts
-import { once } from "node:events";
 import { createReadStream, createWriteStream as createWriteStream2, promises as fs13 } from "node:fs";
 import os6 from "node:os";
 import path13 from "node:path";
-import { createInterface as createInterface2 } from "node:readline";
+import { pipeline as pipeline2 } from "node:stream/promises";
 
 // ../../node_modules/.pnpm/@secretlint+core@13.0.6/node_modules/@secretlint/core/module/SecretLintSourceCodeImpl.js
 var import_structured_source = __toESM(require_structured_source(), 1);
@@ -15711,6 +15710,32 @@ var healthSchema = object({
   }).strict().nullable()
 }).strict();
 var redactionMarkerSchema = object({ version: literal(1) }).strict();
+async function* outboxLines(filename) {
+  const input = createReadStream(filename);
+  let parts = [];
+  try {
+    for await (const value of input) {
+      const chunk = value;
+      let start2 = 0;
+      let newline = chunk.indexOf(10);
+      while (newline !== -1) {
+        const end = chunk.subarray(start2, newline);
+        if (parts.length === 0) yield end.toString("utf8");
+        else {
+          parts.push(end);
+          yield Buffer.concat(parts).toString("utf8");
+          parts = [];
+        }
+        start2 = newline + 1;
+        newline = chunk.indexOf(10, start2);
+      }
+      if (start2 < chunk.length) parts.push(chunk.subarray(start2));
+    }
+    if (parts.length > 0) yield Buffer.concat(parts).toString("utf8");
+  } finally {
+    input.destroy();
+  }
+}
 function parseOutboxEvent(line) {
   let decoded;
   try {
@@ -15925,13 +15950,7 @@ async function pendingEventIds(paths) {
   if (size > MAX_OUTBOX_BYTES)
     throw new Error("Trace outbox exceeds its configured capacity.");
   try {
-    const input = await fs13.open(paths.outbox, "r");
-    const stream = input.createReadStream({
-      autoClose: true,
-      encoding: "utf8"
-    });
-    const lines = createInterface2({ input: stream, crlfDelay: Infinity });
-    for await (const line of lines) {
+    for await (const line of outboxLines(paths.outbox)) {
       ids.add(parseOutboxEvent(line).eventId);
     }
   } catch (error2) {
@@ -15988,11 +16007,7 @@ async function redactPendingOutbox(paths) {
     const temporary = `${paths.outbox}.${process.pid}.redacting`;
     const output = await fs13.open(temporary, "w", 384);
     try {
-      const lines = createInterface2({
-        input: createReadStream(paths.outbox, { encoding: "utf8" }),
-        crlfDelay: Infinity
-      });
-      for await (const line of lines) {
+      for await (const line of outboxLines(paths.outbox)) {
         const event3 = await redactTraceEvent(parseOutboxEvent(line));
         await output.writeFile(`${JSON.stringify(event3)}
 `, "utf8");
@@ -16034,21 +16049,14 @@ async function nextBatch(paths, maxBytes) {
   if (size === 0) return [];
   if (size > MAX_OUTBOX_BYTES)
     throw new Error("Trace outbox exceeds its configured capacity.");
-  const input = await fs13.open(paths.outbox, "r");
-  const stream = input.createReadStream({ autoClose: true, encoding: "utf8" });
-  const lines = createInterface2({ input: stream, crlfDelay: Infinity });
   const events = [];
   let bytes = 0;
-  for await (const line of lines) {
+  for await (const line of outboxLines(paths.outbox)) {
     const lineBytes = Buffer.byteLength(line, "utf8") + 1;
     if (events.length >= MAX_TRACE_EVENTS_PER_BATCH || events.length > 0 && bytes + lineBytes > maxBytes) {
-      lines.close();
-      stream.destroy();
       break;
     }
     if (lineBytes > maxBytes) {
-      lines.close();
-      stream.destroy();
       throw new Error("A queued event exceeds the maximum upload batch size.");
     }
     events.push(parseOutboxEvent(line));
@@ -16057,28 +16065,20 @@ async function nextBatch(paths, maxBytes) {
   return events;
 }
 async function acknowledgeEvents(acknowledgedIds, paths) {
+  if (await outboxSize(paths) === 0) return;
   const temporary = `${paths.outbox}.${process.pid}.tmp`;
-  const input = await fs13.open(paths.outbox, "r").catch((error2) => {
-    if (error2 instanceof Error && "code" in error2 && error2.code === "ENOENT")
-      return null;
-    throw error2;
-  });
-  if (input === null) return;
-  const output = createWriteStream2(temporary, { flags: "w", mode: 384 });
   try {
-    const lines = createInterface2({
-      input: input.createReadStream({ autoClose: true, encoding: "utf8" }),
-      crlfDelay: Infinity
-    });
-    for await (const line of lines) {
-      const event3 = parseOutboxEvent(line);
-      if (!acknowledgedIds.has(event3.eventId)) {
-        if (!output.write(`${line}
-`)) await once(output, "drain");
-      }
-    }
-    output.end();
-    await once(output, "close");
+    await pipeline2(
+      outboxLines(paths.outbox),
+      async function* (lines) {
+        for await (const line of lines) {
+          const event3 = parseOutboxEvent(line);
+          if (!acknowledgedIds.has(event3.eventId)) yield `${line}
+`;
+        }
+      },
+      createWriteStream2(temporary, { flags: "w", mode: 384 })
+    );
     const durable = await fs13.open(temporary, "r+");
     try {
       await durable.sync();
@@ -16087,7 +16087,6 @@ async function acknowledgeEvents(acknowledgedIds, paths) {
     }
     await fs13.rename(temporary, paths.outbox);
   } catch (error2) {
-    output.destroy();
     await fs13.rm(temporary, { force: true });
     throw error2;
   }
@@ -17846,12 +17845,18 @@ async function scanSourceOnce(config2, paths, signal) {
     }
   };
 }
+function retryAfterMs(response) {
+  const header = response.headers.get("retry-after");
+  if (header === null) return null;
+  const milliseconds = /^\d+$/.test(header) ? Number(header) * 1e3 : Date.parse(header) - Date.now();
+  return Number.isFinite(milliseconds) ? Math.max(1e3, Math.min(milliseconds, 3e5)) : 5e3;
+}
 async function uploadPendingOnce(config2, paths, fetcher = collectorFetch, signal, onAcknowledged) {
   let uploaded = 0;
   for (let attempt = 0; attempt < MAX_UPLOADS_PER_TICK; attempt += 1) {
     signal?.throwIfAborted();
     const batch = await nextBatch(paths, MAX_UPLOAD_BYTES);
-    if (batch.length === 0) return uploaded;
+    if (batch.length === 0) return { uploaded, retryAfterMs: null };
     const body = JSON.stringify({ events: batch });
     if (Buffer.byteLength(body, "utf8") > MAX_REQUEST_BYTES) {
       throw new Error("Queued trace batch exceeds the upload request limit.");
@@ -17876,6 +17881,10 @@ async function uploadPendingOnce(config2, paths, fetcher = collectorFetch, signa
         { cause: error2 }
       );
     }
+    if (response.status === 429) {
+      await response.body?.cancel();
+      return { uploaded, retryAfterMs: retryAfterMs(response) ?? 5e3 };
+    }
     if (response.status !== 202) {
       throw new TraceUploadError(
         "http",
@@ -17902,12 +17911,14 @@ async function uploadPendingOnce(config2, paths, fetcher = collectorFetch, signa
     await acknowledgeEvents(new Set(parsed.value.acceptedEventIds), paths);
     onAcknowledged?.();
     uploaded += batch.length;
+    const pause = retryAfterMs(response);
+    if (pause !== null) return { uploaded, retryAfterMs: pause };
   }
-  return uploaded;
+  return { uploaded, retryAfterMs: null };
 }
 async function collectorTick(config2, paths, fetcher = collectorFetch, signal, onAcknowledged) {
   await redactPendingOutbox(paths);
-  let uploaded = await uploadPendingOnce(
+  let upload = await uploadPendingOnce(
     config2,
     paths,
     fetcher,
@@ -17915,19 +17926,23 @@ async function collectorTick(config2, paths, fetcher = collectorFetch, signal, o
     onAcknowledged
   );
   const scan = await outboxSize(paths) >= SCAN_PAUSE_OUTBOX_BYTES ? { discovered: 0, caughtUp: false, history: null } : await scanSourceOnce(config2, paths, signal);
-  uploaded += await uploadPendingOnce(
-    config2,
-    paths,
-    fetcher,
-    signal,
-    onAcknowledged
-  );
+  if (upload.retryAfterMs === null) {
+    const next = await uploadPendingOnce(
+      config2,
+      paths,
+      fetcher,
+      signal,
+      onAcknowledged
+    );
+    upload = { ...next, uploaded: upload.uploaded + next.uploaded };
+  }
   return {
     discovered: scan.discovered,
-    uploaded,
+    uploaded: upload.uploaded,
     outboxBytes: await outboxSize(paths),
     historyCaughtUp: scan.caughtUp,
-    history: scan.history
+    history: scan.history,
+    retryAfterMs: upload.retryAfterMs ?? 0
   };
 }
 
@@ -19035,7 +19050,9 @@ async function runCollector(directory, expectedSource) {
             })
           );
         }
-        retryDelayMs = 5e3;
+        retryDelayMs = Math.max(5e3, result.retryAfterMs);
+        if (result.retryAfterMs > 0)
+          retryDelayMs += Math.floor(Math.random() * 1e3);
       } catch (error2) {
         if (controller.signal.aborted) break;
         if (!trialSettled && runtimeVersion !== void 0) {
@@ -19865,7 +19882,7 @@ Connect supported agents${safeName ? ` to ${safeName}` : " to the workspace you
       "Run iteration connect interactively or pass --yes to approve uploads."
     );
   }
-  const prompt = createInterface3({
+  const prompt = createInterface2({
     input: process.stdin,
     output: process.stdout
   });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "iteration-cli",
-  "version": "0.14.0",
+  "version": "0.14.2",
   "type": "module",
   "repository": {
     "type": "git",