@swell/cli 2.0.1-alpha.13 → 2.0.1-alpha.17

package/dist/push-app-command.js

@@ -0,0 +1,765 @@
+import * as path from 'node:path';
+import * as fs from 'node:fs';
+import { confirm, select, input } from '@inquirer/prompts';
+import Stream from 'stream';
+import { $ } from 'execa';
+import ora from 'ora';
+import { ConfigType, FrontendProjectTypes, findAppConfig, globAllFilesByPath, allConfigFilesInDir, appConfigFromFile, getConfigTypeFromPath, getConfigTypeKeyFromValue, getFrontendProjectType, getAppSlugId, hashString, filePathExists, isPathDirectory, } from './lib/apps/index.js';
+import { default as localConfig } from './lib/config.js';
+import { default as swellConfig } from './lib/app-config.js';
+import style from './lib/style.js';
+import { toAppId } from './lib/create/index.js';
+import { RemoteAppCommand } from './remote-app-command.js';
+const PUSH_CONCURRENCY = 3;
+export class PushAppCommand extends RemoteAppCommand {
+    frontendPath = '';
+    watchingFiles = [];
+    watchingChangeQueue = [];
+    watchingChangeQueueRunning = false;
+    logWatchChanges = true;
+    onWatchChange;
+    async exec(command, onOutput) {
+        const $$ = $({
+            cwd: this.frontendPath,
+            shell: true,
+            stdin: 'inherit',
+            stderr: onOutput ? 'pipe' : 'inherit',
+            stdout: onOutput ? 'pipe' : 'inherit',
+        });
+        if (onOutput) {
+            const outStream = new Stream.Writable();
+            outStream._write = (chunk, _encoding, next) => {
+                const string = chunk.toString();
+                const out = onOutput(string);
+                if (out !== false) {
+                    console.log(string);
+                }
+                next();
+            };
+            await $$ `${command}`.pipeStdout?.(outStream).pipeStderr?.(outStream);
+        }
+        else {
+            await $$ `${command}`;
+        }
+    }
+    setWatchingFiles() {
+        this.watchingFiles = globAllFilesByPath(this.appPath);
+    }
+    async watchForChanges({ logChanges, syncAll, onChange, } = {}) {
+        this.logWatchChanges = logChanges ?? true;
+        this.onWatchChange = onChange;
+        this.setWatchingFiles();
+        if (syncAll) {
+            await this.pushAppConfigs();
+            fs.watch(this.appPath, { recursive: true }, async (_eventType, _filename) => {
+                await this.pushAppConfigs();
+                this.setWatchingFiles();
+            });
+            return;
+        }
+        fs.watch(this.appPath, { recursive: true }, this.watchListener);
+    }
+    watchListener = async (eventType, filename) => {
+        const configFile = filename;
+        const pathParsed = path.parse(configFile);
+        const fileDirs = pathParsed.dir.split(path.sep);
+        // only the first directory is relevant for us
+        const configDir = fileDirs[0];
+        // we only want to watch files in the root of the app directory
+        // and ignore build files etc
+        this.setWatchingFiles();
+        const isWatching = this.watchingFiles.includes(configFile);
+        // TODO: renaming a folder doesn't seem to work
+        // because isWatching = false for the new files
+        if (!configDir) {
+            return;
+        }
+        const configType = getConfigTypeFromPath(configDir);
+        if (!configType) {
+            return;
+        }
+        let watchFileEvent;
+        // per node docs:
+        //
+        //    On most platforms, 'rename' is emitted whenever a filename appears
+        //    or disappears in the directory.
+        //
+        // we want however to identify delete file events so we can send the
+        // correct API request
+        if (eventType === 'rename') {
+            watchFileEvent = 'new';
+            if (!filePathExists(path.join(this.appPath, configFile))) {
+                watchFileEvent = 'deleted';
+            }
+            else if (!isWatching) {
+                return;
+            }
+        }
+        else if (isWatching) {
+            watchFileEvent = 'change';
+        }
+        else {
+            return;
+        }
+        try {
+            await this.handleWatchFileChange(configFile, configType, watchFileEvent);
+        }
+        catch (error) {
+            // we don't want to break the watcher if an error is thrown while
+            // handling a file change
+            // for tests though, we want to break the watcher
+            if (process.env.NODE_ENV === 'test') {
+                // throwing does not break the test so we need to hard exit and log
+                // the error
+                console.error(style.error(error));
+                // eslint-disable-next-line no-process-exit, unicorn/no-process-exit
+                process.exit(1);
+            }
+        }
+    };
+    async handleWatchFileChange(configFile, configType, event) {
+        let config;
+        if (event === 'deleted') {
+            config = findAppConfig(this.app, configFile, configType);
+            if (!config) {
+                return;
+            }
+            this.watchingChangeQueue.push({
+                action: 'remove',
+                configFile,
+                appConfig: config,
+            });
+        }
+        else {
+            config = appConfigFromFile(configFile, configType, this.appPath);
+            this.watchingChangeQueue.push({
+                action: 'push',
+                configFile,
+                appConfig: config,
+            });
+        }
+        await this.runWatchChangeQueue();
+    }
+    async runWatchChangeQueue() {
+        if (this.watchingChangeQueueRunning) {
+            return;
+        }
+        while (this.watchingChangeQueue.length) {
+            this.watchingChangeQueueRunning = true;
+            await Promise.all(this.watchingChangeQueue
+                .splice(0, PUSH_CONCURRENCY)
+                .map(async ({ action, configFile, appConfig }) => {
+                let result;
+                if (action === 'remove') {
+                    result = await this.removeRemoteFile(appConfig, this.logWatchChanges);
+                }
+                else {
+                    result = await this.pushRemoteFile(appConfig, this.logWatchChanges);
+                }
+                this.onWatchChange?.(appConfig, result);
+            }));
+        }
+        this.watchingChangeQueueRunning = false;
+        // refetch app to get updated configs
+        this.app = await this.getAppWithConfig(this.app.id);
+    }
+    async deployAppFrontend(force, log) {
+        const currentStore = localConfig.getDefaultStore();
+        const projectType = this.getFrontendProjectType(false);
+        if (!projectType) {
+            return;
+        }
+        const deploymentHash = this.getFrontendDeploymentHash();
+        // Build and deploy only if there are files to push
+        if (deploymentHash &&
+            (force || deploymentHash !== this.app.frontend?.deployment_hash)) {
+            await this.buildFrontend(projectType);
+            const deploymentUrl = await this.deployFrontend(projectType);
+            await this.updateFrontendDeployment(currentStore, projectType, deploymentUrl, deploymentHash);
+        }
+        if (log !== false) {
+            if (this.app.type === 'storefront' && this.storefront) {
+                this.logStorefrontFrontendUrl(this.storefront);
+            }
+            else if (this.app.type !== 'storefront') {
+                // Get updated app with `installed` property
+                this.app = await this.getApp(this.app.id);
+                this.logAppFrontendUrl();
+            }
+        }
+    }
+    getFrontendDeploymentHash() {
+        const localConfigs = this.getLocalAppConfigs();
+        let frontendHashes = localConfigs
+            .filter((config) => config.filePath?.startsWith(`frontend${path.sep}`))
+            .map((config) => config.hash)
+            .sort()
+            .join('|');
+        if (frontendHashes.length > 0) {
+            const packageHash = localConfigs.find((config) => config.filePath === 'package.json')?.hash;
+            frontendHashes += `|${packageHash}`;
+        }
+        return frontendHashes?.length > 0 ? hashString(frontendHashes) : undefined;
+    }
+    getFrontendProjectType(required = true) {
+        this.frontendPath = path.join(this.appPath, 'frontend');
+        if (!required) {
+            const frontendExists = filePathExists(this.frontendPath);
+            if (!frontendExists) {
+                return null;
+            }
+        }
+        const projectType = getFrontendProjectType(this.appPath);
+        if (!projectType) {
+            this.error(`No valid frontend app found in ${this.appPath}/${this.frontendPath}. Supported frameworks include: ${FrontendProjectTypes.map((type) => type.slug).join(', ')}.`);
+        }
+        return projectType;
+    }
+    async ensureLoggedIn() {
+        try {
+            const user = await this.api.get({ adminPath: 'user' });
+            if (!user) {
+                throw new Error();
+            }
+        }
+        catch {
+            this.log('Logging in...\n');
+            await this.config.runCommand('login');
+            this.log();
+            return true;
+        }
+    }
+    async ensureAppExists(file, shouldCreate = true) {
+        let currentStore = localConfig.getDefaultStore();
+        this.api.setStoreEnv(currentStore, 'test');
+        const loggedIn = await this.ensureLoggedIn();
+        if (loggedIn) {
+            currentStore = localConfig.getDefaultStore();
+            this.api.setStoreEnv(currentStore, 'test');
+        }
+        const app = await this.getAppWithConfig('').catch((_error) => {
+            // Ignore so we can continue to create it
+            return null;
+        });
+        const isTheme = app?.type === 'theme';
+        if (app && !isTheme && this.appType === 'theme') {
+            this.error(`App ${style.appConfigValue(app?.name)} is not a theme.`);
+        }
+        const confirmExistingApp = await this.confirmRemoveInstalledApp(app, currentStore);
+        if (confirmExistingApp === false) {
+            return false;
+        }
+        // Do not create or update if app already exists and not forcing it
+        if (!shouldCreate && app) {
+            this.app = app;
+            return true;
+        }
+        // If app exists but owned by another client, offer to create a new instance
+        if (app?.client_id && app.client_id !== currentStore) {
+            // Themes do not confirm dev version in another instance
+            if (!isTheme && !confirmExistingApp?.id) {
+                const otherAppName = app?.name || this.swellConfig.get('name');
+                const confirmPushNew = await confirm({
+                    default: false,
+                    message: `${style.appConfigValue(otherAppName)} has a dev version in another environment. Do you want to create a new development instance in ${style.storeId(currentStore)}?`,
+                });
+                if (!confirmPushNew) {
+                    return false;
+                }
+            }
+            // Create a new app
+            this.app = await this.getCreateUpdateApp();
+            if (!this.app) {
+                return false;
+            }
+        }
+        else if (!file) {
+            // Update existing app if not targeting a file
+            this.app = await this.getCreateUpdateApp(app);
+        }
+        return true;
+    }
+    async confirmRemoveInstalledApp(app, currentStore) {
+        if (!app?.private_id) {
+            return true;
+        }
+        const existingInstalledApp = await this.api.get({
+            adminPath: `/client/apps/${app.private_id}`,
+        }, { query: { versioned: true } });
+        if (existingInstalledApp) {
+            const continuePush = await confirm({
+                default: false,
+                message: `${style.storeId(currentStore)} has an installed version of ${app.name ? style.appConfigValue(app.name) : 'this app'} v${existingInstalledApp.version}. Do you want to replace it with a development instance?`,
+            });
+            if (!continuePush) {
+                return false;
+            }
+            // uninstall the existing app
+            const spinner = ora();
+            spinner.start('Removing installed app...');
+            try {
+                await this.api.put({
+                    adminPath: `/client/apps/${app.id}`,
+                }, {
+                    body: { uninstalled: true },
+                });
+                spinner.succeed('Installed app removed.');
+                this.log();
+            }
+            catch (error) {
+                spinner.fail(`Error removing installed app from ${style.storeId(currentStore)}.`);
+                this.logError(error.message);
+                return false;
+            }
+        }
+        return existingInstalledApp;
+    }
+    resolveAppPath(appId, targetPath) {
+        let resolvedAppId = appId || '';
+        let resolvedPath = targetPath || resolvedAppId;
+        // If app_id matches directory, use it as target path
+        if (!targetPath &&
+            isPathDirectory(path.resolve(process.cwd(), resolvedAppId))) {
+            resolvedPath = resolvedAppId;
+        }
+        // Reset app config and path if appId is provided
+        if (resolvedPath && this.appPath === '.') {
+            this.appPath = path.resolve(process.cwd(), resolvedPath);
+        }
+        return this.appPath;
+    }
+    async getAppStorefront(params) {
+        const query = Object.entries(params || {})
+            .map(([key, value]) => `${key}=${value}`)
+            .join('&');
+        try {
+            return await this.handleRequestErrors(async () => this.api.get({
+                adminPath: `/apps/${this.app.id}/storefront?${query}`,
+            }));
+        }
+        catch {
+            // noop
+        }
+    }
+    async getAllStorefronts(params) {
+        const query = Object.entries(params || {})
+            .map(([key, value]) => `${key}=${value}`)
+            .join('&');
+        return await this.handleRequestErrors(async () => this.api.get({
+            adminPath: `/storefronts?${query}`,
+        }));
+    }
+    async getAllAppStorefronts(params) {
+        const query = Object.entries(params || {})
+            .map(([key, value]) => `${key}=${value}`)
+            .join('&');
+        return await this.handleRequestErrors(async () => this.api.get({
+            adminPath: `/apps/${this.app.id}/storefronts?${query}`,
+        }));
+    }
+    saveCurrentStorefront() {
+        const currentStorefront = localConfig.getDefaultStorefront(this.appPath);
+        if (this.storefront && this.storefront.id !== currentStorefront) {
+            localConfig.setDefaultStorefront(this.appPath, this.storefront.id);
+        }
+    }
+    async getAppToPull(args, shouldChoose = true) {
+        const { appId, targetPath } = args;
+        const currentStore = localConfig.getDefaultStore();
+        this.api.setStoreEnv(currentStore, 'test');
+        this.resolveAppPath(appId, targetPath);
+        if (isPathDirectory(this.appPath)) {
+            this.swellConfig = swellConfig(this.appPath);
+            const localAppId = this.swellConfig.get('id');
+            const localAppType = this.swellConfig.get('type');
+            if (localAppId) {
+                if (appId && appId !== localAppId) {
+                    this.error(`${localAppType === 'theme' ? 'A theme' : 'An app'} already exists in this path with a different ID: ${style.appConfigValue(localAppId)}`);
+                }
+                return this.getExistingApp(localAppId);
+            }
+        }
+        const app = appId
+            ? await this.getExistingApp(appId)
+            : shouldChoose
+                ? await this.chooseAppToPull()
+                : undefined;
+        if (shouldChoose) {
+            this.swellConfig = swellConfig(this.appPath);
+        }
+        return app;
+    }
+    async getExistingApp(appId) {
+        try {
+            return await this.getApp(appId);
+        }
+        catch (err) {
+            if (err.status === 404) {
+                const labelPrefix = this.appType === 'theme' ? 'Theme' : 'App';
+                this.error(`${labelPrefix} '${appId}' not found.`);
+            }
+            else {
+                throw err;
+            }
+        }
+    }
+    async getStorefrontToPush(flags = {}) {
+        const targetStorefront = flags['storefront-id'];
+        const currentStorefront = localConfig.getDefaultStorefront(this.appPath);
+        let storefrontId = targetStorefront || currentStorefront;
+        if (!storefrontId || flags['storefront-select']) {
+            const storefronts = await this.getAllAppStorefronts({
+                type: this.appType,
+            });
+            if (storefronts.count > 0) {
+                storefrontId = await select({
+                    message: 'Choose a storefront',
+                    choices: [
+                        ...storefronts.results.map((storefront) => ({
+                            name: `${style.appConfigValue(storefront.name)} (${storefront.id}) ${storefront.primary ? '[primary]' : ''}`,
+                            value: storefront.id,
+                        })),
+                        {
+                            name: 'Create new storefront',
+                            value: null,
+                        },
+                    ],
+                });
+            }
+            if (!storefrontId) {
+                this.storefront = await this.createAppStorefront(storefronts.count > 0);
+            }
+        }
+        if (storefrontId) {
+            this.storefront = await this.getAppStorefront({
+                storefront_id: storefrontId,
+                type: this.appType,
+            });
+            if (!this.storefront) {
+                if (targetStorefront) {
+                    this.error(`Storefront ${style.appConfigValue(storefrontId)} not found.`);
+                }
+                this.log(`Storefront ${style.appConfigValue(storefrontId)} not found.\n`);
+                localConfig.setDefaultStorefront(this.appPath, '');
+                return this.getStorefrontToPush();
+            }
+        }
+        this.app = await this.getApp(this.app.id);
+        return this.storefront;
+    }
+    async getStorefrontToPull(args = {}, flags = {}) {
+        const { targetPath } = args;
+        const targetApp = await this.getAppToPull(args, false);
+        const targetStorefront = flags['storefront-id'];
+        this.resolveAppPath(args.appId, targetPath);
+        // Only use default if path exists
+        let currentStorefront;
+        if (isPathDirectory(this.appPath)) {
+            currentStorefront = localConfig.getDefaultStorefront(this.appPath);
+        }
+        let storefrontId = targetStorefront || targetApp ? currentStorefront : undefined;
+        if (!storefrontId || flags['storefront-select']) {
+            const storefronts = await this.getAllStorefronts(targetApp?.id
+                ? this.appType === 'theme'
+                    ? { theme_app_id: targetApp?.id }
+                    : { app_id: targetApp?.id }
+                : { type: this.appType });
+            if (storefronts.count > 0) {
+                storefrontId = await select({
+                    message: 'Choose a storefront',
+                    choices: [
+                        ...storefronts.results.map((storefront) => ({
+                            name: `${style.appConfigValue(storefront.name)} (${storefront.id}) ${storefront.primary ? '[primary]' : ''}`,
+                            value: storefront.id,
+                        })),
+                    ],
+                });
+                this.storefront = storefronts.results.find((storefront) => storefront.id === storefrontId);
+                const appId = this.appType === 'theme'
+                    ? this.storefront.theme_app_id
+                    : this.storefront.app_id;
+                this.resolveAppPath(this.storefront.name, targetPath);
+                this.app = await this.getApp(appId);
+            }
+            else {
+                // Theme apps should always have a storefront, so this shouldn't be necessary
+                // However it's a good fallback in case the storefront was deleted
+                // Choosing a theme app will proceed to pull app files
+                this.app = await this.chooseAppToPull();
+                this.resolveAppPath(this.app.name, targetPath);
+            }
+        }
+        else {
+            this.app = targetApp;
+        }
+        if (storefrontId && !this.storefront) {
+            this.storefront = await this.getAppStorefront({
+                storefront_id: storefrontId,
+                type: 'theme',
+            });
+            if (!this.storefront) {
+                this.error(`Storefront ${style.appConfigValue(storefrontId)} not found.`);
+            }
+            const appId = this.appType === 'theme'
+                ? this.storefront.theme_app_id
+                : this.storefront.app_id;
+            this.app = await this.getApp(appId);
+        }
+        this.swellConfig = swellConfig(this.appPath);
+        return this.storefront;
+    }
+    async chooseAppToPull(query) {
+        const typeLabelPlural = this.appType === 'theme' ? 'themes' : 'apps';
+        const typeLabelPrefixed = this.appType === 'theme' ? 'a theme' : 'an app';
+        const typeQuery = this.appType === 'theme' ? { type: 'theme' } : { type: 'storefront' };
+        const apps = await this.api.get({
+            adminPath: `/apps`,
+        }, { query: { limit: null, ...typeQuery, ...query } });
+        if (!apps.count) {
+            const currentStore = localConfig.getDefaultStore();
+            this.error(`There are no ${typeLabelPlural} associated with your store ${style.storeId(currentStore)}`);
+        }
+        const appSlugId = (await select({
+            choices: apps.results.map((app) => ({
+                name: `${style.appConfigValue(app.name)} (${getAppSlugId(app)})`,
+                value: app.private_id,
+            })),
+            message: `Choose ${typeLabelPrefixed} to pull`,
+        }));
+        const appId = apps.results.find((app) => app.private_id === appSlugId).id;
+        const app = await this.getApp(appId);
+        this.log();
+        return app;
+    }
+    async createAppStorefront(hasOtherStorefronts = true) {
+        let appId;
+        let themeAppId;
+        if (this.app.type === 'theme') {
+            themeAppId = this.app.id;
+            const storefrontApps = await this.handleRequestErrors(async () => this.api.get({
+                adminPath: `/apps?type=storefront&kind=shop`,
+            }));
+            const compatibleStorefrontApps = storefrontApps.results.filter((app) => app.installed &&
+                app.storefront?.theme?.provider === 'app' &&
+                this.app.theme?.storefront?.app === toAppId(app.private_id));
+            if (!compatibleStorefrontApps.length) {
+                this.error('No compatible storefront apps found for this theme. Install a new storefront app first.');
+            }
+            let targetApp;
+            if (compatibleStorefrontApps.length === 1) {
+                targetApp = compatibleStorefrontApps[0];
+            }
+            else {
+                targetApp = await select({
+                    message: 'Choose a storefront app',
+                    choices: compatibleStorefrontApps.map((app) => ({
+                        name: `${style.appConfigValue(app.name)} v${app.version}`,
+                        value: app,
+                    })),
+                });
+            }
+            appId = targetApp.id;
+            this.log(`\n${style.success('✔')} Using ${style.appConfigValue(targetApp.name)} v${targetApp.version}\n`);
+        }
+        else if (this.app.type === 'storefront') {
+            appId = this.app.id;
+            const themeApps = await this.handleRequestErrors(async () => this.api.get({
+                adminPath: `/apps?type=theme`,
+            }));
+            const compatibleThemeApps = themeApps.results.filter((app) => app.installed &&
+                Object.keys(app.compatibilities || {}).includes(this.app.private_id));
+            if (!compatibleThemeApps.length) {
+                this.error('No compatible theme apps found for this storefront. Install a new theme app first.');
+            }
+            let targetApp;
+            if (compatibleThemeApps.length === 1) {
+                targetApp = compatibleThemeApps[0];
+            }
+            else {
+                targetApp = await select({
+                    message: 'Choose a theme app',
+                    choices: compatibleThemeApps.map((app) => ({
+                        name: `${style.appConfigValue(app.name)} v${app.version}`,
+                        value: app,
+                    })),
+                });
+                this.log();
+            }
+            themeAppId = targetApp.id;
+            this.log(`${style.success('✔')} Using ${style.appConfigValue(targetApp.name)} v${targetApp.version}\n`);
+        }
+        else {
+            this.error('App type not supported for storefront creation');
+        }
+        let name;
+        if (hasOtherStorefronts) {
+            name = await input({
+                message: 'Name your storefront',
+                default: this.app.name,
+            });
+            if (name === this.app.name) {
+                name = undefined; // undefined allows the api to auto increment name
+            }
+        }
+        return this.handleRequestErrors(async () => this.api.post({
+            adminPath: `/storefronts`,
+        }, {
+            body: {
+                name,
+                app_id: appId,
+                theme_app_id: themeAppId,
+            },
+            onAsyncGetPath: (response) => ({
+                adminPath: `/storefronts/${response.id}`,
+            }),
+        }));
+    }
+    logStorefrontConnected() {
+        if (!this.storefront) {
+            this.error('Storefront not connected');
+        }
+        const { name, theme_app } = this.storefront;
+        const themeLog = theme_app && theme_app.name !== name
+            ? ` [theme] ${style.appName(theme_app.name)} v${theme_app.version}`
+            : '';
+        this.log(`[storefront] ${style.appName(name)}${themeLog}\n`);
+    }
+    logDashboardUrl(flags) {
+        const currentStore = localConfig.getDefaultStore();
+        this.log(`View the ${style.appConfigValue(this.app.name)} app in your dashboard at ${style.link(this.dashboardUrl(flags, currentStore))}.`);
+    }
+    async pushFilePath(relativePath, force) {
+        const topDir = relativePath.split(path.sep)[0];
+        const configType = (getConfigTypeFromPath(topDir) || 'file');
+        const configTypeKey = getConfigTypeKeyFromValue(configType) || 'file';
+        const exAppConfigs = (this.app?.configs || []).filter((config) => config.filePath?.startsWith(`${relativePath}/`));
+        const allFiles = [];
+        const pushFiles = [];
+        for (const { configFile } of allConfigFilesInDir(this.appPath, relativePath, configTypeKey)) {
+            const config = appConfigFromFile(configFile, configType, this.appPath);
+            allFiles.push(config);
+            const exConfig = exAppConfigs.find((exConfig) => {
+                return config.filePath === exConfig.filePath;
+            });
+            if (!force && exConfig && exConfig.hash === config.hash) {
+                continue;
+            }
+            pushFiles.push(config);
+        }
+        const filesToRemove = exAppConfigs.filter((config) => {
+            return !allFiles.find((appConfig) => {
+                return appConfig.filePath === config.filePath;
+            });
+        });
+        const hasChanges = pushFiles.length > 0 || filesToRemove.length > 0;
+        if (pushFiles.length > 0) {
+            const pushConcurrency = configTypeKey === 'ASSET' ? 1 : PUSH_CONCURRENCY;
+            while (pushFiles.length) {
+                await Promise.all(pushFiles
+                    .splice(0, pushConcurrency)
+                    .map(async (appConfig) => {
+                    await this.pushRemoteFile(appConfig);
+                }));
+            }
+        }
+        // Remove any deleted files
+        if (filesToRemove.length > 0) {
+            while (filesToRemove.length) {
+                await Promise.all(filesToRemove.splice(0, PUSH_CONCURRENCY).map(async (appConfig) => {
+                    await this.removeRemoteFile(appConfig);
+                }));
+            }
+        }
+        if (!hasChanges && !force) {
+            this.log(`${style.success('✔')} All ${style.path(relativePath)} files are up to date.`);
+        }
+        else {
+            this.log();
+            this.log(`${style.success('✔')} Pushed ${style.path(relativePath)} to ${style.appConfigValue(this.app.name)}.`);
+        }
+    }
+    async pushFile(relativePath) {
+        const basePath = relativePath.split(path.sep)[0];
+        const configType = getConfigTypeFromPath(basePath) || ConfigType.FILE;
+        const config = appConfigFromFile(relativePath, configType, this.appPath);
+        await this.pushRemoteFile(config);
+    }
+    async deployFrontend(projectType) {
+        // TODO: check package.json for a "deploy" command and run that if it exists
+        // Note it must return a URL somehow
+        try {
+            return this.wranglerDeployFrontend(projectType);
+        }
+        catch (error) {
+            this.error(`Error deploying frontend: ${error.message}`);
+        }
+    }
+    async buildFrontend(projectType) {
+        this.log(`Building ${projectType.name} frontend...\n`);
+        // TODO: check package.json for a "build" command and run that if it exists
+        await this.exec(projectType.buildCommand);
+    }
+    async wranglerDeployFrontend(projectType) {
+        let deploymentUrl;
+        let interactiveError = false;
+        this.log(`\nDeploying to Cloudflare...\n`);
+        try {
+            await this.exec(`npx wrangler pages deploy ${this.appPath}/frontend/${projectType.deployPath}`, (string) => {
+                // Dependent on wrangler output
+                if (string.includes('Take a peek over at')) {
+                    deploymentUrl = String(string.split('Take a peek over at ')[1]).trim();
+                    return false;
+                }
+                else if (interactiveError ||
+                    string.includes('non-interactive mode') ||
+                    string.includes('non-interactive environment')) {
+                    interactiveError = true;
+                    return false;
+                }
+            });
+        }
+        catch (err) {
+            // noop
+            if (interactiveError) {
+                this.log(style.funcWarn(`Your Cloudflare environment must be initialized by logging in with \`wrangler login\`, and exporting the \`CLOUDFLARE_ACCOUNT_ID\` environment variable. Refer to https://developers.cloudflare.com/workers/wrangler/configuration/ for details, and re-run this command to connect the deployment with your app.`));
+                process.exit(1);
+            }
+            else {
+                throw err;
+            }
+        }
+        if (!deploymentUrl) {
+            this.error('Unable to retrieve deployment URL.');
+        }
+        return deploymentUrl;
+    }
+    async updateFrontendDeployment(currentStore, projectType, deploymentUrl, deploymentHash) {
+        const spinner = ora();
+        spinner.start(`Updating frontend deployment...`);
+        await this.handleRequestErrors(async () => this.api.put({ adminPath: `/apps/${this.app.id}` }, {
+            body: {
+                $client_id: currentStore,
+                $environment_id: 'test',
+                frontend: {
+                    url: deploymentUrl,
+                    service: 'cloudflare',
+                    framework: projectType.slug,
+                    deployment_hash: deploymentHash,
+                },
+            },
+        }), () => spinner.fail('Error updating app deployment'));
+        spinner.succeed('Updated frontend deployment.\n');
+    }
+    logAppFrontendUrl() {
+        const currentStore = localConfig.getDefaultStore();
+        // Shouldn't happen, but just in case
+        if (!this.app.installed?.id) {
+            return;
+        }
+        this.log(`View your app at ${style.link(this.appFrontendUrl(currentStore, this.app.installed.id))}.`);
+    }
+    logStorefrontFrontendUrl(storefront, branchId) {
+        const currentStore = localConfig.getDefaultStore();
+        this.log(`View your storefront at ${style.link(this.storefrontFrontendUrl(currentStore, storefront, branchId))}.`);
+    }
+}