eas-cli 16.23.1 → 16.24.0

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

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

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.fetchRawLogsForJobAsync = void 0;
+exports.fetchRawLogsForBuildJobAsync = exports.fetchRawLogsForCustomJobAsync = void 0;
+const BuildQuery_1 = require("../../graphql/queries/BuildQuery");
 // This function is in a separate module for testing purposes
-async function fetchRawLogsForJobAsync(job) {
+async function fetchRawLogsForCustomJobAsync(job) {
     const firstLogFileUrl = job.turtleJobRun?.logFileUrls?.[0];
     if (!firstLogFileUrl) {
         return null;
@@ -13,4 +14,23 @@ async function fetchRawLogsForJobAsync(job) {
     const rawLogs = await response.text();
     return rawLogs;
 }
-exports.fetchRawLogsForJobAsync = fetchRawLogsForJobAsync;
+exports.fetchRawLogsForCustomJobAsync = fetchRawLogsForCustomJobAsync;
+async function fetchRawLogsForBuildJobAsync(state, job) {
+    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',
+    });
+    const rawLogs = await response.text();
+    return rawLogs;
+}
+exports.fetchRawLogsForBuildJobAsync = fetchRawLogsForBuildJobAsync;

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.maybePromptForMissingInputsAsync = exports.parseWorkflowInputsFromYaml = exports.parseJsonInputs = exports.parseInputs = exports.WorkflowDispatchInputZ = void 0;
+const tslib_1 = require("tslib");
+const YAML = tslib_1.__importStar(require("yaml"));
+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 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;
+}
+exports.parseInputs = parseInputs;
+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;
+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;
+}
+exports.maybePromptForMissingInputsAsync = maybePromptForMissingInputsAsync;
+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/stateMachine.js

@@ -161,7 +161,7 @@ const workflowStepSelectionAction = async (prevState) => {
     if (!job) {
         return moveToWorkflowSelectionErrorState(prevState, 'No job found');
     }
-    const logs = await (0, utils_1.processLogsFromJobAsync)(job);
+    const logs = await (0, utils_1.fetchAndProcessLogsFromJobAsync)(prevState, job);
     if (!logs) {
         return moveToWorkflowSelectionErrorState(prevState, 'No logs found');
     }

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

@@ -35,5 +35,6 @@ export type WorkflowLogLine = {
     msg: string;
     result?: string;
     marker?: string;
+    err?: any;
 };
 export type WorkflowLogs = Map<string, WorkflowLogLine[]>;

package/build/commandUtils/workflow/types.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WorkflowTriggerType = void 0;
 /*
- * Utility types for workflow commands
+ * Utility types and Zod definitions for workflow commands
  */
 var WorkflowTriggerType;
 (function (WorkflowTriggerType) {

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

@@ -1,12 +1,23 @@
-import { WorkflowJobResult, WorkflowLogs, WorkflowRunResult, WorkflowTriggerType } from './types';
-import { WorkflowRunFragment } from '../../graphql/generated';
+import { WorkflowJobResult, WorkflowLogLine, WorkflowLogs, WorkflowRunResult, WorkflowTriggerType } from './types';
+import { 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[];
+export declare function choicesFromWorkflowLogs(logs: WorkflowLogs): (Choice & {
+    name: string;
+    status: string;
+    logLines: WorkflowLogLine[] | undefined;
+})[];
 export declare function processWorkflowRuns(runs: WorkflowRunFragment[]): WorkflowRunResult[];
-export declare function processLogsFromJobAsync(job: WorkflowJobResult): Promise<WorkflowLogs | null>;
+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']): Promise<string>;
+export declare function fileExistsAsync(filePath: string): Promise<boolean>;
+export declare function maybeReadStdinAsync(): Promise<string | null>;

package/build/commandUtils/workflow/utils.js

@@ -1,9 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.processLogsFromJobAsync = exports.processWorkflowRuns = exports.choicesFromWorkflowLogs = exports.choiceFromWorkflowJob = exports.choiceFromWorkflowRun = exports.computeTriggerInfoForWorkflowRun = void 0;
+exports.maybeReadStdinAsync = exports.fileExistsAsync = exports.infoForFailedWorkflowRunAsync = exports.infoForActiveWorkflowRunAsync = exports.fetchAndProcessLogsFromJobAsync = exports.processWorkflowRuns = exports.choicesFromWorkflowLogs = exports.choiceFromWorkflowJob = exports.choiceFromWorkflowRun = exports.computeTriggerInfoForWorkflowRun = void 0;
+const tslib_1 = require("tslib");
+const fs = tslib_1.__importStar(require("node:fs"));
 const fetchLogs_1 = require("./fetchLogs");
 const types_1 = require("./types");
 const generated_1 = require("../../graphql/generated");
+const log_1 = tslib_1.__importDefault(require("../../log"));
+const formatFields_1 = tslib_1.__importDefault(require("../../utils/formatFields"));
 function computeTriggerInfoForWorkflowRun(run) {
     let triggerType = types_1.WorkflowTriggerType.OTHER;
     let trigger = '';
@@ -58,14 +62,19 @@ function choiceFromWorkflowJob(job, index) {
 }
 exports.choiceFromWorkflowJob = choiceFromWorkflowJob;
 function choicesFromWorkflowLogs(logs) {
-    return Array.from(logs.keys()).map(step => {
+    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}`,
+            name: step,
+            status: stepStatus,
             value: step,
+            logLines,
         };
-    });
+    })
+        .filter(step => step.status !== 'skipped');
 }
 exports.choicesFromWorkflowLogs = choicesFromWorkflowLogs;
 function processWorkflowRuns(runs) {
@@ -88,29 +97,158 @@ function processWorkflowRuns(runs) {
     });
 }
 exports.processWorkflowRuns = processWorkflowRuns;
-async function processLogsFromJobAsync(job) {
-    const rawLogs = await (0, fetchLogs_1.fetchRawLogsForJobAsync)(job);
+async function fetchAndProcessLogsFromJobAsync(state, job) {
+    let rawLogs;
+    switch (job.type) {
+        case generated_1.WorkflowJobType.Build:
+        case generated_1.WorkflowJobType.Repack:
+            rawLogs = await (0, fetchLogs_1.fetchRawLogsForBuildJobAsync)(state, job);
+            break;
+        default:
+            rawLogs = await (0, fetchLogs_1.fetchRawLogsForCustomJobAsync)(job);
+            break;
+    }
     if (!rawLogs) {
         return null;
     }
+    log_1.default.debug(`rawLogs = ${JSON.stringify(rawLogs, null, 2)}`);
     const logs = new Map();
     const logKeys = new Set();
-    rawLogs.split('\n').forEach(line => {
+    rawLogs.split('\n').forEach((line, index) => {
+        log_1.default.debug(`line ${index} = ${JSON.stringify(line, null, 2)}`);
         try {
             const parsedLine = JSON.parse(line);
-            const { result, marker } = parsedLine;
-            const { buildStepDisplayName, buildStepInternalId, time, msg } = parsedLine;
+            const { buildStepDisplayName, buildStepInternalId, time, msg, result, marker, err } = 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 });
+                logs.get(stepId)?.push({ time, msg, result, marker, err });
             }
         }
         catch { }
     });
     return logs;
 }
-exports.processLogsFromJobAsync = processLogsFromJobAsync;
+exports.fetchAndProcessLogsFromJobAsync = fetchAndProcessLogsFromJobAsync;
+function descriptionForJobStatus(status) {
+    switch (status) {
+        case generated_1.WorkflowJobStatus.New:
+            return 'Waiting for worker';
+        case generated_1.WorkflowJobStatus.InProgress:
+            return 'In progress';
+        case generated_1.WorkflowJobStatus.Success:
+            return 'Completed successfully';
+        case generated_1.WorkflowJobStatus.Failure:
+            return 'Failed';
+        case generated_1.WorkflowJobStatus.Canceled:
+            return 'Canceled';
+        case generated_1.WorkflowJobStatus.Skipped:
+            return 'Skipped';
+        case generated_1.WorkflowJobStatus.ActionRequired:
+            return 'Waiting for action';
+        case generated_1.WorkflowJobStatus.PendingCancel:
+            return 'Pending cancel';
+    }
+}
+async function infoForActiveWorkflowRunAsync(graphqlClient, workflowRun, maxLogLines = 5 // -1 means no limit
+) {
+    const statusLines = [];
+    const statusValues = [];
+    for (const job of workflowRun.jobs) {
+        statusValues.push({ label: '', value: '' });
+        statusValues.push({ label: '  Job', value: job.name });
+        statusValues.push({ label: '  Status', value: descriptionForJobStatus(job.status) });
+        if (job.status !== generated_1.WorkflowJobStatus.InProgress) {
+            continue;
+        }
+        const logs = await fetchAndProcessLogsFromJobAsync({ graphqlClient }, job);
+        const steps = logs ? choicesFromWorkflowLogs(logs) : [];
+        if (steps.length > 0) {
+            const currentStep = steps[steps.length - 1];
+            statusValues.push({ label: '  Current step', value: currentStep.name });
+            if (currentStep?.logLines?.length) {
+                statusValues.push({ label: '  Current logs', value: '' });
+                const currentLogs = currentStep.logLines
+                    ?.map(line => line.msg)
+                    .filter((_, index) => {
+                    if (maxLogLines === -1) {
+                        return true;
+                    }
+                    return index > (currentStep.logLines?.length ?? 0) - maxLogLines;
+                }) ?? [];
+                for (const log of currentLogs) {
+                    statusValues.push({ label: '', value: log });
+                }
+            }
+        }
+    }
+    statusValues.push({ label: '', value: '' });
+    statusLines.push((0, formatFields_1.default)(statusValues));
+    return statusLines.join('\n');
+}
+exports.infoForActiveWorkflowRunAsync = infoForActiveWorkflowRunAsync;
+async function infoForFailedWorkflowRunAsync(graphqlClient, workflowRun) {
+    const statusLines = [];
+    const statusValues = [];
+    for (const job of workflowRun.jobs) {
+        if (job.status !== generated_1.WorkflowJobStatus.Failure) {
+            continue;
+        }
+        const logs = await fetchAndProcessLogsFromJobAsync({ graphqlClient }, job);
+        const steps = logs ? choicesFromWorkflowLogs(logs) : [];
+        statusValues.push({ label: '', value: '' });
+        statusValues.push({ label: '  Failed job', value: job.name });
+        if (steps.length > 0) {
+            const failedStep = steps.find(step => step.status === 'fail');
+            if (failedStep) {
+                const logs = failedStep.logLines?.map(line => line.msg) ?? [];
+                statusValues.push({ label: '  Failed step', value: failedStep.name });
+                statusValues.push({
+                    label: '  Logs for failed step',
+                    value: '',
+                });
+                for (const log of logs) {
+                    statusValues.push({ label: '', value: log });
+                }
+            }
+        }
+    }
+    statusValues.push({ label: '', value: '' });
+    statusLines.push((0, formatFields_1.default)(statusValues));
+    return statusLines.join('\n');
+}
+exports.infoForFailedWorkflowRunAsync = infoForFailedWorkflowRunAsync;
+async function fileExistsAsync(filePath) {
+    return await fs.promises
+        .access(filePath, fs.constants.F_OK)
+        .then(() => true)
+        .catch(() => false);
+}
+exports.fileExistsAsync = fileExistsAsync;
+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;

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

@@ -39,7 +39,6 @@
  *         description: "Type of deployment"
  * ```
  */
-import { z } from 'zod';
 import EasCommand from '../../commandUtils/EasCommand';
 export default class WorkflowRun extends EasCommand {
     static description: string;
@@ -63,27 +62,3 @@ 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.ZodCodec<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodString>>;
-    required: z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodCodec<z.ZodNumber, z.ZodBoolean>, z.ZodCodec<z.ZodString, z.ZodBoolean>]>>;
-}, z.core.$strip>, z.ZodUnion<readonly [z.ZodObject<{
-    type: z.ZodDefault<z.ZodLiteral<"string">>;
-    default: z.ZodOptional<z.ZodCodec<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodString>>;
-}, 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>]>>;
-}, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"number">;
-    default: z.ZodOptional<z.ZodNumber>;
-}, 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>>;
-}, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"environment">;
-    default: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>]>>;
-export declare function parseWorkflowInputsFromYaml(yamlConfig: string): Record<string, z.infer<typeof WorkflowDispatchInputZ>>;