@donotuse/eas-cli 18.5.0-rc.1

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

@@ -0,0 +1,6 @@
+import { WorkflowJobResult } from './types';
+import { ExpoGraphqlClient } from '../context/contextUtils/createGraphqlClient';
+export declare function fetchRawLogsForCustomJobAsync(job: WorkflowJobResult): Promise<string | null>;
+export declare function fetchRawLogsForBuildJobAsync(state: {
+    graphqlClient: ExpoGraphqlClient;
+}, job: WorkflowJobResult): Promise<string | null>;

package/build/commandUtils/workflow/fetchLogs.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchRawLogsForCustomJobAsync = fetchRawLogsForCustomJobAsync;
+exports.fetchRawLogsForBuildJobAsync = fetchRawLogsForBuildJobAsync;
+const BuildQuery_1 = require("../../graphql/queries/BuildQuery");
+// This function is in a separate module for testing purposes
+async function fetchRawLogsForCustomJobAsync(job) {
+    const firstLogFileUrl = job.turtleJobRun?.logFileUrls?.[0];
+    if (!firstLogFileUrl) {
+        return null;
+    }
+    const response = await fetch(firstLogFileUrl, {
+        method: 'GET',
+    });
+    const rawLogs = await response.text();
+    return rawLogs;
+}
+async function fetchRawLogsForBuildJobAsync(state, job) {
+    // Prefer turtleJobRun logs, which contain JSONL-formatted step logs
+    // for both built-in and custom build steps
+    const turtleLogFileUrl = job.turtleJobRun?.logFileUrls?.[0];
+    if (turtleLogFileUrl) {
+        const response = await fetch(turtleLogFileUrl, {
+            method: 'GET',
+        });
+        return await response.text();
+    }
+    // Fall back to build logFiles
+    const buildId = job.outputs?.build_id;
+    if (!buildId) {
+        return null;
+    }
+    const buildFragment = await BuildQuery_1.BuildQuery.byIdAsync(state.graphqlClient, buildId, {
+        useCache: false,
+    });
+    const firstLogFileUrl = buildFragment.logFiles?.[0];
+    if (!firstLogFileUrl) {
+        return null;
+    }
+    const response = await fetch(firstLogFileUrl, {
+        method: 'GET',
+    });
+    return await response.text();
+}

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

@@ -0,0 +1,40 @@
+import { z } from 'zod';
+import { DefaultEnvironment } from '../../build/utils/environment';
+export declare const WorkflowDispatchInputZ: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodOptional<z.ZodDefault<z.ZodLiteral<"string">>>;
+    default: z.ZodOptional<z.ZodCodec<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodString>>;
+    description: z.ZodOptional<z.ZodCodec<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodString>>;
+    required: z.ZodOptional<z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodCodec<z.ZodNumber, z.ZodBoolean>, z.ZodCodec<z.ZodString, z.ZodBoolean>]>>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"boolean">;
+    default: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodCodec<z.ZodNumber, z.ZodBoolean>, z.ZodCodec<z.ZodString, z.ZodBoolean>]>>;
+    description: z.ZodOptional<z.ZodCodec<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodString>>;
+    required: z.ZodOptional<z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodCodec<z.ZodNumber, z.ZodBoolean>, z.ZodCodec<z.ZodString, z.ZodBoolean>]>>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"number">;
+    default: z.ZodOptional<z.ZodNumber>;
+    description: z.ZodOptional<z.ZodCodec<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodString>>;
+    required: z.ZodOptional<z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodCodec<z.ZodNumber, z.ZodBoolean>, z.ZodCodec<z.ZodString, z.ZodBoolean>]>>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"choice">;
+    default: z.ZodOptional<z.ZodCodec<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodString>>;
+    options: z.ZodArray<z.ZodCodec<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodString>>;
+    description: z.ZodOptional<z.ZodCodec<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodString>>;
+    required: z.ZodOptional<z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodCodec<z.ZodNumber, z.ZodBoolean>, z.ZodCodec<z.ZodString, z.ZodBoolean>]>>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"environment">;
+    default: z.ZodOptional<z.ZodEnum<{
+        development: DefaultEnvironment.Development;
+        preview: DefaultEnvironment.Preview;
+        production: DefaultEnvironment.Production;
+    }>>;
+    description: z.ZodOptional<z.ZodCodec<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodString>>;
+    required: z.ZodOptional<z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodCodec<z.ZodNumber, z.ZodBoolean>, z.ZodCodec<z.ZodString, z.ZodBoolean>]>>>;
+}, z.core.$strip>], "type">;
+export declare function parseInputs(inputFlags: string[]): Record<string, string>;
+export declare function parseJsonInputs(jsonString: string): Record<string, string>;
+export declare function parseWorkflowInputsFromYaml(yamlConfig: string): Record<string, z.infer<typeof WorkflowDispatchInputZ>>;
+export declare function maybePromptForMissingInputsAsync({ inputSpecs, inputs, }: {
+    inputSpecs: Record<string, z.infer<typeof WorkflowDispatchInputZ>>;
+    inputs: Record<string, unknown>;
+}): Promise<Record<string, unknown>>;

package/build/commandUtils/workflow/inputs.js

@@ -0,0 +1,165 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkflowDispatchInputZ = void 0;
+exports.parseInputs = parseInputs;
+exports.parseJsonInputs = parseJsonInputs;
+exports.parseWorkflowInputsFromYaml = parseWorkflowInputsFromYaml;
+exports.maybePromptForMissingInputsAsync = maybePromptForMissingInputsAsync;
+const tslib_1 = require("tslib");
+const zod_1 = require("zod");
+const environment_1 = require("../../build/utils/environment");
+const types_1 = require("../../credentials/ios/types");
+const log_1 = tslib_1.__importDefault(require("../../log"));
+const prompts_1 = require("../../prompts");
+const parse_1 = require("./parse");
+const inputExtraProperties = {
+    description: types_1.stringLike.optional().describe('Description of the input'),
+    required: types_1.booleanLike.default(false).optional().describe('Whether the input is required.'),
+};
+// Adapted from the input definition on the server (https://github.com/expo/universe/pull/21950)
+exports.WorkflowDispatchInputZ = zod_1.z.discriminatedUnion('type', [
+    zod_1.z.object({
+        ...inputExtraProperties,
+        type: zod_1.z.literal('string').default('string').optional(),
+        default: types_1.stringLike.optional().describe('Default value for the input'),
+    }),
+    zod_1.z.object({
+        ...inputExtraProperties,
+        type: zod_1.z.literal('boolean'),
+        default: types_1.booleanLike.optional().describe('Default value for the input'),
+    }),
+    zod_1.z.object({
+        ...inputExtraProperties,
+        type: zod_1.z.literal('number'),
+        default: zod_1.z.number().optional().describe('Default value for the input'),
+    }),
+    zod_1.z.object({
+        ...inputExtraProperties,
+        type: zod_1.z.literal('choice'),
+        default: types_1.stringLike.optional().describe('Default value for the input'),
+        options: zod_1.z.array(types_1.stringLike).min(1).describe('Options for choice type inputs'),
+    }),
+    zod_1.z.object({
+        ...inputExtraProperties,
+        type: zod_1.z.literal('environment'),
+        default: zod_1.z
+            .enum(Object.values(environment_1.DefaultEnvironment))
+            .optional()
+            .describe('Default value for the input'),
+    }),
+]);
+function parseInputs(inputFlags) {
+    const inputs = {};
+    for (const inputFlag of inputFlags) {
+        const equalIndex = inputFlag.indexOf('=');
+        if (equalIndex === -1) {
+            throw new Error(`Invalid input format: ${inputFlag}. Expected key=value format.`);
+        }
+        const key = inputFlag.substring(0, equalIndex);
+        const value = inputFlag.substring(equalIndex + 1);
+        if (!key) {
+            throw new Error(`Invalid input format: ${inputFlag}. Key cannot be empty.`);
+        }
+        inputs[key] = value;
+    }
+    return inputs;
+}
+function parseJsonInputs(jsonString) {
+    try {
+        const parsed = JSON.parse(jsonString);
+        if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+            throw new Error('JSON input must be an object.');
+        }
+        return parsed;
+    }
+    catch (error) {
+        throw new Error(`Invalid JSON input.`, { cause: error });
+    }
+}
+function parseWorkflowInputsFromYaml(yamlConfig) {
+    try {
+        const parsed = (0, parse_1.parsedYamlFromWorkflowContents)({ yamlConfig });
+        return zod_1.z
+            .record(zod_1.z.string(), exports.WorkflowDispatchInputZ)
+            .default({})
+            .parse(parsed?.on?.workflow_dispatch?.inputs);
+    }
+    catch (error) {
+        log_1.default.warn('Failed to parse workflow inputs from YAML:', error);
+        return {};
+    }
+}
+async function maybePromptForMissingInputsAsync({ inputSpecs, inputs, }) {
+    const requiredInputs = Object.entries(inputSpecs).filter(([_, spec]) => spec.required);
+    const missingRequiredInputs = requiredInputs.filter(([key]) => inputs[key] === undefined);
+    if (missingRequiredInputs.length === 0) {
+        return inputs;
+    }
+    log_1.default.addNewLineIfNone();
+    log_1.default.log('Some required inputs are missing. Please provide them:');
+    const nextInputs = { ...inputs };
+    for (const [key, spec] of missingRequiredInputs) {
+        const value = await promptForMissingInputAsync({ key, spec });
+        nextInputs[key] = value;
+    }
+    return nextInputs;
+}
+async function promptForMissingInputAsync({ key, spec, }) {
+    const message = spec.description ? `${key} (${spec.description})` : key;
+    switch (spec.type) {
+        case 'boolean': {
+            const { value } = await (0, prompts_1.promptAsync)({
+                type: 'confirm',
+                name: 'value',
+                message,
+                initial: spec.default,
+            });
+            return value;
+        }
+        case 'number': {
+            const { value } = await (0, prompts_1.promptAsync)({
+                type: 'number',
+                name: 'value',
+                message,
+                initial: spec.default,
+                validate: (val) => {
+                    if (isNaN(val)) {
+                        return 'Please enter a valid number';
+                    }
+                    return true;
+                },
+            });
+            return value;
+        }
+        case 'choice': {
+            const { value } = await (0, prompts_1.promptAsync)({
+                type: 'select',
+                name: 'value',
+                message,
+                choices: spec.options.map(option => ({
+                    title: option,
+                    value: option,
+                })),
+                initial: spec.default,
+            });
+            return value;
+        }
+        case 'string':
+        case 'environment':
+        default: {
+            const { value } = await (0, prompts_1.promptAsync)({
+                type: 'text',
+                name: 'value',
+                message,
+                initial: spec.default,
+                validate: (val) => {
+                    if (spec.required && (!val || val.trim() === '')) {
+                        return 'This field is required';
+                    }
+                    return true;
+                },
+            });
+            return value;
+        }
+    }
+}

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

@@ -0,0 +1,3 @@
+export declare function parsedYamlFromWorkflowContents(workflowFileContents: {
+    yamlConfig: string;
+}): any;

package/build/commandUtils/workflow/parse.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parsedYamlFromWorkflowContents = parsedYamlFromWorkflowContents;
+const tslib_1 = require("tslib");
+const YAML = tslib_1.__importStar(require("yaml"));
+function parsedYamlFromWorkflowContents(workflowFileContents) {
+    return YAML.parse(workflowFileContents.yamlConfig, {
+        // Keep in sync with backend parser options.
+        merge: true,
+        maxAliasCount: 50,
+    });
+}

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

@@ -0,0 +1,44 @@
+import { WorkflowJobResult, WorkflowLogs } from './types';
+import { ExpoGraphqlClient } from '../context/contextUtils/createGraphqlClient';
+export declare enum WorkflowCommandSelectionStateValue {
+    WORKFLOW_RUN_SELECTION = "WORKFLOW_RUN_SELECTION",
+    WORKFLOW_JOB_SELECTION = "WORKFLOW_JOB_SELECTION",
+    WORKFLOW_STEP_SELECTION = "WORKFLOW_STEP_SELECTION",
+    FINISH = "FINISH",
+    ERROR = "ERROR"
+}
+export type WorkflowCommandSelectionState = {
+    graphqlClient: ExpoGraphqlClient;
+    projectId: string;
+    nonInteractive: boolean;
+    allSteps: boolean;
+    state: WorkflowCommandSelectionStateValue;
+    runId?: string;
+    jobId?: string;
+    step?: string;
+    job?: WorkflowJobResult;
+    logs?: WorkflowLogs | null;
+    message?: string;
+};
+export type WorkflowCommandSelectionStateParameters = Omit<WorkflowCommandSelectionState, 'graphqlClient' | 'projectId' | 'state' | 'nonInteractive' | 'allSteps'>;
+export type WorkflowCommandSelectionAction = (prevState: WorkflowCommandSelectionState) => Promise<WorkflowCommandSelectionState>;
+export declare function moveToNewWorkflowCommandSelectionState(previousState: WorkflowCommandSelectionState, newStateValue: WorkflowCommandSelectionStateValue, parameters: WorkflowCommandSelectionStateParameters): WorkflowCommandSelectionState;
+export declare function moveToWorkflowRunSelectionState(previousState: WorkflowCommandSelectionState, params?: {
+    runId?: string | undefined;
+}): WorkflowCommandSelectionState;
+export declare function moveToWorkflowJobSelectionState(previousState: WorkflowCommandSelectionState, params: {
+    jobId?: string | undefined;
+    runId?: string | undefined;
+}): WorkflowCommandSelectionState;
+export declare function moveToWorkflowStepSelectionState(previousState: WorkflowCommandSelectionState, params: {
+    job: WorkflowJobResult;
+}): WorkflowCommandSelectionState;
+export declare function moveToWorkflowSelectionFinishedState(previousState: WorkflowCommandSelectionState, params: {
+    step: string;
+    logs: WorkflowLogs;
+}): WorkflowCommandSelectionState;
+export declare function moveToWorkflowSelectionErrorState(previousState: WorkflowCommandSelectionState, message: string): WorkflowCommandSelectionState;
+export declare const workflowRunSelectionAction: WorkflowCommandSelectionAction;
+export declare const workflowJobSelectionAction: WorkflowCommandSelectionAction;
+export declare const workflowStepSelectionAction: WorkflowCommandSelectionAction;
+export declare const executeWorkflowSelectionActionsAsync: WorkflowCommandSelectionAction;

package/build/commandUtils/workflow/stateMachine.js

@@ -0,0 +1,212 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeWorkflowSelectionActionsAsync = exports.workflowStepSelectionAction = exports.workflowJobSelectionAction = exports.workflowRunSelectionAction = exports.WorkflowCommandSelectionStateValue = void 0;
+exports.moveToNewWorkflowCommandSelectionState = moveToNewWorkflowCommandSelectionState;
+exports.moveToWorkflowRunSelectionState = moveToWorkflowRunSelectionState;
+exports.moveToWorkflowJobSelectionState = moveToWorkflowJobSelectionState;
+exports.moveToWorkflowStepSelectionState = moveToWorkflowStepSelectionState;
+exports.moveToWorkflowSelectionFinishedState = moveToWorkflowSelectionFinishedState;
+exports.moveToWorkflowSelectionErrorState = moveToWorkflowSelectionErrorState;
+const tslib_1 = require("tslib");
+const utils_1 = require("./utils");
+const AppQuery_1 = require("../../graphql/queries/AppQuery");
+const WorkflowJobQuery_1 = require("../../graphql/queries/WorkflowJobQuery");
+const WorkflowRunQuery_1 = require("../../graphql/queries/WorkflowRunQuery");
+const log_1 = tslib_1.__importDefault(require("../../log"));
+const prompts_1 = require("../../prompts");
+/*
+ * State machine types and functions for moving between different workflow command states
+ */
+var WorkflowCommandSelectionStateValue;
+(function (WorkflowCommandSelectionStateValue) {
+    WorkflowCommandSelectionStateValue["WORKFLOW_RUN_SELECTION"] = "WORKFLOW_RUN_SELECTION";
+    WorkflowCommandSelectionStateValue["WORKFLOW_JOB_SELECTION"] = "WORKFLOW_JOB_SELECTION";
+    WorkflowCommandSelectionStateValue["WORKFLOW_STEP_SELECTION"] = "WORKFLOW_STEP_SELECTION";
+    WorkflowCommandSelectionStateValue["FINISH"] = "FINISH";
+    WorkflowCommandSelectionStateValue["ERROR"] = "ERROR";
+})(WorkflowCommandSelectionStateValue || (exports.WorkflowCommandSelectionStateValue = WorkflowCommandSelectionStateValue = {}));
+const workflowCommandSelectionAllowedStateTransitions = {
+    WORKFLOW_JOB_SELECTION: [
+        WorkflowCommandSelectionStateValue.WORKFLOW_STEP_SELECTION,
+        WorkflowCommandSelectionStateValue.WORKFLOW_RUN_SELECTION,
+        WorkflowCommandSelectionStateValue.ERROR,
+        WorkflowCommandSelectionStateValue.FINISH,
+    ],
+    WORKFLOW_RUN_SELECTION: [
+        WorkflowCommandSelectionStateValue.WORKFLOW_JOB_SELECTION,
+        WorkflowCommandSelectionStateValue.ERROR,
+    ],
+    WORKFLOW_STEP_SELECTION: [
+        WorkflowCommandSelectionStateValue.WORKFLOW_JOB_SELECTION,
+        WorkflowCommandSelectionStateValue.ERROR,
+        WorkflowCommandSelectionStateValue.FINISH,
+    ],
+    ERROR: [WorkflowCommandSelectionStateValue.WORKFLOW_RUN_SELECTION],
+    FINISH: [],
+};
+function moveToNewWorkflowCommandSelectionState(previousState, newStateValue, parameters) {
+    if (!workflowCommandSelectionAllowedStateTransitions[previousState.state].includes(newStateValue)) {
+        const errorMessage = `Invalid state transition from ${previousState.state} to ${newStateValue}. Allowed transitions from ${previousState.state}: ${workflowCommandSelectionAllowedStateTransitions[previousState.state].join(', ')}`;
+        throw new Error(errorMessage);
+    }
+    return {
+        ...previousState,
+        state: newStateValue,
+        ...parameters,
+    };
+}
+function moveToWorkflowRunSelectionState(previousState, params) {
+    return moveToNewWorkflowCommandSelectionState(previousState, WorkflowCommandSelectionStateValue.WORKFLOW_RUN_SELECTION, {
+        runId: params?.runId,
+        jobId: undefined,
+    });
+}
+function moveToWorkflowJobSelectionState(previousState, params) {
+    return moveToNewWorkflowCommandSelectionState(previousState, WorkflowCommandSelectionStateValue.WORKFLOW_JOB_SELECTION, params);
+}
+function moveToWorkflowStepSelectionState(previousState, params) {
+    return moveToNewWorkflowCommandSelectionState(previousState, WorkflowCommandSelectionStateValue.WORKFLOW_STEP_SELECTION, params);
+}
+function moveToWorkflowSelectionFinishedState(previousState, params) {
+    return moveToNewWorkflowCommandSelectionState(previousState, WorkflowCommandSelectionStateValue.FINISH, params);
+}
+function moveToWorkflowSelectionErrorState(previousState, message) {
+    return moveToNewWorkflowCommandSelectionState(previousState, WorkflowCommandSelectionStateValue.ERROR, {
+        message,
+    });
+}
+// eslint-disable-next-line async-protect/async-suffix
+const workflowRunSelectionAction = async (prevState) => {
+    const { graphqlClient, projectId, runId, jobId, allSteps } = prevState;
+    log_1.default.debug(`workflowRunSelectionAction: runId = ${runId}, jobId = ${jobId}, allSteps = ${allSteps}`);
+    if (runId) {
+        return moveToWorkflowJobSelectionState(prevState, { runId });
+    }
+    const runs = await AppQuery_1.AppQuery.byIdWorkflowRunsFilteredByStatusAsync(graphqlClient, projectId, undefined, 20);
+    if (runs.length === 0) {
+        return moveToWorkflowSelectionErrorState(prevState, 'No workflow runs found');
+    }
+    const processedRuns = (0, utils_1.processWorkflowRuns)(runs);
+    const choices = processedRuns.map(run => (0, utils_1.choiceFromWorkflowRun)(run));
+    const selectedId = (await (0, prompts_1.promptAsync)({
+        type: 'select',
+        name: 'selectedRun',
+        message: 'Select a workflow run:',
+        choices,
+    })).selectedRun;
+    return moveToWorkflowJobSelectionState(prevState, { runId: selectedId });
+};
+exports.workflowRunSelectionAction = workflowRunSelectionAction;
+// eslint-disable-next-line async-protect/async-suffix
+const workflowJobSelectionAction = async (prevState) => {
+    const { graphqlClient, runId, jobId, nonInteractive, allSteps } = prevState;
+    log_1.default.debug(`workflowJobSelectionAction: runId = ${runId}, jobId = ${jobId}, allSteps = ${allSteps}`);
+    if (jobId) {
+        let workflowJobResult = undefined;
+        try {
+            workflowJobResult = await WorkflowJobQuery_1.WorkflowJobQuery.byIdAsync(graphqlClient, jobId, {
+                useCache: false,
+            });
+            return moveToWorkflowStepSelectionState(prevState, { job: workflowJobResult });
+        }
+        catch { }
+        if (nonInteractive && !workflowJobResult) {
+            return moveToWorkflowSelectionErrorState(prevState, 'No workflow job found that matched the provided ID');
+        }
+        else {
+            // The passed in ID may be a run ID, pass it back to run selection action
+            return moveToWorkflowRunSelectionState(prevState, { runId: jobId });
+        }
+    }
+    else {
+        // No job ID was passed in
+        if (nonInteractive) {
+            return moveToWorkflowSelectionErrorState(prevState, 'No workflow job ID provided in non-interactive mode');
+        }
+        else if (!runId) {
+            // If no jobId or runId, we should go back to run selection
+            return moveToWorkflowRunSelectionState(prevState);
+        }
+        const workflowRunResult = await WorkflowRunQuery_1.WorkflowRunQuery.withJobsByIdAsync(graphqlClient, runId, {
+            useCache: false,
+        });
+        if (!workflowRunResult) {
+            return moveToWorkflowSelectionErrorState(prevState, 'No workflow run found that matched the provided ID');
+        }
+        const choices = [
+            ...workflowRunResult.jobs.map((job, i) => (0, utils_1.choiceFromWorkflowJob)(job, i)),
+            {
+                title: 'Go back and select a different workflow run',
+                value: -1,
+            },
+        ];
+        const selectedJobIndex = (await (0, prompts_1.promptAsync)({
+            type: 'select',
+            name: 'selectedJob',
+            message: 'Select a job:',
+            choices,
+        })).selectedJob;
+        if (selectedJobIndex === -1) {
+            return moveToWorkflowRunSelectionState(prevState);
+        }
+        const selectedJob = workflowRunResult.jobs[selectedJobIndex];
+        return moveToWorkflowStepSelectionState(prevState, { job: selectedJob });
+    }
+};
+exports.workflowJobSelectionAction = workflowJobSelectionAction;
+// eslint-disable-next-line async-protect/async-suffix
+const workflowStepSelectionAction = async (prevState) => {
+    const { job, allSteps } = prevState;
+    log_1.default.debug(`workflowStepSelectionAction: job = ${job?.id}, allSteps = ${allSteps}`);
+    if (!job) {
+        return moveToWorkflowSelectionErrorState(prevState, 'No job found');
+    }
+    const logs = await (0, utils_1.fetchAndProcessLogsFromJobAsync)(prevState, job);
+    if (!logs) {
+        return moveToWorkflowSelectionErrorState(prevState, 'No logs found');
+    }
+    if (allSteps) {
+        return moveToWorkflowSelectionFinishedState(prevState, { step: '', logs });
+    }
+    const choices = [
+        ...(0, utils_1.choicesFromWorkflowLogs)(logs),
+        {
+            title: 'Go back and select a different workflow job',
+            value: 'go-back',
+        },
+    ];
+    const selectedStep = (await (0, prompts_1.promptAsync)({
+        type: 'select',
+        name: 'selectedStep',
+        message: 'Select a step:',
+        choices,
+    })).selectedStep ?? '';
+    if (selectedStep === 'go-back') {
+        return moveToWorkflowJobSelectionState(prevState, {
+            runId: job.workflowRun.id,
+            jobId: undefined,
+        });
+    }
+    return moveToWorkflowSelectionFinishedState(prevState, { step: selectedStep, logs });
+};
+exports.workflowStepSelectionAction = workflowStepSelectionAction;
+const executeWorkflowSelectionActionsAsync = async (prevState) => {
+    let currentState = prevState;
+    while (currentState.state !== WorkflowCommandSelectionStateValue.FINISH &&
+        currentState.state !== WorkflowCommandSelectionStateValue.ERROR) {
+        log_1.default.debug(`${currentState.state}`);
+        switch (currentState.state) {
+            case WorkflowCommandSelectionStateValue.WORKFLOW_JOB_SELECTION:
+                currentState = await (0, exports.workflowJobSelectionAction)(currentState);
+                break;
+            case WorkflowCommandSelectionStateValue.WORKFLOW_RUN_SELECTION:
+                currentState = await (0, exports.workflowRunSelectionAction)(currentState);
+                break;
+            case WorkflowCommandSelectionStateValue.WORKFLOW_STEP_SELECTION:
+                currentState = await (0, exports.workflowStepSelectionAction)(currentState);
+                break;
+        }
+    }
+    return currentState;
+};
+exports.executeWorkflowSelectionActionsAsync = executeWorkflowSelectionActionsAsync;

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

@@ -0,0 +1,40 @@
+import { WorkflowJobByIdQuery, WorkflowRunByIdWithJobsQuery } from '../../graphql/generated';
+export declare enum WorkflowTriggerType {
+    MANUAL = "Manual",
+    GITHUB = "GitHub",
+    SCHEDULED = "Scheduled",
+    OTHER = "Other"
+}
+export type WorkflowRunResult = {
+    id: string;
+    status: string;
+    gitCommitMessage: string | null;
+    gitCommitHash: string | null;
+    triggerType: WorkflowTriggerType;
+    trigger: string | null;
+    startedAt: string;
+    finishedAt: string;
+    workflowId: string;
+    workflowName: string | null;
+    workflowFileName: string;
+};
+export type WorkflowResult = {
+    id: string;
+    name?: string | null | undefined;
+    fileName: string;
+    createdAt: string;
+    updatedAt: string;
+};
+export type WorkflowJobResult = WorkflowRunByIdWithJobsQuery['workflowRuns']['byId']['jobs'][number] | WorkflowJobByIdQuery['workflowJobs']['byId'];
+export type WorkflowRunWithJobsResult = WorkflowRunResult & {
+    jobs: WorkflowJobResult[];
+    logs?: string;
+};
+export type WorkflowLogLine = {
+    time: string;
+    msg: string;
+    result?: string;
+    marker?: string;
+    err?: any;
+};
+export type WorkflowLogs = Map<string, WorkflowLogLine[]>;

package/build/commandUtils/workflow/types.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkflowTriggerType = void 0;
+/*
+ * Utility types and Zod definitions for workflow commands
+ */
+var WorkflowTriggerType;
+(function (WorkflowTriggerType) {
+    WorkflowTriggerType["MANUAL"] = "Manual";
+    WorkflowTriggerType["GITHUB"] = "GitHub";
+    WorkflowTriggerType["SCHEDULED"] = "Scheduled";
+    WorkflowTriggerType["OTHER"] = "Other";
+})(WorkflowTriggerType || (exports.WorkflowTriggerType = WorkflowTriggerType = {}));

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

@@ -0,0 +1,33 @@
+import { WorkflowJobResult, WorkflowLogLine, WorkflowLogs, WorkflowRunResult, WorkflowTriggerType } from './types';
+import { WorkflowRunByIdQuery, WorkflowRunByIdWithJobsQuery, WorkflowRunFragment } from '../../graphql/generated';
+import { Choice } from '../../prompts';
+import { ExpoGraphqlClient } from '../context/contextUtils/createGraphqlClient';
+export declare function computeTriggerInfoForWorkflowRun(run: WorkflowRunFragment): {
+    triggerType: WorkflowTriggerType;
+    trigger: string | null;
+};
+export declare function choiceFromWorkflowRun(run: WorkflowRunResult): Choice;
+export declare function choiceFromWorkflowJob(job: WorkflowJobResult, index: number): Choice;
+export declare function choicesFromWorkflowLogs(logs: WorkflowLogs): (Choice & {
+    name: string;
+    status: string;
+    logLines: WorkflowLogLine[] | undefined;
+})[];
+export declare function processWorkflowRuns(runs: WorkflowRunFragment[]): WorkflowRunResult[];
+export declare function fetchAndProcessLogsFromJobAsync(state: {
+    graphqlClient: ExpoGraphqlClient;
+}, job: WorkflowJobResult): Promise<WorkflowLogs | null>;
+export declare function infoForActiveWorkflowRunAsync(graphqlClient: ExpoGraphqlClient, workflowRun: WorkflowRunByIdWithJobsQuery['workflowRuns']['byId'], maxLogLines?: number): Promise<string>;
+export declare function infoForFailedWorkflowRunAsync(graphqlClient: ExpoGraphqlClient, workflowRun: WorkflowRunByIdWithJobsQuery['workflowRuns']['byId'], maxLogLines?: number): Promise<string>;
+export declare function fileExistsAsync(filePath: string): Promise<boolean>;
+export declare function maybeReadStdinAsync(): Promise<string | null>;
+export declare function showWorkflowStatusAsync(graphqlClient: ExpoGraphqlClient, { workflowRunId, spinnerUsesStdErr, waitForCompletion, }: {
+    workflowRunId: string;
+    spinnerUsesStdErr: boolean;
+    waitForCompletion?: boolean;
+}): Promise<WorkflowRunByIdQuery['workflowRuns']['byId']>;
+export declare const workflowRunExitCodes: {
+    WORKFLOW_FAILED: number;
+    WORKFLOW_CANCELED: number;
+    WAIT_ABORTED: number;
+};