eas-cli 16.19.3 → 16.20.0

package/build/api.d.ts

@@ -19,4 +19,5 @@ export declare class ApiV2Client {
 export declare function getExpoApiBaseUrl(): string;
 export declare function getExpoWebsiteBaseUrl(): string;
 export declare function getEASUpdateURL(projectId: string, manifestHostOverride: string | null): string;
+export declare function getExpoApiWorkflowSchemaURL(): string;
 export {};

package/build/api.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getEASUpdateURL = exports.getExpoWebsiteBaseUrl = exports.getExpoApiBaseUrl = exports.ApiV2Client = void 0;
+exports.getExpoApiWorkflowSchemaURL = exports.getEASUpdateURL = exports.getExpoWebsiteBaseUrl = exports.getExpoApiBaseUrl = exports.ApiV2Client = void 0;
 const tslib_1 = require("tslib");
 const ApiV2Error_1 = require("./ApiV2Error");
 const fetch_1 = tslib_1.__importStar(require("./fetch"));
@@ -105,3 +105,7 @@ function getEASUpdateURL(projectId, manifestHostOverride) {
     }
 }
 exports.getEASUpdateURL = getEASUpdateURL;
+function getExpoApiWorkflowSchemaURL() {
+    return getExpoApiBaseUrl() + '/v2/workflows/schema';
+}
+exports.getExpoApiWorkflowSchemaURL = getExpoApiWorkflowSchemaURL;

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

@@ -0,0 +1,6 @@
+import { ExpoGraphqlClient } from '../context/contextUtils/createGraphqlClient';
+export declare function validateWorkflowFileAsync(workflowFileContents: {
+    yamlConfig: string;
+    filePath: string;
+}, projectDir: string, graphqlClient: ExpoGraphqlClient, projectId: string): Promise<void>;
+export declare function logWorkflowValidationErrors(error: unknown): void;

package/build/commandUtils/workflow/validation.js

@@ -0,0 +1,160 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logWorkflowValidationErrors = exports.validateWorkflowFileAsync = void 0;
+const tslib_1 = require("tslib");
+const eas_json_1 = require("@expo/eas-json");
+const errors_1 = require("@expo/eas-json/build/errors");
+const core_1 = require("@urql/core");
+const fs_1 = require("fs");
+const path_1 = tslib_1.__importDefault(require("path"));
+const YAML = tslib_1.__importStar(require("yaml"));
+const api_1 = require("../../api");
+const WorkflowRevisionMutation_1 = require("../../graphql/mutations/WorkflowRevisionMutation");
+const log_1 = tslib_1.__importDefault(require("../../log"));
+const ajv_1 = require("../../metadata/utils/ajv");
+const workflowFile_1 = require("../../utils/workflowFile");
+const jobTypesWithBuildProfile = new Set(['build', 'repack']);
+const buildProfileIsInterpolated = (profileName) => {
+    return profileName.includes('${{') && profileName.includes('}}');
+};
+async function validateWorkflowFileAsync(workflowFileContents, projectDir, graphqlClient, projectId) {
+    const parsedYaml = parsedYamlFromWorkflowContents(workflowFileContents);
+    log_1.default.debug(`Parsed workflow: ${JSON.stringify(parsedYaml, null, 2)}`);
+    // Check if the parsed result is empty or null
+    log_1.default.debug(`Validating workflow is not empty...`);
+    validateWorkflowIsNotEmpty(parsedYaml);
+    const workflowSchema = await fetchWorkflowSchemaAsync();
+    // Check that all job types are valid
+    log_1.default.debug(`Validating workflow job types...`);
+    validateWorkflowJobTypes(parsedYaml, workflowSchema);
+    // Check for build jobs that do not match any EAS build profiles
+    log_1.default.debug(`Validating workflow build jobs...`);
+    await validateWorkflowBuildJobsAsync(parsedYaml, projectDir);
+    // Check that result passes validation against workflow schema
+    log_1.default.debug(`Validating workflow structure...`);
+    validateWorkflowStructure(parsedYaml, workflowSchema);
+    // Check for other errors using the server-side validation
+    log_1.default.debug(`Validating workflow on server...`);
+    await validateWorkflowOnServerAsync(graphqlClient, projectId, workflowFileContents);
+}
+exports.validateWorkflowFileAsync = validateWorkflowFileAsync;
+function logWorkflowValidationErrors(error) {
+    if (error instanceof errors_1.MissingEasJsonError) {
+        throw new Error('Workflows require a valid eas.json. Please run "eas build:configure" to create it.');
+    }
+    else if (error instanceof errors_1.InvalidEasJsonError) {
+        throw new Error('Workflows require a valid eas.json. Please fix the errors in your eas.json and try again.\n\n' +
+            error.message);
+    }
+    else if (error instanceof YAML.YAMLParseError) {
+        log_1.default.error(`YAML syntax error: ${error.message}`);
+    }
+    else if (error instanceof core_1.CombinedError) {
+        workflowFile_1.WorkflowFile.maybePrintWorkflowFileValidationErrors({
+            error,
+        });
+        throw error;
+    }
+    else if (error instanceof Error) {
+        log_1.default.error(`Error: ${error.message}`);
+    }
+    else {
+        log_1.default.error(`Unexpected error: ${String(error)}`);
+    }
+}
+exports.logWorkflowValidationErrors = logWorkflowValidationErrors;
+function validateWorkflowIsNotEmpty(parsedYaml) {
+    if (parsedYaml === null ||
+        parsedYaml === undefined ||
+        (typeof parsedYaml === 'object' && Object.keys(parsedYaml).length === 0)) {
+        throw new Error('YAML file is empty or contains only comments.');
+    }
+}
+async function validateWorkflowOnServerAsync(graphqlClient, projectId, workflowFileContents) {
+    await WorkflowRevisionMutation_1.WorkflowRevisionMutation.validateWorkflowYamlConfigAsync(graphqlClient, {
+        appId: projectId,
+        yamlConfig: workflowFileContents.yamlConfig,
+    });
+}
+async function validateWorkflowBuildJobsAsync(parsedYaml, projectDir) {
+    const jobs = jobsFromWorkflow(parsedYaml);
+    const buildJobs = jobs.filter(job => jobTypesWithBuildProfile.has(job.value.type));
+    if (buildJobs.length === 0) {
+        return;
+    }
+    const easJsonAccessor = eas_json_1.EasJsonAccessor.fromProjectPath(projectDir);
+    const buildProfileNames = new Set(easJsonAccessor && (await eas_json_1.EasJsonUtils.getBuildProfileNamesAsync(easJsonAccessor)));
+    const invalidBuildJobs = buildJobs.filter(job => !buildProfileNames.has(job.value.params.profile) &&
+        // If a profile name is interpolated, we can't check if it's valid until the workflow actually runs
+        !buildProfileIsInterpolated(job.value.params.profile));
+    if (invalidBuildJobs.length > 0) {
+        const invalidBuildProfiles = new Set(invalidBuildJobs.map(job => job.value.params.profile));
+        throw new Error(`The build jobs in this workflow refer to the following build profiles that are not present in your eas.json file: ${[
+            ...invalidBuildProfiles,
+        ].join(', ')}`);
+    }
+}
+function validateWorkflowJobTypes(parsedYaml, workflowJsonSchema) {
+    const jobs = jobsFromWorkflow(parsedYaml);
+    const jobTypes = jobTypesFromWorkflowSchema(workflowJsonSchema);
+    const invalidJobs = jobs.filter(job => job.value.type && !jobTypes.includes(job.value.type));
+    if (invalidJobs.length > 0) {
+        throw new Error(`The following jobs have invalid types: ${invalidJobs
+            .map(job => job.key)
+            .join(', ')}. Valid types are: ${jobTypes.join(', ')}`);
+    }
+}
+function validateWorkflowStructure(parsedYaml, workflowJsonSchema) {
+    delete workflowJsonSchema['$schema'];
+    const ajv = (0, ajv_1.createValidator)();
+    const validate = ajv.compile(workflowJsonSchema);
+    const result = validate(parsedYaml);
+    if (!result) {
+        log_1.default.debug(JSON.stringify({
+            errors: validate.errors,
+        }, null, 2));
+        const readableErrors = (0, ajv_1.getReadableErrors)(validate.errors ?? []);
+        const processedErrors = new Set();
+        for (const err of readableErrors) {
+            if (err.message) {
+                processedErrors.add(err.message);
+            }
+        }
+        throw new Error([...processedErrors].join('\n'));
+    }
+}
+function parsedYamlFromWorkflowContents(workflowFileContents) {
+    const parsedYaml = YAML.parse(workflowFileContents.yamlConfig);
+    return parsedYaml;
+}
+// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+async function fetchWorkflowSchemaAsync() {
+    // EXPO_TESTING_WORKFLOW_SCHEMA_PATH is used only for testing against a different schema
+    if (process.env.EXPO_TESTING_WORKFLOW_SCHEMA_PATH) {
+        const schemaPath = path_1.default.resolve(process.env.EXPO_TESTING_WORKFLOW_SCHEMA_PATH);
+        log_1.default.debug(`Loading workflow schema from ${schemaPath}`);
+        const jsonString = await fs_1.promises.readFile(schemaPath, 'utf-8');
+        const jsonFromFile = JSON.parse(jsonString);
+        return jsonFromFile.data;
+    }
+    // Otherwise, we fetch from <ApiBaseUrl>/v2/workflows/schema
+    const schemaUrl = (0, api_1.getExpoApiWorkflowSchemaURL)();
+    log_1.default.debug(`Fetching workflow schema from ${schemaUrl}`);
+    const response = await fetch(schemaUrl);
+    if (!response.ok) {
+        throw new Error(`Unable to fetch EAS Workflow schema, received status: ${response.status}`);
+    }
+    const jsonResponse = (await response.json());
+    return jsonResponse.data;
+}
+function jobsFromWorkflow(parsedYaml) {
+    return Object.entries(parsedYaml?.jobs).flatMap(([key, value]) => {
+        return {
+            key,
+            value,
+        };
+    });
+}
+function jobTypesFromWorkflowSchema(workflowJsonSchema) {
+    return workflowJsonSchema?.properties?.jobs?.additionalProperties?.anyOf.map((props) => props.properties.type.const);
+}

package/build/commands/build/configure.js

@@ -12,10 +12,10 @@ const log_1 = tslib_1.__importStar(require("../../log"));
 const platform_1 = require("../../platform");
 const projectUtils_1 = require("../../project/projectUtils");
 const workflow_1 = require("../../project/workflow");
-const prompts_1 = require("../../prompts");
 const UpdatesModule_1 = require("../../update/android/UpdatesModule");
 const configure_2 = require("../../update/configure");
 const UpdatesModule_2 = require("../../update/ios/UpdatesModule");
+const prompts_1 = require("../../utils/prompts");
 class BuildConfigure extends EasCommand_1.default {
     static description = 'configure the project to support EAS Build';
     static flags = {
@@ -93,24 +93,7 @@ class BuildConfigure extends EasCommand_1.default {
 exports.default = BuildConfigure;
 async function promptForPlatformAsync() {
     log_1.default.addNewLineIfNone();
-    const { platform } = await (0, prompts_1.promptAsync)({
-        type: 'select',
+    return await (0, prompts_1.promptPlatformAsync)({
         message: 'Which platforms would you like to configure for EAS Build?',
-        name: 'platform',
-        choices: [
-            {
-                title: 'All',
-                value: platform_1.RequestedPlatform.All,
-            },
-            {
-                title: 'iOS',
-                value: platform_1.RequestedPlatform.Ios,
-            },
-            {
-                title: 'Android',
-                value: platform_1.RequestedPlatform.Android,
-            },
-        ],
     });
-    return platform;
 }

package/build/commands/env/create.js

@@ -130,7 +130,6 @@ class EnvCreate extends EasCommand_1.default {
                     value,
                     visibility,
                     environments,
-                    isGlobal: true, // TODO: every account-wide variable is global for now so it's not user facing
                     type: type ?? generated_1.EnvironmentSecretType.String,
                 }, ownerAccount.id);
             if (!variable) {

package/build/commands/project/new.d.ts

@@ -0,0 +1,33 @@
+import EasCommand from '../../commandUtils/EasCommand';
+import { ExpoGraphqlClient } from '../../commandUtils/context/contextUtils/createGraphqlClient';
+import { AppFragment } from '../../graphql/generated';
+import { PackageManager } from '../../onboarding/installDependencies';
+import { Choice } from '../../prompts';
+import { Actor } from '../../user/User';
+export declare function promptForTargetDirectoryAsync(targetProjectDirFromArgs?: string): Promise<string>;
+export declare function cloneTemplateAsync(targetProjectDir: string): Promise<string>;
+export declare function installProjectDependenciesAsync(projectDir: string): Promise<PackageManager>;
+export declare function getAccountChoices(actor: Actor, namesWithSufficientPermissions: Set<string>): Choice[];
+export declare function createProjectAsync(graphqlClient: ExpoGraphqlClient, actor: Actor, projectDir: string): Promise<string>;
+export declare function stripInvalidCharactersForBundleIdentifier(string: string): string;
+export declare function generateConfigFilesAsync(projectDir: string, app: AppFragment): Promise<void>;
+export declare function generateAppConfigAsync(projectDir: string, app: AppFragment): Promise<void>;
+export declare function generateEasConfigAsync(projectDir: string): Promise<void>;
+export declare function updatePackageJsonAsync(projectDir: string): Promise<void>;
+export declare function copyProjectTemplatesAsync(projectDir: string): Promise<void>;
+export declare function mergeReadmeAsync(projectDir: string): Promise<void>;
+export declare function initializeGitRepositoryAsync(projectDir: string): Promise<void>;
+export declare const formatScriptCommand: (script: string, packageManager: PackageManager) => string;
+export default class New extends EasCommand {
+    static aliases: string[];
+    static description: string;
+    static flags: {};
+    static hidden: boolean;
+    static args: {
+        name: string;
+    }[];
+    static contextDefinition: {
+        loggedIn: import("../../commandUtils/context/LoggedInContextField").default;
+    };
+    runAsync(): Promise<void>;
+}

package/build/commands/project/new.js

@@ -0,0 +1,349 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatScriptCommand = exports.initializeGitRepositoryAsync = exports.mergeReadmeAsync = exports.copyProjectTemplatesAsync = exports.updatePackageJsonAsync = exports.generateEasConfigAsync = exports.generateAppConfigAsync = exports.generateConfigFilesAsync = exports.stripInvalidCharactersForBundleIdentifier = exports.createProjectAsync = exports.getAccountChoices = exports.installProjectDependenciesAsync = exports.cloneTemplateAsync = exports.promptForTargetDirectoryAsync = void 0;
+const tslib_1 = require("tslib");
+const eas_json_1 = require("@expo/eas-json");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const fs_extra_1 = tslib_1.__importDefault(require("fs-extra"));
+const nullthrows_1 = tslib_1.__importDefault(require("nullthrows"));
+const path_1 = tslib_1.__importDefault(require("path"));
+const ts_deepmerge_1 = tslib_1.__importDefault(require("ts-deepmerge"));
+const api_1 = require("../../api");
+const url_1 = require("../../build/utils/url");
+const EasCommand_1 = tslib_1.__importDefault(require("../../commandUtils/EasCommand"));
+const generated_1 = require("../../graphql/generated");
+const AppMutation_1 = require("../../graphql/mutations/AppMutation");
+const AppQuery_1 = require("../../graphql/queries/AppQuery");
+const log_1 = tslib_1.__importStar(require("../../log"));
+const git_1 = require("../../onboarding/git");
+const installDependencies_1 = require("../../onboarding/installDependencies");
+const runCommand_1 = require("../../onboarding/runCommand");
+const ora_1 = require("../../ora");
+const expoConfig_1 = require("../../project/expoConfig");
+const fetchOrCreateProjectIDForWriteToConfigWithConfirmationAsync_1 = require("../../project/fetchOrCreateProjectIDForWriteToConfigWithConfirmationAsync");
+const prompts_1 = require("../../prompts");
+const User_1 = require("../../user/User");
+const easCli_1 = require("../../utils/easCli");
+async function promptForTargetDirectoryAsync(targetProjectDirFromArgs) {
+    log_1.default.log(`🚚 Let's start by cloning the default Expo template project from GitHub and installing dependencies.`);
+    log_1.default.newLine();
+    if (targetProjectDirFromArgs) {
+        return targetProjectDirFromArgs;
+    }
+    const result = await (0, prompts_1.promptAsync)({
+        type: 'text',
+        name: 'targetProjectDir',
+        message: 'Where would you like to create your new project directory?',
+        initial: path_1.default.join(process.cwd(), 'new-expo-project'),
+    });
+    return result.targetProjectDir;
+}
+exports.promptForTargetDirectoryAsync = promptForTargetDirectoryAsync;
+async function cloneTemplateAsync(targetProjectDir) {
+    const githubUsername = 'expo';
+    const githubRepositoryName = 'expo-template-default';
+    log_1.default.log(`📂 Cloning the project to ${targetProjectDir}`);
+    log_1.default.newLine();
+    const cloneMethod = (await (0, git_1.canAccessRepositoryUsingSshAsync)({
+        githubUsername,
+        githubRepositoryName,
+    }))
+        ? 'ssh'
+        : 'https';
+    log_1.default.log(chalk_1.default.dim(`We detected that ${cloneMethod} is your preferred git clone method`));
+    log_1.default.newLine();
+    const { targetProjectDir: finalTargetProjectDirectory } = await (0, git_1.runGitCloneAsync)({
+        githubUsername,
+        githubRepositoryName,
+        targetProjectDir,
+        cloneMethod,
+    });
+    return finalTargetProjectDirectory;
+}
+exports.cloneTemplateAsync = cloneTemplateAsync;
+async function installProjectDependenciesAsync(projectDir) {
+    const packageManager = await (0, installDependencies_1.promptForPackageManagerAsync)();
+    await (0, installDependencies_1.installDependenciesAsync)({
+        projectDir,
+        packageManager,
+    });
+    const dependencies = ['expo-updates', '@expo/metro-runtime'];
+    for (const dependency of dependencies) {
+        await (0, runCommand_1.runCommandAsync)({
+            cwd: projectDir,
+            command: 'npx',
+            args: ['expo', 'install', dependency],
+        });
+    }
+    return packageManager;
+}
+exports.installProjectDependenciesAsync = installProjectDependenciesAsync;
+function getAccountChoices(actor, namesWithSufficientPermissions) {
+    const sortedAccounts = actor.accounts.sort((a, _b) => actor.__typename === 'User' ? (a.name === actor.username ? -1 : 1) : 0);
+    return sortedAccounts.map(account => {
+        const isPersonalAccount = actor.__typename === 'User' && account.name === actor.username;
+        const accountDisplayName = isPersonalAccount
+            ? `${account.name} (personal account)`
+            : account.name;
+        const disabled = !namesWithSufficientPermissions.has(account.name);
+        return {
+            title: accountDisplayName,
+            value: { name: account.name },
+            ...(disabled && {
+                disabled: true,
+                description: 'You do not have the required permissions to create projects on this account.',
+            }),
+        };
+    });
+}
+exports.getAccountChoices = getAccountChoices;
+async function createProjectAsync(graphqlClient, actor, projectDir) {
+    const allAccounts = actor.accounts;
+    const accountNamesWhereUserHasSufficientPermissionsToCreateApp = new Set(allAccounts
+        .filter(a => a.users.find(it => it.actor.id === actor.id)?.role !== generated_1.Role.ViewOnly)
+        .map(it => it.name));
+    let accountName = allAccounts[0].name;
+    if (allAccounts.length > 1) {
+        const choices = getAccountChoices(actor, accountNamesWhereUserHasSufficientPermissionsToCreateApp);
+        accountName = (await (0, prompts_1.promptAsync)({
+            type: 'select',
+            name: 'account',
+            message: 'Which account should own this project?',
+            choices,
+        })).account.name;
+    }
+    const projectName = (0, User_1.getActorUsername)(actor) + '-app';
+    const projectFullName = `@${accountName}/${projectName}`;
+    const existingProjectIdOnServer = await (0, fetchOrCreateProjectIDForWriteToConfigWithConfirmationAsync_1.findProjectIdByAccountNameAndSlugNullableAsync)(graphqlClient, accountName, projectName);
+    if (existingProjectIdOnServer) {
+        throw new Error(`Existing project found: ${projectFullName} (ID: ${existingProjectIdOnServer}). Project ID configuration canceled. Re-run the command to select a different account/project.`);
+    }
+    if (!accountNamesWhereUserHasSufficientPermissionsToCreateApp.has(accountName)) {
+        throw new Error(`You don't have permission to create a new project on the ${accountName} account and no matching project already exists on the account.`);
+    }
+    const projectDashboardUrl = (0, url_1.getProjectDashboardUrl)(accountName, projectName);
+    const projectLink = (0, log_1.link)(projectDashboardUrl, { text: projectFullName });
+    const account = (0, nullthrows_1.default)(allAccounts.find(a => a.name === accountName));
+    const spinner = (0, ora_1.ora)(`Creating ${chalk_1.default.bold(projectFullName)}`).start();
+    let projectId;
+    try {
+        projectId = await AppMutation_1.AppMutation.createAppAsync(graphqlClient, {
+            accountId: account.id,
+            projectName,
+        });
+        spinner.succeed(`Created ${chalk_1.default.bold(projectLink)}`);
+    }
+    catch (err) {
+        spinner.fail();
+        throw err;
+    }
+    const exp = await (0, expoConfig_1.getPrivateExpoConfigAsync)(projectDir, { skipPlugins: true });
+    await (0, expoConfig_1.createOrModifyExpoConfigAsync)(projectDir, {
+        extra: { ...exp.extra, eas: { ...exp.extra?.eas, projectId } },
+    }, { skipSDKVersionRequirement: true });
+    log_1.default.withTick(`Project successfully linked (ID: ${chalk_1.default.bold(projectId)}) (modified app.json)`);
+    return projectId;
+}
+exports.createProjectAsync = createProjectAsync;
+function stripInvalidCharactersForBundleIdentifier(string) {
+    return string.replaceAll(/[^A-Za-z0-9]/g, '');
+}
+exports.stripInvalidCharactersForBundleIdentifier = stripInvalidCharactersForBundleIdentifier;
+async function generateConfigFilesAsync(projectDir, app) {
+    await generateAppConfigAsync(projectDir, app);
+    await generateEasConfigAsync(projectDir);
+    await updatePackageJsonAsync(projectDir);
+    await copyProjectTemplatesAsync(projectDir);
+    await mergeReadmeAsync(projectDir);
+}
+exports.generateConfigFilesAsync = generateConfigFilesAsync;
+async function generateAppConfigAsync(projectDir, app) {
+    // Android package name requires each component to start with a lowercase letter.
+    const isUsernameValidSegment = /^[^a-z]/.test(app.ownerAccount.name);
+    const userPrefix = isUsernameValidSegment ? 'user' : '';
+    const isSlugValidSegment = /^[^a-z]/.test(app.slug);
+    const slugPrefix = isSlugValidSegment ? 'app' : '';
+    const bundleIdentifier = `com.${userPrefix}${stripInvalidCharactersForBundleIdentifier(app.ownerAccount.name)}.${slugPrefix}${stripInvalidCharactersForBundleIdentifier(app.slug)}`;
+    const updateUrl = (0, api_1.getEASUpdateURL)(app.id, /* manifestHostOverride */ null);
+    const { expo: baseExpoConfig } = await fs_extra_1.default.readJson(path_1.default.join(projectDir, 'app.json'));
+    const expoConfig = {
+        name: app.name ?? app.slug,
+        slug: app.slug,
+        scheme: stripInvalidCharactersForBundleIdentifier(app.name ?? app.slug),
+        extra: {
+            eas: {
+                projectId: app.id,
+            },
+        },
+        owner: app.ownerAccount.name,
+        updates: {
+            url: updateUrl,
+        },
+        runtimeVersion: {
+            policy: 'appVersion',
+        },
+        ios: {
+            bundleIdentifier,
+        },
+        android: {
+            package: bundleIdentifier,
+        },
+    };
+    const mergedConfig = (0, ts_deepmerge_1.default)(baseExpoConfig, expoConfig);
+    const appJsonPath = path_1.default.join(projectDir, 'app.json');
+    await fs_extra_1.default.writeJson(appJsonPath, { expo: mergedConfig }, { spaces: 2 });
+    log_1.default.withTick(`Generated ${chalk_1.default.bold('app.json')}. ${(0, log_1.learnMore)('https://docs.expo.dev/versions/latest/config/app/')}`);
+    log_1.default.log();
+}
+exports.generateAppConfigAsync = generateAppConfigAsync;
+async function generateEasConfigAsync(projectDir) {
+    const easBuildGitHubConfig = {
+        android: {
+            image: 'latest',
+        },
+        ios: {
+            image: 'latest',
+        },
+    };
+    const easJson = {
+        cli: {
+            version: `>= ${easCli_1.easCliVersion}`,
+            appVersionSource: eas_json_1.AppVersionSource.REMOTE,
+        },
+        build: {
+            development: {
+                developmentClient: true,
+                distribution: 'internal',
+                ...easBuildGitHubConfig,
+            },
+            'development-simulator': {
+                extends: 'development',
+                ios: {
+                    simulator: true,
+                },
+            },
+            preview: {
+                distribution: 'internal',
+                channel: 'main',
+                ...easBuildGitHubConfig,
+            },
+            production: {
+                channel: 'production',
+                autoIncrement: true,
+                ...easBuildGitHubConfig,
+            },
+        },
+        submit: {
+            production: {},
+        },
+    };
+    const easJsonPath = path_1.default.join(projectDir, 'eas.json');
+    await fs_extra_1.default.writeJson(easJsonPath, easJson, { spaces: 2 });
+    log_1.default.withTick(`Generated ${chalk_1.default.bold('eas.json')}. ${(0, log_1.learnMore)('https://docs.expo.dev/build-reference/eas-json/')}`);
+    log_1.default.log();
+}
+exports.generateEasConfigAsync = generateEasConfigAsync;
+async function updatePackageJsonAsync(projectDir) {
+    const packageJsonPath = path_1.default.join(projectDir, 'package.json');
+    const packageJson = await fs_extra_1.default.readJson(packageJsonPath);
+    if (!packageJson.scripts) {
+        packageJson.scripts = {};
+    }
+    packageJson.scripts.preview = 'npx eas-cli@latest workflow:run publish-preview-update.yml';
+    packageJson.scripts['development-builds'] =
+        'npx eas-cli@latest workflow:run create-development-builds.yml';
+    packageJson.scripts.deploy = 'npx eas-cli@latest workflow:run deploy-to-production.yml';
+    await fs_extra_1.default.writeJson(packageJsonPath, packageJson, { spaces: 2 });
+    log_1.default.withTick('Updated package.json with scripts');
+    log_1.default.log();
+}
+exports.updatePackageJsonAsync = updatePackageJsonAsync;
+async function copyProjectTemplatesAsync(projectDir) {
+    const templatesSourceDir = path_1.default.join(__dirname, 'templates', '.eas', 'workflows');
+    const easWorkflowsTargetDir = path_1.default.join(projectDir, '.eas', 'workflows');
+    await fs_extra_1.default.copy(templatesSourceDir, easWorkflowsTargetDir, {
+        overwrite: true,
+        errorOnExist: false,
+    });
+    log_1.default.withTick('Created EAS workflow files');
+    log_1.default.log();
+}
+exports.copyProjectTemplatesAsync = copyProjectTemplatesAsync;
+async function mergeReadmeAsync(projectDir) {
+    const readmeTemplatePath = path_1.default.join(__dirname, 'templates', 'readme-additions.md');
+    const projectReadmePath = path_1.default.join(projectDir, 'README.md');
+    const readmeAdditions = await fs_extra_1.default.readFile(readmeTemplatePath, 'utf8');
+    const existingReadme = await fs_extra_1.default.readFile(projectReadmePath, 'utf8');
+    const targetSection = '## Get a fresh project';
+    const sectionIndex = existingReadme.indexOf(targetSection);
+    let mergedReadme;
+    if (sectionIndex !== -1) {
+        // Insert before "## Get a fresh project" section
+        const beforeSection = existingReadme.substring(0, sectionIndex).trim();
+        const afterSection = existingReadme.substring(sectionIndex);
+        mergedReadme = beforeSection + '\n\n' + readmeAdditions.trim() + '\n\n' + afterSection;
+    }
+    else {
+        // Append to the end if section doesn't exist
+        mergedReadme = existingReadme.trim() + '\n\n' + readmeAdditions.trim() + '\n';
+    }
+    await fs_extra_1.default.writeFile(projectReadmePath, mergedReadme);
+    log_1.default.withTick('Updated README.md with EAS configuration details');
+    log_1.default.log();
+}
+exports.mergeReadmeAsync = mergeReadmeAsync;
+async function initializeGitRepositoryAsync(projectDir) {
+    await fs_extra_1.default.remove(path_1.default.join(projectDir, '.git'));
+    const commands = [['init'], ['add', '.'], ['commit', '-m', 'Initial commit']];
+    for (const args of commands) {
+        await (0, runCommand_1.runCommandAsync)({
+            cwd: projectDir,
+            command: 'git',
+            args,
+        });
+        log_1.default.log();
+    }
+}
+exports.initializeGitRepositoryAsync = initializeGitRepositoryAsync;
+const formatScriptCommand = (script, packageManager) => {
+    if (packageManager === 'npm') {
+        return `npm run ${script}`;
+    }
+    return `${packageManager} ${script}`;
+};
+exports.formatScriptCommand = formatScriptCommand;
+class New extends EasCommand_1.default {
+    static aliases = ['new'];
+    static description = "create a new project set up with Expo's services.";
+    static flags = {};
+    static hidden = true;
+    static args = [{ name: 'TARGET_PROJECT_DIRECTORY' }];
+    static contextDefinition = {
+        ...this.ContextOptions.LoggedIn,
+    };
+    async runAsync() {
+        const { args } = await this.parse(New);
+        const { loggedIn: { actor, graphqlClient }, } = await this.getContextAsync(New, { nonInteractive: false });
+        if (actor.__typename === 'Robot') {
+            throw new Error('This command is not available for robot users. Make sure you are not using a robot token and try again.');
+        }
+        log_1.default.warn('This command is not yet implemented. It will create a new project, but it will not be fully configured.');
+        log_1.default.log(`👋 Welcome to Expo, ${actor.username}!`);
+        log_1.default.newLine();
+        const targetProjectDirectory = await promptForTargetDirectoryAsync(args.TARGET_PROJECT_DIRECTORY);
+        const projectDirectory = await cloneTemplateAsync(targetProjectDirectory);
+        const packageManager = await installProjectDependenciesAsync(projectDirectory);
+        const projectId = await createProjectAsync(graphqlClient, actor, projectDirectory);
+        const app = await AppQuery_1.AppQuery.byIdAsync(graphqlClient, projectId);
+        await generateConfigFilesAsync(projectDirectory, app);
+        await initializeGitRepositoryAsync(projectDirectory);
+        log_1.default.log('🎉 We finished creating your new project.');
+        log_1.default.log('Next steps:');
+        log_1.default.withInfo(`Run \`cd ${projectDirectory}\` to navigate to your project.`);
+        log_1.default.withInfo(`Run \`${(0, exports.formatScriptCommand)('preview', packageManager)}\` to create a preview build on EAS. ${(0, log_1.learnMore)('https://docs.expo.dev/eas/workflows/examples/publish-preview-update/')}`);
+        log_1.default.withInfo(`Run \`${(0, exports.formatScriptCommand)('start', packageManager)}\` to start developing locally. ${(0, log_1.learnMore)('https://docs.expo.dev/get-started/start-developing/')}`);
+        log_1.default.withInfo(`See the README.md for more information about your project.`);
+        log_1.default.newLine();
+    }
+}
+exports.default = New;

package/build/commands/project/onboarding.js

@@ -100,7 +100,7 @@ class Onboarding extends EasCommand_1.default {
         }))
             ? 'ssh'
             : 'https';
-        log_1.default.log(chalk_1.default.dim(`We detected that ${cloneMethod} is your preffered git clone method`));
+        log_1.default.log(chalk_1.default.dim(`We detected that ${cloneMethod} is your preferred git clone method`));
         log_1.default.log();
         const { targetProjectDir: finalTargetProjectDirectory } = await (0, git_1.runGitCloneAsync)({
             githubUsername,

package/build/commands/workflow/run.js

@@ -132,8 +132,6 @@ class WorkflowRun extends EasCommand_1.default {
             if (error instanceof core_2.CombinedError) {
                 workflowFile_1.WorkflowFile.maybePrintWorkflowFileValidationErrors({
                     error,
-                    accountName: account.name,
-                    projectName,
                 });
                 throw error;
             }

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

@@ -11,6 +11,7 @@ export declare class WorkflowValidate extends EasCommand {
     };
     static contextDefinition: {
         loggedIn: import("../../commandUtils/context/LoggedInContextField").default;
+        projectId: import("../../commandUtils/context/ProjectIdContextField").ProjectIdContextField;
         projectDir: import("../../commandUtils/context/ProjectDirContextField").default;
         getDynamicPublicProjectConfigAsync: import("../../commandUtils/context/DynamicProjectConfigContextField").DynamicPublicProjectConfigContextField;
         getDynamicPrivateProjectConfigAsync: import("../../commandUtils/context/DynamicProjectConfigContextField").DynamicPrivateProjectConfigContextField;