@donotuse/eas-cli 18.5.0-rc.1

package/build/metadata/download.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.downloadMetadataAsync = downloadMetadataAsync;
+const tslib_1 = require("tslib");
+const fs_extra_1 = tslib_1.__importDefault(require("fs-extra"));
+const path_1 = tslib_1.__importDefault(require("path"));
+const tasks_1 = require("./apple/tasks");
+const auth_1 = require("./auth");
+const resolve_1 = require("./config/resolve");
+const errors_1 = require("./errors");
+const telemetry_1 = require("./utils/telemetry");
+const AnalyticsManager_1 = require("../analytics/AnalyticsManager");
+const log_1 = tslib_1.__importDefault(require("../log"));
+const prompts_1 = require("../prompts");
+/**
+ * Generate a local store configuration from the stores.
+ * Note, only App Store is supported at this time.
+ */
+async function downloadMetadataAsync({ projectDir, profile, exp, analytics, credentialsCtx, }) {
+    const filePath = (0, resolve_1.getStaticConfigFilePath)({ projectDir, profile });
+    const fileExists = await fs_extra_1.default.pathExists(filePath);
+    if (fileExists) {
+        const filePathRelative = path_1.default.relative(projectDir, filePath);
+        const overwrite = await (0, prompts_1.confirmAsync)({
+            message: `Do you want to overwrite the existing "${filePathRelative}"?`,
+        });
+        if (!overwrite) {
+            throw new errors_1.MetadataValidationError(`Store config already exists at "${filePath}"`);
+        }
+    }
+    const { app, auth } = await (0, auth_1.getAppStoreAuthAsync)({
+        exp,
+        credentialsCtx,
+        projectDir,
+        profile,
+    });
+    const { unsubscribeTelemetry, executionId } = await (0, telemetry_1.subscribeTelemetryAsync)(analytics, AnalyticsManager_1.MetadataEvent.APPLE_METADATA_DOWNLOAD, { app, auth });
+    log_1.default.addNewLineIfNone();
+    log_1.default.log('Downloading App Store config...');
+    const errors = [];
+    const config = (0, resolve_1.createAppleWriter)();
+    const tasks = (0, tasks_1.createAppleTasks)();
+    const taskCtx = { app };
+    for (const task of tasks) {
+        try {
+            await task.prepareAsync({ context: taskCtx });
+        }
+        catch (error) {
+            errors.push(error);
+        }
+    }
+    for (const task of tasks) {
+        try {
+            await task.downloadAsync({ config, context: taskCtx });
+        }
+        catch (error) {
+            errors.push(error);
+        }
+    }
+    try {
+        await fs_extra_1.default.writeJSON(filePath, config.toSchema(), { spaces: 2 });
+    }
+    finally {
+        unsubscribeTelemetry();
+    }
+    if (errors.length > 0) {
+        throw new errors_1.MetadataDownloadError(errors, executionId);
+    }
+    return filePath;
+}

package/build/metadata/errors.d.ts

@@ -0,0 +1,42 @@
+import { Issue } from './config/issue';
+/**
+ * Before syncing data to the ASC API, we need to validate the metadata config.
+ * This error represents unrecoverable issues before syncing that data,
+ * and should contain useful information for the user to solve before trying again.
+ */
+export declare class MetadataValidationError extends Error {
+    readonly errors: Issue[];
+    constructor(message?: string, errors?: Issue[]);
+}
+/**
+ * If a single entity failed to update, we don't block the other entities from uploading.
+ * We still attempt to update the data in the stores as much as possible.
+ * Because of that, we keep track of any errors encountered and throw this generic error.
+ * It contains that list of encountered errors to present to the user.
+ */
+export declare class MetadataUploadError extends Error {
+    readonly errors: Error[];
+    readonly executionId: string;
+    constructor(errors: Error[], executionId: string);
+}
+/**
+ * If a single entity failed to download, we don't block the other entities from downloading.
+ * We sill attempt to pull in the data from the stores as much as possible.
+ * Because of that, we keep track of any errors envountered and throw this generic error.
+ * It contains that list of encountered errors to present to the user.
+ */
+export declare class MetadataDownloadError extends Error {
+    readonly errors: Error[];
+    readonly executionId: string;
+    constructor(errors: Error[], executionId: string);
+}
+/**
+ * Log the encountered metadata validation error in detail for the user.
+ * This should help communicate any possible configuration error and help the user resolve it.
+ */
+export declare function logMetadataValidationError(error: MetadataValidationError): void;
+/**
+ * Handle a thrown metadata error by informing the user what went wrong.
+ * If a normal error is thrown, this method will re-throw that error to avoid consuming it.
+ */
+export declare function handleMetadataError(error: Error): void;

package/build/metadata/errors.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MetadataDownloadError = exports.MetadataUploadError = exports.MetadataValidationError = void 0;
+exports.logMetadataValidationError = logMetadataValidationError;
+exports.handleMetadataError = handleMetadataError;
+const tslib_1 = require("tslib");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const log_1 = tslib_1.__importStar(require("../log"));
+/**
+ * Before syncing data to the ASC API, we need to validate the metadata config.
+ * This error represents unrecoverable issues before syncing that data,
+ * and should contain useful information for the user to solve before trying again.
+ */
+class MetadataValidationError extends Error {
+    errors;
+    constructor(message, errors = []) {
+        super(message ?? 'Store configuration validation failed');
+        this.errors = errors;
+    }
+}
+exports.MetadataValidationError = MetadataValidationError;
+/**
+ * If a single entity failed to update, we don't block the other entities from uploading.
+ * We still attempt to update the data in the stores as much as possible.
+ * Because of that, we keep track of any errors encountered and throw this generic error.
+ * It contains that list of encountered errors to present to the user.
+ */
+class MetadataUploadError extends Error {
+    errors;
+    executionId;
+    constructor(errors, executionId) {
+        super(`Store configuration upload encountered ${errors.length === 1 ? 'an error' : `${errors.length} errors`}.`);
+        this.errors = errors;
+        this.executionId = executionId;
+    }
+}
+exports.MetadataUploadError = MetadataUploadError;
+/**
+ * If a single entity failed to download, we don't block the other entities from downloading.
+ * We sill attempt to pull in the data from the stores as much as possible.
+ * Because of that, we keep track of any errors envountered and throw this generic error.
+ * It contains that list of encountered errors to present to the user.
+ */
+class MetadataDownloadError extends Error {
+    errors;
+    executionId;
+    constructor(errors, executionId) {
+        super(`Store configuration download encountered ${errors.length === 1 ? 'an error' : `${errors.length} errors`}.`);
+        this.errors = errors;
+        this.executionId = executionId;
+    }
+}
+exports.MetadataDownloadError = MetadataDownloadError;
+/**
+ * Log the encountered metadata validation error in detail for the user.
+ * This should help communicate any possible configuration error and help the user resolve it.
+ */
+function logMetadataValidationError(error) {
+    log_1.default.newLine();
+    log_1.default.error(chalk_1.default.bold(error.message));
+    if (error.errors?.length > 0) {
+        // TODO(cedric): group errors by property to make multiple errors for same property more readable
+        for (const err of error.errors) {
+            log_1.default.log(`  - ${chalk_1.default.bold(`$.${err.path.join('.')}`)} ${err.message}`);
+        }
+    }
+}
+/**
+ * Handle a thrown metadata error by informing the user what went wrong.
+ * If a normal error is thrown, this method will re-throw that error to avoid consuming it.
+ */
+function handleMetadataError(error) {
+    if (error instanceof MetadataValidationError) {
+        logMetadataValidationError(error);
+        return;
+    }
+    if (error instanceof MetadataDownloadError || error instanceof MetadataUploadError) {
+        log_1.default.newLine();
+        log_1.default.error(chalk_1.default.bold(error.message));
+        if (error.errors?.length > 0) {
+            log_1.default.newLine();
+            log_1.default.error(error.errors.map(err => err.message).join('\n\n'));
+        }
+        log_1.default.newLine();
+        log_1.default.log('Check the logs for any configuration issues.');
+        log_1.default.log('If this issue persists, open a new issue at:');
+        // TODO: add execution ID to the issue template link
+        log_1.default.log((0, log_1.link)('https://github.com/expo/eas-cli'));
+        return;
+    }
+    throw error;
+}

package/build/metadata/upload.d.ts

@@ -0,0 +1,17 @@
+import { ExpoConfig } from '@expo/config';
+import { SubmitProfile } from '@expo/eas-json';
+import { Analytics } from '../analytics/AnalyticsManager';
+import { CredentialsContext } from '../credentials/context';
+/**
+ * Sync a local store configuration with the stores.
+ * Note, only App Store is supported at this time.
+ */
+export declare function uploadMetadataAsync({ projectDir, profile, exp, analytics, credentialsCtx, }: {
+    projectDir: string;
+    profile: SubmitProfile;
+    exp: ExpoConfig;
+    analytics: Analytics;
+    credentialsCtx: CredentialsContext;
+}): Promise<{
+    appleLink: string;
+}>;

package/build/metadata/upload.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uploadMetadataAsync = uploadMetadataAsync;
+const tslib_1 = require("tslib");
+const tasks_1 = require("./apple/tasks");
+const auth_1 = require("./auth");
+const resolve_1 = require("./config/resolve");
+const errors_1 = require("./errors");
+const telemetry_1 = require("./utils/telemetry");
+const AnalyticsManager_1 = require("../analytics/AnalyticsManager");
+const log_1 = tslib_1.__importDefault(require("../log"));
+const prompts_1 = require("../prompts");
+/**
+ * Sync a local store configuration with the stores.
+ * Note, only App Store is supported at this time.
+ */
+async function uploadMetadataAsync({ projectDir, profile, exp, analytics, credentialsCtx, }) {
+    const storeConfig = await loadConfigWithValidationPromptAsync(projectDir, profile);
+    const { app, auth } = await (0, auth_1.getAppStoreAuthAsync)({
+        exp,
+        credentialsCtx,
+        projectDir,
+        profile,
+    });
+    const { unsubscribeTelemetry, executionId } = await (0, telemetry_1.subscribeTelemetryAsync)(analytics, AnalyticsManager_1.MetadataEvent.APPLE_METADATA_UPLOAD, { app, auth });
+    log_1.default.addNewLineIfNone();
+    log_1.default.log('Uploading App Store configuration...');
+    const errors = [];
+    const config = (0, resolve_1.createAppleReader)(storeConfig);
+    const tasks = (0, tasks_1.createAppleTasks)({
+        // We need to resolve a different version as soon as possible.
+        // This version is the parent model of all changes we are going to push.
+        version: config.getVersion()?.versionString,
+    });
+    const taskCtx = { app };
+    for (const task of tasks) {
+        try {
+            await task.prepareAsync({ context: taskCtx });
+        }
+        catch (error) {
+            errors.push(error);
+        }
+    }
+    for (const task of tasks) {
+        try {
+            await task.uploadAsync({ config, context: taskCtx });
+        }
+        catch (error) {
+            errors.push(error);
+        }
+    }
+    unsubscribeTelemetry();
+    if (errors.length > 0) {
+        throw new errors_1.MetadataUploadError(errors, executionId);
+    }
+    return { appleLink: `https://appstoreconnect.apple.com/apps/${app.id}/appstore` };
+}
+async function loadConfigWithValidationPromptAsync(projectDir, profile) {
+    try {
+        return await (0, resolve_1.loadConfigAsync)({ projectDir, profile });
+    }
+    catch (error) {
+        if (error instanceof errors_1.MetadataValidationError) {
+            (0, errors_1.logMetadataValidationError)(error);
+            log_1.default.newLine();
+            log_1.default.warn('Without further updates, the current store configuration can fail to be synchronized with the App Store or pass App Store review.');
+            if (await (0, prompts_1.confirmAsync)({ message: 'Do you still want to push the store configuration?' })) {
+                return await (0, resolve_1.loadConfigAsync)({ projectDir, profile, skipValidation: true });
+            }
+        }
+        throw error;
+    }
+}

package/build/metadata/utils/ajv.d.ts

@@ -0,0 +1,10 @@
+import { HumanError } from '@segment/ajv-human-errors';
+import Ajv, { ErrorObject } from 'ajv';
+/**
+ * Create a new AJV validator using the JSON Schema 06 draft.
+ * It also adds the additional formats from the `ajv-formats` package.
+ *
+ * @see https://github.com/ajv-validator/ajv-formats
+ */
+export declare function createValidator(): Ajv;
+export declare function getReadableErrors(errors?: ErrorObject[]): HumanError[];

package/build/metadata/utils/ajv.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createValidator = createValidator;
+exports.getReadableErrors = getReadableErrors;
+const tslib_1 = require("tslib");
+const ajv_human_errors_1 = require("@segment/ajv-human-errors");
+const ajv_1 = tslib_1.__importDefault(require("ajv"));
+const ajv_formats_1 = tslib_1.__importDefault(require("ajv-formats"));
+const jsonSchema = require('ajv/lib/refs/json-schema-draft-06.json');
+/**
+ * Create a new AJV validator using the JSON Schema 06 draft.
+ * It also adds the additional formats from the `ajv-formats` package.
+ *
+ * @see https://github.com/ajv-validator/ajv-formats
+ */
+function createValidator() {
+    const validator = new ajv_1.default({
+        strict: false, // The metadata schema is shared with vscode, including vscode-only properties
+        verbose: true, // Required for `ajv-human-errors`
+        allErrors: true, // Required for `ajv-human-errors`
+    });
+    return (0, ajv_formats_1.default)(validator).addMetaSchema(jsonSchema);
+}
+function getReadableErrors(errors = []) {
+    if (errors.length === 0) {
+        return [];
+    }
+    return new ajv_human_errors_1.AggregateAjvError(errors).toJSON();
+}

package/build/metadata/utils/asc.d.ts

@@ -0,0 +1,3 @@
+import { ConnectModel } from '@expo/apple-utils';
+/** Get the properties of a single App Store Connect entity */
+export type AttributesOf<T extends ConnectModel> = T['attributes'];

package/build/metadata/utils/asc.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/metadata/utils/date.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Remove time precision from a date to avoid potential errors with the App Store.
+ *
+ * "status": "409",
+ * "code": "ENTITY_ERROR.ATTRIBUTE.INVALID",
+ * "title": "An attribute value is invalid.",
+ * "detail": "The attribute 'earliestReleaseDate' only allows hour precision",
+ * "source": {
+ *   "pointer": "/data/attributes/earliestReleaseDate"
+ * }
+ */
+export declare function removeDatePrecision(date: null | undefined | string | number | Date): null | Date;

package/build/metadata/utils/date.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeDatePrecision = removeDatePrecision;
+/**
+ * Remove time precision from a date to avoid potential errors with the App Store.
+ *
+ * "status": "409",
+ * "code": "ENTITY_ERROR.ATTRIBUTE.INVALID",
+ * "title": "An attribute value is invalid.",
+ * "detail": "The attribute 'earliestReleaseDate' only allows hour precision",
+ * "source": {
+ *   "pointer": "/data/attributes/earliestReleaseDate"
+ * }
+ */
+function removeDatePrecision(date) {
+    if (date) {
+        try {
+            const result = new Date(date);
+            result.setMinutes(0);
+            result.setSeconds(0);
+            result.setMilliseconds(0);
+            if (!isNaN(result.getTime())) {
+                return result;
+            }
+        }
+        catch { }
+    }
+    return null;
+}

package/build/metadata/utils/log.d.ts

@@ -0,0 +1,16 @@
+import { Ora } from '../../ora';
+type LogAsyncOptions = {
+    /** If the spinner representing the async action should be hidden, e.g. for JSON output */
+    hidden?: boolean;
+    /** The message to display when the action is pending */
+    pending: string;
+    /** The message to display when the action succeeded */
+    success: string;
+    /** The message to display when the action failed */
+    failure: string;
+};
+/**
+ * Log an asynchronous action using a spinner.
+ */
+export declare function logAsync<T>(action: (spinner?: Ora) => Promise<T>, { hidden, ...message }: LogAsyncOptions): Promise<T>;
+export {};

package/build/metadata/utils/log.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logAsync = logAsync;
+const ora_1 = require("../../ora");
+/**
+ * Log an asynchronous action using a spinner.
+ */
+async function logAsync(action, { hidden, ...message }) {
+    if (hidden) {
+        return await action();
+    }
+    const spinner = (0, ora_1.ora)(message.pending).start();
+    try {
+        const result = await action(spinner);
+        spinner.succeed(message.success);
+        return result;
+    }
+    catch (error) {
+        spinner.fail(message.failure);
+        throw error;
+    }
+}

package/build/metadata/utils/retry.d.ts

@@ -0,0 +1,8 @@
+export declare function waitAsync(duration: number): Promise<void>;
+type WithRetryOptions = {
+    tries?: number;
+    delay?: number;
+    onRetry?: (triesLeft: number) => void;
+};
+export declare function retryIfNullAsync<T>(method: () => Promise<T | null>, options?: WithRetryOptions): Promise<T | null>;
+export {};

package/build/metadata/utils/retry.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waitAsync = waitAsync;
+exports.retryIfNullAsync = retryIfNullAsync;
+async function waitAsync(duration) {
+    await new Promise(resolve => setTimeout(resolve, duration));
+}
+async function retryIfNullAsync(method, options = {}) {
+    let { tries = 5, delay = 1000 } = options;
+    while (tries > 0) {
+        const value = await method();
+        if (value !== null) {
+            return value;
+        }
+        tries--;
+        options.onRetry?.(tries);
+        await waitAsync(delay);
+    }
+    return null;
+}

package/build/metadata/utils/telemetry.d.ts

@@ -0,0 +1,19 @@
+import { App, Session } from '@expo/apple-utils';
+import { Analytics, MetadataEvent } from '../../analytics/AnalyticsManager';
+export type TelemetryContext = {
+    app: App;
+    auth: Partial<Session.AuthState>;
+};
+/**
+ * Subscribe the telemetry to the ongoing metadata requests and responses.
+ * When providing the app and auth info, we can scrub that data from the telemetry.
+ * Returns an execution ID to group all events of a single run together, and a unsubscribe function.
+ */
+export declare function subscribeTelemetryAsync(analytics: Analytics, event: MetadataEvent, options: TelemetryContext): Promise<{
+    /** Unsubscribe the telemetry from all apple-utils events */
+    unsubscribeTelemetry: () => void;
+    /** The unique id added to all telemetry events from a single execution */
+    executionId: string;
+}>;
+/** Exposed for testing */
+export declare function makeDataScrubberAsync({ app, auth, }: TelemetryContext): Promise<(<T>(data: T) => string)>;

package/build/metadata/utils/telemetry.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.subscribeTelemetryAsync = subscribeTelemetryAsync;
+exports.makeDataScrubberAsync = makeDataScrubberAsync;
+const apple_utils_1 = require("@expo/apple-utils");
+const uuid_1 = require("uuid");
+/**
+ * Subscribe the telemetry to the ongoing metadata requests and responses.
+ * When providing the app and auth info, we can scrub that data from the telemetry.
+ * Returns an execution ID to group all events of a single run together, and a unsubscribe function.
+ */
+async function subscribeTelemetryAsync(analytics, event, options) {
+    const executionId = (0, uuid_1.v4)();
+    const scrubber = await makeDataScrubberAsync(options);
+    const { interceptors } = (0, apple_utils_1.getRequestClient)();
+    const responseInterceptorId = interceptors.response.use(response => {
+        analytics.logEvent(event, {
+            executionId,
+            type: 'response',
+            phase: 'resolved',
+            method: response.request.method.toUpperCase(),
+            url: scrubber(response.request.path),
+            status: String(response.status),
+            statusText: scrubber(response.statusText),
+        });
+        return response;
+    }, (error) => {
+        analytics.logEvent(event, {
+            executionId,
+            type: 'response',
+            phase: 'rejected',
+            method: error.request.method.toUpperCase(),
+            url: scrubber(error.config?.url),
+            error: scrubber(error.message),
+            status: String(error.response?.status),
+            statusText: scrubber(error.response?.statusText),
+            input: scrubber(error.config?.data),
+            output: scrubber(error.response?.data),
+        });
+        throw error;
+    });
+    function unsubscribeTelemetry() {
+        interceptors.response.eject(responseInterceptorId);
+    }
+    return { unsubscribeTelemetry, executionId };
+}
+/** Exposed for testing */
+async function makeDataScrubberAsync({ app, auth, }) {
+    const token = await getAuthTokenStringAsync(auth);
+    const patterns = {
+        APPLE_APP_ID: new RegExp(app.id, 'gi'),
+        APPLE_USERNAME: auth.username ? new RegExp(auth.username, 'gi') : null,
+        APPLE_PASSWORD: auth.password ? new RegExp(auth.password, 'gi') : null,
+        APPLE_TOKEN: token ? new RegExp(token, 'gi') : null,
+        APPLE_TEAM_ID: auth.context?.teamId ? new RegExp(auth.context.teamId, 'gi') : null,
+        APPLE_PROVIDER_ID: auth.context?.providerId
+            ? new RegExp(String(auth.context.providerId), 'gi')
+            : null,
+    };
+    const iterator = Object.entries(patterns);
+    return function scrubber(data) {
+        if (!data) {
+            return String(data);
+        }
+        let value = typeof data === 'object' ? JSON.stringify(data) : String(data);
+        for (const [replacement, pattern] of iterator) {
+            if (pattern) {
+                value = value.replace(pattern, `{${replacement}}`);
+            }
+        }
+        return value;
+    };
+}
+async function getAuthTokenStringAsync(auth) {
+    if (!auth.context?.token) {
+        return null;
+    }
+    if (typeof auth.context.token === 'object') {
+        return await auth.context.token.getToken();
+    }
+    return auth.context.token;
+}

package/build/onboarding/git.d.ts

@@ -0,0 +1,16 @@
+export declare function runGitCloneAsync({ targetProjectDir, githubRepositoryName, githubUsername, cloneMethod, showOutput, }: {
+    githubUsername: string;
+    githubRepositoryName: string;
+    targetProjectDir: string;
+    cloneMethod: 'ssh' | 'https';
+    showOutput?: boolean;
+}): Promise<{
+    targetProjectDir: string;
+}>;
+export declare function runGitPushAsync({ targetProjectDir, }: {
+    targetProjectDir: string;
+}): Promise<void>;
+export declare function canAccessRepositoryUsingSshAsync({ githubUsername, githubRepositoryName, }: {
+    githubUsername: string;
+    githubRepositoryName: string;
+}): Promise<boolean>;

package/build/onboarding/git.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runGitCloneAsync = runGitCloneAsync;
+exports.runGitPushAsync = runGitPushAsync;
+exports.canAccessRepositoryUsingSshAsync = canAccessRepositoryUsingSshAsync;
+const tslib_1 = require("tslib");
+const spawn_async_1 = tslib_1.__importDefault(require("@expo/spawn-async"));
+const runCommand_1 = require("./runCommand");
+const log_1 = tslib_1.__importDefault(require("../log"));
+const prompts_1 = require("../prompts");
+async function runGitCloneAsync({ targetProjectDir, githubRepositoryName, githubUsername, cloneMethod, showOutput = true, }) {
+    const url = cloneMethod === 'ssh'
+        ? `git@github.com:${githubUsername}/${githubRepositoryName}.git`
+        : `https://github.com/${githubUsername}/${githubRepositoryName}.git`;
+    try {
+        await (0, runCommand_1.runCommandAsync)({
+            command: 'git',
+            args: ['clone', url, targetProjectDir],
+            shouldPrintStderrLineAsStdout: line => {
+                return line.includes('Cloning into');
+            },
+            showSpinner: false,
+            showOutput,
+        });
+        return { targetProjectDir };
+    }
+    catch (error) {
+        if (error.stderr.includes('already exists')) {
+            log_1.default.warn(`Directory ${targetProjectDir} already exists.`);
+            const shouldContinue = await (0, prompts_1.confirmAsync)({
+                message: 'Do you want to clone your project to some other destination?',
+            });
+            if (!shouldContinue) {
+                throw new Error('Directory already exists. Aborting...');
+            }
+            const { newTargetProjectDir } = await (0, prompts_1.promptAsync)({
+                type: 'text',
+                name: 'newTargetProjectDir',
+                message: 'New target directory path:',
+                validate: (input) => input !== '',
+            });
+            return await runGitCloneAsync({
+                githubRepositoryName,
+                githubUsername,
+                targetProjectDir: newTargetProjectDir,
+                cloneMethod,
+            });
+        }
+        else if (error.stderr.includes('Permission denied')) {
+            log_1.default.warn(`It seems like you do not have permission to clone the repository using ${cloneMethod}.`);
+            const newMethod = cloneMethod === 'ssh' ? 'https' : 'ssh';
+            const shouldContinue = await (0, prompts_1.confirmAsync)({
+                message: `Do you want to clone the repository using ${newMethod} instead?`,
+            });
+            if (!shouldContinue) {
+                throw new Error('Permission denied. Aborting...');
+            }
+            return await runGitCloneAsync({
+                githubRepositoryName,
+                githubUsername,
+                targetProjectDir,
+                cloneMethod: newMethod,
+            });
+        }
+        else {
+            throw error;
+        }
+    }
+}
+async function runGitPushAsync({ targetProjectDir, }) {
+    await (0, runCommand_1.runCommandAsync)({
+        command: 'git',
+        args: ['push'],
+        cwd: targetProjectDir,
+    });
+}
+async function canAccessRepositoryUsingSshAsync({ githubUsername, githubRepositoryName, }) {
+    try {
+        await (0, spawn_async_1.default)('git', [
+            'ls-remote',
+            `git@github.com:${githubUsername}/${githubRepositoryName}.git`,
+        ]);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}