@swell/cli 2.0.20 → 2.2.0

package/dist/lib/theme-sync.js

@@ -1,29 +1,37 @@
-import http from 'http';
 import getPort, { portNumbers } from 'get-port';
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore - http-proxy has incomplete TypeScript definitions
+import httpProxy from 'http-proxy';
+import http from 'node:http';
 import util from 'node:util';
 import zlib from 'node:zlib';
-// @ts-ignore
-import httpProxy from 'http-proxy';
-// @ts-ignore
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore - ws library uses named exports differently
+// eslint-disable-next-line import/no-named-as-default
 import WebSocket, { WebSocketServer } from 'ws';
 const gunzipAsync = util.promisify(zlib.gunzip);
 const inflateAsync = util.promisify(zlib.inflate);
 const brotliDecompressAsync = util.promisify(zlib.brotliDecompress);
 const FALLBACK_PORT = 3000;
 export class ThemeSync {
-    server;
+    options;
     proxy;
+    server;
     wss;
-    options;
-    async selectPort() {
-        return (await getPort({ port: portNumbers(3000, 3100) })) || FALLBACK_PORT;
-    }
     constructor(options) {
         this.options = options;
         this.server = http.createServer();
         this.proxy = httpProxy.createProxyServer({});
         this.wss = new WebSocketServer({ server: this.server });
     }
+    reload() {
+        // Get all connected WebSocket clients
+        const clients = [...this.wss.clients].filter((client) => client.readyState === WebSocket.OPEN);
+        // Notify clients to reload
+        for (const client of clients) {
+            client.send('reload');
+        }
+    }
     async start() {
         // Select port if not specified
         if (!this.options.port) {
@@ -85,38 +93,52 @@ export class ThemeSync {
             });
         });
     }
-    reload() {
-        // Get all connected WebSocket clients
-        const clients = Array.from(this.wss.clients).filter((client) => client.readyState === WebSocket.OPEN);
-        // Notify clients to reload
-        clients.forEach((client) => {
-            client.send('reload');
-        });
+    decodeRequestBody(body, encoding) {
+        switch (encoding) {
+            case 'gzip': {
+                return gunzipAsync(body);
+            }
+            case 'deflate': {
+                return inflateAsync(body);
+            }
+            case 'br': {
+                return brotliDecompressAsync(body);
+            }
+            default: {
+                return Promise.reject(new Error(`Unsupported content encoding: ${encoding}`));
+            }
+        }
+    }
+    // Inject WebSocket client script into proxied HTML
+    injectScript(html, host) {
+        const script = `
+      <script>
+        const ws = new WebSocket('ws://${host}/ws');
+        ws.onmessage = () => {
+          window.location.reload();
+        };
+      </script>
+    `;
+        return html.replace('</body>', `${script}</body>`);
     }
     async parseRequestBody(proxyRes, body) {
         // May contain multiple encodings
         const contentEncoding = String(proxyRes.headers['content-encoding'] ?? '')
             .split(',')
             .reverse();
+        // Sequential decoding of content-encoding layers is required
+        /* eslint-disable no-await-in-loop */
         for (const value of contentEncoding) {
             const encoding = value.trim().toLowerCase();
             if (encoding) {
                 body = await this.decodeRequestBody(body, encoding);
             }
         }
+        /* eslint-enable no-await-in-loop */
         return body.toString('utf8');
     }
-    decodeRequestBody(body, encoding) {
-        switch (encoding) {
-            case 'gzip':
-                return gunzipAsync(body);
-            case 'deflate':
-                return inflateAsync(body);
-            case 'br':
-                return brotliDecompressAsync(body);
-            default:
-                return Promise.reject(new Error(`Unsupported content encoding: ${encoding}`));
-        }
+    async selectPort() {
+        return (await getPort({ port: portNumbers(3000, 3100) })) || FALLBACK_PORT;
     }
     shouldInjectScript(proxyRes, html) {
         // Check if this is an HTML response
@@ -129,16 +151,4 @@ export class ThemeSync {
         }
         return true;
     }
-    // Inject WebSocket client script into proxied HTML
-    injectScript(html, host) {
-        const script = `
-      <script>
-        const ws = new WebSocket('ws://${host}/ws');
-        ws.onmessage = () => {
-          window.location.reload();
-        };
-      </script>
-    `;
-        return html.replace('</body>', `${script}</body>`);
-    }
 }

package/dist/push-app-command.d.ts

@@ -12,20 +12,22 @@ interface WatchingChange {
 export declare abstract class PushAppCommand extends RemoteAppCommand {
     frontendPath: string;
     logWatchChanges: boolean;
-    onWatchChange?: (appConfig?: AppConfig, result?: any) => void;
+    onWatchChange?: (appConfig?: AppConfig, action?: string, result?: any) => void;
     watchingChangeQueue: Map<string, WatchingChange>;
     watchingFiles: Set<string>;
     watchingIgnoreFilter: GlobbyFilterFunction | null;
     watchingTimer: NodeJS.Timeout | null;
     watchListener: (eventType: fs.WatchEventType, filename: null | string) => Promise<void>;
-    buildFrontend(projectType: FrontendProjectType): Promise<void>;
+    protected showFrontendMigrationError(): never;
+    buildFrontend(projectType?: FrontendProjectType): Promise<void>;
     chooseAppToPull(query?: any): Promise<App>;
     createAppStorefront(hasOtherStorefronts?: boolean): Promise<any>;
     deployAppFrontend(force?: boolean, log?: boolean): Promise<void>;
     deployFrontend(projectType: FrontendProjectType): Promise<string>;
     ensureAppExists(file?: string, shouldCreate?: boolean): Promise<boolean>;
     ensureLoggedIn(): Promise<true | undefined>;
-    exec(command: string, onOutput?: (string: string) => any | false): Promise<void>;
+    exec(command: string, cwd?: string, onOutput?: (string: string) => any | false): Promise<void>;
+    execFrontend(command: string, onOutput?: (string: string) => any | false): Promise<void>;
     getAllAppStorefronts(params?: {
         type?: string;
     }): Promise<any>;
@@ -49,19 +51,19 @@ export declare abstract class PushAppCommand extends RemoteAppCommand {
         appId?: string;
         targetPath?: string;
     }, flags?: {
+        env?: string;
         'storefront-id'?: string;
         'storefront-select'?: boolean;
-        env?: string;
     }): Promise<any>;
     getStorefrontToPush(flags?: {
+        env?: string;
         'storefront-id'?: string;
         'storefront-select'?: boolean;
-        env?: string;
     }): Promise<any>;
     setStorefrontEnv(flags: {
+        env?: string;
         'storefront-id'?: string;
         'storefront-select'?: boolean;
-        env?: string;
     }, defaultStorefront?: any): Promise<void>;
     handleWatchFileChange(configFile: string, configType: ConfigType, event: WatchFileEvent): Promise<void>;
     logAppFrontendUrl(): void;
@@ -76,13 +78,15 @@ export declare abstract class PushAppCommand extends RemoteAppCommand {
     runWatchChangeQueue(): Promise<void>;
     saveCurrentStorefront(): void;
     setWatchingFiles(): Promise<void>;
+    startProxyServer(port?: number): Promise<number>;
     updateFrontendDeployment(currentStore: string, projectType: FrontendProjectType, deploymentUrl: string, deploymentHash: string): Promise<void>;
+    updateLocalProxy(proxyUrl: string, storefrontId?: string): Promise<void>;
     watchForChanges({ logChanges, onChange, syncAll, }?: {
         logChanges?: boolean;
-        onChange?: () => void;
+        onChange?: (appConfig?: AppConfig, result?: any) => void;
         syncAll?: boolean;
     }): Promise<void>;
-    wranglerDeployFrontend(projectType: FrontendProjectType): Promise<string>;
+    wranglerDeployFrontend(_projectType: FrontendProjectType): Promise<string>;
     private confirmRemoveInstalledApp;
 }
 export {};

package/dist/push-app-command.js

@@ -1,19 +1,22 @@
 import { confirm, input, select } from '@inquirer/prompts';
 import { $ } from 'execa';
+import getPort, { portNumbers } from 'get-port';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import Stream from 'node:stream';
 import ora from 'ora';
 import { default as swellConfig } from './lib/app-config.js';
-import { ConfigType, FrontendProjectTypes, allConfigFilesInDir, appConfigFromFile, filePathExists, filePathExistsAsync, findAppConfig, getAppSlugId, getConfigTypeFromPath, getConfigTypeKeyFromValue, getFrontendProjectType, globAllFilesByPath, hashString, isPathDirectory, } from './lib/apps/index.js';
-import { selectEnvironmentId } from './lib/stores.js';
+import { ConfigType, getFrontendProjectValidValues, allConfigFilesInDir, appConfigFromFile, filePathExists, filePathExistsAsync, findAppConfig, getAppSlugId, getConfigTypeFromPath, getConfigTypeKeyFromValue, getFrontendProjectType, globAllFilesByPath, hashString, isPathDirectory, } from './lib/apps/index.js';
 import { getGlobIgnorePathsChecker } from './lib/apps/paths.js';
 import { default as localConfig } from './lib/config.js';
 import { toAppId } from './lib/create/index.js';
+import { getProxyUrl } from './lib/proxy.js';
+import { selectEnvironmentId } from './lib/stores.js';
 import style from './lib/style.js';
 import { RemoteAppCommand } from './remote-app-command.js';
 const PUSH_CONCURRENCY = 3;
 const WATCH_WINDOW_MS = 100;
+const DEV_SERVER_FALLBACK_PORT = 3000;
 export class PushAppCommand extends RemoteAppCommand {
     frontendPath = '';
     logWatchChanges = true;
@@ -45,6 +48,7 @@ export class PushAppCommand extends RemoteAppCommand {
         if (!configType) {
             return;
         }
+        await this.setWatchingFiles();
         const isWatching = this.watchingFiles.has(configFile);
         let watchFileEvent;
         // per node docs:
@@ -75,6 +79,7 @@ export class PushAppCommand extends RemoteAppCommand {
             await this.handleWatchFileChange(configFile, configType, watchFileEvent);
         }
         catch (error) {
+            console.error(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
@@ -87,10 +92,29 @@ export class PushAppCommand extends RemoteAppCommand {
             }
         }
     };
+    showFrontendMigrationError() {
+        return this.error(style.funcWarn(`⚠️  Your frontend directory exists but appears to use an older structure.\n` +
+            `Swell CLI v2.1.0+ requires a Workers-based frontend with package.json.\n\n` +
+            `${style.basicHighlight('Migration options:')}\n\n` +
+            `1. ${style.basicHighlight('Migrate to Workers')} (recommended)\n` +
+            `   If you are using a Swell official application (e.g. Proxima), update to the latest version.\n` +
+            `   Otherwise, initialize your frontend as a Workers project.\n` +
+            `   Follow Cloudflare's official guide: ${style.link('https://developers.cloudflare.com/workers/static-assets/migration-guides/migrate-from-pages/')}\n\n` +
+            `2. ${style.basicHighlight('Use older CLI version')}\n` +
+            `   Continue with Pages deployment:\n` +
+            `   ${style.dim('$ npm install -g @swell/cli@2.0.20')}\n`));
+    }
     async buildFrontend(projectType) {
+        if (!projectType) {
+            this.showFrontendMigrationError();
+            return; // unreachable but helps TypeScript narrow the type
+        }
+        if (!projectType.buildCommand) {
+            // No build command needed for this framework
+            return;
+        }
         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);
+        await this.execFrontend(projectType.buildCommand);
     }
     async chooseAppToPull(query) {
         const typeLabelPlural = this.appType === 'theme' ? 'themes' : 'apps';
@@ -241,7 +265,7 @@ export class PushAppCommand extends RemoteAppCommand {
         null);
         const isTheme = app?.type === 'theme';
         if (app && !isTheme && this.appType === 'theme') {
-            this.error(`App ${style.appConfigValue(app?.name)} is not a theme.`);
+            this.error(`App ${style.appConfigValue(app?.name)} is not a theme. Use 'swell app' commands instead.`);
         }
         // Confirm development app unless theme without app syncing
         if (!isTheme || this.themeSyncApp) {
@@ -283,9 +307,9 @@ export class PushAppCommand extends RemoteAppCommand {
             return true;
         }
     }
-    async exec(command, onOutput) {
+    async exec(command, cwd, onOutput) {
         const $$ = $({
-            cwd: this.frontendPath,
+            cwd: cwd || this.appPath,
             shell: true,
             stderr: onOutput ? 'pipe' : 'inherit',
             stdin: 'inherit',
@@ -307,6 +331,9 @@ export class PushAppCommand extends RemoteAppCommand {
             await $$ `${command}`;
         }
     }
+    async execFrontend(command, onOutput) {
+        return this.exec(command, this.frontendPath, onOutput);
+    }
     async getAllAppStorefronts(params) {
         const query = Object.entries(params || {})
             .map(([key, value]) => `${key}=${value}`)
@@ -392,15 +419,23 @@ export class PushAppCommand extends RemoteAppCommand {
     }
     getFrontendProjectType(required = true) {
         this.frontendPath = path.join(this.appPath, 'frontend');
-        if (!required) {
-            const frontendExists = filePathExists(this.frontendPath);
-            if (!frontendExists) {
-                return null;
-            }
+        const frontendExists = filePathExists(this.frontendPath);
+        if (!required && !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(', ')}.`);
+            // If frontend not required, just return null (don't error)
+            if (!required) {
+                return null;
+            }
+            // Frontend IS required but not found
+            // Check if frontend directory exists but lacks package.json (old structure)
+            if (frontendExists) {
+                this.showFrontendMigrationError();
+            }
+            // Frontend directory doesn't exist at all
+            this.error(`No valid frontend app found in ${this.frontendPath}. Supported frameworks include: ${getFrontendProjectValidValues(false)}.`);
         }
         return projectType;
     }
@@ -526,8 +561,8 @@ export class PushAppCommand extends RemoteAppCommand {
                 await this.api.setStoreEnv(currentStore, defaultStorefront?.env);
             }
         }
-        else if (flags['env']) {
-            await this.api.setStoreEnv(currentStore, flags['env']);
+        else if (flags.env) {
+            await this.api.setStoreEnv(currentStore, flags.env);
         }
         else {
             const hasTestEnv = await this.api.isTestEnvEnabled();
@@ -668,15 +703,24 @@ export class PushAppCommand extends RemoteAppCommand {
         }
         const queue = [...this.watchingChangeQueue.values()];
         this.watchingChangeQueue.clear();
+        // Process queue in batches with concurrency control
+        /* eslint-disable no-await-in-loop */
         while (queue.length > 0) {
-            // eslint-disable-next-line no-await-in-loop
-            await Promise.all(queue.splice(0, PUSH_CONCURRENCY).map(async ({ action, appConfig }) => {
-                const result = await (action === 'remove'
-                    ? this.removeRemoteFile(appConfig, this.logWatchChanges)
-                    : this.pushRemoteFile(appConfig, this.logWatchChanges));
-                this.onWatchChange?.(appConfig, result);
-            }));
+            try {
+                await Promise.all(queue
+                    .splice(0, PUSH_CONCURRENCY)
+                    .map(async ({ action, appConfig }) => {
+                    const result = await (action === 'remove'
+                        ? this.removeRemoteFile(appConfig, this.logWatchChanges)
+                        : this.pushRemoteFile(appConfig, this.logWatchChanges));
+                    this.onWatchChange?.(appConfig, action, result);
+                }));
+            }
+            catch {
+                // noop
+            }
         }
+        /* eslint-enable no-await-in-loop */
         // refetch app to get updated configs
         this.app = await this.getAppWithConfig(this.app.id);
         // Process next accumulated changes
@@ -691,6 +735,16 @@ export class PushAppCommand extends RemoteAppCommand {
     async setWatchingFiles() {
         this.watchingFiles = new Set(await globAllFilesByPath(this.appPath));
     }
+    async startProxyServer(port) {
+        // Find an open port starting at 3000
+        const freePort = port ||
+            (await getPort({ port: portNumbers(3000, 3100) })) ||
+            DEV_SERVER_FALLBACK_PORT;
+        // Start proxy
+        const proxyUrl = await getProxyUrl(freePort);
+        await this.updateLocalProxy(proxyUrl, this.storefront?.id);
+        return freePort;
+    }
     async updateFrontendDeployment(currentStore, projectType, deploymentUrl, deploymentHash) {
         const spinner = ora();
         spinner.start('Updating frontend deployment...');
@@ -708,6 +762,17 @@ export class PushAppCommand extends RemoteAppCommand {
         }), () => spinner.fail('Error updating app deployment'));
         spinner.succeed('Updated frontend deployment.\n');
     }
+    async updateLocalProxy(proxyUrl, storefrontId) {
+        const storefront = this.app.type === 'storefront' &&
+            (await this.getAppStorefront({ storefront_id: storefrontId }));
+        await this.handleRequestErrors(async () => this.api.put({ adminPath: `/client/apps/${this.app.id}/local-proxy` }, {
+            body: {
+                proxy_url: proxyUrl,
+                storefront_id: storefront?.id || null,
+                storefront_slug: storefront?.slug || null,
+            },
+        }));
+    }
     async watchForChanges({ logChanges, onChange, syncAll, } = {}) {
         this.watchingIgnoreFilter = await getGlobIgnorePathsChecker(this.appPath);
         this.logWatchChanges = logChanges ?? true;
@@ -723,19 +788,27 @@ export class PushAppCommand extends RemoteAppCommand {
         }
         fs.watch(this.appPath, { recursive: true }, this.watchListener);
     }
-    async wranglerDeployFrontend(projectType) {
+    async wranglerDeployFrontend(_projectType) {
         let deploymentUrl;
         let interactiveError = false;
+        let pagesProjectError = false;
         this.log(`\nDeploying to Cloudflare...\n`);
         try {
-            await this.exec(`npx wrangler pages deploy ${this.appPath}/frontend/${projectType.deployPath}`, (string) => {
+            await this.execFrontend(`npx wrangler deploy`, (string) => {
                 // Dependent on wrangler output
                 // Parse the deployment URL from the wrangler output.
-                const match = string.match(/Take a peek over at (http\S+)/);
+                const match = string.match(/^\s*(https:\/\/\S+\.workers\.dev)\s*[\S\s]*?Current Version ID: [\w-]+/m);
                 if (match && match.length > 0) {
                     deploymentUrl = match[1];
                     return false;
                 }
+                // Check for Pages project error
+                if (string.includes("It looks like you've run a Workers-specific command in a Pages project") ||
+                    string.includes('please run `wrangler pages deploy` instead') ||
+                    string.includes('Missing entry-point')) {
+                    pagesProjectError = true;
+                    return false;
+                }
                 if (interactiveError ||
                     string.includes('non-interactive mode') ||
                     string.includes('non-interactive environment')) {
@@ -746,10 +819,16 @@ export class PushAppCommand extends RemoteAppCommand {
         }
         catch (error) {
             // 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.`));
-                // eslint-disable-next-line no-process-exit, unicorn/no-process-exit
-                process.exit(1);
+            if (pagesProjectError) {
+                this.error(style.funcWarn(`⚠️  Version incompatibility!\n` +
+                    `Your project is configured for Cloudflare Pages, but Swell CLI v2.1.0+ uses Cloudflare Workers.\n\n` +
+                    `To fix this, you can either:\n` +
+                    `1. Update your app project (for Swell official apps) or reconfigure it for workers\n` +
+                    `   (https://developers.cloudflare.com/workers/static-assets/migration-guides/migrate-from-pages/)\n` +
+                    `2. Use an older Swell CLI version: npm install -g @swell/cli@2.0.20\n`));
+            }
+            else if (interactiveError) {
+                this.error(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.`));
             }
             else {
                 throw error;

package/dist/remote-app-command.d.ts

@@ -5,11 +5,11 @@ import { App, AppConfig, AppVersion } from './lib/apps/index.js';
  * configurations.
  */
 export declare abstract class RemoteAppCommand extends AppCommand {
-    appType: string;
     static delayOrientation: boolean;
     static orientation: AppCommandOrientation;
     app: App;
     appCreated: boolean;
+    appType: string;
     storefront?: any;
     storefrontLocalUrl?: string;
     themeSyncApp?: boolean;

package/dist/remote-app-command.js

@@ -15,7 +15,6 @@ import style from './lib/style.js';
  * configurations.
  */
 export class RemoteAppCommand extends AppCommand {
-    appType = 'any';
     // allows child commands to set orientation
     static delayOrientation = false;
     // most of the times this will be the target environment
@@ -24,6 +23,7 @@ export class RemoteAppCommand extends AppCommand {
     app = {};
     // Indicates the app was created during the command execution
     appCreated = false;
+    appType = 'any';
     // API instance of the target storefront, if applicable
     storefront = null;
     // Indicates we are syncing with a local app frontend via proxy
@@ -638,7 +638,9 @@ export class RemoteAppCommand extends AppCommand {
         const { env, store } = flags;
         if (this.app.name) {
             // Show theme version if not syncing app
-            const version = !this.themeSyncApp && this.app.type === 'theme' && this.storefront?.theme_version
+            const version = !this.themeSyncApp &&
+                this.app.type === 'theme' &&
+                this.storefront?.theme_version
                 ? this.storefront?.theme_version
                 : this.app.version;
             orientationOutput.push(`[${this.app.type === 'theme' ? 'theme' : 'app'}] ${style.appName(this.app.name)}${version ? ` v${version}` : ''}`);

package/dist/swell-api-command.d.ts

@@ -0,0 +1,13 @@
+import { HttpMethod } from './lib/api.js';
+import { SwellCommand } from './swell-command.js';
+export declare abstract class SwellApiCommand extends SwellCommand {
+    protected abstract get method(): HttpMethod;
+    protected request(command: typeof SwellApiCommand, requestOptions?: Api.RequestOptions): Promise<void>;
+    protected catch(error: Error): Promise<any>;
+    private parseCommand;
+    private processBody;
+    private isFilePath;
+    private handleResponse;
+    private onSuccess;
+    private onError;
+}

package/dist/swell-api-command.js

@@ -0,0 +1,75 @@
+import * as fs from 'node:fs';
+import path from 'node:path';
+import { FetchError } from 'node-fetch';
+import { SwellCommand } from './swell-command.js';
+export class SwellApiCommand extends SwellCommand {
+    async request(command, requestOptions = {}) {
+        const { paths, options } = await this.parseCommand(command);
+        const response = await this.api[this.method](paths, {
+            rawResponse: true,
+            ...options,
+            ...requestOptions,
+        });
+        await this.handleResponse(response);
+    }
+    async catch(error) {
+        if (error instanceof FetchError) {
+            const message = `Could not connect to Swell API. Please try again later: ${error.message}`;
+            return this.onError(message, { exit: 2, code: error.code });
+        }
+        return this.onError(error.message, { exit: 1 });
+    }
+    async parseCommand(options, argv) {
+        const parsedInput = await super.parse(options, argv);
+        const { args, flags } = parsedInput;
+        const { path } = args;
+        const { live, body } = flags;
+        if (!live) {
+            await this.api.setEnv('test');
+        }
+        if (!path.startsWith('/')) {
+            throw new Error('Path must start with a forward slash (/)');
+        }
+        return {
+            ...parsedInput,
+            paths: { adminPath: `/data${path}` },
+            options: {
+                body: await this.processBody(body),
+            },
+        };
+    }
+    async processBody(body) {
+        if (!body) {
+            return;
+        }
+        const bodyData = this.isFilePath(body)
+            ? await fs.promises.readFile(path.resolve(body), 'utf8')
+            : body;
+        return JSON.parse(bodyData);
+    }
+    isFilePath(filePath) {
+        return (path.isAbsolute(filePath) ||
+            filePath.startsWith('./') ||
+            filePath.startsWith('../'));
+    }
+    async handleResponse(response) {
+        const responseText = await response.text();
+        if (responseText.length <= 2) {
+            throw new Error('Not found');
+        }
+        const result = JSON.parse(responseText);
+        if (result.error || result.errors || !response.ok) {
+            throw new Error(responseText);
+        }
+        this.onSuccess(result);
+    }
+    onSuccess(result) {
+        this.log(JSON.stringify(result, null, 2));
+    }
+    onError(message, { code, exit }) {
+        this.error(message, {
+            code,
+            exit,
+        });
+    }
+}

package/dist/swell-command.d.ts

@@ -14,8 +14,8 @@ export declare abstract class SwellCommand extends Command {
     api: Api;
     requiresAuth: boolean;
     constructor(argv: string[], config: Config);
-    catch(error: any): Promise<void>;
     debugJson(...args: any[]): void;
     logError(message: string): void;
     logSuccess(message: string): void;
+    protected catch(error: any): Promise<void>;
 }

package/dist/swell-command.js

@@ -21,15 +21,6 @@ export class SwellCommand extends Command {
         super(argv, config);
         this.api = new Api();
     }
-    async catch(error) {
-        if (error instanceof GitUnknownError) {
-            this.error(style.error(`git: ${error.stderr || error.stdout || error.message}`));
-        }
-        else if (error instanceof FetchError) {
-            this.error(`Could not connect to Swell API. Please try again later: ${error.message}`);
-        }
-        throw error;
-    }
     debugJson(...args) {
         const stringified = args.map((arg) => typeof arg === 'string' ? arg : JSON.stringify(arg, null, 4));
         this.debug(...stringified);
@@ -40,4 +31,13 @@ export class SwellCommand extends Command {
     logSuccess(message) {
         this.log(`${style.success(message)}`);
     }
+    async catch(error) {
+        if (error instanceof GitUnknownError) {
+            this.error(style.error(`git: ${error.stderr || error.stdout || error.message}`));
+        }
+        else if (error instanceof FetchError) {
+            this.error(`Could not connect to Swell API. Please try again later: ${error.message}`);
+        }
+        throw error;
+    }
 }