@swell/cli 2.9.18 → 2.9.19

package/dist/lib/apps/frontend-scaffold.js

@@ -0,0 +1,502 @@
+import { execa } from 'execa';
+import { exec } from 'node:child_process';
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import { promisify } from 'node:util';
+import { getPackageManagerCommands, transformCreateCommand, } from '../package-manager.js';
+import { writeJsonFile } from './index.js';
+const execAsync = promisify(exec);
+/** Allowed hosts for tunnel providers used in local development */
+export const TUNNEL_ALLOWED_HOSTS = ['.trycloudflare.com', '.swell.store'];
+/**
+ * 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;
+}
+async function addAllowedHostsToAngular(configPath) {
+    const angularJsonPath = path.join(configPath, 'frontend', 'angular.json');
+    let content;
+    try {
+        content = await fs.readFile(angularJsonPath, 'utf8');
+    }
+    catch {
+        return;
+    }
+    let config;
+    try {
+        config = JSON.parse(content);
+    }
+    catch {
+        return;
+    }
+    const { projects } = config;
+    if (!projects || typeof projects !== 'object') {
+        return;
+    }
+    const projectNames = Object.keys(projects);
+    if (projectNames.length === 0) {
+        return;
+    }
+    // Use first project (typically only one exists in new apps)
+    const projectName = projectNames[0];
+    const project = projects[projectName];
+    if (!project?.architect?.serve) {
+        return;
+    }
+    if (!project.architect.serve.options) {
+        project.architect.serve.options = {};
+    }
+    if (project.architect.serve.options.allowedHosts) {
+        return;
+    }
+    project.architect.serve.options.allowedHosts = TUNNEL_ALLOWED_HOSTS;
+    await fs.writeFile(angularJsonPath, JSON.stringify(config, null, 2), 'utf8');
+}
+async function addAllowedHostsToAstro(configPath) {
+    return addViteAllowedHosts(configPath, 'astro.config.mjs', 'defineConfig');
+}
+async function addAllowedHostsToNuxt(configPath) {
+    return addViteAllowedHosts(configPath, 'nuxt.config.ts', 'defineNuxtConfig');
+}
+/**
+ * For frameworks whose dev server is Vite directly. Astro/Nuxt nest the
+ * vite block inside their own defineConfig — see addViteAllowedHosts.
+ */
+async function addAllowedHostsToVite(configPath) {
+    const candidates = [
+        'vite.config.ts',
+        'vite.config.js',
+        'vite.config.mts',
+        'vite.config.mjs',
+    ];
+    let configFilePath;
+    let content;
+    for (const fileName of candidates) {
+        const candidatePath = path.join(configPath, 'frontend', fileName);
+        try {
+            // eslint-disable-next-line no-await-in-loop
+            content = await fs.readFile(candidatePath, 'utf8');
+            configFilePath = candidatePath;
+            break;
+        }
+        catch {
+            /* try next */
+        }
+    }
+    if (!configFilePath || content === undefined) {
+        return;
+    }
+    if (content.includes('allowedHosts')) {
+        return;
+    }
+    const serverBlock = `  server: {
+    allowedHosts: ${JSON.stringify(TUNNEL_ALLOWED_HOSTS)},
+  },`;
+    const emptyConfig = 'defineConfig({})';
+    if (content.includes(emptyConfig)) {
+        content = content.replace(emptyConfig, `defineConfig({\n${serverBlock}\n})`);
+        await fs.writeFile(configFilePath, content, 'utf8');
+        return;
+    }
+    const closingPos = findConfigClosingBrace(content, 'defineConfig');
+    if (closingPos === -1) {
+        return;
+    }
+    const before = content.slice(0, closingPos);
+    const after = content.slice(closingPos);
+    const needsComma = before.trimEnd().slice(-1) !== ',';
+    const separator = needsComma ? ',\n' : '\n';
+    content = before.trimEnd() + separator + serverBlock + '\n' + after;
+    await fs.writeFile(configFilePath, content, 'utf8');
+}
+/**
+ * Add vite allowedHosts configuration to a framework config file.
+ * Supports config files that use a defineX({}) pattern (Astro, Nuxt, etc.)
+ */
+async function addViteAllowedHosts(configPath, configFile, functionName) {
+    const configFilePath = path.join(configPath, 'frontend', configFile);
+    let content;
+    try {
+        content = await fs.readFile(configFilePath, 'utf8');
+    }
+    catch {
+        return;
+    }
+    if (content.includes('allowedHosts')) {
+        return;
+    }
+    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;
+    }
+    // Find the closing brace of the config function using brace counting
+    const closingPos = findConfigClosingBrace(content, functionName);
+    if (closingPos === -1) {
+        return;
+    }
+    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');
+}
+/**
+ * Fix wrangler.jsonc `main` field when it points to a build artifact that
+ * doesn't exist at dev time. The @cloudflare/vite-plugin validates this path
+ * at startup and crashes during `astro dev` if it can't resolve it.
+ *
+ * Only replaces the exact legacy value that C3 currently scaffolds.
+ * Once C3 updates its template, this becomes a no-op.
+ */
+async function fixAstroWranglerEntrypoint(configPath) {
+    const filePath = path.join(configPath, 'frontend', 'wrangler.jsonc');
+    let content;
+    try {
+        content = await fs.readFile(filePath, 'utf8');
+    }
+    catch {
+        return;
+    }
+    const legacy = '"main": "./dist/_worker.js/index.js"';
+    if (!content.includes(legacy)) {
+        return;
+    }
+    const updated = content.replace(legacy, '"main": "@astrojs/cloudflare/entrypoints/server"');
+    await fs.writeFile(filePath, updated, 'utf8');
+}
+/**
+ * Configure allowedHosts for frameworks using Vite dev server.
+ * This allows tunneling services (localtunnel) to proxy requests to the
+ * local dev environment.
+ */
+export async function addFrontendAllowedHosts(framework, configPath) {
+    switch (framework) {
+        case 'astro': {
+            await addAllowedHostsToAstro(configPath);
+            await fixAstroWranglerEntrypoint(configPath);
+            break;
+        }
+        case 'angular': {
+            await addAllowedHostsToAngular(configPath);
+            break;
+        }
+        case 'nuxt': {
+            await addAllowedHostsToNuxt(configPath);
+            break;
+        }
+        case 'react': {
+            await addAllowedHostsToVite(configPath);
+            break;
+        }
+        // Other frameworks don't require allowedHosts configuration
+    }
+}
+/** Write the root workspace files and install root dependencies. */
+export async function setupPackage(name, config, pkg) {
+    const configPath = path.dirname(config.path);
+    const packageJson = {
+        description: config.get('description'),
+        devDependencies: {
+            '@swell/app-types': '^1.2.0',
+            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 --build --noEmit test) && ([ ! -f frontend/tsconfig.json ] || tsc --build --noEmit 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'],
+            module: 'esnext',
+            target: 'esnext',
+            moduleResolution: 'bundler',
+            types: ['@swell/app-types'],
+        },
+        exclude: ['node_modules', 'frontend', 'test', 'vitest.config.ts'],
+    };
+    await writeJsonFile(path.join(configPath, 'package.json'), packageJson);
+    // create frontend can initialize a workspace around an existing manifest.
+    // Keep any configuration the developer has already written.
+    const writeDefault = async (filename, contents) => {
+        await fs
+            .writeFile(path.join(configPath, filename), contents, { flag: 'wx' })
+            .catch((error) => {
+            if (error.code !== 'EEXIST')
+                throw error;
+        });
+    };
+    await writeDefault('tsconfig.json', `${JSON.stringify(tsConfig, null, 2)}\n`);
+    await writeDefault('.gitignore', `node_modules\n.wrangler\n.dev.vars\n.dev.vars.*\n`);
+    // Create pnpm-workspace.yaml for pnpm (required for workspace support)
+    if (pkg === 'pnpm') {
+        await writeDefault('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 writeDefault('frontend/package.json', JSON.stringify({
+            name: 'frontend',
+            private: true,
+            version: '0.0.0',
+        }, null, 2));
+    }
+    // Install root dependencies using selected package manager
+    const { install } = getPackageManagerCommands(pkg);
+    await execAsync(install, { cwd: configPath });
+}
+/**
+ * Remove the empty workspace placeholder created by setupPackage; refuse to
+ * scaffold over any other content in frontend/.
+ */
+export async function prepareFrontendDirectory(configPath) {
+    const frontendPath = path.join(configPath, 'frontend');
+    const frontendPkgPath = path.join(frontendPath, 'package.json');
+    const files = await fs.readdir(frontendPath).catch((error) => {
+        if (error.code === 'ENOENT')
+            return [];
+        throw error;
+    });
+    // Only replace the empty workspace placeholder created by setupPackage.
+    let placeholder = false;
+    try {
+        const content = await fs.readFile(frontendPkgPath, 'utf8');
+        const frontendPkg = JSON.parse(content);
+        placeholder =
+            files.length === 1 &&
+                Object.keys(frontendPkg).length === 3 &&
+                frontendPkg.version === '0.0.0' &&
+                frontendPkg.name === 'frontend' &&
+                frontendPkg.private === true;
+    }
+    catch {
+        // An unreadable or invalid manifest is not our placeholder.
+    }
+    if (files.length > 0 && !placeholder) {
+        throw new Error('frontend/ folder is not empty. Move existing files before scaffolding.');
+    }
+    if (placeholder)
+        await fs.unlink(frontendPkgPath);
+}
+/** Create the root workspace, or add frontend to an existing one. */
+export async function ensureRootWorkspace(swellConfig, pkg) {
+    const configPath = path.dirname(swellConfig.path);
+    const rootPkgPath = path.join(configPath, 'package.json');
+    const rootPackage = await fs.readFile(rootPkgPath, 'utf8').catch((error) => {
+        if (error.code === 'ENOENT')
+            return null;
+        throw error;
+    });
+    if (rootPackage === null) {
+        await setupPackage(swellConfig.get('id'), swellConfig, pkg);
+        // Bun/Yarn setup creates an empty workspace placeholder.
+        if (pkg === 'bun' || pkg === 'yarn') {
+            await fs.unlink(path.join(configPath, 'frontend', 'package.json'));
+        }
+    }
+    else if (pkg !== 'pnpm') {
+        const manifest = JSON.parse(rootPackage);
+        const workspaces = Array.isArray(manifest.workspaces)
+            ? manifest.workspaces
+            : manifest.workspaces?.packages || [];
+        let changed = false;
+        if (!workspaces.includes('frontend')) {
+            if (manifest.workspaces && !Array.isArray(manifest.workspaces)) {
+                manifest.workspaces.packages = [...workspaces, 'frontend'];
+            }
+            else {
+                manifest.workspaces = [...workspaces, 'frontend'];
+            }
+            changed = true;
+        }
+        if (pkg === 'yarn' && manifest.private !== true) {
+            manifest.private = true;
+            changed = true;
+        }
+        if (changed) {
+            await writeJsonFile(rootPkgPath, manifest);
+        }
+    }
+    if (pkg === 'pnpm') {
+        const { stdout } = await execa('pnpm', ['config', 'get', '--json', 'packages'], { cwd: configPath });
+        const packages = stdout.trim() && stdout.trim() !== 'undefined' ? JSON.parse(stdout) : [];
+        if (!packages.includes('frontend')) {
+            await execa('pnpm', [
+                'config',
+                'set',
+                '--location',
+                'project',
+                '--json',
+                'packages',
+                JSON.stringify([...packages, 'frontend']),
+            ], { cwd: configPath });
+        }
+    }
+}
+/**
+ * pnpm's native build policy must include the two toolchain binaries.
+ * Use pnpm to merge its YAML settings without replacing other entries.
+ */
+export async function ensurePnpmBuildApprovals(configPath) {
+    const { stdout } = await execa('pnpm', ['config', 'get', '--json', 'allowBuilds'], { cwd: configPath });
+    const current = stdout.trim() && stdout.trim() !== 'undefined'
+        ? JSON.parse(stdout)
+        : undefined;
+    if (current?.esbuild === false || current?.workerd === false) {
+        throw new Error('Managed templates require esbuild and workerd build scripts. Update allowBuilds in pnpm-workspace.yaml before scaffolding.');
+    }
+    await execa('pnpm', [
+        'config',
+        'set',
+        '--location',
+        'project',
+        '--json',
+        'allowBuilds',
+        JSON.stringify({ ...current, esbuild: true, workerd: true }),
+    ], { cwd: configPath });
+}
+function commandFailureDetail(error) {
+    return ([error.stdout, error.stderr]
+        .map((s) => (s || '').trim())
+        .filter(Boolean)
+        .join('\n') || (error.message ?? '').trim());
+}
+/** Run the template's scaffold command into frontend/. */
+export async function scaffoldFrontendTemplate(configPath, template, pkg) {
+    try {
+        await fs.mkdir(path.join(configPath, 'frontend'), {
+            recursive: true,
+        });
+        // SWELL_LOCAL_TEMPLATE_PATH overrides the scaffold for local dev — copies
+        // the directory at the path into frontend/ instead of running the install
+        // command. Used to iterate on the canonical template repo without pushing.
+        const localTemplatePath = process.env.SWELL_LOCAL_TEMPLATE_PATH;
+        if (localTemplatePath) {
+            const source = path.resolve(localTemplatePath);
+            const dest = path.join(configPath, 'frontend');
+            await fs.cp(source, dest, {
+                recursive: true,
+                filter: (src) => !src.includes('/node_modules') &&
+                    !src.endsWith('/.git') &&
+                    !src.includes('/dist') &&
+                    !src.includes('/.wrangler'),
+            });
+        }
+        else {
+            // Managed commands run the pinned generator through npx; only the
+            // generic self-hosted commands are rewritten for the package manager.
+            const installCommand = template.hosting === 'managed'
+                ? template.installCommand
+                : transformCreateCommand(template.installCommand, pkg);
+            const env = { ...process.env };
+            if (template.hosting === 'managed') {
+                const { stdout } = await execa(pkg, ['--version']);
+                // Keep C3's dependency edits on the selected package manager,
+                // even though npx supplies the pinned generator executable.
+                env.npm_config_user_agent = `${pkg}/${stdout.trim()}`;
+            }
+            await execAsync(installCommand, {
+                cwd: configPath,
+                env,
+            });
+        }
+    }
+    catch (error) {
+        throw new Error(commandFailureDetail(error) || 'Frontend scaffolding failed.');
+    }
+}
+/**
+ * The template finalizer restores the pinned declarations and managed
+ * settings that C3 rewrites while scaffolding.
+ */
+export async function finalizeManagedFrontend(frontendPath) {
+    try {
+        await execa(process.execPath, ['scripts/prepare-managed.mjs'], {
+            cwd: frontendPath,
+        });
+    }
+    catch (error) {
+        throw new Error(commandFailureDetail(error) || 'Frontend scaffolding failed.');
+    }
+}
+/** Ensure frontend package.json has the correct name for the workspace. */
+export async function normalizeFrontendManifest(frontendPath, template) {
+    const frontendPkgPath = path.join(frontendPath, 'package.json');
+    const pkgContent = await fs.readFile(frontendPkgPath, 'utf8');
+    const frontendPkgJson = JSON.parse(pkgContent);
+    frontendPkgJson.name = 'frontend';
+    if (template.hosting === 'managed') {
+        // The CLI owns workspace installation; template lockfiles must not
+        // redirect later commands.
+        for (const lockfile of [
+            'package-lock.json',
+            'bun.lock',
+            'bun.lockb',
+            'pnpm-lock.yaml',
+            'yarn.lock',
+        ]) {
+            // eslint-disable-next-line no-await-in-loop
+            await fs.rm(path.join(frontendPath, lockfile), { force: true });
+        }
+    }
+    await fs.writeFile(frontendPkgPath, JSON.stringify(frontendPkgJson, null, 2), 'utf8');
+}
+/** Run install at root to hoist dependencies to the workspace. */
+export async function installFrontendWorkspace(configPath, template, pkg) {
+    const frontendPath = path.join(configPath, 'frontend');
+    try {
+        const { install } = getPackageManagerCommands(pkg);
+        await execAsync(template.hosting === 'managed' && pkg === 'pnpm'
+            ? `${install} --no-frozen-lockfile`
+            : install, { cwd: configPath });
+        if (template.hosting === 'managed') {
+            await execAsync(getPackageManagerCommands(pkg).run('cf-typegen'), {
+                cwd: frontendPath,
+            });
+        }
+    }
+    catch (error) {
+        throw new Error(error.stderr || error.stdout || error.message);
+    }
+}

package/dist/lib/apps/frontend-templates.d.ts

@@ -0,0 +1,32 @@
+import { Separator } from '@inquirer/prompts';
+export declare const FRONTEND_HOSTING_LABELS: {
+    managed: string;
+    'self-hosted': string;
+};
+export declare const C3_VERSION = "2.72.7";
+export declare const FRONTEND_TEMPLATE_REF = "v0.1";
+export interface FrontendTemplate {
+    /** `--frontend` value and picker value. */
+    slug: string;
+    name: string;
+    hosting: 'managed' | 'self-hosted';
+    /** Runtime detection slug in FrontendProjectTypes. */
+    framework: string;
+    description: string;
+    installCommand: string;
+    /** Absent means available for all app types. */
+    appTypes?: string[];
+    provisionsStorefront?: boolean;
+    /** Accepted `--frontend` values kept out of prompts and help. */
+    aliases?: string[];
+}
+export declare const FRONTEND_TEMPLATES: readonly FrontendTemplate[];
+/** Public `--frontend` values; aliases are accepted but not listed. */
+export declare const FRONTEND_TEMPLATE_VALUES: string[];
+export declare const FRONTEND_TEMPLATE_ALIASES: string[];
+export declare function getFrontendTemplate(value: string): FrontendTemplate | undefined;
+export declare function getFrontendTemplateChoices(appType: string, direct?: boolean): (Separator | {
+    name: string;
+    value: string;
+    description: string;
+})[];

package/dist/lib/apps/frontend-templates.js

@@ -0,0 +1,137 @@
+import { Separator } from '@inquirer/prompts';
+import style from '../style.js';
+export const FRONTEND_HOSTING_LABELS = {
+    managed: 'Hosted by Swell',
+    'self-hosted': 'Your Cloudflare account',
+};
+export const C3_VERSION = '2.72.7';
+// Moving compatibility tag in swell-app-templates: patch releases move it, so
+// template hotfixes need no CLI release; a breaking template change gets a new
+// minor tag and a CLI release that points at it. degit resolves only branch
+// and tag tips, never arbitrary commits.
+export const FRONTEND_TEMPLATE_REF = 'v0.1';
+// npx pins the generator even on Yarn Classic. The caller passes the selected
+// manager's user agent for C3's dependency edits.
+const managedInstallCommand = (directory) => `npx --yes create-cloudflare@${C3_VERSION} frontend --template=swellstores/swell-app-templates/${directory}#${FRONTEND_TEMPLATE_REF} --deploy=false --git=false --no-agents --no-auto-update --lang=ts`;
+const SELF_HOSTED_DESCRIPTION = 'Deploys to your own Cloudflare account.';
+// Picker and help order. Runtime detection lives in FrontendProjectTypes.
+export const FRONTEND_TEMPLATES = [
+    {
+        slug: 'swell-react',
+        name: 'React + Vite',
+        hosting: 'managed',
+        framework: 'react',
+        description: 'client rendering + server endpoints',
+        installCommand: managedInstallCommand('react'),
+    },
+    {
+        slug: 'swell-vinext',
+        name: 'Vinext',
+        hosting: 'managed',
+        framework: 'vinext',
+        description: 'server rendering',
+        installCommand: managedInstallCommand('vinext'),
+    },
+    {
+        slug: 'swell-spa',
+        name: 'React SPA Storefront',
+        hosting: 'managed',
+        framework: 'react',
+        description: 'Client-only commerce starter for AI-authored storefronts.',
+        installCommand: managedInstallCommand('react-storefront'),
+        appTypes: ['storefront'],
+        provisionsStorefront: true,
+        // The former internal AI starter now uses the managed SPA template. This
+        // is a scaffold alias only; the `react-storefront` runtime detection slug
+        // in FrontendProjectTypes still means the legacy chassis storefront.
+        aliases: ['react-storefront'],
+    },
+    {
+        slug: 'nextjs',
+        name: 'Next.js',
+        hosting: 'self-hosted',
+        framework: 'nextjs',
+        description: SELF_HOSTED_DESCRIPTION,
+        installCommand: 'npm create cloudflare@latest -- frontend --framework=next --deploy=false --git=false -- --typescript --use-npm --src-dir --app --eslint --import-alias "@/*" --tailwind --turbopack',
+    },
+    {
+        slug: 'astro',
+        name: 'Astro',
+        hosting: 'self-hosted',
+        framework: 'astro',
+        description: SELF_HOSTED_DESCRIPTION,
+        installCommand: 'npm create cloudflare@latest -- frontend --framework=astro --deploy=false --git=false -- --no-git --yes --skip-houston --typescript strict',
+    },
+    {
+        slug: 'nuxt',
+        name: 'Nuxt',
+        hosting: 'self-hosted',
+        framework: 'nuxt',
+        description: SELF_HOSTED_DESCRIPTION,
+        installCommand: 'npm create cloudflare@latest -- frontend --framework=nuxt --deploy=false --git=false -- --no-modules -f',
+    },
+    {
+        // `--variant=react-ts` pre-answers C3's variant prompt (TS Vite +
+        // plugin-react, not SWC) so install doesn't hang behind our spinner.
+        slug: 'react',
+        name: 'React + Vite',
+        hosting: 'self-hosted',
+        framework: 'react',
+        description: SELF_HOSTED_DESCRIPTION,
+        installCommand: 'npm create cloudflare@latest -- frontend --framework=react --deploy=false --git=false --variant=react-ts',
+    },
+    {
+        slug: 'hono',
+        name: 'Hono',
+        hosting: 'self-hosted',
+        framework: 'hono',
+        description: SELF_HOSTED_DESCRIPTION,
+        installCommand: 'npm create cloudflare@latest -- frontend --framework=hono  --deploy=false --git=false',
+    },
+    {
+        slug: 'angular',
+        name: 'Angular',
+        hosting: 'self-hosted',
+        framework: 'angular',
+        description: SELF_HOSTED_DESCRIPTION,
+        installCommand: 'npm create cloudflare@latest -- frontend --framework=angular --deploy=false --git=false -- --style=sass --zoneless --ai-config=none',
+    },
+];
+/** Public `--frontend` values; aliases are accepted but not listed. */
+export const FRONTEND_TEMPLATE_VALUES = [
+    ...FRONTEND_TEMPLATES.map((template) => template.slug),
+    'none',
+];
+export const FRONTEND_TEMPLATE_ALIASES = FRONTEND_TEMPLATES.flatMap((template) => template.aliases ?? []);
+export function getFrontendTemplate(value) {
+    return FRONTEND_TEMPLATES.find((template) => template.slug === value || template.aliases?.includes(value));
+}
+export function getFrontendTemplateChoices(appType, direct = false) {
+    const templates = FRONTEND_TEMPLATES.filter((template) => !template.appTypes || template.appTypes.includes(appType));
+    return [
+        ...(direct
+            ? []
+            : [
+                {
+                    name: 'Skip for now',
+                    value: 'none',
+                    description: style.dim('\n  Add a frontend later with swell create frontend.'),
+                },
+            ]),
+        ...['managed', 'self-hosted'].flatMap((hosting) => [
+            new Separator(' '),
+            new Separator(` ${style.dim(FRONTEND_HOSTING_LABELS[hosting])}`),
+            ...templates
+                .filter((template) => template.hosting === hosting)
+                .map((template) => {
+                const description = template.description.charAt(0).toUpperCase() +
+                    template.description.slice(1);
+                return {
+                    name: `  ${template.name}`,
+                    value: template.slug,
+                    description: style.dim(`\n  ${template.name}: ${description}${description.endsWith('.') ? '' : '.'}`),
+                };
+            }),
+        ]),
+    ];
+}