eas-cli 16.14.0 → 16.15.0

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 {};

package/build/worker/utils/multipart.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMultipartBodyFromFilesAsync = exports.multipartContentType = void 0;
+const tslib_1 = require("tslib");
+const node_fs_1 = tslib_1.__importDefault(require("node:fs"));
+const CRLF = '\r\n';
+const BOUNDARY_HYPHEN_CHARS = '--';
+const BOUNDARY_ID = '----formdata-eas-cli';
+const FORM_FOOTER = `${BOUNDARY_HYPHEN_CHARS}${BOUNDARY_ID}${BOUNDARY_HYPHEN_CHARS}${CRLF}${CRLF}`;
+const encodeName = (input) => {
+    return input.replace(/["\n\\]/g, (c) => {
+        switch (c) {
+            case '\\':
+                return '\\\\';
+            case '"':
+                return '%22';
+            case '\n':
+                return '%0A';
+            default:
+                return `%${c.charCodeAt(0).toString(16).toUpperCase()}`;
+        }
+    });
+};
+async function* createReadStreamAsync(filePath) {
+    for await (const raw of node_fs_1.default.createReadStream(filePath)) {
+        const chunk = raw;
+        yield new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength);
+    }
+}
+const makeFormHeader = (params) => {
+    const name = encodeName(params.name);
+    let header = BOUNDARY_HYPHEN_CHARS + BOUNDARY_ID + CRLF;
+    header += `Content-Disposition: form-data; name="${name}"; filename="${name}"`;
+    if (params.contentType) {
+        header += `${CRLF}Content-Type: ${params.contentType}`;
+    }
+    if (params.contentLength) {
+        header += `${CRLF}Content-Length: ${params.contentLength}`;
+    }
+    header += CRLF;
+    header += CRLF;
+    return header;
+};
+exports.multipartContentType = `multipart/form-data; boundary=${BOUNDARY_ID}`;
+async function* createMultipartBodyFromFilesAsync(entries, onProgressUpdate) {
+    const encoder = new TextEncoder();
+    for (let idx = 0; idx < entries.length; idx++) {
+        const entry = entries[idx];
+        const header = makeFormHeader({
+            name: entry.name,
+            contentType: entry.contentType,
+            contentLength: entry.contentLength,
+        });
+        yield encoder.encode(header);
+        yield* createReadStreamAsync(entry.filePath);
+        yield encoder.encode(CRLF);
+        if (onProgressUpdate) {
+            onProgressUpdate((idx + 1) / entries.length);
+        }
+    }
+    yield encoder.encode(FORM_FOOTER);
+}
+exports.createMultipartBodyFromFilesAsync = createMultipartBodyFromFilesAsync;

package/oclif.manifest.json

@@ -1,5 +1,5 @@
 {
-  "version": "16.14.0",
+  "version": "16.15.0",
   "commands": {
     "analytics": {
       "id": "analytics",

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "eas-cli",
   "description": "EAS command line tool",
-  "version": "16.14.0",
+  "version": "16.15.0",
   "author": "Expo <support@expo.dev>",
   "bin": {
     "eas": "./bin/run"
@@ -241,5 +241,5 @@
     "node": "20.11.0",
     "yarn": "1.22.21"
   },
-  "gitHead": "bf27ec5238e337c0a0bdba524e5815e0e646f8e9"
+  "gitHead": "72f3ba817fcf4f210ef9786c2346d76ce32a0378"
 }