@allurereport/service 3.17.0 → 3.19.0

package/dist/history.d.ts

@@ -13,6 +13,7 @@ export declare class AllureRemoteHistory implements AllureHistory {
         repo?: string;
         branch?: string;
     });
+    resolveTestResultUrl(historyUrl: string, pluginId: string, historicalResultId: string): string;
     readHistory(params?: {
         repo?: string;
         branch?: string;

package/dist/history.js

@@ -4,6 +4,15 @@ export class AllureRemoteHistory {
     constructor(params) {
         this.params = params;
     }
+    resolveTestResultUrl(historyUrl, pluginId, historicalResultId) {
+        if (!historyUrl) {
+            return "";
+        }
+        const { origin, pathname } = new URL(historyUrl);
+        const navigateUrl = new URL([pathname, pluginId].join("/"), origin);
+        navigateUrl.hash = historicalResultId;
+        return navigateUrl.toString();
+    }
     async readHistory(params) {
         const { limit } = this.params;
         try {

package/dist/model.d.ts

@@ -16,6 +16,7 @@ export type UploadReportPayload = {
     files: Record<string, string> | Record<string, string>[];
     onProgress?: (uploadedFilesDelta?: number) => void;
     uploadBatchMaxBytes?: number;
+    signal?: AbortSignal;
 };
 export type UploadReportFilePayload = {
     filename: string;

package/dist/service.js

@@ -9,21 +9,34 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _AllureServiceClient_client, _AllureServiceClient_url;
+var _AllureServiceClient_instances, _AllureServiceClient_client, _AllureServiceClient_url, _AllureServiceClient_uploadedAssets, _AllureServiceClient_uploadRawFile, _AllureServiceClient_uploadPreparedFile;
+import { createReadStream } from "node:fs";
+import { stat } from "node:fs/promises";
 import { join as joinPosix } from "node:path/posix";
+import { parseIntegerConfigValue } from "@allurereport/core-api";
 import { ALLURE_SERVICE_STORAGE_PREFIX, } from "./model.js";
-import { createServiceHttpClient, uploadReport } from "./utils/http.js";
+import { createServiceHttpClient } from "./utils/http.js";
+import { encodeUploadPath, normalizeUploadPath, uploadStorageReport } from "./utils/storage.js";
 import { parseServiceToken } from "./utils/token.js";
 import { createUploadForm } from "./utils/upload.js";
 const UPLOAD_CONTENT_TYPE = "application/octet-stream";
 const createUploadBlob = (content) => new Blob([content], { type: UPLOAD_CONTENT_TYPE });
 const createReportUrl = (baseUrl, reportUuid) => `${baseUrl}/${reportUuid}`;
 const createReportFileUrl = (baseUrl, reportUuid, reportFilename) => `${baseUrl}/${joinPosix(reportUuid, reportFilename)}`;
+const resolveUploadConcurrency = (value) => {
+    const concurrency = parseIntegerConfigValue(value) ?? 10;
+    if (concurrency <= 0) {
+        throw new Error(`Allure service upload concurrency must resolve to an integer greater than 0; received ${String(value)}`);
+    }
+    return concurrency;
+};
 export class AllureServiceClient {
     constructor(config) {
+        _AllureServiceClient_instances.add(this);
         this.config = config;
         _AllureServiceClient_client.set(this, void 0);
         _AllureServiceClient_url.set(this, void 0);
+        _AllureServiceClient_uploadedAssets.set(this, new Map());
         if (!config?.accessToken) {
             throw new Error("Allure service access token is required");
         }
@@ -65,19 +78,29 @@ export class AllureServiceClient {
             ...historyPoint,
             url: createReportUrl(__classPrivateFieldGet(this, _AllureServiceClient_url, "f"), reportUuid),
         };
-        return __classPrivateFieldGet(this, _AllureServiceClient_client, "f").post(`/api/reports/${reportUuid}/complete`, {
-            body: {
-                historyPoint: completedHistoryPoint,
-            },
-        });
+        try {
+            return await __classPrivateFieldGet(this, _AllureServiceClient_client, "f").post(`/api/reports/${reportUuid}/complete`, {
+                body: {
+                    historyPoint: completedHistoryPoint,
+                },
+            });
+        }
+        finally {
+            __classPrivateFieldGet(this, _AllureServiceClient_uploadedAssets, "f").delete(reportUuid);
+        }
     }
     async deleteReport(payload) {
         const { reportUuid, pluginId = "" } = payload;
-        return __classPrivateFieldGet(this, _AllureServiceClient_client, "f").post(`/api/report/${reportUuid}/delete`, {
-            body: {
-                pluginId,
-            },
-        });
+        try {
+            return await __classPrivateFieldGet(this, _AllureServiceClient_client, "f").post(`/api/report/${reportUuid}/delete`, {
+                body: {
+                    pluginId,
+                },
+            });
+        }
+        finally {
+            __classPrivateFieldGet(this, _AllureServiceClient_uploadedAssets, "f").delete(reportUuid);
+        }
     }
     async addReportAssets(payload) {
         const { files, signal } = payload;
@@ -94,7 +117,12 @@ export class AllureServiceClient {
         });
     }
     async addReportAsset(payload) {
-        return this.addReportAssets({ files: [payload], ...(payload.signal ? { signal: payload.signal } : {}) });
+        const remotePath = normalizeUploadPath(payload.filename);
+        return __classPrivateFieldGet(this, _AllureServiceClient_instances, "m", _AllureServiceClient_uploadRawFile).call(this, {
+            ...payload,
+            endpoint: "/api/assets",
+            remotePath,
+        });
     }
     async addReportFiles(payload) {
         const { reportUuid, pluginId, files, signal } = payload;
@@ -115,26 +143,59 @@ export class AllureServiceClient {
         ]));
     }
     async addReportFile(payload) {
-        const result = await this.addReportFiles({
-            reportUuid: payload.reportUuid,
-            pluginId: payload.pluginId,
-            files: [payload],
-            ...(payload.signal ? { signal: payload.signal } : {}),
+        const filename = normalizeUploadPath(payload.filename);
+        const remotePath = payload.pluginId ? `${normalizeUploadPath(payload.pluginId)}/${filename}` : filename;
+        await __classPrivateFieldGet(this, _AllureServiceClient_instances, "m", _AllureServiceClient_uploadRawFile).call(this, {
+            ...payload,
+            endpoint: `/api/reports/${payload.reportUuid}/files`,
+            remotePath,
         });
-        return result[payload.filename];
+        return createReportFileUrl(__classPrivateFieldGet(this, _AllureServiceClient_url, "f"), payload.reportUuid, remotePath);
     }
     async uploadReport(payload) {
-        const { uploadBatchMaxBytes: _uploadBatchMaxBytes, ...uploadPayload } = payload;
-        return uploadReport({
-            ...uploadPayload,
-            uploadConcurrency: this.config.uploadConcurrency,
+        const uploadedAssets = __classPrivateFieldGet(this, _AllureServiceClient_uploadedAssets, "f").get(payload.reportUuid) ?? new Set();
+        __classPrivateFieldGet(this, _AllureServiceClient_uploadedAssets, "f").set(payload.reportUuid, uploadedAssets);
+        return uploadStorageReport({
+            ...payload,
+            uploadConcurrency: resolveUploadConcurrency(this.config.uploadConcurrency),
             uploadMaxAttempts: this.config.uploadMaxAttempts,
             uploadMaxSimultaneousFailures: this.config.uploadMaxSimultaneousFailures,
-            addReportAsset: this.addReportAsset.bind(this),
-            addReportAssets: this.addReportAssets.bind(this),
-            addReportFile: this.addReportFile.bind(this),
-            addReportFiles: this.addReportFiles.bind(this),
+            uploadedAssets,
+            upload: (file, signal) => __classPrivateFieldGet(this, _AllureServiceClient_instances, "m", _AllureServiceClient_uploadPreparedFile).call(this, payload.reportUuid, file, signal),
         });
     }
 }
-_AllureServiceClient_client = new WeakMap(), _AllureServiceClient_url = new WeakMap();
+_AllureServiceClient_client = new WeakMap(), _AllureServiceClient_url = new WeakMap(), _AllureServiceClient_uploadedAssets = new WeakMap(), _AllureServiceClient_instances = new WeakSet(), _AllureServiceClient_uploadRawFile = async function _AllureServiceClient_uploadRawFile(payload) {
+    const { endpoint, remotePath, file, filepath, signal } = payload;
+    if (file === undefined && !filepath) {
+        throw new Error("File or filepath is required");
+    }
+    const size = payload.size ?? (file !== undefined ? file.length : (await stat(filepath)).size);
+    const body = file ?? createReadStream(filepath, { signal });
+    try {
+        return await __classPrivateFieldGet(this, _AllureServiceClient_client, "f").put(`${endpoint}?path=${encodeUploadPath(remotePath)}`, {
+            body,
+            headers: {
+                "Content-Length": size,
+                "Content-Type": UPLOAD_CONTENT_TYPE,
+            },
+            maxBodyLength: Number.POSITIVE_INFINITY,
+            maxContentLength: Number.POSITIVE_INFINITY,
+            ...(signal ? { signal } : {}),
+        });
+    }
+    finally {
+        if (!Buffer.isBuffer(body)) {
+            body.destroy();
+        }
+    }
+}, _AllureServiceClient_uploadPreparedFile = async function _AllureServiceClient_uploadPreparedFile(reportUuid, file, signal) {
+    const endpoint = file.kind === "report" ? `/api/reports/${reportUuid}/files` : "/api/assets";
+    await __classPrivateFieldGet(this, _AllureServiceClient_instances, "m", _AllureServiceClient_uploadRawFile).call(this, {
+        ...file,
+        endpoint,
+        remotePath: file.remotePath,
+        signal,
+    });
+    return file.kind === "report" ? createReportFileUrl(__classPrivateFieldGet(this, _AllureServiceClient_url, "f"), reportUuid, file.remotePath) : undefined;
+};

package/dist/utils/http.d.ts

@@ -2,12 +2,29 @@ import { type AxiosRequestConfig } from "axios";
 import type { UploadReportConfig, UploadReportFilePayload, UploadReportFilesPayload, UploadReportPayload, UploadReportResult } from "../model.js";
 export declare class KnownError extends Error {
     status?: number;
-    constructor(message: string, status?: number, options?: ErrorOptions);
+    details?: ServiceHttpErrorDetails;
+    constructor(message: string, status?: number, options?: ErrorOptions & {
+        details?: ServiceHttpErrorDetails;
+    });
 }
 export declare class UnknownError extends Error {
     stack?: string;
-    constructor(message: string, stack?: string, options?: ErrorOptions);
+    details?: ServiceHttpErrorDetails;
+    constructor(message: string, stack?: string, options?: ErrorOptions & {
+        details?: ServiceHttpErrorDetails;
+    });
 }
+export type ServiceHttpErrorDetails = {
+    method: string;
+    endpoint: string;
+    status?: number;
+    statusText?: string;
+    responseMessage?: string;
+    rayId?: string;
+    mitigated?: string;
+    retryAfter?: string;
+    networkCode?: string;
+};
 export declare const formatResponseErrorData: (data: unknown) => string | undefined;
 export declare const formatServiceHttpErrorMessage: (payload: {
     method: string;
@@ -16,6 +33,9 @@ export declare const formatServiceHttpErrorMessage: (payload: {
     statusText?: string;
     data?: unknown;
     fallbackMessage?: string;
+    contentType?: string;
+    rayId?: string;
+    mitigated?: string;
 }) => string;
 export declare const createServiceHttpClient: (serviceUrl: string, params?: {
     accessToken?: string;

package/dist/utils/http.js

@@ -3,19 +3,50 @@ import axios, { isAxiosError } from "axios";
 import { isReportDataFile } from "./files.js";
 export class KnownError extends Error {
     constructor(message, status, options) {
-        super(message, options);
+        const { details, ...errorOptions } = options ?? {};
+        super(message, errorOptions);
         this.name = "KnownError";
         this.status = status;
+        this.details = details;
     }
 }
 export class UnknownError extends Error {
     constructor(message, stack, options) {
-        super(message, options);
+        const { details, ...errorOptions } = options ?? {};
+        super(message, errorOptions);
         this.name = "UnknownError";
         this.stack = stack;
+        this.details = details;
     }
 }
 const ERROR_MESSAGE_FIELDS = ["message", "error_description", "error", "detail", "title", "description"];
+const MAX_RESPONSE_MESSAGE_LENGTH = 512;
+const truncateResponseMessage = (message) => {
+    if (!message) {
+        return undefined;
+    }
+    const normalized = message.replace(/\s+/g, " ").trim();
+    if (normalized.length <= MAX_RESPONSE_MESSAGE_LENGTH) {
+        return normalized;
+    }
+    return `${normalized.slice(0, MAX_RESPONSE_MESSAGE_LENGTH)}…`;
+};
+const responseHeader = (headers, name) => {
+    if (!headers || typeof headers !== "object") {
+        return undefined;
+    }
+    const headerGetter = headers.get;
+    if (typeof headerGetter === "function") {
+        const value = headerGetter.call(headers, name);
+        return value === undefined || value === null ? undefined : String(value);
+    }
+    const entries = Object.entries(headers);
+    const entry = entries.find(([headerName]) => headerName.toLowerCase() === name.toLowerCase());
+    if (!entry || entry[1] === undefined || entry[1] === null) {
+        return undefined;
+    }
+    return Array.isArray(entry[1]) ? entry[1].join(", ") : String(entry[1]);
+};
 const stringifyErrorObject = (value) => {
     try {
         return JSON.stringify(value);
@@ -103,11 +134,18 @@ export const formatResponseErrorData = (data) => {
     return stringifyErrorObject(errorData);
 };
 export const formatServiceHttpErrorMessage = (payload) => {
-    const { method, endpoint, status, statusText, data, fallbackMessage } = payload;
+    const { method, endpoint, status, statusText, data, fallbackMessage, contentType, rayId, mitigated } = payload;
     const request = `${method.toUpperCase()} ${endpoint}`;
+    if (status === 403 && mitigated === "challenge") {
+        return `Allure service request failed: ${request} was blocked by a Cloudflare managed challenge (status 403${rayId ? `, ray ${rayId}` : ""}). Machine API routes must be excluded from browser challenges.`;
+    }
     const statusMessage = status ? ` responded with ${status}${statusText ? ` ${statusText}` : ""}` : " failed";
-    const details = formatResponseErrorData(data) || fallbackMessage;
-    return `Allure service request failed: ${request}${statusMessage}${details ? `: ${details}` : ""}`;
+    const responseMessage = contentType?.toLowerCase().includes("text/html") ? undefined : formatResponseErrorData(data);
+    const details = truncateResponseMessage(responseMessage || fallbackMessage);
+    const metadata = [rayId ? `ray ${rayId}` : undefined, mitigated ? `cf-mitigated ${mitigated}` : undefined]
+        .filter(Boolean)
+        .join(", ");
+    return `Allure service request failed: ${request}${statusMessage}${metadata ? ` (${metadata})` : ""}${details ? `: ${details}` : ""}`;
 };
 export const createServiceHttpClient = (serviceUrl, params) => {
     const client = axios.create({
@@ -145,8 +183,24 @@ export const createServiceHttpClient = (serviceUrl, params) => {
             if (!axiosError) {
                 throw err;
             }
-            const { data, status, statusText } = err.response ?? {};
+            const { data, status, statusText, headers: responseHeaders } = err.response ?? {};
             const responseStatus = status ?? 500;
+            const contentType = responseHeader(responseHeaders, "content-type");
+            const rayId = responseHeader(responseHeaders, "cf-ray");
+            const mitigated = responseHeader(responseHeaders, "cf-mitigated");
+            const retryAfter = responseHeader(responseHeaders, "retry-after");
+            const responseMessage = truncateResponseMessage(contentType?.toLowerCase().includes("text/html") ? undefined : formatResponseErrorData(data));
+            const details = {
+                method,
+                endpoint,
+                status,
+                statusText,
+                responseMessage,
+                rayId,
+                mitigated,
+                retryAfter,
+                networkCode: err.code,
+            };
             const errorMessage = formatServiceHttpErrorMessage({
                 method,
                 endpoint,
@@ -154,11 +208,14 @@ export const createServiceHttpClient = (serviceUrl, params) => {
                 statusText,
                 data,
                 fallbackMessage: err.message,
+                contentType,
+                rayId,
+                mitigated,
             });
             if (responseStatus < 500) {
-                throw new KnownError(errorMessage, responseStatus, { cause: err });
+                throw new KnownError(errorMessage, responseStatus, { cause: err, details });
             }
-            throw new UnknownError(errorMessage, err.stack, { cause: err });
+            throw new UnknownError(errorMessage, err.stack, { cause: err, details });
         }
     };
     return {

package/dist/utils/storage.d.ts

@@ -0,0 +1,13 @@
+import type { UploadReportConfig, UploadReportFilePayload, UploadReportPayload, UploadReportResult } from "../model.js";
+export type StorageUploadFile = UploadReportFilePayload & {
+    kind: "report" | "asset";
+    normalizedFilename: string;
+    remotePath: string;
+    size: number;
+};
+export declare const normalizeUploadPath: (path: string) => string;
+export declare const encodeUploadPath: (path: string) => string;
+export declare const uploadStorageReport: (payload: UploadReportPayload & UploadReportConfig & {
+    uploadedAssets: Set<string>;
+    upload: (file: StorageUploadFile, signal: AbortSignal) => Promise<string | undefined>;
+}) => Promise<UploadReportResult>;

package/dist/utils/storage.js

@@ -0,0 +1,263 @@
+import { stat } from "node:fs/promises";
+import { posix, win32 } from "node:path";
+import { isReportDataFile } from "./files.js";
+import { KnownError, UnknownError } from "./http.js";
+const RETRYABLE_STATUSES = new Set([408, 425, 429, 500, 502, 503, 504]);
+const RETRYABLE_NETWORK_CODES = new Set([
+    "EAI_AGAIN",
+    "ECONNABORTED",
+    "ECONNREFUSED",
+    "ECONNRESET",
+    "EHOSTUNREACH",
+    "ENETDOWN",
+    "ENETUNREACH",
+    "EPIPE",
+    "ETIMEDOUT",
+    "ERR_NETWORK",
+]);
+const INITIAL_RETRY_DELAY_MS = 500;
+const MAX_RETRY_DELAY_MS = 30000;
+const abortError = (signal) => {
+    if (signal.reason instanceof Error) {
+        return signal.reason;
+    }
+    const error = new Error("The upload was aborted");
+    error.name = "AbortError";
+    return error;
+};
+const throwIfAborted = (signal) => {
+    if (signal.aborted) {
+        throw abortError(signal);
+    }
+};
+export const normalizeUploadPath = (path) => {
+    if (!path || path.includes("\0")) {
+        throw new Error(`Invalid upload path "${path}": the path must be non-empty and must not contain NUL`);
+    }
+    const normalizedSeparators = path.replaceAll(win32.sep, posix.sep);
+    if (posix.isAbsolute(normalizedSeparators) || win32.parse(path).root !== "") {
+        throw new Error(`Invalid upload path "${path}": the path must be relative`);
+    }
+    const segments = normalizedSeparators.split(posix.sep);
+    if (segments.some((segment) => segment === "" || segment === "." || segment === "..")) {
+        throw new Error(`Invalid upload path "${path}": empty, "." and ".." segments are not allowed`);
+    }
+    return posix.normalize(normalizedSeparators);
+};
+export const encodeUploadPath = (path) => encodeURIComponent(path).replace(/[!'()*]/g, (character) => `%${character.charCodeAt(0).toString(16).toUpperCase()}`);
+const prepareUploadFiles = async (payload, signal) => {
+    const { pluginId } = payload;
+    const normalizedPluginId = pluginId ? normalizeUploadPath(pluginId) : undefined;
+    const fileSets = Array.isArray(payload.files) ? payload.files : [payload.files];
+    const files = [];
+    const uniqueAssets = new Map();
+    for (const fileSet of fileSets) {
+        for (const [filename, filepath] of Object.entries(fileSet)) {
+            throwIfAborted(signal);
+            const normalizedFilename = normalizeUploadPath(filename);
+            const kind = isReportDataFile(normalizedFilename) ? "report" : "asset";
+            const remotePath = kind === "report" && normalizedPluginId ? `${normalizedPluginId}/${normalizedFilename}` : normalizedFilename;
+            if (kind === "asset" && uniqueAssets.has(remotePath)) {
+                continue;
+            }
+            const size = (await stat(filepath)).size;
+            const file = {
+                filename,
+                filepath,
+                kind,
+                normalizedFilename,
+                remotePath,
+                size,
+                signal,
+            };
+            if (kind === "report") {
+                files.push(file);
+                continue;
+            }
+            uniqueAssets.set(remotePath, file);
+        }
+    }
+    files.push(...uniqueAssets.values());
+    return files;
+};
+const parseRetryAfter = (value) => {
+    if (!value) {
+        return undefined;
+    }
+    const seconds = Number(value);
+    if (Number.isFinite(seconds) && seconds >= 0) {
+        return Math.round(seconds * 1000);
+    }
+    const timestamp = Date.parse(value);
+    if (Number.isNaN(timestamp)) {
+        return undefined;
+    }
+    return Math.max(0, timestamp - Date.now());
+};
+const retryDelay = (attempt, retryAfter) => {
+    const serverDelay = parseRetryAfter(retryAfter);
+    if (serverDelay !== undefined) {
+        return serverDelay;
+    }
+    const maximumDelay = Math.min(MAX_RETRY_DELAY_MS, INITIAL_RETRY_DELAY_MS * 2 ** (attempt - 1));
+    return Math.floor(Math.random() * maximumDelay);
+};
+const waitForRetry = async (delay, signal) => {
+    throwIfAborted(signal);
+    await new Promise((resolve, reject) => {
+        const finish = () => {
+            signal.removeEventListener("abort", onAbort);
+            resolve();
+        };
+        const timeout = setTimeout(finish, delay);
+        const onAbort = () => {
+            clearTimeout(timeout);
+            signal.removeEventListener("abort", onAbort);
+            reject(abortError(signal));
+        };
+        signal.addEventListener("abort", onAbort, { once: true });
+        void Promise.resolve().then(() => {
+            if (signal.aborted) {
+                onAbort();
+            }
+        });
+    });
+};
+const errorDetails = (error) => {
+    if (error instanceof KnownError || error instanceof UnknownError) {
+        return error.details;
+    }
+    return undefined;
+};
+const isRetryable = (error) => {
+    const details = errorDetails(error);
+    if (!details) {
+        return false;
+    }
+    if (details.status !== undefined) {
+        return RETRYABLE_STATUSES.has(details.status);
+    }
+    return details.networkCode === undefined || RETRYABLE_NETWORK_CODES.has(details.networkCode);
+};
+const formatUploadError = (file, error, attempts) => {
+    const details = errorDetails(error);
+    const operation = file.kind === "report" ? "upload report file" : "upload shared asset";
+    if (!details) {
+        return error;
+    }
+    const method = details.method.toUpperCase();
+    if (details.status === 403 && details.mitigated === "challenge") {
+        return new KnownError(`Allure service request failed: ${operation} ${method} ${details.endpoint} was blocked by a Cloudflare managed challenge (status 403${details.rayId ? `, ray ${details.rayId}` : ""}, path "${file.remotePath}", attempts ${attempts}). Machine API routes must be excluded from browser challenges.`, 403, { cause: error, details });
+    }
+    const result = [
+        `Allure service request failed: ${operation} ${method} ${details.endpoint}`,
+        details.status
+            ? ` responded with ${details.status}${details.statusText ? ` ${details.statusText}` : ""}`
+            : " failed",
+        ` (path "${file.remotePath}", attempts ${attempts}`,
+        details.rayId ? `, ray ${details.rayId}` : "",
+        details.mitigated ? `, cf-mitigated ${details.mitigated}` : "",
+        ")",
+        details.responseMessage ? `: ${details.responseMessage}` : "",
+    ].join("");
+    if (details.status !== undefined) {
+        return new KnownError(result, details.status, { cause: error, details });
+    }
+    return new UnknownError(result, error instanceof Error ? error.stack : undefined, { cause: error, details });
+};
+const uploadWithRetry = async (file, signal, failedUploads, maxAttempts, upload) => {
+    const attempts = typeof maxAttempts === "number" && Number.isFinite(maxAttempts) && maxAttempts > 0 ? Math.floor(maxAttempts) : 5;
+    for (let attempt = 1; attempt <= attempts; attempt++) {
+        throwIfAborted(signal);
+        try {
+            const result = await upload(file, signal);
+            failedUploads.delete(file.remotePath);
+            return result;
+        }
+        catch (error) {
+            if (signal.aborted) {
+                throw abortError(signal);
+            }
+            if (!isRetryable(error)) {
+                throw formatUploadError(file, error, attempt);
+            }
+            failedUploads.add(file.remotePath);
+            if (attempt >= attempts) {
+                throw formatUploadError(file, error, attempt);
+            }
+            const details = errorDetails(error);
+            const delay = retryDelay(attempt, details?.retryAfter);
+            console.warn("Retrying Allure service upload", {
+                endpoint: details?.endpoint,
+                attempt: attempt + 1,
+                status: details?.status ?? details?.networkCode ?? "network error",
+                delay,
+            });
+            await waitForRetry(delay, signal);
+        }
+    }
+    return undefined;
+};
+export const uploadStorageReport = async (payload) => {
+    const { onProgress, uploadConcurrency, uploadMaxAttempts, uploadedAssets, upload } = payload;
+    const controller = new AbortController();
+    const externalSignal = payload.signal;
+    const abortFromExternalSignal = () => controller.abort(externalSignal?.reason);
+    if (externalSignal) {
+        externalSignal.addEventListener("abort", abortFromExternalSignal, { once: true });
+        if (externalSignal.aborted) {
+            abortFromExternalSignal();
+        }
+    }
+    try {
+        const prepared = await prepareUploadFiles(payload, controller.signal);
+        const files = prepared.filter((file) => file.kind === "report" || !uploadedAssets.has(file.remotePath));
+        if (files.length === 0) {
+            throwIfAborted(controller.signal);
+            return { hrefs: {} };
+        }
+        const failedUploads = new Set();
+        const hrefs = {};
+        let indexHref;
+        let nextFileIndex = 0;
+        const uploadNext = async () => {
+            while (!controller.signal.aborted) {
+                const fileIndex = nextFileIndex++;
+                if (fileIndex >= files.length) {
+                    return;
+                }
+                const file = files[fileIndex];
+                const href = await uploadWithRetry(file, controller.signal, failedUploads, uploadMaxAttempts, upload);
+                if (file.kind === "asset") {
+                    uploadedAssets.add(file.remotePath);
+                }
+                else if (href) {
+                    hrefs[file.filename] = href;
+                    if (file.normalizedFilename === "index.html") {
+                        indexHref = href;
+                    }
+                }
+                onProgress?.(1);
+            }
+        };
+        const workerCount = Math.min(uploadConcurrency, files.length);
+        const workers = Array.from({ length: workerCount }, () => uploadNext());
+        try {
+            await Promise.all(workers);
+            throwIfAborted(controller.signal);
+        }
+        catch (error) {
+            controller.abort(error);
+            await Promise.allSettled(workers);
+            throw error;
+        }
+        return { indexHref, hrefs };
+    }
+    catch (error) {
+        controller.abort(error);
+        throw error;
+    }
+    finally {
+        externalSignal?.removeEventListener("abort", abortFromExternalSignal);
+    }
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@allurereport/service",
-  "version": "3.17.0",
+  "version": "3.19.0",
   "description": "Allure Service API",
   "keywords": [
     "allure",
@@ -30,9 +30,9 @@
     "lint:fix": "oxlint --import-plugin --fix src test features stories"
   },
   "dependencies": {
-    "@allurereport/core-api": "3.17.0",
-    "@allurereport/plugin-api": "3.17.0",
-    "axios": "^1.18.1",
+    "@allurereport/core-api": "3.19.0",
+    "@allurereport/plugin-api": "3.19.0",
+    "axios": "^1.20.0",
     "open": "^11.0.0"
   },
   "devDependencies": {