eoas 1.0.2 → 1.0.3

package/dist/lib/runtimeVersion.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveRuntimeVersionAsync = exports.resolveRuntimeVersionUsingCLIAsync = exports.isModernExpoUpdatesCLIWithRuntimeVersionCommandSupportedAsync = exports.expoUpdatesCommandAsync = exports.ExpoUpdatesCLICommandFailedError = exports.ExpoUpdatesCLIInvalidCommandError = exports.ExpoUpdatesCLIModuleNotFoundError = void 0;
+const tslib_1 = require("tslib");
+const config_plugins_1 = require("@expo/config-plugins");
+const spawn_async_1 = tslib_1.__importDefault(require("@expo/spawn-async"));
+const fs_extra_1 = tslib_1.__importDefault(require("fs-extra"));
+const resolve_from_1 = tslib_1.__importStar(require("resolve-from"));
+const semver_1 = tslib_1.__importDefault(require("semver"));
+const log_1 = tslib_1.__importStar(require("./log"));
+class ExpoUpdatesCLIModuleNotFoundError extends Error {
+}
+exports.ExpoUpdatesCLIModuleNotFoundError = ExpoUpdatesCLIModuleNotFoundError;
+class ExpoUpdatesCLIInvalidCommandError extends Error {
+}
+exports.ExpoUpdatesCLIInvalidCommandError = ExpoUpdatesCLIInvalidCommandError;
+class ExpoUpdatesCLICommandFailedError extends Error {
+}
+exports.ExpoUpdatesCLICommandFailedError = ExpoUpdatesCLICommandFailedError;
+async function expoUpdatesCommandAsync(projectDir, args, options) {
+    let expoUpdatesCli;
+    try {
+        expoUpdatesCli =
+            (0, resolve_from_1.silent)(projectDir, 'expo-updates/bin/cli') ??
+                (0, resolve_from_1.default)(projectDir, 'expo-updates/bin/cli.js');
+    }
+    catch (e) {
+        if (e.code === 'MODULE_NOT_FOUND') {
+            throw new ExpoUpdatesCLIModuleNotFoundError(`The \`expo-updates\` package was not found. Follow the installation directions at ${(0, log_1.link)('https://docs.expo.dev/bare/installing-expo-modules/')}`);
+        }
+        throw e;
+    }
+    try {
+        return (await (0, spawn_async_1.default)(expoUpdatesCli, args, {
+            stdio: 'pipe',
+            env: { ...process.env, ...options.env },
+            cwd: options.cwd,
+        })).stdout;
+    }
+    catch (e) {
+        if (e.stderr && typeof e.stderr === 'string') {
+            if (e.stderr.includes('Invalid command')) {
+                throw new ExpoUpdatesCLIInvalidCommandError(`The command specified by ${args} was not valid in the \`expo-updates\` CLI.`);
+            }
+            else {
+                throw new ExpoUpdatesCLICommandFailedError(e.stderr);
+            }
+        }
+        throw e;
+    }
+}
+exports.expoUpdatesCommandAsync = expoUpdatesCommandAsync;
+async function getExpoUpdatesPackageVersionIfInstalledAsync(projectDir) {
+    const maybePackageJson = resolve_from_1.default.silent(projectDir, 'expo-updates/package.json');
+    if (!maybePackageJson) {
+        return null;
+    }
+    const { version } = await fs_extra_1.default.readJson(maybePackageJson);
+    return version ?? null;
+}
+async function isModernExpoUpdatesCLIWithRuntimeVersionCommandSupportedAsync(projectDir) {
+    const expoUpdatesPackageVersion = await getExpoUpdatesPackageVersionIfInstalledAsync(projectDir);
+    if (expoUpdatesPackageVersion === null) {
+        return false;
+    }
+    if (expoUpdatesPackageVersion.includes('canary')) {
+        return true;
+    }
+    // Anything SDK 51 or greater uses the expo-updates CLI
+    return semver_1.default.gte(expoUpdatesPackageVersion, '0.25.4');
+}
+exports.isModernExpoUpdatesCLIWithRuntimeVersionCommandSupportedAsync = isModernExpoUpdatesCLIWithRuntimeVersionCommandSupportedAsync;
+async function resolveRuntimeVersionUsingCLIAsync({ platform, workflow, projectDir, env, cwd, }) {
+    log_1.default.debug('Using expo-updates runtimeversion:resolve CLI for runtime version resolution');
+    const useDebugFingerprintSource = log_1.default.isDebug;
+    const extraArgs = useDebugFingerprintSource ? ['--debug'] : [];
+    const resolvedRuntimeVersionJSONResult = await expoUpdatesCommandAsync(projectDir, ['runtimeversion:resolve', '--platform', platform, '--workflow', workflow, ...extraArgs], { env, cwd });
+    const runtimeVersionResult = JSON.parse(resolvedRuntimeVersionJSONResult);
+    log_1.default.debug('runtimeversion:resolve output:');
+    log_1.default.debug(resolvedRuntimeVersionJSONResult);
+    return {
+        runtimeVersion: runtimeVersionResult.runtimeVersion ?? null,
+        expoUpdatesRuntimeFingerprint: runtimeVersionResult.fingerprintSources
+            ? {
+                fingerprintSources: runtimeVersionResult.fingerprintSources,
+                isDebugFingerprintSource: useDebugFingerprintSource,
+            }
+            : null,
+        expoUpdatesRuntimeFingerprintHash: runtimeVersionResult.fingerprintSources
+            ? runtimeVersionResult.runtimeVersion
+            : null,
+    };
+}
+exports.resolveRuntimeVersionUsingCLIAsync = resolveRuntimeVersionUsingCLIAsync;
+async function resolveRuntimeVersionAsync({ exp, platform, workflow, projectDir, env, cwd, }) {
+    if (!(await isModernExpoUpdatesCLIWithRuntimeVersionCommandSupportedAsync(projectDir))) {
+        // fall back to the previous behavior (using the @expo/config-plugins eas-cli dependency rather
+        // than the versioned @expo/config-plugins dependency in the project)
+        return {
+            runtimeVersion: await config_plugins_1.Updates.getRuntimeVersionNullableAsync(projectDir, exp, platform),
+            expoUpdatesRuntimeFingerprint: null,
+            expoUpdatesRuntimeFingerprintHash: null,
+        };
+    }
+    try {
+        return await resolveRuntimeVersionUsingCLIAsync({ platform, workflow, projectDir, env, cwd });
+    }
+    catch (e) {
+        // if expo-updates is not installed, there's no need for a runtime version in the build
+        if (e instanceof ExpoUpdatesCLIModuleNotFoundError) {
+            return null;
+        }
+        throw e;
+    }
+}
+exports.resolveRuntimeVersionAsync = resolveRuntimeVersionAsync;

package/dist/lib/utils.d.ts

@@ -0,0 +1 @@
+export declare function isValidUpdateUrl(updateUrl: string): boolean;

package/dist/lib/utils.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isValidUpdateUrl = void 0;
+function isValidUpdateUrl(updateUrl) {
+    return updateUrl.match(/^https?:\/\/[^/]+$/) !== null;
+}
+exports.isValidUpdateUrl = isValidUpdateUrl;

package/dist/lib/vcs/clients/git.d.ts

@@ -0,0 +1,31 @@
+import { Client } from '../vcs';
+export default class GitClient extends Client {
+    private readonly maybeCwdOverride?;
+    constructor(maybeCwdOverride?: string | undefined);
+    ensureRepoExistsAsync(): Promise<void>;
+    commitAsync({ commitMessage, commitAllFiles, nonInteractive, }: {
+        commitMessage: string;
+        commitAllFiles?: boolean;
+        nonInteractive: boolean;
+    }): Promise<void>;
+    isCommitRequiredAsync(): Promise<boolean>;
+    showChangedFilesAsync(): Promise<void>;
+    hasUncommittedChangesAsync(): Promise<boolean>;
+    getRootPathAsync(): Promise<string>;
+    makeShallowCopyAsync(destinationPath: string): Promise<void>;
+    getCommitHashAsync(): Promise<string | undefined>;
+    trackFileAsync(file: string): Promise<void>;
+    getBranchNameAsync(): Promise<string | null>;
+    getLastCommitMessageAsync(): Promise<string | null>;
+    showDiffAsync(): Promise<void>;
+    isFileUntrackedAsync(path: string): Promise<boolean>;
+    isFileIgnoredAsync(filePath: string): Promise<boolean>;
+    canGetLastCommitMessage(): boolean;
+}
+/**
+ * Checks if git is configured to be case sensitive
+ * @returns {boolean | undefined}
+ *    - boolean - is git case sensitive
+ *    - undefined - case sensitivity is not configured and git is using default behavior
+ */
+export declare function isGitCaseSensitiveAsync(cwd: string | undefined): Promise<boolean | undefined>;

package/dist/lib/vcs/clients/git.js

@@ -0,0 +1,322 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isGitCaseSensitiveAsync = void 0;
+const tslib_1 = require("tslib");
+const PackageManagerUtils = tslib_1.__importStar(require("@expo/package-manager"));
+const spawn_async_1 = tslib_1.__importDefault(require("@expo/spawn-async"));
+const core_1 = require("@oclif/core");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const path_1 = tslib_1.__importDefault(require("path"));
+const log_1 = tslib_1.__importStar(require("../../log"));
+const ora_1 = require("../../ora");
+const prompts_1 = require("../../prompts");
+const git_1 = require("../git");
+const vcs_1 = require("../vcs");
+class GitClient extends vcs_1.Client {
+    maybeCwdOverride;
+    constructor(maybeCwdOverride) {
+        super();
+        this.maybeCwdOverride = maybeCwdOverride;
+    }
+    async ensureRepoExistsAsync() {
+        try {
+            if (!(await (0, git_1.isGitInstalledAsync)())) {
+                log_1.default.error(`${chalk_1.default.bold('git')} command not found. Install it before proceeding or set ${chalk_1.default.bold('EAS_NO_VCS=1')} to use EAS CLI without Git (or any other version control system).`);
+                log_1.default.error((0, log_1.learnMore)('https://expo.fyi/eas-vcs-workflow'));
+                core_1.Errors.exit(1);
+            }
+        }
+        catch (error) {
+            log_1.default.error(`${chalk_1.default.bold('git')} found, but ${chalk_1.default.bold('git --help')} exited with status ${error?.status}${error?.stderr ? `:` : '.'}`);
+            if (error?.stderr) {
+                log_1.default.error(error?.stderr);
+            }
+            log_1.default.error(`Repair your Git installation, or set ${chalk_1.default.bold('EAS_NO_VCS=1')} to use EAS CLI without Git (or any other version control system).`);
+            log_1.default.error((0, log_1.learnMore)('https://expo.fyi/eas-vcs-workflow'));
+            core_1.Errors.exit(1);
+        }
+        if (await (0, git_1.doesGitRepoExistAsync)(this.maybeCwdOverride)) {
+            return;
+        }
+        log_1.default.warn("It looks like you haven't initialized the git repository yet.");
+        log_1.default.warn('EAS requires you to use a git repository for your project.');
+        const cwd = process.cwd();
+        const repoRoot = PackageManagerUtils.resolveWorkspaceRoot(cwd) ?? cwd;
+        const confirmInit = await (0, prompts_1.confirmAsync)({
+            message: `Would you like us to run 'git init' in ${this.maybeCwdOverride ?? repoRoot} for you?`,
+            type: 'confirm',
+            name: 'confirmInit',
+        });
+        if (!confirmInit) {
+            throw new Error('A git repository is required for building your project. Initialize it and run this command again.');
+        }
+        await (0, spawn_async_1.default)('git', ['init'], { cwd: this.maybeCwdOverride ?? repoRoot });
+        log_1.default.log("We're going to make an initial commit for your repository.");
+        const { message } = await (0, prompts_1.promptAsync)({
+            type: 'text',
+            name: 'message',
+            message: 'Commit message:',
+            initial: 'Initial commit',
+            validate: (input) => input !== '',
+        });
+        await this.commitAsync({ commitAllFiles: true, commitMessage: message, nonInteractive: false });
+    }
+    async commitAsync({ commitMessage, commitAllFiles, nonInteractive = false, }) {
+        await ensureGitConfiguredAsync({ nonInteractive });
+        try {
+            if (commitAllFiles) {
+                await (0, spawn_async_1.default)('git', ['add', '-A'], {
+                    cwd: this.maybeCwdOverride,
+                });
+            }
+            await (0, spawn_async_1.default)('git', ['add', '-u'], {
+                cwd: this.maybeCwdOverride,
+            });
+            await (0, spawn_async_1.default)('git', ['commit', '-m', commitMessage], {
+                cwd: this.maybeCwdOverride,
+            });
+        }
+        catch (err) {
+            if (err?.stdout) {
+                log_1.default.error(err.stdout);
+            }
+            if (err?.stderr) {
+                log_1.default.error(err.stderr);
+            }
+            throw err;
+        }
+    }
+    async isCommitRequiredAsync() {
+        return await this.hasUncommittedChangesAsync();
+    }
+    async showChangedFilesAsync() {
+        const gitStatusOutput = await (0, git_1.gitStatusAsync)({
+            showUntracked: true,
+            cwd: this.maybeCwdOverride,
+        });
+        log_1.default.log(gitStatusOutput);
+    }
+    async hasUncommittedChangesAsync() {
+        const changes = await (0, git_1.gitStatusAsync)({ showUntracked: true, cwd: this.maybeCwdOverride });
+        return changes.length > 0;
+    }
+    async getRootPathAsync() {
+        return (await (0, spawn_async_1.default)('git', ['rev-parse', '--show-toplevel'], {
+            cwd: this.maybeCwdOverride,
+        })).stdout.trim();
+    }
+    async makeShallowCopyAsync(destinationPath) {
+        if (await this.hasUncommittedChangesAsync()) {
+            // it should already be checked before this function is called, but in case it wasn't
+            // we want to ensure that any changes were introduced by call to `setGitCaseSensitivityAsync`
+            throw new Error('You have some uncommitted changes in your repository.');
+        }
+        let gitRepoUri;
+        if (process.platform === 'win32') {
+            // getRootDirectoryAsync() will return C:/path/to/repo on Windows and path
+            // prefix should be file:///
+            gitRepoUri = `file:///${await this.getRootPathAsync()}`;
+        }
+        else {
+            // getRootDirectoryAsync() will /path/to/repo, and path prefix should be
+            // file:/// so only file:// needs to be prepended
+            gitRepoUri = `file://${await this.getRootPathAsync()}`;
+        }
+        const isCaseSensitive = await isGitCaseSensitiveAsync(this.maybeCwdOverride);
+        await setGitCaseSensitivityAsync(true, this.maybeCwdOverride);
+        try {
+            if (await this.hasUncommittedChangesAsync()) {
+                log_1.default.error('Detected inconsistent filename casing between your local filesystem and git.');
+                log_1.default.error('This will likely cause your build to fail. Impacted files:');
+                await (0, spawn_async_1.default)('git', ['status', '--short'], {
+                    stdio: 'inherit',
+                    cwd: this.maybeCwdOverride,
+                });
+                log_1.default.newLine();
+                log_1.default.error(`Error: Resolve filename casing inconsistencies before proceeding. ${(0, log_1.learnMore)('https://expo.fyi/macos-ignorecase')}`);
+                throw new Error('You have some uncommitted changes in your repository.');
+            }
+            await (0, spawn_async_1.default)('git', ['clone', '--no-hardlinks', '--depth', '1', gitRepoUri, destinationPath], {
+                cwd: this.maybeCwdOverride,
+            });
+        }
+        finally {
+            await setGitCaseSensitivityAsync(isCaseSensitive, this.maybeCwdOverride);
+        }
+    }
+    async getCommitHashAsync() {
+        try {
+            return (await (0, spawn_async_1.default)('git', ['rev-parse', 'HEAD'], {
+                cwd: this.maybeCwdOverride,
+            })).stdout.trim();
+        }
+        catch {
+            return undefined;
+        }
+    }
+    async trackFileAsync(file) {
+        await (0, spawn_async_1.default)('git', ['add', '--intent-to-add', file], {
+            cwd: this.maybeCwdOverride,
+        });
+    }
+    async getBranchNameAsync() {
+        try {
+            return (await (0, spawn_async_1.default)('git', ['rev-parse', '--abbrev-ref', 'HEAD'], {
+                cwd: this.maybeCwdOverride,
+            })).stdout.trim();
+        }
+        catch {
+            return null;
+        }
+    }
+    async getLastCommitMessageAsync() {
+        try {
+            return (await (0, spawn_async_1.default)('git', ['--no-pager', 'log', '-1', '--pretty=%B'], {
+                cwd: this.maybeCwdOverride,
+            })).stdout.trim();
+        }
+        catch {
+            return null;
+        }
+    }
+    async showDiffAsync() {
+        const outputTooLarge = (await (0, git_1.getGitDiffOutputAsync)(this.maybeCwdOverride)).split(/\r\n|\r|\n/).length > 100;
+        await (0, git_1.gitDiffAsync)({ withPager: outputTooLarge, cwd: this.maybeCwdOverride });
+    }
+    async isFileUntrackedAsync(path) {
+        const withUntrackedFiles = await (0, git_1.gitStatusAsync)({
+            showUntracked: true,
+            cwd: this.maybeCwdOverride,
+        });
+        const trackedFiles = await (0, git_1.gitStatusAsync)({ showUntracked: false, cwd: this.maybeCwdOverride });
+        const pathWithoutLeadingDot = path.replace(/^\.\//, ''); // remove leading './' from path
+        return (withUntrackedFiles.includes(pathWithoutLeadingDot) &&
+            !trackedFiles.includes(pathWithoutLeadingDot));
+    }
+    async isFileIgnoredAsync(filePath) {
+        try {
+            await (0, spawn_async_1.default)('git', ['check-ignore', '-q', filePath], {
+                cwd: this.maybeCwdOverride ?? path_1.default.normalize(await this.getRootPathAsync()),
+            });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    canGetLastCommitMessage() {
+        return true;
+    }
+}
+exports.default = GitClient;
+async function ensureGitConfiguredAsync({ nonInteractive, }) {
+    let usernameConfigured = true;
+    let emailConfigured = true;
+    try {
+        await (0, spawn_async_1.default)('git', ['config', '--get', 'user.name']);
+    }
+    catch (err) {
+        log_1.default.debug(err);
+        usernameConfigured = false;
+    }
+    try {
+        await (0, spawn_async_1.default)('git', ['config', '--get', 'user.email']);
+    }
+    catch (err) {
+        log_1.default.debug(err);
+        emailConfigured = false;
+    }
+    if (usernameConfigured && emailConfigured) {
+        return;
+    }
+    log_1.default.warn(`You need to configure Git with your ${[
+        !usernameConfigured && 'username (user.name)',
+        !emailConfigured && 'email address (user.email)',
+    ]
+        .filter(i => i)
+        .join(' and ')}`);
+    if (nonInteractive) {
+        throw new Error('Git cannot be configured automatically in non-interactive mode');
+    }
+    if (!usernameConfigured) {
+        const { username } = await (0, prompts_1.promptAsync)({
+            type: 'text',
+            name: 'username',
+            message: 'Username:',
+            validate: (input) => input !== '',
+        });
+        const spinner = (0, ora_1.ora)(`Running ${chalk_1.default.bold(`git config --local user.name ${username}`)}`).start();
+        try {
+            await (0, spawn_async_1.default)('git', ['config', '--local', 'user.name', username]);
+            spinner.succeed();
+        }
+        catch (err) {
+            spinner.fail();
+            throw err;
+        }
+    }
+    if (!emailConfigured) {
+        const { email } = await (0, prompts_1.promptAsync)({
+            type: 'text',
+            name: 'email',
+            message: 'Email address:',
+            validate: (input) => input !== '',
+        });
+        const spinner = (0, ora_1.ora)(`Running ${chalk_1.default.bold(`git config --local user.email ${email}`)}`).start();
+        try {
+            await (0, spawn_async_1.default)('git', ['config', '--local', 'user.email', email]);
+            spinner.succeed();
+        }
+        catch (err) {
+            spinner.fail();
+            throw err;
+        }
+    }
+}
+/**
+ * Checks if git is configured to be case sensitive
+ * @returns {boolean | undefined}
+ *    - boolean - is git case sensitive
+ *    - undefined - case sensitivity is not configured and git is using default behavior
+ */
+async function isGitCaseSensitiveAsync(cwd) {
+    if (process.platform !== 'darwin') {
+        return undefined;
+    }
+    try {
+        const result = await (0, spawn_async_1.default)('git', ['config', '--get', 'core.ignorecase'], {
+            cwd,
+        });
+        const isIgnoreCaseEnabled = result.stdout.trim();
+        if (isIgnoreCaseEnabled === '') {
+            return undefined;
+        }
+        else if (isIgnoreCaseEnabled === 'true') {
+            return false;
+        }
+        else {
+            return true;
+        }
+    }
+    catch {
+        return undefined;
+    }
+}
+exports.isGitCaseSensitiveAsync = isGitCaseSensitiveAsync;
+async function setGitCaseSensitivityAsync(enable, cwd) {
+    // we are assuming that if someone sets that on non-macos device then
+    // they know what they are doing
+    if (process.platform !== 'darwin') {
+        return;
+    }
+    if (enable === undefined) {
+        await (0, spawn_async_1.default)('git', ['config', '--unset', 'core.ignorecase'], {
+            cwd,
+        });
+    }
+    else {
+        await (0, spawn_async_1.default)('git', ['config', 'core.ignorecase', String(!enable)], {
+            cwd,
+        });
+    }
+}

package/dist/lib/vcs/clients/gitNoCommit.d.ts

@@ -0,0 +1,8 @@
+import GitClient from './git';
+export default class GitNoCommitClient extends GitClient {
+    isCommitRequiredAsync(): Promise<boolean>;
+    getRootPathAsync(): Promise<string>;
+    makeShallowCopyAsync(destinationPath: string): Promise<void>;
+    isFileIgnoredAsync(filePath: string): Promise<boolean>;
+    trackFileAsync(file: string): Promise<void>;
+}

package/dist/lib/vcs/clients/gitNoCommit.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const spawn_async_1 = tslib_1.__importDefault(require("@expo/spawn-async"));
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const path_1 = tslib_1.__importDefault(require("path"));
+const git_1 = tslib_1.__importDefault(require("./git"));
+const log_1 = tslib_1.__importDefault(require("../../log"));
+const local_1 = require("../local");
+class GitNoCommitClient extends git_1.default {
+    async isCommitRequiredAsync() {
+        return false;
+    }
+    async getRootPathAsync() {
+        return (await (0, spawn_async_1.default)('git', ['rev-parse', '--show-toplevel'])).stdout.trim();
+    }
+    async makeShallowCopyAsync(destinationPath) {
+        // normalize converts C:/some/path to C:\some\path on windows
+        const srcPath = path_1.default.normalize(await this.getRootPathAsync());
+        await (0, local_1.makeShallowCopyAsync)(srcPath, destinationPath);
+    }
+    async isFileIgnoredAsync(filePath) {
+        // normalize converts C:/some/path to C:\some\path on windows
+        const rootPath = path_1.default.normalize(await this.getRootPathAsync());
+        const ignore = new local_1.Ignore(rootPath);
+        await ignore.initIgnoreAsync();
+        return ignore.ignores(filePath);
+    }
+    async trackFileAsync(file) {
+        try {
+            await super.trackFileAsync(file);
+        }
+        catch {
+            // In the no commit workflow it doesn't matter if we fail to track changes,
+            // so we can ignore if this throws an exception
+            log_1.default.warn(`Unable to track ${chalk_1.default.bold(path_1.default.basename(file))} in Git. Proceeding without tracking.`);
+            log_1.default.warn(`  Reason: the command ${chalk_1.default.bold(`"git add ${file}"`)} exited with an error.`);
+            log_1.default.newLine();
+        }
+    }
+}
+exports.default = GitNoCommitClient;

package/dist/lib/vcs/clients/noVcs.d.ts

@@ -0,0 +1,7 @@
+import { Client } from '../vcs';
+export default class NoVcsClient extends Client {
+    getRootPathAsync(): Promise<string>;
+    makeShallowCopyAsync(destinationPath: string): Promise<void>;
+    isFileIgnoredAsync(filePath: string): Promise<boolean>;
+    canGetLastCommitMessage(): boolean;
+}

package/dist/lib/vcs/clients/noVcs.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const local_1 = require("../local");
+const vcs_1 = require("../vcs");
+class NoVcsClient extends vcs_1.Client {
+    async getRootPathAsync() {
+        return (0, local_1.getRootPath)();
+    }
+    async makeShallowCopyAsync(destinationPath) {
+        const srcPath = (0, local_1.getRootPath)();
+        await (0, local_1.makeShallowCopyAsync)(srcPath, destinationPath);
+    }
+    async isFileIgnoredAsync(filePath) {
+        const ignore = new local_1.Ignore((0, local_1.getRootPath)());
+        await ignore.initIgnoreAsync();
+        return ignore.ignores(filePath);
+    }
+    canGetLastCommitMessage() {
+        return false;
+    }
+}
+exports.default = NoVcsClient;

package/dist/lib/vcs/git.d.ts

@@ -0,0 +1,13 @@
+export declare function isGitInstalledAsync(): Promise<boolean>;
+export declare function doesGitRepoExistAsync(cwd: string | undefined): Promise<boolean>;
+interface GitStatusOptions {
+    showUntracked: boolean;
+    cwd: string | undefined;
+}
+export declare function gitStatusAsync({ showUntracked, cwd }: GitStatusOptions): Promise<string>;
+export declare function getGitDiffOutputAsync(cwd: string | undefined): Promise<string>;
+export declare function gitDiffAsync({ withPager, cwd, }: {
+    withPager?: boolean;
+    cwd: string | undefined;
+}): Promise<void>;
+export {};

package/dist/lib/vcs/git.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.gitDiffAsync = exports.getGitDiffOutputAsync = exports.gitStatusAsync = exports.doesGitRepoExistAsync = exports.isGitInstalledAsync = void 0;
+const tslib_1 = require("tslib");
+const spawn_async_1 = tslib_1.__importDefault(require("@expo/spawn-async"));
+async function isGitInstalledAsync() {
+    try {
+        await (0, spawn_async_1.default)('git', ['--help']);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            return false;
+        }
+        throw error;
+    }
+    return true;
+}
+exports.isGitInstalledAsync = isGitInstalledAsync;
+async function doesGitRepoExistAsync(cwd) {
+    try {
+        await (0, spawn_async_1.default)('git', ['rev-parse', '--git-dir'], {
+            cwd,
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+exports.doesGitRepoExistAsync = doesGitRepoExistAsync;
+async function gitStatusAsync({ showUntracked, cwd }) {
+    return (await (0, spawn_async_1.default)('git', ['status', '-s', showUntracked ? '-uall' : '-uno'], {
+        cwd,
+    })).stdout;
+}
+exports.gitStatusAsync = gitStatusAsync;
+async function getGitDiffOutputAsync(cwd) {
+    return (await (0, spawn_async_1.default)('git', ['--no-pager', 'diff'], {
+        cwd,
+    })).stdout;
+}
+exports.getGitDiffOutputAsync = getGitDiffOutputAsync;
+async function gitDiffAsync({ withPager = false, cwd, }) {
+    const options = withPager ? [] : ['--no-pager'];
+    try {
+        await (0, spawn_async_1.default)('git', [...options, 'diff'], {
+            stdio: ['ignore', 'inherit', 'inherit'],
+            cwd,
+        });
+    }
+    catch (error) {
+        if (typeof error.message === 'string' && error.message.includes('SIGPIPE')) {
+            // This error is thrown when the user exits the pager with `q`.
+            // do nothing
+            return;
+        }
+        throw error;
+    }
+}
+exports.gitDiffAsync = gitDiffAsync;

package/dist/lib/vcs/index.d.ts

@@ -0,0 +1,2 @@
+import { Client } from './vcs';
+export declare function resolveVcsClient(requireCommit?: boolean): Client;

package/dist/lib/vcs/index.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveVcsClient = void 0;
+const tslib_1 = require("tslib");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const git_1 = tslib_1.__importDefault(require("./clients/git"));
+const gitNoCommit_1 = tslib_1.__importDefault(require("./clients/gitNoCommit"));
+const noVcs_1 = tslib_1.__importDefault(require("./clients/noVcs"));
+const NO_VCS_WARNING = `Using EAS CLI without version control system is not recommended, use this mode only if you know what you are doing.`;
+function resolveVcsClient(requireCommit = false) {
+    if (process.env.EAS_NO_VCS) {
+        if (process.env.NODE_ENV !== 'test') {
+            // This log might be printed before cli arguments are evaluated,
+            // so it needs to go to stderr in case command is run in JSON
+            // only mode.
+            // eslint-disable-next-line no-console
+            console.error(chalk_1.default.yellow(NO_VCS_WARNING));
+        }
+        return new noVcs_1.default();
+    }
+    if (requireCommit) {
+        return new git_1.default();
+    }
+    return new gitNoCommit_1.default();
+}
+exports.resolveVcsClient = resolveVcsClient;