Method #executeWithBackoff

src/github/github_fetch.mjs:411–451

(args, parseFn)

  }

  async #executeWithBackoff(args, parseFn) {
    // "Basics": only retry once, and only if we can infer a short wait.
    for (let attempt = 0; attempt < 2; attempt++) {
      const res = await this.ghRunner(args);
      if (res.timedOut) throw new Error(`gh timed out: gh ${args.join(' ')}`);
      if (res.exitCode !== 0 && !res.stdout) {
        throw new Error(`gh failed (exit ${res.exitCode}): ${res.stderr || 'unknown error'}`);
      }

      const parsed = parseFn(res.stdout);
      const status = parsed.status;
      const headers = parsed.headers || {};

      const isRateLimited =
        status === 429 ||
        (status === 403 && String(headers['x-ratelimit-remaining'] || '') === '0');

      if (!isRateLimited || attempt === 1) return parsed;

      const retryAfter = Number(headers['retry-after'] || 'NaN');
      const resetEpoch = Number(headers['x-ratelimit-reset'] || 'NaN');
      const nowEpoch = Math.floor(Date.now() / 1000);

      let waitSeconds = Number.isFinite(retryAfter) ? retryAfter : NaN;
      if (!Number.isFinite(waitSeconds) && Number.isFinite(resetEpoch)) {
        waitSeconds = Math.max(0, resetEpoch - nowEpoch);
      }
      if (!Number.isFinite(waitSeconds)) {
        // Can't infer; don't spin.
        return parsed;
      }

      waitSeconds = Math.min(waitSeconds, this.maxBackoffSeconds);
      if (waitSeconds > 0) {
        await this.sleepFn(waitSeconds * 1000);
      }
    }

    // Unreachable
    throw new Error('unexpected backoff loop state');
  }
}