@donotuse/eas-cli 18.5.0-rc.1

package/build/commands/build/list.js

@@ -0,0 +1,157 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const core_1 = require("@oclif/core");
+const queries_1 = require("../../build/queries");
+const types_1 = require("../../build/types");
+const EasCommand_1 = tslib_1.__importDefault(require("../../commandUtils/EasCommand"));
+const flags_1 = require("../../commandUtils/flags");
+const pagination_1 = require("../../commandUtils/pagination");
+const generated_1 = require("../../graphql/generated");
+const log_1 = tslib_1.__importDefault(require("../../log"));
+const platform_1 = require("../../platform");
+const projectUtils_1 = require("../../project/projectUtils");
+const buildDistribution_1 = require("../../utils/buildDistribution");
+const json_1 = require("../../utils/json");
+class BuildList extends EasCommand_1.default {
+    static description = 'list all builds for your project';
+    static flags = {
+        platform: core_1.Flags.option({
+            options: Object.values(platform_1.RequestedPlatform),
+            char: 'p',
+        })(),
+        status: core_1.Flags.option({
+            options: Object.values(types_1.BuildStatus),
+            description: 'Filter only builds with the specified status',
+        })(),
+        distribution: core_1.Flags.option({
+            options: Object.values(types_1.BuildDistributionType),
+            description: 'Filter only builds with the specified distribution type',
+        })(),
+        channel: core_1.Flags.string(),
+        'app-version': core_1.Flags.string({
+            aliases: ['appVersion'],
+            description: 'Filter only builds created with the specified main app version',
+        }),
+        'app-build-version': core_1.Flags.string({
+            aliases: ['appBuildVersion'],
+            description: 'Filter only builds created with the specified app build version',
+        }),
+        'sdk-version': core_1.Flags.string({
+            aliases: ['sdkVersion'],
+            description: 'Filter only builds created with the specified Expo SDK version',
+        }),
+        'runtime-version': core_1.Flags.string({
+            aliases: ['runtimeVersion'],
+            description: 'Filter only builds created with the specified runtime version',
+        }),
+        'app-identifier': core_1.Flags.string({
+            aliases: ['appIdentifier'],
+            description: 'Filter only builds created with the specified app identifier',
+        }),
+        'build-profile': core_1.Flags.string({
+            char: 'e',
+            aliases: ['profile', 'buildProfile'],
+            description: 'Filter only builds created with the specified build profile',
+        }),
+        'git-commit-hash': core_1.Flags.string({
+            aliases: ['gitCommitHash'],
+            description: 'Filter only builds created with the specified git commit hash',
+        }),
+        'fingerprint-hash': core_1.Flags.string({
+            description: 'Filter only builds with the specified fingerprint hash',
+        }),
+        ...pagination_1.EasPaginatedQueryFlags,
+        limit: (0, pagination_1.getLimitFlagWithCustomValues)({ defaultTo: 10, limit: queries_1.BUILDS_LIMIT }),
+        ...flags_1.EasNonInteractiveAndJsonFlags,
+        simulator: core_1.Flags.boolean({
+            description: 'Filter only iOS simulator builds. Can only be used with --platform flag set to "ios"',
+        }),
+    };
+    static contextDefinition = {
+        ...this.ContextOptions.ProjectId,
+        ...this.ContextOptions.LoggedIn,
+        ...this.ContextOptions.Vcs,
+    };
+    async runAsync() {
+        const { flags } = await this.parse(BuildList);
+        const paginatedQueryOptions = (0, pagination_1.getPaginatedQueryOptions)(flags);
+        const { json: jsonFlag, nonInteractive } = (0, flags_1.resolveNonInteractiveAndJsonFlags)(flags);
+        const { platform: requestedPlatform, status: buildStatus, distribution: buildDistribution, } = flags;
+        if (buildDistribution === types_1.BuildDistributionType.SIMULATOR) {
+            log_1.default.warn(`Using --distribution flag with "simulator" value is deprecated - use --simulator flag instead`);
+        }
+        if (flags.simulator && requestedPlatform !== platform_1.RequestedPlatform.Ios) {
+            log_1.default.error(`The --simulator flag is only usable with --platform flag set to "ios", as it is used to filter specifically iOS simulator builds`);
+            process.exit(1);
+        }
+        const { projectId, loggedIn: { graphqlClient }, } = await this.getContextAsync(BuildList, {
+            nonInteractive,
+        });
+        if (jsonFlag) {
+            (0, json_1.enableJsonOutput)();
+        }
+        const platform = toAppPlatform(requestedPlatform);
+        const graphqlBuildStatus = toGraphQLBuildStatus(buildStatus);
+        const graphqlBuildDistribution = (0, buildDistribution_1.buildDistributionTypeToGraphQLDistributionType)(buildDistribution);
+        const displayName = await (0, projectUtils_1.getDisplayNameForProjectIdAsync)(graphqlClient, projectId);
+        await (0, queries_1.listAndRenderBuildsOnAppAsync)(graphqlClient, {
+            projectId,
+            projectDisplayName: displayName,
+            filter: {
+                platform,
+                status: graphqlBuildStatus,
+                distribution: graphqlBuildDistribution,
+                channel: flags.channel,
+                appVersion: flags['app-version'],
+                appBuildVersion: flags['app-build-version'],
+                sdkVersion: flags['sdk-version'],
+                runtimeVersion: flags['runtime-version'],
+                appIdentifier: flags['app-identifier'],
+                buildProfile: flags['build-profile'],
+                gitCommitHash: flags['git-commit-hash'],
+                simulator: flags.simulator,
+                fingerprintHash: flags['fingerprint-hash'],
+            },
+            paginatedQueryOptions,
+        });
+    }
+}
+exports.default = BuildList;
+const toAppPlatform = (requestedPlatform) => {
+    if (!requestedPlatform || requestedPlatform === platform_1.RequestedPlatform.All) {
+        return undefined;
+    }
+    else if (requestedPlatform === platform_1.RequestedPlatform.Android) {
+        return generated_1.AppPlatform.Android;
+    }
+    else {
+        return generated_1.AppPlatform.Ios;
+    }
+};
+const toGraphQLBuildStatus = (buildStatus) => {
+    if (!buildStatus) {
+        return undefined;
+    }
+    else if (buildStatus === types_1.BuildStatus.NEW) {
+        return generated_1.BuildStatus.New;
+    }
+    else if (buildStatus === types_1.BuildStatus.IN_QUEUE) {
+        return generated_1.BuildStatus.InQueue;
+    }
+    else if (buildStatus === types_1.BuildStatus.IN_PROGRESS) {
+        return generated_1.BuildStatus.InProgress;
+    }
+    else if (buildStatus === types_1.BuildStatus.PENDING_CANCEL) {
+        return generated_1.BuildStatus.PendingCancel;
+    }
+    else if (buildStatus === types_1.BuildStatus.ERRORED) {
+        return generated_1.BuildStatus.Errored;
+    }
+    else if (buildStatus === types_1.BuildStatus.FINISHED) {
+        return generated_1.BuildStatus.Finished;
+    }
+    else {
+        return generated_1.BuildStatus.Canceled;
+    }
+};

package/build/commands/build/resign.d.ts

@@ -0,0 +1,63 @@
+import { Platform } from '@expo/eas-build-job';
+import EasCommand from '../../commandUtils/EasCommand';
+import { ExpoGraphqlClient } from '../../commandUtils/context/contextUtils/createGraphqlClient';
+import { BuildFragment } from '../../graphql/generated';
+interface BuildResignFlags {
+    json: boolean;
+    nonInteractive: boolean;
+    offset?: number;
+    limit?: number;
+    platform?: Platform;
+    targetProfile?: string;
+    sourceProfile?: string;
+    maybeBuildId?: string;
+    wait: boolean;
+    environment?: string;
+}
+interface RawBuildResignFlags {
+    json: boolean;
+    'non-interactive': boolean;
+    offset: number | undefined;
+    limit: number | undefined;
+    platform: 'android' | 'ios' | undefined;
+    'target-profile': string | undefined;
+    'source-profile': string | undefined;
+    wait: boolean;
+    id: string | undefined;
+    environment: string | undefined;
+}
+export default class BuildResign extends EasCommand {
+    static description: string;
+    static flags: {
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        'non-interactive': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        offset: import("@oclif/core/lib/interfaces").OptionFlag<number | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        limit: import("@oclif/core/lib/interfaces").OptionFlag<number | undefined>;
+        platform: import("@oclif/core/lib/interfaces").OptionFlag<"android" | "ios" | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'target-profile': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'source-profile': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        wait: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        id: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+    };
+    static contextDefinition: {
+        vcsClient: import("../../commandUtils/context/VcsClientContextField").default;
+        analytics: import("../../commandUtils/context/AnalyticsContextField").default;
+        projectDir: import("../../commandUtils/context/ProjectDirContextField").default;
+        getDynamicPublicProjectConfigAsync: import("../../commandUtils/context/DynamicProjectConfigContextField").DynamicPublicProjectConfigContextField;
+        getDynamicPrivateProjectConfigAsync: import("../../commandUtils/context/DynamicProjectConfigContextField").DynamicPrivateProjectConfigContextField;
+        loggedIn: import("../../commandUtils/context/LoggedInContextField").default;
+    };
+    runAsync(): Promise<void>;
+    sanitizeFlags(flags: RawBuildResignFlags): BuildResignFlags;
+    ensureBuildSelectedAsync({ graphqlClient, projectId, platform, nonInteractive, limit, offset, buildProfile, }: {
+        graphqlClient: ExpoGraphqlClient;
+        projectId: string;
+        platform: Platform;
+        nonInteractive: boolean;
+        limit?: number;
+        offset?: number;
+        buildProfile?: string;
+    }, maybeBuild?: BuildFragment): Promise<BuildFragment>;
+    maybeGetBuildAsync(graphqlClient: ExpoGraphqlClient, maybeBuildId?: string, maybePlatform?: Platform): Promise<BuildFragment | undefined>;
+}
+export {};

package/build/commands/build/resign.js

@@ -0,0 +1,233 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const eas_build_job_1 = require("@expo/eas-build-job");
+const eas_json_1 = require("@expo/eas-json");
+const core_1 = require("@oclif/core");
+const assert_1 = tslib_1.__importDefault(require("assert"));
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const _1 = require(".");
+const build_1 = require("../../build/build");
+const evaluateConfigWithEnvVarsAsync_1 = require("../../build/evaluateConfigWithEnvVarsAsync");
+const credentials_1 = require("../../build/ios/credentials");
+const prepareJob_1 = require("../../build/ios/prepareJob");
+const queries_1 = require("../../build/queries");
+const printBuildInfo_1 = require("../../build/utils/printBuildInfo");
+const EasCommand_1 = tslib_1.__importDefault(require("../../commandUtils/EasCommand"));
+const flags_1 = require("../../commandUtils/flags");
+const pagination_1 = require("../../commandUtils/pagination");
+const context_1 = require("../../credentials/context");
+const generated_1 = require("../../graphql/generated");
+const BuildMutation_1 = require("../../graphql/mutations/BuildMutation");
+const BuildQuery_1 = require("../../graphql/queries/BuildQuery");
+const AppPlatform_1 = require("../../graphql/types/AppPlatform");
+const log_1 = tslib_1.__importDefault(require("../../log"));
+const platform_1 = require("../../platform");
+const scheme_1 = require("../../project/ios/scheme");
+const target_1 = require("../../project/ios/target");
+const projectUtils_1 = require("../../project/projectUtils");
+const json_1 = require("../../utils/json");
+const statuspageService_1 = require("../../utils/statuspageService");
+class BuildResign extends EasCommand_1.default {
+    static description = 're-sign a build archive';
+    static flags = {
+        platform: core_1.Flags.option({
+            char: 'p',
+            options: ['android', 'ios'],
+        })(),
+        'target-profile': core_1.Flags.string({
+            char: 'e',
+            description: 'Name of the target build profile from eas.json. Credentials and environment variables from this profile will be used when re-signing. Defaults to "production" if defined in eas.json.',
+            helpValue: 'PROFILE_NAME',
+            aliases: ['profile'],
+        }),
+        'source-profile': core_1.Flags.string({
+            description: 'Name of the source build profile from eas.json. Used to filter builds eligible for re-signing.',
+            helpValue: 'PROFILE_NAME',
+        }),
+        wait: core_1.Flags.boolean({
+            default: true,
+            allowNo: true,
+            description: 'Wait for build(s) to complete.',
+        }),
+        id: core_1.Flags.string({
+            description: 'ID of the build to re-sign.',
+        }),
+        ...pagination_1.EasPaginatedQueryFlags,
+        ...flags_1.EasNonInteractiveAndJsonFlags,
+    };
+    static contextDefinition = {
+        ...this.ContextOptions.LoggedIn,
+        ...this.ContextOptions.DynamicProjectConfig,
+        ...this.ContextOptions.ProjectDir,
+        ...this.ContextOptions.Analytics,
+        ...this.ContextOptions.Vcs,
+    };
+    async runAsync() {
+        const { flags: rawFlags } = await this.parse(BuildResign);
+        if (rawFlags.json) {
+            (0, json_1.enableJsonOutput)();
+        }
+        const flags = this.sanitizeFlags(rawFlags);
+        const { limit, offset, nonInteractive } = flags;
+        const { loggedIn: { actor, graphqlClient }, getDynamicPrivateProjectConfigAsync, projectDir, analytics, vcsClient, } = await this.getContextAsync(BuildResign, {
+            nonInteractive: flags.nonInteractive,
+            withServerSideEnvironment: null,
+        });
+        const maybeBuild = flags.maybeBuildId
+            ? await this.maybeGetBuildAsync(graphqlClient, flags.maybeBuildId)
+            : undefined;
+        const platform = maybeBuild?.platform.toLowerCase() ??
+            (await (0, platform_1.selectPlatformAsync)(flags.platform));
+        if (platform === eas_build_job_1.Platform.ANDROID) {
+            throw new Error('Re-signing archives is not supported on Android yet.');
+        }
+        await (0, _1.handleDeprecatedEasJsonAsync)(projectDir, flags.nonInteractive);
+        await (0, statuspageService_1.maybeWarnAboutEasOutagesAsync)(graphqlClient, [generated_1.StatuspageServiceName.EasBuild]);
+        const easJsonAccessor = eas_json_1.EasJsonAccessor.fromProjectPath(projectDir);
+        const easJsonCliConfig = (await eas_json_1.EasJsonUtils.getCliConfigAsync(easJsonAccessor)) ?? {};
+        const buildProfile = await eas_json_1.EasJsonUtils.getBuildProfileAsync(easJsonAccessor, platform, flags.targetProfile ?? 'production');
+        const { exp, projectId, env } = await (0, evaluateConfigWithEnvVarsAsync_1.evaluateConfigWithEnvVarsAsync)({
+            buildProfile,
+            buildProfileName: flags.targetProfile ?? 'production',
+            graphqlClient,
+            getProjectConfig: getDynamicPrivateProjectConfigAsync,
+            opts: { env: buildProfile.env },
+        });
+        const account = await (0, projectUtils_1.getOwnerAccountForProjectIdAsync)(graphqlClient, projectId);
+        const build = await this.ensureBuildSelectedAsync({
+            graphqlClient,
+            projectId,
+            platform,
+            nonInteractive,
+            limit,
+            offset,
+            buildProfile: flags.sourceProfile,
+        }, maybeBuild);
+        const credentialsCtx = new context_1.CredentialsContext({
+            projectInfo: { exp, projectId },
+            nonInteractive,
+            projectDir,
+            user: actor,
+            graphqlClient,
+            analytics,
+            env,
+            easJsonCliConfig,
+            vcsClient,
+        });
+        if (buildProfile.credentialsSource !== eas_json_1.CredentialsSource.LOCAL && !nonInteractive) {
+            await credentialsCtx.appStore.ensureAuthenticatedAsync();
+        }
+        const xcodeBuildContext = await (0, scheme_1.resolveXcodeBuildContextAsync)({
+            projectDir,
+            nonInteractive,
+            exp,
+            vcsClient,
+        }, buildProfile);
+        const targets = await (0, target_1.resolveTargetsAsync)({
+            projectDir,
+            exp,
+            xcodeBuildContext,
+            env,
+            vcsClient,
+        });
+        const credentialsResult = await (0, credentials_1.ensureIosCredentialsForBuildResignAsync)(credentialsCtx, targets, buildProfile);
+        (0, assert_1.default)(build.artifacts?.applicationArchiveUrl, 'Missing application archive.');
+        const jobOverrides = {
+            mode: generated_1.BuildMode.Resign,
+            type: generated_1.BuildWorkflow.Unknown,
+            resign: {
+                applicationArchiveSource: {
+                    type: generated_1.ProjectArchiveSourceType.Url,
+                    url: build.artifacts?.applicationArchiveUrl,
+                },
+            },
+            secrets: (0, prepareJob_1.prepareCredentialsToResign)(credentialsResult.credentials),
+            builderEnvironment: { image: 'default' },
+        };
+        const newBuild = await BuildMutation_1.BuildMutation.retryIosBuildAsync(graphqlClient, {
+            buildId: build.id,
+            jobOverrides,
+        });
+        log_1.default.addNewLineIfNone();
+        (0, printBuildInfo_1.printLogsUrls)([newBuild]);
+        log_1.default.newLine();
+        if (!flags.wait) {
+            if (flags.json) {
+                (0, json_1.printJsonOnlyOutput)(newBuild);
+            }
+            return;
+        }
+        const buildResult = await (0, build_1.waitForBuildEndAsync)(graphqlClient, {
+            buildIds: [newBuild.id],
+            accountName: account.name,
+        });
+        if (!flags.json) {
+            (0, printBuildInfo_1.printBuildResults)(buildResult);
+        }
+        else {
+            (0, assert_1.default)(buildResult[0], 'missing build results');
+            (0, json_1.printJsonOnlyOutput)(buildResult[0]);
+        }
+    }
+    sanitizeFlags(flags) {
+        const { json, nonInteractive } = (0, flags_1.resolveNonInteractiveAndJsonFlags)(flags);
+        if (nonInteractive && !flags.id) {
+            throw new Error(`${chalk_1.default.bold('--id')} is required when running with ${chalk_1.default.bold('--non-interactive')} flag.`);
+        }
+        return {
+            json,
+            nonInteractive,
+            offset: flags.offset,
+            limit: flags.limit,
+            platform: flags.platform,
+            sourceProfile: flags['source-profile'],
+            targetProfile: flags['target-profile'],
+            maybeBuildId: flags.id,
+            wait: flags.wait,
+            environment: flags.environment,
+        };
+    }
+    async ensureBuildSelectedAsync({ graphqlClient, projectId, platform, nonInteractive, limit, offset, buildProfile, }, maybeBuild) {
+        if (maybeBuild) {
+            return maybeBuild;
+        }
+        const build = await (0, queries_1.listAndSelectBuildOnAppAsync)(graphqlClient, {
+            projectId,
+            title: 'Which build would you like to re-sign with new credentials?',
+            paginatedQueryOptions: {
+                limit,
+                offset: offset ?? 0,
+                nonInteractive,
+                json: false,
+            },
+            filter: {
+                distribution: generated_1.DistributionType.Internal,
+                platform: (0, AppPlatform_1.toAppPlatform)(platform),
+                status: generated_1.BuildStatus.Finished,
+                buildProfile,
+            },
+        });
+        if (!build) {
+            throw new Error('There are no builds that can be re-signed on this project.');
+        }
+        return build;
+    }
+    async maybeGetBuildAsync(graphqlClient, maybeBuildId, maybePlatform) {
+        if (maybeBuildId) {
+            const build = await BuildQuery_1.BuildQuery.byIdAsync(graphqlClient, maybeBuildId);
+            if (build.distribution !== generated_1.DistributionType.Internal) {
+                throw new Error('This is not an internal distribution build.');
+            }
+            if (build.status !== generated_1.BuildStatus.Finished) {
+                throw new Error('Only builds that finished successfully can be re-signed.');
+            }
+            if (maybePlatform && build.platform !== (0, AppPlatform_1.toAppPlatform)(maybePlatform)) {
+                throw new Error(`Build with ID ${maybeBuildId} was not created for platform ${platform_1.requestedPlatformDisplayNames[maybePlatform]}.`);
+            }
+            return build;
+        }
+        return undefined;
+    }
+}
+exports.default = BuildResign;

package/build/commands/build/run.d.ts

@@ -0,0 +1,21 @@
+import EasCommand from '../../commandUtils/EasCommand';
+export default class Run extends EasCommand {
+    static description: string;
+    static flags: {
+        offset: import("@oclif/core/lib/interfaces").OptionFlag<number | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        limit: import("@oclif/core/lib/interfaces").OptionFlag<number | undefined>;
+        latest: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        url: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        path: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        id: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        platform: import("@oclif/core/lib/interfaces").OptionFlag<"android" | "ios" | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        profile: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+    };
+    static contextDefinition: {
+        vcsClient: import("../../commandUtils/context/VcsClientContextField").default;
+        projectId: import("../../commandUtils/context/ProjectIdContextField").ProjectIdContextField;
+        loggedIn: import("../../commandUtils/context/LoggedInContextField").default;
+    };
+    runAsync(): Promise<void>;
+    private sanitizeFlagsAsync;
+}

package/build/commands/build/run.js

@@ -0,0 +1,191 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const core_1 = require("@oclif/core");
+const assert_1 = tslib_1.__importDefault(require("assert"));
+const fs_extra_1 = require("fs-extra");
+const queries_1 = require("../../build/queries");
+const EasCommand_1 = tslib_1.__importDefault(require("../../commandUtils/EasCommand"));
+const pagination_1 = require("../../commandUtils/pagination");
+const generated_1 = require("../../graphql/generated");
+const BuildQuery_1 = require("../../graphql/queries/BuildQuery");
+const log_1 = tslib_1.__importDefault(require("../../log"));
+const platform_1 = require("../../platform");
+const projectUtils_1 = require("../../project/projectUtils");
+const prompts_1 = require("../../prompts");
+const run_1 = require("../../run/run");
+const utils_1 = require("../../run/utils");
+const download_1 = require("../../utils/download");
+class Run extends EasCommand_1.default {
+    static description = 'run simulator/emulator builds from eas-cli';
+    static flags = {
+        latest: core_1.Flags.boolean({
+            description: 'Run the latest simulator/emulator build for specified platform',
+            exclusive: ['id', 'path', 'url'],
+        }),
+        url: core_1.Flags.string({
+            description: 'Simulator/Emulator build archive url',
+            exclusive: ['latest', 'id', 'path'],
+        }),
+        path: core_1.Flags.string({
+            description: 'Path to the simulator/emulator build archive or app',
+            exclusive: ['latest', 'id', 'url'],
+        }),
+        id: core_1.Flags.string({
+            description: 'ID of the simulator/emulator build to run',
+            exclusive: ['latest, path, url'],
+        }),
+        platform: core_1.Flags.option({
+            char: 'p',
+            options: ['android', 'ios'],
+        })(),
+        profile: core_1.Flags.string({
+            char: 'e',
+            description: 'Name of the build profile used to create the build to run. When specified, only builds created with the specified build profile will be queried.',
+            helpValue: 'PROFILE_NAME',
+        }),
+        ...pagination_1.EasPaginatedQueryFlags,
+    };
+    static contextDefinition = {
+        ...this.ContextOptions.LoggedIn,
+        ...this.ContextOptions.ProjectId,
+        ...this.ContextOptions.Vcs,
+    };
+    async runAsync() {
+        const { flags: rawFlags } = await this.parse(Run);
+        const flags = await this.sanitizeFlagsAsync(rawFlags);
+        const queryOptions = (0, pagination_1.getPaginatedQueryOptions)(flags);
+        const { loggedIn: { graphqlClient }, projectId, } = await this.getContextAsync(Run, {
+            nonInteractive: false,
+        });
+        const simulatorBuildPath = await getPathToSimulatorBuildAppAsync(graphqlClient, projectId, flags, queryOptions);
+        await (0, run_1.runAsync)(simulatorBuildPath, flags.selectedPlatform);
+    }
+    async sanitizeFlagsAsync(flags) {
+        const { platform, limit, offset, profile, ...runArchiveFlags } = flags;
+        const selectedPlatform = await resolvePlatformAsync(platform);
+        if (platform === 'ios' && process.platform !== 'darwin') {
+            core_1.Errors.error('You can only use an iOS simulator to run apps on macOS devices', {
+                exit: 1,
+            });
+        }
+        if (runArchiveFlags.path &&
+            !((runArchiveFlags.path.endsWith('.tar.gz') ||
+                runArchiveFlags.path.endsWith('.app') ||
+                runArchiveFlags.path.endsWith('.apk')) &&
+                (await (0, fs_extra_1.pathExists)(runArchiveFlags.path)))) {
+            core_1.Errors.error('The path must point to a .tar.gz archive, .apk file, or .app directory', {
+                exit: 1,
+            });
+        }
+        if (profile && (runArchiveFlags.id || runArchiveFlags.path || runArchiveFlags.url)) {
+            log_1.default.warn('The --profile flag is ignored when using --id, --path, or --url flags.');
+        }
+        return {
+            selectedPlatform,
+            runArchiveFlags,
+            limit,
+            offset,
+            profile,
+        };
+    }
+}
+exports.default = Run;
+async function resolvePlatformAsync(platform) {
+    if (process.platform !== 'darwin') {
+        return generated_1.AppPlatform.Android;
+    }
+    if (platform && Object.values(generated_1.AppPlatform).includes(platform.toUpperCase())) {
+        return platform.toUpperCase();
+    }
+    const { selectedPlatform } = await (0, prompts_1.promptAsync)({
+        type: 'select',
+        message: 'Select platform',
+        name: 'selectedPlatform',
+        choices: [
+            { title: 'Android', value: generated_1.AppPlatform.Android },
+            { title: 'iOS', value: generated_1.AppPlatform.Ios },
+        ],
+    });
+    return selectedPlatform;
+}
+function validateChosenBuild(maybeBuild, selectedPlatform) {
+    if (!maybeBuild) {
+        throw new Error('There are no simulator/emulator builds that can be run for this project.');
+    }
+    if (selectedPlatform !== maybeBuild.platform) {
+        throw new Error(`The selected build is for ${platform_1.appPlatformDisplayNames[maybeBuild.platform]}, but you selected ${platform_1.appPlatformDisplayNames[selectedPlatform]}`);
+    }
+    if (maybeBuild.status !== generated_1.BuildStatus.Finished) {
+        throw new Error('The selected build is not finished.');
+    }
+    if (!(0, utils_1.isRunnableOnSimulatorOrEmulator)(maybeBuild)) {
+        throw new Error('Artifacts for the latest build have expired and are no longer available, or this is not a simulator/emulator build.');
+    }
+    return maybeBuild;
+}
+async function maybeGetBuildAsync(graphqlClient, flags, projectId, paginatedQueryOptions) {
+    const simulator = flags.selectedPlatform === generated_1.AppPlatform.Ios ? true : undefined;
+    if (flags.runArchiveFlags.id) {
+        const build = await BuildQuery_1.BuildQuery.byIdAsync(graphqlClient, flags.runArchiveFlags.id);
+        return validateChosenBuild(build, flags.selectedPlatform);
+    }
+    else if (!flags.runArchiveFlags.id &&
+        !flags.runArchiveFlags.path &&
+        !flags.runArchiveFlags.url &&
+        !flags.runArchiveFlags.latest) {
+        const build = await (0, queries_1.listAndSelectBuildOnAppAsync)(graphqlClient, {
+            projectId,
+            title: `Select ${platform_1.appPlatformDisplayNames[flags.selectedPlatform]} ${flags.selectedPlatform === generated_1.AppPlatform.Ios ? 'simulator' : 'emulator'} build to run for ${await (0, projectUtils_1.getDisplayNameForProjectIdAsync)(graphqlClient, projectId)} app`,
+            filter: {
+                platform: flags.selectedPlatform,
+                status: generated_1.BuildStatus.Finished,
+                buildProfile: flags.profile,
+                simulator,
+            },
+            paginatedQueryOptions,
+            selectPromptDisabledFunction: build => !(0, utils_1.isRunnableOnSimulatorOrEmulator)(build),
+            selectPromptWarningMessage: `Artifacts for this build have expired and are no longer available, or this is not ${flags.selectedPlatform === generated_1.AppPlatform.Ios ? 'a simulator' : 'an emulator'} build.`,
+        });
+        return validateChosenBuild(build, flags.selectedPlatform);
+    }
+    else if (flags.runArchiveFlags.latest) {
+        const latestBuild = await (0, queries_1.getLatestBuildAsync)(graphqlClient, {
+            projectId,
+            filter: {
+                platform: flags.selectedPlatform,
+                status: generated_1.BuildStatus.Finished,
+                buildProfile: flags.profile,
+                simulator,
+            },
+        });
+        return validateChosenBuild(latestBuild, flags.selectedPlatform);
+    }
+    else {
+        return null;
+    }
+}
+async function getPathToSimulatorBuildAppAsync(graphqlClient, projectId, flags, queryOptions) {
+    const maybeBuild = await maybeGetBuildAsync(graphqlClient, flags, projectId, queryOptions);
+    if (maybeBuild) {
+        const cachedAppPath = (0, run_1.getEasBuildRunCachedAppPath)(projectId, maybeBuild.id, flags.selectedPlatform);
+        if (await (0, fs_extra_1.pathExists)(cachedAppPath)) {
+            log_1.default.newLine();
+            log_1.default.log(`Using cached app...`);
+            return cachedAppPath;
+        }
+        if (!maybeBuild.artifacts?.applicationArchiveUrl) {
+            throw new Error('Build does not have an application archive url');
+        }
+        return await (0, download_1.downloadAndMaybeExtractAppAsync)(maybeBuild.artifacts.applicationArchiveUrl, flags.selectedPlatform, cachedAppPath);
+    }
+    if (flags.runArchiveFlags.url) {
+        return await (0, download_1.downloadAndMaybeExtractAppAsync)(flags.runArchiveFlags.url, flags.selectedPlatform);
+    }
+    if (flags.runArchiveFlags.path?.endsWith('.tar.gz')) {
+        return await (0, download_1.extractAppFromLocalArchiveAsync)(flags.runArchiveFlags.path, flags.selectedPlatform);
+    }
+    // this should never fail, due to the validation in sanitizeFlagsAsync
+    (0, assert_1.default)(flags.runArchiveFlags.path);
+    return flags.runArchiveFlags.path;
+}