@donotuse/eas-cli 18.5.0-rc.1

package/build/rollout/branch-mapping.js

@@ -0,0 +1,271 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isLegacyRolloutInfo = isLegacyRolloutInfo;
+exports.isConstrainedRolloutInfo = isConstrainedRolloutInfo;
+exports.isConstrainedRollout = isConstrainedRollout;
+exports.getRolloutInfo = getRolloutInfo;
+exports.getRolloutInfoFromBranchMapping = getRolloutInfoFromBranchMapping;
+exports.getRollout = getRollout;
+exports.composeRollout = composeRollout;
+exports.getRolloutBranchMapping = getRolloutBranchMapping;
+exports.isRolloutBranchMapping = isRolloutBranchMapping;
+exports.isRollout = isRollout;
+exports.doesTargetRollout = doesTargetRollout;
+exports.createRolloutBranchMapping = createRolloutBranchMapping;
+exports.editRolloutBranchMapping = editRolloutBranchMapping;
+exports.assertRolloutBranchMapping = assertRolloutBranchMapping;
+const branch_mapping_1 = require("../channel/branch-mapping");
+const utils_1 = require("../channel/utils");
+function isLegacyRolloutInfo(rollout) {
+    return !isConstrainedRolloutInfo(rollout);
+}
+function isConstrainedRolloutInfo(rollout) {
+    return 'runtimeVersion' in rollout;
+}
+function isConstrainedRollout(rollout) {
+    return isConstrainedRolloutInfo(rollout);
+}
+function getRolloutInfo(basicChannelInfo) {
+    const rolloutBranchMapping = getRolloutBranchMapping(basicChannelInfo.branchMapping);
+    return getRolloutInfoFromBranchMapping(rolloutBranchMapping);
+}
+function getRolloutInfoFromBranchMapping(branchMapping) {
+    const rolledOutBranchId = branchMapping.data[0].branchId;
+    const defaultBranchId = branchMapping.data[1].branchId;
+    if (isRtvConstrainedRollout(branchMapping)) {
+        const statementNode = branchMapping.data[0].branchMappingLogic;
+        (0, branch_mapping_1.assertStatement)(statementNode);
+        const nodesFromStatement = (0, branch_mapping_1.getNodesFromStatement)(statementNode);
+        const runtimeVersionNode = nodesFromStatement.find(isRuntimeVersionNode);
+        if (!runtimeVersionNode) {
+            throw new branch_mapping_1.BranchMappingValidationError('Runtime version node must be defined.');
+        }
+        (0, branch_mapping_1.assertNodeObject)(runtimeVersionNode);
+        const runtimeVersion = runtimeVersionNode.operand;
+        (0, branch_mapping_1.assertString)(runtimeVersion);
+        const rolloutNode = nodesFromStatement.find(isRolloutNode);
+        if (!rolloutNode) {
+            throw new branch_mapping_1.BranchMappingValidationError('Rollout node must be defined.');
+        }
+        (0, branch_mapping_1.assertNodeObject)(rolloutNode);
+        const operand = rolloutNode.operand;
+        (0, branch_mapping_1.assertNumber)(operand);
+        return {
+            rolledOutBranchId,
+            percentRolledOut: Math.round(operand * 100),
+            runtimeVersion,
+            defaultBranchId,
+        };
+    }
+    else {
+        const rolloutNode = branchMapping.data[0].branchMappingLogic;
+        (0, branch_mapping_1.assertNodeObject)(rolloutNode);
+        const operand = rolloutNode.operand;
+        (0, branch_mapping_1.assertNumber)(operand);
+        return {
+            rolledOutBranchId,
+            percentRolledOut: Math.round(operand * 100),
+            defaultBranchId,
+        };
+    }
+}
+function getRollout(channel) {
+    const rolloutBranchMapping = getRolloutBranchMapping(channel.branchMapping);
+    const rolledOutBranchId = rolloutBranchMapping.data[0].branchId;
+    const rolledOutBranch = (0, utils_1.getUpdateBranch)(channel, rolledOutBranchId);
+    const defaultBranchId = rolloutBranchMapping.data[1].branchId;
+    const defaultBranch = (0, utils_1.getUpdateBranch)(channel, defaultBranchId);
+    const rolloutInfo = getRolloutInfo(channel);
+    return composeRollout(rolloutInfo, defaultBranch, rolledOutBranch);
+}
+function composeRollout(rolloutInfo, defaultBranch, rolledOutBranch) {
+    if (rolloutInfo.defaultBranchId !== defaultBranch.id) {
+        throw new branch_mapping_1.BranchMappingValidationError(`Default branch id must match. Received: ${JSON.stringify(rolloutInfo)} ${defaultBranch.id}`);
+    }
+    if (rolloutInfo.rolledOutBranchId !== rolledOutBranch.id) {
+        throw new branch_mapping_1.BranchMappingValidationError(`Rolled out branch id must match. Received: ${JSON.stringify(rolloutInfo)} ${rolledOutBranch.id}`);
+    }
+    return {
+        ...rolloutInfo,
+        rolledOutBranch,
+        defaultBranch,
+    };
+}
+function getRolloutBranchMapping(branchMappingString) {
+    const branchMapping = (0, branch_mapping_1.getBranchMapping)(branchMappingString);
+    assertRolloutBranchMapping(branchMapping);
+    return branchMapping;
+}
+/**
+ * Detect if a branch mapping is a rollout.
+ *
+ * Types of rollout:
+ * 1. Legacy unconstrained rollout:
+ * Maps to a rollout branch via a rollout token
+ * Falls back to a default branch
+ *
+ * Example:
+ * {
+    version: 0,
+    data: [
+      {
+        branchId: uuidv4(),
+        branchMappingLogic: {
+          operand: 10 / 100,
+          clientKey: 'rolloutToken',
+          branchMappingOperator: hashLtOperator(),
+        },
+      },
+      { branchId: uuidv4(), branchMappingLogic: alwaysTrue() },
+    ],
+  }
+  *
+  * 2. RTV constrained rollout:
+  * Maps to a rollout branch via a rollout token, constrained by runtime version
+  * Falls back to a default branch
+  *
+  * Example:
+  * {
+    version: 0,
+    data: [
+      {
+        branchId: uuidv4(),
+        branchMappingLogic: andStatement([
+          {
+            operand: '1.0.0',
+            clientKey: 'runtimeVersion',
+            branchMappingOperator: equalsOperator(),
+          },
+          {
+            operand: 10 / 100,
+            clientKey: 'rolloutToken',
+            branchMappingOperator: hashLtOperator(),
+          },
+        ]),
+      },
+      { branchId: uuidv4(), branchMappingLogic: alwaysTrue() },
+    ],
+  }
+ */
+function isRolloutBranchMapping(branchMapping) {
+    return isUnconstrainedRollout(branchMapping) || isRtvConstrainedRollout(branchMapping);
+}
+function isRollout(channelInfo) {
+    const branchMapping = (0, branch_mapping_1.getBranchMapping)(channelInfo.branchMapping);
+    return isRolloutBranchMapping(branchMapping);
+}
+function doesTargetRollout(branchMapping, runtimeVersion) {
+    const rolloutInfo = getRolloutInfoFromBranchMapping(branchMapping);
+    if (!isConstrainedRolloutInfo(rolloutInfo)) {
+        return true;
+    }
+    return rolloutInfo.runtimeVersion === runtimeVersion;
+}
+function createRolloutBranchMapping({ defaultBranchId, rolloutBranchId, percent, runtimeVersion, }) {
+    assertPercent(percent);
+    return {
+        version: 0,
+        data: [
+            {
+                branchId: rolloutBranchId,
+                branchMappingLogic: [
+                    'and',
+                    {
+                        operand: runtimeVersion,
+                        clientKey: 'runtimeVersion',
+                        branchMappingOperator: '==',
+                    },
+                    {
+                        operand: percent / 100,
+                        clientKey: 'rolloutToken',
+                        branchMappingOperator: 'hash_lt',
+                    },
+                ],
+            },
+            { branchId: defaultBranchId, branchMappingLogic: (0, branch_mapping_1.alwaysTrue)() },
+        ],
+    };
+}
+function editRolloutBranchMapping(branchMapping, percent) {
+    assertPercent(percent);
+    if (isRtvConstrainedRollout(branchMapping)) {
+        return editRtvConstrainedRollout(branchMapping, percent);
+    }
+    else {
+        return editLegacyRollout(branchMapping, percent);
+    }
+}
+function editRtvConstrainedRollout(branchMapping, percent) {
+    const newBranchMapping = { ...branchMapping };
+    const statementNode = newBranchMapping.data[0].branchMappingLogic;
+    const nodesFromStatement = (0, branch_mapping_1.getNodesFromStatement)(statementNode);
+    const rolloutNode = nodesFromStatement.find(isRolloutNode);
+    if (!rolloutNode) {
+        throw new branch_mapping_1.BranchMappingValidationError('Rollout node must be defined.');
+    }
+    rolloutNode.operand = percent / 100;
+    return newBranchMapping;
+}
+function editLegacyRollout(branchMapping, percent) {
+    const newBranchMapping = { ...branchMapping };
+    const rolloutNode = newBranchMapping.data[0].branchMappingLogic;
+    rolloutNode.operand = percent / 100;
+    return newBranchMapping;
+}
+function isRtvConstrainedRollout(branchMapping) {
+    if (branchMapping.data.length !== 2) {
+        return false;
+    }
+    const hasRtvRolloutNode = isRtvConstrainedRolloutNode(branchMapping.data[0].branchMappingLogic);
+    const defaultsToAlwaysTrueNode = (0, branch_mapping_1.isAlwaysTrue)(branchMapping.data[1].branchMappingLogic);
+    return hasRtvRolloutNode && defaultsToAlwaysTrueNode;
+}
+function isRtvConstrainedRolloutNode(node) {
+    if (!(0, branch_mapping_1.isStatement)(node) || !(0, branch_mapping_1.isAndStatement)(node)) {
+        return false;
+    }
+    const statementNodes = (0, branch_mapping_1.getNodesFromStatement)(node);
+    if (statementNodes.length !== 2) {
+        return false;
+    }
+    const hasRuntimeVersionNode = statementNodes.some(isRuntimeVersionNode);
+    const hasRolloutNode = statementNodes.some(isRolloutNode);
+    return hasRuntimeVersionNode && hasRolloutNode;
+}
+function isUnconstrainedRollout(branchMapping) {
+    if (branchMapping.data.length !== 2) {
+        return false;
+    }
+    const hasRolloutNode = isRolloutNode(branchMapping.data[0].branchMappingLogic);
+    const defaultsToAlwaysTrueNode = (0, branch_mapping_1.isAlwaysTrue)(branchMapping.data[1].branchMappingLogic);
+    return hasRolloutNode && defaultsToAlwaysTrueNode;
+}
+function isRuntimeVersionNode(node) {
+    if (typeof node === 'string') {
+        return false;
+    }
+    if (Array.isArray(node)) {
+        return false;
+    }
+    return node.clientKey === 'runtimeVersion' && node.branchMappingOperator === '==';
+}
+function isRolloutNode(node) {
+    if (typeof node === 'string') {
+        return false;
+    }
+    if (Array.isArray(node)) {
+        return false;
+    }
+    return node.clientKey === 'rolloutToken' && node.branchMappingOperator === 'hash_lt';
+}
+function assertRolloutBranchMapping(branchMapping) {
+    if (!isRolloutBranchMapping(branchMapping)) {
+        throw new branch_mapping_1.BranchMappingValidationError('Branch mapping node must be a rollout. Received: ' + JSON.stringify(branchMapping));
+    }
+}
+function assertPercent(percent) {
+    const isPercent = Number.isInteger(percent) && percent >= 0 && percent <= 100;
+    if (!isPercent) {
+        throw new branch_mapping_1.BranchMappingValidationError(`The percentage must be an integer between 0 and 100 inclusive. Received: ${percent}`);
+    }
+}

package/build/rollout/utils.d.ts

@@ -0,0 +1,10 @@
+import { Rollout } from './branch-mapping';
+import { RuntimeFragment, UpdateBranchBasicInfoFragment, UpdateFragment } from '../graphql/generated';
+import { UpdateBranchObject, UpdateChannelObject } from '../graphql/queries/ChannelQuery';
+export declare function printRollout(channel: UpdateChannelObject): void;
+export declare function displayRolloutDetails(channelName: string, rollout: Rollout<UpdateBranchBasicInfoFragment>): void;
+export declare function formatBranchWithUpdateGroup(maybeUpdateGroup: UpdateFragment[] | undefined | null, branch: UpdateBranchObject, percentRolledOut: number): string;
+export declare function formatRuntimeWithUpdateGroup(maybeUpdateGroup: UpdateFragment[] | undefined | null, runtime: RuntimeFragment, branchName: string): string;
+export declare function promptForRolloutPercentAsync({ promptMessage, }: {
+    promptMessage: string;
+}): Promise<number>;

package/build/rollout/utils.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printRollout = printRollout;
+exports.displayRolloutDetails = displayRolloutDetails;
+exports.formatBranchWithUpdateGroup = formatBranchWithUpdateGroup;
+exports.formatRuntimeWithUpdateGroup = formatRuntimeWithUpdateGroup;
+exports.promptForRolloutPercentAsync = promptForRolloutPercentAsync;
+const tslib_1 = require("tslib");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const branch_mapping_1 = require("./branch-mapping");
+const log_1 = tslib_1.__importDefault(require("../log"));
+const prompts_1 = require("../prompts");
+const utils_1 = require("../update/utils");
+const formatFields_1 = tslib_1.__importDefault(require("../utils/formatFields"));
+function printRollout(channel) {
+    if (!(0, branch_mapping_1.isRollout)(channel)) {
+        log_1.default.log(`Channel ${chalk_1.default.bold(channel.name)} doesn't have a rollout.`);
+        return;
+    }
+    const rollout = (0, branch_mapping_1.getRollout)(channel);
+    displayRolloutDetails(channel.name, rollout);
+}
+function displayRolloutDetails(channelName, rollout) {
+    const rolledOutPercent = rollout.percentRolledOut;
+    log_1.default.newLine();
+    log_1.default.log(chalk_1.default.bold('🚀 Rollout:'));
+    log_1.default.log((0, formatFields_1.default)([
+        { label: 'Channel', value: channelName },
+        ...((0, branch_mapping_1.isConstrainedRollout)(rollout)
+            ? [{ label: 'Runtime version', value: rollout.runtimeVersion }]
+            : []),
+        {
+            label: 'Branches',
+            value: `${rollout.rolledOutBranch.name} (${rolledOutPercent}%), ${rollout.defaultBranch.name} (${100 - rolledOutPercent}%)`,
+        },
+    ]));
+    log_1.default.addNewLineIfNone();
+}
+function formatBranchWithUpdateGroup(maybeUpdateGroup, branch, percentRolledOut) {
+    const lines = [];
+    lines.push(chalk_1.default.bold(`➡️ 📱 Latest update on the ${chalk_1.default.bold(branch.name)} branch (${percentRolledOut}%)`));
+    if (!maybeUpdateGroup) {
+        lines.push(`No updates for target runtime`);
+    }
+    else {
+        const [updateGroupDescription] = (0, utils_1.getUpdateGroupDescriptions)([maybeUpdateGroup]);
+        lines.push(...formatUpdateGroup(updateGroupDescription));
+    }
+    return lines.join('\n    ');
+}
+function formatRuntimeWithUpdateGroup(maybeUpdateGroup, runtime, branchName) {
+    const lines = [];
+    lines.push(chalk_1.default.bold(`➡️ 📱 Latest update on the ${chalk_1.default.bold(branchName)} branch served to runtime ${chalk_1.default.bold(runtime.version)}:`));
+    if (!maybeUpdateGroup) {
+        lines.push(`No updates published for this runtime`);
+    }
+    else {
+        const [updateGroupDescription] = (0, utils_1.getUpdateGroupDescriptions)([maybeUpdateGroup]);
+        lines.push(...formatUpdateGroup(updateGroupDescription));
+    }
+    return lines.join('\n    ');
+}
+function formatUpdateGroup(updateGroup) {
+    const lines = [];
+    const formattedLines = (0, formatFields_1.default)([
+        { label: 'Message', value: updateGroup.message ?? 'N/A' },
+        { label: 'Runtime version', value: updateGroup.runtimeVersion ?? 'N/A' },
+        { label: 'Platforms', value: updateGroup.platforms ?? 'N/A' },
+        { label: 'Group ID', value: updateGroup.group ?? 'N/A' },
+    ]).split('\n');
+    lines.push(...formattedLines);
+    return lines;
+}
+async function promptForRolloutPercentAsync({ promptMessage, }) {
+    const { name: rolloutPercent } = await (0, prompts_1.promptAsync)({
+        type: 'text',
+        name: 'name',
+        format: value => {
+            return parseInt(value, 10);
+        },
+        message: promptMessage,
+        initial: 0,
+        validate: (rolloutPercent) => {
+            const floatValue = parseFloat(rolloutPercent);
+            return Number.isInteger(floatValue) && floatValue >= 0 && floatValue <= 100
+                ? true
+                : 'The rollout percentage must be an integer between 0 and 100 inclusive.';
+        },
+    });
+    return rolloutPercent;
+}

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

@@ -0,0 +1,5 @@
+export declare function getAaptExecutableAsync(): Promise<string>;
+export declare function getAptParametersAsync(appPath: string): Promise<{
+    packageName: string;
+    activityName: string;
+}>;

package/build/run/android/aapt.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAaptExecutableAsync = getAaptExecutableAsync;
+exports.getAptParametersAsync = getAptParametersAsync;
+const tslib_1 = require("tslib");
+const spawn_async_1 = tslib_1.__importDefault(require("@expo/spawn-async"));
+const fast_glob_1 = tslib_1.__importDefault(require("fast-glob"));
+const path_1 = tslib_1.__importDefault(require("path"));
+const sdk_1 = require("./sdk");
+const log_1 = tslib_1.__importDefault(require("../../log"));
+async function aaptAsync(...options) {
+    try {
+        return await (0, spawn_async_1.default)(await getAaptExecutableAsync(), options);
+    }
+    catch (error) {
+        if (error.stderr) {
+            log_1.default.error(error.stderr);
+        }
+        throw error;
+    }
+}
+async function getAaptExecutableAsync() {
+    const sdkRoot = await (0, sdk_1.getAndroidSdkRootAsync)();
+    if (!sdkRoot) {
+        log_1.default.debug('Failed to resolve the Android SDK path, falling back to global aapt executable');
+        return 'aapt';
+    }
+    const aaptPaths = await (0, fast_glob_1.default)(path_1.default.posix.join('build-tools/**', process.platform === 'win32' ? 'aapt.exe' : 'aapt'), { cwd: sdkRoot, absolute: true });
+    if (aaptPaths.length === 0) {
+        throw new Error('Failed to resolve the Android aapt path');
+    }
+    const sorted = aaptPaths.sort();
+    return sorted[sorted.length - 1];
+}
+async function getAptParametersAsync(appPath) {
+    const { stdout } = await aaptAsync('dump', 'badging', appPath);
+    const packageNameMatch = stdout.match(/package: name='([^']+)'/);
+    if (!packageNameMatch) {
+        throw new Error(`Could not read package name from ${appPath}`);
+    }
+    // get activity name
+    const activityNameMatch = stdout.match(/launchable-activity: name='([^']+)'/);
+    if (!activityNameMatch) {
+        throw new Error(`Could not read activity name from ${appPath}`);
+    }
+    return {
+        packageName: packageNameMatch[1],
+        activityName: activityNameMatch[1],
+    };
+}

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

@@ -0,0 +1,23 @@
+import { SpawnResult } from '@expo/spawn-async';
+export interface AndroidEmulator {
+    pid?: string;
+    name: string;
+}
+export declare function adbAsync(...args: string[]): Promise<SpawnResult>;
+export declare function getAdbExecutableAsync(): Promise<string>;
+export declare function sanitizeAdbDeviceName(deviceName: string): string | undefined;
+/**
+ * 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`
+ */
+export declare function getAdbNameForDeviceIdAsync(emulatorPid: string): Promise<string | null>;
+export declare function getRunningEmulatorsAsync(): Promise<AndroidEmulator[]>;
+export declare function getFirstRunningEmulatorAsync(): Promise<AndroidEmulator | null>;
+/**
+ * Returns true if emulator is booted
+ *
+ * @param emulatorPid
+ */
+export declare function isEmulatorBootedAsync(emulatorPid: string): Promise<boolean>;
+export declare function waitForEmulatorToBeBootedAsync(maxWaitTimeMs: number, intervalMs: number): Promise<AndroidEmulator>;

package/build/run/android/adb.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.adbAsync = adbAsync;
+exports.getAdbExecutableAsync = getAdbExecutableAsync;
+exports.sanitizeAdbDeviceName = sanitizeAdbDeviceName;
+exports.getAdbNameForDeviceIdAsync = getAdbNameForDeviceIdAsync;
+exports.getRunningEmulatorsAsync = getRunningEmulatorsAsync;
+exports.getFirstRunningEmulatorAsync = getFirstRunningEmulatorAsync;
+exports.isEmulatorBootedAsync = isEmulatorBootedAsync;
+exports.waitForEmulatorToBeBootedAsync = waitForEmulatorToBeBootedAsync;
+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 sdk_1 = require("./sdk");
+const log_1 = tslib_1.__importDefault(require("../../log"));
+const filter_1 = require("../../utils/expodash/filter");
+const promise_1 = require("../../utils/promise");
+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;
+    }
+}
+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');
+}
+function sanitizeAdbDeviceName(deviceName) {
+    return deviceName.trim().split(/[\r\n]+/)[0];
+}
+/**
+ * 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) {
+    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 sanitizeAdbDeviceName(stdout) ?? null;
+}
+// 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 }) => {
+        const name = (await getAdbNameForDeviceIdAsync(pid)) ?? '';
+        return {
+            pid,
+            name,
+        };
+    });
+    return await Promise.all(devicePromises);
+}
+async function getFirstRunningEmulatorAsync() {
+    const emulators = await getRunningEmulatorsAsync();
+    return emulators[0] ?? null;
+}
+/**
+ * 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;
+    }
+}
+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?.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.');
+}

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