ghcr-cleanup-manager 1.1.5 → 1.1.6

package/CHANGELOG.md

@@ -7,6 +7,12 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 
 ## [Unreleased]
 
+## [v1.1.6] - 2026-07-08
+
+### Fixed
+
+- Scan and cleanup now retry GitHub REST rate-limit responses consistently.
+
 ## [v1.1.5] - 2026-07-02
 
 ### Fixed

package/README.md

@@ -41,7 +41,7 @@ jobs:
 
       - name: Preview GHCR cleanup
         id: ghcr-cleanup-manager
-        uses: ghcr-manager/ghcr-cleanup-manager@v1.1.5
+        uses: ghcr-manager/ghcr-cleanup-manager@v1.1.6
         with:
           command: cleanup
           token: ${{ github.token }}
@@ -84,7 +84,7 @@ The action supports two commands:
 ### Preview cleanup
 
 ```yaml
-- uses: ghcr-manager/ghcr-cleanup-manager@v1.1.5
+- uses: ghcr-manager/ghcr-cleanup-manager@v1.1.6
   with:
     command: cleanup
     token: ${{ github.token }}
@@ -105,7 +105,7 @@ The action supports two commands:
 ### Apply cleanup
 
 ```yaml
-- uses: ghcr-manager/ghcr-cleanup-manager@v1.1.5
+- uses: ghcr-manager/ghcr-cleanup-manager@v1.1.6
   with:
     command: cleanup
     token: ${{ github.token }}
@@ -127,7 +127,7 @@ off `dry-run`.
 ### Scan one package
 
 ```yaml
-- uses: ghcr-manager/ghcr-cleanup-manager@v1.1.5
+- uses: ghcr-manager/ghcr-cleanup-manager@v1.1.6
   with:
     command: scan
     token: ${{ github.token }}

package/dist/core/_github-package-owner.js

@@ -1,5 +1,6 @@
 import { githubApiBaseUrl, githubApiVersion, ingestRequestRetryCount, ingestRequestRetryDelayMs } from "../config/index.js";
 import { buildHttpErrorMessage } from "./_http-error.js";
+import { runGitHubApiWithRetry, throwIfRetryableGitHubApiResponse } from "./_github-rest.js";
 const _ownerUriComponentByOwner = new Map();
 export async function getOwnerURIComponent(fetchImpl, owner, token, logger) {
     const cachedOwnerURIComponent = _ownerUriComponentByOwner.get(owner);
@@ -7,8 +8,8 @@ export async function getOwnerURIComponent(fetchImpl, owner, token, logger) {
         return cachedOwnerURIComponent;
     }
     const url = new URL(`/users/${encodeURIComponent(owner)}`, githubApiBaseUrl).toString();
-    for (let attempt = 1;; attempt += 1) {
-        const response = await fetchImpl(url, {
+    const response = await runGitHubApiWithRetry("GitHub owner lookup", logger, ingestRequestRetryCount, ingestRequestRetryDelayMs, async () => {
+        const ownerResponse = await fetchImpl(url, {
             headers: {
                 Accept: "application/vnd.github+json",
                 Authorization: `Bearer ${token}`,
@@ -16,30 +17,22 @@ export async function getOwnerURIComponent(fetchImpl, owner, token, logger) {
                 "X-GitHub-Api-Version": githubApiVersion
             }
         });
-        if (response.ok) {
-            const payload = (await response.json());
-            if (payload.type === "Organization") {
-                const ownerURIComponent = `orgs/${encodeURIComponent(owner)}`;
-                _ownerUriComponentByOwner.set(owner, ownerURIComponent);
-                return ownerURIComponent;
-            }
-            if (payload.type === "User") {
-                const ownerURIComponent = `users/${encodeURIComponent(owner)}`;
-                _ownerUriComponentByOwner.set(owner, ownerURIComponent);
-                return ownerURIComponent;
-            }
-            throw new Error(`GitHub owner lookup did not include a supported type`);
-        }
-        if (!_isRetryableStatus(response.status) || attempt > ingestRequestRetryCount) {
-            throw new Error(await buildHttpErrorMessage(response, "GitHub owner lookup failed"));
-        }
-        logger.warn(`GitHub owner lookup failed on attempt ${attempt}/${ingestRequestRetryCount + 1}; retrying in ${ingestRequestRetryDelayMs}ms - ${await buildHttpErrorMessage(response, "GitHub owner lookup failed")}`);
-        await _sleep(ingestRequestRetryDelayMs);
+        await throwIfRetryableGitHubApiResponse(ownerResponse, "GitHub owner lookup failed", ingestRequestRetryDelayMs);
+        return ownerResponse;
+    });
+    if (!response.ok) {
+        throw new Error(await buildHttpErrorMessage(response, "GitHub owner lookup failed"));
     }
-}
-function _isRetryableStatus(status) {
-    return status === 429 || status === 502 || status === 503 || status === 504;
-}
-function _sleep(delayMs) {
-    return new Promise((resolve) => setTimeout(resolve, delayMs));
+    const payload = (await response.json());
+    if (payload.type === "Organization") {
+        const ownerURIComponent = `orgs/${encodeURIComponent(owner)}`;
+        _ownerUriComponentByOwner.set(owner, ownerURIComponent);
+        return ownerURIComponent;
+    }
+    if (payload.type === "User") {
+        const ownerURIComponent = `users/${encodeURIComponent(owner)}`;
+        _ownerUriComponentByOwner.set(owner, ownerURIComponent);
+        return ownerURIComponent;
+    }
+    throw new Error(`GitHub owner lookup did not include a supported type`);
 }

package/dist/core/_github-rest.d.ts

@@ -0,0 +1,15 @@
+import { type HttpErrorResponse } from "./_http-error.js";
+export interface GitHubApiLogger {
+    warn(message: string): void;
+}
+export interface GitHubApiResponse extends HttpErrorResponse {
+    ok: boolean;
+}
+export declare class RetryableGitHubApiError extends Error {
+    readonly retryAfterMs?: number;
+    constructor(message: string, retryAfterMs?: number);
+}
+export declare function runGitHubApiWithRetry<T>(label: string, logger: GitHubApiLogger, retryCount: number, retryDelayMs: number, run: () => Promise<T>): Promise<T>;
+export declare function throwIfRetryableGitHubApiResponse(response: GitHubApiResponse, fallback: string, retryDelayMs: number): Promise<void>;
+export declare function isRetryableGitHubApiStatus(status: number): boolean;
+export declare function buildTransportErrorMessage(error: unknown, fallback: string): string;

package/dist/core/_github-rest.js

@@ -0,0 +1,116 @@
+import { buildHttpErrorMessage } from "./_http-error.js";
+const _RETRYABLE_STATUS_CODES = new Set([429, 502, 503, 504]);
+const _MINUTE_MS = 60_000;
+export class RetryableGitHubApiError extends Error {
+    retryAfterMs;
+    constructor(message, retryAfterMs) {
+        super(message);
+        this.name = "RetryableGitHubApiError";
+        this.retryAfterMs = retryAfterMs;
+    }
+}
+export async function runGitHubApiWithRetry(label, logger, retryCount, retryDelayMs, run) {
+    let attempt = 0;
+    for (;;) {
+        try {
+            return await run();
+        }
+        catch (error) {
+            attempt += 1;
+            if (attempt > retryCount || !_shouldRetryGitHubApiError(error)) {
+                throw error;
+            }
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            const resolvedRetryDelayMs = _resolveRetryDelayMs(error, retryDelayMs);
+            logger.warn(`${label} failed on attempt ${attempt}/${retryCount + 1}; retrying in ${resolvedRetryDelayMs}ms - ${errorMessage}`);
+            await _sleep(resolvedRetryDelayMs);
+        }
+    }
+}
+export async function throwIfRetryableGitHubApiResponse(response, fallback, retryDelayMs) {
+    if (response.ok) {
+        return;
+    }
+    const errorMessage = await buildHttpErrorMessage(response, fallback);
+    if (isRetryableGitHubApiStatus(response.status)) {
+        throw new RetryableGitHubApiError(errorMessage);
+    }
+    const rateLimitRetryAfterMs = _resolveRateLimitRetryAfterMs(response, errorMessage, retryDelayMs);
+    if (rateLimitRetryAfterMs !== undefined) {
+        throw new RetryableGitHubApiError(errorMessage, rateLimitRetryAfterMs);
+    }
+}
+export function isRetryableGitHubApiStatus(status) {
+    return _RETRYABLE_STATUS_CODES.has(status);
+}
+export function buildTransportErrorMessage(error, fallback) {
+    const details = [fallback];
+    details.push(..._collectErrorDetails(error));
+    return details.join(" - ");
+}
+function _shouldRetryGitHubApiError(error) {
+    return (error instanceof RetryableGitHubApiError ||
+        (error instanceof Error && /fetch failed|status 429|status 502|status 503|status 504/.test(error.message)));
+}
+function _resolveRetryDelayMs(error, retryDelayMs) {
+    if (error instanceof RetryableGitHubApiError && error.retryAfterMs !== undefined) {
+        return error.retryAfterMs;
+    }
+    return retryDelayMs;
+}
+function _resolveRateLimitRetryAfterMs(response, errorMessage, retryDelayMs) {
+    const retryAfterHeader = response.headers.get("retry-after");
+    if (retryAfterHeader) {
+        const retryAfterSeconds = Number.parseInt(retryAfterHeader, 10);
+        if (Number.isFinite(retryAfterSeconds) && retryAfterSeconds >= 0) {
+            return retryAfterSeconds * 1000;
+        }
+    }
+    const remaining = response.headers.get("x-ratelimit-remaining");
+    const reset = response.headers.get("x-ratelimit-reset");
+    if (remaining === "0" && reset) {
+        const resetEpochSeconds = Number.parseInt(reset, 10);
+        if (Number.isFinite(resetEpochSeconds)) {
+            return Math.max(resetEpochSeconds * 1000 - Date.now(), retryDelayMs);
+        }
+    }
+    if (/secondary rate limit|API rate limit exceeded/i.test(errorMessage)) {
+        return _MINUTE_MS;
+    }
+    return undefined;
+}
+function _sleep(delayMs) {
+    return new Promise((resolve) => setTimeout(resolve, delayMs));
+}
+function _collectErrorDetails(error) {
+    if (!(error instanceof Error)) {
+        return [String(error)];
+    }
+    const details = [];
+    const seen = new Set();
+    let current = error;
+    while (current instanceof Error && !seen.has(current)) {
+        seen.add(current);
+        const message = _formatErrorMessage(current);
+        if (message && !details.includes(message)) {
+            details.push(message);
+        }
+        current = current.cause;
+    }
+    return details.length > 0 ? details : [String(error)];
+}
+function _formatErrorMessage(error) {
+    const code = "code" in error && typeof error.code === "string"
+        ? error.code
+        : undefined;
+    if (error.message && code) {
+        return `${error.message} (${code})`;
+    }
+    if (error.message) {
+        return error.message;
+    }
+    if (code) {
+        return code;
+    }
+    return undefined;
+}

package/dist/core/index.d.ts

@@ -2,5 +2,6 @@ export type { ManifestEdgeKind, ManifestEdgeRecord, ManifestDescriptorRecord, Ma
 export { ManifestKinds } from "./_types.js";
 export type { HttpErrorResponse } from "./_http-error.js";
 export { buildHttpErrorMessage } from "./_http-error.js";
+export { buildTransportErrorMessage, isRetryableGitHubApiStatus, runGitHubApiWithRetry, throwIfRetryableGitHubApiResponse } from "./_github-rest.js";
 export { getOwnerURIComponent } from "./_github-package-owner.js";
 export { digestFromDigestTag, isDigestTag } from "./_digest-tag.js";

package/dist/core/index.js

@@ -1,4 +1,5 @@
 export { ManifestKinds } from "./_types.js";
 export { buildHttpErrorMessage } from "./_http-error.js";
+export { buildTransportErrorMessage, isRetryableGitHubApiStatus, runGitHubApiWithRetry, throwIfRetryableGitHubApiResponse } from "./_github-rest.js";
 export { getOwnerURIComponent } from "./_github-package-owner.js";
 export { digestFromDigestTag, isDigestTag } from "./_digest-tag.js";

package/dist/db/planner/_planner-plan-artifacts.js

@@ -47,7 +47,15 @@ export class PlannerPlanArtifacts {
     }
     #listClosureManifests(scanId) {
         return this.#sql
-            .all(_LIST_CLOSURE_MANIFESTS_SQL, [scanId, scanId, scanId, scanId, scanId, scanId, scanId])
+            .all(_LIST_CLOSURE_MANIFESTS_SQL, [
+            scanId,
+            scanId,
+            scanId,
+            scanId,
+            scanId,
+            scanId,
+            scanId
+        ])
             .map(mapClosureManifestRow);
     }
     #listBlockedRoots(scanId) {

package/dist/execute/_http.d.ts

@@ -1,7 +1,6 @@
 import type { DeleteExecutionLogger, GitHubPackageFetch, GitHubPackageFetchResponse } from "./_types.js";
-export { buildHttpErrorMessage } from "../core/index.js";
+export { buildHttpErrorMessage, buildTransportErrorMessage } from "../core/index.js";
 export declare function runWithRetry<T>(label: string, logger: DeleteExecutionLogger, run: () => Promise<T>): Promise<T>;
 export declare function isRetryableStatus(status: number): boolean;
-export declare function buildTransportErrorMessage(error: unknown, fallback: string): string;
 export declare function resolveFetch(fetchImpl?: GitHubPackageFetch): GitHubPackageFetch;
 export declare function resolveJsonHeaders(response: GitHubPackageFetchResponse): string | undefined;

package/dist/execute/_http.js

@@ -1,35 +1,11 @@
 import { executeRequestRetryCount, executeRequestRetryDelayMs } from "../config/index.js";
-export { buildHttpErrorMessage } from "../core/index.js";
-const _RETRYABLE_STATUS_CODES = new Set([429, 502, 503, 504]);
+import { isRetryableGitHubApiStatus, runGitHubApiWithRetry } from "../core/index.js";
+export { buildHttpErrorMessage, buildTransportErrorMessage } from "../core/index.js";
 export async function runWithRetry(label, logger, run) {
-    let attempt = 0;
-    for (;;) {
-        try {
-            return await run();
-        }
-        catch (error) {
-            attempt += 1;
-            if (attempt > executeRequestRetryCount || !_shouldRetryError(error)) {
-                throw error;
-            }
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            logger.warn(`${label} failed on attempt ${attempt}/${executeRequestRetryCount + 1}; retrying in ${executeRequestRetryDelayMs}ms - ${errorMessage}`);
-            await sleep(executeRequestRetryDelayMs);
-        }
-    }
+    return runGitHubApiWithRetry(label, logger, executeRequestRetryCount, executeRequestRetryDelayMs, run);
 }
 export function isRetryableStatus(status) {
-    return _RETRYABLE_STATUS_CODES.has(status);
-}
-export function buildTransportErrorMessage(error, fallback) {
-    const details = [fallback];
-    if (error instanceof Error && error.message) {
-        details.push(error.message);
-    }
-    else {
-        details.push(String(error));
-    }
-    return details.join(" - ");
+    return isRetryableGitHubApiStatus(status);
 }
 export function resolveFetch(fetchImpl) {
     return fetchImpl ?? fetch;
@@ -37,12 +13,3 @@ export function resolveFetch(fetchImpl) {
 export function resolveJsonHeaders(response) {
     return response.headers.get("content-type")?.split(";")[0];
 }
-function _shouldRetryError(error) {
-    if (!(error instanceof Error)) {
-        return false;
-    }
-    return /fetch failed|status 429|status 502|status 503|status 504/.test(error.message);
-}
-function sleep(delayMs) {
-    return new Promise((resolve) => setTimeout(resolve, delayMs));
-}

package/dist/execute/_package-version-delete-client.js

@@ -1,6 +1,6 @@
 import { githubApiBaseUrl, githubApiVersion } from "../config/index.js";
-import { getOwnerURIComponent } from "../core/index.js";
-import { buildHttpErrorMessage, buildTransportErrorMessage, isRetryableStatus, resolveFetch, runWithRetry } from "./_http.js";
+import { buildHttpErrorMessage, buildTransportErrorMessage, getOwnerURIComponent, throwIfRetryableGitHubApiResponse } from "../core/index.js";
+import { resolveFetch, runWithRetry } from "./_http.js";
 export async function deletePackageVersion(owner, packageName, versionId, token, logger, runtime) {
     const fetchImpl = resolveFetch(runtime?.fetchImpl);
     const ownerURIComponent = await getOwnerURIComponent(fetchImpl, owner, token, logger);
@@ -17,9 +17,7 @@ export async function deletePackageVersion(owner, packageName, versionId, token,
                     "X-GitHub-Api-Version": githubApiVersion
                 }
             });
-            if (!deleteResponse.ok && isRetryableStatus(deleteResponse.status)) {
-                throw new Error(await buildHttpErrorMessage(deleteResponse, `GitHub package delete request failed for version ${versionId}`));
-            }
+            await throwIfRetryableGitHubApiResponse(deleteResponse, `GitHub package delete request failed for version ${versionId}`, 1000);
             return deleteResponse;
         });
     }

package/dist/execute/_package-version-page-client.js

@@ -1,6 +1,6 @@
 import { githubApiBaseUrl, githubApiVersion } from "../config/index.js";
-import { getOwnerURIComponent } from "../core/index.js";
-import { buildHttpErrorMessage, buildTransportErrorMessage, isRetryableStatus, resolveFetch, runWithRetry } from "./_http.js";
+import { buildHttpErrorMessage, buildTransportErrorMessage, getOwnerURIComponent, throwIfRetryableGitHubApiResponse } from "../core/index.js";
+import { resolveFetch, runWithRetry } from "./_http.js";
 export async function findPackageVersionByDigestAndTag(owner, packageName, digest, tag, token, logger, runtime) {
     const fetchImpl = resolveFetch(runtime?.fetchImpl);
     for (let attempt = 1; attempt <= 5; attempt += 1) {
@@ -31,9 +31,7 @@ export async function loadPackageVersionPage(owner, packageName, page, token, lo
                     "X-GitHub-Api-Version": githubApiVersion
                 }
             });
-            if (!pageResponse.ok && isRetryableStatus(pageResponse.status)) {
-                throw new Error(await buildHttpErrorMessage(pageResponse, `GitHub Packages request for page ${page} failed`));
-            }
+            await throwIfRetryableGitHubApiResponse(pageResponse, `GitHub Packages request for page ${page} failed`, 1000);
             return pageResponse;
         });
     }

package/dist/ingest/github/_package-metadata-load.js

@@ -1,12 +1,12 @@
-import { githubApiBaseUrl, githubApiVersion } from "../../config/index.js";
-import { getOwnerURIComponent } from "../../core/index.js";
-import { buildFetchTransportErrorMessage, buildHttpErrorMessage, withFetchRetry } from "./_shared.js";
+import { githubApiBaseUrl, githubApiVersion, ingestRequestRetryCount, ingestRequestRetryDelayMs } from "../../config/index.js";
+import { buildHttpErrorMessage, getOwnerURIComponent, runGitHubApiWithRetry, throwIfRetryableGitHubApiResponse } from "../../core/index.js";
+import { buildFetchTransportErrorMessage } from "./_shared.js";
 export async function loadPackageMetadata(fetchImpl, options) {
     const ownerURIComponent = await getOwnerURIComponent(fetchImpl, options.owner, options.token, options.logger);
     const url = new URL(`/${ownerURIComponent}/packages/container/${encodeURIComponent(options.packageName)}`, githubApiBaseUrl).toString();
     let response;
     try {
-        response = await withFetchRetry(async () => {
+        response = await runGitHubApiWithRetry("GitHub package metadata request", options.logger, ingestRequestRetryCount, ingestRequestRetryDelayMs, async () => {
             const packageResponse = await fetchImpl(url, {
                 headers: {
                     Accept: "application/vnd.github+json",
@@ -15,14 +15,8 @@ export async function loadPackageMetadata(fetchImpl, options) {
                     "X-GitHub-Api-Version": githubApiVersion
                 }
             });
-            if (!packageResponse.ok && _shouldRetryStatus(packageResponse.status)) {
-                throw new Error(await buildHttpErrorMessage(packageResponse, "GitHub package metadata request failed"));
-            }
+            await throwIfRetryableGitHubApiResponse(packageResponse, "GitHub package metadata request failed", ingestRequestRetryDelayMs);
             return packageResponse;
-        }, {
-            logger: options.logger,
-            label: "GitHub package metadata request",
-            shouldRetry: (error) => _shouldRetryError(error)
         });
     }
     catch (error) {
@@ -34,12 +28,3 @@ export async function loadPackageMetadata(fetchImpl, options) {
     const payload = (await response.json());
     return { rawJson: JSON.stringify(payload) };
 }
-function _shouldRetryStatus(status) {
-    return status === 429 || status === 502 || status === 503 || status === 504;
-}
-function _shouldRetryError(error) {
-    if (!(error instanceof Error)) {
-        return false;
-    }
-    return /fetch failed|status 429|status 502|status 503|status 504/.test(error.message);
-}

package/dist/ingest/github/_package-version-page-load.js

@@ -1,12 +1,12 @@
-import { githubApiBaseUrl, githubApiVersion } from "../../config/index.js";
-import { getOwnerURIComponent } from "../../core/index.js";
-import { buildFetchTransportErrorMessage, buildHttpErrorMessage, withFetchRetry } from "./_shared.js";
+import { githubApiBaseUrl, githubApiVersion, ingestRequestRetryCount, ingestRequestRetryDelayMs } from "../../config/index.js";
+import { buildHttpErrorMessage, getOwnerURIComponent, runGitHubApiWithRetry, throwIfRetryableGitHubApiResponse } from "../../core/index.js";
+import { buildFetchTransportErrorMessage } from "./_shared.js";
 export async function loadPackageVersionPage(fetchImpl, options, page) {
     const startTime = Date.now();
     const url = await buildPackageVersionPageUrl(fetchImpl, options, page);
     let response;
     try {
-        response = await withFetchRetry(async () => {
+        response = await runGitHubApiWithRetry(`GitHub Packages request for page ${page}`, options.logger, ingestRequestRetryCount, ingestRequestRetryDelayMs, async () => {
             const pageResponse = await fetchImpl(url, {
                 headers: {
                     Accept: "application/vnd.github+json",
@@ -15,14 +15,8 @@ export async function loadPackageVersionPage(fetchImpl, options, page) {
                     "X-GitHub-Api-Version": githubApiVersion
                 }
             });
-            if (!pageResponse.ok && _shouldRetryStatus(pageResponse.status)) {
-                throw new Error(await buildHttpErrorMessage(pageResponse, `GitHub Packages request for page ${page} failed`));
-            }
+            await throwIfRetryableGitHubApiResponse(pageResponse, `GitHub Packages request for page ${page} failed`, ingestRequestRetryDelayMs);
             return pageResponse;
-        }, {
-            logger: options.logger,
-            label: `GitHub Packages request for page ${page}`,
-            shouldRetry: (error) => _shouldRetryError(error)
         });
     }
     catch (error) {
@@ -44,12 +38,3 @@ async function buildPackageVersionPageUrl(fetchImpl, options, page) {
     url.searchParams.set("page", String(page));
     return url.toString();
 }
-function _shouldRetryStatus(status) {
-    return status === 429 || status === 502 || status === 503 || status === 504;
-}
-function _shouldRetryError(error) {
-    if (!(error instanceof Error)) {
-        return false;
-    }
-    return /fetch failed|status 429|status 502|status 503|status 504/.test(error.message);
-}

package/dist/ingest/github/_shared.js

@@ -1,4 +1,5 @@
 import { ingestRequestRetryCount, ingestRequestRetryDelayMs } from "../../config/index.js";
+import { buildTransportErrorMessage } from "../../core/index.js";
 export { buildHttpErrorMessage } from "../../core/index.js";
 export const acceptedManifestMediaTypes = [
     "application/vnd.oci.image.index.v1+json",
@@ -11,9 +12,7 @@ export async function defaultFetch(input, init) {
     return fetch(input, init);
 }
 export function buildFetchTransportErrorMessage(error, fallback) {
-    const details = [fallback];
-    details.push(..._collectErrorDetails(error));
-    return details.join(" - ");
+    return buildTransportErrorMessage(error, fallback);
 }
 export async function withFetchRetry(run, options) {
     let attempt = 0;
@@ -36,35 +35,3 @@ export async function withFetchRetry(run, options) {
 function _sleep(delayMs) {
     return new Promise((resolve) => setTimeout(resolve, delayMs));
 }
-function _collectErrorDetails(error) {
-    if (!(error instanceof Error)) {
-        return [String(error)];
-    }
-    const details = [];
-    const seen = new Set();
-    let current = error;
-    while (current instanceof Error && !seen.has(current)) {
-        seen.add(current);
-        const message = _formatErrorMessage(current);
-        if (message && !details.includes(message)) {
-            details.push(message);
-        }
-        current = current.cause;
-    }
-    return details.length > 0 ? details : [String(error)];
-}
-function _formatErrorMessage(error) {
-    const code = "code" in error && typeof error.code === "string"
-        ? error.code
-        : undefined;
-    if (error.message && code) {
-        return `${error.message} (${code})`;
-    }
-    if (error.message) {
-        return error.message;
-    }
-    if (code) {
-        return code;
-    }
-    return undefined;
-}

package/package.json

@@ -2,7 +2,7 @@
   "name": "ghcr-cleanup-manager",
   "description": "GHCR Cleanup Manager: GitHub Action and CLI for safe GitHub Container Registry cleanup and inspection.",
   "homepage": "https://github.com/ghcr-manager/ghcr-cleanup-manager#readme",
-  "version": "v1.1.5",
+  "version": "v1.1.6",
   "license": "MIT",
   "type": "module",
   "keywords": [