@donotuse/eas-cli 18.5.0-rc.1

package/build/commands/workflow/status.js

@@ -0,0 +1,111 @@
+"use strict";
+/**
+ * EAS Workflow Status Command
+ *
+ * This command shows the status of an existing workflow run.
+ *
+ * If no run ID is provided, you will be prompted to select from recent workflow runs for the current project.
+ *
+ * If the selected run is still in progress, the command will show the progress of the run, with an option
+ * to show periodic status updates while waiting for completion (similar to `eas workflow:run --wait`).
+ *
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const core_1 = require("@oclif/core");
+const getenv_1 = require("getenv");
+const url_1 = require("../../build/utils/url");
+const EasCommand_1 = tslib_1.__importDefault(require("../../commandUtils/EasCommand"));
+const flags_1 = require("../../commandUtils/flags");
+const utils_1 = require("../../commandUtils/workflow/utils");
+const generated_1 = require("../../graphql/generated");
+const AppQuery_1 = require("../../graphql/queries/AppQuery");
+const WorkflowRunQuery_1 = require("../../graphql/queries/WorkflowRunQuery");
+const log_1 = tslib_1.__importStar(require("../../log"));
+const projectUtils_1 = require("../../project/projectUtils");
+const prompts_1 = require("../../prompts");
+const json_1 = require("../../utils/json");
+class WorkflowStatus extends EasCommand_1.default {
+    static description = 'show the status of an existing workflow run. If no run ID is provided, you will be prompted to select from recent workflow runs for the current project.';
+    static args = {
+        WORKFLOW_RUN_ID: core_1.Args.string({
+            description: 'A workflow run ID.',
+        }),
+    };
+    static flags = {
+        ...flags_1.EASNonInteractiveFlag,
+        wait: core_1.Flags.boolean({
+            default: false,
+            allowNo: true,
+            description: 'Exit codes: 0 = success, 11 = failure, 12 = canceled, 13 = wait aborted.',
+            summary: 'Wait for workflow run to complete. Defaults to false.',
+        }),
+        ...flags_1.EasJsonOnlyFlag,
+    };
+    static contextDefinition = {
+        ...this.ContextOptions.DynamicProjectConfig,
+        ...this.ContextOptions.ProjectDir,
+        ...this.ContextOptions.Vcs,
+        ...this.ContextOptions.LoggedIn,
+    };
+    async runAsync() {
+        const { flags, args } = await this.parse(WorkflowStatus);
+        if (flags.json) {
+            (0, json_1.enableJsonOutput)();
+        }
+        const { getDynamicPrivateProjectConfigAsync, loggedIn: { graphqlClient }, } = await this.getContextAsync(WorkflowStatus, {
+            nonInteractive: flags['non-interactive'],
+            withServerSideEnvironment: null,
+        });
+        const { projectId, exp: { slug: projectName }, } = await getDynamicPrivateProjectConfigAsync();
+        const account = await (0, projectUtils_1.getOwnerAccountForProjectIdAsync)(graphqlClient, projectId);
+        let workflowRunId = args.WORKFLOW_RUN_ID;
+        if (!workflowRunId && flags['non-interactive']) {
+            throw new Error('Workflow run ID is required in non-interactive mode');
+        }
+        if (!workflowRunId) {
+            const queryResult = await AppQuery_1.AppQuery.byIdWorkflowRunsFilteredByStatusAsync(graphqlClient, projectId, undefined, 50);
+            const runs = (0, utils_1.processWorkflowRuns)(queryResult);
+            if (runs.length === 0) {
+                log_1.default.warn('No workflow runs to show');
+                return;
+            }
+            const answers = await (0, prompts_1.promptAsync)({
+                type: 'select',
+                name: 'selectedRun',
+                message: 'Select a workflow run:',
+                choices: runs.map(run => (0, utils_1.choiceFromWorkflowRun)(run)),
+            });
+            workflowRunId = answers.selectedRun;
+            if (!workflowRunId) {
+                throw new Error('No workflow run selected');
+            }
+        }
+        log_1.default.addNewLineIfNone();
+        log_1.default.log(`See logs: ${(0, log_1.link)((0, url_1.getWorkflowRunUrl)(account.name, projectName, workflowRunId))}`);
+        log_1.default.addNewLineIfNone();
+        const spinnerUsesStdErr = (0, getenv_1.boolish)('CI', false) || flags.json;
+        await (0, utils_1.showWorkflowStatusAsync)(graphqlClient, {
+            workflowRunId,
+            spinnerUsesStdErr,
+            waitForCompletion: flags.wait,
+        });
+        const workflowRun = await WorkflowRunQuery_1.WorkflowRunQuery.withJobsByIdAsync(graphqlClient, workflowRunId, {
+            useCache: false,
+        });
+        const status = workflowRun.status;
+        if (flags.json) {
+            (0, json_1.printJsonOnlyOutput)({
+                ...workflowRun,
+                url: (0, url_1.getWorkflowRunUrl)(account.name, projectName, workflowRunId),
+            });
+        }
+        if (status === generated_1.WorkflowRunStatus.Failure) {
+            process.exit(utils_1.workflowRunExitCodes.WORKFLOW_FAILED);
+        }
+        else if (status === generated_1.WorkflowRunStatus.Canceled) {
+            process.exit(utils_1.workflowRunExitCodes.WORKFLOW_CANCELED);
+        }
+    }
+}
+exports.default = WorkflowStatus;

package/build/commands/workflow/validate.d.ts

@@ -0,0 +1,18 @@
+import EasCommand from '../../commandUtils/EasCommand';
+export declare class WorkflowValidate extends EasCommand {
+    static description: string;
+    static args: {
+        path: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        'non-interactive': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    static contextDefinition: {
+        loggedIn: import("../../commandUtils/context/LoggedInContextField").default;
+        projectId: import("../../commandUtils/context/ProjectIdContextField").ProjectIdContextField;
+        projectDir: import("../../commandUtils/context/ProjectDirContextField").default;
+        getDynamicPublicProjectConfigAsync: import("../../commandUtils/context/DynamicProjectConfigContextField").DynamicPublicProjectConfigContextField;
+        getDynamicPrivateProjectConfigAsync: import("../../commandUtils/context/DynamicProjectConfigContextField").DynamicPrivateProjectConfigContextField;
+    };
+    runAsync(): Promise<void>;
+}

package/build/commands/workflow/validate.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkflowValidate = void 0;
+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 validation_1 = require("../../commandUtils/workflow/validation");
+const log_1 = tslib_1.__importDefault(require("../../log"));
+const ora_1 = require("../../ora");
+const workflowFile_1 = require("../../utils/workflowFile");
+class WorkflowValidate extends EasCommand_1.default {
+    static description = 'validate a workflow configuration yaml file';
+    static args = {
+        path: core_1.Args.string({
+            description: 'Path to the workflow configuration YAML file (must end with .yml or .yaml)',
+            required: true,
+        }),
+    };
+    static flags = {
+        ...flags_1.EASNonInteractiveFlag,
+    };
+    static contextDefinition = {
+        ...this.ContextOptions.DynamicProjectConfig,
+        ...this.ContextOptions.ProjectDir,
+        ...this.ContextOptions.ProjectId,
+        ...this.ContextOptions.LoggedIn,
+    };
+    async runAsync() {
+        const { args: { path: filePath }, flags, } = await this.parse(WorkflowValidate);
+        const spinner = (0, ora_1.ora)().start('Validating the workflow YAML file…');
+        try {
+            const { loggedIn: { graphqlClient }, projectDir, projectId, } = await this.getContextAsync(WorkflowValidate, {
+                nonInteractive: flags['non-interactive'],
+                withServerSideEnvironment: null,
+            });
+            const workflowFileContents = await workflowFile_1.WorkflowFile.readWorkflowFileContentsAsync({
+                projectDir,
+                filePath,
+            });
+            log_1.default.log(`Using workflow file from ${workflowFileContents.filePath}`);
+            await (0, validation_1.validateWorkflowFileAsync)(workflowFileContents, projectDir, graphqlClient, projectId);
+            spinner.succeed('Workflow configuration YAML is valid.');
+        }
+        catch (error) {
+            spinner.fail('Workflow configuration YAML is not valid.');
+            (0, validation_1.logWorkflowValidationErrors)(error);
+        }
+    }
+}
+exports.WorkflowValidate = WorkflowValidate;

package/build/commands/workflow/view.d.ts

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

package/build/commands/workflow/view.js

@@ -0,0 +1,169 @@
+"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 formatBuild_1 = require("../../build/utils/formatBuild");
+const url_1 = require("../../build/utils/url");
+const EasCommand_1 = tslib_1.__importDefault(require("../../commandUtils/EasCommand"));
+const flags_1 = require("../../commandUtils/flags");
+const stateMachine_1 = require("../../commandUtils/workflow/stateMachine");
+const utils_1 = require("../../commandUtils/workflow/utils");
+const generated_1 = require("../../graphql/generated");
+const WorkflowRunQuery_1 = require("../../graphql/queries/WorkflowRunQuery");
+const log_1 = tslib_1.__importStar(require("../../log"));
+const formatFields_1 = tslib_1.__importDefault(require("../../utils/formatFields"));
+const json_1 = require("../../utils/json");
+const processedOutputs = job => {
+    const result = [];
+    const keys = job.outputs ? Object.keys(job.outputs) : [];
+    keys.forEach(key => {
+        result.push({
+            label: `    ${key}`,
+            get value() {
+                const value = job.outputs[key];
+                return typeof value === 'string' ? value : JSON.stringify(value, null, 2);
+            },
+        });
+    });
+    return result;
+};
+class WorkflowView extends EasCommand_1.default {
+    static description = 'view details for a workflow run, including jobs. If no run ID is provided, you will be prompted to select from recent workflow runs for the current project.';
+    static flags = {
+        ...flags_1.EasJsonOnlyFlag,
+        ...flags_1.EASNonInteractiveFlag,
+    };
+    static args = {
+        id: core_1.Args.string({
+            description: 'ID of the workflow run to view',
+        }),
+    };
+    static contextDefinition = {
+        ...this.ContextOptions.ProjectId,
+        ...this.ContextOptions.LoggedIn,
+    };
+    async runAsync() {
+        const { args, flags } = await this.parse(WorkflowView);
+        const nonInteractive = flags['non-interactive'];
+        const { loggedIn: { graphqlClient }, projectId, } = await this.getContextAsync(WorkflowView, {
+            nonInteractive,
+        });
+        if (flags.json) {
+            (0, json_1.enableJsonOutput)();
+        }
+        if (nonInteractive && !args.id) {
+            throw new Error('If non-interactive, this command requires a workflow run ID as argument');
+        }
+        const actionResult = await (0, stateMachine_1.workflowRunSelectionAction)({
+            graphqlClient,
+            projectId,
+            nonInteractive,
+            allSteps: false,
+            state: stateMachine_1.WorkflowCommandSelectionStateValue.WORKFLOW_RUN_SELECTION,
+            runId: args.id,
+        });
+        if (actionResult.state === stateMachine_1.WorkflowCommandSelectionStateValue.ERROR) {
+            log_1.default.error(actionResult.message);
+            return;
+        }
+        const idToQuery = actionResult.runId ?? '';
+        const result = await WorkflowRunQuery_1.WorkflowRunQuery.withJobsByIdAsync(graphqlClient, idToQuery, {
+            useCache: false,
+        });
+        const { triggerType, trigger } = (0, utils_1.computeTriggerInfoForWorkflowRun)(result);
+        result.triggerType = triggerType;
+        result.trigger = trigger;
+        const processedJobs = result.jobs.map(job => {
+            const processedJob = job;
+            if (job.type === generated_1.WorkflowJobType.Build) {
+                processedJob.artifacts = job.turtleBuild?.artifacts ?? undefined;
+            }
+            else {
+                processedJob.artifacts = job.turtleJobRun?.artifacts;
+            }
+            delete processedJob.turtleJobRun;
+            return processedJob;
+        });
+        result.jobs = processedJobs;
+        result.logURL = (0, url_1.getWorkflowRunUrl)(result.workflow.app.ownerAccount.name, result.workflow.app.name, result.id);
+        if (flags.json) {
+            (0, json_1.printJsonOnlyOutput)(result);
+            return;
+        }
+        log_1.default.log((0, formatFields_1.default)([
+            { label: 'Run ID', value: result.id },
+            { label: 'Workflow', value: result.workflow.fileName },
+            { label: 'Trigger Type', value: result.triggerType },
+            { label: 'Trigger', value: result.trigger ?? 'null' },
+            {
+                label: 'Git Commit Message',
+                value: result.gitCommitMessage?.split('\n')[0] ?? 'null',
+            },
+            { label: 'Status', value: result.status },
+            { label: 'Errors', value: result.errors.map(error => error.title).join('\n') },
+            { label: 'Created At', value: result.createdAt },
+            { label: 'Updated At', value: result.updatedAt },
+            { label: 'Log URL', value: (0, log_1.link)(result.logURL) },
+        ]));
+        log_1.default.addNewLineIfNone();
+        result.jobs.forEach((job) => {
+            log_1.default.log((0, formatFields_1.default)([
+                { label: 'Job ID', value: job.id },
+                { label: '  Key', value: job.key },
+                { label: '  Name', value: job.name },
+                { label: '  Status', value: job.status },
+                { label: '  Type', value: job.type },
+                { label: '  Created At', value: job.createdAt },
+                { label: '  Updated At', value: job.updatedAt },
+            ]));
+            if (job.errors.length > 0) {
+                log_1.default.gray(chalk_1.default.dim('  Errors:'));
+                job.errors.forEach(error => {
+                    log_1.default.log((0, formatFields_1.default)([{ label: `    ${error.title}`, value: `${error.message}` }]));
+                });
+            }
+            if (job.outputs) {
+                const outputs = processedOutputs(job);
+                if (outputs.length > 0) {
+                    log_1.default.gray(chalk_1.default.dim('  Outputs:'));
+                    log_1.default.log((0, formatFields_1.default)(outputs));
+                }
+            }
+            if (job.type === generated_1.WorkflowJobType.Build) {
+                if (job.turtleBuild?.artifacts) {
+                    log_1.default.gray(chalk_1.default.dim('  Artifacts:'));
+                    log_1.default.log((0, formatFields_1.default)((0, formatBuild_1.formatGraphQLBuildArtifacts)(job.turtleBuild).map(item => {
+                        item.label = `    ${item.label}`;
+                        return item;
+                    })));
+                }
+            }
+            else {
+                const jobArtifacts = job.artifacts;
+                if (jobArtifacts?.length) {
+                    log_1.default.gray(chalk_1.default.dim('  Artifacts:'));
+                    jobArtifacts.forEach(artifact => {
+                        log_1.default.log((0, formatFields_1.default)([
+                            { label: '    ID', value: artifact.id },
+                            { label: '    Name', value: artifact.name },
+                            { label: '    Content Type', value: artifact?.contentType ?? 'null' },
+                            {
+                                label: '    File Size Bytes',
+                                value: artifact?.fileSizeBytes ? `${artifact.fileSizeBytes}` : 'null',
+                            },
+                            { label: '    Filename', value: artifact.filename },
+                            {
+                                label: '    Download URL',
+                                value: artifact?.downloadUrl ? (0, log_1.link)(artifact.downloadUrl) : 'null',
+                            },
+                        ]));
+                        log_1.default.addNewLineIfNone();
+                    });
+                }
+            }
+            log_1.default.addNewLineIfNone();
+        });
+    }
+}
+exports.default = WorkflowView;

package/build/credentials/android/AndroidCredentialsProvider.d.ts

@@ -0,0 +1,23 @@
+import { Platform } from '@expo/eas-build-job';
+import { CredentialsSource } from '@expo/eas-json';
+import { AppLookupParams } from './api/GraphqlClient';
+import { Keystore } from './credentials';
+import { CredentialsContext } from '../context';
+export interface AndroidCredentials {
+    keystore: Keystore;
+}
+interface Options {
+    app: AppLookupParams;
+    name?: string;
+}
+export default class AndroidCredentialsProvider {
+    private readonly ctx;
+    private readonly options;
+    readonly platform = Platform.ANDROID;
+    constructor(ctx: CredentialsContext, options: Options);
+    getCredentialsAsync(src: CredentialsSource.LOCAL | CredentialsSource.REMOTE): Promise<AndroidCredentials>;
+    private getRemoteAsync;
+    private toAndroidCredentials;
+    private getLocalAsync;
+}
+export {};

package/build/credentials/android/AndroidCredentialsProvider.js

@@ -0,0 +1,44 @@
+"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 nullthrows_1 = tslib_1.__importDefault(require("nullthrows"));
+const SetUpBuildCredentials_1 = require("./actions/SetUpBuildCredentials");
+const credentialsJsonReader = tslib_1.__importStar(require("../credentialsJson/read"));
+class AndroidCredentialsProvider {
+    ctx;
+    options;
+    platform = eas_build_job_1.Platform.ANDROID;
+    constructor(ctx, options) {
+        this.ctx = ctx;
+        this.options = options;
+    }
+    async getCredentialsAsync(src) {
+        switch (src) {
+            case eas_json_1.CredentialsSource.LOCAL:
+                return await this.getLocalAsync();
+            case eas_json_1.CredentialsSource.REMOTE:
+                return await this.getRemoteAsync();
+        }
+    }
+    async getRemoteAsync() {
+        const setupBuildCredentialsAction = new SetUpBuildCredentials_1.SetUpBuildCredentials(this.options);
+        const buildCredentials = await setupBuildCredentialsAction.runAsync(this.ctx);
+        return this.toAndroidCredentials(buildCredentials);
+    }
+    toAndroidCredentials(androidBuildCredentials) {
+        return {
+            keystore: {
+                keystore: (0, nullthrows_1.default)(androidBuildCredentials.androidKeystore?.keystore),
+                keystorePassword: (0, nullthrows_1.default)(androidBuildCredentials.androidKeystore?.keystorePassword),
+                keyAlias: (0, nullthrows_1.default)(androidBuildCredentials.androidKeystore?.keyAlias),
+                keyPassword: androidBuildCredentials.androidKeystore?.keyPassword ?? undefined,
+            },
+        };
+    }
+    async getLocalAsync() {
+        return await credentialsJsonReader.readAndroidCredentialsAsync(this.ctx.projectDir);
+    }
+}
+exports.default = AndroidCredentialsProvider;

package/build/credentials/android/actions/AssignFcm.d.ts

@@ -0,0 +1,8 @@
+import { AndroidFcmFragment, CommonAndroidAppCredentialsFragment } from '../../../graphql/generated';
+import { CredentialsContext } from '../../context';
+import { AppLookupParams } from '../api/GraphqlClient';
+export declare class AssignFcm {
+    private readonly app;
+    constructor(app: AppLookupParams);
+    runAsync(ctx: CredentialsContext, fcm: AndroidFcmFragment): Promise<CommonAndroidAppCredentialsFragment>;
+}

package/build/credentials/android/actions/AssignFcm.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AssignFcm = void 0;
+const tslib_1 = require("tslib");
+const log_1 = tslib_1.__importDefault(require("../../../log"));
+class AssignFcm {
+    app;
+    constructor(app) {
+        this.app = app;
+    }
+    async runAsync(ctx, fcm) {
+        const appCredentials = await ctx.android.createOrGetExistingAndroidAppCredentialsWithBuildCredentialsAsync(ctx.graphqlClient, this.app);
+        const updatedAppCredentials = await ctx.android.updateAndroidAppCredentialsAsync(ctx.graphqlClient, appCredentials, {
+            androidFcmId: fcm.id,
+        });
+        log_1.default.succeed(`FCM API Key assigned to ${this.app.androidApplicationIdentifier}`);
+        return updatedAppCredentials;
+    }
+}
+exports.AssignFcm = AssignFcm;

package/build/credentials/android/actions/AssignGoogleServiceAccountKeyForFcmV1.d.ts

@@ -0,0 +1,8 @@
+import { CommonAndroidAppCredentialsFragment, GoogleServiceAccountKeyFragment } from '../../../graphql/generated';
+import { CredentialsContext } from '../../context';
+import { AppLookupParams } from '../api/GraphqlClient';
+export declare class AssignGoogleServiceAccountKeyForFcmV1 {
+    private readonly app;
+    constructor(app: AppLookupParams);
+    runAsync(ctx: CredentialsContext, googleServiceAccountKey: GoogleServiceAccountKeyFragment): Promise<CommonAndroidAppCredentialsFragment>;
+}

package/build/credentials/android/actions/AssignGoogleServiceAccountKeyForFcmV1.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AssignGoogleServiceAccountKeyForFcmV1 = void 0;
+const tslib_1 = require("tslib");
+const log_1 = tslib_1.__importDefault(require("../../../log"));
+class AssignGoogleServiceAccountKeyForFcmV1 {
+    app;
+    constructor(app) {
+        this.app = app;
+    }
+    async runAsync(ctx, googleServiceAccountKey) {
+        const appCredentials = await ctx.android.createOrGetExistingAndroidAppCredentialsWithBuildCredentialsAsync(ctx.graphqlClient, this.app);
+        const updatedAppCredentials = await ctx.android.updateAndroidAppCredentialsAsync(ctx.graphqlClient, appCredentials, {
+            googleServiceAccountKeyForFcmV1Id: googleServiceAccountKey.id,
+        });
+        log_1.default.succeed(`Google Service Account Key assigned to ${this.app.androidApplicationIdentifier} for FCM V1`);
+        return updatedAppCredentials;
+    }
+}
+exports.AssignGoogleServiceAccountKeyForFcmV1 = AssignGoogleServiceAccountKeyForFcmV1;

package/build/credentials/android/actions/AssignGoogleServiceAccountKeyForSubmissions.d.ts

@@ -0,0 +1,8 @@
+import { CommonAndroidAppCredentialsFragment, GoogleServiceAccountKeyFragment } from '../../../graphql/generated';
+import { CredentialsContext } from '../../context';
+import { AppLookupParams } from '../api/GraphqlClient';
+export declare class AssignGoogleServiceAccountKeyForSubmissions {
+    private readonly app;
+    constructor(app: AppLookupParams);
+    runAsync(ctx: CredentialsContext, googleServiceAccountKey: GoogleServiceAccountKeyFragment): Promise<CommonAndroidAppCredentialsFragment>;
+}

package/build/credentials/android/actions/AssignGoogleServiceAccountKeyForSubmissions.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AssignGoogleServiceAccountKeyForSubmissions = void 0;
+const tslib_1 = require("tslib");
+const log_1 = tslib_1.__importDefault(require("../../../log"));
+class AssignGoogleServiceAccountKeyForSubmissions {
+    app;
+    constructor(app) {
+        this.app = app;
+    }
+    async runAsync(ctx, googleServiceAccountKey) {
+        const appCredentials = await ctx.android.createOrGetExistingAndroidAppCredentialsWithBuildCredentialsAsync(ctx.graphqlClient, this.app);
+        const updatedAppCredentials = await ctx.android.updateAndroidAppCredentialsAsync(ctx.graphqlClient, appCredentials, {
+            googleServiceAccountKeyForSubmissionsId: googleServiceAccountKey.id,
+        });
+        log_1.default.succeed(`Google Service Account Key assigned to ${this.app.androidApplicationIdentifier} for submissions`);
+        return updatedAppCredentials;
+    }
+}
+exports.AssignGoogleServiceAccountKeyForSubmissions = AssignGoogleServiceAccountKeyForSubmissions;

package/build/credentials/android/actions/BuildCredentialsUtils.d.ts

@@ -0,0 +1,20 @@
+import { AndroidAppBuildCredentialsFragment } from '../../../graphql/generated';
+import { GradleBuildContext } from '../../../project/android/gradle';
+import { CredentialsContext } from '../../context';
+import { AppLookupParams } from '../api/GraphqlClient';
+/**
+ * Legacy credentials can be copied over to EAS if the user does not have
+ * EAS credentials set up yet
+ */
+export declare function canCopyLegacyCredentialsAsync(ctx: CredentialsContext, app: AppLookupParams): Promise<boolean>;
+export declare function promptUserAndCopyLegacyCredentialsAsync(ctx: CredentialsContext, app: AppLookupParams): Promise<void>;
+export declare function getAppLookupParamsFromContextAsync(ctx: CredentialsContext, gradleContext?: GradleBuildContext): Promise<AppLookupParams>;
+export declare function createOrUpdateDefaultAndroidAppBuildCredentialsAsync(ctx: CredentialsContext, appLookupParams: AppLookupParams, { androidKeystoreId, }: {
+    androidKeystoreId: string;
+}): Promise<AndroidAppBuildCredentialsFragment>;
+export declare function promptForNameAsync(): Promise<string>;
+/**
+ * sort a build credentials array in descending order of preference
+ * prefer default credentials, then prefer names that come first lexicographically
+ */
+export declare function sortBuildCredentials(androidAppBuildCredentialsList: AndroidAppBuildCredentialsFragment[]): AndroidAppBuildCredentialsFragment[];