eas-cli 11.0.3 → 12.1.0

package/build/worker/assets.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.packFilesIterableAsync = exports.listAssetMapFilesAsync = exports.listWorkerFilesAsync = exports.createAssetMapAsync = void 0;
+const tslib_1 = require("tslib");
+const minizlib_1 = require("minizlib");
+const node_crypto_1 = require("node:crypto");
+const node_fs_1 = tslib_1.__importStar(require("node:fs"));
+const node_os_1 = tslib_1.__importDefault(require("node:os"));
+const node_path_1 = tslib_1.__importDefault(require("node:path"));
+const promises_1 = require("node:stream/promises");
+const tar_stream_1 = require("tar-stream");
+/** Returns whether a file or folder is ignored */
+function isIgnoredName(name) {
+    switch (name) {
+        // macOS system files
+        case '.DS_Store':
+        case '.AppleDouble':
+        case '.Trashes':
+        case '__MACOSX':
+        case '.LSOverride':
+            return true;
+        default:
+            // Backup file name convention
+            return name.endsWith('~');
+    }
+}
+/** Creates a temporary file write path */
+async function createTempWritePathAsync() {
+    const basename = node_path_1.default.basename(__filename, node_path_1.default.extname(__filename));
+    const tmpdir = await node_fs_1.default.promises.realpath(node_os_1.default.tmpdir());
+    const random = (0, node_crypto_1.randomBytes)(4).toString('hex');
+    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 });
+    await (0, promises_1.pipeline)(node_fs_1.default.createReadStream(filePath), hash);
+    return `${hash.read()}`;
+}
+/** Lists plain files in base path recursively and outputs normalized paths */
+function listFilesRecursively(basePath) {
+    async function* recurseAsync(parentPath) {
+        const target = parentPath ? node_path_1.default.resolve(basePath, parentPath) : basePath;
+        const entries = await node_fs_1.default.promises.readdir(target, { withFileTypes: true });
+        for (const dirent of entries) {
+            const normalizedPath = parentPath ? `${parentPath}/${dirent.name}` : dirent.name;
+            if (isIgnoredName(dirent.name)) {
+                continue;
+            }
+            else if (dirent.isFile()) {
+                yield {
+                    normalizedPath,
+                    path: node_path_1.default.resolve(target, dirent.name),
+                };
+            }
+            else if (dirent.isDirectory()) {
+                yield* recurseAsync(normalizedPath);
+            }
+        }
+    }
+    return recurseAsync();
+}
+/** Creates an asset map of a given target path */
+async function createAssetMapAsync(assetPath, options) {
+    const map = Object.create(null);
+    for await (const file of listFilesRecursively(assetPath)) {
+        map[file.normalizedPath] = await computeSha512HashAsync(file.path, options?.hashOptions);
+    }
+    return map;
+}
+exports.createAssetMapAsync = createAssetMapAsync;
+/** Reads worker files while normalizing sourcemaps and providing normalized paths */
+async function* listWorkerFilesAsync(workerPath) {
+    for await (const file of listFilesRecursively(workerPath)) {
+        yield {
+            normalizedPath: file.normalizedPath,
+            path: file.path,
+            data: await node_fs_1.default.promises.readFile(file.path),
+        };
+    }
+}
+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));
+        const data = await node_fs_1.default.promises.readFile(filePath);
+        yield {
+            normalizedPath,
+            path: filePath,
+            data,
+        };
+    }
+}
+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`;
+    const write = (0, node_fs_1.createWriteStream)(writePath);
+    const gzip = new minizlib_1.Gzip({ portable: true, ...options });
+    const tar = (0, tar_stream_1.pack)();
+    const writeTask$ = (0, promises_1.pipeline)(tar, gzip, write);
+    for await (const file of iterable) {
+        tar.entry({ name: file[0], type: 'file' }, file[1]);
+    }
+    tar.finalize();
+    await writeTask$;
+    return writePath;
+}
+exports.packFilesIterableAsync = packFilesIterableAsync;

package/build/worker/deployment.d.ts

@@ -0,0 +1,6 @@
+import { ExpoConfig } from '@expo/config-types';
+import { ExpoGraphqlClient } from '../commandUtils/context/contextUtils/createGraphqlClient';
+export declare function getSignedDeploymentUrlAsync(graphqlClient: ExpoGraphqlClient, exp: ExpoConfig, deploymentVariables: {
+    appId: string;
+    deploymentIdentifier?: string | null;
+}): Promise<string>;

package/build/worker/deployment.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSignedDeploymentUrlAsync = void 0;
+const tslib_1 = require("tslib");
+const mutations_1 = require("./mutations");
+const log_1 = tslib_1.__importDefault(require("../log"));
+const prompts_1 = require("../prompts");
+async function getSignedDeploymentUrlAsync(graphqlClient, exp, deploymentVariables) {
+    try {
+        return await mutations_1.DeploymentsMutation.createSignedDeploymentUrlAsync(graphqlClient, deploymentVariables);
+    }
+    catch (error) {
+        const isMissingDevDomain = error?.graphQLErrors?.some(e => ['APP_NO_DEV_DOMAIN_NAME'].includes(e?.extensions?.errorCode));
+        if (!isMissingDevDomain) {
+            throw error;
+        }
+        await chooseDevDomainNameAsync({
+            graphqlClient,
+            appId: deploymentVariables.appId,
+            slug: exp.slug,
+        });
+        return await mutations_1.DeploymentsMutation.createSignedDeploymentUrlAsync(graphqlClient, deploymentVariables);
+    }
+}
+exports.getSignedDeploymentUrlAsync = getSignedDeploymentUrlAsync;
+async function chooseDevDomainNameAsync({ graphqlClient, appId, slug, }) {
+    const validationMessage = 'The project does not have a dev domain name.';
+    const { name } = await (0, prompts_1.promptAsync)({
+        type: 'text',
+        name: 'name',
+        message: 'Choose a dev domain name for your project:',
+        validate: value => (value && value.length > 3 ? true : validationMessage),
+        initial: slug,
+    });
+    if (!name) {
+        throw new Error('Prompt failed');
+    }
+    try {
+        const success = await mutations_1.DeploymentsMutation.assignDevDomainNameAsync(graphqlClient, {
+            appId,
+            name,
+        });
+        if (!success) {
+            throw new Error('Failed to assign dev domain name');
+        }
+    }
+    catch (error) {
+        const isChosenNameTaken = error?.graphQLErrors?.some(e => ['DEV_DOMAIN_NAME_TAKEN'].includes(e?.extensions?.errorCode));
+        if (isChosenNameTaken) {
+            log_1.default.error(`The entered dev domain name "${name}" is taken. Choose a different name.`);
+            await chooseDevDomainNameAsync({ graphqlClient, appId, slug });
+        }
+        if (!isChosenNameTaken) {
+            throw error;
+        }
+    }
+}

package/build/worker/mutations.d.ts

@@ -0,0 +1,11 @@
+import { ExpoGraphqlClient } from '../commandUtils/context/contextUtils/createGraphqlClient';
+export declare const DeploymentsMutation: {
+    createSignedDeploymentUrlAsync(graphqlClient: ExpoGraphqlClient, deploymentVariables: {
+        appId: string;
+        deploymentIdentifier?: string | null;
+    }): Promise<string>;
+    assignDevDomainNameAsync(graphqlClient: ExpoGraphqlClient, devDomainNameVariables: {
+        appId: string;
+        name: string;
+    }): Promise<boolean>;
+};

package/build/worker/mutations.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeploymentsMutation = void 0;
+const tslib_1 = require("tslib");
+const assert_1 = tslib_1.__importDefault(require("assert"));
+const graphql_tag_1 = tslib_1.__importDefault(require("graphql-tag"));
+const client_1 = require("../graphql/client");
+exports.DeploymentsMutation = {
+    async createSignedDeploymentUrlAsync(graphqlClient, deploymentVariables) {
+        const data = await (0, client_1.withErrorHandlingAsync)(graphqlClient
+            .mutation((0, graphql_tag_1.default) `
+            mutation createDeploymentUrlMutation($appId: ID!, $deploymentIdentifier: ID) {
+              deployments {
+                createSignedDeploymentUrl(
+                  appId: $appId
+                  deploymentIdentifier: $deploymentIdentifier
+                ) {
+                  pendingWorkerDeploymentId
+                  deploymentIdentifier
+                  url
+                }
+              }
+            }
+          `, deploymentVariables)
+            .toPromise());
+        const url = data.deployments?.createSignedDeploymentUrl.url;
+        (0, assert_1.default)(url, 'Deployment URL must be defined');
+        return url;
+    },
+    async assignDevDomainNameAsync(graphqlClient, devDomainNameVariables) {
+        const data = await (0, client_1.withErrorHandlingAsync)(graphqlClient
+            .mutation((0, graphql_tag_1.default) `
+            mutation AssignDevDomainName($appId: ID!, $name: DevDomainName!) {
+              devDomainName {
+                assignDevDomainName(appId: $appId, name: $name) {
+                  id
+                  name
+                }
+              }
+            }
+          `, devDomainNameVariables)
+            .toPromise());
+        return data.devDomainName.assignDevDomainName.name === devDomainNameVariables.name;
+    },
+};

package/build/worker/upload.d.ts

@@ -0,0 +1,20 @@
+import { HeadersInit, RequestInit, Response } from 'node-fetch';
+export interface UploadParams extends Omit<RequestInit, 'signal' | 'body'> {
+    filePath: string;
+    compress?: boolean;
+    url: string;
+    method?: string;
+    headers?: HeadersInit;
+    body?: undefined;
+    signal?: AbortSignal;
+}
+export interface UploadResult {
+    params: UploadParams;
+    response: Response;
+}
+export declare function uploadAsync(params: UploadParams): Promise<UploadResult>;
+export interface UploadPending {
+    params: UploadParams;
+}
+export type BatchUploadSignal = UploadResult | UploadPending;
+export declare function batchUploadAsync(uploads: readonly UploadParams[]): AsyncGenerator<BatchUploadSignal>;

package/build/worker/upload.js

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.batchUploadAsync = exports.uploadAsync = void 0;
+const tslib_1 = require("tslib");
+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 node_path_1 = tslib_1.__importDefault(require("node:path"));
+const promise_retry_1 = tslib_1.__importDefault(require("promise-retry"));
+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;
+    }
+};
+let sharedAgent;
+const getAgent = () => {
+    if (sharedAgent) {
+        return sharedAgent;
+    }
+    else if (process.env.https_proxy) {
+        return (sharedAgent = (0, https_proxy_agent_1.default)(process.env.https_proxy));
+    }
+    else {
+        return (sharedAgent = new https.Agent({
+            keepAlive: true,
+            maxSockets: MAX_CONCURRENCY,
+            maxTotalSockets: MAX_CONCURRENCY,
+            scheduling: 'lifo',
+            timeout: 4000,
+        }));
+    }
+};
+async function uploadAsync(params) {
+    const { filePath, signal, compress, method = 'POST', url, headers: headersInit, ...requestInit } = params;
+    const stat = await node_fs_1.default.promises.stat(params.filePath);
+    if (stat.size > MAX_UPLOAD_SIZE) {
+        throw new Error(`Upload of "${params.filePath}" aborted: File size is greater than the upload limit (>500MB)`);
+    }
+    const contentType = mime_1.default.getType(node_path_1.default.basename(params.filePath));
+    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');
+        }
+        let response;
+        try {
+            response = await (0, node_fetch_1.default)(params.url, {
+                ...requestInit,
+                method,
+                body: bodyStream,
+                headers,
+                agent: getAgent(),
+                // @ts-expect-error: Internal types don't match
+                signal,
+            });
+        }
+        catch (error) {
+            return retry(error);
+        }
+        if (response.status === 408 ||
+            response.status === 409 ||
+            response.status === 429 ||
+            (response.status >= 500 && response.status <= 599)) {
+            const message = `Upload of "${filePath}" failed: ${response.statusText}`;
+            const text = await response.text().catch(() => null);
+            return retry(new Error(text ? `${message}\n${text}` : message));
+        }
+        else if (response.status === 413) {
+            const message = `Upload of "${filePath}" failed: File size exceeded the upload limit`;
+            throw new Error(message);
+        }
+        else if (!response.ok) {
+            throw new Error(`Upload of "${filePath}" failed: ${response.statusText}`);
+        }
+        return {
+            params,
+            response,
+        };
+    }, {
+        retries: MAX_RETRIES,
+        minTimeout: MIN_RETRY_TIMEOUT,
+        randomize: true,
+        factor: 2,
+    });
+}
+exports.uploadAsync = uploadAsync;
+async function* batchUploadAsync(uploads) {
+    const controller = new AbortController();
+    const queue = new Set();
+    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 };
+            }
+            yield await Promise.race(queue);
+        }
+    }
+    catch (error) {
+        if (typeof error !== 'object' || error.name !== 'AbortError') {
+            throw error;
+        }
+    }
+    finally {
+        if (queue.size > 0) {
+            controller.abort();
+        }
+    }
+}
+exports.batchUploadAsync = batchUploadAsync;

package/oclif.manifest.json

@@ -1,5 +1,5 @@
 {
-  "version": "11.0.3",
+  "version": "12.1.0",
   "commands": {
     "analytics": {
       "id": "analytics",
@@ -3378,6 +3378,27 @@
         "loggedIn": {}
       }
     },
+    "worker:deploy": {
+      "id": "worker:deploy",
+      "description": "deploy an Expo web build",
+      "strict": true,
+      "pluginName": "eas-cli",
+      "pluginAlias": "eas-cli",
+      "pluginType": "core",
+      "hidden": true,
+      "state": "beta",
+      "aliases": [
+        "deploy"
+      ],
+      "flags": {},
+      "args": {},
+      "contextDefinition": {
+        "getDynamicPublicProjectConfigAsync": {},
+        "getDynamicPrivateProjectConfigAsync": {},
+        "projectDir": {},
+        "loggedIn": {}
+      }
+    },
     "build:version:get": {
       "id": "build:version:get",
       "description": "get the latest version from EAS servers",

package/package.json

@@ -1,20 +1,20 @@
 {
   "name": "eas-cli",
   "description": "EAS command line tool",
-  "version": "11.0.3",
+  "version": "12.1.0",
   "author": "Expo <support@expo.dev>",
   "bin": {
     "eas": "./bin/run"
   },
   "bugs": "https://github.com/expo/eas-cli/issues",
   "dependencies": {
-    "@expo/apple-utils": "1.7.1",
+    "@expo/apple-utils": "1.8.0",
     "@expo/code-signing-certificates": "0.0.5",
     "@expo/config": "8.5.4",
     "@expo/config-plugins": "7.8.4",
     "@expo/config-types": "50.0.0",
     "@expo/eas-build-job": "1.0.133",
-    "@expo/eas-json": "11.0.0",
+    "@expo/eas-json": "12.0.0",
     "@expo/json-file": "8.2.37",
     "@expo/logger": "1.0.117",
     "@expo/multipart-body-parser": "1.1.0",
@@ -28,7 +28,7 @@
     "@expo/results": "1.0.0",
     "@expo/rudder-sdk-node": "1.1.1",
     "@expo/spawn-async": "1.7.0",
-    "@expo/steps": "1.0.130",
+    "@expo/steps": "1.0.134",
     "@expo/timeago.js": "1.0.0",
     "@oclif/core": "^1.26.2",
     "@oclif/plugin-autocomplete": "^2.3.10",
@@ -63,6 +63,7 @@
     "log-symbols": "4.1.0",
     "mime": "3.0.0",
     "minimatch": "5.1.2",
+    "minizlib": "3.0.1",
     "nanoid": "3.3.4",
     "node-fetch": "2.6.7",
     "node-forge": "1.3.1",
@@ -78,6 +79,7 @@
     "semver": "7.5.4",
     "slash": "3.0.0",
     "tar": "6.2.1",
+    "tar-stream": "3.1.7",
     "terminal-link": "2.1.1",
     "tslib": "2.6.2",
     "turndown": "7.1.2",
@@ -105,6 +107,7 @@
     "@types/prompts": "2.4.2",
     "@types/semver": "7.5.6",
     "@types/tar": "6.1.10",
+    "@types/tar-stream": "3.1.3",
     "@types/tough-cookie": "4.0.2",
     "@types/uuid": "9.0.7",
     "@types/wrap-ansi": "3.0.0",
@@ -223,5 +226,5 @@
     "node": "20.11.0",
     "yarn": "1.22.21"
   },
-  "gitHead": "56d492cbac7b2c198b13c80e56efc637869465f5"
+  "gitHead": "e993e9a370e5823d3c413f7edf0cbec7a6395c32"
 }