eas-cli 16.14.1 → 16.16.0

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"));
@@ -34,8 +35,8 @@ async function createTempWritePathAsync() {
     return node_path_1.default.resolve(tmpdir, `tmp-${basename}-${process.pid}-${random}`);
 }
 /** Computes a SHA512 hash for a file */
-async function computeSha512HashAsync(filePath, options) {
-    const hash = (0, node_crypto_1.createHash)('sha512', { encoding: 'hex', ...options });
+async function computeSha512HashAsync(filePath) {
+    const hash = (0, node_crypto_1.createHash)('sha512', { encoding: 'hex' });
     await (0, promises_1.pipeline)(node_fs_1.default.createReadStream(filePath), hash);
     return `${hash.read()}`;
 }
@@ -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);
+            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,52 @@ 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_stream_1.Readable.from((0, multipart_1.createReadStreamAsync)(asset), { objectMode: false });
+        }
+        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';
+            body = node_stream_1.Readable.from((0, multipart_1.createMultipartBodyFromFilesAsync)(multipart, onProgressUpdate), {
+                objectMode: false,
+            });
         }
         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 +94,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 +108,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 +152,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 +199,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,11 @@
+export declare function createReadStreamAsync(fileEntry: MultipartFileEntry): AsyncGenerator<Uint8Array>;
+export interface MultipartFileEntry {
+    sha512: string;
+    path: string;
+    type: string | null;
+    size: number;
+}
+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,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMultipartBodyFromFilesAsync = exports.multipartContentType = exports.createReadStreamAsync = void 0;
+const tslib_1 = require("tslib");
+const node_crypto_1 = require("node:crypto");
+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(fileEntry) {
+    let handle;
+    try {
+        handle = await node_fs_1.default.promises.open(fileEntry.path);
+        const hash = (0, node_crypto_1.createHash)('sha512');
+        // NOTE(@kitten): fs.createReadStream() was previously used here as an async iterator
+        // However, if an early 'end' event is emitted, the async iterator may abort too early and cut off file contents
+        let bytesTotal = 0;
+        while (bytesTotal < fileEntry.size) {
+            const read = await handle.read();
+            const output = read.buffer.subarray(0, read.bytesRead);
+            bytesTotal += output.byteLength;
+            if (bytesTotal > fileEntry.size) {
+                throw new RangeError(`Asset "${fileEntry.path}" was modified during the upload (length mismatch)`);
+            }
+            if (output.byteLength) {
+                hash.update(output);
+            }
+            if (bytesTotal === fileEntry.size) {
+                const sha512 = hash.digest('hex');
+                if (sha512 !== fileEntry.sha512) {
+                    throw new Error(`Asset "${fileEntry.path}" was modified during the upload (checksum mismatch)`);
+                }
+            }
+            if (output.byteLength) {
+                yield output;
+            }
+            else {
+                break;
+            }
+        }
+        if (bytesTotal < fileEntry.size) {
+            throw new RangeError(`Asset "${fileEntry.path}" was modified during the upload (length mismatch)`);
+        }
+    }
+    finally {
+        await handle?.close();
+    }
+}
+exports.createReadStreamAsync = createReadStreamAsync;
+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.sha512,
+            contentType: entry.type,
+            contentLength: entry.size,
+        });
+        yield encoder.encode(header);
+        yield* createReadStreamAsync(entry);
+        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.1",
+  "version": "16.16.0",
   "commands": {
     "analytics": {
       "id": "analytics",
@@ -4196,6 +4196,45 @@
         "loggedIn": {}
       }
     },
+    "workflow:logs": {
+      "id": "workflow:logs",
+      "description": "view logs for a workflow run, selecting a job and step to view. You can pass in either a workflow run ID or a job ID. If no ID is passed in, you will be prompted to select from recent workflow runs for the current project.",
+      "strict": true,
+      "pluginName": "eas-cli",
+      "pluginAlias": "eas-cli",
+      "pluginType": "core",
+      "aliases": [],
+      "flags": {
+        "json": {
+          "name": "json",
+          "type": "boolean",
+          "description": "Enable JSON output, non-JSON messages will be printed to stderr.",
+          "allowNo": false
+        },
+        "non-interactive": {
+          "name": "non-interactive",
+          "type": "boolean",
+          "description": "Run the command in non-interactive mode.",
+          "allowNo": false
+        },
+        "all-steps": {
+          "name": "all-steps",
+          "type": "boolean",
+          "description": "Print all logs, rather than prompting for a specific step. This will be automatically set when in non-interactive mode.",
+          "allowNo": false
+        }
+      },
+      "args": {
+        "id": {
+          "name": "id",
+          "description": "ID of the workflow run or workflow job to view logs for"
+        }
+      },
+      "contextDefinition": {
+        "projectId": {},
+        "loggedIn": {}
+      }
+    },
     "workflow:run": {
       "id": "workflow:run",
       "description": "run an EAS workflow",
@@ -4218,6 +4257,18 @@
           "description": "Exit codes: 0 = success, 11 = failure, 12 = canceled, 13 = wait aborted.",
           "allowNo": true
         },
+        "input": {
+          "name": "input",
+          "type": "option",
+          "char": "F",
+          "summary": "Set workflow inputs",
+          "description": "Add a parameter in key=value format. Use multiple instances of this flag to set multiple inputs.",
+          "multiple": true,
+          "aliases": [
+            "f",
+            "field"
+          ]
+        },
         "json": {
           "name": "json",
           "type": "boolean",
@@ -4320,6 +4371,39 @@
         "loggedIn": {}
       }
     },
+    "workflow:view": {
+      "id": "workflow:view",
+      "description": "view details for a workflow run, including jobs. If no run ID is provided, you will be prompted to select from recent workflow runs for the current project.",
+      "strict": true,
+      "pluginName": "eas-cli",
+      "pluginAlias": "eas-cli",
+      "pluginType": "core",
+      "aliases": [],
+      "flags": {
+        "json": {
+          "name": "json",
+          "type": "boolean",
+          "description": "Enable JSON output, non-JSON messages will be printed to stderr.",
+          "allowNo": false
+        },
+        "non-interactive": {
+          "name": "non-interactive",
+          "type": "boolean",
+          "description": "Run the command in non-interactive mode.",
+          "allowNo": false
+        }
+      },
+      "args": {
+        "id": {
+          "name": "id",
+          "description": "ID of the workflow run to view"
+        }
+      },
+      "contextDefinition": {
+        "projectId": {},
+        "loggedIn": {}
+      }
+    },
     "build:version:get": {
       "id": "build:version:get",
       "description": "get the latest version from EAS servers",

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "eas-cli",
   "description": "EAS command line tool",
-  "version": "16.14.1",
+  "version": "16.16.0",
   "author": "Expo <support@expo.dev>",
   "bin": {
     "eas": "./bin/run"
@@ -241,5 +241,5 @@
     "node": "20.11.0",
     "yarn": "1.22.21"
   },
-  "gitHead": "2502b843f8f75322d0d9b87476efc9bc975631ba"
+  "gitHead": "8e96143b59aa8cd4b1b1bb269670ed3b56768258"
 }

package/build/commandUtils/workflows.d.ts

@@ -1,20 +0,0 @@
-import { WorkflowRunFragment } from '../graphql/generated';
-export type WorkflowRunResult = {
-    id: string;
-    status: string;
-    gitCommitMessage: string | null;
-    gitCommitHash: string | null;
-    startedAt: string;
-    finishedAt: string;
-    workflowId: string;
-    workflowName: string | null;
-    workflowFileName: string;
-};
-export declare function processWorkflowRuns(runs: WorkflowRunFragment[]): WorkflowRunResult[];
-export type WorkflowResult = {
-    id: string;
-    name?: string | null | undefined;
-    fileName: string;
-    createdAt: string;
-    updatedAt: string;
-};