eas-cli 18.8.0 → 18.9.0

package/build/commands/integrations/asc/status.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const EasCommand_1 = tslib_1.__importDefault(require("../../../commandUtils/EasCommand"));
+const flags_1 = require("../../../commandUtils/flags");
+const utils_1 = require("../../../integrations/asc/utils");
+const AscAppLinkQuery_1 = require("../../../graphql/queries/AscAppLinkQuery");
+const log_1 = tslib_1.__importDefault(require("../../../log"));
+const ora_1 = require("../../../ora");
+const json_1 = require("../../../utils/json");
+class IntegrationsAscStatus extends EasCommand_1.default {
+    static description = 'show the App Store Connect app link status for the current project';
+    static flags = {
+        ...flags_1.EasNonInteractiveAndJsonFlags,
+    };
+    static contextDefinition = {
+        ...this.ContextOptions.ProjectId,
+        ...this.ContextOptions.LoggedIn,
+    };
+    async runAsync() {
+        const { flags } = await this.parse(IntegrationsAscStatus);
+        const { json, nonInteractive } = (0, flags_1.resolveNonInteractiveAndJsonFlags)(flags);
+        if (json) {
+            (0, json_1.enableJsonOutput)();
+        }
+        const { projectId, loggedIn: { graphqlClient }, } = await this.getContextAsync(IntegrationsAscStatus, {
+            nonInteractive,
+        });
+        const metadata = await this.fetchStatusAsync(graphqlClient, projectId);
+        if (!metadata) {
+            if (json) {
+                (0, json_1.printJsonOnlyOutput)((0, utils_1.buildInvalidJsonOutput)('status', projectId));
+            }
+            else {
+                log_1.default.addNewLineIfNone();
+                log_1.default.warn('The App Store Connect API key linked to this project has been revoked or is no longer valid.');
+            }
+            return;
+        }
+        if (json) {
+            (0, json_1.printJsonOnlyOutput)((0, utils_1.buildJsonOutput)('status', metadata));
+        }
+        else {
+            log_1.default.addNewLineIfNone();
+            log_1.default.log((0, utils_1.formatAscAppLinkStatus)(metadata));
+        }
+    }
+    async fetchStatusAsync(graphqlClient, projectId) {
+        const spinner = (0, ora_1.ora)('Fetching App Store Connect app link status').start();
+        try {
+            const metadata = await AscAppLinkQuery_1.AscAppLinkQuery.getAppMetadataAsync(graphqlClient, projectId);
+            spinner.succeed('Fetched App Store Connect app link status');
+            return metadata;
+        }
+        catch (err) {
+            if ((0, utils_1.isAscAuthenticationError)(err)) {
+                spinner.fail('App Store Connect connection is invalid');
+                return null;
+            }
+            spinner.fail('Failed to fetch App Store Connect app link status');
+            throw err;
+        }
+    }
+}
+exports.default = IntegrationsAscStatus;

package/build/commands/simulator/start.d.ts

@@ -0,0 +1,16 @@
+import EasCommand from '../../commandUtils/EasCommand';
+export default class SimulatorStart extends EasCommand {
+    static hidden: boolean;
+    static description: string;
+    static flags: {
+        'non-interactive': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        platform: import("@oclif/core/lib/interfaces").OptionFlag<"android" | "ios", import("@oclif/core/lib/interfaces").CustomOptions>;
+        type: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'package-version': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+    };
+    static contextDefinition: {
+        loggedIn: import("../../commandUtils/context/LoggedInContextField").default;
+        projectId: import("../../commandUtils/context/ProjectIdContextField").ProjectIdContextField;
+    };
+    runAsync(): Promise<void>;
+}

package/build/commands/simulator/start.js

@@ -0,0 +1,205 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const core_1 = require("@oclif/core");
+const url_1 = require("../../build/utils/url");
+const EasCommand_1 = tslib_1.__importDefault(require("../../commandUtils/EasCommand"));
+const flags_1 = require("../../commandUtils/flags");
+const generated_1 = require("../../graphql/generated");
+const DeviceRunSessionMutation_1 = require("../../graphql/mutations/DeviceRunSessionMutation");
+const DeviceRunSessionQuery_1 = require("../../graphql/queries/DeviceRunSessionQuery");
+const log_1 = tslib_1.__importStar(require("../../log"));
+const ora_1 = require("../../ora");
+const promise_1 = require("../../utils/promise");
+const nullthrows_1 = tslib_1.__importDefault(require("nullthrows"));
+const POLL_INTERVAL_MS = 5_000; // 5 seconds
+const POLL_TIMEOUT_MS = 15 * 60 * 1_000; // 15 minutes
+// Mapping enum → CLI flag value. Declared as Record<DeviceRunSessionType, string>
+// so adding a new enum value in codegen fails the build until it is wired up here.
+const DEVICE_RUN_SESSION_TYPE_FLAG_VALUES = {
+    [generated_1.DeviceRunSessionType.AgentDevice]: 'agent-device',
+};
+const DEVICE_RUN_SESSION_TYPE_BY_FLAG_VALUE = Object.fromEntries(Object.entries(DEVICE_RUN_SESSION_TYPE_FLAG_VALUES).map(([type, value]) => [value, type]));
+class SimulatorStart extends EasCommand_1.default {
+    static hidden = true;
+    static description = '[EXPERIMENTAL] start a remote simulator session on EAS and get the credentials to connect to it with the CLI tool of your choice';
+    static flags = {
+        platform: core_1.Flags.option({
+            description: 'Device platform',
+            options: ['android', 'ios'],
+            required: true,
+        })(),
+        type: core_1.Flags.option({
+            description: 'Type of device run session to create',
+            options: Object.values(DEVICE_RUN_SESSION_TYPE_FLAG_VALUES),
+            default: DEVICE_RUN_SESSION_TYPE_FLAG_VALUES[generated_1.DeviceRunSessionType.AgentDevice],
+        })(),
+        'package-version': core_1.Flags.string({
+            description: 'Version of the package backing the device run session (e.g. "0.1.3-alpha.3"). Defaults to "latest" when omitted.',
+        }),
+        ...flags_1.EASNonInteractiveFlag,
+    };
+    static contextDefinition = {
+        ...this.ContextOptions.ProjectId,
+        ...this.ContextOptions.LoggedIn,
+    };
+    async runAsync() {
+        const { flags } = await this.parse(SimulatorStart);
+        const { projectId, loggedIn: { graphqlClient }, } = await this.getContextAsync(SimulatorStart, {
+            nonInteractive: flags['non-interactive'],
+        });
+        const platform = flags.platform === 'android' ? generated_1.AppPlatform.Android : generated_1.AppPlatform.Ios;
+        const createSpinner = (0, ora_1.ora)('🚀 Creating device run session').start();
+        let deviceRunSessionId;
+        try {
+            const session = await DeviceRunSessionMutation_1.DeviceRunSessionMutation.createDeviceRunSessionAsync(graphqlClient, {
+                appId: projectId,
+                platform,
+                type: DEVICE_RUN_SESSION_TYPE_BY_FLAG_VALUE[flags.type],
+                packageVersion: flags['package-version'],
+            });
+            deviceRunSessionId = session.id;
+            const jobRunId = (0, nullthrows_1.default)(session.turtleJobRun?.id, 'Expected device run session to start');
+            const jobRunUrl = (0, url_1.getBareJobRunUrl)(session.app.ownerAccount.name, session.app.slug, jobRunId);
+            createSpinner.succeed(`Device run session created (id: ${deviceRunSessionId}) ${(0, log_1.link)(jobRunUrl)}`);
+        }
+        catch (err) {
+            createSpinner.fail('Failed to create device run session');
+            throw err;
+        }
+        const checkReadiness = getReadinessCheckerForType(flags.type);
+        const pollSpinner = (0, ora_1.ora)(`⏳ Waiting for ${flags.type} daemon to start`).start();
+        const deadline = Date.now() + POLL_TIMEOUT_MS;
+        let result = { ready: false };
+        try {
+            while (Date.now() < deadline) {
+                const session = await DeviceRunSessionQuery_1.DeviceRunSessionQuery.byIdAsync(graphqlClient, deviceRunSessionId);
+                if (session.status === generated_1.DeviceRunSessionStatus.Errored ||
+                    session.status === generated_1.DeviceRunSessionStatus.Stopped) {
+                    throw new Error(`Device run session ${deviceRunSessionId} ${session.status.toLowerCase()} before the ${flags.type} daemon was ready.`);
+                }
+                const jobRunStatus = session.turtleJobRun?.status;
+                if (jobRunStatus === generated_1.JobRunStatus.Errored ||
+                    jobRunStatus === generated_1.JobRunStatus.Canceled ||
+                    jobRunStatus === generated_1.JobRunStatus.Finished) {
+                    throw new Error(`Turtle job run for device run session ${deviceRunSessionId} ${jobRunStatus.toLowerCase()} before the ${flags.type} daemon was ready.`);
+                }
+                const logMessages = await fetchLogMessagesAsync(session.turtleJobRun?.logFileUrls ?? []);
+                result = checkReadiness(logMessages);
+                if (result.ready) {
+                    pollSpinner.succeed(`🎉 ${flags.type} daemon is ready`);
+                    break;
+                }
+                await (0, promise_1.sleepAsync)(POLL_INTERVAL_MS);
+            }
+        }
+        catch (err) {
+            pollSpinner.fail(`Failed while polling for ${flags.type} daemon logs`);
+            throw err;
+        }
+        if (!result.ready) {
+            pollSpinner.fail(`Timed out waiting for ${flags.type} daemon to start`);
+            throw new Error(`Timed out after ${Math.round(POLL_TIMEOUT_MS / 1000)}s waiting for ${flags.type} daemon to start.`);
+        }
+        log_1.default.newLine();
+        log_1.default.log(`🔑 Run the following in your shell to attach to ${flags.type}:`);
+        log_1.default.newLine();
+        log_1.default.log(result.message);
+        log_1.default.newLine();
+        log_1.default.log(`When you are done, stop the session with: eas simulator:stop --id ${deviceRunSessionId}`);
+    }
+}
+exports.default = SimulatorStart;
+function getReadinessCheckerForType(type) {
+    switch (type) {
+        case DEVICE_RUN_SESSION_TYPE_FLAG_VALUES[generated_1.DeviceRunSessionType.AgentDevice]:
+            return checkAgentDeviceReadiness;
+        default:
+            throw new Error(`Unsupported device run session type: ${type}`);
+    }
+}
+const AGENT_DEVICE_BASE_URL_ENV_VAR = 'AGENT_DEVICE_DAEMON_BASE_URL';
+const AGENT_DEVICE_AUTH_TOKEN_ENV_VAR = 'AGENT_DEVICE_DAEMON_AUTH_TOKEN';
+function checkAgentDeviceReadiness(logMessages) {
+    let baseUrl;
+    let authToken;
+    for (const msg of logMessages) {
+        baseUrl = baseUrl ?? extractExportedEnvValue(msg, AGENT_DEVICE_BASE_URL_ENV_VAR);
+        authToken = authToken ?? extractExportedEnvValue(msg, AGENT_DEVICE_AUTH_TOKEN_ENV_VAR);
+        if (baseUrl && authToken) {
+            break;
+        }
+    }
+    if (baseUrl && authToken) {
+        return {
+            ready: true,
+            message: [
+                `export ${AGENT_DEVICE_BASE_URL_ENV_VAR}='${baseUrl}'`,
+                `export ${AGENT_DEVICE_AUTH_TOKEN_ENV_VAR}='${authToken}'`,
+            ].join('\n'),
+        };
+    }
+    return { ready: false };
+}
+async function fetchLogMessagesAsync(logUrls) {
+    const messages = [];
+    for (const url of logUrls) {
+        const text = await fetchLogTextAsync(url);
+        if (!text) {
+            continue;
+        }
+        for (const line of text.split('\n')) {
+            if (!line.trim()) {
+                continue;
+            }
+            messages.push(extractLogMessage(line));
+        }
+    }
+    return messages;
+}
+async function fetchLogTextAsync(url) {
+    try {
+        const response = await fetch(url);
+        if (!response.ok) {
+            return undefined;
+        }
+        return await response.text();
+    }
+    catch {
+        return undefined;
+    }
+}
+function extractLogMessage(line) {
+    // Turtle job run logs are JSONL (bunyan-shaped), e.g.
+    //   {"msg":"export FOO=\"bar\"","time":"...","logId":"..."}
+    // Fall back to the raw line if it's not JSON or doesn't have a string msg.
+    const trimmed = line.trim();
+    if (!trimmed.startsWith('{')) {
+        return line;
+    }
+    try {
+        const parsed = JSON.parse(trimmed);
+        if (parsed && typeof parsed === 'object' && 'msg' in parsed) {
+            const msg = parsed.msg;
+            if (typeof msg === 'string') {
+                return msg;
+            }
+        }
+    }
+    catch {
+        // not JSON, fall through
+    }
+    return line;
+}
+function extractExportedEnvValue(text, varName) {
+    // Matches: export NAME=value | export NAME="value" | export NAME='value'
+    const pattern = new RegExp(`export\\s+${escapeRegExp(varName)}=(?:"([^"]*)"|'([^']*)'|(\\S+))`);
+    const match = pattern.exec(text);
+    if (!match) {
+        return undefined;
+    }
+    return match[1] ?? match[2] ?? match[3];
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}

package/build/commands/simulator/stop.d.ts

@@ -0,0 +1,13 @@
+import EasCommand from '../../commandUtils/EasCommand';
+export default class SimulatorStop extends EasCommand {
+    static hidden: boolean;
+    static description: string;
+    static flags: {
+        'non-interactive': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        id: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+    };
+    static contextDefinition: {
+        loggedIn: import("../../commandUtils/context/LoggedInContextField").default;
+    };
+    runAsync(): Promise<void>;
+}

package/build/commands/simulator/stop.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const core_1 = require("@oclif/core");
+const EasCommand_1 = tslib_1.__importDefault(require("../../commandUtils/EasCommand"));
+const flags_1 = require("../../commandUtils/flags");
+const DeviceRunSessionMutation_1 = require("../../graphql/mutations/DeviceRunSessionMutation");
+const ora_1 = require("../../ora");
+class SimulatorStop extends EasCommand_1.default {
+    static hidden = true;
+    static description = '[EXPERIMENTAL] stop a remote simulator session on EAS by its device run session ID';
+    static flags = {
+        id: core_1.Flags.string({
+            description: 'Device run session ID',
+            required: true,
+        }),
+        ...flags_1.EASNonInteractiveFlag,
+    };
+    static contextDefinition = {
+        ...this.ContextOptions.LoggedIn,
+    };
+    async runAsync() {
+        const { flags } = await this.parse(SimulatorStop);
+        const { loggedIn: { graphqlClient }, } = await this.getContextAsync(SimulatorStop, {
+            nonInteractive: flags['non-interactive'],
+        });
+        const stopSpinner = (0, ora_1.ora)(`🛑 Stopping device run session ${flags.id}`).start();
+        try {
+            const session = await DeviceRunSessionMutation_1.DeviceRunSessionMutation.stopDeviceRunSessionAsync(graphqlClient, flags.id);
+            stopSpinner.succeed(`🎉 Device run session ${session.id} is ${session.status.toLowerCase()}`);
+        }
+        catch (err) {
+            stopSpinner.fail(`Failed to stop device run session ${flags.id}`);
+            throw err;
+        }
+    }
+}
+exports.default = SimulatorStop;

package/build/credentials/ios/actions/AscApiKeyUtils.d.ts

@@ -3,7 +3,8 @@ import { CredentialsContext } from '../../context';
 import { AscApiKey } from '../appstore/Credentials.types';
 import { AscApiKeyPath, MinimalAscApiKey } from '../credentials';
 export declare enum AppStoreApiKeyPurpose {
-    SUBMISSION_SERVICE = "EAS Submit"
+    SUBMISSION_SERVICE = "EAS Submit",
+    ASC_APP_CONNECTION = "EAS Connect"
 }
 export declare function promptForAscApiKeyPathAsync(ctx: CredentialsContext): Promise<AscApiKeyPath>;
 export declare function promptForIssuerIdAsync(): Promise<string>;

package/build/credentials/ios/actions/AscApiKeyUtils.js

@@ -15,6 +15,7 @@ const chalk_1 = tslib_1.__importDefault(require("chalk"));
 const fs_extra_1 = tslib_1.__importDefault(require("fs-extra"));
 const nanoid_1 = require("nanoid");
 const path_1 = tslib_1.__importDefault(require("path"));
+const apple_utils_1 = require("@expo/apple-utils");
 const AppleTeamFormatting_1 = require("./AppleTeamFormatting");
 const log_1 = tslib_1.__importStar(require("../../../log"));
 const prompts_1 = require("../../../prompts");
@@ -25,6 +26,7 @@ const validateAscApiKey_1 = require("../validators/validateAscApiKey");
 var AppStoreApiKeyPurpose;
 (function (AppStoreApiKeyPurpose) {
     AppStoreApiKeyPurpose["SUBMISSION_SERVICE"] = "EAS Submit";
+    AppStoreApiKeyPurpose["ASC_APP_CONNECTION"] = "EAS Connect";
 })(AppStoreApiKeyPurpose || (exports.AppStoreApiKeyPurpose = AppStoreApiKeyPurpose = {}));
 async function promptForAscApiKeyPathAsync(ctx) {
     const { keyId, keyP8Path } = await promptForKeyP8AndIdAsync();
@@ -79,11 +81,25 @@ async function provideOrGenerateAscApiKeyAsync(ctx, purpose) {
 }
 async function generateAscApiKeyAsync(ctx, purpose) {
     await ctx.appStore.ensureAuthenticatedAsync();
+    const role = await selectRoleForGeneratedAscApiKeyAsync();
     const ascApiKey = await ctx.appStore.createAscApiKeyAsync(ctx.analytics, {
         nickname: getAscApiKeyName(purpose),
+        roles: [role],
     });
     return await getMinimalAscApiKeyAsync(ascApiKey);
 }
+async function selectRoleForGeneratedAscApiKeyAsync() {
+    return await (0, prompts_1.selectAsync)('Select role for the generated API key:', [
+        {
+            title: 'ADMIN (default)',
+            value: apple_utils_1.UserRole.ADMIN,
+        },
+        {
+            title: 'APP_MANAGER (least privilege for app management)',
+            value: apple_utils_1.UserRole.APP_MANAGER,
+        },
+    ]);
+}
 function getAscApiKeyName(purpose) {
     const nameParts = ['[Expo]', purpose, (0, nanoid_1.nanoid)(10)];
     return nameParts.join(' ');

package/build/credentials/ios/appstore/AppStoreApi.d.ts

@@ -1,4 +1,5 @@
 import { ProfileType } from '@expo/app-store';
+import { UserRole } from '@expo/apple-utils';
 import { AscApiKey, AscApiKeyInfo, DistributionCertificate, DistributionCertificateStoreInfo, ProvisioningProfile, ProvisioningProfileStoreInfo, PushKey, PushKeyStoreInfo } from './Credentials.types';
 import { Options as AuthenticateOptions } from './authenticate';
 import { AuthCtx, AuthenticationMode, UserAuthCtx } from './authenticateTypes';
@@ -26,8 +27,9 @@ export default class AppStoreApi {
     createOrReuseAdhocProvisioningProfileAsync(udids: string[], bundleIdentifier: string, distCertSerialNumber: string, profileType: ProfileType): Promise<ProvisioningProfile>;
     listAscApiKeysAsync(): Promise<AscApiKeyInfo[]>;
     getAscApiKeyAsync(keyId: string): Promise<AscApiKeyInfo | null>;
-    createAscApiKeyAsync(analytics: Analytics, { nickname }: {
+    createAscApiKeyAsync(analytics: Analytics, { nickname, roles }: {
         nickname: string;
+        roles?: UserRole[];
     }): Promise<AscApiKey>;
     revokeAscApiKeyAsync(keyId: string): Promise<AscApiKeyInfo>;
 }

package/build/credentials/ios/appstore/AppStoreApi.js

@@ -94,9 +94,9 @@ class AppStoreApi {
         const userCtx = await this.ensureUserAuthenticatedAsync();
         return await (0, ascApiKey_1.getAscApiKeyAsync)(userCtx, keyId);
     }
-    async createAscApiKeyAsync(analytics, { nickname }) {
+    async createAscApiKeyAsync(analytics, { nickname, roles }) {
         const userCtx = await this.ensureUserAuthenticatedAsync();
-        return await (0, ascApiKey_1.createAscApiKeyAsync)(analytics, userCtx, { nickname });
+        return await (0, ascApiKey_1.createAscApiKeyAsync)(analytics, userCtx, { nickname, roles });
     }
     async revokeAscApiKeyAsync(keyId) {
         const userCtx = await this.ensureUserAuthenticatedAsync();