eas-cli 16.22.0 → 16.23.1

package/build/build/android/graphql.js

@@ -4,7 +4,6 @@ exports.transformJob = void 0;
 const eas_build_job_1 = require("@expo/eas-build-job");
 const generated_1 = require("../../graphql/generated");
 const graphql_1 = require("../graphql");
-const environment_1 = require("../utils/environment");
 function transformJob(job) {
     return {
         type: (0, graphql_1.transformWorkflow)(job.type),
@@ -25,7 +24,7 @@ function transformJob(job) {
         experimental: job.experimental,
         mode: (0, graphql_1.transformBuildMode)(job.mode),
         customBuildConfig: job.customBuildConfig,
-        environment: (0, environment_1.buildProfileEnvironmentToEnvironment)(job.environment),
+        environment: job.environment,
         loggerLevel: job.loggerLevel
             ? graphql_1.loggerLevelToGraphQLWorkerLoggerLevel[job.loggerLevel]
             : undefined,

package/build/build/evaluateConfigWithEnvVarsAsync.js

@@ -23,14 +23,8 @@ async function evaluateConfigWithEnvVarsAsync({ buildProfile, buildProfileName,
 }
 exports.evaluateConfigWithEnvVarsAsync = evaluateConfigWithEnvVarsAsync;
 async function resolveEnvVarsAsync({ buildProfile, buildProfileName, graphqlClient, projectId, }) {
-    const environment = buildProfile.environment?.toUpperCase() ??
+    const environment = buildProfile.environment ??
         resolveSuggestedEnvironmentForBuildProfileConfiguration(buildProfile);
-    if (!(0, environment_1.isEnvironment)(environment)) {
-        log_1.default.log(`Loaded "env" configuration for the "${buildProfileName}" profile: ${buildProfile.env && Object.keys(buildProfile.env).length > 0
-            ? Object.keys(buildProfile.env).join(', ')
-            : 'no environment variables specified'}. ${(0, log_1.learnMore)('https://docs.expo.dev/build-reference/variables/')}`);
-        return { ...buildProfile.env };
-    }
     try {
         const environmentVariables = await EnvironmentVariablesQuery_1.EnvironmentVariablesQuery.byAppIdWithSensitiveAsync(graphqlClient, {
             appId: projectId,
@@ -68,10 +62,10 @@ async function resolveEnvVarsAsync({ buildProfile, buildProfileName, graphqlClie
 }
 function resolveSuggestedEnvironmentForBuildProfileConfiguration(buildProfile) {
     const environment = buildProfile.distribution === 'store'
-        ? environment_1.EnvironmentVariableEnvironment.Production
+        ? environment_1.DefaultEnvironment.Production
         : buildProfile.developmentClient
-            ? environment_1.EnvironmentVariableEnvironment.Development
-            : environment_1.EnvironmentVariableEnvironment.Preview;
-    log_1.default.log(`Resolved "${environment.toLowerCase()}" environment for the build. ${(0, log_1.learnMore)('https://docs.expo.dev/eas/environment-variables/#setting-the-environment-for-your-builds')}`);
+            ? environment_1.DefaultEnvironment.Development
+            : environment_1.DefaultEnvironment.Preview;
+    log_1.default.log(`Resolved "${environment}" environment for the build. ${(0, log_1.learnMore)('https://docs.expo.dev/eas/environment-variables/#setting-the-environment-for-your-builds')}`);
     return environment;
 }

package/build/build/ios/graphql.js

@@ -4,7 +4,6 @@ exports.transformIosSecrets = exports.transformJob = void 0;
 const tslib_1 = require("tslib");
 const nullthrows_1 = tslib_1.__importDefault(require("nullthrows"));
 const graphql_1 = require("../graphql");
-const environment_1 = require("../utils/environment");
 function transformJob(job) {
     return {
         type: (0, graphql_1.transformWorkflow)(job.type),
@@ -26,7 +25,7 @@ function transformJob(job) {
         experimental: job.experimental,
         mode: (0, graphql_1.transformBuildMode)(job.mode),
         customBuildConfig: job.customBuildConfig,
-        environment: (0, environment_1.buildProfileEnvironmentToEnvironment)(job.environment),
+        environment: job.environment,
         loggerLevel: job.loggerLevel
             ? graphql_1.loggerLevelToGraphQLWorkerLoggerLevel[job.loggerLevel]
             : undefined,

package/build/build/utils/environment.d.ts

@@ -1,8 +1,5 @@
-import { BuildProfile } from '@expo/eas-json';
-export declare enum EnvironmentVariableEnvironment {
+export declare enum DefaultEnvironment {
     Development = "development",
     Preview = "preview",
     Production = "production"
 }
-export declare function isEnvironment(env: string): env is EnvironmentVariableEnvironment;
-export declare function buildProfileEnvironmentToEnvironment(environment: BuildProfile['environment']): EnvironmentVariableEnvironment | null;

package/build/build/utils/environment.js

@@ -1,26 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildProfileEnvironmentToEnvironment = exports.isEnvironment = exports.EnvironmentVariableEnvironment = void 0;
-// Default environments
-var EnvironmentVariableEnvironment;
-(function (EnvironmentVariableEnvironment) {
-    EnvironmentVariableEnvironment["Development"] = "development";
-    EnvironmentVariableEnvironment["Preview"] = "preview";
-    EnvironmentVariableEnvironment["Production"] = "production";
-})(EnvironmentVariableEnvironment || (exports.EnvironmentVariableEnvironment = EnvironmentVariableEnvironment = {}));
-const BuildProfileEnvironmentToEnvironment = {
-    production: EnvironmentVariableEnvironment.Production,
-    preview: EnvironmentVariableEnvironment.Preview,
-    development: EnvironmentVariableEnvironment.Development,
-};
-function isEnvironment(env) {
-    return Object.values(EnvironmentVariableEnvironment).includes(env.toLowerCase());
-}
-exports.isEnvironment = isEnvironment;
-function buildProfileEnvironmentToEnvironment(environment) {
-    if (!environment) {
-        return null;
-    }
-    return BuildProfileEnvironmentToEnvironment[environment];
-}
-exports.buildProfileEnvironmentToEnvironment = buildProfileEnvironmentToEnvironment;
+exports.DefaultEnvironment = void 0;
+var DefaultEnvironment;
+(function (DefaultEnvironment) {
+    DefaultEnvironment["Development"] = "development";
+    DefaultEnvironment["Preview"] = "preview";
+    DefaultEnvironment["Production"] = "production";
+})(DefaultEnvironment || (exports.DefaultEnvironment = DefaultEnvironment = {}));

package/build/commandUtils/EasCommand.d.ts

@@ -12,7 +12,6 @@ import { ProjectIdContextField } from './context/ProjectIdContextField';
 import { ServerSideEnvironmentVariablesContextField } from './context/ServerSideEnvironmentVariablesContextField';
 import SessionManagementContextField from './context/SessionManagementContextField';
 import VcsClientContextField from './context/VcsClientContextField';
-import { EnvironmentVariableEnvironment } from '../build/utils/environment';
 import { Client } from '../vcs/vcs';
 export type ContextInput<T extends {
     [name: string]: any;
@@ -32,7 +31,7 @@ interface BaseGetContextAsyncArgs {
     vcsClientOverride?: Client;
 }
 interface GetContextAsyncArgsWithRequiredServerSideEnvironmentArgument extends BaseGetContextAsyncArgs {
-    withServerSideEnvironment: EnvironmentVariableEnvironment | null;
+    withServerSideEnvironment: string | null;
 }
 interface GetContextAsyncArgsWithoutServerSideEnvironmentArgument extends BaseGetContextAsyncArgs {
     withServerSideEnvironment?: never;

package/build/commandUtils/context/ContextField.d.ts

@@ -1,5 +1,4 @@
 import { Analytics } from '../../analytics/AnalyticsManager';
-import { EnvironmentVariableEnvironment } from '../../build/utils/environment';
 import SessionManager from '../../user/SessionManager';
 import { Client } from '../../vcs/vcs';
 export interface ContextOptions {
@@ -10,7 +9,7 @@ export interface ContextOptions {
     /**
      * If specified, env variables from the selected environment will be fetched from the server and used to evaluate the dynamic config.
      */
-    withServerSideEnvironment?: EnvironmentVariableEnvironment | null;
+    withServerSideEnvironment?: string | null;
 }
 export default abstract class ContextField<T> {
     abstract getValueAsync(options: ContextOptions): Promise<T>;

package/build/commandUtils/context/contextUtils/loadServerSideEnvironmentVariablesAsync.d.ts

@@ -1,7 +1,6 @@
 import { ExpoGraphqlClient } from './createGraphqlClient';
-import { EnvironmentVariableEnvironment } from '../../../build/utils/environment';
 export declare function loadServerSideEnvironmentVariablesAsync({ environment, projectId, graphqlClient, }: {
-    environment: EnvironmentVariableEnvironment;
+    environment: string;
     projectId: string;
     graphqlClient: ExpoGraphqlClient;
 }): Promise<Record<string, string>>;

package/build/commandUtils/context/contextUtils/loadServerSideEnvironmentVariablesAsync.js

@@ -2,14 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.loadServerSideEnvironmentVariablesAsync = void 0;
 const tslib_1 = require("tslib");
-const environment_1 = require("../../../build/utils/environment");
 const EnvironmentVariablesQuery_1 = require("../../../graphql/queries/EnvironmentVariablesQuery");
 const log_1 = tslib_1.__importDefault(require("../../../log"));
-const cachedServerSideEnvironmentVariables = {
-    [environment_1.EnvironmentVariableEnvironment.Development]: null,
-    [environment_1.EnvironmentVariableEnvironment.Preview]: null,
-    [environment_1.EnvironmentVariableEnvironment.Production]: null,
-};
+const cachedServerSideEnvironmentVariables = {};
 async function loadServerSideEnvironmentVariablesAsync({ environment, projectId, graphqlClient, }) {
     // don't load environment variables if they were already loaded while executing a command
     const cachedEnvVarsForEnvironment = cachedServerSideEnvironmentVariables[environment];
@@ -24,10 +19,10 @@ async function loadServerSideEnvironmentVariablesAsync({ environment, projectId,
         .filter(({ name, value }) => name && value)
         .map(({ name, value }) => [name, value]));
     if (Object.keys(serverEnvVars).length > 0) {
-        log_1.default.log(`Environment variables with visibility "Plain text" and "Sensitive" loaded from the "${environment.toLowerCase()}" environment on EAS: ${Object.keys(serverEnvVars).join(', ')}.`);
+        log_1.default.log(`Environment variables with visibility "Plain text" and "Sensitive" loaded from the "${environment}" environment on EAS: ${Object.keys(serverEnvVars).join(', ')}.`);
     }
     else {
-        log_1.default.log(`No environment variables with visibility "Plain text" and "Sensitive" found for the "${environment.toLowerCase()}" environment on EAS.`);
+        log_1.default.log(`No environment variables with visibility "Plain text" and "Sensitive" found for the "${environment}" environment on EAS.`);
     }
     log_1.default.newLine();
     cachedServerSideEnvironmentVariables[environment] = serverEnvVars;

package/build/commandUtils/flags.d.ts

@@ -1,17 +1,15 @@
-import { EnvironmentVariableEnvironment } from '../build/utils/environment';
 export declare const EasNonInteractiveAndJsonFlags: {
     json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
     'non-interactive': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
 };
 export declare const EasEnvironmentFlagParameters: {
     description: string;
-    options: EnvironmentVariableEnvironment[];
 };
 export declare const EASEnvironmentFlag: {
-    environment: import("@oclif/core/lib/interfaces").OptionFlag<EnvironmentVariableEnvironment | undefined>;
+    environment: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined>;
 };
 export declare const EASMultiEnvironmentFlag: {
-    environment: import("@oclif/core/lib/interfaces").OptionFlag<EnvironmentVariableEnvironment[] | undefined>;
+    environment: import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined>;
 };
 export declare const EASVariableFormatFlag: {
     format: import("@oclif/core/lib/interfaces").OptionFlag<string>;
@@ -30,5 +28,5 @@ export declare const EasJsonOnlyFlag: {
     json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
 };
 export declare const EasUpdateEnvironmentFlag: {
-    environment: import("@oclif/core/lib/interfaces").OptionFlag<EnvironmentVariableEnvironment | null>;
+    environment: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined>;
 };

package/build/commandUtils/flags.js

@@ -2,15 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EasUpdateEnvironmentFlag = exports.EasJsonOnlyFlag = exports.EASNonInteractiveFlag = exports.EASEnvironmentVariableScopeFlag = exports.EASVariableVisibilityFlag = exports.EASVariableFormatFlag = exports.EASMultiEnvironmentFlag = exports.EASEnvironmentFlag = exports.EasEnvironmentFlagParameters = exports.EasNonInteractiveAndJsonFlags = void 0;
 const core_1 = require("@oclif/core");
-const environment_1 = require("../build/utils/environment");
-// NOTE: not exactly true, but, provided mapToLowercase and upperCaseAsync
-// are used in tandem, it saves on unnecessary typying in commands
-async function upperCaseAsync(input) {
-    return input.toUpperCase();
-}
-function mapToLowercase(options) {
-    return options.map(option => option.toLowerCase());
-}
 exports.EasNonInteractiveAndJsonFlags = {
     json: core_1.Flags.boolean({
         description: 'Enable JSON output, non-JSON messages will be printed to stderr.',
@@ -21,18 +12,15 @@ exports.EasNonInteractiveAndJsonFlags = {
     }),
 };
 exports.EasEnvironmentFlagParameters = {
-    description: "Environment variable's environment",
-    options: mapToLowercase([
-        environment_1.EnvironmentVariableEnvironment.Development,
-        environment_1.EnvironmentVariableEnvironment.Preview,
-        environment_1.EnvironmentVariableEnvironment.Production,
-    ]),
+    description: "Environment variable's environment, e.g. 'production', 'preview', 'development'",
 };
 exports.EASEnvironmentFlag = {
-    environment: core_1.Flags.enum(exports.EasEnvironmentFlagParameters),
+    environment: core_1.Flags.string({
+        description: "Environment variable's environment, e.g. 'production', 'preview', 'development'",
+    }),
 };
 exports.EASMultiEnvironmentFlag = {
-    environment: core_1.Flags.enum({
+    environment: core_1.Flags.string({
         ...exports.EasEnvironmentFlagParameters,
         multiple: true,
     }),
@@ -68,11 +56,9 @@ exports.EasJsonOnlyFlag = {
     }),
 };
 exports.EasUpdateEnvironmentFlag = {
-    environment: core_1.Flags.enum({
-        description: 'Environment to use for the server-side defined EAS environment variables during command execution.',
-        options: mapToLowercase(Object.values(environment_1.EnvironmentVariableEnvironment)),
-        parse: upperCaseAsync,
+    environment: core_1.Flags.string({
+        description: 'Environment to use for the server-side defined EAS environment variables during command execution, e.g. "production", "preview", "development"',
         required: false,
-        default: null,
+        default: undefined,
     }),
 };

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

@@ -0,0 +1,4 @@
+import { PackageManager } from '../../onboarding/installDependencies';
+export declare function cloneTemplateAsync(targetProjectDir: string): Promise<string>;
+export declare function installProjectDependenciesAsync(projectDir: string, packageManager: PackageManager): Promise<void>;
+export declare function initializeGitRepositoryAsync(projectDir: string): Promise<void>;

package/build/commandUtils/new/commands.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initializeGitRepositoryAsync = exports.installProjectDependenciesAsync = exports.cloneTemplateAsync = void 0;
+const tslib_1 = require("tslib");
+const fs_extra_1 = tslib_1.__importDefault(require("fs-extra"));
+const path_1 = tslib_1.__importDefault(require("path"));
+const log_1 = tslib_1.__importDefault(require("../../log"));
+const git_1 = require("../../onboarding/git");
+const installDependencies_1 = require("../../onboarding/installDependencies");
+const runCommand_1 = require("../../onboarding/runCommand");
+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';
+    const { targetProjectDir: finalTargetProjectDirectory } = await (0, git_1.runGitCloneAsync)({
+        githubUsername,
+        githubRepositoryName,
+        targetProjectDir,
+        cloneMethod,
+    });
+    return finalTargetProjectDirectory;
+}
+exports.cloneTemplateAsync = cloneTemplateAsync;
+async function installProjectDependenciesAsync(projectDir, packageManager) {
+    await (0, installDependencies_1.installDependenciesAsync)({
+        outputLevel: 'none',
+        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],
+            showOutput: false,
+        });
+    }
+}
+exports.installProjectDependenciesAsync = installProjectDependenciesAsync;
+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,
+            showOutput: false,
+        });
+        log_1.default.log();
+    }
+}
+exports.initializeGitRepositoryAsync = initializeGitRepositoryAsync;

package/build/commandUtils/new/configs.d.ts

@@ -0,0 +1,25 @@
+import { Choice } from '../../prompts';
+import { Actor } from '../../user/User';
+import { ExpoGraphqlClient } from '../context/contextUtils/createGraphqlClient';
+export declare function generateProjectConfigAsync(actor: Actor, pathArg: string | undefined, options: {
+    graphqlClient: ExpoGraphqlClient;
+    projectAccount: string;
+}): Promise<{
+    projectName: string;
+    projectDirectory: string;
+}>;
+export declare function promptForProjectAccountAsync(actor: Actor): Promise<string>;
+export declare function getAccountChoices(actor: Actor, permissionsMap?: Map<string, boolean>): Choice[];
+export declare function generateProjectNameVariations(actor: Actor, baseName: string): string[];
+/**
+ * Finds an available project name that doesn't conflict with either:
+ * Local filesystem (directory already exists)
+ * Remote server (project already exists on Expo)
+ */
+export declare function findAvailableProjectNameAsync(actor: Actor, baseName: string, parentDirectory: string, { graphqlClient, projectAccount, }: {
+    graphqlClient: ExpoGraphqlClient;
+    projectAccount: string;
+}): Promise<{
+    projectName: string;
+    projectDirectory: string;
+}>;

package/build/commandUtils/new/configs.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findAvailableProjectNameAsync = exports.generateProjectNameVariations = exports.getAccountChoices = exports.promptForProjectAccountAsync = exports.generateProjectConfigAsync = void 0;
+const tslib_1 = require("tslib");
+const fs_extra_1 = tslib_1.__importDefault(require("fs-extra"));
+const nanoid_1 = require("nanoid");
+const path_1 = tslib_1.__importDefault(require("path"));
+const generated_1 = require("../../graphql/generated");
+const log_1 = tslib_1.__importDefault(require("../../log"));
+const fetchOrCreateProjectIDForWriteToConfigWithConfirmationAsync_1 = require("../../project/fetchOrCreateProjectIDForWriteToConfigWithConfirmationAsync");
+const prompts_1 = require("../../prompts");
+const User_1 = require("../../user/User");
+function validateProjectPath(resolvedPath) {
+    const normalizedPath = path_1.default.normalize(resolvedPath);
+    // Check for path traversal attempts
+    if (normalizedPath.includes('..')) {
+        throw new Error(`Invalid project path: "${resolvedPath}". Path traversal is not allowed.`);
+    }
+    // Ensure we're not trying to create a project in system directories
+    const systemDirs = ['/bin', '/sbin', '/etc', '/usr', '/var', '/sys', '/proc', '/dev'];
+    const isSystemDir = systemDirs.some(dir => normalizedPath === dir || normalizedPath.startsWith(dir + path_1.default.sep));
+    if (isSystemDir) {
+        throw new Error(`Invalid project path: "${resolvedPath}". Cannot create projects in system directories.`);
+    }
+}
+async function generateProjectConfigAsync(actor, pathArg, options) {
+    let baseName = 'new-expo-project';
+    let parentDirectory = process.cwd();
+    if (pathArg) {
+        const resolvedPath = path_1.default.isAbsolute(pathArg) ? pathArg : path_1.default.resolve(process.cwd(), pathArg);
+        validateProjectPath(resolvedPath);
+        baseName = path_1.default.basename(resolvedPath);
+        parentDirectory = path_1.default.dirname(resolvedPath);
+    }
+    // Find an available name checking both local filesystem and remote server
+    const { projectName, projectDirectory } = await findAvailableProjectNameAsync(actor, baseName, parentDirectory, options);
+    log_1.default.withInfo(`Using project directory: ${projectDirectory}`);
+    return {
+        projectName,
+        projectDirectory,
+    };
+}
+exports.generateProjectConfigAsync = generateProjectConfigAsync;
+function getAccountPermissionsMap(actor) {
+    const permissionsMap = new Map();
+    for (const account of actor.accounts) {
+        const hasPermission = account.users.find(it => it.actor.id === actor.id)?.role !== generated_1.Role.ViewOnly;
+        permissionsMap.set(account.name, hasPermission);
+    }
+    return permissionsMap;
+}
+async function promptForProjectAccountAsync(actor) {
+    const permissionsMap = getAccountPermissionsMap(actor);
+    // If only one account, use it (if has permissions)
+    if (actor.accounts.length === 1) {
+        const account = actor.accounts[0];
+        if (permissionsMap.get(account.name)) {
+            return account.name;
+        }
+        throw new Error(`You don't have permission to create projects on your only available account (${account.name}).`);
+    }
+    // Multiple accounts - prompt user to select one with permissions
+    return (await (0, prompts_1.promptAsync)({
+        type: 'select',
+        name: 'account',
+        message: 'Which account should own this project?',
+        choices: getAccountChoices(actor, permissionsMap),
+    })).account.name;
+}
+exports.promptForProjectAccountAsync = promptForProjectAccountAsync;
+function getAccountChoices(actor, permissionsMap) {
+    const permissions = permissionsMap ?? getAccountPermissionsMap(actor);
+    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 = !permissions.get(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;
+function generateProjectNameVariations(actor, baseName) {
+    const username = (0, User_1.getActorUsername)(actor);
+    const date = new Date().toISOString().split('T')[0];
+    return [
+        baseName,
+        `${baseName}-${username}-${date}`,
+        `${baseName}-${username}-${date}-${(0, nanoid_1.nanoid)(6)}`,
+    ];
+}
+exports.generateProjectNameVariations = generateProjectNameVariations;
+async function verifyProjectDoesNotExistAsync(graphqlClient, accountName, projectName, { silent = false } = {}) {
+    const existingProjectId = await (0, fetchOrCreateProjectIDForWriteToConfigWithConfirmationAsync_1.findProjectIdByAccountNameAndSlugNullableAsync)(graphqlClient, accountName, projectName);
+    const doesNotExist = existingProjectId === null;
+    if (!doesNotExist && !silent) {
+        log_1.default.warn(`Project @${accountName}/${projectName} already exists on the server.`);
+    }
+    return doesNotExist;
+}
+/**
+ * Finds an available project name that doesn't conflict with either:
+ * Local filesystem (directory already exists)
+ * Remote server (project already exists on Expo)
+ */
+async function findAvailableProjectNameAsync(actor, baseName, parentDirectory, { graphqlClient, projectAccount, }) {
+    const nameVariations = generateProjectNameVariations(actor, baseName);
+    for (let i = 0; i < nameVariations.length; i++) {
+        const nameVariation = nameVariations[i];
+        const proposedDirectory = path_1.default.join(parentDirectory, nameVariation);
+        const usingVariant = i !== 0;
+        const localExists = await fs_extra_1.default.pathExists(proposedDirectory);
+        if (localExists) {
+            continue;
+        }
+        const remoteAvailable = await verifyProjectDoesNotExistAsync(graphqlClient, projectAccount, nameVariation, { silent: usingVariant });
+        if (!remoteAvailable) {
+            continue;
+        }
+        log_1.default.withInfo(`Using ${usingVariant ? 'alternate ' : ''}project name: ${nameVariation}`);
+        return {
+            projectName: nameVariation,
+            projectDirectory: proposedDirectory,
+        };
+    }
+    throw new Error(`Unable to find a unique project name for "${baseName}". All generated variations already exist.`);
+}
+exports.findAvailableProjectNameAsync = findAvailableProjectNameAsync;

package/build/commandUtils/new/projectFiles.d.ts

@@ -0,0 +1,8 @@
+import { AppFragment } from '../../graphql/generated';
+import { PackageManager } from '../../onboarding/installDependencies';
+export declare function cleanAndPrefix(_string: string, type: 'user' | 'app' | 'scheme'): string;
+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 updateReadmeAsync(projectDir: string, packageManager: PackageManager): Promise<void>;