eas-cli 16.15.0 → 16.16.0

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

@@ -0,0 +1,2 @@
+import { WorkflowJobResult } from './types';
+export declare function fetchRawLogsForJobAsync(job: WorkflowJobResult): Promise<string | null>;

package/build/commandUtils/workflow/fetchLogs.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchRawLogsForJobAsync = void 0;
+// This function is in a separate module for testing purposes
+async function fetchRawLogsForJobAsync(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;
+}
+exports.fetchRawLogsForJobAsync = fetchRawLogsForJobAsync;

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.moveToWorkflowSelectionErrorState = exports.moveToWorkflowSelectionFinishedState = exports.moveToWorkflowStepSelectionState = exports.moveToWorkflowJobSelectionState = exports.moveToWorkflowRunSelectionState = exports.moveToNewWorkflowCommandSelectionState = exports.WorkflowCommandSelectionStateValue = void 0;
+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,
+    };
+}
+exports.moveToNewWorkflowCommandSelectionState = moveToNewWorkflowCommandSelectionState;
+function moveToWorkflowRunSelectionState(previousState, params) {
+    return moveToNewWorkflowCommandSelectionState(previousState, WorkflowCommandSelectionStateValue.WORKFLOW_RUN_SELECTION, {
+        runId: params?.runId,
+        jobId: undefined,
+    });
+}
+exports.moveToWorkflowRunSelectionState = moveToWorkflowRunSelectionState;
+function moveToWorkflowJobSelectionState(previousState, params) {
+    return moveToNewWorkflowCommandSelectionState(previousState, WorkflowCommandSelectionStateValue.WORKFLOW_JOB_SELECTION, params);
+}
+exports.moveToWorkflowJobSelectionState = moveToWorkflowJobSelectionState;
+function moveToWorkflowStepSelectionState(previousState, params) {
+    return moveToNewWorkflowCommandSelectionState(previousState, WorkflowCommandSelectionStateValue.WORKFLOW_STEP_SELECTION, params);
+}
+exports.moveToWorkflowStepSelectionState = moveToWorkflowStepSelectionState;
+function moveToWorkflowSelectionFinishedState(previousState, params) {
+    return moveToNewWorkflowCommandSelectionState(previousState, WorkflowCommandSelectionStateValue.FINISH, params);
+}
+exports.moveToWorkflowSelectionFinishedState = moveToWorkflowSelectionFinishedState;
+function moveToWorkflowSelectionErrorState(previousState, message) {
+    return moveToNewWorkflowCommandSelectionState(previousState, WorkflowCommandSelectionStateValue.ERROR, {
+        message,
+    });
+}
+exports.moveToWorkflowSelectionErrorState = moveToWorkflowSelectionErrorState;
+// 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.processLogsFromJobAsync)(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,39 @@
+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;
+};
+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 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,12 @@
+import { WorkflowJobResult, WorkflowLogs, WorkflowRunResult, WorkflowTriggerType } from './types';
+import { WorkflowRunFragment } from '../../graphql/generated';
+import { Choice } from '../../prompts';
+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[];
+export declare function processWorkflowRuns(runs: WorkflowRunFragment[]): WorkflowRunResult[];
+export declare function processLogsFromJobAsync(job: WorkflowJobResult): Promise<WorkflowLogs | null>;

package/build/commandUtils/workflow/utils.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processLogsFromJobAsync = exports.processWorkflowRuns = exports.choicesFromWorkflowLogs = exports.choiceFromWorkflowJob = exports.choiceFromWorkflowRun = exports.computeTriggerInfoForWorkflowRun = void 0;
+const fetchLogs_1 = require("./fetchLogs");
+const types_1 = require("./types");
+const generated_1 = require("../../graphql/generated");
+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 };
+}
+exports.computeTriggerInfoForWorkflowRun = computeTriggerInfoForWorkflowRun;
+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] ?? ''}`,
+    };
+}
+exports.choiceFromWorkflowRun = choiceFromWorkflowRun;
+function choiceFromWorkflowJob(job, index) {
+    return {
+        title: `${job.name} - ${job.status}`,
+        value: index,
+        description: `ID: ${job.id}`,
+    };
+}
+exports.choiceFromWorkflowJob = choiceFromWorkflowJob;
+function choicesFromWorkflowLogs(logs) {
+    return Array.from(logs.keys()).map(step => {
+        const logLines = logs.get(step);
+        const stepStatus = logLines?.filter((line) => line.marker === 'end-step')[0]?.result ?? '';
+        return {
+            title: `${step} - ${stepStatus}`,
+            value: step,
+        };
+    });
+}
+exports.choicesFromWorkflowLogs = choicesFromWorkflowLogs;
+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,
+        };
+    });
+}
+exports.processWorkflowRuns = processWorkflowRuns;
+async function processLogsFromJobAsync(job) {
+    const rawLogs = await (0, fetchLogs_1.fetchRawLogsForJobAsync)(job);
+    if (!rawLogs) {
+        return null;
+    }
+    const logs = new Map();
+    const logKeys = new Set();
+    rawLogs.split('\n').forEach(line => {
+        try {
+            const parsedLine = JSON.parse(line);
+            const { result, marker } = parsedLine;
+            const { buildStepDisplayName, buildStepInternalId, time, msg } = parsedLine;
+            const stepId = buildStepDisplayName ?? buildStepInternalId;
+            if (stepId) {
+                if (!logKeys.has(stepId)) {
+                    logKeys.add(stepId);
+                    logs.set(stepId, []);
+                }
+                logs.get(stepId)?.push({ time, msg, result, marker });
+            }
+        }
+        catch { }
+    });
+    return logs;
+}
+exports.processLogsFromJobAsync = processLogsFromJobAsync;

package/build/commands/workflow/cancel.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
 const EasCommand_1 = tslib_1.__importDefault(require("../../commandUtils/EasCommand"));
 const flags_1 = require("../../commandUtils/flags");
-const workflows_1 = require("../../commandUtils/workflows");
+const utils_1 = require("../../commandUtils/workflow/utils");
 const generated_1 = require("../../graphql/generated");
 const WorkflowRunMutation_1 = require("../../graphql/mutations/WorkflowRunMutation");
 const AppQuery_1 = require("../../graphql/queries/AppQuery");
@@ -44,7 +44,7 @@ class WorkflowRunCancel extends EasCommand_1.default {
             }
             // Run the workflow run list query and select runs to cancel
             const queryResult = await AppQuery_1.AppQuery.byIdWorkflowRunsFilteredByStatusAsync(graphqlClient, projectId, generated_1.WorkflowRunStatus.InProgress, 50);
-            const runs = (0, workflows_1.processWorkflowRuns)(queryResult);
+            const runs = (0, utils_1.processWorkflowRuns)(queryResult);
             if (runs.length === 0) {
                 log_1.default.warn('No workflow runs to cancel');
                 return;
@@ -53,10 +53,7 @@ class WorkflowRunCancel extends EasCommand_1.default {
                 type: 'multiselect',
                 name: 'selectedRuns',
                 message: 'Select IN_PROGRESS workflow runs to cancel',
-                choices: runs.map(run => ({
-                    title: `${run.id} - ${run.workflowFileName}, ${run.gitCommitMessage ?? ''}, ${run.startedAt}`,
-                    value: run.id,
-                })),
+                choices: runs.map(run => (0, utils_1.choiceFromWorkflowRun)(run)),
             });
             answers.selectedRuns.forEach((id) => {
                 workflowRunIds.add(id);

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

@@ -0,0 +1,18 @@
+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: {
+        name: string;
+        description: string;
+    }[];
+    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,94 @@
+"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 = [
+        { name: 'id', 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;