@swell/cli 2.0.20 → 2.1.0

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

package/dist/push-app-command.js

@@ -3,6 +3,7 @@ import { $ } from 'execa';
 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';
@@ -12,8 +13,10 @@ import { default as localConfig } from './lib/config.js';
 import { toAppId } from './lib/create/index.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;
 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,12 @@ export class PushAppCommand extends RemoteAppCommand {
             return true;
         }
     }
-    async exec(command, onOutput) {
+    async execFrontend(command, onOutput) {
+        return this.exec(command, this.frontendPath, onOutput);
+    }
+    async exec(command, cwd, onOutput) {
         const $$ = $({
-            cwd: this.frontendPath,
+            cwd: cwd || this.appPath,
             shell: true,
             stderr: onOutput ? 'pipe' : 'inherit',
             stdin: 'inherit',
@@ -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: ${FrontendProjectTypes.map((type) => type.slug).join(', ')}.`);
         }
         return projectType;
     }
@@ -670,12 +705,19 @@ export class PushAppCommand extends RemoteAppCommand {
         this.watchingChangeQueue.clear();
         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 (_err) {
+                //noop
+            }
         }
         // refetch app to get updated configs
         this.app = await this.getAppWithConfig(this.app.id);
@@ -723,19 +765,48 @@ 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) {
         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 +817,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;