@swell/cli 2.0.20 → 2.2.0

package/dist/lib/apps/app-config.js

@@ -174,14 +174,14 @@ export class AppConfig {
             : this.fileData?.toString('utf8');
     }
 }
-class AppConfigDefault extends AppConfig {
+export class AppConfigDefault extends AppConfig {
     hasValues = false;
     type = ConfigType.FILE;
     preparePostData(postData) {
         return postData;
     }
 }
-class AppConfigModel extends AppConfig {
+export class AppConfigModel extends AppConfig {
     hasValues = true;
     type = ConfigType.MODEL;
     preparePostData(postData) {
@@ -190,7 +190,7 @@ class AppConfigModel extends AppConfig {
         return postData;
     }
 }
-class AppConfigContent extends AppConfig {
+export class AppConfigContent extends AppConfig {
     hasValues = true;
     type = ConfigType.CONTENT;
     preparePostData(postData) {
@@ -198,7 +198,7 @@ class AppConfigContent extends AppConfig {
         return postData;
     }
 }
-class AppConfigNotification extends AppConfig {
+export class AppConfigNotification extends AppConfig {
     hasValues = true;
     type = ConfigType.NOTIFICATION;
     preparePostData(postData) {
@@ -225,35 +225,42 @@ class AppConfigNotification extends AppConfig {
         return postData;
     }
 }
-class AppConfigSetting extends AppConfig {
+export class AppConfigSetting extends AppConfig {
     hasValues = true;
     type = ConfigType.SETTING;
     preparePostData(postData) {
         return postData;
     }
 }
-class AppConfigWebhook extends AppConfig {
+export class AppConfigWebhook extends AppConfig {
     hasValues = true;
     type = ConfigType.WEBHOOK;
     preparePostData(postData) {
         return postData;
     }
 }
-class AppConfigFunction extends AppConfig {
+export class AppConfigFunction extends AppConfig {
     hasValues = true;
     type = ConfigType.FUNCTION;
+    isRootFunction() {
+        return (this.isRootConfig('functions') &&
+            (this.filePath.endsWith('.js') || this.filePath.endsWith('.ts')));
+    }
     async preparePostData(postData) {
-        const isFunction = this.isRootConfig('functions') &&
-            (this.filePath.endsWith('.js') || this.filePath.endsWith('.ts'));
-        if (isFunction) {
+        if (this.isRootFunction()) {
             try {
+                // get file contents and if it's empty ignore
+                const fileData = this.prepareFileData();
+                if (!fileData) {
+                    return;
+                }
                 const { code, config } = await bundleFunction(this.filePath);
                 if (!config) {
                     throw new IgnoringFileError('Function must export a `config` object.');
                 }
                 // Save the original file and the bundled version
                 postData.file = {
-                    data: this.prepareFileData(),
+                    data: fileData,
                 };
                 postData.build_file = {
                     content_type: 'text/javascript',
@@ -269,15 +276,15 @@ class AppConfigFunction extends AppConfig {
     }
 }
 // Assets do not get installed but saved as plain files
-class AppConfigAsset extends AppConfigDefault {
+export class AppConfigAsset extends AppConfigDefault {
     hasValues = false;
     type = ConfigType.ASSET;
 }
-class AppConfigFrontend extends AppConfigDefault {
+export class AppConfigFrontend extends AppConfigDefault {
     hasValues = false;
     type = ConfigType.FRONTEND;
 }
-class AppConfigTheme extends AppConfigDefault {
+export class AppConfigTheme extends AppConfigDefault {
     hasValues = false;
     type = ConfigType.THEME;
     preparePostData(postData) {

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

@@ -117,15 +117,16 @@ export declare enum ConfigInputFields {
     VERSION = "version"
 }
 export interface FrontendProjectType {
-    buildCommand: string;
-    configFileName: string;
-    deployPath: string;
+    buildCommand?: string;
     devCommand: string;
-    installCommand: string;
+    installCommand?: string;
+    mainPackage: string;
     name: string;
     slug: string;
 }
 export declare const FrontendProjectTypes: FrontendProjectType[];
+export declare function getFrontendProjectSlugs(withNone?: boolean, withLegacy?: boolean): string[];
+export declare function getFrontendProjectValidValues(withNone?: boolean, withLegacy?: boolean): string;
 export declare function getAppSlugId(app: App): string | undefined;
 export declare function getFrontendProjectType(appPath: string): FrontendProjectType | undefined;
 export declare function getConfigTypeFromPath(path: string): ConfigType | undefined;

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',
@@ -94,39 +93,128 @@ export var ConfigInputFields;
     ConfigInputFields["VALUES"] = "values";
     ConfigInputFields["VERSION"] = "version";
 })(ConfigInputFields || (ConfigInputFields = {}));
-export const FrontendProjectTypes = [
-    {
-        buildCommand: 'npx @cloudflare/next-on-pages',
-        configFileName: 'next.config',
-        deployPath: '.vercel/output/static',
-        devCommand: 'npx next dev --port ${PORT}',
-        installCommand: 'npx create-next-app@latest frontend --typescript --use-npm --src-dir --app --eslint --import-alias "@/*" --tailwind',
-        name: 'Next.js',
-        slug: 'nextjs',
-    },
+// Legacy apps (pre-workspace) - Astro only (Proxima, Sunrise)
+// Uses direct commands without workspace prefix
+const LegacyFrontendProjectTypes = [
     {
         buildCommand: 'npx astro build',
-        configFileName: 'astro.config',
-        deployPath: 'dist',
         devCommand: 'npx astro dev --port ${PORT}',
-        installCommand: 'npm create astro@latest frontend -- --install --no-git --yes --skip-houston --typescript strict',
+        mainPackage: 'astro',
+        name: 'Astro',
+        slug: 'astro',
+    },
+];
+// Modern apps (workspace-based) - All frameworks
+export const FrontendProjectTypes = [
+    {
+        buildCommand: 'npm exec --workspace=frontend -- astro build',
+        devCommand: 'npm exec --workspace=frontend -- astro dev --port ${PORT}',
+        installCommand: 'npm create cloudflare@latest -- frontend --framework=astro --deploy=false --git=false -- --no-git --yes --skip-houston --typescript strict',
+        mainPackage: 'astro',
         name: 'Astro',
         slug: 'astro',
     },
+    {
+        buildCommand: 'npm exec --workspace=frontend -- ng build',
+        devCommand: 'npm exec --workspace=frontend -- ng serve --port ${PORT}',
+        installCommand: 'npm create cloudflare@latest -- frontend --framework=angular --deploy=false --git=false -- --style=sass --zoneless --ai-config=none',
+        mainPackage: '@angular/core',
+        name: 'Angular',
+        slug: 'angular',
+    },
+    {
+        devCommand: 'npm exec --workspace=frontend -- wrangler dev --port ${PORT}',
+        installCommand: 'npm create cloudflare@latest -- frontend --framework=hono  --deploy=false --git=false',
+        mainPackage: 'hono',
+        name: 'Hono',
+        slug: 'hono',
+    },
+    {
+        buildCommand: 'npm exec --workspace=frontend -- nuxt build',
+        devCommand: 'npm exec --workspace=frontend -- nuxt dev --port ${PORT}',
+        installCommand: 'npm create cloudflare@latest -- frontend --framework=nuxt --deploy=false --git=false -- --no-modules -f',
+        mainPackage: 'nuxt',
+        name: 'Nuxt',
+        slug: 'nuxt',
+    },
+    {
+        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 -- 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',
+        name: 'Next.js',
+        slug: 'nextjs',
+    },
 ];
-const frontendProjectConfigExtensions = ['.mjs', '.js', '.ts', '.cjs'];
+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;
 }
+function hasWorkspaceStructure(appPath) {
+    // Check if root package.json has workspaces field including 'frontend'
+    const rootPkgPath = path.join(appPath, 'package.json');
+    if (!filePathExists(rootPkgPath)) {
+        return false;
+    }
+    try {
+        const content = fs.readFileSync(rootPkgPath, 'utf8');
+        const pkg = JSON.parse(content);
+        return Array.isArray(pkg.workspaces) && pkg.workspaces.includes('frontend');
+    }
+    catch {
+        return false;
+    }
+}
 export function getFrontendProjectType(appPath) {
-    for (const projectType of FrontendProjectTypes) {
-        for (const extension of frontendProjectConfigExtensions) {
-            const configFile = path.join(appPath, 'frontend', `${projectType.configFileName}${extension}`);
-            if (filePathExists(configFile)) {
-                return projectType;
+    // Detect workspace structure and select appropriate config
+    const hasWorkspace = hasWorkspaceStructure(appPath);
+    const projectTypes = hasWorkspace
+        ? FrontendProjectTypes
+        : LegacyFrontendProjectTypes;
+    // Try frontend/package.json first (new workspace structure), then root package.json (old structure)
+    const pkgPaths = [
+        path.join(appPath, 'frontend', 'package.json'),
+        path.join(appPath, 'package.json'),
+    ];
+    for (const pkgPath of pkgPaths) {
+        if (!filePathExists(pkgPath)) {
+            continue;
+        }
+        try {
+            const content = fs.readFileSync(pkgPath, 'utf8');
+            const pkg = JSON.parse(content);
+            for (const projectType of projectTypes) {
+                if (pkg.dependencies?.[projectType.mainPackage] ||
+                    pkg.devDependencies?.[projectType.mainPackage]) {
+                    // Create a copy to avoid mutating the original
+                    const detectedType = { ...projectType };
+                    // If buildCommand not explicitly set in framework definition, detect it
+                    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;
+                }
             }
         }
+        catch {
+            // Ignore JSON parse errors, try next path
+            continue;
+        }
     }
+    return undefined;
 }
 export function getConfigTypeFromPath(path) {
     for (const type in ConfigPaths) {

package/dist/lib/bundle.js

@@ -11,7 +11,8 @@ export async function bundleFunction(filePath) {
             metafile: true,
             platform: 'node',
             target: ['chrome58'],
-            write: false, // Do not write the output to a file
+            write: false,
+            logLevel: 'silent', // Do not output compile errors
         });
         const { metafile: { inputs }, outputFiles: [{ text: origCode }], } = buildResult;
         // TODO: make a separate method to get dependencies for watch command

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,8 +1,6 @@
 export declare const API_BASE_URL: any;
-export declare const ADMIN_API_BASE_URL: any;
-export declare const LOGIN_HOST: any;
-export declare const APP_PAGES_HOST: any;
-export declare const STOREFRONT_FRONTEND_HOST: 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

@@ -4,15 +4,17 @@ import { env } from './config.js';
 // url for backend api calls
 export const API_BASE_URL = env.get('API_BASE_URL') || defaultEnv.API_BASE_URL;
 // url for admin api calls
-export const ADMIN_API_BASE_URL = env.get('ADMIN_API_BASE_URL') || defaultEnv.ADMIN_API_BASE_URL;
+const ADMIN_API_BASE_URL = env.get('ADMIN_API_BASE_URL') || defaultEnv.ADMIN_API_BASE_URL;
 // url host for admin login
-export const LOGIN_HOST = env.get('LOGIN_HOST') || defaultEnv.LOGIN_HOST;
+const LOGIN_HOST = env.get('LOGIN_HOST') || defaultEnv.LOGIN_HOST;
 // url host for app frontend
-export const APP_PAGES_HOST = env.get('APP_PAGES_HOST') || defaultEnv.APP_PAGES_HOST;
+const APP_PAGES_HOST = env.get('APP_PAGES_HOST') || defaultEnv.APP_PAGES_HOST;
 // url host for storefront app frontend
-export const STOREFRONT_FRONTEND_HOST = env.get('STOREFRONT_FRONTEND_HOST') ||
+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/proxy.d.ts

@@ -0,0 +1 @@
+export declare function getProxyUrl(port: number): Promise<string>;

package/dist/lib/proxy.js

@@ -1 +1,29 @@
-"use strict";
+import localtunnel from 'localtunnel';
+import ngrok from 'ngrok';
+import { LOCAL_PROXY_PROVIDER } from './constants.js';
+export async function getProxyUrl(port) {
+    const provider = LOCAL_PROXY_PROVIDER || 'localtunnel';
+    try {
+        switch (provider) {
+            case 'local': {
+                return `http://localhost:${port}`;
+            }
+            case 'ngrok': {
+                return await ngrok.connect({
+                    addr: port,
+                    region: 'us', // TODO: make it configurable
+                });
+            }
+            // eslint-disable-next-line unicorn/no-useless-switch-case
+            case 'localtunnel':
+            default: {
+                const tunnel = await localtunnel({ port });
+                return tunnel.url;
+            }
+        }
+    }
+    catch (error) {
+        console.log(error);
+        throw new Error(`Unable to start tunnel on port ${port} (${provider}): ${error.message}`);
+    }
+}

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/swell-function-wrapper.d.ts

@@ -48,10 +48,28 @@ declare function executeModuleHandler(req: SwellRequest, context: Event): Promis
  * @returns {boolean}
  */
 declare function isOrdinaryObject(val: any): boolean;
-declare const origialConsoleLog: {
-    (...data: any[]): void;
-    (message?: any, ...optionalParams: any[]): void;
-};
+declare namespace originalConsole {
+    let log: {
+        (...data: any[]): void;
+        (message?: any, ...optionalParams: any[]): void;
+    };
+    let info: {
+        (...data: any[]): void;
+        (message?: any, ...optionalParams: any[]): void;
+    };
+    let debug: {
+        (...data: any[]): void;
+        (message?: any, ...optionalParams: any[]): void;
+    };
+    let warn: {
+        (...data: any[]): void;
+        (message?: any, ...optionalParams: any[]): void;
+    };
+    let error: {
+        (...data: any[]): void;
+        (message?: any, ...optionalParams: any[]): void;
+    };
+}
 /**
  * Class representing a Swell request.
  */
@@ -68,6 +86,7 @@ declare class SwellRequest {
     logParams: any;
     apiHost: any;
     id: any;
+    isLocalDev: boolean;
     swell: SwellAPI;
     body: {};
     query: {};

package/dist/lib/swell-function-wrapper.js

@@ -1,5 +1,11 @@
 "use strict";
-const origialConsoleLog = console.log;
+const originalConsole = {
+    log: console.log,
+    info: console.info,
+    debug: console.debug,
+    warn: console.warn,
+    error: console.error,
+};
 addEventListener('fetch', (event) => {
     event.respondWith(request(event.request, event.env, event));
 });
@@ -93,6 +99,8 @@ class SwellRequest {
         this.logParams = this.parseJson(req.headers.get('Swell-Request-Log'));
         this.apiHost = req.headers.get('Swell-API-Host') || 'https://api.schema.io';
         this.id = req.headers.get('Swell-Request-ID') || this.logParams?.req_id;
+        // Check if the request is from a local development environment
+        this.isLocalDev = req.headers.get('Swell-Local-Dev') === 'true';
         // Swell client
         this.swell = new SwellAPI(this, context);
         // URL of the original request
@@ -142,7 +150,7 @@ class SwellRequest {
         }
     }
     log(level, ...line) {
-        origialConsoleLog(...line);
+        originalConsole[level]?.(...line);
         this._logs.push({
             date: Date.now(),
             line: line.map((l) => (l instanceof Error ? l.stack : JSON.stringify(l))),
@@ -150,7 +158,7 @@ class SwellRequest {
         });
     }
     getIngestableLogs(response) {
-        if (!this.logParams) {
+        if (!this.logParams || this.isLocalDev) {
             return;
         }
         if (this.logParams.$start) {
@@ -384,4 +392,3 @@ function isOrdinaryObject(val) {
         val !== null &&
         Object.getPrototypeOf(val) === Object.prototype);
 }
-;

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 {};