@donotuse/eas-cli 18.5.0-rc.1

package/build/commands/worker/deploy.js

@@ -0,0 +1,323 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const timeago_js_1 = require("@expo/timeago.js");
+const core_1 = require("@oclif/core");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const node_fs_1 = tslib_1.__importDefault(require("node:fs"));
+const path = tslib_1.__importStar(require("node:path"));
+const EasCommand_1 = tslib_1.__importDefault(require("../../commandUtils/EasCommand"));
+const flags_1 = require("../../commandUtils/flags");
+const log_1 = tslib_1.__importDefault(require("../../log"));
+const ora_1 = require("../../ora");
+const json_1 = require("../../utils/json");
+const progress_1 = require("../../utils/progress");
+const WorkerAssets = tslib_1.__importStar(require("../../worker/assets"));
+const deployment_1 = require("../../worker/deployment");
+const upload_1 = require("../../worker/upload");
+const logs_1 = require("../../worker/utils/logs");
+const isDirectory = (directoryPath) => node_fs_1.default.promises
+    .stat(directoryPath)
+    .then(stat => stat.isDirectory())
+    .catch(() => false);
+class WorkerDeploy extends EasCommand_1.default {
+    async runAsync() {
+        const { flags: rawFlags } = await this.parse(_a);
+        const flags = this.sanitizeFlags(rawFlags);
+        if (flags.json) {
+            (0, json_1.enableJsonOutput)();
+        }
+        log_1.default.warn('EAS Worker Deployments are in beta and subject to breaking changes.');
+        const { getDynamicPrivateProjectConfigAsync, loggedIn: { graphqlClient }, projectDir, } = await this.getContextAsync(_a, { ...flags, withServerSideEnvironment: null });
+        const projectDist = await resolveExportedProjectAsync(flags, projectDir);
+        const { projectId } = await getDynamicPrivateProjectConfigAsync();
+        logExportedProjectInfo(projectDist);
+        async function* emitWorkerTarballAsync(params) {
+            yield ['assets.json', JSON.stringify(params.assetMap)];
+            yield ['manifest.json', JSON.stringify(params.manifest)];
+            if (projectDist.type === 'server' && projectDist.serverPath) {
+                const workerFiles = WorkerAssets.listWorkerFilesAsync(projectDist.serverPath);
+                for await (const workerFile of workerFiles) {
+                    yield [`server/${workerFile.normalizedPath}`, workerFile.data];
+                }
+            }
+        }
+        async function finalizeDeployAsync(deployParams) {
+            const finalizeDeployUrl = new URL('/deploy/finalize', deployParams.baseURL);
+            finalizeDeployUrl.searchParams.set('token', deployParams.token);
+            const result = await (0, upload_1.callUploadApiAsync)(finalizeDeployUrl, {
+                method: 'POST',
+                headers: {
+                    accept: 'application/json',
+                },
+            });
+            if (!result || typeof result !== 'object' || !('success' in result) || !result.success) {
+                throw new Error('Deploy failed: Incomplete asset uploads. Please try again');
+            }
+        }
+        async function uploadTarballAsync(tarPath, uploadUrl) {
+            const { response } = await (0, upload_1.uploadAsync)({
+                url: uploadUrl,
+                filePath: tarPath,
+                compress: false,
+                headers: {
+                    accept: 'application/json',
+                },
+            });
+            if (response.status === 413) {
+                throw new Error('Upload failed! (Payload too large)\n' +
+                    `The files in "${path.relative(projectDir, projectDist.path)}" (at: ${projectDir}) exceed the maximum file size (10MB gzip).`);
+            }
+            else if (!response.ok) {
+                throw new Error(`Upload failed! (${response.statusText})`);
+            }
+            else {
+                const json = await response.json();
+                if (!json.success || !json.result || typeof json.result !== 'object') {
+                    throw new Error(json.message ? `Upload failed: ${json.message}` : 'Upload failed!');
+                }
+                const { id, fullName, token } = json.result;
+                if (typeof token !== 'string') {
+                    throw new Error('Upload failed: API failed to return a deployment token');
+                }
+                else if (typeof id !== 'string') {
+                    throw new Error('Upload failed: API failed to return a deployment identifier');
+                }
+                else if (typeof fullName !== 'string') {
+                    throw new Error('Upload failed: API failed to return a script name');
+                }
+                const baseURL = new URL('/', uploadUrl).toString();
+                return { id, fullName, baseURL, token };
+            }
+        }
+        async function uploadAssetsAsync(assetMap, deployParams) {
+            const uploadParams = [];
+            const assetPath = projectDist.type === 'server' ? projectDist.clientPath : projectDist.path;
+            if (!assetPath) {
+                return;
+            }
+            for await (const asset of WorkerAssets.listAssetMapFilesAsync(assetPath, assetMap)) {
+                const uploadURL = new URL(`/asset/${asset.sha512}`, deployParams.baseURL);
+                uploadURL.searchParams.set('token', deployParams.token);
+                uploadParams.push({ url: uploadURL.toString(), filePath: asset.path });
+            }
+            const progress = {
+                total: uploadParams.length,
+                pending: 0,
+                percent: 0,
+                transferred: 0,
+            };
+            const updateProgress = (0, progress_1.createProgressTracker)({
+                total: progress.total,
+                message(ratio) {
+                    const percent = `${Math.floor(ratio * 100)}`;
+                    const details = chalk_1.default.dim(`(${progress.pending} Pending, ${progress.transferred} Completed, ${progress.total} Total)`);
+                    return `Uploading assets: ${percent.padStart(3)}% ${details}`;
+                },
+                completedMessage: 'Uploaded assets',
+            });
+            try {
+                for await (const signal of (0, upload_1.batchUploadAsync)(uploadParams)) {
+                    if ('response' in signal) {
+                        progress.pending--;
+                        progress.percent = ++progress.transferred / progress.total;
+                    }
+                    else {
+                        progress.pending++;
+                    }
+                    updateProgress({ progress });
+                }
+            }
+            catch (error) {
+                updateProgress({ isComplete: true, error });
+                throw error;
+            }
+            updateProgress({ isComplete: true });
+        }
+        let assetMap;
+        let tarPath;
+        let deployResult;
+        let progress = (0, ora_1.ora)('Preparing project').start();
+        try {
+            const manifest = await WorkerAssets.createManifestAsync({
+                environment: flags.environment,
+                projectDir,
+                projectId,
+            }, graphqlClient);
+            assetMap = await WorkerAssets.createAssetMapAsync(projectDist.type === 'server' ? projectDist.clientPath : projectDist.path);
+            tarPath = await WorkerAssets.packFilesIterableAsync(emitWorkerTarballAsync({
+                assetMap,
+                manifest,
+            }));
+            const uploadUrl = await (0, deployment_1.getSignedDeploymentUrlAsync)(graphqlClient, {
+                appId: projectId,
+                deploymentIdentifier: flags.deploymentIdentifier,
+                // NOTE(cedric): this function might ask the user for a dev-domain name,
+                // when that happens, no ora spinner should be running.
+                onSetupDevDomain: () => progress.stop(),
+                nonInteractive: flags.nonInteractive,
+            });
+            progress.start('Creating deployment');
+            deployResult = await uploadTarballAsync(tarPath, uploadUrl);
+            progress.succeed('Created deployment');
+        }
+        catch (error) {
+            progress.fail('Failed to create deployment');
+            throw error;
+        }
+        await uploadAssetsAsync(assetMap, deployResult);
+        await finalizeDeployAsync(deployResult);
+        let deploymentAlias = null;
+        if (flags.aliasName) {
+            progress = (0, ora_1.ora)((0, chalk_1.default) `Assigning alias {bold ${flags.aliasName}} to deployment`).start();
+            try {
+                deploymentAlias = await (0, deployment_1.assignWorkerDeploymentAliasAsync)({
+                    graphqlClient,
+                    appId: projectId,
+                    deploymentId: deployResult.id,
+                    aliasName: flags.aliasName,
+                });
+                // Only stop the spinner when not promoting to production
+                if (!flags.isProduction) {
+                    progress.succeed((0, chalk_1.default) `Assigned alias {bold ${flags.aliasName}} to deployment`);
+                }
+            }
+            catch (error) {
+                progress.fail((0, chalk_1.default) `Failed to assign {bold ${flags.aliasName}} alias to deployment`);
+                throw error;
+            }
+        }
+        let deploymentProdAlias = null;
+        if (flags.isProduction) {
+            try {
+                if (!flags.aliasName) {
+                    progress = (0, ora_1.ora)((0, chalk_1.default) `Promoting deployment to {bold production}`).start();
+                }
+                else {
+                    progress.text = (0, chalk_1.default) `Promoting deployment to {bold production}`;
+                }
+                deploymentProdAlias = await (0, deployment_1.assignWorkerDeploymentProductionAsync)({
+                    graphqlClient,
+                    appId: projectId,
+                    deploymentId: deployResult.id,
+                });
+                progress.succeed(!flags.aliasName
+                    ? (0, chalk_1.default) `Promoted deployment to {bold production}`
+                    : (0, chalk_1.default) `Promoted deployment to {bold production} with alias {bold ${flags.aliasName}}`);
+            }
+            catch (error) {
+                progress.fail('Failed to promote deployment to production');
+                throw error;
+            }
+        }
+        if (flags.json) {
+            (0, json_1.printJsonOnlyOutput)((0, logs_1.formatWorkerDeploymentJson)({
+                projectId,
+                deployment: {
+                    deploymentIdentifier: deployResult.id,
+                    url: (0, logs_1.getDeploymentUrlFromFullName)(deployResult.fullName),
+                },
+                aliases: [deploymentAlias],
+                production: deploymentProdAlias,
+            }));
+            return;
+        }
+        log_1.default.addNewLineIfNone();
+        log_1.default.log(`🎉 Your deployment is ready`);
+        log_1.default.addNewLineIfNone();
+        log_1.default.log((0, logs_1.formatWorkerDeploymentTable)({
+            projectId,
+            deployment: {
+                deploymentIdentifier: deployResult.id,
+                url: (0, logs_1.getDeploymentUrlFromFullName)(deployResult.fullName),
+            },
+            aliases: [deploymentAlias],
+            production: deploymentProdAlias,
+        }));
+        if (!deploymentProdAlias) {
+            log_1.default.addNewLineIfNone();
+            log_1.default.log('🚀 When you are ready to deploy to production:');
+            log_1.default.log((0, chalk_1.default) `  $ eas deploy {bold --prod}`);
+        }
+    }
+    sanitizeFlags(flags) {
+        return {
+            nonInteractive: flags['non-interactive'],
+            json: flags['json'],
+            isProduction: !!flags.prod,
+            aliasName: flags.alias?.trim().toLowerCase(),
+            deploymentIdentifier: flags.id?.trim(),
+            exportDir: flags['export-dir'],
+        };
+    }
+}
+_a = WorkerDeploy;
+WorkerDeploy.description = 'Deploy your Expo web build';
+WorkerDeploy.aliases = ['deploy'];
+WorkerDeploy.usage = [(0, chalk_1.default) `deploy {dim [options]}`, `deploy --prod`];
+// TODO(@kitten): Keep command hidden until worker deployments are live
+WorkerDeploy.hidden = true;
+WorkerDeploy.state = 'beta';
+WorkerDeploy.flags = {
+    prod: core_1.Flags.boolean({
+        aliases: ['production'],
+        description: 'Create a new production deployment.',
+        default: false,
+    }),
+    alias: core_1.Flags.string({
+        description: 'Custom alias to assign to the new deployment.',
+        helpValue: 'name',
+    }),
+    id: core_1.Flags.string({
+        description: 'Custom unique identifier for the new deployment.',
+        helpValue: 'xyz123',
+    }),
+    'export-dir': core_1.Flags.string({
+        description: 'Directory where the Expo project was exported.',
+        helpValue: 'dir',
+        default: 'dist',
+    }),
+    environment: {
+        ...flags_1.EASEnvironmentFlag.environment,
+        description: 'Deploy with EAS Environment Variables matching the specified environment.',
+    },
+    ...flags_1.EasNonInteractiveAndJsonFlags,
+};
+WorkerDeploy.contextDefinition = {
+    ..._a.ContextOptions.DynamicProjectConfig,
+    ..._a.ContextOptions.ProjectDir,
+    ..._a.ContextOptions.LoggedIn,
+};
+exports.default = WorkerDeploy;
+async function resolveExportedProjectAsync(flags, projectDir) {
+    const exportPath = path.join(projectDir, flags.exportDir);
+    const serverPath = path.join(exportPath, 'server');
+    const clientPath = path.join(exportPath, 'client');
+    const [exportDirStat, expoRoutesStat, hasClientDir] = await Promise.all([
+        node_fs_1.default.promises.stat(exportPath).catch(() => null),
+        node_fs_1.default.promises.stat(path.join(serverPath, '_expo/routes.json')).catch(() => null),
+        isDirectory(clientPath),
+    ]);
+    if (!exportDirStat?.isDirectory()) {
+        throw new Error(`No "${flags.exportDir}/" folder found. Prepare your project for deployment with "npx expo export --platform web"`);
+    }
+    if (expoRoutesStat?.isFile()) {
+        return {
+            type: 'server',
+            path: exportPath,
+            modifiedAt: exportDirStat.mtime,
+            serverPath,
+            clientPath: hasClientDir ? clientPath : undefined,
+        };
+    }
+    return { type: 'static', path: exportPath, modifiedAt: exportDirStat.mtime };
+}
+function logExportedProjectInfo(project) {
+    let modifiedAgo = '';
+    // Only show the timestamp for exports older than 1 minute
+    if (project.modifiedAt && Date.now() - project.modifiedAt.getTime() > 60000) {
+        modifiedAgo = ` - exported ${(0, timeago_js_1.format)(project.modifiedAt)}`;
+    }
+    log_1.default.log((0, chalk_1.default) `{dim > Project export: ${project.type}${modifiedAgo}}`);
+}

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

@@ -0,0 +1,13 @@
+import EasCommand from '../../commandUtils/EasCommand';
+export default class WorkflowRunCancel extends EasCommand {
+    static description: string;
+    static strict: boolean;
+    static contextDefinition: {
+        loggedIn: import("../../commandUtils/context/LoggedInContextField").default;
+        projectId: import("../../commandUtils/context/ProjectIdContextField").ProjectIdContextField;
+    };
+    static flags: {
+        'non-interactive': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    runAsync(): Promise<void>;
+}

package/build/commands/workflow/cancel.js

@@ -0,0 +1,81 @@
+"use strict";
+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 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");
+const log_1 = tslib_1.__importDefault(require("../../log"));
+const prompts_1 = require("../../prompts");
+class WorkflowRunCancel extends EasCommand_1.default {
+    static description = 'Cancel one or more workflow runs. If no workflow run IDs are provided, you will be prompted to select IN_PROGRESS runs to cancel.';
+    static strict = false;
+    static contextDefinition = {
+        ...this.ContextOptions.ProjectId,
+        ...this.ContextOptions.LoggedIn,
+    };
+    static flags = {
+        ...flags_1.EASNonInteractiveFlag,
+    };
+    async runAsync() {
+        const { argv } = await this.parse(WorkflowRunCancel);
+        let nonInteractive = false;
+        const workflowRunIds = new Set();
+        // Custom parsing of argv
+        const tokens = [...argv];
+        while (tokens.length > 0) {
+            const token = tokens.shift();
+            if (token === '--non-interactive') {
+                nonInteractive = true;
+                continue;
+            }
+            else if (token) {
+                workflowRunIds.add(token);
+            }
+        }
+        const { projectId, loggedIn: { graphqlClient }, } = await this.getContextAsync(WorkflowRunCancel, {
+            nonInteractive,
+        });
+        if (workflowRunIds.size === 0) {
+            if (nonInteractive) {
+                throw new Error('Must supply workflow run IDs as arguments when in non-interactive mode');
+            }
+            // 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, utils_1.processWorkflowRuns)(queryResult);
+            if (runs.length === 0) {
+                log_1.default.warn('No workflow runs to cancel');
+                return;
+            }
+            const answers = await (0, prompts_1.promptAsync)({
+                type: 'multiselect',
+                name: 'selectedRuns',
+                message: 'Select IN_PROGRESS workflow runs to cancel',
+                choices: runs.map(run => (0, utils_1.choiceFromWorkflowRun)(run)),
+            });
+            answers.selectedRuns.forEach((id) => {
+                workflowRunIds.add(id);
+            });
+            if (workflowRunIds.size === 0) {
+                log_1.default.warn('No workflow runs to cancel');
+                return;
+            }
+        }
+        log_1.default.addNewLineIfNone();
+        for (const workflowRunId of workflowRunIds) {
+            try {
+                await WorkflowRunMutation_1.WorkflowRunMutation.cancelWorkflowRunAsync(graphqlClient, {
+                    workflowRunId,
+                });
+                log_1.default.log(`Workflow run ${workflowRunId} has been canceled.`);
+            }
+            catch (e) {
+                log_1.default.error(`Failed to cancel workflow run ${workflowRunId}: ${e}`);
+            }
+        }
+        log_1.default.addNewLineIfNone();
+    }
+}
+exports.default = WorkflowRunCancel;

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

@@ -0,0 +1,17 @@
+import EasCommand from '../../commandUtils/EasCommand';
+export declare class WorkflowCreate extends EasCommand {
+    static description: string;
+    static args: {
+        name: import("@oclif/core/lib/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        'skip-validation': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    static contextDefinition: {
+        loggedIn: import("../../commandUtils/context/LoggedInContextField").default;
+        projectDir: import("../../commandUtils/context/ProjectDirContextField").default;
+        getDynamicPublicProjectConfigAsync: import("../../commandUtils/context/DynamicProjectConfigContextField").DynamicPublicProjectConfigContextField;
+        getDynamicPrivateProjectConfigAsync: import("../../commandUtils/context/DynamicProjectConfigContextField").DynamicPrivateProjectConfigContextField;
+    };
+    runAsync(): Promise<void>;
+}

package/build/commands/workflow/create.js

@@ -0,0 +1,171 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkflowCreate = void 0;
+const tslib_1 = require("tslib");
+const core_1 = require("@oclif/core");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const promises_1 = tslib_1.__importDefault(require("fs/promises"));
+const fs_extra_1 = tslib_1.__importDefault(require("fs-extra"));
+const path_1 = tslib_1.__importDefault(require("path"));
+const EasCommand_1 = tslib_1.__importDefault(require("../../commandUtils/EasCommand"));
+const buildProfileUtils_1 = require("../../commandUtils/workflow/buildProfileUtils");
+const creation_1 = require("../../commandUtils/workflow/creation");
+const validation_1 = require("../../commandUtils/workflow/validation");
+const log_1 = tslib_1.__importDefault(require("../../log"));
+const prompts_1 = require("../../prompts");
+const formatFields_1 = tslib_1.__importDefault(require("../../utils/formatFields"));
+const workflowFile_1 = require("../../utils/workflowFile");
+class WorkflowCreate extends EasCommand_1.default {
+    static description = 'create a new workflow configuration YAML file';
+    static args = {
+        name: core_1.Args.string({
+            description: 'Name of the workflow file (must end with .yml or .yaml)',
+            required: false,
+        }),
+    };
+    static flags = {
+        'skip-validation': core_1.Flags.boolean({
+            description: 'If set, the workflow file will not be validated before being created',
+            default: false,
+        }),
+    };
+    static contextDefinition = {
+        ...this.ContextOptions.DynamicProjectConfig,
+        ...this.ContextOptions.ProjectDir,
+        ...this.ContextOptions.LoggedIn,
+    };
+    async runAsync() {
+        const { args: { name: argFileName }, flags, } = await this.parse(WorkflowCreate);
+        try {
+            const { getDynamicPrivateProjectConfigAsync, loggedIn: { graphqlClient }, projectDir, } = await this.getContextAsync(WorkflowCreate, {
+                nonInteractive: false,
+                withServerSideEnvironment: null,
+            });
+            const { exp: originalExpoConfig, projectId } = await getDynamicPrivateProjectConfigAsync();
+            let expoConfig = originalExpoConfig;
+            let workflowStarter;
+            while (!workflowStarter) {
+                workflowStarter = await chooseTemplateAsync();
+                switch (workflowStarter.name) {
+                    case creation_1.WorkflowStarterName.BUILD:
+                    case creation_1.WorkflowStarterName.DEPLOY:
+                    case creation_1.WorkflowStarterName.UPDATE: {
+                        const shouldProceed = await (0, buildProfileUtils_1.runBuildConfigureIfNeededAsync)({
+                            projectDir,
+                            expoConfig,
+                        });
+                        if (!shouldProceed) {
+                            workflowStarter = undefined;
+                            continue;
+                        }
+                        break;
+                    }
+                    default:
+                        break;
+                }
+                switch (workflowStarter.name) {
+                    case creation_1.WorkflowStarterName.DEPLOY:
+                    case creation_1.WorkflowStarterName.UPDATE: {
+                        const shouldProceed = await (0, buildProfileUtils_1.runUpdateConfigureIfNeededAsync)({
+                            projectDir,
+                            expoConfig,
+                        });
+                        if (!shouldProceed) {
+                            workflowStarter = undefined;
+                            continue;
+                        }
+                        // Need to refetch the Expo config because it may have changed
+                        expoConfig = (await getDynamicPrivateProjectConfigAsync()).exp;
+                        break;
+                    }
+                    default:
+                        break;
+                }
+            }
+            const { fileName, filePath } = await chooseFileNameAsync(argFileName, projectDir, workflowStarter);
+            // Customize the template if needed
+            workflowStarter = await (0, creation_1.customizeTemplateIfNeededAsync)(workflowStarter, projectDir, expoConfig);
+            log_1.default.debug(`Creating workflow file ${fileName} from template ${workflowStarter.name}`);
+            const yamlString = [
+                workflowStarter.header,
+                (0, validation_1.workflowContentsFromParsedYaml)(workflowStarter.template),
+            ].join('\n');
+            if (!flags['skip-validation']) {
+                await (0, validation_1.validateWorkflowFileAsync)({ yamlConfig: yamlString, filePath: fileName }, projectDir, graphqlClient, projectId);
+            }
+            await ensureWorkflowsDirectoryExistsAsync({ projectDir });
+            filePath && (await promises_1.default.writeFile(filePath, yamlString));
+            log_1.default.withTick(`Created ${chalk_1.default.bold(filePath)}`);
+            log_1.default.addNewLineIfNone();
+            log_1.default.log((0, creation_1.howToRunWorkflow)(fileName, workflowStarter));
+            // Next steps
+            if (workflowStarter.nextSteps && workflowStarter.nextSteps.length > 0) {
+                log_1.default.addNewLineIfNone();
+                log_1.default.log('Next steps:');
+                log_1.default.addNewLineIfNone();
+                log_1.default.log((0, formatFields_1.default)(workflowStarter.nextSteps.map((step, index) => ({
+                    label: `${index + 1}.`,
+                    value: step,
+                }))));
+            }
+        }
+        catch (error) {
+            (0, validation_1.logWorkflowValidationErrors)(error);
+            log_1.default.error('Failed to create workflow file.');
+        }
+    }
+}
+exports.WorkflowCreate = WorkflowCreate;
+async function ensureWorkflowsDirectoryExistsAsync({ projectDir, }) {
+    try {
+        await promises_1.default.access(path_1.default.join(projectDir, '.eas', 'workflows'));
+    }
+    catch {
+        await promises_1.default.mkdir(path_1.default.join(projectDir, '.eas', 'workflows'), { recursive: true });
+        log_1.default.withTick(`Created directory ${chalk_1.default.bold(path_1.default.join(projectDir, '.eas', 'workflows'))}`);
+    }
+}
+async function chooseTemplateAsync() {
+    const workflowStarter = (await (0, prompts_1.promptAsync)({
+        type: 'select',
+        name: 'starter',
+        message: 'Select a workflow template:',
+        choices: creation_1.workflowStarters.map(starter => ({
+            title: starter.displayName,
+            value: starter,
+        })),
+    })).starter;
+    return workflowStarter;
+}
+async function chooseFileNameAsync(initialValue, projectDir, workflowStarter) {
+    let fileName = initialValue;
+    let filePath = '';
+    while ((fileName?.length ?? 0) === 0) {
+        fileName = (await (0, prompts_1.promptAsync)({
+            type: 'text',
+            name: 'fileName',
+            message: 'What would you like to name your workflow file?',
+            initial: workflowStarter.defaultFileName,
+        })).fileName;
+        if (!fileName) {
+            fileName = undefined;
+            continue;
+        }
+        try {
+            workflowFile_1.WorkflowFile.validateYamlExtension(fileName);
+        }
+        catch (error) {
+            log_1.default.error(error instanceof Error ? error.message : 'Invalid YAML file name extension');
+            fileName = undefined;
+            continue;
+        }
+        filePath = path_1.default.join(projectDir, '.eas', 'workflows', fileName);
+        if (await fs_extra_1.default.pathExists(filePath)) {
+            log_1.default.error(`Workflow file already exists: ${filePath}`);
+            log_1.default.error('Please choose a different file name.');
+            log_1.default.newLine();
+            fileName = undefined;
+        }
+    }
+    return { fileName: fileName ?? '', filePath };
+}

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

@@ -0,0 +1,13 @@
+import EasCommand from '../../commandUtils/EasCommand';
+export default class WorkflowList extends EasCommand {
+    static hidden: boolean;
+    static description: string;
+    static flags: {
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    static contextDefinition: {
+        loggedIn: import("../../commandUtils/context/LoggedInContextField").default;
+        projectId: import("../../commandUtils/context/ProjectIdContextField").ProjectIdContextField;
+    };
+    runAsync(): Promise<void>;
+}

package/build/commands/workflow/list.js

@@ -0,0 +1,53 @@
+"use strict";
+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 AppQuery_1 = require("../../graphql/queries/AppQuery");
+const log_1 = tslib_1.__importDefault(require("../../log"));
+const formatFields_1 = tslib_1.__importDefault(require("../../utils/formatFields"));
+const json_1 = require("../../utils/json");
+class WorkflowList extends EasCommand_1.default {
+    static hidden = true;
+    static description = 'List workflows for the current project';
+    static flags = {
+        ...flags_1.EasJsonOnlyFlag,
+    };
+    static contextDefinition = {
+        ...this.ContextOptions.ProjectId,
+        ...this.ContextOptions.LoggedIn,
+    };
+    async runAsync() {
+        const { flags } = await this.parse(WorkflowList);
+        const { projectId, loggedIn: { graphqlClient }, } = await this.getContextAsync(WorkflowList, {
+            nonInteractive: true,
+        });
+        if (flags.json) {
+            (0, json_1.enableJsonOutput)();
+        }
+        const workflows = await AppQuery_1.AppQuery.byIdWorkflowsAsync(graphqlClient, projectId);
+        const result = workflows.map(workflow => ({
+            id: workflow.id,
+            name: workflow.name,
+            fileName: workflow.fileName,
+            createdAt: workflow.createdAt,
+            updatedAt: workflow.updatedAt,
+        }));
+        if (flags.json) {
+            (0, json_1.printJsonOnlyOutput)(result);
+            return;
+        }
+        log_1.default.addNewLineIfNone();
+        result.forEach(workflow => {
+            log_1.default.log((0, formatFields_1.default)([
+                { label: 'ID', value: workflow.id },
+                { label: 'Name', value: workflow.name ?? '-' },
+                { label: 'File name', value: workflow.fileName },
+                { label: 'Created At', value: workflow.createdAt },
+                { label: 'Updated At', value: workflow.updatedAt },
+            ]));
+            log_1.default.addNewLineIfNone();
+        });
+    }
+}
+exports.default = WorkflowList;