@swell/cli 2.3.4 → 2.4.1

package/dist/lib/apps/index.js

@@ -3,6 +3,7 @@ import { pluralize, titleize } from 'inflection';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { toAppId } from '../create/index.js';
+import { detectPackageManager, transformCommand } from '../package-manager.js';
 import { AppConfig } from './app-config.js';
 export { AppConfig, FunctionProcessingError, IgnoringFileError, } from './app-config.js';
 export { allBaseFilesInDir, allConfigDirsPaths, allConfigFilesInDir, allConfigFilesPaths, allConfigFilesPathsByType, getAllConfigPaths, globAllFilesByPath, isPathDirectory, } from './paths.js';
@@ -113,54 +114,42 @@ export var ConfigInputFields;
     ConfigInputFields["VALUES"] = "values";
     ConfigInputFields["VERSION"] = "version";
 })(ConfigInputFields || (ConfigInputFields = {}));
-// Legacy apps (pre-workspace) - Astro only (Proxima, Sunrise)
-// Uses direct commands without workspace prefix
-const LegacyFrontendProjectTypes = [
+// Frontend project types - all use direct commands run from frontend/ directory
+export const FrontendProjectTypes = [
     {
         buildCommand: 'npx astro build',
         devCommand: 'npx astro dev --port ${PORT}',
-        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}',
+        buildCommand: 'npx ng build',
+        devCommand: 'npx 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}',
+        devCommand: 'npx 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}',
+        buildCommand: 'npx nuxt build',
+        devCommand: 'npx 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}',
+        buildCommand: 'npx opennextjs-cloudflare build',
+        devCommand: 'npx 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',
@@ -183,28 +172,8 @@ export function getFrontendProjectValidValues(withNone = true, withLegacy = true
 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) {
-    // 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)
+    // Try frontend/package.json first (workspace structure), then root package.json (legacy)
     const pkgPaths = [
         path.join(appPath, 'frontend', 'package.json'),
         path.join(appPath, 'package.json'),
@@ -216,15 +185,16 @@ export function getFrontendProjectType(appPath) {
         try {
             const content = fs.readFileSync(pkgPath, 'utf8');
             const pkg = JSON.parse(content);
-            for (const projectType of projectTypes) {
+            for (const projectType of FrontendProjectTypes) {
                 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' : '';
+                    // Check if package.json has a "build" script, if not set to empty string (no build needed)
+                    detectedType.buildCommand ||= pkg.scripts?.build
+                        ? 'npm run build'
+                        : '';
                     return detectedType;
                 }
             }
@@ -236,6 +206,20 @@ export function getFrontendProjectType(appPath) {
     }
     return undefined;
 }
+/**
+ * Get project commands transformed for the detected package manager.
+ * Detects the package manager from lock files in appPath and transforms
+ * npm-style commands to the equivalent for that package manager.
+ */
+export function getProjectCommands(appPath, projectType) {
+    const pm = detectPackageManager(appPath);
+    return {
+        buildCommand: projectType.buildCommand
+            ? transformCommand(projectType.buildCommand, pm)
+            : undefined,
+        devCommand: transformCommand(projectType.devCommand, pm),
+    };
+}
 export function getConfigTypeFromPath(path) {
     for (const type in AllConfigPaths) {
         if (AllConfigPaths[type] === path) {
@@ -377,3 +361,18 @@ export function batchAppFilesByType(configs) {
     // Add base files if config types are not specified
     return batches;
 }
+export function hasAppContext() {
+    return fs.existsSync('swell.json');
+}
+export async function getCurrentAppSlugId() {
+    if (!hasAppContext()) {
+        return;
+    }
+    try {
+        const appConfig = JSON.parse(await fs.promises.readFile('swell.json', 'utf8'));
+        return appConfig.id;
+    }
+    catch {
+        // noop
+    }
+}

package/dist/lib/constants.d.ts

@@ -2,6 +2,7 @@ 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 getFrontendApiBaseUrl(storeId: string): any;
 export declare function getLoginHost(storeId?: string): any;
 export declare function getAppFrontendHost(storeId: string, installedAppId: string): any;
 export declare function getStorefrontFrontendHost(storefrontSlug: string, branchId?: string): any;

package/dist/lib/constants.js

@@ -5,6 +5,8 @@ import { env } from './config.js';
 export const API_BASE_URL = env.get('API_BASE_URL') || defaultEnv.API_BASE_URL;
 // url for admin api calls
 const ADMIN_API_BASE_URL = env.get('ADMIN_API_BASE_URL') || defaultEnv.ADMIN_API_BASE_URL;
+// url for store api calls
+const FRONTEND_API_BASE_URL = env.get('FRONTEND_API_BASE_URL') || defaultEnv.FRONTEND_API_BASE_URL;
 // url host for admin login
 const LOGIN_HOST = env.get('LOGIN_HOST') || defaultEnv.LOGIN_HOST;
 // url host for app frontend
@@ -19,6 +21,9 @@ export const SCHEMAS_BASE_URL = env.get('SCHEMAS_BASE_URL') || defaultEnv.SCHEMA
 export function getAdminApiBaseUrl(storeId) {
     return ADMIN_API_BASE_URL.replace('${STORE_ID}', storeId);
 }
+export function getFrontendApiBaseUrl(storeId) {
+    return FRONTEND_API_BASE_URL.replace('${STORE_ID}', storeId);
+}
 export function getLoginHost(storeId) {
     return LOGIN_HOST.replace('${STORE_ID}', storeId || 'login');
 }

package/dist/lib/create/tests.js

@@ -4,7 +4,7 @@ import { filePathExists, writeFile } from '../apps/index.js';
 import { envDtsTemplate, integrationTestTemplate, mockRequestTemplate, setupGlobalsTemplate, swellClientTemplate, tsconfigTemplate, unitTestTemplate, vitestConfigTemplate, } from './tests/templates/index.js';
 const TEST_DEV_DEPENDENCIES = {
     '@cloudflare/vitest-pool-workers': 'latest',
-    vitest: 'latest',
+    vitest: '3.2.x',
     '@swell/app-types': 'latest',
 };
 async function writeTextFile(filePath, contents, overwrite) {

package/dist/lib/package-manager.d.ts

@@ -0,0 +1,86 @@
+export type PackageManager = 'npm' | 'yarn' | 'pnpm' | 'bun';
+export interface PackageManagerCommands {
+    /** Install command (e.g., 'npm install') */
+    install: string;
+    /** Run a script (e.g., 'npm run build' for script 'build') */
+    run: (script: string) => string;
+    /** Execute command in workspace (e.g., 'npm exec --workspace=frontend -- astro build') */
+    workspaceExec: (workspace: string, command: string) => string;
+    /** Run a script in a workspace (e.g., 'npm run build --workspace=frontend') */
+    workspaceRun: (workspace: string, script: string) => string;
+    /** Execute a binary (e.g., 'npx wrangler') */
+    exec: (command: string) => string;
+}
+/**
+ * Find lock file in directory or parent directories
+ * @returns Lock file name and path, or null if not found
+ */
+export declare function findLockFile(directory: string): {
+    name: string;
+    packageManager: PackageManager;
+    path: string;
+} | null;
+/**
+ * Detect package manager from lock file in directory tree
+ * @returns Detected package manager, defaults to 'npm' if no lock file found
+ */
+export declare function detectPackageManager(directory: string): PackageManager;
+/**
+ * Get command templates for a package manager
+ */
+export declare function getPackageManagerCommands(pm: PackageManager): PackageManagerCommands;
+/**
+ * Detect package manager and get its commands
+ */
+export declare function getPackageManager(directory: string): {
+    commands: PackageManagerCommands;
+    lockFile: {
+        name: string;
+        path: string;
+    } | null;
+    name: PackageManager;
+};
+/**
+ * Transform an npm command to the equivalent for the detected package manager
+ * Handles common patterns:
+ * - 'npm run X' -> 'yarn run X' / 'pnpm run X' / 'bun run X'
+ * - 'npm run X --workspace=Y' -> 'yarn workspace Y run X' / 'pnpm --filter Y run X' / 'bun run --filter Y X'
+ * - 'npm exec --workspace=X -- Y' -> equivalent workspace command
+ * - 'npx X' -> 'yarn dlx X' / 'pnpm dlx X' / 'bunx X'
+ */
+export declare function transformCommand(command: string, pm: PackageManager): string;
+/**
+ * Transform npm create commands to the equivalent for another package manager.
+ * Handles 'npm create X@version -- args' -> 'pm create X@version args'
+ * Also transforms --use-npm to --use-{pm} for CLIs that support it (e.g., Next.js)
+ * For yarn, removes @latest suffix since yarn classic (v1) may not handle it properly.
+ *
+ * @example
+ * transformCreateCommand('npm create cloudflare@latest -- frontend --framework=hono', 'bun')
+ * // Returns: 'bun create cloudflare@latest frontend --framework=hono'
+ *
+ * @example
+ * transformCreateCommand('npm create cloudflare@latest -- frontend --framework=next --use-npm', 'pnpm')
+ * // Returns: 'pnpm create cloudflare@latest frontend --framework=next --use-pnpm'
+ *
+ * @example
+ * transformCreateCommand('npm create cloudflare@latest -- frontend --framework=astro', 'yarn')
+ * // Returns: 'yarn create cloudflare -- frontend --framework=astro'
+ */
+export declare function transformCreateCommand(command: string, pm: PackageManager): string;
+/**
+ * Get spawn arguments for executing a package binary.
+ * Returns the program and any prefix args needed before the command args.
+ * Useful for node's spawn() which needs program and args separately.
+ *
+ * Uses npx for most package managers (universally available via Node.js).
+ * Uses bunx for bun projects (performance benefit from Bun runtime).
+ *
+ * @example
+ * const { program, prefixArgs } = getExecSpawnArgs('npm');
+ * spawn(program, [...prefixArgs, 'wrangler', 'dev', '--port=3000']);
+ */
+export declare function getExecSpawnArgs(pm: PackageManager): {
+    prefixArgs: string[];
+    program: string;
+};

package/dist/lib/package-manager.js

@@ -0,0 +1,186 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+/** Lock file to package manager mapping (priority order: bun > pnpm > yarn > npm) */
+const LOCK_FILES = [
+    ['bun.lockb', 'bun'],
+    ['bun.lock', 'bun'],
+    ['pnpm-lock.yaml', 'pnpm'],
+    ['yarn.lock', 'yarn'],
+    ['package-lock.json', 'npm'],
+];
+/** Command templates for each package manager */
+const COMMANDS = {
+    npm: {
+        install: 'npm install',
+        run: (script) => `npm run ${script}`,
+        workspaceExec: (workspace, command) => `npm exec --workspace=${workspace} -- ${command}`,
+        workspaceRun: (workspace, script) => `npm run ${script} --workspace=${workspace}`,
+        exec: (command) => `npx ${command}`,
+    },
+    yarn: {
+        install: 'yarn install',
+        run: (script) => `yarn run ${script}`,
+        workspaceExec: (workspace, command) => `yarn workspace ${workspace} ${command}`,
+        workspaceRun: (workspace, script) => `yarn workspace ${workspace} run ${script}`,
+        exec: (command) => `yarn dlx ${command}`,
+    },
+    pnpm: {
+        install: 'pnpm install',
+        run: (script) => `pnpm run ${script}`,
+        workspaceExec: (workspace, command) => `pnpm --filter ${workspace} exec ${command}`,
+        workspaceRun: (workspace, script) => `pnpm --filter ${workspace} run ${script}`,
+        exec: (command) => `pnpm dlx ${command}`,
+    },
+    bun: {
+        install: 'bun install',
+        run: (script) => `bun run ${script}`,
+        // Use --cwd for executing binaries in a workspace (--filter is for scripts only)
+        workspaceExec: (workspace, command) => `bun --cwd ${workspace} x ${command}`,
+        workspaceRun: (workspace, script) => `bun run --filter ${workspace} ${script}`,
+        exec: (command) => `bunx ${command}`,
+    },
+};
+/**
+ * Find lock file in directory or parent directories
+ * @returns Lock file name and path, or null if not found
+ */
+export function findLockFile(directory) {
+    let currentDir = path.resolve(directory);
+    const { root } = path.parse(currentDir);
+    while (currentDir !== root) {
+        for (const [lockFile, pm] of LOCK_FILES) {
+            const lockPath = path.join(currentDir, lockFile);
+            if (fs.existsSync(lockPath)) {
+                return { name: lockFile, packageManager: pm, path: lockPath };
+            }
+        }
+        currentDir = path.dirname(currentDir);
+    }
+    return null;
+}
+/**
+ * Detect package manager from lock file in directory tree
+ * @returns Detected package manager, defaults to 'npm' if no lock file found
+ */
+export function detectPackageManager(directory) {
+    const lockFile = findLockFile(directory);
+    return lockFile?.packageManager ?? 'npm';
+}
+/**
+ * Get command templates for a package manager
+ */
+export function getPackageManagerCommands(pm) {
+    return COMMANDS[pm];
+}
+/**
+ * Detect package manager and get its commands
+ */
+export function getPackageManager(directory) {
+    const lockFile = findLockFile(directory);
+    const name = lockFile?.packageManager ?? 'npm';
+    return {
+        commands: COMMANDS[name],
+        lockFile: lockFile ? { name: lockFile.name, path: lockFile.path } : null,
+        name,
+    };
+}
+/**
+ * Transform an npm command to the equivalent for the detected package manager
+ * Handles common patterns:
+ * - 'npm run X' -> 'yarn run X' / 'pnpm run X' / 'bun run X'
+ * - 'npm run X --workspace=Y' -> 'yarn workspace Y run X' / 'pnpm --filter Y run X' / 'bun run --filter Y X'
+ * - 'npm exec --workspace=X -- Y' -> equivalent workspace command
+ * - 'npx X' -> 'yarn dlx X' / 'pnpm dlx X' / 'bunx X'
+ */
+export function transformCommand(command, pm) {
+    if (pm === 'npm') {
+        return command;
+    }
+    const commands = COMMANDS[pm];
+    // Transform 'npm exec --workspace=X -- Y'
+    const workspaceMatch = command.match(/^npm exec --workspace=(\S+) -- (.+)$/);
+    if (workspaceMatch) {
+        return commands.workspaceExec(workspaceMatch[1], workspaceMatch[2]);
+    }
+    // Transform 'npm run X --workspace=Y'
+    const workspaceRunMatch = command.match(/^npm run (\S+) --workspace=(\S+)$/);
+    if (workspaceRunMatch) {
+        return commands.workspaceRun(workspaceRunMatch[2], workspaceRunMatch[1]);
+    }
+    // Transform 'npm run X' (with optional flags)
+    const runMatch = command.match(/^npm run (\S.*)$/);
+    if (runMatch) {
+        return commands.run(runMatch[1]);
+    }
+    // Transform 'npx X' to 'bunx X' for bun (performance benefit from Bun runtime)
+    // For other package managers, keep npx as-is (universally available via Node.js)
+    if (pm === 'bun') {
+        const npxMatch = command.match(/^npx (.+)$/);
+        if (npxMatch) {
+            return `bunx ${npxMatch[1]}`;
+        }
+    }
+    // Warn if command looks like npm but wasn't transformed
+    if (command.startsWith('npm ')) {
+        console.warn(`Warning: Command "${command}" was not transformed for ${pm}.`);
+    }
+    return command;
+}
+/**
+ * Transform npm create commands to the equivalent for another package manager.
+ * Handles 'npm create X@version -- args' -> 'pm create X@version args'
+ * Also transforms --use-npm to --use-{pm} for CLIs that support it (e.g., Next.js)
+ * For yarn, removes @latest suffix since yarn classic (v1) may not handle it properly.
+ *
+ * @example
+ * transformCreateCommand('npm create cloudflare@latest -- frontend --framework=hono', 'bun')
+ * // Returns: 'bun create cloudflare@latest frontend --framework=hono'
+ *
+ * @example
+ * transformCreateCommand('npm create cloudflare@latest -- frontend --framework=next --use-npm', 'pnpm')
+ * // Returns: 'pnpm create cloudflare@latest frontend --framework=next --use-pnpm'
+ *
+ * @example
+ * transformCreateCommand('npm create cloudflare@latest -- frontend --framework=astro', 'yarn')
+ * // Returns: 'yarn create cloudflare -- frontend --framework=astro'
+ */
+export function transformCreateCommand(command, pm) {
+    if (pm === 'npm') {
+        return command;
+    }
+    // Match 'npm create X@version -- args' or 'npm create X -- args'
+    const createMatch = command.match(/^npm create (\S+) -- (.+)$/);
+    if (createMatch) {
+        let [, packageWithVersion, args] = createMatch;
+        // Replace --use-npm with --use-{pm} for Next.js and similar CLIs
+        const transformedArgs = args.replace(/--use-npm\b/, `--use-${pm}`);
+        // For yarn classic (v1), remove @latest since yarn create fetches latest by default
+        // and may not properly handle version specifiers. Also add -- separator for args.
+        if (pm === 'yarn') {
+            packageWithVersion = packageWithVersion.replace(/@latest$/, '');
+            return `yarn create ${packageWithVersion} -- ${transformedArgs}`;
+        }
+        return `${pm} create ${packageWithVersion} ${transformedArgs}`;
+    }
+    return command;
+}
+/**
+ * Get spawn arguments for executing a package binary.
+ * Returns the program and any prefix args needed before the command args.
+ * Useful for node's spawn() which needs program and args separately.
+ *
+ * Uses npx for most package managers (universally available via Node.js).
+ * Uses bunx for bun projects (performance benefit from Bun runtime).
+ *
+ * @example
+ * const { program, prefixArgs } = getExecSpawnArgs('npm');
+ * spawn(program, [...prefixArgs, 'wrangler', 'dev', '--port=3000']);
+ */
+export function getExecSpawnArgs(pm) {
+    // Use bunx for bun (performance benefit), npx for everything else
+    // npx is universally available via Node.js and avoids yarn dlx v1/v2 issues
+    if (pm === 'bun') {
+        return { prefixArgs: [], program: 'bunx' };
+    }
+    return { prefixArgs: [], program: 'npx' };
+}

package/dist/push-app-command.js

@@ -6,10 +6,11 @@ import * as path from 'node:path';
 import Stream from 'node:stream';
 import ora from 'ora';
 import { default as swellConfig } from './lib/app-config.js';
-import { ConfigType, getFrontendProjectValidValues, allConfigFilesInDir, appConfigFromFile, filePathExists, filePathExistsAsync, findAppConfig, getAppSlugId, getConfigTypeFromPath, getConfigTypeKeyFromValue, getFrontendProjectType, globAllFilesByPath, hashString, isPathDirectory, } from './lib/apps/index.js';
+import { ConfigType, getFrontendProjectValidValues, allConfigFilesInDir, appConfigFromFile, filePathExists, filePathExistsAsync, findAppConfig, getAppSlugId, getConfigTypeFromPath, getConfigTypeKeyFromValue, getFrontendProjectType, getProjectCommands, 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 { detectPackageManager, transformCommand, } from './lib/package-manager.js';
 import { getProxyUrl } from './lib/proxy.js';
 import { selectEnvironmentId } from './lib/stores.js';
 import style from './lib/style.js';
@@ -109,12 +110,14 @@ export class PushAppCommand extends RemoteAppCommand {
             this.showFrontendMigrationError();
             return; // unreachable but helps TypeScript narrow the type
         }
-        if (!projectType.buildCommand) {
+        // Get commands transformed for the detected package manager
+        const { buildCommand } = getProjectCommands(this.appPath, projectType);
+        if (!buildCommand) {
             // No build command needed for this framework
             return;
         }
         this.log(`Building ${projectType.name} frontend...\n`);
-        await this.execFrontend(projectType.buildCommand);
+        await this.execFrontend(buildCommand);
     }
     async chooseAppToPull(query) {
         const typeLabelPlural = this.appType === 'theme' ? 'themes' : 'apps';
@@ -332,7 +335,8 @@ export class PushAppCommand extends RemoteAppCommand {
         }
     }
     async execFrontend(command, onOutput) {
-        return this.exec(command, this.frontendPath, onOutput);
+        // Run from frontend directory where wrangler.toml and framework configs live
+        return this.exec(command, this.frontendPath || path.join(this.appPath, 'frontend'), onOutput);
     }
     async getAllAppStorefronts(params) {
         const query = Object.entries(params || {})
@@ -794,12 +798,15 @@ export class PushAppCommand extends RemoteAppCommand {
         let pagesProjectError = false;
         let outputBuffer = '';
         this.log(`\nDeploying to Cloudflare...\n`);
+        // Get the wrangler deploy command for the detected package manager
+        const pm = detectPackageManager(this.appPath);
+        const deployCommand = transformCommand('npx wrangler deploy', pm);
         try {
-            await this.execFrontend(`npx wrangler deploy`, (string) => {
+            await this.execFrontend(deployCommand, (string) => {
                 // Accumulate output for URL parsing after command completes
                 outputBuffer += string;
                 // Suppress workers.dev URL from output (users should use swell domain)
-                if (string.match(/^\s*https:\/\/\S+\.workers\.dev\s*$/m)) {
+                if (/^\s*https:\/\/\S+\.workers\.dev\s*$/m.test(string)) {
                     return false;
                 }
                 // Check for Pages project error

package/dist/swell-api-command.js

@@ -29,10 +29,14 @@ export class SwellApiCommand extends SwellCommand {
         const parsedInput = await super.parse(options, argv);
         const { args, flags } = parsedInput;
         const { path: requestPath } = args;
-        const { live, body } = flags;
+        const { live, api, body } = flags;
+        const isFrontendAPI = api === 'frontend';
         if (!live) {
             await this.api.setEnv('test');
         }
+        if (isFrontendAPI) {
+            await this.api.setPublicKey();
+        }
         if (!requestPath.startsWith('/')) {
             throw new Error('Path must start with a forward slash (/)');
         }
@@ -53,7 +57,9 @@ export class SwellApiCommand extends SwellCommand {
             const queryParams = this.parseQueryString(queryString);
             return this.buildFunctionCallRequest(parsedInput, functionId, processedBody, queryParams);
         }
-        const paths = { adminPath: `/data${requestPath}` };
+        const paths = isFrontendAPI
+            ? { frontendPath: requestPath }
+            : { adminPath: `/data${requestPath}` };
         return {
             ...parsedInput,
             paths,