eas-cli 16.14.1 → 16.15.0

package/build/commands/deploy/index.js

@@ -14,11 +14,11 @@ const log_1 = tslib_1.__importStar(require("../../log"));
 const ora_1 = require("../../ora");
 const projectUtils_1 = require("../../project/projectUtils");
 const json_1 = require("../../utils/json");
-const progress_1 = require("../../utils/progress");
 const WorkerAssets = tslib_1.__importStar(require("../../worker/assets"));
 const deployment_1 = require("../../worker/deployment");
 const upload_1 = require("../../worker/upload");
 const logs_1 = require("../../worker/utils/logs");
+const MAX_UPLOAD_SIZE = 5e8; // 500MB
 const isDirectory = (directoryPath) => node_fs_1.default.promises
     .stat(directoryPath)
     .then(stat => stat.isDirectory())
@@ -96,14 +96,11 @@ class WorkerDeploy extends EasCommand_1.default {
             }
         }
         async function uploadTarballAsync(tarPath, uploadUrl) {
+            const payload = { filePath: tarPath };
             const { response } = await (0, upload_1.uploadAsync)({
-                url: uploadUrl,
-                filePath: tarPath,
-                compress: false,
-                headers: {
-                    accept: 'application/json',
-                },
-            });
+                baseURL: uploadUrl,
+                method: 'POST',
+            }, payload);
             if (response.status === 413) {
                 throw new Error('Upload failed! (Payload too large)\n' +
                     `The files in "${path.relative(projectDir, projectDist.path)}" (at: ${projectDir}) exceed the maximum file size (10MB gzip).`);
@@ -116,7 +113,7 @@ class WorkerDeploy extends EasCommand_1.default {
                 if (!json.success || !json.result || typeof json.result !== 'object') {
                     throw new Error(json.message ? `Upload failed: ${json.message}` : 'Upload failed!');
                 }
-                const { id, fullName, token } = json.result;
+                const { id, fullName, token, upload } = json.result;
                 if (typeof token !== 'string') {
                     throw new Error('Upload failed: API failed to return a deployment token');
                 }
@@ -126,56 +123,57 @@ class WorkerDeploy extends EasCommand_1.default {
                 else if (typeof fullName !== 'string') {
                     throw new Error('Upload failed: API failed to return a script name');
                 }
+                else if (!Array.isArray(upload) && upload !== undefined) {
+                    throw new Error('Upload failed: API returned invalid asset upload instructions');
+                }
                 const baseURL = new URL('/', uploadUrl).toString();
-                return { id, fullName, baseURL, token };
+                return { id, fullName, baseURL, token, upload };
             }
         }
-        async function uploadAssetsAsync(assetMap, deployParams) {
-            const uploadParams = [];
-            const assetPath = projectDist.type === 'server' ? projectDist.clientPath : projectDist.path;
-            if (!assetPath) {
-                return;
+        async function uploadAssetsAsync(assetFiles, deployParams) {
+            const baseURL = new URL('/asset/', deployParams.baseURL);
+            const uploadInit = { baseURL, method: 'POST' };
+            uploadInit.baseURL.searchParams.set('token', deployParams.token);
+            const uploadPayloads = [];
+            if (deployParams.upload) {
+                const assetsBySHA512 = assetFiles.reduce((map, asset) => {
+                    map.set(asset.sha512, asset);
+                    return map;
+                }, new Map());
+                const payloads = deployParams.upload
+                    .map(instruction => instruction.sha512.map(sha512 => {
+                    const asset = assetsBySHA512.get(sha512);
+                    if (!asset) {
+                        // NOTE(@kitten): This should never happen
+                        throw new Error(`Uploading assets failed: API instructed us to upload an asset that does not exist`);
+                    }
+                    return asset;
+                }))
+                    .filter(assets => assets && assets.length > 0)
+                    .map(assets => (assets.length > 1 ? { multipart: assets } : { asset: assets[0] }));
+                uploadPayloads.push(...payloads);
             }
-            for await (const asset of WorkerAssets.listAssetMapFilesAsync(assetPath, assetMap)) {
-                const uploadURL = new URL(`/asset/${asset.sha512}`, deployParams.baseURL);
-                uploadURL.searchParams.set('token', deployParams.token);
-                uploadParams.push({ url: uploadURL.toString(), filePath: asset.path });
+            else {
+                // NOTE(@kitten): Legacy format which uploads assets one-by-one
+                uploadPayloads.push(...assetFiles.map(asset => ({ asset })));
             }
-            const progress = {
-                total: uploadParams.length,
-                pending: 0,
-                percent: 0,
-                transferred: 0,
-            };
-            const updateProgress = (0, progress_1.createProgressTracker)({
-                total: progress.total,
-                message(ratio) {
-                    const percent = `${Math.floor(ratio * 100)}`;
-                    const details = chalk_1.default.dim(`(${progress.pending} Pending, ${progress.transferred} Completed, ${progress.total} Total)`);
-                    return `Uploading assets: ${percent.padStart(3)}% ${details}`;
-                },
-                completedMessage: 'Uploaded assets',
-            });
+            const progressTotal = uploadPayloads.reduce((acc, payload) => acc + ('multipart' in payload ? payload.multipart.length : 1), 0);
+            const progressTracker = (0, upload_1.createProgressBar)(`Uploading ${progressTotal} assets`);
             try {
-                for await (const signal of (0, upload_1.batchUploadAsync)(uploadParams)) {
-                    if ('response' in signal) {
-                        progress.pending--;
-                        progress.percent = ++progress.transferred / progress.total;
-                    }
-                    else {
-                        progress.pending++;
-                    }
-                    updateProgress({ progress });
+                for await (const signal of (0, upload_1.batchUploadAsync)(uploadInit, uploadPayloads, progressTracker.update)) {
+                    progressTracker.update(signal.progress);
                 }
             }
             catch (error) {
-                updateProgress({ isComplete: true, error });
+                progressTracker.stop();
                 throw error;
             }
-            updateProgress({ isComplete: true });
+            finally {
+                progressTracker.stop();
+            }
         }
-        let assetMap;
         let tarPath;
+        let assetFiles;
         let deployResult;
         let progress = (0, ora_1.ora)('Preparing project').start();
         try {
@@ -189,9 +187,9 @@ class WorkerDeploy extends EasCommand_1.default {
                     'In case of conflict, the EAS environment variable values will be used: ' +
                     manifestResult.conflictingVariableNames.join(' '));
             }
-            assetMap = await WorkerAssets.createAssetMapAsync(projectDist.type === 'server' ? projectDist.clientPath : projectDist.path);
+            assetFiles = await WorkerAssets.collectAssetsAsync(projectDist.type === 'server' ? projectDist.clientPath : projectDist.path, { maxFileSize: MAX_UPLOAD_SIZE });
             tarPath = await WorkerAssets.packFilesIterableAsync(emitWorkerTarballAsync({
-                assetMap,
+                assetMap: WorkerAssets.assetsToAssetsMap(assetFiles),
                 manifest: manifestResult.manifest,
             }));
             if (flags.dryRun) {
@@ -232,7 +230,7 @@ class WorkerDeploy extends EasCommand_1.default {
             }
             throw error;
         }
-        await uploadAssetsAsync(assetMap, deployResult);
+        await uploadAssetsAsync(assetFiles, deployResult);
         await finalizeDeployAsync(deployResult);
         let deploymentAlias = null;
         if (flags.aliasName) {

package/build/worker/assets.d.ts

@@ -6,11 +6,24 @@ import { ExpoGraphqlClient } from '../commandUtils/context/contextUtils/createGr
 import { EnvironmentVariableEnvironment } from '../graphql/generated';
 interface AssetMapOptions {
     hashOptions?: HashOptions;
+    maxFileSize: number;
 }
+export interface AssetFileEntry {
+    normalizedPath: string;
+    path: string;
+    size: number;
+    sha512: string;
+    type: string | null;
+}
+/** Collects assets from a given target path */
+export declare function collectAssetsAsync(assetPath: string | undefined, options: AssetMapOptions): Promise<AssetFileEntry[]>;
 /** Mapping of normalized file paths to a SHA512 hash */
-export type AssetMap = Record<string, string>;
-/** Creates an asset map of a given target path */
-declare function createAssetMapAsync(assetPath?: string, options?: AssetMapOptions): Promise<AssetMap>;
+export type AssetMap = Record<string, string | {
+    sha512: string;
+    size: number;
+}>;
+/** Converts array of asset entries into AssetMap (as sent to deployment-api) */
+export declare function assetsToAssetsMap(assets: AssetFileEntry[]): AssetMap;
 export interface Manifest {
     env: Record<string, string | undefined>;
 }
@@ -31,16 +44,9 @@ interface WorkerFileEntry {
     data: Buffer | string;
 }
 /** Reads worker files while normalizing sourcemaps and providing normalized paths */
-declare function listWorkerFilesAsync(workerPath: string): AsyncGenerator<WorkerFileEntry>;
-interface AssetFileEntry {
-    normalizedPath: string;
-    sha512: string;
-    path: string;
-}
-/** Reads files of an asset maps and enumerates normalized paths and data */
-declare function listAssetMapFilesAsync(assetPath: string, assetMap: AssetMap): AsyncGenerator<AssetFileEntry>;
+export declare function listWorkerFilesAsync(workerPath: string): AsyncGenerator<WorkerFileEntry>;
 /** Entry of a normalized (gzip-safe) path and file data */
 export type FileEntry = readonly [normalizedPath: string, data: Buffer | string];
 /** Packs file entries into a tar.gz file (path to tgz returned) */
-declare function packFilesIterableAsync(iterable: Iterable<FileEntry> | AsyncIterable<FileEntry>, options?: GzipOptions): Promise<string>;
-export { createAssetMapAsync, listWorkerFilesAsync, listAssetMapFilesAsync, packFilesIterableAsync, };
+export declare function packFilesIterableAsync(iterable: Iterable<FileEntry> | AsyncIterable<FileEntry>, options?: GzipOptions): Promise<string>;
+export {};

package/build/worker/assets.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.packFilesIterableAsync = exports.listAssetMapFilesAsync = exports.listWorkerFilesAsync = exports.createAssetMapAsync = exports.createManifestAsync = void 0;
+exports.packFilesIterableAsync = exports.listWorkerFilesAsync = exports.createManifestAsync = exports.assetsToAssetsMap = exports.collectAssetsAsync = void 0;
 const tslib_1 = require("tslib");
 const env_1 = require("@expo/env");
+const mime_1 = tslib_1.__importDefault(require("mime"));
 const minizlib_1 = require("minizlib");
 const node_crypto_1 = require("node:crypto");
 const node_fs_1 = tslib_1.__importStar(require("node:fs"));
@@ -50,9 +51,12 @@ function listFilesRecursively(basePath) {
                 continue;
             }
             else if (dirent.isFile()) {
+                const absolutePath = node_path_1.default.resolve(target, dirent.name);
+                const stats = await node_fs_1.default.promises.stat(absolutePath);
                 yield {
                     normalizedPath,
-                    path: node_path_1.default.resolve(target, dirent.name),
+                    path: absolutePath,
+                    size: stats.size,
                 };
             }
             else if (dirent.isDirectory()) {
@@ -62,17 +66,54 @@ function listFilesRecursively(basePath) {
     }
     return recurseAsync();
 }
-/** Creates an asset map of a given target path */
-async function createAssetMapAsync(assetPath, options) {
-    const map = Object.create(null);
+async function determineMimeTypeAsync(filePath) {
+    let contentType = mime_1.default.getType(node_path_1.default.basename(filePath));
+    if (!contentType) {
+        const fileContent = await node_fs_1.default.promises.readFile(filePath, 'utf-8');
+        try {
+            // check if file is valid JSON without an extension, e.g. for the apple app site association file
+            const parsedData = JSON.parse(fileContent);
+            if (parsedData) {
+                contentType = 'application/json';
+            }
+        }
+        catch { }
+    }
+    return contentType;
+}
+/** Collects assets from a given target path */
+async function collectAssetsAsync(assetPath, options) {
+    const assets = [];
     if (assetPath) {
         for await (const file of listFilesRecursively(assetPath)) {
-            map[file.normalizedPath] = await computeSha512HashAsync(file.path, options?.hashOptions);
+            if (file.size > options.maxFileSize) {
+                throw new Error(`Upload of "${file.normalizedPath}" aborted: File size is greater than the upload limit (>500MB)`);
+            }
+            const sha512$ = computeSha512HashAsync(file.path, options?.hashOptions);
+            const contentType$ = determineMimeTypeAsync(file.path);
+            assets.push({
+                normalizedPath: file.normalizedPath,
+                path: file.path,
+                size: file.size,
+                sha512: await sha512$,
+                type: await contentType$,
+            });
         }
     }
-    return map;
+    return assets;
 }
-exports.createAssetMapAsync = createAssetMapAsync;
+exports.collectAssetsAsync = collectAssetsAsync;
+/** Converts array of asset entries into AssetMap (as sent to deployment-api) */
+function assetsToAssetsMap(assets) {
+    return assets.reduce((map, entry) => {
+        map[entry.normalizedPath] = {
+            sha512: entry.sha512,
+            size: entry.size,
+        };
+        return map;
+    }, Object.create(null));
+}
+exports.assetsToAssetsMap = assetsToAssetsMap;
 /** Creates a manifest configuration sent up for deployment */
 async function createManifestAsync(params, graphqlClient) {
     // Resolve .env file variables
@@ -110,18 +151,6 @@ async function* listWorkerFilesAsync(workerPath) {
     }
 }
 exports.listWorkerFilesAsync = listWorkerFilesAsync;
-/** Reads files of an asset maps and enumerates normalized paths and data */
-async function* listAssetMapFilesAsync(assetPath, assetMap) {
-    for (const normalizedPath in assetMap) {
-        const filePath = node_path_1.default.resolve(assetPath, normalizedPath.split('/').join(node_path_1.default.sep));
-        yield {
-            normalizedPath,
-            path: filePath,
-            sha512: assetMap[normalizedPath],
-        };
-    }
-}
-exports.listAssetMapFilesAsync = listAssetMapFilesAsync;
 /** Packs file entries into a tar.gz file (path to tgz returned) */
 async function packFilesIterableAsync(iterable, options) {
     const writePath = `${await createTempWritePathAsync()}.tar.gz`;

package/build/worker/upload.d.ts

@@ -1,23 +1,35 @@
 /// <reference types="node" />
 /// <reference types="node" />
 import { HeadersInit, RequestInit, Response } from 'node-fetch';
-export interface UploadParams extends Omit<RequestInit, 'signal' | 'body'> {
+import { AssetFileEntry } from './assets';
+export type UploadPayload = {
     filePath: string;
-    compress?: boolean;
-    url: string;
+} | {
+    asset: AssetFileEntry;
+} | {
+    multipart: AssetFileEntry[];
+};
+export interface UploadRequestInit {
+    baseURL: string | URL;
     method?: string;
     headers?: HeadersInit;
-    body?: undefined;
     signal?: AbortSignal;
 }
 export interface UploadResult {
-    params: UploadParams;
+    payload: UploadPayload;
     response: Response;
 }
-export declare function uploadAsync(params: UploadParams): Promise<UploadResult>;
+type OnProgressUpdateCallback = (progress: number) => void;
+export declare function uploadAsync(init: UploadRequestInit, payload: UploadPayload, onProgressUpdate?: OnProgressUpdateCallback): Promise<UploadResult>;
 export declare function callUploadApiAsync(url: string | URL, init?: RequestInit): Promise<unknown>;
 export interface UploadPending {
-    params: UploadParams;
+    payload: UploadPayload;
+    progress: number;
 }
-export type BatchUploadSignal = UploadResult | UploadPending;
-export declare function batchUploadAsync(uploads: readonly UploadParams[]): AsyncGenerator<BatchUploadSignal>;
+export declare function batchUploadAsync(init: UploadRequestInit, payloads: UploadPayload[], onProgressUpdate?: OnProgressUpdateCallback): AsyncGenerator<UploadPending>;
+interface UploadProgressBar {
+    update(progress: number): void;
+    stop(): void;
+}
+export declare function createProgressBar(label?: string): UploadProgressBar;
+export {};

package/build/worker/upload.js

@@ -1,53 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.batchUploadAsync = exports.callUploadApiAsync = exports.uploadAsync = void 0;
+exports.createProgressBar = exports.batchUploadAsync = exports.callUploadApiAsync = exports.uploadAsync = void 0;
 const tslib_1 = require("tslib");
+const cli_progress_1 = tslib_1.__importDefault(require("cli-progress"));
 const https = tslib_1.__importStar(require("https"));
 const https_proxy_agent_1 = tslib_1.__importDefault(require("https-proxy-agent"));
-const mime_1 = tslib_1.__importDefault(require("mime"));
-const minizlib_1 = require("minizlib");
 const node_fetch_1 = tslib_1.__importStar(require("node-fetch"));
-const node_fs_1 = tslib_1.__importStar(require("node:fs"));
-const promises_1 = require("node:fs/promises");
-const node_path_1 = tslib_1.__importDefault(require("node:path"));
+const node_fs_1 = tslib_1.__importDefault(require("node:fs"));
+const node_os_1 = tslib_1.__importDefault(require("node:os"));
+const node_stream_1 = require("node:stream");
 const promise_retry_1 = tslib_1.__importDefault(require("promise-retry"));
+const multipart_1 = require("./utils/multipart");
+const MAX_CONCURRENCY = Math.min(10, Math.max(node_os_1.default.availableParallelism() * 2, 20));
 const MAX_RETRIES = 4;
-const MAX_CONCURRENCY = 10;
-const MIN_RETRY_TIMEOUT = 100;
-const MAX_UPLOAD_SIZE = 5e8; // 5MB
-const MIN_COMPRESSION_SIZE = 5e4; // 50kB
-const isCompressible = (contentType, size) => {
-    if (size < MIN_COMPRESSION_SIZE) {
-        // Don't compress small files
-        return false;
-    }
-    else if (contentType && /^(?:audio|video|image)\//i.test(contentType)) {
-        // Never compress images, audio, or videos as they're presumably precompressed
-        return false;
-    }
-    else if (contentType && /^application\//i.test(contentType)) {
-        // Only compress `application/` files if they're marked as XML/JSON/JS
-        return /(?:xml|json5?|javascript)$/i.test(contentType);
-    }
-    else {
-        return true;
-    }
-};
-const getContentTypeAsync = async (filePath) => {
-    let contentType = mime_1.default.getType(node_path_1.default.basename(filePath));
-    if (!contentType) {
-        const fileContent = await (0, promises_1.readFile)(filePath, 'utf-8');
-        try {
-            // check if file is valid JSON without an extension, e.g. for the apple app site association file
-            const parsedData = JSON.parse(fileContent);
-            if (parsedData) {
-                contentType = 'application/json';
-            }
-        }
-        catch { }
-    }
-    return contentType;
-};
 let sharedAgent;
 const getAgent = () => {
     if (sharedAgent) {
@@ -66,36 +31,56 @@ const getAgent = () => {
         }));
     }
 };
-async function uploadAsync(params) {
-    const { filePath, signal, compress, method = 'POST', url, headers: headersInit, ...requestInit } = params;
-    const stat = await node_fs_1.default.promises.stat(filePath);
-    if (stat.size > MAX_UPLOAD_SIZE) {
-        throw new Error(`Upload of "${filePath}" aborted: File size is greater than the upload limit (>500MB)`);
-    }
-    const contentType = await getContentTypeAsync(filePath);
+async function uploadAsync(init, payload, onProgressUpdate) {
     return await (0, promise_retry_1.default)(async (retry) => {
-        const headers = new node_fetch_1.Headers(headersInit);
-        if (contentType) {
-            headers.set('content-type', contentType);
-        }
-        let bodyStream = (0, node_fs_1.createReadStream)(filePath);
-        if (compress && isCompressible(contentType, stat.size)) {
-            const gzip = new minizlib_1.Gzip({ portable: true });
-            bodyStream.on('error', error => gzip.emit('error', error));
-            // @ts-expect-error: Gzip implements a Readable-like interface
-            bodyStream = bodyStream.pipe(gzip);
-            headers.set('content-encoding', 'gzip');
+        if (onProgressUpdate) {
+            onProgressUpdate(0);
+        }
+        const headers = new node_fetch_1.Headers(init.headers);
+        const url = new URL(`${init.baseURL}`);
+        let errorPrefix;
+        let body;
+        let method = init.method || 'POST';
+        if ('asset' in payload) {
+            const { asset } = payload;
+            errorPrefix = `Upload of "${asset.normalizedPath}" failed`;
+            if (asset.type) {
+                headers.set('content-type', asset.type);
+            }
+            if (asset.size) {
+                headers.set('content-length', `${asset.size}`);
+            }
+            method = 'POST';
+            url.pathname = `/asset/${asset.sha512}`;
+            body = node_fs_1.default.createReadStream(asset.path);
+        }
+        else if ('filePath' in payload) {
+            const { filePath } = payload;
+            errorPrefix = 'Worker deployment failed';
+            body = node_fs_1.default.createReadStream(filePath);
+        }
+        else if ('multipart' in payload) {
+            const { multipart } = payload;
+            errorPrefix = `Upload of ${multipart.length} assets failed`;
+            headers.set('content-type', multipart_1.multipartContentType);
+            method = 'PATCH';
+            url.pathname = '/asset/batch';
+            const iterator = (0, multipart_1.createMultipartBodyFromFilesAsync)(multipart.map(asset => ({
+                name: asset.sha512,
+                filePath: asset.path,
+                contentType: asset.type,
+                contentLength: asset.size,
+            })), onProgressUpdate);
+            body = node_stream_1.Readable.from(iterator);
         }
         let response;
         try {
-            response = await (0, node_fetch_1.default)(params.url, {
-                ...requestInit,
+            response = await (0, node_fetch_1.default)(url, {
                 method,
-                body: bodyStream,
+                body,
                 headers,
                 agent: getAgent(),
-                // @ts-expect-error: Internal types don't match
-                signal,
+                signal: init.signal,
             });
         }
         catch (error) {
@@ -113,11 +98,11 @@ async function uploadAsync(params) {
                 if (rayId) {
                     message += `\nReport this error quoting Request ID ${rayId}`;
                 }
-                return `Upload of "${filePath}" failed: ${message}`;
+                return `${errorPrefix}: ${message}`;
             }
             else {
                 const json = await response.json().catch(() => null);
-                return json?.error ?? `Upload of "${filePath}" failed: ${response.statusText}`;
+                return json?.error ?? `${errorPrefix}: ${response.statusText}`;
             }
         };
         if (response.status === 408 ||
@@ -127,21 +112,23 @@ async function uploadAsync(params) {
             return retry(new Error(await getErrorMessageAsync()));
         }
         else if (response.status === 413) {
-            const message = `Upload of "${filePath}" failed: File size exceeded the upload limit`;
+            const message = `${errorPrefix}: File size exceeded the upload limit`;
             throw new Error(message);
         }
         else if (!response.ok) {
             throw new Error(await getErrorMessageAsync());
         }
+        else if (onProgressUpdate) {
+            onProgressUpdate(1);
+        }
         return {
-            params,
+            payload,
             response,
         };
     }, {
         retries: MAX_RETRIES,
-        minTimeout: MIN_RETRY_TIMEOUT,
-        randomize: true,
-        factor: 2,
+        minTimeout: 50,
+        randomize: false,
     });
 }
 exports.uploadAsync = uploadAsync;
@@ -169,19 +156,41 @@ async function callUploadApiAsync(url, init) {
     });
 }
 exports.callUploadApiAsync = callUploadApiAsync;
-async function* batchUploadAsync(uploads) {
+async function* batchUploadAsync(init, payloads, onProgressUpdate) {
+    const progressTracker = new Array(payloads.length).fill(0);
     const controller = new AbortController();
     const queue = new Set();
+    const initWithSignal = { ...init, signal: controller.signal };
+    const getProgressValue = () => {
+        const progress = progressTracker.reduce((acc, value) => acc + value, 0);
+        return progress / payloads.length;
+    };
+    const sendProgressUpdate = onProgressUpdate &&
+        (() => {
+            onProgressUpdate(getProgressValue());
+        });
     try {
         let index = 0;
-        while (index < uploads.length || queue.size > 0) {
-            while (queue.size < MAX_CONCURRENCY && index < uploads.length) {
-                const uploadParams = uploads[index++];
-                let uploadPromise;
-                queue.add((uploadPromise = uploadAsync({ ...uploadParams, signal: controller.signal }).finally(() => queue.delete(uploadPromise))));
-                yield { params: uploadParams };
+        while (index < payloads.length || queue.size > 0) {
+            while (queue.size < MAX_CONCURRENCY && index < payloads.length) {
+                const currentIndex = index++;
+                const payload = payloads[currentIndex];
+                const onChildProgressUpdate = sendProgressUpdate &&
+                    ((progress) => {
+                        progressTracker[currentIndex] = progress;
+                        sendProgressUpdate();
+                    });
+                const uploadPromise = uploadAsync(initWithSignal, payload, onChildProgressUpdate).finally(() => {
+                    queue.delete(uploadPromise);
+                    progressTracker[currentIndex] = 1;
+                });
+                queue.add(uploadPromise);
+                yield { payload, progress: getProgressValue() };
             }
-            yield await Promise.race(queue);
+            yield {
+                ...(await Promise.race(queue)),
+                progress: getProgressValue(),
+            };
         }
         if (queue.size > 0) {
             controller.abort();
@@ -194,3 +203,16 @@ async function* batchUploadAsync(uploads) {
     }
 }
 exports.batchUploadAsync = batchUploadAsync;
+function createProgressBar(label = 'Uploading assets') {
+    const queueProgressBar = new cli_progress_1.default.SingleBar({ format: `|{bar}| {percentage}% ${label}` }, cli_progress_1.default.Presets.rect);
+    queueProgressBar.start(1, 0);
+    return {
+        update(progress) {
+            queueProgressBar.update(progress);
+        },
+        stop() {
+            queueProgressBar.stop();
+        },
+    };
+}
+exports.createProgressBar = createProgressBar;

package/build/worker/utils/multipart.d.ts

@@ -0,0 +1,10 @@
+export interface MultipartFileEntry {
+    name: string;
+    filePath: string;
+    contentType: string | null;
+    contentLength: number | null;
+}
+export declare const multipartContentType = "multipart/form-data; boundary=----formdata-eas-cli";
+type OnProgressUpdateCallback = (progress: number) => void;
+export declare function createMultipartBodyFromFilesAsync(entries: MultipartFileEntry[], onProgressUpdate?: OnProgressUpdateCallback): AsyncGenerator<Uint8Array>;
+export {};