eoas 1.0.1

package/src/lib/expoConfig.ts

@@ -0,0 +1,265 @@
+// This file is copied from eas-cli[https://github.com/expo/eas-cli] to ensure consistent user experience across the CLI.
+import { ExpoConfig, getConfig, getConfigFilePaths } from '@expo/config';
+import { Env } from '@expo/eas-build-job';
+import spawnAsync from '@expo/spawn-async';
+import fs from 'fs-extra';
+import Joi from 'joi';
+import jscodeshift, { Collection } from 'jscodeshift';
+import path from 'path';
+
+import Log from './log';
+import { isExpoInstalled } from './package';
+
+export enum RequestedPlatform {
+  Android = 'android',
+  Ios = 'ios',
+  All = 'all',
+}
+
+export type PublicExpoConfig = Omit<
+  ExpoConfig,
+  '_internal' | 'hooks' | 'ios' | 'android' | 'updates'
+> & {
+  ios?: Omit<ExpoConfig['ios'], 'config'>;
+  android?: Omit<ExpoConfig['android'], 'config'>;
+  updates?: Omit<ExpoConfig['updates'], 'codeSigningCertificate' | 'codeSigningMetadata'>;
+};
+
+export interface ExpoConfigOptions {
+  env?: Env;
+  skipSDKVersionRequirement?: boolean;
+  skipPlugins?: boolean;
+}
+
+interface ExpoConfigOptionsInternal extends ExpoConfigOptions {
+  isPublicConfig?: boolean;
+}
+
+let wasExpoConfigWarnPrinted = false;
+
+async function getExpoConfigInternalAsync(
+  projectDir: string,
+  opts: ExpoConfigOptionsInternal = {}
+): Promise<ExpoConfig> {
+  const originalProcessEnv: NodeJS.ProcessEnv = process.env;
+  try {
+    process.env = {
+      ...process.env,
+      ...opts.env,
+    };
+
+    let exp: ExpoConfig;
+    if (isExpoInstalled(projectDir)) {
+      try {
+        const { stdout } = await spawnAsync(
+          'npx',
+          ['expo', 'config', '--json', ...(opts.isPublicConfig ? ['--type', 'public'] : [])],
+
+          {
+            cwd: projectDir,
+            env: {
+              ...process.env,
+              ...opts.env,
+              EXPO_NO_DOTENV: '1',
+            },
+          }
+        );
+        exp = JSON.parse(stdout);
+      } catch (err: any) {
+        if (!wasExpoConfigWarnPrinted) {
+          Log.warn(
+            `Failed to read the app config from the project using "npx expo config" command: ${err.message}.`
+          );
+          Log.warn('Falling back to the version of "@expo/config" shipped with the EAS CLI.');
+          wasExpoConfigWarnPrinted = true;
+        }
+        exp = getConfig(projectDir, {
+          skipSDKVersionRequirement: true,
+          ...(opts.isPublicConfig ? { isPublicConfig: true } : {}),
+          ...(opts.skipPlugins ? { skipPlugins: true } : {}),
+        }).exp;
+      }
+    } else {
+      exp = getConfig(projectDir, {
+        skipSDKVersionRequirement: true,
+        ...(opts.isPublicConfig ? { isPublicConfig: true } : {}),
+        ...(opts.skipPlugins ? { skipPlugins: true } : {}),
+      }).exp;
+    }
+
+    const { error } = MinimalAppConfigSchema.validate(exp, {
+      allowUnknown: true,
+      abortEarly: true,
+    });
+    if (error) {
+      throw new Error(`Invalid app config.\n${error.message}`);
+    }
+    return exp;
+  } finally {
+    process.env = originalProcessEnv;
+  }
+}
+
+const MinimalAppConfigSchema = Joi.object({
+  slug: Joi.string().required(),
+  name: Joi.string().required(),
+  version: Joi.string(),
+  android: Joi.object({
+    versionCode: Joi.number().integer(),
+  }),
+  ios: Joi.object({
+    buildNumber: Joi.string(),
+  }),
+});
+
+export async function getPrivateExpoConfigAsync(
+  projectDir: string,
+  opts: ExpoConfigOptions = {}
+): Promise<ExpoConfig> {
+  ensureExpoConfigExists(projectDir);
+  return await getExpoConfigInternalAsync(projectDir, { ...opts, isPublicConfig: false });
+}
+
+export function ensureExpoConfigExists(projectDir: string): void {
+  const paths = getConfigFilePaths(projectDir);
+  if (!paths?.staticConfigPath && !paths?.dynamicConfigPath) {
+    // eslint-disable-next-line node/no-sync
+    fs.writeFileSync(path.join(projectDir, 'app.json'), JSON.stringify({ expo: {} }, null, 2));
+  }
+}
+
+export function isUsingStaticExpoConfig(projectDir: string): boolean {
+  const paths = getConfigFilePaths(projectDir);
+  return !!(paths.staticConfigPath?.endsWith('app.json') && !paths.dynamicConfigPath);
+}
+
+export async function getPublicExpoConfigAsync(
+  projectDir: string,
+  opts: ExpoConfigOptions = {}
+): Promise<PublicExpoConfig> {
+  ensureExpoConfigExists(projectDir);
+
+  return await getExpoConfigInternalAsync(projectDir, { ...opts, isPublicConfig: true });
+}
+
+export function getExpoConfigUpdateUrl(config: ExpoConfig): string | undefined {
+  return config.updates?.url;
+}
+
+export async function createOrModifyExpoConfigAsync(
+  projectDir: string,
+  exp: Partial<ExpoConfig>
+): Promise<void> {
+  try {
+    ensureExpoConfigExists(projectDir);
+    const configPathJS = path.join(projectDir, 'app.config.js');
+    const configPathTS = path.join(projectDir, 'app.config.ts');
+
+    // eslint-disable-next-line node/no-sync
+    const hasJsConfig = fs.existsSync(configPathJS);
+
+    if (isUsingStaticExpoConfig(projectDir)) {
+      Log.withInfo(
+        'You are using a static app config. We will create a dynamic config file for you.'
+      );
+
+      const newConfigContent = `export default ({ config }) => ({
+                                ...config,
+                                ...${stringifyWithEnv(exp)}
+                              });`;
+      // eslint-disable-next-line node/no-sync
+      fs.writeFileSync(configPathJS, newConfigContent);
+    } else if (hasJsConfig) {
+      // eslint-disable-next-line node/no-sync
+      const existingCode = fs.readFileSync(configPathJS, 'utf8');
+      const j = jscodeshift;
+      const ast: Collection = j(existingCode);
+
+      ast.find(j.ArrowFunctionExpression).forEach(path => {
+        if (
+          path.value.body &&
+          j.BlockStatement.check(path.value.body) &&
+          path.value.body.body.length > 0
+        ) {
+          const returnStatement = path.value.body.body.find(node => j.ReturnStatement.check(node));
+          if (
+            returnStatement &&
+            j.ReturnStatement.check(returnStatement) &&
+            returnStatement.argument
+          ) {
+            const configObject = returnStatement.argument;
+            if (j.ObjectExpression.check(configObject)) {
+              updateObjectExpression(j, configObject, exp);
+            }
+          }
+        }
+      });
+      const updatedCode = ast.toSource({
+        quote: 'auto',
+        trailingComma: true,
+        reuseWhitespace: true,
+      });
+
+      // eslint-disable-next-line node/no-sync
+      fs.writeFileSync(configPathJS, updatedCode);
+    } else if (configPathTS) {
+      Log.warn('TypeScript support is not yet implemented.');
+      throw new Error('TypeScript support is not yet implemented.');
+    }
+  } catch (e) {
+    Log.withInfo('An error occurred while updating the Expo config. Please update it manually.');
+    Log.newLine();
+    Log.warn('Please modify your app.config.ts file manually by adding the following code:');
+    Log.newLine();
+    Log.withInfo(`${stringifyWithEnv(exp)}`);
+    Log.newLine();
+    throw e;
+  }
+}
+
+function updateObjectExpression(
+  j: typeof jscodeshift,
+  configObject: ReturnType<typeof j.objectExpression>,
+  updates: Record<string, any>
+): void {
+  Object.entries(updates).forEach(([key, value]) => {
+    const existingProperty = configObject.properties.find(prop => {
+      return (
+        prop.type === 'Property' &&
+        ((prop.key.type === 'Identifier' && prop.key.name === key) ||
+          (prop.key.type === 'StringLiteral' && prop.key.value === key))
+      );
+    });
+
+    if (existingProperty) {
+      configObject.properties = configObject.properties.filter(prop => prop !== existingProperty);
+    }
+
+    const newProperty = j.objectProperty(j.identifier(key), createValueNode(j, value));
+
+    configObject.properties.push(newProperty);
+  });
+}
+
+function createValueNode(j: typeof jscodeshift, value: any): any {
+  if (typeof value === 'string' && value.startsWith('process.env.')) {
+    return j.memberExpression(
+      j.memberExpression(j.identifier('process'), j.identifier('env')),
+      j.identifier(value.split('.')[2])
+    );
+  }
+
+  if (typeof value === 'object' && value !== null) {
+    return j.objectExpression(
+      Object.entries(value).map(
+        ([key, val]) => j.objectProperty(j.stringLiteral(key), createValueNode(j, val)) // Force stringLiteral pour garder les guillemets
+      )
+    );
+  }
+
+  return j.literal(value);
+}
+
+function stringifyWithEnv(obj: Record<string, any>): string {
+  return JSON.stringify(obj, null, 2).replace(/"process\.env\.(\w+)"/g, 'process.env.$1');
+}

package/src/lib/log.ts

@@ -0,0 +1,122 @@
+// This file is copied from eas-cli[https://github.com/expo/eas-cli] to ensure consistent user experience across the CLI.
+import chalk from 'chalk';
+import figures from 'figures';
+import { boolish } from 'getenv';
+import logSymbols from 'log-symbols';
+import terminalLink from 'terminal-link';
+
+type Color = (...text: string[]) => string;
+
+export default class Log {
+  public static readonly isDebug = boolish('DEBUG', false);
+
+  public static log(...args: any[]): void {
+    Log.consoleLog(...args);
+  }
+
+  public static newLine(): void {
+    Log.consoleLog();
+  }
+
+  public static addNewLineIfNone(): void {
+    if (!Log.isLastLineNewLine) {
+      Log.newLine();
+    }
+  }
+
+  public static error(...args: any[]): void {
+    Log.consoleLog(...Log.withTextColor(args, chalk.red));
+  }
+
+  public static warn(...args: any[]): void {
+    Log.consoleLog(...Log.withTextColor(args, chalk.yellow));
+  }
+
+  public static debug(...args: any[]): void {
+    if (Log.isDebug) {
+      Log.consoleLog(...args);
+    }
+  }
+
+  public static gray(...args: any[]): void {
+    Log.consoleLog(...Log.withTextColor(args, chalk.gray));
+  }
+
+  public static warnDeprecatedFlag(flag: string, message: string): void {
+    Log.warn(`› ${chalk.bold('--' + flag)} flag is deprecated. ${message}`);
+  }
+
+  public static fail(message: string): void {
+    Log.log(`${chalk.red(logSymbols.error)} ${message}`);
+  }
+
+  public static succeed(message: string): void {
+    Log.log(`${chalk.green(logSymbols.success)} ${message}`);
+  }
+
+  public static withTick(...args: any[]): void {
+    Log.consoleLog(chalk.green(figures.tick), ...args);
+  }
+
+  public static withInfo(...args: any[]): void {
+    Log.consoleLog(chalk.green(figures.info), ...args);
+  }
+
+  private static consoleLog(...args: any[]): void {
+    Log.updateIsLastLineNewLine(args);
+    // eslint-disable-next-line no-console
+    console.log(...args);
+  }
+
+  private static withTextColor(args: any[], chalkColor: Color): string[] {
+    return args.map(arg => chalkColor(arg));
+  }
+
+  private static isLastLineNewLine = false;
+  private static updateIsLastLineNewLine(args: any[]): void {
+    if (args.length === 0) {
+      Log.isLastLineNewLine = true;
+    } else {
+      const lastArg = args[args.length - 1];
+      if (typeof lastArg === 'string' && (lastArg === '' || lastArg.match(/[\r\n]$/))) {
+        Log.isLastLineNewLine = true;
+      } else {
+        Log.isLastLineNewLine = false;
+      }
+    }
+  }
+}
+
+/**
+ * Prints a link for given URL, using text if provided, otherwise text is just the URL.
+ * Format links as dim (unless disabled) and with an underline.
+ *
+ * @example https://expo.dev
+ */
+export function link(
+  url: string,
+  { text = url, fallback, dim = true }: { text?: string; dim?: boolean; fallback?: string } = {}
+): string {
+  // Links can be disabled via env variables https://github.com/jamestalmage/supports-hyperlinks/blob/master/index.js
+  const output = terminalLink(text, url, {
+    fallback: () =>
+      fallback ?? (text === url ? chalk.underline(url) : `${text}: ${chalk.underline(url)}`),
+  });
+  return dim ? chalk.dim(output) : output;
+}
+
+/**
+ * Provide a consistent "Learn more" link experience.
+ * Format links as dim (unless disabled) with an underline.
+ *
+ * @example Learn more: https://expo.dev
+ */
+export function learnMore(
+  url: string,
+  {
+    learnMoreMessage: maybeLearnMoreMessage,
+    dim = true,
+  }: { learnMoreMessage?: string; dim?: boolean } = {}
+): string {
+  return link(url, { text: maybeLearnMoreMessage ?? 'Learn more', dim });
+}

package/src/lib/ora.ts

@@ -0,0 +1,113 @@
+// This file is copied from eas-cli[https://github.com/expo/eas-cli] to ensure consistent user experience across the CLI.
+import { boolish } from 'getenv';
+// eslint-disable-next-line
+import oraReal, { Options, Ora } from 'ora';
+
+import Log from './log';
+
+export { Ora, Options };
+
+// eslint-disable-next-line no-console
+const logReal = console.log;
+// eslint-disable-next-line no-console
+const infoReal = console.info;
+// eslint-disable-next-line no-console
+const warnReal = console.warn;
+// eslint-disable-next-line no-console
+const errorReal = console.error;
+
+const isCi = boolish('CI', false);
+
+/**
+ * A custom ora spinner that sends the stream to stdout in CI, or non-TTY, instead of stderr (the default).
+ *
+ * @param options
+ * @returns
+ */
+export function ora(options?: Options | string): Ora {
+  const inputOptions = typeof options === 'string' ? { text: options } : options ?? {};
+  const disabled = Log.isDebug || !process.stdin.isTTY || isCi;
+  const spinner = oraReal({
+    // Ensure our non-interactive mode emulates CI mode.
+    isEnabled: !disabled,
+    // In non-interactive mode, send the stream to stdout so it prevents looking like an error.
+    stream: disabled ? process.stdout : process.stderr,
+    ...inputOptions,
+  });
+
+  const oraStart = spinner.start.bind(spinner);
+  const oraStop = spinner.stop.bind(spinner);
+  const oraStopAndPersist = spinner.stopAndPersist.bind(spinner);
+
+  const logWrap = (method: any, args: any[]): void => {
+    oraStop();
+    method(...args);
+    spinner.start();
+  };
+
+  const wrapNativeLogs = (): void => {
+    // eslint-disable-next-line no-console
+    console.log = (...args: any) => {
+      logWrap(logReal, args);
+    };
+    // eslint-disable-next-line no-console
+    console.info = (...args: any) => {
+      logWrap(infoReal, args);
+    };
+    // eslint-disable-next-line no-console
+    console.warn = (...args: any) => {
+      logWrap(warnReal, args);
+    };
+    // eslint-disable-next-line no-console
+    console.error = (...args: any) => {
+      logWrap(errorReal, args);
+    };
+  };
+
+  const resetNativeLogs = (): void => {
+    // eslint-disable-next-line no-console
+    console.log = logReal;
+    // eslint-disable-next-line no-console
+    console.info = infoReal;
+    // eslint-disable-next-line no-console
+    console.warn = warnReal;
+    // eslint-disable-next-line no-console
+    console.error = errorReal;
+  };
+
+  spinner.start = (text): Ora => {
+    // wrapNativeLogs wraps calls to console so they always:
+    // 1. stop the spinner
+    // 2. log the message
+    // 3. start the spinner again
+    // Every restart of the spinner causes the spinner message to be logged again
+    // which makes logs look like
+    //
+    // - Exporting...
+    // [expo-cli] Starting Metro Bundler
+    // - Exporting...
+    // [expo-cli] Android Bundling complete 3492ms
+    // - Exporting...
+    //
+    // Skipping wrapping native logs removes the repeated interleaved "Exporting..." messages.
+    if (!disabled) {
+      wrapNativeLogs();
+    }
+
+    return oraStart(text);
+  };
+
+  spinner.stopAndPersist = (options): Ora => {
+    const result = oraStopAndPersist(options);
+    resetNativeLogs();
+    return result;
+  };
+
+  spinner.stop = (): Ora => {
+    const result = oraStop();
+    resetNativeLogs();
+    return result;
+  };
+
+  return spinner;
+}

package/src/lib/package.ts

@@ -0,0 +1,6 @@
+import { getPackageJson } from '@expo/config';
+
+export function isExpoInstalled(projectDir: string): boolean {
+  const packageJson = getPackageJson(projectDir);
+  return !!(packageJson.dependencies && 'expo' in packageJson.dependencies);
+}

package/src/lib/prompts.ts

@@ -0,0 +1,97 @@
+// This file is copied from eas-cli[https://github.com/expo/eas-cli] to ensure consistent user experience across the CLI.
+import { constants } from 'os';
+import prompts, { Answers, Choice, Options } from 'prompts';
+
+export interface ExpoChoice<T> extends Choice {
+  value: T;
+}
+
+export async function promptAsync<T extends string = string>(
+  questions: prompts.PromptObject<T> | prompts.PromptObject<T>[],
+  options: Options = {}
+): Promise<Answers<T>> {
+  if (!process.stdin.isTTY) {
+    const message = Array.isArray(questions) ? questions[0]?.message : questions.message;
+    throw new Error(
+      `Input is required, but stdin is not readable. Failed to display prompt: ${message}`
+    );
+  }
+  return await prompts<T>(questions, {
+    onCancel() {
+      process.exit(constants.signals.SIGINT + 128); // Exit code 130 used when process is interrupted with ctrl+c.
+    },
+    ...options,
+  });
+}
+
+export async function confirmAsync(
+  question: prompts.PromptObject<any>,
+  options?: Options
+): Promise<boolean> {
+  const { value } = await promptAsync(
+    {
+      initial: true,
+      ...question,
+      name: 'value',
+      type: 'confirm',
+    },
+    options
+  );
+  return value;
+}
+
+export async function selectAsync<T>(
+  message: string,
+  choices: ExpoChoice<T>[],
+  config?: {
+    options?: Options;
+    initial?: T;
+    warningMessageForDisabledEntries?: string;
+  }
+): Promise<T> {
+  const initial = config?.initial ? choices.findIndex(({ value }) => value === config.initial) : 0;
+  const { value } = await promptAsync(
+    {
+      message,
+      choices,
+      initial,
+      name: 'value',
+      type: 'select',
+      warn: config?.warningMessageForDisabledEntries,
+    },
+    config?.options ?? {}
+  );
+  return value ?? null;
+}
+
+export async function toggleConfirmAsync(
+  questions: prompts.PromptObject<any>,
+  options?: Options
+): Promise<boolean> {
+  const { value } = await promptAsync(
+    {
+      active: 'yes',
+      inactive: 'no',
+      ...questions,
+      name: 'value',
+      type: 'toggle',
+    },
+    options
+  );
+  return value ?? null;
+}
+
+export async function pressAnyKeyToContinueAsync(): Promise<void> {
+  process.stdin.setRawMode(true);
+  process.stdin.resume();
+  process.stdin.setEncoding('utf8');
+
+  await new Promise<void>(res => {
+    process.stdin.on('data', key => {
+      if (String(key) === '\u0003') {
+        process.exit(constants.signals.SIGINT + 128); // ctrl-c
+      }
+      res();
+    });
+  });
+}

package/src/lib/repo.ts

@@ -0,0 +1,62 @@
+// This file is copied from eas-cli[https://github.com/expo/eas-cli] to ensure consistent user experience across the CLI.
+import chalk from 'chalk';
+
+import Log from './log';
+import { confirmAsync, promptAsync } from './prompts';
+import { Client } from './vcs/vcs';
+
+export async function commitPromptAsync(
+  vcsClient: Client,
+  {
+    initialCommitMessage,
+    commitAllFiles,
+  }: {
+    initialCommitMessage?: string;
+    commitAllFiles?: boolean;
+  } = {}
+): Promise<void> {
+  const { message } = await promptAsync({
+    type: 'text',
+    name: 'message',
+    message: 'Commit message:',
+    initial: initialCommitMessage,
+    validate: (input: string) => input !== '',
+  });
+  await vcsClient.commitAsync({
+    commitAllFiles,
+    commitMessage: message,
+    nonInteractive: false,
+  });
+}
+
+export async function ensureRepoIsCleanAsync(
+  vcsClient: Client,
+  nonInteractive = false
+): Promise<void> {
+  if (!(await vcsClient.isCommitRequiredAsync())) {
+    return;
+  }
+  Log.addNewLineIfNone();
+  Log.warn(`${chalk.bold('Warning!')} Your repository working tree is dirty.`);
+  Log.log(
+    `This operation needs to be run on a clean working tree. ${chalk.bold(
+      'Commit all your changes before proceeding'
+    )}.`
+  );
+  if (nonInteractive) {
+    Log.log('The following files need to be committed:');
+    await vcsClient.showChangedFilesAsync();
+
+    throw new Error('Commit all changes. Aborting...');
+  }
+  const answer = await confirmAsync({
+    message: `Commit changes to git?`,
+    type: 'confirm',
+    name: 'confirm git commit',
+  });
+  if (answer) {
+    await commitPromptAsync(vcsClient, { commitAllFiles: true });
+  } else {
+    throw new Error('Commit all changes. Aborting...');
+  }
+}