@swell/cli 2.0.19 → 2.1.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,11 +117,10 @@ 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;
 }

package/dist/lib/apps/index.js

@@ -94,39 +94,122 @@ 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',
     },
 ];
-const frontendProjectConfigExtensions = ['.mjs', '.js', '.ts', '.cjs'];
+// 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',
+    },
+];
 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, 'utf-8');
+        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, 'utf-8');
+            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
+                    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 = '';
+                        }
+                    }
+                    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/constants.d.ts

@@ -1,8 +1,5 @@
 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 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,16 @@ 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;
 // helpers to get constants with replacements
 export function getAdminApiBaseUrl(storeId) {
     return ADMIN_API_BASE_URL.replace('${STORE_ID}', storeId);

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/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/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>;
+    execFrontend(command: string, onOutput?: (string: string) => any | false): Promise<void>;
+    exec(command: string, cwd?: string, onOutput?: (string: string) => any | false): Promise<void>;
     getAllAppStorefronts(params?: {
         type?: string;
     }): Promise<any>;
@@ -79,9 +81,11 @@ export declare abstract class PushAppCommand extends RemoteAppCommand {
     updateFrontendDeployment(currentStore: string, projectType: FrontendProjectType, deploymentUrl: string, deploymentHash: string): Promise<void>;
     watchForChanges({ logChanges, onChange, syncAll, }?: {
         logChanges?: boolean;
-        onChange?: () => void;
+        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>;
     private confirmRemoveInstalledApp;
 }