@swell/cli 2.1.0 → 2.2.0

package/dist/lib/apps/index.js

@@ -46,7 +46,7 @@ const ConfigTypeBatchOrder = [
     ConfigType.FRONTEND,
     ConfigType.FILE,
 ];
-// Configs available for different app types
+// Configs available for admin/integration app types
 const StandardConfigTypes = [
     'MODEL',
     'CONTENT',
@@ -56,7 +56,6 @@ const StandardConfigTypes = [
     'NOTIFICATION',
     'SETTING',
     'WEBHOOK',
-    'THEME',
 ];
 export const StorefrontConfigTypes = [
     'FRONTEND',
@@ -140,7 +139,7 @@ export const FrontendProjectTypes = [
     },
     {
         buildCommand: 'npm exec --workspace=frontend -- opennextjs-cloudflare build',
-        //devCommand: 'npm exec --workspace=frontend -- opennextjs-cloudflare build && npm exec --workspace=frontend -- opennextjs-cloudflare preview --port=${PORT}',
+        // devCommand: 'npm exec --workspace=frontend -- opennextjs-cloudflare build && npm exec --workspace=frontend -- opennextjs-cloudflare preview --port=${PORT}',
         devCommand: 'npm exec --workspace=frontend -- next dev --turbopack --port ${PORT}',
         installCommand: 'npm create cloudflare@latest -- frontend --framework=next --deploy=false --git=false -- --typescript --use-npm --src-dir --app --eslint --import-alias "@/*" --tailwind --turbopack',
         mainPackage: 'next',
@@ -148,6 +147,19 @@ export const FrontendProjectTypes = [
         slug: 'nextjs',
     },
 ];
+export function getFrontendProjectSlugs(withNone = true, withLegacy = true) {
+    const types = withLegacy
+        ? FrontendProjectTypes
+        : FrontendProjectTypes.filter((projectType) => projectType.installCommand);
+    const slugs = types.map((projectType) => projectType.slug);
+    if (withNone) {
+        slugs.push('none');
+    }
+    return slugs;
+}
+export function getFrontendProjectValidValues(withNone = true, withLegacy = true) {
+    return getFrontendProjectSlugs(withNone, withLegacy).join(', ');
+}
 export function getAppSlugId(app) {
     return toAppId(app.private_id) || app.public_id || app.id;
 }
@@ -158,7 +170,7 @@ function hasWorkspaceStructure(appPath) {
         return false;
     }
     try {
-        const content = fs.readFileSync(rootPkgPath, 'utf-8');
+        const content = fs.readFileSync(rootPkgPath, 'utf8');
         const pkg = JSON.parse(content);
         return Array.isArray(pkg.workspaces) && pkg.workspaces.includes('frontend');
     }
@@ -182,7 +194,7 @@ export function getFrontendProjectType(appPath) {
             continue;
         }
         try {
-            const content = fs.readFileSync(pkgPath, 'utf-8');
+            const content = fs.readFileSync(pkgPath, 'utf8');
             const pkg = JSON.parse(content);
             for (const projectType of projectTypes) {
                 if (pkg.dependencies?.[projectType.mainPackage] ||
@@ -190,16 +202,9 @@ export function getFrontendProjectType(appPath) {
                     // Create a copy to avoid mutating the original
                     const detectedType = { ...projectType };
                     // If buildCommand not explicitly set in framework definition, detect it
-                    if (detectedType.buildCommand === undefined) {
-                        // Check if package.json has a "build" script
-                        if (pkg.scripts?.build) {
-                            detectedType.buildCommand = 'npm run build';
-                        }
-                        else {
-                            // No build script found, set to empty string (no build needed)
-                            detectedType.buildCommand = '';
-                        }
-                    }
+                    detectedType.buildCommand ||=
+                        // Check if package.json has a "build" script, if not set to empty string (no build needed)
+                        pkg.scripts?.build ? 'npm run build' : '';
                     return detectedType;
                 }
             }

package/dist/lib/config.d.ts

@@ -8,8 +8,8 @@ declare function getAll(): any;
 declare function getDefaultStore(): string;
 declare function setDefaultStore(storeId: string): void;
 declare function getDefaultStorefront(appPath: string): {
-    id: string;
     env?: string;
+    id: string;
 };
 declare function setDefaultStorefront(appPath: string, storefrontId: string, env?: string): void;
 declare function getSessionId(storeId: string): any;

package/dist/lib/constants.d.ts

@@ -1,5 +1,6 @@
 export declare const API_BASE_URL: any;
 export declare const LOCAL_PROXY_PROVIDER: any;
+export declare const SCHEMAS_BASE_URL: any;
 export declare function getAdminApiBaseUrl(storeId: string): any;
 export declare function getLoginHost(storeId?: string): any;
 export declare function getAppFrontendHost(storeId: string, installedAppId: string): any;

package/dist/lib/constants.js

@@ -14,6 +14,7 @@ const STOREFRONT_FRONTEND_HOST = env.get('STOREFRONT_FRONTEND_HOST') ||
     env.get('STOREFRONT_PAGES_HOST') || // Deprecated
     defaultEnv.STOREFRONT_FRONTEND_HOST;
 export const LOCAL_PROXY_PROVIDER = env.get('LOCAL_PROXY_PROVIDER') || defaultEnv.LOCAL_PROXY_PROVIDER;
+export const SCHEMAS_BASE_URL = env.get('SCHEMAS_BASE_URL') || defaultEnv.SCHEMAS_BASE_URL;
 // helpers to get constants with replacements
 export function getAdminApiBaseUrl(storeId) {
     return ADMIN_API_BASE_URL.replace('${STORE_ID}', storeId);

package/dist/lib/create/content.d.ts

@@ -1,4 +1,5 @@
 interface CreateContentFileBody {
+    $schema: string;
     collection: string;
     description?: string;
     fields?: ContentFieldProps[];
@@ -18,6 +19,9 @@ interface ContentFieldProps {
     label: string;
     type?: ContentType;
 }
+declare const validateViews: (values: string[], onError: (msg: string, options: {
+    exit: number;
+}) => never) => void;
 declare const parseViews: (views: string[]) => ContentViewProps[];
 declare const parseFields: (fields: string[]) => ContentFieldProps[];
-export { CreateContentFileBody, parseFields, parseViews };
+export { CreateContentFileBody, parseFields, parseViews, validateViews };

package/dist/lib/create/content.js

@@ -1,4 +1,11 @@
 import { titleize } from 'inflection';
+const validContentViewValues = ['list', 'edit', 'new'];
+const validateViews = (values, onError) => {
+    const invalid = values.filter((v) => !validContentViewValues.includes(v));
+    if (invalid.length > 0) {
+        onError(`Invalid view(s): ${invalid.join(', ')}\n\nValid views: ${validContentViewValues.join(', ')}\n\nExample: swell create content visitors -v list,edit,new -y`, { exit: 1 });
+    }
+};
 const parseViews = (views) => {
     if (views.length === 0) {
         return [];
@@ -37,4 +44,4 @@ const parseFields = (fields) => {
     }
     return fieldResponse;
 };
-export { parseFields, parseViews };
+export { parseFields, parseViews, validateViews };

package/dist/lib/create/function.d.ts

@@ -7,11 +7,12 @@ interface CreateFunctionArgs {
 interface WriteFunctionFileParams {
     description: string;
     events: string;
+    extension?: string;
     functionName: string;
     language: FunctionLanguage;
     route: string;
     schedule: string;
     trigger: FunctionType;
 }
-declare const getFunctionTemplate: ({ description, events, language, route, schedule, trigger, }: WriteFunctionFileParams) => string;
+declare const getFunctionTemplate: ({ description, events, extension, language, route, schedule, trigger, }: WriteFunctionFileParams) => string;
 export { CreateFunctionArgs, FunctionLanguage, FunctionType, WriteFunctionFileParams, getFunctionTemplate, };

package/dist/lib/create/function.js

@@ -1,4 +1,4 @@
-const getFunctionTemplate = ({ description, events, language, route, schedule, trigger, }) => {
+const getFunctionTemplate = ({ description, events, extension, language, route, schedule, trigger, }) => {
     let typeAppend = ``;
     if (trigger === 'model') {
         const eventsList = events
@@ -24,12 +24,16 @@ const getFunctionTemplate = ({ description, events, language, route, schedule, t
     schedule: '${schedule}',
   },`;
     }
+    let extensionAppend = '';
+    if (extension) {
+        extensionAppend = `extension: '${extension}',\n  `;
+    }
     return `export const config${language === 'ts' ? ': SwellConfig' : ''} = {
-  description: '${description}'${typeAppend}
+  ${extensionAppend}description: '${description}'${typeAppend}
 };
 
 export default async function (req${language === 'ts' ? ': SwellRequest' : ''}) {
-  const { swell, store, settings, data${trigger === 'route' ? ', session' : ''} } = req;
+  const { swell, store, data } = req;
 }
 `;
 };

package/dist/lib/create/model.d.ts

@@ -1,4 +1,5 @@
 interface CreateModelFileBody {
+    $schema: string;
     collection?: string;
     description?: string;
     events?: ModelEventObject;

package/dist/lib/create/schemas.d.ts

@@ -0,0 +1,6 @@
+export declare const SCHEMAS: {
+    readonly CONTENT: "https://json.swell.store/content.json";
+    readonly MODEL: "https://json.swell.store/model.json";
+    readonly NOTIFICATION: "https://json.swell.store/notification.json";
+    readonly SETTING: "https://json.swell.store/setting.json";
+};

package/dist/lib/create/schemas.js

@@ -0,0 +1,6 @@
+export const SCHEMAS = {
+    CONTENT: 'https://json.swell.store/content.json',
+    MODEL: 'https://json.swell.store/model.json',
+    NOTIFICATION: 'https://json.swell.store/notification.json',
+    SETTING: 'https://json.swell.store/setting.json',
+};

package/dist/lib/sessions.js

@@ -2,6 +2,7 @@ import { ux } from '@oclif/core';
 import * as http from 'node:http';
 import open from 'open';
 import { getLoginHost } from './constants.js';
+import { getProxyUrl } from './proxy.js';
 import style from './style.js';
 /**
  * Get the session id for the passed in store. If the session is not found,
@@ -90,10 +91,10 @@ function serverForLogin({ onPost, onStart, storeId, }) {
             res.end('Not Found');
         }
     });
-    server.listen(0, '127.0.0.1', async () => {
+    server.listen(0, async () => {
         const serverAddr = server.address();
-        // the port will be dynamically assigned, one of the available ports
-        const localServerUrl = Buffer.from(`http://${serverAddr.address}:${serverAddr.port}/`).toString('base64');
+        const proxyUrl = await getProxyUrl(serverAddr.port);
+        const localServerUrl = Buffer.from(proxyUrl).toString('base64');
         const loginUrl = `${getLoginHost(storeId)}/admin?cli=${localServerUrl}`;
         onStart(loginUrl);
     });

package/dist/lib/style.js

@@ -1,4 +1,3 @@
-/* eslint-disable perfectionist/sort-objects */
 import chalk from 'chalk';
 export default {
     basicHighlight: chalk.bold,

package/dist/lib/theme-sync.d.ts

@@ -3,17 +3,17 @@ interface ThemeSyncOptions {
     targetUrl: string;
 }
 export declare class ThemeSync {
-    private readonly server;
+    private readonly options;
     private readonly proxy;
+    private readonly server;
     private readonly wss;
-    private readonly options;
-    private selectPort;
     constructor(options: ThemeSyncOptions);
-    start(): Promise<number>;
     reload(): void;
-    private parseRequestBody;
+    start(): Promise<number>;
     private decodeRequestBody;
-    private shouldInjectScript;
     private injectScript;
+    private parseRequestBody;
+    private selectPort;
+    private shouldInjectScript;
 }
 export {};

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

@@ -26,8 +26,8 @@ export declare abstract class PushAppCommand extends RemoteAppCommand {
     deployFrontend(projectType: FrontendProjectType): Promise<string>;
     ensureAppExists(file?: string, shouldCreate?: boolean): Promise<boolean>;
     ensureLoggedIn(): Promise<true | undefined>;
-    execFrontend(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>;
@@ -51,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;
@@ -78,15 +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?: (appConfig?: AppConfig, result?: any) => void;
         syncAll?: boolean;
     }): Promise<void>;
-    startProxyServer(port?: number): Promise<number>;
-    updateLocalProxy(proxyUrl: string, storefrontId?: string): Promise<void>;
-    wranglerDeployFrontend(projectType: FrontendProjectType): Promise<string>;
+    wranglerDeployFrontend(_projectType: FrontendProjectType): Promise<string>;
     private confirmRemoveInstalledApp;
 }
 export {};

package/dist/push-app-command.js

@@ -1,19 +1,19 @@
 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 getPort, { portNumbers } from 'get-port';
 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';
-import { getProxyUrl } from './lib/proxy.js';
 const PUSH_CONCURRENCY = 3;
 const WATCH_WINDOW_MS = 100;
 const DEV_SERVER_FALLBACK_PORT = 3000;
@@ -307,9 +307,6 @@ export class PushAppCommand extends RemoteAppCommand {
             return true;
         }
     }
-    async execFrontend(command, onOutput) {
-        return this.exec(command, this.frontendPath, onOutput);
-    }
     async exec(command, cwd, onOutput) {
         const $$ = $({
             cwd: cwd || this.appPath,
@@ -334,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}`)
@@ -435,7 +435,7 @@ export class PushAppCommand extends RemoteAppCommand {
                 this.showFrontendMigrationError();
             }
             // Frontend directory doesn't exist at all
-            this.error(`No valid frontend app found in ${this.frontendPath}. Supported frameworks include: ${FrontendProjectTypes.map((type) => type.slug).join(', ')}.`);
+            this.error(`No valid frontend app found in ${this.frontendPath}. Supported frameworks include: ${getFrontendProjectValidValues(false)}.`);
         }
         return projectType;
     }
@@ -561,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();
@@ -703,8 +703,9 @@ 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
             try {
                 await Promise.all(queue
                     .splice(0, PUSH_CONCURRENCY)
@@ -715,10 +716,11 @@ export class PushAppCommand extends RemoteAppCommand {
                     this.onWatchChange?.(appConfig, action, result);
                 }));
             }
-            catch (_err) {
-                //noop
+            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
@@ -733,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...');
@@ -750,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;
@@ -765,28 +788,7 @@ export class PushAppCommand extends RemoteAppCommand {
         }
         fs.watch(this.appPath, { recursive: true }, this.watchListener);
     }
-    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 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 wranglerDeployFrontend(projectType) {
+    async wranglerDeployFrontend(_projectType) {
         let deploymentUrl;
         let interactiveError = false;
         let pagesProjectError = false;
@@ -795,7 +797,7 @@ export class PushAppCommand extends RemoteAppCommand {
             await this.execFrontend(`npx wrangler deploy`, (string) => {
                 // Dependent on wrangler output
                 // Parse the deployment URL from the wrangler output.
-                const match = string.match(/^\s*(https:\/\/\S+\.workers\.dev)\s*[\s\S]*?Current Version ID: [\w-]+/m);
+                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;

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}` : ''}`);