no-mistakes 0.17.0 → 0.19.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "no-mistakes",
-  "version": "0.17.0",
+  "version": "0.19.0",
   "description": "Static codebase analysis tools for TS/JS dependencies, dependents, and symbols",
   "license": "MIT",
   "repository": {

package/scripts/install/download.js

@@ -7,23 +7,29 @@ const https = require("node:https");
 const { pipeline } = require("node:stream/promises");
 const { fileURLToPath } = require("node:url");
 
+const { HttpError, withRetry } = require("./retry");
+
 const DOWNLOAD_TIMEOUT_MS = 30_000;
 
-function download(url, destination, redirects = 0, validateUrl = () => {}) {
+function download(url, destination, redirects = 0, validateUrl = () => {}, retryOptions) {
   validateUrl(url);
   if (isFileUrl(url)) {
     return copyFile(fileURLToPath(url), destination);
   }
 
-  return request(
-    url,
-    async (response) => {
-      await pipeline(response, createWriteStream(destination));
-    },
-    redirects,
-    { http, https },
-    DOWNLOAD_TIMEOUT_MS,
-    validateUrl,
+  return withRetry(
+    () =>
+      request(
+        url,
+        async (response) => {
+          await pipeline(response, createWriteStream(destination));
+        },
+        redirects,
+        { http, https },
+        DOWNLOAD_TIMEOUT_MS,
+        validateUrl,
+      ),
+    { ...retryOptions, describe: () => `download of ${url}` },
   );
 }
 
@@ -67,7 +73,7 @@ function request(
 
       if (response.statusCode !== 200) {
         response.resume();
-        reject(new Error(`Download failed for ${url}: HTTP ${response.statusCode}`));
+        reject(new HttpError(url, response.statusCode));
         return;
       }
 
@@ -75,7 +81,9 @@ function request(
     });
 
     req.setTimeout(timeoutMs, () => {
-      req.destroy(new Error(`Download timed out after ${timeoutMs}ms: ${url}`));
+      const timeoutError = new Error(`Download timed out after ${timeoutMs}ms: ${url}`);
+      timeoutError.retryable = true;
+      req.destroy(timeoutError);
     });
     req.on("error", reject);
   });
@@ -85,32 +93,37 @@ function isRedirectStatus(statusCode) {
   return [301, 302, 303, 307, 308].includes(statusCode);
 }
 
-async function fetchText(url, validateUrl = () => {}) {
+async function fetchText(url, validateUrl = () => {}, retryOptions) {
   validateUrl(url);
 
   if (isFileUrl(url)) {
     return readFile(fileURLToPath(url), "utf8");
   }
-  const chunks = [];
-  let totalLength = 0;
   const MAX_LENGTH = 1024 * 1024;
-  await request(
-    url,
-    async (response) => {
-      for await (const chunk of response) {
-        totalLength += chunk.length;
-        if (totalLength > MAX_LENGTH) {
-          throw new Error(`Response exceeded maximum size of ${MAX_LENGTH} bytes`);
-        }
-        chunks.push(chunk);
-      }
+  return withRetry(
+    async () => {
+      const chunks = [];
+      let totalLength = 0;
+      await request(
+        url,
+        async (response) => {
+          for await (const chunk of response) {
+            totalLength += chunk.length;
+            if (totalLength > MAX_LENGTH) {
+              throw new Error(`Response exceeded maximum size of ${MAX_LENGTH} bytes`);
+            }
+            chunks.push(chunk);
+          }
+        },
+        0,
+        { http, https },
+        DOWNLOAD_TIMEOUT_MS,
+        validateUrl,
+      );
+      return Buffer.concat(chunks).toString("utf8");
     },
-    0,
-    { http, https },
-    DOWNLOAD_TIMEOUT_MS,
-    validateUrl,
+    { ...retryOptions, describe: () => `fetch of ${url}` },
   );
-  return Buffer.concat(chunks).toString("utf8");
 }
 
 function isFileUrl(url) {

package/scripts/install/index.js

@@ -4,10 +4,12 @@ const assets = require("./assets");
 const download = require("./download");
 const installer = require("./installer");
 const platform = require("./platform");
+const retry = require("./retry");
 
 module.exports = {
   ...assets,
   ...download,
   ...installer,
   ...platform,
+  ...retry,
 };

package/scripts/install/retry.js

@@ -0,0 +1,94 @@
+"use strict";
+
+const DEFAULT_MAX_ATTEMPTS = 4;
+const DEFAULT_RETRY_BASE_MS = 500;
+const RETRY_MAX_DELAY_MS = 4_000;
+const RETRYABLE_NETWORK_CODES = new Set([
+  "ECONNRESET",
+  "ECONNREFUSED",
+  "ETIMEDOUT",
+  "EAI_AGAIN",
+  "ENETUNREACH",
+  "EPIPE",
+  "ERR_STREAM_PREMATURE_CLOSE",
+]);
+
+class HttpError extends Error {
+  constructor(url, statusCode) {
+    super(`Download failed for ${url}: HTTP ${statusCode}`);
+    this.name = "HttpError";
+    this.statusCode = statusCode;
+    this.retryable = isRetryableStatus(statusCode);
+  }
+}
+
+function isRetryableStatus(statusCode) {
+  if (typeof statusCode !== "number") return false;
+  if (statusCode >= 500 && statusCode < 600) return true;
+  return statusCode === 408 || statusCode === 429;
+}
+
+function isRetryableError(error) {
+  if (!error) return false;
+  if (error.retryable === true) return true;
+  if (error.code && RETRYABLE_NETWORK_CODES.has(error.code)) return true;
+  return false;
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function parsePositiveInt(value, fallback) {
+  if (value === undefined || value === null || value === "") return fallback;
+  const n = Number(value);
+  if (!Number.isFinite(n) || !Number.isInteger(n) || n < 1) return fallback;
+  return n;
+}
+
+function computeBackoffMs(attempt, baseDelayMs, random = Math.random) {
+  const exponential = baseDelayMs * 2 ** (attempt - 1);
+  const capped = Math.min(exponential, RETRY_MAX_DELAY_MS);
+  return Math.floor(random() * capped);
+}
+
+async function withRetry(fn, options = {}) {
+  const maxAttempts = parsePositiveInt(
+    options.maxAttempts ?? process.env.NO_MISTAKES_DOWNLOAD_MAX_ATTEMPTS,
+    DEFAULT_MAX_ATTEMPTS,
+  );
+  const baseDelayMs = parsePositiveInt(
+    options.baseDelayMs ?? process.env.NO_MISTAKES_DOWNLOAD_RETRY_BASE_MS,
+    DEFAULT_RETRY_BASE_MS,
+  );
+  const delay = options.delay ?? sleep;
+  const random = options.random ?? Math.random;
+  const logger = options.logger ?? console;
+  const describe = options.describe ?? (() => "download");
+
+  let attempt = 0;
+  for (;;) {
+    attempt += 1;
+    try {
+      return await fn();
+    } catch (error) {
+      if (attempt >= maxAttempts || !isRetryableError(error)) {
+        throw error;
+      }
+      const waitMs = computeBackoffMs(attempt, baseDelayMs, random);
+      logger.warn(
+        `no-mistakes: retrying ${describe()} after ${error.message} (attempt ${attempt + 1}/${maxAttempts}, waiting ~${waitMs}ms)`,
+      );
+      await delay(waitMs);
+    }
+  }
+}
+
+module.exports = {
+  HttpError,
+  computeBackoffMs,
+  isRetryableError,
+  isRetryableStatus,
+  parsePositiveInt,
+  withRetry,
+};