@donotuse/eas-cli 18.5.0-rc.1

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

@@ -0,0 +1,17 @@
+import EasCommand from '../../commandUtils/EasCommand';
+export default class WorkflowLogView extends EasCommand {
+    static description: string;
+    static flags: {
+        'all-steps': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        '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/logs.js

@@ -0,0 +1,96 @@
+"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 stateMachine_1 = require("../../commandUtils/workflow/stateMachine");
+const log_1 = tslib_1.__importDefault(require("../../log"));
+const json_1 = require("../../utils/json");
+function printLogsForAllSteps(logs) {
+    [...logs.keys()].forEach(step => {
+        const logLines = logs.get(step);
+        if (logLines) {
+            log_1.default.log(`Step: ${step}`);
+            logLines.forEach(line => {
+                log_1.default.log(`  ${line.time} ${line.msg}`);
+            });
+        }
+        log_1.default.addNewLineIfNone();
+    });
+}
+class WorkflowLogView extends EasCommand_1.default {
+    static description = 'view logs for a workflow run, selecting a job and step to view. You can pass in either a workflow run ID or a job ID. If no ID is passed in, you will be prompted to select from recent workflow runs for the current project.';
+    static flags = {
+        ...flags_1.EasJsonOnlyFlag,
+        ...flags_1.EASNonInteractiveFlag,
+        'all-steps': core_1.Flags.boolean({
+            description: 'Print all logs, rather than prompting for a specific step. This will be automatically set when in non-interactive mode.',
+            default: false,
+        }),
+    };
+    static args = {
+        id: core_1.Args.string({
+            description: 'ID of the workflow run or workflow job to view logs for',
+        }),
+    };
+    static contextDefinition = {
+        ...this.ContextOptions.ProjectId,
+        ...this.ContextOptions.LoggedIn,
+    };
+    async runAsync() {
+        const { args, flags } = await this.parse(WorkflowLogView);
+        const nonInteractive = flags['non-interactive'];
+        const allSteps = nonInteractive ? true : flags['all-steps'];
+        log_1.default.debug(`allSteps = ${allSteps}`);
+        log_1.default.debug(`nonInteractive = ${nonInteractive}`);
+        log_1.default.debug(`flags.json = ${flags.json}`);
+        log_1.default.debug(`args.id = ${args.id}`);
+        const { loggedIn: { graphqlClient }, projectId, } = await this.getContextAsync(WorkflowLogView, {
+            nonInteractive,
+        });
+        if (flags.json) {
+            (0, json_1.enableJsonOutput)();
+        }
+        const finalSelectionState = await (0, stateMachine_1.executeWorkflowSelectionActionsAsync)({
+            graphqlClient,
+            projectId,
+            nonInteractive,
+            allSteps,
+            state: stateMachine_1.WorkflowCommandSelectionStateValue.WORKFLOW_JOB_SELECTION,
+            jobId: args.id,
+        });
+        if (finalSelectionState.state === stateMachine_1.WorkflowCommandSelectionStateValue.ERROR) {
+            log_1.default.error(finalSelectionState.message);
+            return;
+        }
+        const logs = finalSelectionState?.logs;
+        if (allSteps) {
+            if (logs) {
+                if (flags.json) {
+                    (0, json_1.printJsonOnlyOutput)(Object.fromEntries(logs));
+                }
+                else {
+                    printLogsForAllSteps(logs);
+                }
+            }
+        }
+        else {
+            const selectedStep = finalSelectionState?.step;
+            const logLines = logs?.get(selectedStep);
+            if (logLines) {
+                if (flags.json) {
+                    const output = {};
+                    output[selectedStep] = logLines ?? null;
+                    (0, json_1.printJsonOnlyOutput)(output);
+                }
+                else {
+                    logLines.forEach(line => {
+                        log_1.default.log(`  ${line.time} ${line.msg}`);
+                    });
+                }
+            }
+        }
+    }
+}
+exports.default = WorkflowLogView;

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

@@ -0,0 +1,63 @@
+/**
+ * EAS Workflow Run Command
+ *
+ * This command runs an EAS workflow with support for interactive input prompting.
+ *
+ * Input Sources (in order of precedence):
+ * 1. Command line flags (-F key=value)
+ * 2. STDIN JSON input (echo '{"key": "value"}' | eas workflow:run)
+ * 3. Interactive prompts (when required inputs are missing and not in non-interactive mode)
+ *
+ * Interactive Prompting:
+ * - When running in interactive mode (default), the command will automatically prompt
+ *   for any required inputs that are not provided via flags or STDIN
+ * - Input types supported: string, boolean, number, choice, environment
+ * - Each input type has appropriate validation and default values
+ * - Use --non-interactive flag to disable prompting and require all inputs via flags
+ *
+ * Example workflow with inputs:
+ * ```yaml
+ * on:
+ *   workflow_dispatch:
+ *     inputs:
+ *       environment:
+ *         type: string
+ *         required: true
+ *         description: "Environment to deploy to"
+ *       debug:
+ *         type: boolean
+ *         default: false
+ *         description: "Enable debug mode"
+ *       version:
+ *         type: number
+ *         required: true
+ *         description: "Version number"
+ *       deployment_type:
+ *         type: choice
+ *         options: ["staging", "production"]
+ *         default: "staging"
+ *         description: "Type of deployment"
+ * ```
+ */
+import EasCommand from '../../commandUtils/EasCommand';
+export default class WorkflowRun extends EasCommand {
+    static description: string;
+    static args: {
+        file: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        wait: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        input: import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        ref: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'non-interactive': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    static contextDefinition: {
+        loggedIn: import("../../commandUtils/context/LoggedInContextField").default;
+        vcsClient: import("../../commandUtils/context/VcsClientContextField").default;
+        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/run.js

@@ -0,0 +1,318 @@
+"use strict";
+/**
+ * EAS Workflow Run Command
+ *
+ * This command runs an EAS workflow with support for interactive input prompting.
+ *
+ * Input Sources (in order of precedence):
+ * 1. Command line flags (-F key=value)
+ * 2. STDIN JSON input (echo '{"key": "value"}' | eas workflow:run)
+ * 3. Interactive prompts (when required inputs are missing and not in non-interactive mode)
+ *
+ * Interactive Prompting:
+ * - When running in interactive mode (default), the command will automatically prompt
+ *   for any required inputs that are not provided via flags or STDIN
+ * - Input types supported: string, boolean, number, choice, environment
+ * - Each input type has appropriate validation and default values
+ * - Use --non-interactive flag to disable prompting and require all inputs via flags
+ *
+ * Example workflow with inputs:
+ * ```yaml
+ * on:
+ *   workflow_dispatch:
+ *     inputs:
+ *       environment:
+ *         type: string
+ *         required: true
+ *         description: "Environment to deploy to"
+ *       debug:
+ *         type: boolean
+ *         default: false
+ *         description: "Enable debug mode"
+ *       version:
+ *         type: number
+ *         required: true
+ *         description: "Version number"
+ *       deployment_type:
+ *         type: choice
+ *         options: ["staging", "production"]
+ *         default: "staging"
+ *         description: "Type of deployment"
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const spawn_async_1 = tslib_1.__importDefault(require("@expo/spawn-async"));
+const core_1 = require("@oclif/core");
+const core_2 = require("@urql/core");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const getenv_1 = require("getenv");
+const path = tslib_1.__importStar(require("node:path"));
+const slash_1 = tslib_1.__importDefault(require("slash"));
+const url_1 = require("../../build/utils/url");
+const EasCommand_1 = tslib_1.__importDefault(require("../../commandUtils/EasCommand"));
+const flags_1 = require("../../commandUtils/flags");
+const inputs_1 = require("../../commandUtils/workflow/inputs");
+const utils_1 = require("../../commandUtils/workflow/utils");
+const generated_1 = require("../../graphql/generated");
+const WorkflowRevisionMutation_1 = require("../../graphql/mutations/WorkflowRevisionMutation");
+const WorkflowRunMutation_1 = require("../../graphql/mutations/WorkflowRunMutation");
+const WorkflowRunQuery_1 = require("../../graphql/queries/WorkflowRunQuery");
+const log_1 = tslib_1.__importStar(require("../../log"));
+const projectUtils_1 = require("../../project/projectUtils");
+const uploadAccountScopedFileAsync_1 = require("../../project/uploadAccountScopedFileAsync");
+const uploadAccountScopedProjectSourceAsync_1 = require("../../project/uploadAccountScopedProjectSourceAsync");
+const json_1 = require("../../utils/json");
+const workflowFile_1 = require("../../utils/workflowFile");
+class WorkflowRun extends EasCommand_1.default {
+    static description = 'run an EAS workflow. The entire local project directory will be packaged and uploaded to EAS servers for the workflow run, unless the --ref flag is used.';
+    static args = {
+        file: core_1.Args.string({
+            description: 'Path to the workflow file to run',
+            required: true,
+        }),
+    };
+    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.',
+        }),
+        input: core_1.Flags.string({
+            char: 'F',
+            aliases: ['f', 'field'],
+            multiple: true,
+            description: 'Add a parameter in key=value format. Use multiple instances of this flag to set multiple inputs.',
+            summary: 'Set workflow inputs',
+        }),
+        ref: core_1.Flags.string({
+            description: "The git reference must exist in the project's git repository, and the workflow file must exist at that reference. When this flag is used, the local project is not uploaded; instead, the workflow is run from the exact state of the project at the chosen reference.",
+            summary: 'Git reference to run the workflow on',
+        }),
+        ...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(WorkflowRun);
+        if (flags.json) {
+            (0, json_1.enableJsonOutput)();
+        }
+        const { getDynamicPrivateProjectConfigAsync, loggedIn: { graphqlClient }, vcsClient, projectDir, } = await this.getContextAsync(WorkflowRun, {
+            nonInteractive: flags['non-interactive'],
+            withServerSideEnvironment: null,
+        });
+        const { projectId, exp: { slug: projectName }, } = await getDynamicPrivateProjectConfigAsync({
+            skipPlugins: true,
+        });
+        const account = await (0, projectUtils_1.getOwnerAccountForProjectIdAsync)(graphqlClient, projectId);
+        let yamlConfig;
+        let workflowRunId;
+        let workflowRevisionId;
+        let gitRef;
+        if (flags.ref) {
+            // Run from git ref
+            const fileName = path.basename(args.file);
+            // Find the real commit, make sure the ref is valid
+            gitRef = (await (0, spawn_async_1.default)('git', ['rev-parse', flags.ref], {
+                cwd: projectDir,
+            })).output[0].trim();
+            if (!gitRef) {
+                throw new Error('Failed to resolve git reference');
+            }
+            log_1.default.log(`Using workflow file ${fileName} at ${gitRef}`);
+            let revisionResult;
+            try {
+                revisionResult = await WorkflowRevisionMutation_1.WorkflowRevisionMutation.getOrCreateWorkflowRevisionFromGitRefAsync(graphqlClient, {
+                    appId: projectId,
+                    fileName,
+                    gitRef,
+                });
+            }
+            catch (err) {
+                throw new Error(`Failed to find or create workflow revision for ${fileName} at ${flags.ref}: ${err}`);
+            }
+            log_1.default.debug(`Workflow revision: ${JSON.stringify(revisionResult, null, 2)}`);
+            if (!revisionResult) {
+                throw new Error(`Failed to find or create workflow revision for ${fileName} at ${flags.ref}`);
+            }
+            yamlConfig = revisionResult.yamlConfig;
+            workflowRevisionId = revisionResult.id;
+        }
+        else {
+            // Run from local file
+            try {
+                const workflowFileContents = await workflowFile_1.WorkflowFile.readWorkflowFileContentsAsync({
+                    projectDir,
+                    filePath: args.file,
+                });
+                log_1.default.log(`Using workflow file from ${workflowFileContents.filePath}`);
+                yamlConfig = workflowFileContents.yamlConfig;
+            }
+            catch (err) {
+                log_1.default.error('Failed to read workflow file.');
+                throw err;
+            }
+        }
+        // Validate workflow YAML
+        try {
+            await WorkflowRevisionMutation_1.WorkflowRevisionMutation.validateWorkflowYamlConfigAsync(graphqlClient, {
+                appId: projectId,
+                yamlConfig,
+            });
+        }
+        catch (error) {
+            if (error instanceof core_2.CombinedError) {
+                workflowFile_1.WorkflowFile.maybePrintWorkflowFileValidationErrors({
+                    error,
+                });
+                throw error;
+            }
+        }
+        let inputs;
+        // Check for stdin input
+        const stdinData = await (0, utils_1.maybeReadStdinAsync)();
+        const inputsFromFlags = [...(flags.input ?? [])];
+        // Validate that both stdin and -F flags are not provided simultaneously
+        if (stdinData && inputsFromFlags.length > 0) {
+            throw new Error('Cannot use both stdin JSON input and -F flags simultaneously. Please use only one input method.');
+        }
+        if (stdinData) {
+            inputs = (0, inputs_1.parseJsonInputs)(stdinData);
+        }
+        else if (inputsFromFlags.length > 0) {
+            inputs = (0, inputs_1.parseInputs)(inputsFromFlags);
+        }
+        // Parse workflow inputs from YAML and prompt for missing required inputs
+        const inputSpecs = (0, inputs_1.parseWorkflowInputsFromYaml)(yamlConfig);
+        if (!flags['non-interactive']) {
+            inputs = await (0, inputs_1.maybePromptForMissingInputsAsync)({ inputSpecs, inputs: inputs ?? {} });
+        }
+        if (inputs && Object.keys(inputs).length > 0) {
+            log_1.default.addNewLineIfNone();
+            log_1.default.newLine();
+            log_1.default.log('Running with inputs:');
+            for (const [key, value] of Object.entries(inputs)) {
+                log_1.default.log(`- ${chalk_1.default.bold(key)}: ${JSON.stringify(value)}`);
+            }
+        }
+        let projectArchiveBucketKey;
+        let easJsonBucketKey = null;
+        let packageJsonBucketKey = null;
+        const easJsonPath = path.join(projectDir, 'eas.json');
+        const packageJsonPath = path.join(projectDir, 'package.json');
+        const projectRootDirectory = (0, slash_1.default)(path.relative(await vcsClient.getRootPathAsync(), projectDir) || '.');
+        if (gitRef) {
+            // Run from git ref
+            let runResult;
+            try {
+                runResult = await WorkflowRunMutation_1.WorkflowRunMutation.createWorkflowRunFromGitRefAsync(graphqlClient, {
+                    workflowRevisionId: workflowRevisionId ?? '',
+                    gitRef,
+                    inputs,
+                });
+            }
+            catch (err) {
+                throw new Error(`Failed to create workflow run: ${err}`);
+            }
+            workflowRunId = runResult.id;
+        }
+        else {
+            // Run from local file
+            try {
+                ({ projectArchiveBucketKey } = await (0, uploadAccountScopedProjectSourceAsync_1.uploadAccountScopedProjectSourceAsync)({
+                    graphqlClient,
+                    vcsClient,
+                    accountId: account.id,
+                }));
+                if (await (0, utils_1.fileExistsAsync)(easJsonPath)) {
+                    ({ fileBucketKey: easJsonBucketKey } = await (0, uploadAccountScopedFileAsync_1.uploadAccountScopedFileAsync)({
+                        graphqlClient,
+                        accountId: account.id,
+                        filePath: easJsonPath,
+                        maxSizeBytes: 1024 * 1024,
+                    }));
+                }
+                else {
+                    log_1.default.warn(`⚠ No ${chalk_1.default.bold('eas.json')} found in the project directory. Running ${chalk_1.default.bold('type: build')} jobs will not work. Run ${chalk_1.default.bold('eas build:configure')} to configure your project for builds.`);
+                }
+                if (await (0, utils_1.fileExistsAsync)(packageJsonPath)) {
+                    ({ fileBucketKey: packageJsonBucketKey } = await (0, uploadAccountScopedFileAsync_1.uploadAccountScopedFileAsync)({
+                        graphqlClient,
+                        accountId: account.id,
+                        filePath: packageJsonPath,
+                        maxSizeBytes: 1024 * 1024,
+                    }));
+                }
+                else {
+                    log_1.default.warn(`⚠ No ${chalk_1.default.bold('package.json')} found in the project directory. It is used to automatically infer best job configuration for your project. You may want to define ${chalk_1.default.bold('image')} property in your workflow to specify the image to use.`);
+                }
+            }
+            catch (err) {
+                log_1.default.error('Failed to upload project sources.');
+                throw err;
+            }
+            try {
+                ({ id: workflowRunId } = await WorkflowRunMutation_1.WorkflowRunMutation.createWorkflowRunAsync(graphqlClient, {
+                    appId: projectId,
+                    workflowRevisionInput: {
+                        fileName: path.basename(args.file),
+                        yamlConfig,
+                    },
+                    workflowRunInput: {
+                        inputs,
+                        projectSource: {
+                            type: generated_1.WorkflowProjectSourceType.Gcs,
+                            projectArchiveBucketKey,
+                            easJsonBucketKey,
+                            packageJsonBucketKey,
+                            projectRootDirectory,
+                        },
+                    },
+                }));
+            }
+            catch (err) {
+                log_1.default.error('Failed to start the workflow with the API.');
+                throw err;
+            }
+        }
+        log_1.default.newLine();
+        log_1.default.log(`See logs: ${(0, log_1.link)((0, url_1.getWorkflowRunUrl)(account.name, projectName, workflowRunId))}`);
+        if (!flags.wait) {
+            if (flags.json) {
+                (0, json_1.printJsonOnlyOutput)({
+                    id: workflowRunId,
+                    url: (0, url_1.getWorkflowRunUrl)(account.name, projectName, workflowRunId),
+                });
+            }
+            process.exit(0);
+        }
+        const spinnerUsesStdErr = (0, getenv_1.boolish)('CI', false) || flags.json;
+        const { status } = await (0, utils_1.showWorkflowStatusAsync)(graphqlClient, {
+            workflowRunId,
+            spinnerUsesStdErr,
+        });
+        if (flags.json) {
+            const workflowRun = await WorkflowRunQuery_1.WorkflowRunQuery.withJobsByIdAsync(graphqlClient, workflowRunId, {
+                useCache: false,
+            });
+            (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 = WorkflowRun;

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

@@ -0,0 +1,16 @@
+import EasCommand from '../../commandUtils/EasCommand';
+import { WorkflowRunStatus } from '../../graphql/generated';
+export default class WorkflowRunList extends EasCommand {
+    static description: string;
+    static flags: {
+        limit: import("@oclif/core/lib/interfaces").OptionFlag<number | undefined>;
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        workflow: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        status: import("@oclif/core/lib/interfaces").OptionFlag<WorkflowRunStatus | 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/workflow/runs.js

@@ -0,0 +1,73 @@
+"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 pagination_1 = require("../../commandUtils/pagination");
+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.__importDefault(require("../../log"));
+const formatFields_1 = tslib_1.__importDefault(require("../../utils/formatFields"));
+const json_1 = require("../../utils/json");
+class WorkflowRunList extends EasCommand_1.default {
+    static description = 'list recent workflow runs for this project, with their IDs, statuses, and timestamps';
+    static flags = {
+        workflow: core_1.Flags.string({
+            description: 'If present, the query will only return runs for the specified workflow file name',
+            required: false,
+        }),
+        status: core_1.Flags.option({
+            description: 'If present, filter the returned runs to select those with the specified status',
+            required: false,
+            options: Object.values(generated_1.WorkflowRunStatus),
+        })(),
+        ...flags_1.EasJsonOnlyFlag,
+        limit: (0, pagination_1.getLimitFlagWithCustomValues)({ defaultTo: 10, limit: 100 }),
+    };
+    static contextDefinition = {
+        ...this.ContextOptions.ProjectId,
+        ...this.ContextOptions.LoggedIn,
+    };
+    async runAsync() {
+        const { flags } = await this.parse(WorkflowRunList);
+        const { projectId, loggedIn: { graphqlClient }, } = await this.getContextAsync(WorkflowRunList, {
+            nonInteractive: true,
+        });
+        if (flags.json) {
+            (0, json_1.enableJsonOutput)();
+        }
+        const workflowFileName = flags.workflow;
+        const status = flags.status;
+        const limit = flags.limit ?? 10;
+        let runs;
+        if (workflowFileName) {
+            runs = await WorkflowRunQuery_1.WorkflowRunQuery.byAppIdFileNameAndStatusAsync(graphqlClient, projectId, workflowFileName, status, limit);
+        }
+        else {
+            runs = await AppQuery_1.AppQuery.byIdWorkflowRunsFilteredByStatusAsync(graphqlClient, projectId, status, limit);
+        }
+        const result = (0, utils_1.processWorkflowRuns)(runs);
+        if (flags.json) {
+            (0, json_1.printJsonOnlyOutput)(result);
+            return;
+        }
+        log_1.default.addNewLineIfNone();
+        result.forEach(run => {
+            log_1.default.log((0, formatFields_1.default)([
+                { label: 'Run ID', value: run.id },
+                { label: 'Workflow', value: run.workflowFileName },
+                { label: 'Status', value: run.status },
+                { label: 'Started At', value: run.startedAt },
+                { label: 'Finished At', value: run.finishedAt },
+                { label: 'Trigger Type', value: run.triggerType },
+                { label: 'Trigger', value: run.trigger ?? 'null' },
+                { label: 'Git Commit Message', value: run.gitCommitMessage ?? 'null' },
+            ]));
+            log_1.default.addNewLineIfNone();
+        });
+    }
+}
+exports.default = WorkflowRunList;

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

@@ -0,0 +1,31 @@
+/**
+ * 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`).
+ *
+ */
+import EasCommand from '../../commandUtils/EasCommand';
+export default class WorkflowStatus extends EasCommand {
+    static description: string;
+    static args: {
+        WORKFLOW_RUN_ID: import("@oclif/core/lib/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        wait: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        'non-interactive': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    static contextDefinition: {
+        loggedIn: import("../../commandUtils/context/LoggedInContextField").default;
+        vcsClient: import("../../commandUtils/context/VcsClientContextField").default;
+        projectDir: import("../../commandUtils/context/ProjectDirContextField").default;
+        getDynamicPublicProjectConfigAsync: import("../../commandUtils/context/DynamicProjectConfigContextField").DynamicPublicProjectConfigContextField;
+        getDynamicPrivateProjectConfigAsync: import("../../commandUtils/context/DynamicProjectConfigContextField").DynamicPrivateProjectConfigContextField;
+    };
+    runAsync(): Promise<void>;
+}