@swell/cli 2.3.4 → 2.4.1

package/dist/create-app-command.js

@@ -9,9 +9,39 @@ import { promisify } from 'node:util';
 import ora from 'ora';
 import Api from './lib/api.js';
 import { FrontendProjectTypes, getFrontendProjectValidValues, getAllConfigPaths, getFrontendProjectSlugs, writeFile, writeJsonFile, } from './lib/apps/index.js';
+import { getPackageManagerCommands, transformCreateCommand, } from './lib/package-manager.js';
 import style from './lib/style.js';
 import { SwellCommand } from './swell-command.js';
 const execAsync = promisify(exec);
+/** Allowed hosts for tunnel providers used in local development */
+const TUNNEL_ALLOWED_HOSTS = ['.ngrok.app', '.loca.lt', '.trycloudflare.com'];
+/**
+ * Find the closing brace position for a config function call (e.g., defineConfig, defineNuxtConfig).
+ * Uses brace counting to find the matching `}` for the opening `{`.
+ * @returns Position of the closing `}`, or -1 if not found
+ */
+function findConfigClosingBrace(content, functionName) {
+    const pattern = new RegExp(`${functionName}\\s*\\(\\s*\\{`);
+    const match = content.match(pattern);
+    if (!match || match.index === undefined) {
+        return -1;
+    }
+    const startPos = match.index + match[0].length;
+    let depth = 1;
+    for (let i = startPos; i < content.length && depth > 0; i++) {
+        const char = content[i];
+        if (char === '{') {
+            depth++;
+        }
+        else if (char === '}') {
+            depth--;
+            if (depth === 0) {
+                return i;
+            }
+        }
+    }
+    return -1;
+}
 export class CreateAppCommand extends SwellCommand {
     // Command name used in error message examples; override in subclasses
     commandExample = 'swell create app';
@@ -76,51 +106,24 @@ export class CreateAppCommand extends SwellCommand {
         if (project.architect.serve.options.allowedHosts) {
             return;
         }
-        project.architect.serve.options.allowedHosts = ['.ngrok.app', '.loca.lt'];
+        project.architect.serve.options.allowedHosts = TUNNEL_ALLOWED_HOSTS;
         await fs.writeFile(angularJsonPath, JSON.stringify(config, null, 2), 'utf8');
     }
     async addAllowedHostsToAstro(configPath) {
-        const astroConfigPath = path.join(configPath, 'frontend', 'astro.config.mjs');
-        let content;
-        try {
-            content = await fs.readFile(astroConfigPath, 'utf8');
-        }
-        catch {
-            return;
-        }
-        if (content.includes('allowedHosts')) {
-            return;
-        }
-        const lines = content.split('\n');
-        let insertIndex = -1;
-        for (const [i, line] of lines.entries()) {
-            if (line.includes('defineConfig({')) {
-                insertIndex = i + 1;
-                break;
-            }
-        }
-        if (insertIndex === -1) {
-            return;
-        }
-        // Detect indentation from next line or use default
-        const nextLine = lines[insertIndex];
-        const indentMatch = nextLine?.match(/^(\s+)/);
-        const baseIndent = indentMatch ? indentMatch[1] : '  ';
-        const viteConfig = [
-            `${baseIndent}vite: {`,
-            `${baseIndent}  server: {`,
-            `${baseIndent}    allowedHosts: ['.ngrok.app', '.loca.lt'],`,
-            `${baseIndent}  },`,
-            `${baseIndent}},`,
-        ];
-        lines.splice(insertIndex, 0, ...viteConfig);
-        await fs.writeFile(astroConfigPath, lines.join('\n'), 'utf8');
+        return this.addViteAllowedHosts(configPath, 'astro.config.mjs', 'defineConfig');
     }
     async addAllowedHostsToNuxt(configPath) {
-        const nuxtConfigPath = path.join(configPath, 'frontend', 'nuxt.config.ts');
+        return this.addViteAllowedHosts(configPath, 'nuxt.config.ts', 'defineNuxtConfig');
+    }
+    /**
+     * Add vite allowedHosts configuration to a framework config file.
+     * Supports config files that use a defineX({}) pattern (Astro, Nuxt, etc.)
+     */
+    async addViteAllowedHosts(configPath, configFile, functionName) {
+        const configFilePath = path.join(configPath, 'frontend', configFile);
         let content;
         try {
-            content = await fs.readFile(nuxtConfigPath, 'utf8');
+            content = await fs.readFile(configFilePath, 'utf8');
         }
         catch {
             return;
@@ -128,29 +131,30 @@ export class CreateAppCommand extends SwellCommand {
         if (content.includes('allowedHosts')) {
             return;
         }
-        const lines = content.split('\n');
-        let insertIndex = -1;
-        for (const [i, line] of lines.entries()) {
-            if (line.includes('defineNuxtConfig({')) {
-                insertIndex = i + 1;
-                break;
-            }
+        const viteConfig = `  vite: {
+    server: {
+      allowedHosts: ${JSON.stringify(TUNNEL_ALLOWED_HOSTS)},
+    },
+  },`;
+        // Handle empty config: functionName({})
+        const emptyConfig = `${functionName}({})`;
+        if (content.includes(emptyConfig)) {
+            content = content.replace(emptyConfig, `${functionName}({\n${viteConfig}\n})`);
+            await fs.writeFile(configFilePath, content, 'utf8');
+            return;
         }
-        if (insertIndex === -1) {
+        // Find the closing brace of the config function using brace counting
+        const closingPos = findConfigClosingBrace(content, functionName);
+        if (closingPos === -1) {
             return;
         }
-        const nextLine = lines[insertIndex];
-        const indentMatch = nextLine?.match(/^(\s+)/);
-        const baseIndent = indentMatch ? indentMatch[1] : '  ';
-        const viteConfig = [
-            `${baseIndent}vite: {`,
-            `${baseIndent}  server: {`,
-            `${baseIndent}    allowedHosts: ['.ngrok.app', '.loca.lt'],`,
-            `${baseIndent}  },`,
-            `${baseIndent}},`,
-        ];
-        lines.splice(insertIndex, 0, ...viteConfig);
-        await fs.writeFile(nuxtConfigPath, lines.join('\n'), 'utf8');
+        const before = content.slice(0, closingPos);
+        const after = content.slice(closingPos);
+        // Ensure proper comma before vite config
+        const needsComma = before.trimEnd().slice(-1) !== ',';
+        const separator = needsComma ? ',\n' : '\n';
+        content = before.trimEnd() + separator + viteConfig + '\n' + after;
+        await fs.writeFile(configFilePath, content, 'utf8');
     }
     async createAppConfigFolders(swellConfig) {
         for (const type of getAllConfigPaths(swellConfig.get('type'))) {
@@ -188,19 +192,63 @@ export class CreateAppCommand extends SwellCommand {
             }));
         if (frameworkType && frameworkType !== 'none') {
             const projectType = this.getProjectType(frameworkType);
+            // Determine package manager - 'none' is not valid for frontend scaffolding
+            let pkg = (flags.pkg || 'npm');
+            if (flags.pkg === 'none') {
+                this.log(`\n${style.dim('Note: --pkg none is not available for frontend scaffolding, using npm.')}`);
+                pkg = 'npm';
+                // Ensure root package.json exists (skipped when --pkg none)
+                const rootPkgPath = path.join(configPath, 'package.json');
+                try {
+                    await fs.access(rootPkgPath);
+                }
+                catch {
+                    // Root package.json doesn't exist, create it
+                    await this.setupPackage(swellConfig.get('id'), swellConfig, pkg);
+                }
+            }
             this.log();
+            // Check for placeholder frontend/package.json and remove it before C3 scaffolding
+            const frontendPath = path.join(configPath, 'frontend');
+            const frontendPkgPath = path.join(frontendPath, 'package.json');
+            try {
+                const content = await fs.readFile(frontendPkgPath, 'utf8');
+                const frontendPkg = JSON.parse(content);
+                // Only remove if it matches our placeholder signature
+                if (frontendPkg.version === '0.0.0' &&
+                    frontendPkg.name === 'frontend' &&
+                    frontendPkg.private === true) {
+                    await fs.unlink(frontendPkgPath);
+                }
+            }
+            catch {
+                // No package.json or can't read, that's fine
+            }
+            // Check if frontend folder exists and has files (user-created content)
+            try {
+                const files = await fs.readdir(frontendPath);
+                if (files.length > 0) {
+                    spinner.fail('frontend/ folder is not empty. Please remove existing files before scaffolding.');
+                    return false;
+                }
+            }
+            catch {
+                // Folder doesn't exist, that's fine - C3 will create it
+            }
             spinner.start(`Creating ${projectType?.name} frontend app (this may take a while)...`);
             try {
                 await execAsync(`mkdir -p frontend`, {
                     cwd: configPath,
                 });
-                await execAsync(projectType.installCommand, {
+                // Transform install command for the selected package manager
+                const installCommand = transformCreateCommand(projectType.installCommand, pkg);
+                await execAsync(installCommand, {
                     cwd: configPath,
                 });
                 // Use this command to debug output, i.e.e when command becomes non-responsive
                 /* await this.execWithStdio(
                   configPath,
-                  projectType.installCommand,
+                  installCommand,
                 ); */
             }
             catch (error) {
@@ -210,25 +258,23 @@ export class CreateAppCommand extends SwellCommand {
                 return false;
             }
             // Ensure frontend package.json has correct name for workspace
-            const frontendPkgPath = path.join(configPath, 'frontend', 'package.json');
             try {
                 const pkgContent = await fs.readFile(frontendPkgPath, 'utf8');
-                const pkg = JSON.parse(pkgContent);
-                if (pkg.name !== 'frontend') {
-                    pkg.name = 'frontend';
-                    await fs.writeFile(frontendPkgPath, JSON.stringify(pkg, null, 2), 'utf8');
+                const frontendPkgJson = JSON.parse(pkgContent);
+                if (frontendPkgJson.name !== 'frontend') {
+                    frontendPkgJson.name = 'frontend';
+                    await fs.writeFile(frontendPkgPath, JSON.stringify(frontendPkgJson, null, 2), 'utf8');
                 }
             }
             catch {
                 // Ignore if package.json doesn't exist or can't be read
             }
             await this.addFrontendAllowedHosts(projectType, configPath);
-            // Re-run npm install at root to properly initialize workspace structure
-            // (removes frontend/package-lock.json, hoists dependencies, creates root lock file)
+            // Run install at root to hoist dependencies to workspace
             spinner.start('Initializing workspace...');
             try {
-                const execAsync = promisify(exec);
-                await execAsync('npm install', { cwd: configPath });
+                const { install } = getPackageManagerCommands(pkg);
+                await execAsync(install, { cwd: configPath });
                 spinner.succeed('Workspace initialized');
             }
             catch {
@@ -375,19 +421,22 @@ export class CreateAppCommand extends SwellCommand {
         const configPath = path.dirname(config.path);
         const packageJson = {
             description: config.get('description'),
-            // Include workspace even if frontend doesn't exist yet
-            // npm tolerates missing workspace directories without errors
-            workspaces: ['frontend'],
             devDependencies: {
                 '@swell/app-types': '^1.0.5',
                 typescript: '^5.9.3',
             },
             name,
+            // Required for yarn workspaces, good practice for all package managers
+            private: true,
             scripts: {
                 typecheck: '([ -z "$(find functions -name \'*.ts\' 2>/dev/null | head -1)" ] || tsc --noEmit) && ([ ! -f test/tsconfig.json ] || tsc --noEmit -p test) && ([ ! -f frontend/tsconfig.json ] || tsc --noEmit -p frontend)',
             },
             version: config.get('version'),
         };
+        // pnpm uses pnpm-workspace.yaml instead of workspaces field in package.json
+        if (pkg !== 'pnpm') {
+            packageJson.workspaces = ['frontend'];
+        }
         const tsConfig = {
             compilerOptions: {
                 lib: ['esnext', 'webworker'],
@@ -401,15 +450,24 @@ export class CreateAppCommand extends SwellCommand {
         await writeJsonFile(path.join(configPath, 'package.json'), packageJson);
         await writeJsonFile(path.join(configPath, 'tsconfig.json'), tsConfig);
         await writeFile(path.join(configPath, '.gitignore'), `node_modules`);
-        try {
-            const packageManager = await this.findPackageManager(pkg);
-            await execAsync(`${packageManager} install`, {
-                cwd: configPath,
+        // Create pnpm-workspace.yaml for pnpm (required for workspace support)
+        if (pkg === 'pnpm') {
+            await writeFile(path.join(configPath, 'pnpm-workspace.yaml'), 'packages:\n  - frontend\n');
+        }
+        // Create placeholder frontend/package.json for bun and yarn
+        // These package managers require workspace directories to exist with a package.json
+        if (pkg === 'bun' || pkg === 'yarn') {
+            const frontendPath = path.join(configPath, 'frontend');
+            await fs.mkdir(frontendPath, { recursive: true });
+            await writeJsonFile(path.join(frontendPath, 'package.json'), {
+                name: 'frontend',
+                private: true,
+                version: '0.0.0',
             });
         }
-        catch (error) {
-            this.error(error.message);
-        }
+        // Install root dependencies using selected package manager
+        const { install } = getPackageManagerCommands(pkg);
+        await execAsync(install, { cwd: configPath });
     }
     async tryPackageSetup(name, config, pkg) {
         try {

package/dist/env/local.d.ts

@@ -1,6 +1,7 @@
 declare namespace _default {
     let API_BASE_URL: string;
     let ADMIN_API_BASE_URL: string;
+    let FRONTEND_API_BASE_URL: string;
     let LOGIN_HOST: string;
     let APP_PAGES_HOST: string;
     let STOREFRONT_FRONTEND_HOST: string;

package/dist/env/local.js

@@ -1,6 +1,7 @@
 export default {
     API_BASE_URL: 'https://localapi.schema.io:4443',
     ADMIN_API_BASE_URL: 'http://${STORE_ID}.swell.test:4001/admin/api',
+    FRONTEND_API_BASE_URL: 'http://${STORE_ID}.swell.test:4001/api',
     LOGIN_HOST: 'http://${STORE_ID}.swell.test:3000',
     APP_PAGES_HOST: 'http://${STORE_ID}--${APP_ID}--${ENV}.swell.test:4001',
     STOREFRONT_FRONTEND_HOST: 'http://${BRANCH_PREFIX}${STOREFRONT_SLUG}.swell.test:4001',

package/dist/env/production.d.ts

@@ -1,6 +1,7 @@
 declare namespace _default {
     let API_BASE_URL: string;
     let ADMIN_API_BASE_URL: string;
+    let FRONTEND_API_BASE_URL: string;
     let LOGIN_HOST: string;
     let APP_PAGES_HOST: string;
     let STOREFRONT_FRONTEND_HOST: string;

package/dist/env/production.js

@@ -1,6 +1,7 @@
 export default {
     API_BASE_URL: 'https://api.swell.store',
     ADMIN_API_BASE_URL: 'https://${STORE_ID}.swell.store/admin/api',
+    FRONTEND_API_BASE_URL: 'https://${STORE_ID}.swell.store/api',
     LOGIN_HOST: 'https://${STORE_ID}.swell.store',
     APP_PAGES_HOST: 'https://${STORE_ID}--${APP_ID}--${ENV}.swell.store',
     STOREFRONT_FRONTEND_HOST: 'https://${BRANCH_PREFIX}${STOREFRONT_SLUG}.swell.store',

package/dist/env/review.d.ts

@@ -1,6 +1,7 @@
 declare namespace _default {
     let API_BASE_URL: string;
     let ADMIN_API_BASE_URL: string;
+    let FRONTEND_API_BASE_URL: string;
     let LOGIN_HOST: string;
     let APP_PAGES_HOST: string;
     let STOREFRONT_FRONTEND_HOST: string;

package/dist/env/review.js

@@ -1,6 +1,7 @@
 export default {
     API_BASE_URL: 'https://${REVIEW_DOMAIN}.rav2.swell.store',
     ADMIN_API_BASE_URL: 'https://${STORE_ID}.${REVIEW_DOMAIN}.rav2.swell.store/admin/api',
+    FRONTEND_API_BASE_URL: 'https://${STORE_ID}.${REVIEW_DOMAIN}.rav2.swell.store/api',
     LOGIN_HOST: 'https://${REVIEW_DOMAIN}.rav2.swell.store',
     APP_PAGES_HOST: 'https://${STORE_ID}--${APP_ID}--${ENV}.${REVIEW_DOMAIN}.rav2.swell.store',
     STOREFRONT_FRONTEND_HOST: 'https://${BRANCH_PREFIX}${STOREFRONT_SLUG}.${REVIEW_DOMAIN}.rav2.swell.store',

package/dist/env/staging.d.ts

@@ -1,6 +1,7 @@
 declare namespace _default {
     let API_BASE_URL: string;
     let ADMIN_API_BASE_URL: string;
+    let FRONTEND_API_BASE_URL: string;
     let LOGIN_HOST: string;
     let APP_PAGES_HOST: string;
     let STOREFRONT_FRONTEND_HOST: string;

package/dist/env/staging.js

@@ -1,6 +1,7 @@
 export default {
     API_BASE_URL: 'https://staging.swell.store',
     ADMIN_API_BASE_URL: 'https://${STORE_ID}.staging.swell.store/admin/api',
+    FRONTEND_API_BASE_URL: 'https://${STORE_ID}.staging.swell.store/api',
     LOGIN_HOST: 'https://staging.swell.store',
     APP_PAGES_HOST: 'https://${STORE_ID}--${APP_ID}--${ENV}.staging.swell.store',
     STOREFRONT_FRONTEND_HOST: 'https://${BRANCH_PREFIX}${STOREFRONT_SLUG}.staging.swell.store',

package/dist/lib/api.d.ts

@@ -5,10 +5,11 @@ export declare enum HttpMethod {
     DELETE = "delete"
 }
 export default class Api {
+    storeId: string | undefined;
     envId: string | undefined;
     secretKey: string | undefined;
-    storeId: string | undefined;
-    constructor(storeId?: string, envId?: string, secretKey?: string);
+    publicKey: string | undefined;
+    constructor(storeId?: string, envId?: string, publicKey?: string, secretKey?: string);
     api(pathOpts: Api.Paths, options: Api.RequestOptions): Promise<any>;
     get(pathOpts: Api.Paths, options?: Api.RequestOptions): Promise<any>;
     getAll(pathOpts: Api.Paths, options?: Api.RequestOptions): Promise<{
@@ -21,6 +22,8 @@ export default class Api {
     isTestEnvEnabled(): Promise<boolean>;
     setEnv(envId: string): Promise<void>;
     setStoreEnv(storeId: string, envId?: string): Promise<void>;
+    setPublicKey(publicKey?: string): Promise<void>;
+    private isFrontend;
     private isAdmin;
     private truncatePath;
     private waitForAsyncResponse;

package/dist/lib/api.js

@@ -1,7 +1,9 @@
 import fetch from 'node-fetch';
 import { stringify } from 'qs';
+import { getCurrentAppSlugId, hasAppContext } from './apps/index.js';
 import config from './config.js';
-import { API_BASE_URL, getAdminApiBaseUrl } from './constants.js';
+import { API_BASE_URL, getAdminApiBaseUrl, getFrontendApiBaseUrl, } from './constants.js';
+import style from './style.js';
 export var HttpMethod;
 (function (HttpMethod) {
     HttpMethod["GET"] = "get";
@@ -15,7 +17,7 @@ const defaultHeaders = (opts) => ({
     ...opts,
 });
 const authenticatedHeaders = (storeId, opts = {}) => {
-    let { secretKey, sessionId, ...moreOpts } = opts;
+    let { publicKey, secretKey, sessionId, ...moreOpts } = opts;
     sessionId ??= config.getSessionId(storeId);
     if (secretKey) {
         return defaultHeaders({
@@ -23,6 +25,12 @@ const authenticatedHeaders = (storeId, opts = {}) => {
             ...moreOpts,
         });
     }
+    if (publicKey) {
+        return defaultHeaders({
+            Authorization: `Basic ${Buffer.from(publicKey).toString('base64')}`,
+            ...moreOpts,
+        });
+    }
     if (sessionId) {
         return defaultHeaders({
             'X-Session': sessionId,
@@ -32,12 +40,14 @@ const authenticatedHeaders = (storeId, opts = {}) => {
     return defaultHeaders(moreOpts);
 };
 export default class Api {
+    storeId;
     envId;
     secretKey;
-    storeId;
-    constructor(storeId, envId, secretKey) {
+    publicKey;
+    constructor(storeId, envId, publicKey, secretKey) {
         this.storeId = storeId;
         this.envId = envId;
+        this.publicKey = publicKey;
         this.secretKey = secretKey;
     }
     async api(pathOpts, options) {
@@ -50,14 +60,17 @@ export default class Api {
                 ...options?.headers,
                 ...(this.envId ? { 'Swell-Env': this.envId } : undefined),
                 ...authenticatedHeaders(storeId, {
+                    publicKey: this.publicKey,
                     secretKey: this.secretKey,
                     sessionId: options.sessionId,
                 }),
             },
         };
-        path = this.isAdmin()
-            ? `${getAdminApiBaseUrl(storeId)}/${this.truncatePath(pathOpts.adminPath)}`
-            : `${API_BASE_URL}/${this.truncatePath(pathOpts.backendPath)}`;
+        path = this.isFrontend(pathOpts)
+            ? `${getFrontendApiBaseUrl(storeId)}/${this.truncatePath(pathOpts.frontendPath)}`
+            : this.isAdmin(pathOpts)
+                ? `${getAdminApiBaseUrl(storeId)}/${this.truncatePath(pathOpts.adminPath)}`
+                : `${API_BASE_URL}/${this.truncatePath(pathOpts.backendPath)}`;
         if (options.query) {
             path += `?${stringify(options.query)}`;
         }
@@ -179,8 +192,46 @@ export default class Api {
         this.storeId = storeId;
         this.envId = envId;
     }
-    isAdmin() {
-        return !this.secretKey;
+    async setPublicKey(publicKey) {
+        if (publicKey) {
+            this.publicKey = publicKey;
+            return;
+        }
+        const appSlugId = await getCurrentAppSlugId();
+        const response = await this.post({ adminPath: '/data/:batch' }, {
+            query: [
+                {
+                    method: 'get',
+                    url: '/:clients/:self/keys/:last',
+                    data: {
+                        scope: 'user',
+                        public: { $exists: true },
+                        revoked: { $ne: true },
+                    },
+                },
+                appSlugId && {
+                    method: 'get',
+                    url: '/:clients/:self/apps/:last',
+                    data: {
+                        app_private_id: `_${appSlugId}`,
+                    },
+                },
+            ],
+        });
+        const [userKey, installedApp] = Object.values(response);
+        this.publicKey = installedApp?.public_key || userKey?.public;
+        if (!this.publicKey) {
+            throw new Error('No API public key available. Run inside a deployed app or create a user-scoped public key.');
+        }
+        else if (hasAppContext() && !installedApp?.public_key) {
+            console.warn(style.funcWarn('⚠ No app context found. Running in user scope.'));
+        }
+    }
+    isFrontend(pathOpts) {
+        return Boolean(pathOpts.frontendPath) && Boolean(this.publicKey);
+    }
+    isAdmin(pathOpts) {
+        return Boolean(pathOpts.adminPath) && !this.secretKey;
     }
     truncatePath(path) {
         return path?.startsWith('/') ? path.slice(1) : path;

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

@@ -131,6 +131,15 @@ export declare function getFrontendProjectSlugs(withNone?: boolean, withLegacy?:
 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;
+/**
+ * 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 declare function getProjectCommands(appPath: string, projectType: FrontendProjectType): {
+    buildCommand?: string;
+    devCommand: string;
+};
 export declare function getConfigTypeFromPath(path: string): ConfigType | undefined;
 export declare function getConfigTypeKeyFromValue(value: string): string | undefined;
 export declare function filePathExists(filePath: string): boolean;
@@ -156,3 +165,5 @@ interface BatchAppFiles {
  * @returns {BatchAppFiles[]} Batches of files to push
  */
 export declare function batchAppFilesByType(configs: AppConfig[]): BatchAppFiles[];
+export declare function hasAppContext(): boolean;
+export declare function getCurrentAppSlugId(): Promise<string | undefined>;