eoas 1.0.2 → 1.0.3

package/dist/lib/expoConfig.d.ts

@@ -0,0 +1,23 @@
+import { ExpoConfig } from '@expo/config';
+import { Env } from '@expo/eas-build-job';
+export declare 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;
+}
+export declare function getPrivateExpoConfigAsync(projectDir: string, opts?: ExpoConfigOptions): Promise<ExpoConfig>;
+export declare function ensureExpoConfigExists(projectDir: string): void;
+export declare function isUsingStaticExpoConfig(projectDir: string): boolean;
+export declare function getPublicExpoConfigAsync(projectDir: string, opts?: ExpoConfigOptions): Promise<PublicExpoConfig>;
+export declare function getExpoConfigUpdateUrl(config: ExpoConfig): string | undefined;
+export declare function createOrModifyExpoConfigAsync(projectDir: string, exp: Partial<ExpoConfig>): Promise<void>;

package/dist/lib/expoConfig.js

@@ -0,0 +1,198 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createOrModifyExpoConfigAsync = exports.getExpoConfigUpdateUrl = exports.getPublicExpoConfigAsync = exports.isUsingStaticExpoConfig = exports.ensureExpoConfigExists = exports.getPrivateExpoConfigAsync = exports.RequestedPlatform = void 0;
+const tslib_1 = require("tslib");
+// This file is copied from eas-cli[https://github.com/expo/eas-cli] to ensure consistent user experience across the CLI.
+const config_1 = require("@expo/config");
+const spawn_async_1 = tslib_1.__importDefault(require("@expo/spawn-async"));
+const fs_extra_1 = tslib_1.__importDefault(require("fs-extra"));
+const joi_1 = tslib_1.__importDefault(require("joi"));
+const jscodeshift_1 = tslib_1.__importDefault(require("jscodeshift"));
+const path_1 = tslib_1.__importDefault(require("path"));
+const log_1 = tslib_1.__importDefault(require("./log"));
+const package_1 = require("./package");
+var RequestedPlatform;
+(function (RequestedPlatform) {
+    RequestedPlatform["Android"] = "android";
+    RequestedPlatform["Ios"] = "ios";
+    RequestedPlatform["All"] = "all";
+})(RequestedPlatform || (exports.RequestedPlatform = RequestedPlatform = {}));
+let wasExpoConfigWarnPrinted = false;
+async function getExpoConfigInternalAsync(projectDir, opts = {}) {
+    const originalProcessEnv = process.env;
+    try {
+        process.env = {
+            ...process.env,
+            ...opts.env,
+        };
+        let exp;
+        if ((0, package_1.isExpoInstalled)(projectDir)) {
+            try {
+                const { stdout } = await (0, spawn_async_1.default)('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) {
+                if (!wasExpoConfigWarnPrinted) {
+                    log_1.default.warn(`Failed to read the app config from the project using "npx expo config" command: ${err.message}.`);
+                    log_1.default.warn('Falling back to the version of "@expo/config" shipped with the EAS CLI.');
+                    wasExpoConfigWarnPrinted = true;
+                }
+                exp = (0, config_1.getConfig)(projectDir, {
+                    skipSDKVersionRequirement: true,
+                    ...(opts.isPublicConfig ? { isPublicConfig: true } : {}),
+                    ...(opts.skipPlugins ? { skipPlugins: true } : {}),
+                }).exp;
+            }
+        }
+        else {
+            exp = (0, config_1.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_1.default.object({
+    slug: joi_1.default.string().required(),
+    name: joi_1.default.string().required(),
+    version: joi_1.default.string(),
+    android: joi_1.default.object({
+        versionCode: joi_1.default.number().integer(),
+    }),
+    ios: joi_1.default.object({
+        buildNumber: joi_1.default.string(),
+    }),
+});
+async function getPrivateExpoConfigAsync(projectDir, opts = {}) {
+    ensureExpoConfigExists(projectDir);
+    return await getExpoConfigInternalAsync(projectDir, { ...opts, isPublicConfig: false });
+}
+exports.getPrivateExpoConfigAsync = getPrivateExpoConfigAsync;
+function ensureExpoConfigExists(projectDir) {
+    const paths = (0, config_1.getConfigFilePaths)(projectDir);
+    if (!paths?.staticConfigPath && !paths?.dynamicConfigPath) {
+        // eslint-disable-next-line node/no-sync
+        fs_extra_1.default.writeFileSync(path_1.default.join(projectDir, 'app.json'), JSON.stringify({ expo: {} }, null, 2));
+    }
+}
+exports.ensureExpoConfigExists = ensureExpoConfigExists;
+function isUsingStaticExpoConfig(projectDir) {
+    const paths = (0, config_1.getConfigFilePaths)(projectDir);
+    return !!(paths.staticConfigPath?.endsWith('app.json') && !paths.dynamicConfigPath);
+}
+exports.isUsingStaticExpoConfig = isUsingStaticExpoConfig;
+async function getPublicExpoConfigAsync(projectDir, opts = {}) {
+    ensureExpoConfigExists(projectDir);
+    return await getExpoConfigInternalAsync(projectDir, { ...opts, isPublicConfig: true });
+}
+exports.getPublicExpoConfigAsync = getPublicExpoConfigAsync;
+function getExpoConfigUpdateUrl(config) {
+    return config.updates?.url;
+}
+exports.getExpoConfigUpdateUrl = getExpoConfigUpdateUrl;
+async function createOrModifyExpoConfigAsync(projectDir, exp) {
+    try {
+        ensureExpoConfigExists(projectDir);
+        const configPathJS = path_1.default.join(projectDir, 'app.config.js');
+        const configPathTS = path_1.default.join(projectDir, 'app.config.ts');
+        // eslint-disable-next-line node/no-sync
+        const hasJsConfig = fs_extra_1.default.existsSync(configPathJS);
+        if (isUsingStaticExpoConfig(projectDir)) {
+            log_1.default.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_extra_1.default.writeFileSync(configPathJS, newConfigContent);
+        }
+        else if (hasJsConfig) {
+            // eslint-disable-next-line node/no-sync
+            const existingCode = fs_extra_1.default.readFileSync(configPathJS, 'utf8');
+            const j = jscodeshift_1.default;
+            const ast = 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_extra_1.default.writeFileSync(configPathJS, updatedCode);
+        }
+        else if (configPathTS) {
+            log_1.default.warn('TypeScript support is not yet implemented.');
+            throw new Error('TypeScript support is not yet implemented.');
+        }
+    }
+    catch (e) {
+        log_1.default.withInfo('An error occurred while updating the Expo config. Please update it manually.');
+        log_1.default.newLine();
+        log_1.default.warn('Please modify your app.config.ts file manually by adding the following code:');
+        log_1.default.newLine();
+        log_1.default.withInfo(`${stringifyWithEnv(exp)}`);
+        log_1.default.newLine();
+        throw e;
+    }
+}
+exports.createOrModifyExpoConfigAsync = createOrModifyExpoConfigAsync;
+function updateObjectExpression(j, configObject, updates) {
+    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, value) {
+    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) {
+    return JSON.stringify(obj, null, 2).replace(/"process\.env\.(\w+)"/g, 'process.env.$1');
+}

package/dist/lib/log.d.ts

@@ -0,0 +1,40 @@
+export default class Log {
+    static readonly isDebug: boolean;
+    static log(...args: any[]): void;
+    static newLine(): void;
+    static addNewLineIfNone(): void;
+    static error(...args: any[]): void;
+    static warn(...args: any[]): void;
+    static debug(...args: any[]): void;
+    static gray(...args: any[]): void;
+    static warnDeprecatedFlag(flag: string, message: string): void;
+    static fail(message: string): void;
+    static succeed(message: string): void;
+    static withTick(...args: any[]): void;
+    static withInfo(...args: any[]): void;
+    private static consoleLog;
+    private static withTextColor;
+    private static isLastLineNewLine;
+    private static updateIsLastLineNewLine;
+}
+/**
+ * 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 declare function link(url: string, { text, fallback, dim }?: {
+    text?: string;
+    dim?: boolean;
+    fallback?: string;
+}): string;
+/**
+ * Provide a consistent "Learn more" link experience.
+ * Format links as dim (unless disabled) with an underline.
+ *
+ * @example Learn more: https://expo.dev
+ */
+export declare function learnMore(url: string, { learnMoreMessage: maybeLearnMoreMessage, dim, }?: {
+    learnMoreMessage?: string;
+    dim?: boolean;
+}): string;

package/dist/lib/log.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.learnMore = exports.link = void 0;
+const tslib_1 = require("tslib");
+// This file is copied from eas-cli[https://github.com/expo/eas-cli] to ensure consistent user experience across the CLI.
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const figures_1 = tslib_1.__importDefault(require("figures"));
+const getenv_1 = require("getenv");
+const log_symbols_1 = tslib_1.__importDefault(require("log-symbols"));
+const terminal_link_1 = tslib_1.__importDefault(require("terminal-link"));
+class Log {
+    static isDebug = (0, getenv_1.boolish)('DEBUG', false);
+    static log(...args) {
+        Log.consoleLog(...args);
+    }
+    static newLine() {
+        Log.consoleLog();
+    }
+    static addNewLineIfNone() {
+        if (!Log.isLastLineNewLine) {
+            Log.newLine();
+        }
+    }
+    static error(...args) {
+        Log.consoleLog(...Log.withTextColor(args, chalk_1.default.red));
+    }
+    static warn(...args) {
+        Log.consoleLog(...Log.withTextColor(args, chalk_1.default.yellow));
+    }
+    static debug(...args) {
+        if (Log.isDebug) {
+            Log.consoleLog(...args);
+        }
+    }
+    static gray(...args) {
+        Log.consoleLog(...Log.withTextColor(args, chalk_1.default.gray));
+    }
+    static warnDeprecatedFlag(flag, message) {
+        Log.warn(`› ${chalk_1.default.bold('--' + flag)} flag is deprecated. ${message}`);
+    }
+    static fail(message) {
+        Log.log(`${chalk_1.default.red(log_symbols_1.default.error)} ${message}`);
+    }
+    static succeed(message) {
+        Log.log(`${chalk_1.default.green(log_symbols_1.default.success)} ${message}`);
+    }
+    static withTick(...args) {
+        Log.consoleLog(chalk_1.default.green(figures_1.default.tick), ...args);
+    }
+    static withInfo(...args) {
+        Log.consoleLog(chalk_1.default.green(figures_1.default.info), ...args);
+    }
+    static consoleLog(...args) {
+        Log.updateIsLastLineNewLine(args);
+        // eslint-disable-next-line no-console
+        console.log(...args);
+    }
+    static withTextColor(args, chalkColor) {
+        return args.map(arg => chalkColor(arg));
+    }
+    static isLastLineNewLine = false;
+    static updateIsLastLineNewLine(args) {
+        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;
+            }
+        }
+    }
+}
+exports.default = Log;
+/**
+ * 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
+ */
+function link(url, { text = url, fallback, dim = true } = {}) {
+    // Links can be disabled via env variables https://github.com/jamestalmage/supports-hyperlinks/blob/master/index.js
+    const output = (0, terminal_link_1.default)(text, url, {
+        fallback: () => fallback ?? (text === url ? chalk_1.default.underline(url) : `${text}: ${chalk_1.default.underline(url)}`),
+    });
+    return dim ? chalk_1.default.dim(output) : output;
+}
+exports.link = link;
+/**
+ * Provide a consistent "Learn more" link experience.
+ * Format links as dim (unless disabled) with an underline.
+ *
+ * @example Learn more: https://expo.dev
+ */
+function learnMore(url, { learnMoreMessage: maybeLearnMoreMessage, dim = true, } = {}) {
+    return link(url, { text: maybeLearnMoreMessage ?? 'Learn more', dim });
+}
+exports.learnMore = learnMore;

package/dist/lib/ora.d.ts

@@ -0,0 +1,9 @@
+import { Options, Ora } from 'ora';
+export { Ora, Options };
+/**
+ * A custom ora spinner that sends the stream to stdout in CI, or non-TTY, instead of stderr (the default).
+ *
+ * @param options
+ * @returns
+ */
+export declare function ora(options?: Options | string): Ora;

package/dist/lib/ora.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ora = void 0;
+const tslib_1 = require("tslib");
+// This file is copied from eas-cli[https://github.com/expo/eas-cli] to ensure consistent user experience across the CLI.
+const getenv_1 = require("getenv");
+// eslint-disable-next-line
+const ora_1 = tslib_1.__importDefault(require("ora"));
+const log_1 = tslib_1.__importDefault(require("./log"));
+// 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 = (0, getenv_1.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
+ */
+function ora(options) {
+    const inputOptions = typeof options === 'string' ? { text: options } : options ?? {};
+    const disabled = log_1.default.isDebug || !process.stdin.isTTY || isCi;
+    const spinner = (0, ora_1.default)({
+        // 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, args) => {
+        oraStop();
+        method(...args);
+        spinner.start();
+    };
+    const wrapNativeLogs = () => {
+        // eslint-disable-next-line no-console
+        console.log = (...args) => {
+            logWrap(logReal, args);
+        };
+        // eslint-disable-next-line no-console
+        console.info = (...args) => {
+            logWrap(infoReal, args);
+        };
+        // eslint-disable-next-line no-console
+        console.warn = (...args) => {
+            logWrap(warnReal, args);
+        };
+        // eslint-disable-next-line no-console
+        console.error = (...args) => {
+            logWrap(errorReal, args);
+        };
+    };
+    const resetNativeLogs = () => {
+        // 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) => {
+        // 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) => {
+        const result = oraStopAndPersist(options);
+        resetNativeLogs();
+        return result;
+    };
+    spinner.stop = () => {
+        const result = oraStop();
+        resetNativeLogs();
+        return result;
+    };
+    return spinner;
+}
+exports.ora = ora;

package/dist/lib/package.d.ts

@@ -0,0 +1 @@
+export declare function isExpoInstalled(projectDir: string): boolean;

package/dist/lib/package.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isExpoInstalled = void 0;
+const config_1 = require("@expo/config");
+function isExpoInstalled(projectDir) {
+    const packageJson = (0, config_1.getPackageJson)(projectDir);
+    return !!(packageJson.dependencies && 'expo' in packageJson.dependencies);
+}
+exports.isExpoInstalled = isExpoInstalled;

package/dist/lib/prompts.d.ts

@@ -0,0 +1,13 @@
+import prompts, { Answers, Choice, Options } from 'prompts';
+export interface ExpoChoice<T> extends Choice {
+    value: T;
+}
+export declare function promptAsync<T extends string = string>(questions: prompts.PromptObject<T> | prompts.PromptObject<T>[], options?: Options): Promise<Answers<T>>;
+export declare function confirmAsync(question: prompts.PromptObject<any>, options?: Options): Promise<boolean>;
+export declare function selectAsync<T>(message: string, choices: ExpoChoice<T>[], config?: {
+    options?: Options;
+    initial?: T;
+    warningMessageForDisabledEntries?: string;
+}): Promise<T>;
+export declare function toggleConfirmAsync(questions: prompts.PromptObject<any>, options?: Options): Promise<boolean>;
+export declare function pressAnyKeyToContinueAsync(): Promise<void>;

package/dist/lib/prompts.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pressAnyKeyToContinueAsync = exports.toggleConfirmAsync = exports.selectAsync = exports.confirmAsync = exports.promptAsync = void 0;
+const tslib_1 = require("tslib");
+// This file is copied from eas-cli[https://github.com/expo/eas-cli] to ensure consistent user experience across the CLI.
+const os_1 = require("os");
+const prompts_1 = tslib_1.__importDefault(require("prompts"));
+async function promptAsync(questions, options = {}) {
+    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 (0, prompts_1.default)(questions, {
+        onCancel() {
+            process.exit(os_1.constants.signals.SIGINT + 128); // Exit code 130 used when process is interrupted with ctrl+c.
+        },
+        ...options,
+    });
+}
+exports.promptAsync = promptAsync;
+async function confirmAsync(question, options) {
+    const { value } = await promptAsync({
+        initial: true,
+        ...question,
+        name: 'value',
+        type: 'confirm',
+    }, options);
+    return value;
+}
+exports.confirmAsync = confirmAsync;
+async function selectAsync(message, choices, config) {
+    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;
+}
+exports.selectAsync = selectAsync;
+async function toggleConfirmAsync(questions, options) {
+    const { value } = await promptAsync({
+        active: 'yes',
+        inactive: 'no',
+        ...questions,
+        name: 'value',
+        type: 'toggle',
+    }, options);
+    return value ?? null;
+}
+exports.toggleConfirmAsync = toggleConfirmAsync;
+async function pressAnyKeyToContinueAsync() {
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.setEncoding('utf8');
+    await new Promise(res => {
+        process.stdin.on('data', key => {
+            if (String(key) === '\u0003') {
+                process.exit(os_1.constants.signals.SIGINT + 128); // ctrl-c
+            }
+            res();
+        });
+    });
+}
+exports.pressAnyKeyToContinueAsync = pressAnyKeyToContinueAsync;

package/dist/lib/repo.d.ts

@@ -0,0 +1,6 @@
+import { Client } from './vcs/vcs';
+export declare function commitPromptAsync(vcsClient: Client, { initialCommitMessage, commitAllFiles, }?: {
+    initialCommitMessage?: string;
+    commitAllFiles?: boolean;
+}): Promise<void>;
+export declare function ensureRepoIsCleanAsync(vcsClient: Client, nonInteractive?: boolean): Promise<void>;

package/dist/lib/repo.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureRepoIsCleanAsync = exports.commitPromptAsync = void 0;
+const tslib_1 = require("tslib");
+// This file is copied from eas-cli[https://github.com/expo/eas-cli] to ensure consistent user experience across the CLI.
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const log_1 = tslib_1.__importDefault(require("./log"));
+const prompts_1 = require("./prompts");
+async function commitPromptAsync(vcsClient, { initialCommitMessage, commitAllFiles, } = {}) {
+    const { message } = await (0, prompts_1.promptAsync)({
+        type: 'text',
+        name: 'message',
+        message: 'Commit message:',
+        initial: initialCommitMessage,
+        validate: (input) => input !== '',
+    });
+    await vcsClient.commitAsync({
+        commitAllFiles,
+        commitMessage: message,
+        nonInteractive: false,
+    });
+}
+exports.commitPromptAsync = commitPromptAsync;
+async function ensureRepoIsCleanAsync(vcsClient, nonInteractive = false) {
+    if (!(await vcsClient.isCommitRequiredAsync())) {
+        return;
+    }
+    log_1.default.addNewLineIfNone();
+    log_1.default.warn(`${chalk_1.default.bold('Warning!')} Your repository working tree is dirty.`);
+    log_1.default.log(`This operation needs to be run on a clean working tree. ${chalk_1.default.bold('Commit all your changes before proceeding')}.`);
+    if (nonInteractive) {
+        log_1.default.log('The following files need to be committed:');
+        await vcsClient.showChangedFilesAsync();
+        throw new Error('Commit all changes. Aborting...');
+    }
+    const answer = await (0, prompts_1.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...');
+    }
+}
+exports.ensureRepoIsCleanAsync = ensureRepoIsCleanAsync;

package/dist/lib/runtimeVersion.d.ts

@@ -0,0 +1,42 @@
+import { ExpoConfig } from '@expo/config';
+import { Env, Workflow } from '@expo/eas-build-job';
+export declare class ExpoUpdatesCLIModuleNotFoundError extends Error {
+}
+export declare class ExpoUpdatesCLIInvalidCommandError extends Error {
+}
+export declare class ExpoUpdatesCLICommandFailedError extends Error {
+}
+export declare function expoUpdatesCommandAsync(projectDir: string, args: string[], options: {
+    env: Env | undefined;
+    cwd?: string;
+}): Promise<string>;
+export declare function isModernExpoUpdatesCLIWithRuntimeVersionCommandSupportedAsync(projectDir: string): Promise<boolean>;
+export declare function resolveRuntimeVersionUsingCLIAsync({ platform, workflow, projectDir, env, cwd, }: {
+    platform: 'ios' | 'android';
+    workflow: Workflow;
+    projectDir: string;
+    env: Env | undefined;
+    cwd?: string;
+}): Promise<{
+    runtimeVersion: string | null;
+    expoUpdatesRuntimeFingerprint: {
+        fingerprintSources: object[];
+        isDebugFingerprintSource: boolean;
+    } | null;
+    expoUpdatesRuntimeFingerprintHash: string | null;
+}>;
+export declare function resolveRuntimeVersionAsync({ exp, platform, workflow, projectDir, env, cwd, }: {
+    exp: ExpoConfig;
+    platform: 'ios' | 'android';
+    workflow: Workflow;
+    projectDir: string;
+    env: Env | undefined;
+    cwd?: string;
+}): Promise<{
+    runtimeVersion: string | null;
+    expoUpdatesRuntimeFingerprint: {
+        fingerprintSources: object[];
+        isDebugFingerprintSource: boolean;
+    } | null;
+    expoUpdatesRuntimeFingerprintHash: string | null;
+} | null>;