gangtise-openapi-cli 0.43.1 → 0.44.0

package/dist/src/core/output.js

@@ -1,6 +1,7 @@
 import { createHash, randomBytes } from "node:crypto";
-import { rmSync, statSync } from "node:fs";
+import { renameSync, rmSync, statSync, writeFileSync } from "node:fs";
 import fs from "node:fs/promises";
+import path from "node:path";
 import { ConfigError } from "./errors.js";
 const OUTPUT_FORMATS = ["table", "json", "jsonl", "csv", "markdown"];
 export function stagingPath(target, suffix = "part") {
@@ -8,6 +9,46 @@ export function stagingPath(target, suffix = "part") {
     handedOut.add(staging);
     return staging;
 }
+export async function writeFileAtomic(target, content, options = {}) {
+    const staging = stagingPath(target, options.suffix);
+    try {
+        await fs.writeFile(staging, content, options.mode === undefined ? undefined : { mode: options.mode });
+        await publishFile(staging, target);
+    }
+    catch (error) {
+        await fs.unlink(staging).catch(() => { });
+        throw error;
+    }
+}
+const publishedIdentity = new Map();
+export async function publishFile(staging, target) {
+    const { dev, ino } = await fs.stat(staging);
+    await fs.rename(staging, target);
+    publishedIdentity.set(path.resolve(target), { dev, ino });
+}
+export async function stillPublished(target) {
+    const mine = publishedIdentity.get(path.resolve(target));
+    if (!mine || !mine.ino)
+        return undefined;
+    const now = await fs.stat(target).catch(() => undefined);
+    if (!now)
+        return undefined;
+    return now.dev === mine.dev && now.ino === mine.ino;
+}
+export function writeFileAtomicSync(target, content, options = {}) {
+    const staging = stagingPath(target, options.suffix);
+    try {
+        writeFileSync(staging, content);
+        renameSync(staging, target);
+    }
+    catch (error) {
+        try {
+            rmSync(staging, { force: true });
+        }
+        catch { }
+        throw error;
+    }
+}
 const handedOut = new Set();
 const claimed = new Set();
 export function trackClaim(name) {
@@ -117,13 +158,14 @@ function clampCell(value) {
     }
     return out + "…";
 }
-function renderTable(rows) {
+function renderTable(rows, clamp) {
     if (rows.length === 0) {
         return "(empty)";
     }
+    const cell = clamp ? clampCell : (value) => value;
     const columns = Array.from(new Set(rows.flatMap((row) => Object.keys(row))));
-    const headerCells = columns.map((column) => clampCell(sanitizeCell(column)));
-    const matrix = rows.map((row) => columns.map((column) => clampCell(sanitizeCell(formatScalar(row[column])))));
+    const headerCells = columns.map((column) => cell(sanitizeCell(column)));
+    const matrix = rows.map((row) => columns.map((column) => cell(sanitizeCell(formatScalar(row[column])))));
     const cellWidths = matrix.map((cells) => cells.map(displayWidth));
     const headerWidths = headerCells.map(displayWidth);
     const widths = columns.map((_, c) => cellWidths.reduce((max, cells) => Math.max(max, cells[c]), headerWidths[c]));
@@ -144,14 +186,25 @@ function renderMarkdown(rows) {
     const body = rows.map((row) => `| ${columns.map((column) => mdEscape(sanitizeCell(formatScalar(row[column])))).join(" | ")} |`);
     return [header, divider, ...body].join("\n");
 }
-function renderCsv(rows) {
-    if (rows.length === 0) {
-        return "";
+export function csvHeader(columns) {
+    return columns.map(csvEscape).join(",");
+}
+export function csvRow(columns, row) {
+    return columns.map((column) => csvEscape(formatScalar(row[column]))).join(",");
+}
+export function* outputLines(value, format, columns) {
+    if (format === "jsonl") {
+        for (const item of jsonlItems(value))
+            yield JSON.stringify(item);
+        return;
     }
-    const columns = Array.from(new Set(rows.flatMap((row) => Object.keys(row))));
-    const header = columns.map(csvEscape).join(",");
-    const body = rows.map((row) => columns.map((column) => csvEscape(formatScalar(row[column]))).join(","));
-    return [header, ...body].join("\n");
+    const rows = toRows(value);
+    const header = rows.length > 0 ? Array.from(new Set(rows.flatMap((row) => Object.keys(row)))) : (columns ?? []).map(String);
+    if (header.length === 0)
+        return;
+    yield csvHeader(header);
+    for (const row of rows)
+        yield csvRow(header, row);
 }
 export function jsonlItems(value) {
     const list = value && typeof value === "object" && !Array.isArray(value) ? value.list : undefined;
@@ -160,71 +213,61 @@ export function jsonlItems(value) {
 export function countOutputRows(value, format) {
     return format === "jsonl" ? jsonlItems(value).length : toRows(value).length;
 }
-export function renderOutput(value, format) {
+export function renderOutput(value, format, options = {}) {
     switch (format) {
         case "json":
             return JSON.stringify(value, null, 2);
         case "jsonl":
-            return jsonlItems(value).map((item) => JSON.stringify(item)).join("\n");
         case "csv":
-            return renderCsv(toRows(value));
+            return [...outputLines(value, format, options.columns)].join("\n");
         case "markdown":
             return renderMarkdown(toRows(value));
         case "table":
         default:
-            return renderTable(toRows(value));
+            return renderTable(toRows(value), options.clampCells ?? true);
+    }
+}
+export async function writeOutputLines(stream, value, format, options = {}) {
+    const hash = options.digest ? createHash("sha256") : undefined;
+    let bytes = 0;
+    const flush = async (lines) => {
+        if (lines.length === 0)
+            return;
+        const text = lines.join("\n");
+        if (hash) {
+            const buf = Buffer.from(`${text}\n`, "utf8");
+            hash.update(buf);
+            bytes += buf.byteLength;
+        }
+        await writeLine(stream, text);
+    };
+    let chunk = [];
+    let first = true;
+    for (const line of outputLines(value, format, options.columns)) {
+        chunk.push(first && options.bom && format === "csv" ? `\ufeff${line}` : line);
+        first = false;
+        if (chunk.length >= LINES_PER_WRITE) {
+            await flush(chunk);
+            chunk = [];
+        }
     }
+    await flush(chunk);
+    return hash ? { bytes, sha256: hash.digest("hex") } : undefined;
 }
-export async function streamOutputToFile(value, format, outputPath) {
+export async function streamOutputToFile(value, format, outputPath, columns) {
     if (format !== "jsonl" && format !== "csv")
         return null;
-    const list = pickList(value);
-    if (!list)
-        return null;
-    if (list.length < 1000)
-        return null;
-    let csvRows = [];
-    let csvColumns = [];
-    if (format === "csv") {
-        csvRows = list.filter((row) => Boolean(row && typeof row === "object" && !Array.isArray(row)));
-        if (csvRows.length === 0)
-            return null;
-        csvColumns = Array.from(new Set(csvRows.flatMap((row) => Object.keys(row))));
-    }
-    const { dirname } = await import("node:path");
     const { createWriteStream } = await import("node:fs");
-    await fs.mkdir(dirname(outputPath), { recursive: true });
+    await fs.mkdir(path.dirname(outputPath), { recursive: true });
     const partPath = stagingPath(outputPath);
     const stream = createWriteStream(partPath, { encoding: "utf8" });
     stream.on("error", () => { });
     try {
-        if (format === "jsonl") {
-            let chunk = [];
-            for (const item of jsonlItems(value)) {
-                chunk.push(JSON.stringify(item));
-                if (chunk.length >= LINES_PER_WRITE) {
-                    await writeLines(stream, chunk);
-                    chunk = [];
-                }
-            }
-            await writeLines(stream, chunk);
-        }
-        else {
-            let chunk = ["\ufeff" + csvColumns.map(csvEscape).join(",")];
-            for (const row of csvRows) {
-                chunk.push(csvColumns.map((column) => csvEscape(formatScalar(row[column]))).join(","));
-                if (chunk.length >= LINES_PER_WRITE) {
-                    await writeLines(stream, chunk);
-                    chunk = [];
-                }
-            }
-            await writeLines(stream, chunk);
-        }
+        const digest = await writeOutputLines(stream, value, format, { columns, bom: true, digest: true });
         await new Promise((resolve, reject) => {
             stream.end((err) => err ? reject(err) : resolve());
         });
-        const digest = await digestFile(partPath);
-        await fs.rename(partPath, outputPath);
+        await publishFile(partPath, outputPath);
         return digest;
     }
     catch (error) {
@@ -246,9 +289,10 @@ export function pickList(value) {
     }
     return null;
 }
+const NUMERIC_LOOKING = /^[+\-](?:(?=[^\d]*\d)[\d.,%eE]+)?$/;
 export function csvEscape(value) {
     let out = value;
-    if (/^[=@\t\r]/.test(out) || (/^[+\-]/.test(out) && !Number.isFinite(Number(out))))
+    if (/^[=@\t\r]/.test(out) || (/^[+\-]/.test(out) && !NUMERIC_LOOKING.test(out)))
         out = "'" + out;
     if (/[",\n\r]/.test(out))
         return `"${out.replaceAll("\"", "\"\"")}"`;
@@ -277,20 +321,7 @@ export async function saveOutputIfNeeded(content, outputPath, withDigest = true)
     }
     const { dirname } = await import("node:path");
     await fs.mkdir(dirname(outputPath), { recursive: true });
-    const partPath = stagingPath(outputPath);
-    try {
-        if (typeof content === "string") {
-            await fs.writeFile(partPath, content, "utf8");
-        }
-        else {
-            await fs.writeFile(partPath, content);
-        }
-        const digest = withDigest ? digestBuffer(content) : undefined;
-        await fs.rename(partPath, outputPath);
-        return digest;
-    }
-    catch (error) {
-        await fs.unlink(partPath).catch(() => { });
-        throw error;
-    }
+    const digest = withDigest ? digestBuffer(content) : undefined;
+    await writeFileAtomic(outputPath, content);
+    return digest;
 }

package/dist/src/core/printer.js

@@ -1,7 +1,7 @@
 import fs from "node:fs/promises";
 import path from "node:path";
 import { normalizeRows } from "./normalize.js";
-import { countOutputRows, digestFile, pickList, renderOutput, saveOutputIfNeeded, stagingPath, streamOutputToFile } from "./output.js";
+import { countOutputRows, digestFile, pickList, renderOutput, saveOutputIfNeeded, stagingPath, stillPublished, streamOutputToFile, writeOutputLines } from "./output.js";
 import { getRowSink } from "./rowSink.js";
 import { extractTitles, writeTitleCache } from "./titleCache.js";
 import { CLI_VERSION } from "../version.js";
@@ -9,11 +9,13 @@ import { decidedExitCode, EXIT_SUPERSEDED, markIncomplete, markSuperseded } from
 const LARGE_RESULT_ROWS = 50_000;
 export const SUPERSEDED_EXIT = EXIT_SUPERSEDED;
 export async function warnIfSuperseded(output, digest) {
+    if (await stillPublished(output) === true)
+        return;
     const actual = await digestFile(output).catch(() => undefined);
     if (!actual || actual.sha256 === digest.sha256)
         return;
     process.stderr.write(`[gangtise] warning: ${output} was replaced by another export to the same path while this one was finishing — the file there is not this command's output `
-        + `(wrote sha256 ${digest.sha256.slice(0, 12)}…, found ${actual.sha256.slice(0, 12)}…). Give concurrent exports distinct --output paths.\n`);
+        + `(this run wrote sha256 ${digest.sha256.slice(0, 12)}…). Give concurrent exports distinct --output paths.\n`);
     markSuperseded();
 }
 function warnIfLargeInMemory(items, format) {
@@ -135,10 +137,9 @@ export async function printData(data, format, output, cache) {
                 await streamed.finish();
                 digest = streamed.digest;
             }
-            else if (!(digest = (await streamOutputToFile(normalized, format, output)) ?? undefined)) {
+            else if (!(digest = (await streamOutputToFile(normalized, format, output, columns)) ?? undefined)) {
                 warnIfLargeInMemory(items, format);
-                const content = renderOutput(normalized, format);
-                digest = await saveOutputIfNeeded(format === "csv" ? `\ufeff${content}` : content, output);
+                digest = await saveOutputIfNeeded(renderOutput(normalized, format, { clampCells: false }), output);
             }
         }
         catch (error) {
@@ -151,6 +152,10 @@ export async function printData(data, format, output, cache) {
         process.stdout.write(`${output}\n`);
         return;
     }
+    if (format === "jsonl" || format === "csv") {
+        await writeOutputLines(process.stdout, normalized, format, { columns });
+        return;
+    }
     warnIfLargeInMemory(items, format);
     const rendered = renderOutput(normalized, format);
     if (rendered)

package/dist/src/core/quoteSharding.js

@@ -1,4 +1,4 @@
-import { isStructuralError } from "./errors.js";
+import { ApiError, isStructuralError } from "./errors.js";
 import { columnarSchemaValid } from "./normalize.js";
 import { attachRowSink } from "./rowSink.js";
 import { isVerbose, PAGE_CONCURRENCY, runInOrder } from "./transport.js";
@@ -60,6 +60,12 @@ function buildShards(start, end, shardDays) {
     flush();
     return shards;
 }
+const OUT_OF_WINDOW_CODE = "110003";
+function describeError(error) {
+    if (error instanceof ApiError)
+        return `${error.code ? `(${error.code}) ` : ""}${error.message}`;
+    return error instanceof Error ? error.message : String(error);
+}
 export async function callKlineWithSharding(client, endpointKey, body, config) {
     const fullMarketValue = config.fullMarketValue ?? "all";
     if (!isFullMarket(body, fullMarketValue)) {
@@ -101,9 +107,13 @@ export async function callKlineWithSharding(client, endpointKey, body, config) {
     const failedShards = [];
     let firstError = null;
     let aborted = false;
+    let unsent = 0;
+    const outOfWindow = [];
+    let windowError = null;
     const fetchShard = async (shard) => {
         if (aborted) {
             failedShards.push(shard);
+            unsent++;
             return null;
         }
         try {
@@ -115,6 +125,12 @@ export async function callKlineWithSharding(client, endpointKey, body, config) {
             return res;
         }
         catch (error) {
+            if (error instanceof ApiError && error.code === OUT_OF_WINDOW_CODE) {
+                outOfWindow.push(shard);
+                if (!windowError)
+                    windowError = error;
+                return null;
+            }
             if (!firstError)
                 firstError = error;
             if (!isStructuralError(error))
@@ -193,13 +209,19 @@ export async function callKlineWithSharding(client, endpointKey, body, config) {
         await keep(map ? rows.map((item) => (Array.isArray(item) ? map.map((k) => item[k]) : item)) : rows);
     };
     await runInOrder(shards, config.concurrency ?? PAGE_CONCURRENCY, fetchShard, mergeShard);
-    if (failedShards.length === shards.length) {
-        throw firstError ?? new Error(`All ${shards.length} kline shards failed`);
+    if (failedShards.length + outOfWindow.length === shards.length) {
+        throw firstError ?? windowError ?? new Error(`All ${shards.length} kline shards failed`);
+    }
+    const skipped = [...outOfWindow].sort((a, b) => a.startDate.localeCompare(b.startDate));
+    if (skipped.length > 0) {
+        process.stderr.write(`[gangtise] note: ${skipped.length}/${shards.length} shard(s) between ${skipped[0].startDate} and ${skipped[skipped.length - 1].endDate} lie outside your account's history window (110003) and were skipped; the result covers the rest of the range (see outOfWindowShards).\n`);
     }
     const base = header ?? fallback ?? {};
     const out = { ...base, total: count, list: merged };
     if (sink)
         attachRowSink(out, sink);
+    if (skipped.length > 0)
+        out.outOfWindowShards = skipped;
     if (fieldList) {
         out.fieldList = fieldList;
     }
@@ -215,7 +237,9 @@ export async function callKlineWithSharding(client, endpointKey, body, config) {
     if (failedShards.length > 0) {
         out.partial = true;
         out.failedShards = failedShards;
-        process.stderr.write(`[gangtise] warning: ${failedShards.length}/${shards.length} shards failed; results are partial (see failedShards)\n`);
+        const notSent = unsent > 0 ? ` (${unsent} of them not sent: the first error stopped the rest)` : "";
+        const cause = firstError ? `; first error: ${describeError(firstError)}` : "";
+        process.stderr.write(`[gangtise] warning: ${failedShards.length}/${shards.length} shards failed${notSent}${cause}; results are partial (see failedShards)\n`);
     }
     if (partialShards.length > 0) {
         out.partial = true;

package/dist/src/core/rowSink.js

@@ -1,8 +1,9 @@
+import { createHash } from "node:crypto";
 import { createReadStream, createWriteStream } from "node:fs";
 import fs from "node:fs/promises";
 import path from "node:path";
 import { assertColumnarHeader, zipFieldRow } from "./normalize.js";
-import { csvEscape, digestFile, formatScalar, stagingPath, writeLine, writeLines, LINES_PER_WRITE } from "./output.js";
+import { csvHeader, csvRow, publishFile, stagingPath, writeLine, LINES_PER_WRITE } from "./output.js";
 import { extractTitles, MAX_TITLES_PER_ENDPOINT } from "./titleCache.js";
 export const ROW_SINK = Symbol("gangtise.rowSink");
 const STREAM_THRESHOLD = 1000;
@@ -25,6 +26,8 @@ export class ExportSink {
     earliestDates = new Map();
     partPath;
     rowsPath;
+    hash = createHash("sha256");
+    bytes = 0;
     constructor(outputPath, format = "jsonl", cache) {
         this.outputPath = outputPath;
         this.format = format;
@@ -93,8 +96,8 @@ export class ExportSink {
             await endStream(stream);
             if (this.format === "csv")
                 await this.assembleCsv();
-            this.digest = await digestFile(this.partPath);
-            await fs.rename(this.partPath, this.outputPath);
+            this.digest = { bytes: this.bytes, sha256: this.hash.digest("hex") };
+            await publishFile(this.partPath, this.outputPath);
             this.finished = true;
         }
         catch (error) {
@@ -142,7 +145,7 @@ export class ExportSink {
             }
             chunk.push(JSON.stringify(item));
             if (chunk.length >= LINES_PER_WRITE) {
-                await writeLines(stream, chunk);
+                await this.writeChunk(stream, chunk, this.format === "jsonl");
                 chunk = [];
             }
             this.rows++;
@@ -154,7 +157,18 @@ export class ExportSink {
                 }
             }
         }
-        await writeLines(stream, chunk);
+        await this.writeChunk(stream, chunk, this.format === "jsonl");
+    }
+    async writeChunk(stream, lines, published) {
+        if (lines.length === 0)
+            return;
+        const text = lines.join("\n");
+        if (published) {
+            const buf = Buffer.from(`${text}\n`, "utf8");
+            this.hash.update(buf);
+            this.bytes += buf.byteLength;
+        }
+        await writeLine(stream, text);
     }
     async assembleCsv() {
         const out = createWriteStream(this.partPath, { encoding: "utf8" });
@@ -162,7 +176,7 @@ export class ExportSink {
         this.stream = out;
         const objectMode = this.objectRows > 0;
         const columns = objectMode ? this.columns : ["index", "value"];
-        await writeLine(out, "\ufeff" + columns.map(csvEscape).join(","));
+        await this.writeChunk(out, [`\ufeff${csvHeader(columns)}`], true);
         const input = createReadStream(this.rowsPath, { encoding: "utf8" });
         try {
             let index = 0;
@@ -174,10 +188,10 @@ export class ExportSink {
                 if (objectMode) {
                     if (!isObjectRow(item))
                         return;
-                    csvLines.push(columns.map((column) => csvEscape(formatScalar(item[column]))).join(","));
+                    csvLines.push(csvRow(columns, item));
                 }
                 else {
-                    csvLines.push(`${csvEscape(String(index++))},${csvEscape(formatScalar(item))}`);
+                    csvLines.push(csvRow(columns, { index: index++, value: item }));
                 }
             };
             let rest = "";
@@ -187,12 +201,12 @@ export class ExportSink {
                 for (const line of lines)
                     emit(line);
                 if (csvLines.length >= LINES_PER_WRITE) {
-                    await writeLines(out, csvLines);
+                    await this.writeChunk(out, csvLines, true);
                     csvLines = [];
                 }
             }
             emit(rest);
-            await writeLines(out, csvLines);
+            await this.writeChunk(out, csvLines, true);
             await endStream(out);
         }
         catch (error) {

package/dist/src/core/titleCache.js

@@ -1,7 +1,7 @@
 import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
-import { stagingPath } from "./output.js";
+import { writeFileAtomic } from "./output.js";
 export const DEFAULT_TITLE_CACHE_PATH = path.join(os.homedir(), ".config", "gangtise", "title-cache.json");
 export const TITLE_LOOKUP_SIZE = 200;
 const TITLE_CACHE_TTL_MS = 24 * 60 * 60 * 1000;
@@ -78,15 +78,7 @@ async function flush(filePath) {
         await mergeFromDisk(filePath, data);
         const snapshot = JSON.stringify(data);
         await fs.mkdir(path.dirname(filePath), { recursive: true });
-        const tmp = stagingPath(filePath, "tmp");
-        await fs.writeFile(tmp, snapshot, { encoding: "utf8", mode: 0o600 });
-        try {
-            await fs.rename(tmp, filePath);
-        }
-        catch (error) {
-            await fs.unlink(tmp).catch(() => { });
-            throw error;
-        }
+        await writeFileAtomic(filePath, snapshot, { mode: 0o600, suffix: "tmp" });
     }
 }
 function capTitles(merged, freshKeys, cap) {

package/dist/src/core/transport.js

@@ -53,12 +53,19 @@ export async function runWithConcurrency(items, concurrency, fn) {
     const limit = Math.max(1, Math.min(concurrency, items.length));
     const results = new Array(items.length);
     let next = 0;
+    let failed = false;
     async function worker() {
-        while (true) {
+        while (!failed) {
             const index = next++;
             if (index >= items.length)
                 return;
-            results[index] = await fn(items[index], index);
+            try {
+                results[index] = await fn(items[index], index);
+            }
+            catch (error) {
+                failed = true;
+                throw error;
+            }
         }
     }
     await Promise.all(Array.from({ length: limit }, () => worker()));
@@ -122,6 +129,8 @@ export function resolvePageConcurrency(raw, fallback = 5, max = 32) {
         return fallback;
     return Math.min(parsed, max);
 }
+export const JSON_TOTAL_FACTOR = 2;
+export const TRANSFER_TOTAL_FACTOR = 60;
 export const PAGE_CONCURRENCY = resolvePageConcurrency(process.env.GANGTISE_PAGE_CONCURRENCY);
 const RETRYABLE_HTTP_STATUS = new Set([429, 500, 502, 503, 504]);
 const RETRYABLE_NETWORK_CODES = new Set(["ECONNREFUSED", "ECONNRESET", "ETIMEDOUT", "ENOTFOUND", "EAI_AGAIN", "UND_ERR_CONNECT_TIMEOUT", "UND_ERR_SOCKET", "UND_ERR_HEADERS_TIMEOUT", "UND_ERR_BODY_TIMEOUT"]);
@@ -129,9 +138,6 @@ const RETRYABLE_API_CODES = new Set(["999999"]);
 const TERMINAL_API_CODES = new Set(["999011", "140002"]);
 const NO_REPLAY_NETWORK_CODES = new Set(["ECONNREFUSED", "ENOTFOUND", "EAI_AGAIN", "UND_ERR_CONNECT_TIMEOUT"]);
 function isRetryableError(error, policy) {
-    if (error && typeof error === "object" && error.__retryable === true) {
-        return true;
-    }
     if (error instanceof ApiError) {
         if (error.code && TERMINAL_API_CODES.has(error.code))
             return false;
@@ -157,8 +163,12 @@ function isRetryableError(error, policy) {
     }
     return false;
 }
-export function markRetryable(error) {
-    return Object.assign(error, { __retryable: true });
+const MAX_AUTH_REPLAYS = 2;
+export function markAuthReplay(error) {
+    return Object.assign(error, { __authReplay: true });
+}
+function isAuthReplay(error) {
+    return Boolean(error && typeof error === "object" && error.__authReplay === true);
 }
 export function isTransientError(error) {
     return isRetryableError(error, "default");
@@ -168,11 +178,19 @@ export async function withRetry(fn, options = {}) {
     const baseDelay = options.baseDelayMs ?? 400;
     const maxDelay = options.maxDelayMs ?? 4_000;
     let attempt = 0;
+    let authReplays = 0;
     while (true) {
         try {
             return await fn();
         }
         catch (error) {
+            if (isAuthReplay(error)) {
+                if (authReplays++ >= MAX_AUTH_REPLAYS)
+                    throw error;
+                if (verboseEnabled)
+                    process.stderr.write(`[gangtise] replaying with a recovered token (${authReplays}/${MAX_AUTH_REPLAYS}) after: ${error instanceof Error ? error.message.slice(0, 120) : String(error)}\n`);
+                continue;
+            }
             if (attempt >= retries || !isRetryableError(error, options.policy ?? "default"))
                 throw error;
             const retryAfter = retryAfterFromError(error);

package/dist/src/core/updateCheck.js

@@ -1,22 +1,16 @@
-import { mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { mkdirSync, readFileSync } from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { isVersionNewer } from "./args.js";
-import { stagingPath } from "./output.js";
+import { writeFileAtomicSync } from "./output.js";
 export const UPDATE_CHECK_TTL_MS = 24 * 60 * 60 * 1000;
 export const DEFAULT_UPDATE_CHECK_PATH = path.join(os.homedir(), ".config", "gangtise", "update-check.json");
 function saveLatest(cachePath, latest, now) {
-    const staging = stagingPath(cachePath, "tmp");
     try {
         mkdirSync(path.dirname(cachePath), { recursive: true });
-        writeFileSync(staging, JSON.stringify({ checkedAt: now, latest }));
-        renameSync(staging, cachePath);
+        writeFileAtomicSync(cachePath, JSON.stringify({ checkedAt: now, latest }), { suffix: "tmp" });
     }
     catch {
-        try {
-            rmSync(staging, { force: true });
-        }
-        catch { }
     }
 }
 export async function latestVersion(cachePath = DEFAULT_UPDATE_CHECK_PATH, timeoutMs = 2000, now = Date.now()) {