@donotuse/eas-cli 18.5.0-rc.1

package/build/commandUtils/workflow/utils.js

@@ -0,0 +1,325 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.workflowRunExitCodes = void 0;
+exports.computeTriggerInfoForWorkflowRun = computeTriggerInfoForWorkflowRun;
+exports.choiceFromWorkflowRun = choiceFromWorkflowRun;
+exports.choiceFromWorkflowJob = choiceFromWorkflowJob;
+exports.choicesFromWorkflowLogs = choicesFromWorkflowLogs;
+exports.processWorkflowRuns = processWorkflowRuns;
+exports.fetchAndProcessLogsFromJobAsync = fetchAndProcessLogsFromJobAsync;
+exports.infoForActiveWorkflowRunAsync = infoForActiveWorkflowRunAsync;
+exports.infoForFailedWorkflowRunAsync = infoForFailedWorkflowRunAsync;
+exports.fileExistsAsync = fileExistsAsync;
+exports.maybeReadStdinAsync = maybeReadStdinAsync;
+exports.showWorkflowStatusAsync = showWorkflowStatusAsync;
+const tslib_1 = require("tslib");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const fs = tslib_1.__importStar(require("node:fs"));
+const fetchLogs_1 = require("./fetchLogs");
+const types_1 = require("./types");
+const generated_1 = require("../../graphql/generated");
+const WorkflowRunQuery_1 = require("../../graphql/queries/WorkflowRunQuery");
+const log_1 = tslib_1.__importDefault(require("../../log"));
+const ora_1 = require("../../ora");
+const formatFields_1 = tslib_1.__importDefault(require("../../utils/formatFields"));
+const promise_1 = require("../../utils/promise");
+function computeTriggerInfoForWorkflowRun(run) {
+    let triggerType = types_1.WorkflowTriggerType.OTHER;
+    let trigger = '';
+    if (run.actor?.__typename === 'Robot') {
+        if (run.actor.firstName?.startsWith('GitHub App · ')) {
+            trigger = `${run.requestedGitRef ?? ''}@${run.gitCommitHash?.substring(0, 12) ?? ''}`;
+        }
+    }
+    else if (run.actor?.__typename === 'User') {
+        trigger = run.actor.username;
+    }
+    switch (run.triggerEventType) {
+        case generated_1.WorkflowRunTriggerEventType.Manual:
+            triggerType = types_1.WorkflowTriggerType.MANUAL;
+            break;
+        case generated_1.WorkflowRunTriggerEventType.GithubPullRequestLabeled:
+        case generated_1.WorkflowRunTriggerEventType.GithubPullRequestOpened:
+        case generated_1.WorkflowRunTriggerEventType.GithubPullRequestReopened:
+        case generated_1.WorkflowRunTriggerEventType.GithubPullRequestSynchronize:
+        case generated_1.WorkflowRunTriggerEventType.GithubPush:
+            triggerType = types_1.WorkflowTriggerType.GITHUB;
+            break;
+        case generated_1.WorkflowRunTriggerEventType.Schedule:
+            triggerType = types_1.WorkflowTriggerType.SCHEDULED;
+            trigger = run.triggeringSchedule ?? '';
+            break;
+    }
+    return { triggerType, trigger };
+}
+function choiceFromWorkflowRun(run) {
+    const titleArray = [
+        run.workflowFileName,
+        run.status,
+        run.startedAt,
+        run.triggerType,
+        run.trigger,
+    ];
+    return {
+        title: titleArray.join(' - '),
+        value: run.id,
+        description: `ID: ${run.id}, Message: ${run.gitCommitMessage?.split('\n')[0] ?? ''}`,
+    };
+}
+function choiceFromWorkflowJob(job, index) {
+    return {
+        title: `${job.name} - ${job.status}`,
+        value: index,
+        description: `ID: ${job.id}`,
+    };
+}
+function choicesFromWorkflowLogs(logs) {
+    return Array.from(logs.keys())
+        .map(step => {
+        const logLines = logs.get(step);
+        const stepStatus = logLines?.filter((line) => line.marker === 'end-step' || line.marker === 'END_PHASE')[0]?.result ?? '';
+        return {
+            title: `${step} - ${stepStatus}`,
+            name: step,
+            status: stepStatus,
+            value: step,
+            logLines,
+        };
+    })
+        .filter(step => step.status !== 'skipped');
+}
+function processWorkflowRuns(runs) {
+    return runs.map(run => {
+        const finishedAt = run.status === generated_1.WorkflowRunStatus.InProgress ? null : run.updatedAt;
+        const { triggerType, trigger } = computeTriggerInfoForWorkflowRun(run);
+        return {
+            id: run.id,
+            status: run.status,
+            gitCommitMessage: run.gitCommitMessage?.split('\n')[0] ?? null,
+            gitCommitHash: run.gitCommitHash ?? null,
+            startedAt: run.createdAt,
+            finishedAt,
+            triggerType,
+            trigger,
+            workflowId: run.workflow.id,
+            workflowName: run.workflow.name ?? null,
+            workflowFileName: run.workflow.fileName,
+        };
+    });
+}
+async function fetchAndProcessLogsFromJobAsync(state, job) {
+    let rawLogs;
+    switch (job.type) {
+        case generated_1.WorkflowJobType.Build:
+        case generated_1.WorkflowJobType.Repack:
+            rawLogs = await (0, fetchLogs_1.fetchRawLogsForBuildJobAsync)(state, job);
+            break;
+        default:
+            rawLogs = await (0, fetchLogs_1.fetchRawLogsForCustomJobAsync)(job);
+            break;
+    }
+    if (!rawLogs) {
+        return null;
+    }
+    log_1.default.debug(`rawLogs = ${JSON.stringify(rawLogs, null, 2)}`);
+    const logs = new Map();
+    const logKeys = new Set();
+    rawLogs.split('\n').forEach((line, index) => {
+        log_1.default.debug(`line ${index} = ${JSON.stringify(line, null, 2)}`);
+        try {
+            const parsedLine = JSON.parse(line);
+            const { buildStepDisplayName, buildStepInternalId, phase, time, msg, result, marker, err } = parsedLine;
+            const stepId = buildStepDisplayName ?? buildStepInternalId ?? phase;
+            if (stepId) {
+                if (!logKeys.has(stepId)) {
+                    logKeys.add(stepId);
+                    logs.set(stepId, []);
+                }
+                logs.get(stepId)?.push({ time, msg, result, marker, err });
+            }
+        }
+        catch { }
+    });
+    return logs;
+}
+function descriptionForJobStatus(status) {
+    switch (status) {
+        case generated_1.WorkflowJobStatus.New:
+            return 'Waiting for worker';
+        case generated_1.WorkflowJobStatus.InProgress:
+            return 'In progress';
+        case generated_1.WorkflowJobStatus.Success:
+            return 'Completed successfully';
+        case generated_1.WorkflowJobStatus.Failure:
+            return 'Failed';
+        case generated_1.WorkflowJobStatus.Canceled:
+            return 'Canceled';
+        case generated_1.WorkflowJobStatus.Skipped:
+            return 'Skipped';
+        case generated_1.WorkflowJobStatus.ActionRequired:
+            return 'Waiting for action';
+        case generated_1.WorkflowJobStatus.PendingCancel:
+            return 'Pending cancel';
+    }
+}
+async function infoForActiveWorkflowRunAsync(graphqlClient, workflowRun, maxLogLines = 5 // -1 means no limit
+) {
+    const statusLines = [];
+    const statusValues = [];
+    for (const job of workflowRun.jobs) {
+        statusValues.push({ label: '', value: '' });
+        statusValues.push({ label: '  Job', value: job.name });
+        statusValues.push({ label: '  Status', value: descriptionForJobStatus(job.status) });
+        if (job.status !== generated_1.WorkflowJobStatus.InProgress) {
+            continue;
+        }
+        const logs = await fetchAndProcessLogsFromJobAsync({ graphqlClient }, job);
+        const steps = logs ? choicesFromWorkflowLogs(logs) : [];
+        if (steps.length > 0) {
+            const currentStep = steps[steps.length - 1];
+            statusValues.push({ label: '  Current step', value: currentStep.name });
+            if (currentStep?.logLines?.length) {
+                statusValues.push({ label: '  Current logs', value: '' });
+                const currentLogs = currentStep.logLines
+                    ?.map(line => line.msg)
+                    .filter((_, index) => {
+                    if (maxLogLines === -1) {
+                        return true;
+                    }
+                    return index > (currentStep.logLines?.length ?? 0) - maxLogLines;
+                }) ?? [];
+                for (const log of currentLogs) {
+                    statusValues.push({ label: '', value: log });
+                }
+            }
+        }
+    }
+    statusValues.push({ label: '', value: '' });
+    statusLines.push((0, formatFields_1.default)(statusValues));
+    return statusLines.join('\n');
+}
+async function infoForFailedWorkflowRunAsync(graphqlClient, workflowRun, maxLogLines = -1 // -1 means no limit
+) {
+    const statusLines = [];
+    const statusValues = [];
+    const logLinesToKeep = maxLogLines === -1 ? Infinity : maxLogLines;
+    for (const job of workflowRun.jobs) {
+        if (job.status !== generated_1.WorkflowJobStatus.Failure) {
+            continue;
+        }
+        const logs = await fetchAndProcessLogsFromJobAsync({ graphqlClient }, job);
+        const steps = logs ? choicesFromWorkflowLogs(logs) : [];
+        statusValues.push({ label: '', value: '' });
+        statusValues.push({ label: '  Failed job', value: job.name });
+        if (steps.length > 0) {
+            const failedStep = steps.find(step => step.status === 'fail' || step.status === 'failed');
+            if (failedStep) {
+                const logs = failedStep.logLines?.map(line => line.msg).slice(-logLinesToKeep) ?? [];
+                statusValues.push({ label: '  Failed step', value: failedStep.name });
+                statusValues.push({
+                    label: '  Logs for failed step',
+                    value: '',
+                });
+                for (const log of logs) {
+                    statusValues.push({ label: '', value: log });
+                }
+            }
+        }
+    }
+    statusValues.push({ label: '', value: '' });
+    statusLines.push((0, formatFields_1.default)(statusValues));
+    return statusLines.join('\n');
+}
+async function fileExistsAsync(filePath) {
+    return await fs.promises
+        .access(filePath, fs.constants.F_OK)
+        .then(() => true)
+        .catch(() => false);
+}
+async function maybeReadStdinAsync() {
+    // Check if there's data on stdin
+    if (process.stdin.isTTY) {
+        return null;
+    }
+    return await new Promise((resolve, reject) => {
+        let data = '';
+        process.stdin.setEncoding('utf8');
+        process.stdin.on('readable', () => {
+            let chunk;
+            while ((chunk = process.stdin.read()) !== null) {
+                data += chunk;
+            }
+        });
+        process.stdin.on('end', () => {
+            const trimmedData = data.trim();
+            resolve(trimmedData || null);
+        });
+        process.stdin.on('error', err => {
+            reject(err);
+        });
+    });
+}
+async function showWorkflowStatusAsync(graphqlClient, { workflowRunId, spinnerUsesStdErr, waitForCompletion = true, }) {
+    log_1.default.log('Waiting for workflow run to complete. You can press Ctrl+C to exit.');
+    const spinner = (0, ora_1.ora)({
+        stream: spinnerUsesStdErr ? process.stderr : process.stdout,
+        text: '',
+    }).start();
+    spinner.prefixText = (0, chalk_1.default) `{bold.yellow Workflow run is waiting to start:}`;
+    let failedFetchesCount = 0;
+    while (true) {
+        try {
+            const workflowRun = await WorkflowRunQuery_1.WorkflowRunQuery.withJobsByIdAsync(graphqlClient, workflowRunId, {
+                useCache: false,
+            });
+            failedFetchesCount = 0;
+            switch (workflowRun.status) {
+                case generated_1.WorkflowRunStatus.New:
+                    break;
+                case generated_1.WorkflowRunStatus.InProgress: {
+                    spinner.prefixText = (0, chalk_1.default) `{bold.green Workflow run is in progress:}`;
+                    spinner.text = await infoForActiveWorkflowRunAsync(graphqlClient, workflowRun, 5);
+                    break;
+                }
+                case generated_1.WorkflowRunStatus.ActionRequired:
+                    spinner.prefixText = (0, chalk_1.default) `{bold.yellow Workflow run is waiting for action:}`;
+                    break;
+                case generated_1.WorkflowRunStatus.Canceled:
+                    spinner.prefixText = (0, chalk_1.default) `{bold.yellow Workflow has been canceled.}`;
+                    spinner.stopAndPersist();
+                    return workflowRun;
+                case generated_1.WorkflowRunStatus.Failure: {
+                    spinner.prefixText = (0, chalk_1.default) `{bold.red Workflow has failed.}`;
+                    const failedInfo = await infoForFailedWorkflowRunAsync(graphqlClient, workflowRun, 30);
+                    spinner.fail(failedInfo);
+                    return workflowRun;
+                }
+                case generated_1.WorkflowRunStatus.Success:
+                    spinner.prefixText = (0, chalk_1.default) `{bold.green Workflow has completed successfully.}`;
+                    spinner.text = '';
+                    spinner.succeed('');
+                    return workflowRun;
+            }
+            if (!waitForCompletion) {
+                if (spinner.isSpinning) {
+                    spinner.stopAndPersist();
+                }
+                return workflowRun;
+            }
+        }
+        catch {
+            spinner.text = '⚠ Failed to fetch the workflow run status. Check your network connection.';
+            failedFetchesCount += 1;
+            if (failedFetchesCount > 6) {
+                spinner.fail('Failed to fetch the workflow run status 6 times in a row. Aborting wait.');
+                process.exit(exports.workflowRunExitCodes.WAIT_ABORTED);
+            }
+        }
+        await (0, promise_1.sleepAsync)(10 /* seconds */ * 1000 /* milliseconds */);
+    }
+}
+exports.workflowRunExitCodes = {
+    WORKFLOW_FAILED: 11,
+    WORKFLOW_CANCELED: 12,
+    WAIT_ABORTED: 13,
+};

package/build/commandUtils/workflow/validation.d.ts

@@ -0,0 +1,7 @@
+import { ExpoGraphqlClient } from '../context/contextUtils/createGraphqlClient';
+export declare function validateWorkflowFileAsync(workflowFileContents: {
+    yamlConfig: string;
+    filePath: string;
+}, projectDir: string, graphqlClient: ExpoGraphqlClient, projectId: string): Promise<void>;
+export declare function logWorkflowValidationErrors(error: unknown): void;
+export declare function workflowContentsFromParsedYaml(parsedYaml: any): string;

package/build/commandUtils/workflow/validation.js

@@ -0,0 +1,159 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateWorkflowFileAsync = validateWorkflowFileAsync;
+exports.logWorkflowValidationErrors = logWorkflowValidationErrors;
+exports.workflowContentsFromParsedYaml = workflowContentsFromParsedYaml;
+const tslib_1 = require("tslib");
+const errors_1 = require("@expo/eas-json/build/errors");
+const core_1 = require("@urql/core");
+const fs_1 = require("fs");
+const path_1 = tslib_1.__importDefault(require("path"));
+const YAML = tslib_1.__importStar(require("yaml"));
+const buildProfileUtils_1 = require("./buildProfileUtils");
+const api_1 = require("../../api");
+const WorkflowRevisionMutation_1 = require("../../graphql/mutations/WorkflowRevisionMutation");
+const log_1 = tslib_1.__importDefault(require("../../log"));
+const ajv_1 = require("../../metadata/utils/ajv");
+const workflowFile_1 = require("../../utils/workflowFile");
+const parse_1 = require("./parse");
+const jobTypesWithBuildProfile = new Set(['build', 'repack']);
+const buildProfileIsInterpolated = (profileName) => {
+    return profileName.includes('${{') && profileName.includes('}}');
+};
+async function validateWorkflowFileAsync(workflowFileContents, projectDir, graphqlClient, projectId) {
+    const parsedYaml = (0, parse_1.parsedYamlFromWorkflowContents)(workflowFileContents);
+    log_1.default.debug(`Parsed workflow: ${JSON.stringify(parsedYaml, null, 2)}`);
+    // Check if the parsed result is empty or null
+    log_1.default.debug(`Validating workflow is not empty...`);
+    validateWorkflowIsNotEmpty(parsedYaml);
+    const workflowSchema = await fetchWorkflowSchemaAsync();
+    // Check that all job types are valid
+    log_1.default.debug(`Validating workflow job types...`);
+    validateWorkflowJobTypes(parsedYaml, workflowSchema);
+    // Check for build jobs that do not match any EAS build profiles
+    log_1.default.debug(`Validating workflow build jobs...`);
+    await validateWorkflowBuildJobsAsync(parsedYaml, projectDir);
+    // Check that result passes validation against workflow schema
+    log_1.default.debug(`Validating workflow structure...`);
+    validateWorkflowStructure(parsedYaml, workflowSchema);
+    // Check for other errors using the server-side validation
+    log_1.default.debug(`Validating workflow on server...`);
+    await validateWorkflowOnServerAsync(graphqlClient, projectId, workflowFileContents);
+}
+function logWorkflowValidationErrors(error) {
+    if (error instanceof errors_1.MissingEasJsonError) {
+        throw new Error('Workflows require a valid eas.json. Please run "eas build:configure" to create it.');
+    }
+    else if (error instanceof errors_1.InvalidEasJsonError) {
+        throw new Error('Workflows require a valid eas.json. Please fix the errors in your eas.json and try again.\n\n' +
+            error.message);
+    }
+    else if (error instanceof YAML.YAMLParseError) {
+        log_1.default.error(`YAML syntax error: ${error.message}`);
+    }
+    else if (error instanceof core_1.CombinedError) {
+        workflowFile_1.WorkflowFile.maybePrintWorkflowFileValidationErrors({
+            error,
+        });
+        throw error;
+    }
+    else if (error instanceof Error) {
+        log_1.default.error(`Error: ${error.message}`);
+    }
+    else {
+        log_1.default.error(`Unexpected error: ${String(error)}`);
+    }
+}
+function validateWorkflowIsNotEmpty(parsedYaml) {
+    if (parsedYaml === null ||
+        parsedYaml === undefined ||
+        (typeof parsedYaml === 'object' && Object.keys(parsedYaml).length === 0)) {
+        throw new Error('YAML file is empty or contains only comments.');
+    }
+}
+async function validateWorkflowOnServerAsync(graphqlClient, projectId, workflowFileContents) {
+    await WorkflowRevisionMutation_1.WorkflowRevisionMutation.validateWorkflowYamlConfigAsync(graphqlClient, {
+        appId: projectId,
+        yamlConfig: workflowFileContents.yamlConfig,
+    });
+}
+async function validateWorkflowBuildJobsAsync(parsedYaml, projectDir) {
+    const jobs = jobsFromWorkflow(parsedYaml);
+    const buildJobs = jobs.filter(job => jobTypesWithBuildProfile.has(job.value.type));
+    if (buildJobs.length === 0) {
+        return;
+    }
+    const buildProfileNames = await (0, buildProfileUtils_1.buildProfileNamesFromProjectAsync)(projectDir);
+    const invalidBuildJobs = buildJobs.filter(job => !buildProfileNames.has(job.value.params.profile) &&
+        // If a profile name is interpolated, we can't check if it's valid until the workflow actually runs
+        !buildProfileIsInterpolated(job.value.params.profile));
+    if (invalidBuildJobs.length > 0) {
+        const invalidBuildProfiles = new Set(invalidBuildJobs.map(job => job.value.params.profile));
+        throw new Error(`The build jobs in this workflow refer to the following build profiles that are not present in your eas.json file: ${[
+            ...invalidBuildProfiles,
+        ].join(', ')}`);
+    }
+}
+function validateWorkflowJobTypes(parsedYaml, workflowJsonSchema) {
+    const jobs = jobsFromWorkflow(parsedYaml);
+    const jobTypes = jobTypesFromWorkflowSchema(workflowJsonSchema);
+    const invalidJobs = jobs.filter(job => job.value.type && !jobTypes.includes(job.value.type));
+    if (invalidJobs.length > 0) {
+        throw new Error(`The following jobs have invalid types: ${invalidJobs
+            .map(job => job.key)
+            .join(', ')}. Valid types are: ${jobTypes.join(', ')}`);
+    }
+}
+function validateWorkflowStructure(parsedYaml, workflowJsonSchema) {
+    delete workflowJsonSchema['$schema'];
+    const ajv = (0, ajv_1.createValidator)();
+    const validate = ajv.compile(workflowJsonSchema);
+    const result = validate(parsedYaml);
+    if (!result) {
+        log_1.default.debug(JSON.stringify({
+            errors: validate.errors,
+        }, null, 2));
+        const readableErrors = (0, ajv_1.getReadableErrors)(validate.errors ?? []);
+        const processedErrors = new Set();
+        for (const err of readableErrors) {
+            if (err.message) {
+                processedErrors.add(err.message);
+            }
+        }
+        throw new Error([...processedErrors].join('\n'));
+    }
+}
+function workflowContentsFromParsedYaml(parsedYaml) {
+    return YAML.stringify(parsedYaml);
+}
+// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+async function fetchWorkflowSchemaAsync() {
+    // EXPO_TESTING_WORKFLOW_SCHEMA_PATH is used only for testing against a different schema
+    if (process.env.EXPO_TESTING_WORKFLOW_SCHEMA_PATH) {
+        const schemaPath = path_1.default.resolve(process.env.EXPO_TESTING_WORKFLOW_SCHEMA_PATH);
+        log_1.default.debug(`Loading workflow schema from ${schemaPath}`);
+        const jsonString = await fs_1.promises.readFile(schemaPath, 'utf-8');
+        const jsonFromFile = JSON.parse(jsonString);
+        return jsonFromFile.data;
+    }
+    // Otherwise, we fetch from <ApiBaseUrl>/v2/workflows/schema
+    const schemaUrl = (0, api_1.getExpoApiWorkflowSchemaURL)();
+    log_1.default.debug(`Fetching workflow schema from ${schemaUrl}`);
+    const response = await fetch(schemaUrl);
+    if (!response.ok) {
+        throw new Error(`Unable to fetch EAS Workflow schema, received status: ${response.status}`);
+    }
+    const jsonResponse = (await response.json());
+    return jsonResponse.data;
+}
+function jobsFromWorkflow(parsedYaml) {
+    return Object.entries(parsedYaml?.jobs).flatMap(([key, value]) => {
+        return {
+            key,
+            value,
+        };
+    });
+}
+function jobTypesFromWorkflowSchema(workflowJsonSchema) {
+    return workflowJsonSchema?.properties?.jobs?.additionalProperties?.anyOf.map((props) => props.properties.type.const);
+}

package/build/commands/account/login.d.ts

@@ -0,0 +1,14 @@
+import EasCommand from '../../commandUtils/EasCommand';
+export default class AccountLogin extends EasCommand {
+    static description: string;
+    static aliases: string[];
+    static flags: {
+        sso: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        browser: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    static contextDefinition: {
+        sessionManager: import("../../commandUtils/context/SessionManagementContextField").default;
+        maybeLoggedIn: import("../../commandUtils/context/MaybeLoggedInContextField").default;
+    };
+    runAsync(): Promise<void>;
+}

package/build/commands/account/login.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const core_1 = require("@oclif/core");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const EasCommand_1 = tslib_1.__importDefault(require("../../commandUtils/EasCommand"));
+const log_1 = tslib_1.__importDefault(require("../../log"));
+const prompts_1 = require("../../prompts");
+const User_1 = require("../../user/User");
+class AccountLogin extends EasCommand_1.default {
+    static description = 'log in with your Expo account';
+    static aliases = ['login'];
+    static flags = {
+        // can pass either --sso or -s
+        sso: core_1.Flags.boolean({
+            description: 'Login with SSO',
+            char: 's',
+            default: false,
+        }),
+        browser: core_1.Flags.boolean({
+            description: 'Login with your browser',
+            char: 'b',
+            default: false,
+        }),
+    };
+    static contextDefinition = {
+        ...this.ContextOptions.MaybeLoggedIn,
+        ...this.ContextOptions.SessionManagment,
+    };
+    async runAsync() {
+        const { flags: { sso, browser }, } = await this.parse(AccountLogin);
+        const { sessionManager, maybeLoggedIn: { actor }, } = await this.getContextAsync(AccountLogin, { nonInteractive: false });
+        if (sessionManager.getAccessToken()) {
+            throw new Error('EXPO_TOKEN is set in your environment, and is being used for all EAS authentication. To use username/password authentication, unset EXPO_TOKEN in your environment and re-run the command.');
+        }
+        if (actor) {
+            log_1.default.warn(`You are already logged in as ${chalk_1.default.bold((0, User_1.getActorDisplayName)(actor))}.`);
+            const shouldContinue = await (0, prompts_1.confirmAsync)({
+                message: 'Do you want to continue?',
+            });
+            if (!shouldContinue) {
+                core_1.Errors.error('Aborted', { exit: 1 });
+            }
+        }
+        await sessionManager.showLoginPromptAsync({ sso, browser });
+        log_1.default.log('Logged in');
+    }
+}
+exports.default = AccountLogin;

package/build/commands/account/logout.d.ts

@@ -0,0 +1,9 @@
+import EasCommand from '../../commandUtils/EasCommand';
+export default class AccountLogout extends EasCommand {
+    static description: string;
+    static aliases: string[];
+    static contextDefinition: {
+        sessionManager: import("../../commandUtils/context/SessionManagementContextField").default;
+    };
+    runAsync(): Promise<void>;
+}

package/build/commands/account/logout.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const EasCommand_1 = tslib_1.__importDefault(require("../../commandUtils/EasCommand"));
+const log_1 = tslib_1.__importDefault(require("../../log"));
+class AccountLogout extends EasCommand_1.default {
+    static description = 'log out';
+    static aliases = ['logout'];
+    static contextDefinition = {
+        ...this.ContextOptions.SessionManagment,
+    };
+    async runAsync() {
+        const { sessionManager } = await this.getContextAsync(AccountLogout, { nonInteractive: false });
+        await sessionManager.logoutAsync();
+        log_1.default.log('Logged out');
+    }
+}
+exports.default = AccountLogout;

package/build/commands/account/usage.d.ts

@@ -0,0 +1,15 @@
+import EasCommand from '../../commandUtils/EasCommand';
+export default class AccountUsage extends EasCommand {
+    static description: string;
+    static args: {
+        ACCOUNT_NAME: import("@oclif/core/lib/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        'non-interactive': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    static contextDefinition: {
+        loggedIn: import("../../commandUtils/context/LoggedInContextField").default;
+    };
+    runAsync(): Promise<void>;
+}