eas-cli 2.7.1 → 2.9.0

package/build/run/android/adb.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waitForEmulatorToBeBootedAsync = exports.isEmulatorBootedAsync = exports.getFirstRunningEmulatorAsync = exports.getRunningEmulatorsAsync = exports.getAdbNameForDeviceIdAsync = exports.sanitizeAdbDeviceName = exports.getAdbExecutableAsync = exports.adbAsync = void 0;
+const tslib_1 = require("tslib");
+const spawn_async_1 = tslib_1.__importDefault(require("@expo/spawn-async"));
+const os_1 = tslib_1.__importDefault(require("os"));
+const path_1 = tslib_1.__importDefault(require("path"));
+const log_1 = tslib_1.__importDefault(require("../../log"));
+const filter_1 = require("../../utils/expodash/filter");
+const promise_1 = require("../../utils/promise");
+const sdk_1 = require("./sdk");
+const BEGINNING_OF_ADB_ERROR_MESSAGE = 'error: ';
+async function adbAsync(...args) {
+    const adbExecutable = await getAdbExecutableAsync();
+    try {
+        return await (0, spawn_async_1.default)(adbExecutable, args);
+    }
+    catch (error) {
+        let errorMessage = (error.stderr || error.stdout || error.message).trim();
+        if (errorMessage.startsWith(BEGINNING_OF_ADB_ERROR_MESSAGE)) {
+            errorMessage = errorMessage.substring(BEGINNING_OF_ADB_ERROR_MESSAGE.length);
+        }
+        error.message = errorMessage;
+        throw error;
+    }
+}
+exports.adbAsync = adbAsync;
+async function getAdbExecutableAsync() {
+    const sdkRoot = await (0, sdk_1.getAndroidSdkRootAsync)();
+    if (!sdkRoot) {
+        log_1.default.debug('Failed to resolve the Android SDK path, falling back to global adb executable');
+        return 'adb';
+    }
+    return path_1.default.join(sdkRoot, 'platform-tools/adb');
+}
+exports.getAdbExecutableAsync = getAdbExecutableAsync;
+function sanitizeAdbDeviceName(deviceName) {
+    return deviceName.trim().split(/[\r\n]+/)[0];
+}
+exports.sanitizeAdbDeviceName = sanitizeAdbDeviceName;
+/**
+ * Return the Emulator name for an emulator ID, this can be used to determine if an emulator is booted.
+ *
+ * @param devicePid a value like `emulator-5554` from `abd devices`
+ */
+async function getAdbNameForDeviceIdAsync(emulatorPid) {
+    var _a;
+    const { stdout } = await adbAsync('-s', emulatorPid, 'emu', 'avd', 'name');
+    if (stdout.match(/could not connect to TCP port .*: Connection refused/)) {
+        // Can also occur when the emulator does not exist.
+        throw new Error(`Emulator not found: ${stdout}`);
+    }
+    return (_a = sanitizeAdbDeviceName(stdout)) !== null && _a !== void 0 ? _a : null;
+}
+exports.getAdbNameForDeviceIdAsync = getAdbNameForDeviceIdAsync;
+// TODO: This is very expensive for some operations.
+async function getRunningEmulatorsAsync() {
+    const { stdout } = await adbAsync('devices', '-l');
+    const splitItems = stdout.trim().split(os_1.default.EOL);
+    const attachedDevices = splitItems
+        // First line is `"List of devices attached"`, remove it
+        .slice(1, splitItems.length)
+        .map(line => {
+        // unauthorized: ['FA8251A00719', 'unauthorized', 'usb:338690048X', 'transport_id:5']
+        // authorized: ['FA8251A00719', 'device', 'usb:336592896X', 'product:walleye', 'model:Pixel_2', 'device:walleye', 'transport_id:4']
+        // emulator: ['emulator-5554', 'offline', 'transport_id:1']
+        const [pid] = line.split(' ').filter(filter_1.truthy);
+        const type = line.includes('emulator') ? 'emulator' : 'device';
+        return { pid, type };
+    })
+        .filter(({ pid, type }) => !!pid && type === 'emulator');
+    const devicePromises = attachedDevices.map(async ({ pid }) => {
+        var _a;
+        const name = (_a = (await getAdbNameForDeviceIdAsync(pid))) !== null && _a !== void 0 ? _a : '';
+        return {
+            pid,
+            name,
+        };
+    });
+    return Promise.all(devicePromises);
+}
+exports.getRunningEmulatorsAsync = getRunningEmulatorsAsync;
+async function getFirstRunningEmulatorAsync() {
+    var _a;
+    const emulators = await getRunningEmulatorsAsync();
+    return (_a = emulators[0]) !== null && _a !== void 0 ? _a : null;
+}
+exports.getFirstRunningEmulatorAsync = getFirstRunningEmulatorAsync;
+/**
+ * Returns true if emulator is booted
+ *
+ * @param emulatorPid
+ */
+async function isEmulatorBootedAsync(emulatorPid) {
+    try {
+        const { stdout } = await adbAsync('-s', emulatorPid, 'shell', 'getprop', 'sys.boot_completed');
+        if (stdout.trim() === '1') {
+            return true;
+        }
+        return false;
+    }
+    catch {
+        return false;
+    }
+}
+exports.isEmulatorBootedAsync = isEmulatorBootedAsync;
+async function waitForEmulatorToBeBootedAsync(maxWaitTimeMs, intervalMs) {
+    log_1.default.newLine();
+    log_1.default.log('Waiting for the Android emulator to start...');
+    const startTime = Date.now();
+    while (Date.now() - startTime < maxWaitTimeMs) {
+        const emulator = await getFirstRunningEmulatorAsync();
+        if ((emulator === null || emulator === void 0 ? void 0 : emulator.pid) && (await isEmulatorBootedAsync(emulator.pid))) {
+            return emulator;
+        }
+        await (0, promise_1.sleepAsync)(intervalMs);
+    }
+    throw new Error('Timed out waiting for the Android emulator to start.');
+}
+exports.waitForEmulatorToBeBootedAsync = waitForEmulatorToBeBootedAsync;

package/build/run/android/emulator.d.ts

@@ -0,0 +1,7 @@
+import { AndroidEmulator } from './adb';
+export declare const EMULATOR_MAX_WAIT_TIMEOUT_MS: number;
+export declare function getEmulatorExecutableAsync(): Promise<string>;
+export declare function selectEmulatorAsync(): Promise<AndroidEmulator>;
+export declare function ensureEmulatorBootedAsync(emulator: AndroidEmulator): Promise<AndroidEmulator>;
+export declare function installAppAsync(emulator: AndroidEmulator, apkFilePath: string): Promise<void>;
+export declare function startAppAsync(emulator: AndroidEmulator, packageName: string, activityName: string): Promise<void>;

package/build/run/android/emulator.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startAppAsync = exports.installAppAsync = exports.ensureEmulatorBootedAsync = exports.selectEmulatorAsync = exports.getEmulatorExecutableAsync = exports.EMULATOR_MAX_WAIT_TIMEOUT_MS = void 0;
+const tslib_1 = require("tslib");
+const spawn_async_1 = tslib_1.__importDefault(require("@expo/spawn-async"));
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const node_assert_1 = tslib_1.__importDefault(require("node:assert"));
+const os_1 = tslib_1.__importDefault(require("os"));
+const path_1 = tslib_1.__importDefault(require("path"));
+const log_1 = tslib_1.__importDefault(require("../../log"));
+const prompts_1 = require("../../prompts");
+const filter_1 = require("../../utils/expodash/filter");
+const adb_1 = require("./adb");
+const sdk_1 = require("./sdk");
+exports.EMULATOR_MAX_WAIT_TIMEOUT_MS = 60 * 1000 * 3;
+async function getEmulatorExecutableAsync() {
+    const sdkRoot = await (0, sdk_1.getAndroidSdkRootAsync)();
+    if (sdkRoot) {
+        return path_1.default.join(sdkRoot, 'emulator', 'emulator');
+    }
+    return 'emulator';
+}
+exports.getEmulatorExecutableAsync = getEmulatorExecutableAsync;
+async function emulatorAsync(...options) {
+    const emulatorExecutable = await getEmulatorExecutableAsync();
+    try {
+        return await (0, spawn_async_1.default)(emulatorExecutable, options);
+    }
+    catch (error) {
+        if (error.stderr) {
+            log_1.default.error(error.stderr);
+        }
+        throw error;
+    }
+}
+async function getAvaliableAndroidEmulatorsAsync() {
+    try {
+        const { stdout } = await emulatorAsync('-list-avds');
+        return stdout
+            .split(os_1.default.EOL)
+            .filter(filter_1.truthy)
+            .map(name => ({
+            name,
+        }));
+    }
+    catch {
+        return [];
+    }
+}
+/** Start an Android device and wait until it is booted. */
+async function bootEmulatorAsync(emulator, { timeout = exports.EMULATOR_MAX_WAIT_TIMEOUT_MS, interval = 1000, } = {}) {
+    log_1.default.newLine();
+    log_1.default.log(`Opening emulator ${chalk_1.default.bold(emulator.name)}`);
+    const emulatorExecutable = await getEmulatorExecutableAsync();
+    // Start a process to open an emulator
+    const emulatorProcess = (0, spawn_async_1.default)(emulatorExecutable, [`@${emulator.name}`], {
+        stdio: 'ignore',
+        detached: true,
+    });
+    // we don't want to wait for the emulator process to exit before we can finish `eas build:run` command
+    // https://github.com/expo/eas-cli/pull/1485#discussion_r1007935871
+    emulatorProcess.child.unref();
+    return await (0, adb_1.waitForEmulatorToBeBootedAsync)(timeout, interval);
+}
+async function selectEmulatorAsync() {
+    const runningEmulator = await (0, adb_1.getFirstRunningEmulatorAsync)();
+    if (runningEmulator) {
+        log_1.default.newLine();
+        log_1.default.log(`Using open emulator: ${chalk_1.default.bold(runningEmulator.name)}`);
+        return runningEmulator;
+    }
+    const emulators = await getAvaliableAndroidEmulatorsAsync();
+    log_1.default.newLine();
+    const { selectedEmulator } = await (0, prompts_1.promptAsync)({
+        type: 'select',
+        message: `Select an emulator to run your app on`,
+        name: 'selectedEmulator',
+        choices: emulators.map(emulator => ({
+            title: emulator.name,
+            value: emulator,
+        })),
+    });
+    return selectedEmulator;
+}
+exports.selectEmulatorAsync = selectEmulatorAsync;
+async function ensureEmulatorBootedAsync(emulator) {
+    if (!emulator.pid || !(await (0, adb_1.isEmulatorBootedAsync)(emulator.pid))) {
+        return await bootEmulatorAsync(emulator);
+    }
+    return emulator;
+}
+exports.ensureEmulatorBootedAsync = ensureEmulatorBootedAsync;
+async function installAppAsync(emulator, apkFilePath) {
+    log_1.default.newLine();
+    log_1.default.log('Installing your app...');
+    (0, node_assert_1.default)(emulator.pid);
+    await (0, adb_1.adbAsync)('-s', emulator.pid, 'install', '-r', '-d', apkFilePath);
+    log_1.default.succeed('Successfully installed your app!');
+}
+exports.installAppAsync = installAppAsync;
+async function startAppAsync(emulator, packageName, activityName) {
+    log_1.default.newLine();
+    log_1.default.log('Starting your app...');
+    (0, node_assert_1.default)(emulator.pid);
+    await (0, adb_1.adbAsync)('-s', emulator.pid, 'shell', 'am', 'start', '-a', 'android.intent.action.MAIN', '-f', '0x20000000', // FLAG_ACTIVITY_SINGLE_TOP -- If set, the activity will not be launched if it is already running at the top of the history stack.
+    '-n', `${packageName}/${activityName}`);
+    log_1.default.succeed('Successfully started your app!');
+}
+exports.startAppAsync = startAppAsync;

package/build/run/android/run.d.ts

@@ -1 +1 @@
-export declare function runAppOnAndroidEmulatorAsync(_appPath: string): Promise<void>;
+export declare function runAppOnAndroidEmulatorAsync(appPath: string): Promise<void>;

package/build/run/android/run.js

@@ -2,8 +2,15 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runAppOnAndroidEmulatorAsync = void 0;
 const tslib_1 = require("tslib");
-const log_1 = tslib_1.__importDefault(require("../../log"));
-async function runAppOnAndroidEmulatorAsync(_appPath) {
-    log_1.default.error('Not implemented!');
+const aapt_1 = require("./aapt");
+const emulator = tslib_1.__importStar(require("./emulator"));
+const systemRequirements_1 = require("./systemRequirements");
+async function runAppOnAndroidEmulatorAsync(appPath) {
+    await (0, systemRequirements_1.assertExecutablesExistAsync)();
+    const selectedEmulator = await emulator.selectEmulatorAsync();
+    const bootedEmulator = await emulator.ensureEmulatorBootedAsync(selectedEmulator);
+    await emulator.installAppAsync(bootedEmulator, appPath);
+    const { packageName, activityName } = await (0, aapt_1.getAptParametersAsync)(appPath);
+    await emulator.startAppAsync(bootedEmulator, packageName, activityName);
 }
 exports.runAppOnAndroidEmulatorAsync = runAppOnAndroidEmulatorAsync;

package/build/run/android/sdk.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="node" />
+export declare const ANDROID_DEFAULT_LOCATION: Readonly<Partial<Record<NodeJS.Platform, string>>>;
+export declare function getAndroidSdkRootAsync(): Promise<string | null>;

package/build/run/android/sdk.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAndroidSdkRootAsync = exports.ANDROID_DEFAULT_LOCATION = void 0;
+const tslib_1 = require("tslib");
+const fs_extra_1 = require("fs-extra");
+const os_1 = tslib_1.__importDefault(require("os"));
+const path_1 = tslib_1.__importDefault(require("path"));
+exports.ANDROID_DEFAULT_LOCATION = {
+    darwin: path_1.default.join(os_1.default.homedir(), 'Library', 'Android', 'sdk'),
+    linux: path_1.default.join(os_1.default.homedir(), 'Android', 'Sdk'),
+    win32: path_1.default.join(os_1.default.homedir(), 'AppData', 'Local', 'Android', 'Sdk'),
+};
+const ANDROID_DEFAULT_LOCATION_FOR_CURRENT_PLATFORM = exports.ANDROID_DEFAULT_LOCATION[process.platform];
+async function getAndroidSdkRootAsync() {
+    if (process.env.ANDROID_HOME && (await (0, fs_extra_1.pathExists)(process.env.ANDROID_HOME))) {
+        return process.env.ANDROID_HOME;
+    }
+    else if (process.env.ANDROID_SDK_ROOT && (await (0, fs_extra_1.pathExists)(process.env.ANDROID_SDK_ROOT))) {
+        return process.env.ANDROID_SDK_ROOT;
+    }
+    else if (ANDROID_DEFAULT_LOCATION_FOR_CURRENT_PLATFORM &&
+        (await (0, fs_extra_1.pathExists)(ANDROID_DEFAULT_LOCATION_FOR_CURRENT_PLATFORM))) {
+        return ANDROID_DEFAULT_LOCATION_FOR_CURRENT_PLATFORM;
+    }
+    else {
+        return null;
+    }
+}
+exports.getAndroidSdkRootAsync = getAndroidSdkRootAsync;

package/build/run/android/systemRequirements.d.ts

@@ -0,0 +1 @@
+export declare function assertExecutablesExistAsync(): Promise<void>;

package/build/run/android/systemRequirements.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertExecutablesExistAsync = void 0;
+const tslib_1 = require("tslib");
+const spawn_async_1 = tslib_1.__importDefault(require("@expo/spawn-async"));
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const aapt_1 = require("./aapt");
+const adb_1 = require("./adb");
+const emulator_1 = require("./emulator");
+async function assertExecutableExistsAsync(executable, options) {
+    try {
+        await (0, spawn_async_1.default)(executable, options);
+    }
+    catch (err) {
+        throw new Error(`${chalk_1.default.bold(executable)} executable doesn't seem to work. Please make sure Android Studio is installed on your device and ${chalk_1.default.bold('ANDROID_HOME')} or ${chalk_1.default.bold('ANDROID_SDK_ROOT')} env variables are set.
+${err.message}`);
+    }
+}
+async function assertExecutablesExistAsync() {
+    await assertExecutableExistsAsync(await (0, adb_1.getAdbExecutableAsync)(), ['--version']);
+    await assertExecutableExistsAsync(await (0, emulator_1.getEmulatorExecutableAsync)(), ['-list-avds']);
+    await assertExecutableExistsAsync(await (0, aapt_1.getAaptExecutableAsync)(), ['version']);
+}
+exports.assertExecutablesExistAsync = assertExecutablesExistAsync;

package/build/run/ios/simulator.js

@@ -20,7 +20,7 @@ async function selectSimulatorAsync() {
         message: `Select a simulator to run your app on`,
         name: 'selectedSimulator',
         choices: simulators.map(simulator => ({
-            title: `ios ${simulator.osVersion} ${simulator.name}`,
+            title: `iOS ${simulator.osVersion} ${simulator.name}`,
             value: simulator,
         })),
     });

package/build/run/utils.d.ts

@@ -0,0 +1,2 @@
+import { BuildFragment } from '../graphql/generated';
+export declare function isRunnableOnSimulatorOrEmulator(build: BuildFragment): boolean;

package/build/run/utils.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isRunnableOnSimulatorOrEmulator = void 0;
+const generated_1 = require("../graphql/generated");
+function isAab(build) {
+    var _a, _b, _c;
+    return (_c = (_b = (_a = build.artifacts) === null || _a === void 0 ? void 0 : _a.applicationArchiveUrl) === null || _b === void 0 ? void 0 : _b.endsWith('.aab')) !== null && _c !== void 0 ? _c : false;
+}
+function didArtifactsExpire(build) {
+    return new Date().getTime() - new Date(build.updatedAt).getTime() > 30 * 24 * 60 * 60 * 1000; // 30 days
+}
+function isRunnableOnSimulatorOrEmulator(build) {
+    var _a;
+    return (build.status === generated_1.BuildStatus.Finished &&
+        !!((_a = build.artifacts) === null || _a === void 0 ? void 0 : _a.applicationArchiveUrl) &&
+        ((build.platform === generated_1.AppPlatform.Ios && build.distribution === generated_1.DistributionType.Simulator) ||
+            (build.platform === generated_1.AppPlatform.Android && !isAab(build))) &&
+        !didArtifactsExpire(build));
+}
+exports.isRunnableOnSimulatorOrEmulator = isRunnableOnSimulatorOrEmulator;

package/build/submit/ArchiveSource.d.ts

@@ -7,14 +7,19 @@ export declare enum ArchiveSourceType {
     latest = 1,
     path = 2,
     buildId = 3,
-    buildList = 4,
-    prompt = 5
+    build = 4,
+    buildList = 5,
+    prompt = 6,
+    gcs = 7
 }
-interface ArchiveSourceBase {
-    sourceType: ArchiveSourceType;
+export interface ArchiveResolverContext {
     platform: Platform;
     projectId: string;
     nonInteractive: boolean;
+    graphqlClient: ExpoGraphqlClient;
+}
+interface ArchiveSourceBase {
+    sourceType: ArchiveSourceType;
 }
 interface ArchiveUrlSource extends ArchiveSourceBase {
     sourceType: ArchiveSourceType.url;
@@ -31,18 +36,23 @@ interface ArchiveBuildIdSource extends ArchiveSourceBase {
     sourceType: ArchiveSourceType.buildId;
     id: string;
 }
+interface ArchiveBuildSource extends ArchiveSourceBase {
+    sourceType: ArchiveSourceType.build;
+    build: BuildFragment;
+}
 interface ArchiveBuildListSource extends ArchiveSourceBase {
     sourceType: ArchiveSourceType.buildList;
 }
 interface ArchivePromptSource extends ArchiveSourceBase {
     sourceType: ArchiveSourceType.prompt;
 }
-export interface Archive {
-    build?: BuildFragment;
-    source: ArchiveSource;
-    url?: string;
+interface ArchiveGCSSource extends ArchiveSourceBase {
+    sourceType: ArchiveSourceType.gcs;
+    bucketKey: string;
+    localSource: ArchivePathSource;
 }
-export declare type ArchiveSource = ArchiveUrlSource | ArchiveLatestSource | ArchivePathSource | ArchiveBuildIdSource | ArchiveBuildListSource | ArchivePromptSource;
-export declare function getArchiveAsync(graphqlClient: ExpoGraphqlClient, source: ArchiveSource): Promise<Archive>;
+export declare type ArchiveSource = ArchiveUrlSource | ArchiveLatestSource | ArchivePathSource | ArchiveBuildIdSource | ArchiveBuildSource | ArchiveBuildListSource | ArchivePromptSource | ArchiveGCSSource;
+export declare type ResolvedArchiveSource = ArchiveUrlSource | ArchiveGCSSource | ArchiveBuildSource;
+export declare function getArchiveAsync(ctx: ArchiveResolverContext, source: ArchiveSource): Promise<ResolvedArchiveSource>;
 export declare function isUuidV4(s: string): boolean;
 export {};