eas-cli 16.14.1 → 16.16.0

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;

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

@@ -1,3 +1,45 @@
+/**
+ * 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 { z } from 'zod';
 import EasCommand from '../../commandUtils/EasCommand';
 export default class WorkflowRun extends EasCommand {
     static description: string;
@@ -8,6 +50,7 @@ export default class WorkflowRun extends EasCommand {
     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>;
         'non-interactive': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
     };
     static contextDefinition: {
@@ -19,3 +62,65 @@ export default class WorkflowRun extends EasCommand {
     };
     runAsync(): Promise<void>;
 }
+export declare function parseInputs(inputFlags: string[]): Record<string, string>;
+export declare function maybeReadStdinAsync(): Promise<string | null>;
+export declare function parseJsonInputs(jsonString: string): Record<string, string>;
+export declare const WorkflowDispatchInputZ: z.ZodIntersection<z.ZodObject<{
+    description: z.ZodOptional<z.ZodPipeline<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodString>>;
+    required: z.ZodDefault<z.ZodUnion<[z.ZodBoolean, z.ZodPipeline<z.ZodNumber, z.ZodBoolean>, z.ZodEffects<z.ZodBoolean, boolean, unknown>]>>;
+}, "strip", z.ZodTypeAny, {
+    required: boolean;
+    description?: string | undefined;
+}, {
+    description?: string | number | undefined;
+    required?: unknown;
+}>, z.ZodUnion<[z.ZodObject<{
+    type: z.ZodDefault<z.ZodLiteral<"string">>;
+    default: z.ZodOptional<z.ZodPipeline<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    type: "string";
+    default?: string | undefined;
+}, {
+    default?: string | number | undefined;
+    type?: "string" | undefined;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"boolean">;
+    default: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodPipeline<z.ZodNumber, z.ZodBoolean>, z.ZodEffects<z.ZodBoolean, boolean, unknown>]>>;
+}, "strip", z.ZodTypeAny, {
+    type: "boolean";
+    default?: boolean | undefined;
+}, {
+    type: "boolean";
+    default?: unknown;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"number">;
+    default: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    type: "number";
+    default?: number | undefined;
+}, {
+    type: "number";
+    default?: number | undefined;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"choice">;
+    default: z.ZodOptional<z.ZodPipeline<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodString>>;
+    options: z.ZodArray<z.ZodPipeline<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodString>, "many">;
+}, "strip", z.ZodTypeAny, {
+    type: "choice";
+    options: string[];
+    default?: string | undefined;
+}, {
+    type: "choice";
+    options: (string | number)[];
+    default?: string | number | undefined;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"environment">;
+    default: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    type: "environment";
+    default?: string | undefined;
+}, {
+    type: "environment";
+    default?: string | undefined;
+}>]>>;
+export declare function parseWorkflowInputsFromYaml(yamlConfig: string): Record<string, z.infer<typeof WorkflowDispatchInputZ>>;

package/build/commands/workflow/run.js

@@ -1,5 +1,47 @@
 "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 });
+exports.parseWorkflowInputsFromYaml = exports.WorkflowDispatchInputZ = exports.parseJsonInputs = exports.maybeReadStdinAsync = exports.parseInputs = void 0;
 const tslib_1 = require("tslib");
 const core_1 = require("@oclif/core");
 const core_2 = require("@urql/core");
@@ -7,6 +49,8 @@ const chalk_1 = tslib_1.__importDefault(require("chalk"));
 const fs = tslib_1.__importStar(require("node:fs"));
 const path = tslib_1.__importStar(require("node:path"));
 const slash_1 = tslib_1.__importDefault(require("slash"));
+const YAML = tslib_1.__importStar(require("yaml"));
+const zod_1 = require("zod");
 const url_1 = require("../../build/utils/url");
 const EasCommand_1 = tslib_1.__importDefault(require("../../commandUtils/EasCommand"));
 const flags_1 = require("../../commandUtils/flags");
@@ -19,6 +63,7 @@ const ora_1 = require("../../ora");
 const projectUtils_1 = require("../../project/projectUtils");
 const uploadAccountScopedFileAsync_1 = require("../../project/uploadAccountScopedFileAsync");
 const uploadAccountScopedProjectSourceAsync_1 = require("../../project/uploadAccountScopedProjectSourceAsync");
+const prompts_1 = require("../../prompts");
 const json_1 = require("../../utils/json");
 const promise_1 = require("../../utils/promise");
 const workflowFile_1 = require("../../utils/workflowFile");
@@ -38,6 +83,13 @@ class WorkflowRun extends EasCommand_1.default {
             description: 'Exit codes: 0 = success, 11 = failure, 12 = canceled, 13 = wait aborted.',
             summary: 'Wait for workflow run to complete',
         }),
+        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',
+        }),
         ...flags_1.EasJsonOnlyFlag,
     };
     static contextDefinition = {
@@ -86,6 +138,33 @@ class WorkflowRun extends EasCommand_1.default {
                 throw error;
             }
         }
+        let inputs;
+        // Check for stdin input
+        const stdinData = await 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 = parseJsonInputs(stdinData);
+        }
+        else if (inputsFromFlags.length > 0) {
+            inputs = parseInputs(inputsFromFlags);
+        }
+        // Parse workflow inputs from YAML and prompt for missing required inputs
+        const inputSpecs = parseWorkflowInputsFromYaml(yamlConfig);
+        if (!flags['non-interactive']) {
+            inputs = await 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;
@@ -134,6 +213,7 @@ class WorkflowRun extends EasCommand_1.default {
                     yamlConfig,
                 },
                 workflowRunInput: {
+                    inputs,
                     projectSource: {
                         type: generated_1.WorkflowProjectSourceType.Gcs,
                         projectArchiveBucketKey,
@@ -226,3 +306,203 @@ async function fileExistsAsync(filePath) {
         .then(() => true)
         .catch(() => false);
 }
+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;
+}
+exports.parseInputs = parseInputs;
+async function maybeReadStdinAsync() {
+    // Check if there's data on stdin
+    if (process.stdin.isTTY) {
+        return null;
+    }
+    return await new Promise((resolve, reject) => {
+        let data = '';
+        process.stdin.setEncoding('utf8');
+        process.stdin.on('readable', () => {
+            let chunk;
+            while ((chunk = process.stdin.read()) !== null) {
+                data += chunk;
+            }
+        });
+        process.stdin.on('end', () => {
+            const trimmedData = data.trim();
+            resolve(trimmedData || null);
+        });
+        process.stdin.on('error', err => {
+            reject(err);
+        });
+    });
+}
+exports.maybeReadStdinAsync = maybeReadStdinAsync;
+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 });
+    }
+}
+exports.parseJsonInputs = parseJsonInputs;
+// `z.coerce.boolean()` does `Boolean(val)` under the hood,
+// which is not what we want. See:
+// https://github.com/colinhacks/zod/issues/2985#issuecomment-2230692578
+const booleanLike = zod_1.z.union([
+    zod_1.z.boolean(),
+    zod_1.z.number().pipe(zod_1.z.coerce.boolean()),
+    zod_1.z.preprocess(val => {
+        if (typeof val === 'string') {
+            if (val.toLowerCase() === 'true') {
+                return true;
+            }
+            if (val.toLowerCase() === 'false') {
+                return false;
+            }
+        }
+        return val;
+    }, zod_1.z.boolean()),
+]);
+const stringLike = zod_1.z
+    .union([
+    // We're going to coerce numbers and strings into strings.
+    zod_1.z.number(),
+    zod_1.z.string(),
+    // We do not allow other primitives, like:
+    // - bigints, symbols - because YAML does not support them,
+    // - booleans - because YAML accepts `True` and `true` as boolean input
+    //   and parses both as JS `true` -- if we stringified that,
+    //   we would lose the capital "T" which may not be what the user expects,
+    // - nulls - user should do `"null"` or not pass the property at all.
+])
+    .pipe(zod_1.z.coerce.string());
+exports.WorkflowDispatchInputZ = zod_1.z
+    .object({
+    description: stringLike.optional().describe('Description of the input'),
+    required: booleanLike.default(false).describe('Whether the input is required'),
+})
+    .and(zod_1.z.union([
+    zod_1.z.object({
+        type: zod_1.z.literal('string').default('string'),
+        default: stringLike.optional().describe('Default value for the input'),
+    }),
+    zod_1.z.object({
+        type: zod_1.z.literal('boolean'),
+        default: booleanLike.optional().describe('Default value for the input'),
+    }),
+    zod_1.z.object({
+        type: zod_1.z.literal('number'),
+        default: zod_1.z.number().optional().describe('Default value for the input'),
+    }),
+    zod_1.z.object({
+        type: zod_1.z.literal('choice'),
+        default: stringLike.optional().describe('Default value for the input'),
+        options: zod_1.z.array(stringLike).min(1).describe('Options for choice type inputs'),
+    }),
+    zod_1.z.object({
+        type: zod_1.z.literal('environment'),
+        default: zod_1.z.string().optional().describe('Default value for the input'),
+    }),
+]));
+function parseWorkflowInputsFromYaml(yamlConfig) {
+    try {
+        const parsed = YAML.parse(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 {};
+    }
+}
+exports.parseWorkflowInputsFromYaml = parseWorkflowInputsFromYaml;
+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': {
+            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/commands/workflow/runs.js

@@ -5,7 +5,7 @@ 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 workflows_1 = require("../../commandUtils/workflows");
+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");
@@ -49,7 +49,7 @@ class WorkflowRunList extends EasCommand_1.default {
         else {
             runs = await AppQuery_1.AppQuery.byIdWorkflowRunsFilteredByStatusAsync(graphqlClient, projectId, status, limit);
         }
-        const result = (0, workflows_1.processWorkflowRuns)(runs);
+        const result = (0, utils_1.processWorkflowRuns)(runs);
         if (flags.json) {
             (0, json_1.printJsonOnlyOutput)(result);
             return;
@@ -62,8 +62,9 @@ class WorkflowRunList extends EasCommand_1.default {
                 { 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' },
-                { label: 'Git Commit Hash', value: run.gitCommitHash ?? 'null' },
             ]));
             log_1.default.addNewLineIfNone();
         });

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

@@ -0,0 +1,17 @@
+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: {
+        name: string;
+        description: string;
+    }[];
+    static contextDefinition: {
+        loggedIn: import("../../commandUtils/context/LoggedInContextField").default;
+        projectId: import("../../commandUtils/context/ProjectIdContextField").ProjectIdContextField;
+    };
+    runAsync(): Promise<void>;
+}