@doswiftly/cli 0.1.1

package/dist/commands/template.js

@@ -0,0 +1,1309 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync, statSync } from 'fs';
+import { execSync, execFileSync } from 'child_process';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import * as p from '@clack/prompts';
+import { createSharedApiClient } from '../lib/shared-api-client.js';
+import { logger } from '../lib/logger.js';
+import { getStoredRole } from './auth.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+/**
+ * Check that the current user has SaaS developer role.
+ * Exits with error if the role is insufficient.
+ * This is a UX improvement — the backend also rejects unauthorized requests.
+ */
+function requireSaasDeveloperRole() {
+    const role = getStoredRole()?.toLowerCase();
+    if (role && role !== 'admin' && role !== 'saas_developer') {
+        console.log(chalk.red('\n  Error: This command requires SaaS developer role.'));
+        console.log(chalk.gray('  Your current role: ' + role + '\n'));
+        process.exit(1);
+    }
+}
+async function apiRequest(endpoint, options = {}) {
+    // Template operations are platform-level, not shop-level
+    // They don't require doswiftly.config.ts with shop.slug
+    const client = createSharedApiClient({ requireShopSlug: false });
+    logger.debug(`API Request: ${options.method || 'GET'} ${endpoint}`);
+    try {
+        const response = await client.request({
+            url: endpoint,
+            method: (options.method || 'GET'),
+            data: options.body ? JSON.parse(options.body) : undefined,
+        });
+        return response.data;
+    }
+    catch (error) {
+        // Extract meaningful error message from axios error response
+        if (error && typeof error === 'object' && 'response' in error) {
+            const axiosError = error;
+            const serverMessage = axiosError.response?.data?.message;
+            if (serverMessage) {
+                throw new Error(serverMessage);
+            }
+        }
+        throw error;
+    }
+}
+/**
+ * List all available templates from the registry.
+ */
+export async function templateListCommand() {
+    console.log(chalk.bold.blue('\nDoSwiftly CLI - Template Registry\n'));
+    const spinner = ora('Fetching templates...').start();
+    try {
+        const templates = await apiRequest('/cli/templates');
+        spinner.stop();
+        if (!templates || templates.length === 0) {
+            console.log(chalk.yellow('  No templates available.\n'));
+            return;
+        }
+        console.log(chalk.gray('─'.repeat(80)));
+        console.log(chalk.bold('  Name'.padEnd(25)) +
+            chalk.bold('Version'.padEnd(12)) +
+            chalk.bold('UI Library'.padEnd(15)) +
+            chalk.bold('Status'.padEnd(12)) +
+            chalk.bold('Description'));
+        console.log(chalk.gray('─'.repeat(80)));
+        for (const t of templates) {
+            const statusColor = t.status === 'PUBLISHED' ? chalk.green : chalk.yellow;
+            console.log(`  ${chalk.cyan(t.name.padEnd(25))}` +
+                `${chalk.gray(t.version.padEnd(12))}` +
+                `${chalk.gray((t.uiLibrary || '-').padEnd(15))}` +
+                `${statusColor(t.status.padEnd(12))}` +
+                `${chalk.gray((t.description || '').slice(0, 30))}`);
+        }
+        console.log(chalk.gray('─'.repeat(80)));
+        console.log('');
+    }
+    catch (error) {
+        spinner.fail('Failed to fetch templates');
+        console.log(chalk.red(`\n${error.message}\n`));
+        process.exit(1);
+    }
+}
+/**
+ * Show template details.
+ */
+export async function templateInfoCommand(name) {
+    console.log(chalk.bold.blue('\nDoSwiftly CLI - Template Info\n'));
+    if (!name) {
+        console.log(chalk.red('  Error: Template name required\n'));
+        process.exit(1);
+    }
+    const spinner = ora(`Fetching template '${name}'...`).start();
+    try {
+        const t = await apiRequest(`/cli/templates/${encodeURIComponent(name)}`);
+        spinner.stop();
+        console.log(`  ${chalk.bold('Name:')}        ${chalk.cyan(t.name)}`);
+        console.log(`  ${chalk.bold('Version:')}     ${t.version}`);
+        console.log(`  ${chalk.bold('Status:')}      ${t.status}`);
+        console.log(`  ${chalk.bold('Visibility:')}  ${t.visibility}`);
+        if (t.description) {
+            console.log(`  ${chalk.bold('Description:')} ${t.description}`);
+        }
+        if (t.uiLibrary) {
+            console.log(`  ${chalk.bold('UI Library:')}  ${t.uiLibrary}`);
+        }
+        if (t.features.length > 0) {
+            console.log(`  ${chalk.bold('Features:')}    ${t.features.join(', ')}`);
+        }
+        if (t.repoUrl) {
+            console.log(`  ${chalk.bold('Repository:')}  ${chalk.cyan(t.repoUrl)}`);
+        }
+        if (t.previewUrl) {
+            console.log(`  ${chalk.bold('Preview:')}     ${chalk.cyan(t.previewUrl)}`);
+        }
+        console.log('');
+    }
+    catch (error) {
+        spinner.fail('Failed to fetch template');
+        console.log(chalk.red(`\n${error.message}\n`));
+        process.exit(1);
+    }
+}
+/**
+ * Read doswiftly-template.json manifest from current directory.
+ */
+function readTemplateManifest() {
+    if (!existsSync('doswiftly-template.json'))
+        return null;
+    try {
+        return JSON.parse(readFileSync('doswiftly-template.json', 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Detect git remote URL from the current directory.
+ * Converts SSH URLs to HTTPS for degit compatibility.
+ */
+function detectGitRemoteUrl() {
+    try {
+        execSync('git rev-parse --git-dir', { stdio: 'pipe' });
+        const url = execSync('git remote get-url origin', { encoding: 'utf-8', stdio: 'pipe' }).trim();
+        if (!url)
+            return null;
+        // Convert SSH to HTTPS
+        if (url.startsWith('git@github.com:')) {
+            return url.replace('git@github.com:', 'https://github.com/').replace(/\.git$/, '');
+        }
+        return url.replace(/\.git$/, '');
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Check if git is initialized in the current directory.
+ */
+function isGitInitialized() {
+    try {
+        execSync('git rev-parse --git-dir', { stdio: 'pipe' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Register a new template in the registry (SaaS developer only).
+ *
+ * Auto-detects:
+ * 1. Template name/description/uiLibrary from doswiftly-template.json
+ * 2. Git remote URL from `git remote get-url origin`
+ * 3. Falls back to CLI flags if auto-detect fails
+ */
+export async function templateRegisterCommand(options = {}) {
+    requireSaasDeveloperRole();
+    console.log(chalk.bold.blue('\nDoSwiftly CLI - Register Template\n'));
+    // Validate project structure
+    if (!existsSync('package.json')) {
+        console.log(chalk.red('  Error: No package.json found. Run this from a template project root.\n'));
+        process.exit(1);
+    }
+    // Check git is initialized
+    if (!isGitInitialized()) {
+        console.log(chalk.red('  Error: Git is not initialized in this directory.'));
+        console.log(chalk.gray('  Run "git init" or "doswiftly init --create-template" first.\n'));
+        process.exit(1);
+    }
+    // Auto-detect from manifest
+    const manifest = readTemplateManifest();
+    if (manifest) {
+        console.log(chalk.gray('  Auto-detected doswiftly-template.json'));
+    }
+    const name = options.name || manifest?.name || null;
+    const description = options.description || manifest?.description || undefined;
+    const uiLibrary = options.uiLibrary || manifest?.uiLibrary || undefined;
+    if (!name) {
+        console.log(chalk.red('  Error: Template name required.'));
+        console.log(chalk.gray('  Use --name or add "name" to doswiftly-template.json\n'));
+        process.exit(1);
+    }
+    // Auto-detect git remote URL
+    let repoUrl = options.repoUrl || detectGitRemoteUrl();
+    if (repoUrl) {
+        console.log(chalk.gray(`  Git remote: ${repoUrl}`));
+    }
+    else {
+        console.log(chalk.yellow('  Warning: No git remote detected. Use --repo-url to specify.'));
+    }
+    // Show summary
+    console.log(chalk.gray('\n  Registration summary:'));
+    console.log(chalk.gray(`    Name:        ${chalk.cyan(name)}`));
+    if (description)
+        console.log(chalk.gray(`    Description: ${description}`));
+    if (repoUrl)
+        console.log(chalk.gray(`    Repo URL:    ${repoUrl}`));
+    if (uiLibrary)
+        console.log(chalk.gray(`    UI Library:  ${uiLibrary}`));
+    console.log('');
+    const spinner = ora(`Registering template '${name}'...`).start();
+    try {
+        const template = await apiRequest('/cli/templates', {
+            method: 'POST',
+            body: JSON.stringify({
+                name,
+                description,
+                repoUrl,
+                uiLibrary,
+            }),
+        });
+        spinner.succeed(`Template '${template.name}' registered`);
+        console.log(chalk.gray(`\n  ID: ${template.id}`));
+        console.log(chalk.gray(`  Status: ${template.status}`));
+        console.log(chalk.gray('\n  Next steps:'));
+        console.log(chalk.gray('    1. Set version in package.json (e.g., "version": "1.0.0")'));
+        console.log(chalk.gray('    2. Publish: doswiftly template publish'));
+        console.log(chalk.gray('    3. Set visibility: doswiftly template visibility ' + template.name + ' PUBLIC\n'));
+    }
+    catch (error) {
+        spinner.fail('Failed to register template');
+        console.log(chalk.red(`\n${error.message}\n`));
+        process.exit(1);
+    }
+}
+/**
+ * Update template metadata (SaaS developer only).
+ */
+export async function templateUpdateCommand(nameOrId, options = {}) {
+    requireSaasDeveloperRole();
+    console.log(chalk.bold.blue('\nDoSwiftly CLI - Update Template\n'));
+    if (!nameOrId) {
+        console.log(chalk.red('  Error: Template name or ID required\n'));
+        process.exit(1);
+    }
+    const body = {};
+    if (options.description !== undefined)
+        body.description = options.description;
+    if (options.repoUrl !== undefined)
+        body.repoUrl = options.repoUrl;
+    if (options.uiLibrary !== undefined)
+        body.uiLibrary = options.uiLibrary;
+    if (options.previewUrl !== undefined)
+        body.previewUrl = options.previewUrl;
+    if (options.visibility !== undefined)
+        body.visibility = options.visibility;
+    if (Object.keys(body).length === 0) {
+        console.log(chalk.yellow('  No fields to update. Use --description, --repo-url, --ui-library, --preview-url, or --visibility.\n'));
+        process.exit(1);
+    }
+    const spinner = ora(`Updating template '${nameOrId}'...`).start();
+    try {
+        const template = await apiRequest(`/cli/templates/${encodeURIComponent(nameOrId)}`, {
+            method: 'PUT',
+            body: JSON.stringify(body),
+        });
+        spinner.succeed(`Template '${template.name}' updated`);
+        console.log(chalk.gray(`\n  Name: ${template.name}`));
+        if (template.description)
+            console.log(chalk.gray(`  Description: ${template.description}`));
+        if (template.repoUrl)
+            console.log(chalk.gray(`  Repository: ${template.repoUrl}`));
+        console.log(chalk.gray(`  Visibility: ${template.visibility}`));
+        console.log('');
+    }
+    catch (error) {
+        spinner.fail('Failed to update template');
+        console.log(chalk.red(`\n${error.message}\n`));
+        process.exit(1);
+    }
+}
+/**
+ * Read version from package.json in current directory.
+ */
+function readPackageVersion() {
+    if (!existsSync('package.json'))
+        return null;
+    try {
+        const pkg = JSON.parse(readFileSync('package.json', 'utf-8'));
+        return pkg.version || null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Publish template with version from package.json (SaaS developer only).
+ *
+ * Reads version from:
+ * 1. package.json (preferred - npm ecosystem standard)
+ * 2. doswiftly-template.json (fallback)
+ *
+ * This ensures single source of truth for versioning.
+ */
+export async function templatePublishCommand(nameOrId) {
+    requireSaasDeveloperRole();
+    console.log(chalk.bold.blue('\nDoSwiftly CLI - Publish Template\n'));
+    // Auto-detect from manifest if nameOrId not provided
+    const manifest = readTemplateManifest();
+    const resolvedName = nameOrId || manifest?.name || null;
+    if (!resolvedName) {
+        console.log(chalk.red('  Error: Template name required.'));
+        console.log(chalk.gray('  Provide name as argument or run from a directory with doswiftly-template.json\n'));
+        process.exit(1);
+    }
+    // Read version from package.json (primary) or doswiftly-template.json (fallback)
+    const packageVersion = readPackageVersion();
+    const manifestVersion = manifest?.version;
+    const version = packageVersion || manifestVersion;
+    if (!version) {
+        console.log(chalk.red('  Error: No version found.'));
+        console.log(chalk.gray('  Set "version" in package.json (recommended) or doswiftly-template.json\n'));
+        process.exit(1);
+    }
+    // Show version source for transparency
+    const versionSource = packageVersion ? 'package.json' : 'doswiftly-template.json';
+    console.log(chalk.gray(`  Version: ${chalk.cyan(version)} (from ${versionSource})`));
+    console.log('');
+    const spinner = ora(`Publishing template '${resolvedName}' v${version}...`).start();
+    try {
+        const template = await apiRequest(`/cli/templates/${encodeURIComponent(resolvedName)}/version`, {
+            method: 'PUT',
+            body: JSON.stringify({ version }),
+        });
+        spinner.succeed(`Template '${template.name}' v${template.version} published`);
+        console.log(chalk.gray(`\n  Status: ${template.status}`));
+        console.log(chalk.gray(`  Visibility: ${template.visibility}`));
+        if (template.visibility === 'PRIVATE') {
+            console.log(chalk.yellow('\n  Note: Template is PRIVATE. Set visibility to PUBLIC for users to see it:'));
+            console.log(chalk.cyan(`    doswiftly template visibility ${template.name} PUBLIC`));
+        }
+        console.log('');
+    }
+    catch (error) {
+        spinner.fail('Failed to publish template');
+        console.log(chalk.red(`\n${error.message}\n`));
+        process.exit(1);
+    }
+}
+/**
+ * @deprecated Use templatePublishCommand instead.
+ * Kept for backward compatibility - redirects to publish command.
+ */
+export async function templateVersionCommand(nameOrId, version) {
+    console.log(chalk.yellow('\n  ⚠️  "template version" is deprecated. Use "template publish" instead.'));
+    console.log(chalk.gray('  The version is now read automatically from package.json.\n'));
+    // For backward compatibility, still allow manual version if provided
+    requireSaasDeveloperRole();
+    const spinner = ora(`Publishing template '${nameOrId}' v${version}...`).start();
+    try {
+        const template = await apiRequest(`/cli/templates/${encodeURIComponent(nameOrId)}/version`, {
+            method: 'PUT',
+            body: JSON.stringify({ version }),
+        });
+        spinner.succeed(`Template '${template.name}' v${template.version} published`);
+        console.log(chalk.gray(`\n  Status: ${template.status}`));
+        console.log('');
+    }
+    catch (error) {
+        spinner.fail('Failed to publish template');
+        console.log(chalk.red(`\n${error.message}\n`));
+        process.exit(1);
+    }
+}
+/**
+ * Unpublish a template (SaaS developer only).
+ */
+export async function templateUnpublishCommand(name) {
+    requireSaasDeveloperRole();
+    console.log(chalk.bold.blue('\nDoSwiftly CLI - Unpublish Template\n'));
+    if (!name) {
+        console.log(chalk.red('  Error: Template name required\n'));
+        process.exit(1);
+    }
+    const spinner = ora(`Unpublishing template '${name}'...`).start();
+    try {
+        await apiRequest(`/cli/templates/${encodeURIComponent(name)}/unpublish`, {
+            method: 'POST',
+        });
+        spinner.succeed(`Template '${name}' unpublished`);
+        console.log(chalk.yellow('\n  Template has been deprecated and will no longer appear in listings.\n'));
+    }
+    catch (error) {
+        spinner.fail('Failed to unpublish template');
+        console.log(chalk.red(`\n${error.message}\n`));
+        process.exit(1);
+    }
+}
+/**
+ * Set template visibility (SaaS developer only).
+ * Convenience wrapper around templateUpdateCommand.
+ */
+export async function templateVisibilityCommand(nameOrId, visibility) {
+    if (!nameOrId) {
+        console.log(chalk.red('\n  Error: Template name or ID required\n'));
+        process.exit(1);
+    }
+    const normalizedVis = visibility?.toUpperCase();
+    if (!normalizedVis || !['PUBLIC', 'PRIVATE'].includes(normalizedVis)) {
+        console.log(chalk.red('\n  Error: Visibility must be PUBLIC or PRIVATE\n'));
+        process.exit(1);
+    }
+    return templateUpdateCommand(nameOrId, { visibility: normalizedVis });
+}
+/**
+ * Recursively copy directory with placeholder replacement.
+ */
+function copyTemplateDir(src, dest, replacements) {
+    mkdirSync(dest, { recursive: true });
+    const entries = readdirSync(src);
+    for (const entry of entries) {
+        const srcPath = join(src, entry);
+        const destPath = join(dest, entry);
+        const stat = statSync(srcPath);
+        if (stat.isDirectory()) {
+            copyTemplateDir(srcPath, destPath, replacements);
+        }
+        else {
+            let content = readFileSync(srcPath, 'utf-8');
+            for (const [placeholder, value] of Object.entries(replacements)) {
+                content = content.replace(new RegExp(placeholder, 'g'), value);
+            }
+            writeFileSync(destPath, content);
+        }
+    }
+}
+/**
+ * Recursively read all files from a directory.
+ * Returns array of { path, content } for API upload.
+ */
+function readAllFiles(dir, baseDir = dir) {
+    const files = [];
+    const entries = readdirSync(dir);
+    for (const entry of entries) {
+        const fullPath = join(dir, entry);
+        const relativePath = fullPath.replace(baseDir + '/', '').replace(baseDir + '\\', '');
+        const stat = statSync(fullPath);
+        if (stat.isDirectory()) {
+            // Skip .git directory
+            if (entry === '.git')
+                continue;
+            files.push(...readAllFiles(fullPath, baseDir));
+        }
+        else {
+            try {
+                const content = readFileSync(fullPath, 'utf-8');
+                // Use forward slashes for GitHub API
+                files.push({ path: relativePath.replace(/\\/g, '/'), content });
+            }
+            catch {
+                // Skip binary files or unreadable files
+            }
+        }
+    }
+    return files;
+}
+/**
+ * Create a new template with optional GitHub repository creation.
+ * Full flow: scaffold → create GitHub repo (optional) → register → provide next steps.
+ */
+export async function templateCreateCommand(options = {}) {
+    requireSaasDeveloperRole();
+    console.log(chalk.bold.blue('\nDoSwiftly CLI - Create Template\n'));
+    // Step 1: Template name
+    let templateName = options.name;
+    if (!templateName) {
+        const nameResult = await p.text({
+            message: 'Template name:',
+            placeholder: 'my-awesome-template',
+            validate: (v) => {
+                if (!v)
+                    return 'Name is required';
+                if (!/^[a-z0-9-]+$/.test(v))
+                    return 'Use lowercase letters, numbers, and hyphens only';
+                if (v.length < 3)
+                    return 'At least 3 characters';
+                return undefined;
+            },
+        });
+        if (p.isCancel(nameResult)) {
+            console.log(chalk.yellow('\n  Operation cancelled.\n'));
+            process.exit(0);
+        }
+        templateName = nameResult;
+    }
+    // Validate name format
+    if (!/^[a-z0-9-]+$/.test(templateName)) {
+        console.log(chalk.red('\n  Error: Template name must be lowercase, alphanumeric, and may contain hyphens.\n'));
+        process.exit(1);
+    }
+    // Step 2: Description
+    let description = options.description;
+    if (!description) {
+        const descResult = await p.text({
+            message: 'Template description (optional):',
+            placeholder: `DoSwiftly storefront template: ${templateName}`,
+        });
+        if (p.isCancel(descResult)) {
+            console.log(chalk.yellow('\n  Operation cancelled.\n'));
+            process.exit(0);
+        }
+        description = descResult || `DoSwiftly storefront template: ${templateName}`;
+    }
+    // Step 3: Base template selection
+    let baseTemplate = options.base;
+    if (!baseTemplate) {
+        const baseResult = await p.select({
+            message: 'Base template to start from:',
+            options: [
+                {
+                    value: 'storefront-nextjs-shadcn',
+                    label: 'shadcn/ui (Recommended)',
+                    hint: 'Next.js + shadcn/ui + Tailwind CSS',
+                },
+                {
+                    value: 'storefront-minimal',
+                    label: 'Minimal (Next.js only)',
+                    hint: 'Minimal Next.js starter',
+                },
+            ],
+        });
+        if (p.isCancel(baseResult)) {
+            console.log(chalk.yellow('\n  Operation cancelled.\n'));
+            process.exit(0);
+        }
+        baseTemplate = baseResult;
+    }
+    // UI Library mapping
+    const uiLibraryMap = {
+        'storefront-nextjs-shadcn': 'shadcn/ui',
+        'storefront-minimal': 'none',
+    };
+    const uiLibrary = uiLibraryMap[baseTemplate] || 'none';
+    // Step 4: GitHub repository creation
+    let createGitHubRepo = false;
+    let repoInfo = null;
+    let githubUsername;
+    if (!options.skipGithub) {
+        const githubResult = await p.confirm({
+            message: 'Create GitHub repository in DoSwiftly organization?',
+            initialValue: true,
+        });
+        if (p.isCancel(githubResult)) {
+            console.log(chalk.yellow('\n  Operation cancelled.\n'));
+            process.exit(0);
+        }
+        createGitHubRepo = githubResult;
+        // Ask for GitHub username to add as collaborator (optional - not needed for org owners)
+        if (createGitHubRepo) {
+            const usernameResult = await p.text({
+                message: 'GitHub username to add as collaborator (Enter to skip):',
+                placeholder: ' ',
+                defaultValue: '',
+                validate: (v) => {
+                    if (!v || v.trim() === '')
+                        return undefined; // Optional
+                    if (!/^[a-zA-Z0-9](?:[a-zA-Z0-9-]*[a-zA-Z0-9])?$/.test(v.trim())) {
+                        return 'Invalid GitHub username format';
+                    }
+                    return undefined;
+                },
+            });
+            if (p.isCancel(usernameResult)) {
+                console.log(chalk.yellow('\n  Operation cancelled.\n'));
+                process.exit(0);
+            }
+            const trimmed = usernameResult?.trim();
+            githubUsername = trimmed && trimmed.length > 0 ? trimmed : undefined;
+        }
+    }
+    // Create target directory
+    const targetDir = templateName;
+    if (existsSync(targetDir)) {
+        console.log(chalk.red(`\n  Error: Directory "${targetDir}" already exists.\n`));
+        process.exit(1);
+    }
+    // Step 5: Create GitHub repo if requested
+    if (createGitHubRepo) {
+        const repoSpinner = ora('Creating GitHub repository...').start();
+        try {
+            repoInfo = await apiRequest('/cli/templates/create-repo', {
+                method: 'POST',
+                body: JSON.stringify({ name: templateName, description, githubUsername }),
+            });
+            if (repoInfo.collaboratorAdded) {
+                repoSpinner.succeed(`GitHub repository created: ${chalk.cyan(repoInfo.fullName)} ` +
+                    `(${chalk.green(repoInfo.collaboratorUsername)} added as admin)`);
+            }
+            else {
+                repoSpinner.succeed(`GitHub repository created: ${chalk.cyan(repoInfo.fullName)}`);
+            }
+        }
+        catch (error) {
+            repoSpinner.fail('Failed to create GitHub repository');
+            const errorMsg = error.message;
+            // Check if it's a configuration/installation issue
+            if (errorMsg.includes('not configured') || errorMsg.includes('not installed')) {
+                console.log(chalk.yellow('\n  GitHub integration is not available.'));
+                console.log(chalk.gray('  You can continue without GitHub integration.\n'));
+                const continueResult = await p.confirm({
+                    message: 'Continue without GitHub integration?',
+                    initialValue: true,
+                });
+                if (p.isCancel(continueResult) || !continueResult) {
+                    console.log(chalk.yellow('\n  Operation cancelled.\n'));
+                    process.exit(0);
+                }
+                createGitHubRepo = false;
+            }
+            else if (errorMsg.includes('already exists')) {
+                console.log(chalk.red(`\n  ${errorMsg}\n`));
+                process.exit(1);
+            }
+            else if (errorMsg.includes('permission') || errorMsg.includes('403')) {
+                // Permission-related error - offer to continue without GitHub
+                console.log(chalk.yellow('\n  GitHub App does not have required permissions.'));
+                console.log(chalk.gray(`  ${errorMsg}\n`));
+                const continueResult = await p.confirm({
+                    message: 'Continue without GitHub integration?',
+                    initialValue: true,
+                });
+                if (p.isCancel(continueResult) || !continueResult) {
+                    console.log(chalk.yellow('\n  Operation cancelled.\n'));
+                    process.exit(0);
+                }
+                createGitHubRepo = false;
+            }
+            else {
+                console.log(chalk.red(`\n  ${errorMsg}\n`));
+                process.exit(1);
+            }
+        }
+    }
+    // Step 6: Scaffold the template locally
+    const scaffoldSpinner = ora('Creating template project...').start();
+    try {
+        const templateDir = join(__dirname, '..', '..', 'templates', baseTemplate);
+        if (!existsSync(templateDir)) {
+            throw new Error(`Base template not found: ${baseTemplate}`);
+        }
+        // Copy template files with generic placeholders
+        const replacements = {
+            '\\{\\{PROJECT_NAME\\}\\}': templateName,
+            '\\{\\{SHOP_SLUG\\}\\}': '{{SHOP_SLUG}}',
+            '\\{\\{API_URL\\}\\}': '{{API_URL}}',
+            '\\{\\{SDK_VERSION\\}\\}': '^1.0.0',
+            '\\{\\{COMMERCE_SDK_VERSION\\}\\}': '^1.0.0',
+            '\\{\\{STOREFRONT_OPS_VERSION\\}\\}': '^1.0.0',
+        };
+        copyTemplateDir(templateDir, targetDir, replacements);
+        // Create doswiftly-template.json manifest
+        const manifest = {
+            name: templateName,
+            description,
+            uiLibrary,
+            features: [],
+            version: '0.1.0',
+        };
+        writeFileSync(join(targetDir, 'doswiftly-template.json'), JSON.stringify(manifest, null, 2) + '\n');
+        // Initialize git
+        scaffoldSpinner.text = 'Initializing git repository...';
+        let gitInitialized = false;
+        let localBranch = 'main';
+        try {
+            execFileSync('git', ['init'], { stdio: 'pipe', cwd: targetDir });
+            execFileSync('git', ['add', '-A'], { stdio: 'pipe', cwd: targetDir });
+            // Check if git user is configured, if not set temporary values
+            try {
+                execFileSync('git', ['config', 'user.name'], { stdio: 'pipe', cwd: targetDir });
+            }
+            catch {
+                execFileSync('git', ['config', 'user.name', 'DoSwiftly CLI'], { stdio: 'pipe', cwd: targetDir });
+            }
+            try {
+                execFileSync('git', ['config', 'user.email'], { stdio: 'pipe', cwd: targetDir });
+            }
+            catch {
+                execFileSync('git', ['config', 'user.email', 'cli@doswiftly.com'], { stdio: 'pipe', cwd: targetDir });
+            }
+            execFileSync('git', ['commit', '-m', `chore: initialize ${templateName} template`], {
+                stdio: 'pipe',
+                cwd: targetDir,
+            });
+            // Get the actual branch name (might be 'master' on older git)
+            try {
+                localBranch = execSync('git branch --show-current', {
+                    stdio: 'pipe',
+                    cwd: targetDir,
+                    encoding: 'utf-8',
+                }).trim() || 'main';
+            }
+            catch {
+                localBranch = 'main';
+            }
+            gitInitialized = true;
+        }
+        catch (gitError) {
+            const err = gitError;
+            const errorMsg = err.stderr || err.message || 'Unknown git error';
+            scaffoldSpinner.fail('Failed to initialize git');
+            console.log(chalk.red(`\n  Git error: ${errorMsg.trim()}\n`));
+            // Continue without git - user can init manually
+        }
+        // Add remote if GitHub repo was created
+        if (repoInfo) {
+            scaffoldSpinner.text = 'Configuring git remote...';
+            // Detect if user has SSH configured for GitHub
+            let useSSH = false;
+            try {
+                // Check if SSH key auth works with GitHub
+                execSync('ssh -T git@github.com 2>&1 || true', { stdio: 'pipe', encoding: 'utf-8' });
+                // Check if user has SSH in their git config or .ssh folder
+                const sshTest = execSync('ssh -o BatchMode=yes -o StrictHostKeyChecking=no git@github.com 2>&1 || true', {
+                    stdio: 'pipe',
+                    encoding: 'utf-8',
+                });
+                // GitHub returns "successfully authenticated" even with exit code 1
+                if (sshTest.includes('successfully authenticated') || sshTest.includes('Hi ')) {
+                    useSSH = true;
+                }
+            }
+            catch {
+                // SSH not configured, use HTTPS
+            }
+            const remoteUrl = useSSH ? repoInfo.sshUrl : repoInfo.cloneUrl;
+            try {
+                execSync(`git remote add origin ${remoteUrl}`, {
+                    stdio: 'pipe',
+                    cwd: targetDir,
+                });
+            }
+            catch {
+                // Non-fatal
+            }
+        }
+        scaffoldSpinner.succeed('Template project created');
+        // Step 7: Push to GitHub using local git
+        if (repoInfo && gitInitialized) {
+            const pushSpinner = ora('Pushing to GitHub...').start();
+            try {
+                // Try to push using local git credentials
+                // Use the local branch name, not the remote default (they might differ)
+                execSync(`git push -u origin ${localBranch}`, {
+                    cwd: targetDir,
+                    stdio: ['pipe', 'pipe', 'pipe'],
+                    encoding: 'utf-8',
+                });
+                pushSpinner.succeed('Pushed to GitHub');
+            }
+            catch (pushError) {
+                pushSpinner.fail('Failed to push to GitHub');
+                // Extract and show the actual git error
+                const err = pushError;
+                const gitError = err.stderr || err.message || 'Unknown error';
+                console.log(chalk.red('\n  Git error:'));
+                console.log(chalk.gray(`  ${gitError.trim().split('\n').join('\n  ')}`));
+                // Provide helpful suggestions
+                console.log(chalk.yellow('\n  Possible solutions:'));
+                console.log(chalk.gray('  1. Run: gh auth login (if you have GitHub CLI)'));
+                console.log(chalk.gray('  2. Configure SSH key for GitHub'));
+                console.log(chalk.gray('  3. Use HTTPS with credential manager'));
+                console.log(chalk.yellow('\n  Then push manually:'));
+                console.log(chalk.cyan(`    cd ${templateName} && git push -u origin ${localBranch}\n`));
+            }
+        }
+        else if (repoInfo && !gitInitialized) {
+            console.log(chalk.yellow('\n  Git not initialized. Push manually after fixing git config:'));
+            console.log(chalk.cyan(`    cd ${templateName} && git init && git add -A && git commit -m "Initial commit" && git push -u origin main\n`));
+        }
+        // Step 8: Auto-register the template
+        if (repoInfo) {
+            const registerSpinner = ora('Registering template in registry...').start();
+            try {
+                const template = await apiRequest('/cli/templates', {
+                    method: 'POST',
+                    body: JSON.stringify({
+                        name: templateName,
+                        description,
+                        repoUrl: repoInfo.repoUrl,
+                        uiLibrary,
+                        ...(repoInfo.repoId && { githubRepoId: repoInfo.repoId }),
+                        ...(repoInfo.ownerId && { githubOrgId: repoInfo.ownerId }),
+                    }),
+                });
+                registerSpinner.succeed(`Template registered: ${chalk.cyan(template.name)}`);
+            }
+            catch (regError) {
+                registerSpinner.fail('Failed to register template');
+                const errorMsg = regError.message || 'Unknown error';
+                console.log(chalk.red(`  Error: ${errorMsg}`));
+                console.log(chalk.yellow('  You can register manually with:'));
+                console.log(chalk.gray(`    cd ${templateName} && doswiftly template register\n`));
+            }
+        }
+        // Show CF Builds status
+        if (repoInfo?.buildsSetup) {
+            if (repoInfo.buildsSetup.success) {
+                console.log(chalk.green('\n  Cloudflare Workers Builds configured!'));
+                console.log(chalk.gray(`    Worker: storefront-template-${templateName}`));
+                console.log(chalk.gray('    Auto-deploy: pushes to main/master trigger build + deploy'));
+            }
+            else {
+                console.log(chalk.yellow('\n  CF Builds setup failed: ' + (repoInfo.buildsSetup.error || 'unknown')));
+                console.log(chalk.gray(`    Retry with: doswiftly template setup-builds ${templateName}`));
+            }
+        }
+    }
+    catch (error) {
+        scaffoldSpinner.fail('Failed to create template project');
+        console.log(chalk.red(`\n  ${error.message}\n`));
+        process.exit(1);
+    }
+    // Success summary
+    console.log(chalk.green('\n  ✓ Template created successfully!\n'));
+    console.log(chalk.gray('  Location: ') + chalk.cyan(`${targetDir}/`));
+    if (repoInfo) {
+        console.log(chalk.gray('  Repository: ') + chalk.cyan(repoInfo.repoUrl));
+    }
+    console.log(chalk.bold('\n  Next steps:\n'));
+    console.log(chalk.cyan(`    cd ${templateName}`));
+    console.log(chalk.gray('    # Customize your template'));
+    if (!repoInfo) {
+        console.log(chalk.cyan('    git remote add origin <your-github-repo-url>'));
+        console.log(chalk.cyan('    git push -u origin main'));
+        console.log(chalk.cyan('    doswiftly template register'));
+        console.log(chalk.gray('    # Update version in package.json, then:'));
+        console.log(chalk.cyan('    doswiftly template publish'));
+    }
+    else if (repoInfo.buildsSetup?.success) {
+        console.log(chalk.gray('    # Make changes, commit and push:'));
+        console.log(chalk.cyan('    git add -A && git commit -m "feat: ..." && git push'));
+        console.log(chalk.gray('    # CF Builds will auto-build and deploy on push'));
+    }
+    else {
+        console.log(chalk.gray('    # Update version in package.json, then:'));
+        console.log(chalk.cyan('    doswiftly template publish'));
+    }
+    console.log('');
+}
+/**
+ * Validate a template project before publishing.
+ * Checks:
+ * 1. doswiftly-template.json exists and is valid
+ * 2. package.json exists with required fields
+ * 3. Required dependencies are present
+ * 4. Git remote is configured
+ * 5. Build succeeds (optional, with --build flag)
+ */
+export async function templateValidateCommand(options = {}) {
+    requireSaasDeveloperRole();
+    console.log(chalk.bold.blue('\nDoSwiftly CLI - Validate Template\n'));
+    const result = {
+        valid: true,
+        errors: [],
+        warnings: [],
+    };
+    // Check 1: doswiftly-template.json
+    console.log(chalk.gray('  Checking doswiftly-template.json...'));
+    const manifest = readTemplateManifest();
+    if (!manifest) {
+        result.valid = false;
+        result.errors.push('doswiftly-template.json not found. Create one with required fields: name, description, uiLibrary');
+    }
+    else {
+        // Validate required fields
+        if (!manifest.name) {
+            result.valid = false;
+            result.errors.push('doswiftly-template.json: "name" field is required');
+        }
+        else if (!/^[a-z0-9-]+$/.test(manifest.name)) {
+            result.valid = false;
+            result.errors.push('doswiftly-template.json: "name" must be lowercase, alphanumeric with hyphens');
+        }
+        if (!manifest.description) {
+            result.warnings.push('doswiftly-template.json: "description" is recommended');
+        }
+        if (!manifest.uiLibrary) {
+            result.warnings.push('doswiftly-template.json: "uiLibrary" is recommended (e.g., "shadcn/ui", "none")');
+        }
+        if (!manifest.version) {
+            result.warnings.push('doswiftly-template.json: "version" is recommended');
+        }
+        console.log(chalk.green('    ✓ doswiftly-template.json exists'));
+    }
+    // Check 2: package.json
+    console.log(chalk.gray('  Checking package.json...'));
+    if (!existsSync('package.json')) {
+        result.valid = false;
+        result.errors.push('package.json not found');
+    }
+    else {
+        try {
+            const pkg = JSON.parse(readFileSync('package.json', 'utf-8'));
+            if (!pkg.name) {
+                result.warnings.push('package.json: "name" field is recommended');
+            }
+            // Check for required dependencies
+            const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+            const requiredDeps = ['next', 'react', 'react-dom'];
+            const missingDeps = requiredDeps.filter(dep => !allDeps[dep]);
+            if (missingDeps.length > 0) {
+                result.warnings.push(`package.json: Missing recommended dependencies: ${missingDeps.join(', ')}`);
+            }
+            // Check for DoSwiftly SDK
+            if (!allDeps['@doswiftly/commerce-sdk'] && !allDeps['@doswiftly/storefront-operations']) {
+                result.warnings.push('package.json: Consider adding @doswiftly/commerce-sdk for storefront functionality');
+            }
+            console.log(chalk.green('    ✓ package.json exists'));
+        }
+        catch {
+            result.valid = false;
+            result.errors.push('package.json is not valid JSON');
+        }
+    }
+    // Check 3: Git initialization
+    console.log(chalk.gray('  Checking git configuration...'));
+    if (!isGitInitialized()) {
+        result.warnings.push('Git is not initialized. Run "git init" before publishing');
+    }
+    else {
+        const remoteUrl = detectGitRemoteUrl();
+        if (!remoteUrl) {
+            result.warnings.push('No git remote configured. Add one with "git remote add origin <url>"');
+        }
+        else {
+            console.log(chalk.green(`    ✓ Git remote: ${remoteUrl}`));
+        }
+    }
+    // Check 4: Required files
+    console.log(chalk.gray('  Checking required files...'));
+    const recommendedFiles = [
+        { path: 'README.md', required: false },
+        { path: '.gitignore', required: false },
+        { path: 'tsconfig.json', required: false },
+    ];
+    for (const file of recommendedFiles) {
+        if (!existsSync(file.path)) {
+            if (file.required) {
+                result.valid = false;
+                result.errors.push(`Required file missing: ${file.path}`);
+            }
+            else {
+                result.warnings.push(`Recommended file missing: ${file.path}`);
+            }
+        }
+    }
+    // Check 5: Placeholder tokens (should not be resolved yet in templates)
+    console.log(chalk.gray('  Checking placeholder tokens...'));
+    const checkFiles = ['package.json', 'doswiftly-template.json'];
+    for (const file of checkFiles) {
+        if (existsSync(file)) {
+            const content = readFileSync(file, 'utf-8');
+            // Templates should contain placeholders like {{SHOP_SLUG}}
+            if (content.includes('{{SHOP_SLUG}}') || content.includes('{{API_URL}}')) {
+                console.log(chalk.green(`    ✓ ${file} contains expected placeholders`));
+            }
+        }
+    }
+    // Check 6: Build test (optional)
+    if (options.build) {
+        console.log(chalk.gray('  Running build test...'));
+        const buildSpinner = ora('Building project...').start();
+        try {
+            execSync('npm run build', { stdio: 'pipe' });
+            buildSpinner.succeed('Build succeeded');
+        }
+        catch (buildError) {
+            buildSpinner.fail('Build failed');
+            result.valid = false;
+            result.errors.push('Build failed. Fix build errors before publishing.');
+        }
+    }
+    // Summary
+    console.log('');
+    if (result.errors.length > 0) {
+        console.log(chalk.red.bold('  Errors:'));
+        for (const error of result.errors) {
+            console.log(chalk.red(`    ✗ ${error}`));
+        }
+        console.log('');
+    }
+    if (result.warnings.length > 0) {
+        console.log(chalk.yellow.bold('  Warnings:'));
+        for (const warning of result.warnings) {
+            console.log(chalk.yellow(`    ⚠ ${warning}`));
+        }
+        console.log('');
+    }
+    if (result.valid && result.errors.length === 0) {
+        console.log(chalk.green.bold('  ✓ Template is valid and ready for publishing!\n'));
+        console.log(chalk.gray('  Next steps:'));
+        console.log(chalk.cyan('    doswiftly template register'));
+        console.log(chalk.cyan('    doswiftly template version <name> 1.0.0\n'));
+    }
+    else {
+        console.log(chalk.red.bold('  ✗ Template validation failed. Fix errors before publishing.\n'));
+        process.exit(1);
+    }
+}
+// ============================================================================
+// Template Build Command (OpenNext for Cloudflare)
+// ============================================================================
+/**
+ * Build a template for Cloudflare Workers using OpenNext.
+ * Runs: pnpm build && npx @opennextjs/cloudflare build
+ */
+export async function templateBuildCommand(options = {}) {
+    requireSaasDeveloperRole();
+    console.log(chalk.bold.blue('\nDoSwiftly CLI - Build Template for Cloudflare\n'));
+    // Check for required files
+    if (!existsSync('package.json')) {
+        console.log(chalk.red('  Error: No package.json found. Run this from a template project root.\n'));
+        process.exit(1);
+    }
+    // Read manifest for template name
+    const manifest = readTemplateManifest();
+    const templateName = manifest?.name || 'template';
+    console.log(chalk.gray(`  Template: ${chalk.cyan(templateName)}`));
+    // Check for @opennextjs/cloudflare
+    let hasOpenNext = false;
+    try {
+        const pkg = JSON.parse(readFileSync('package.json', 'utf-8'));
+        const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+        hasOpenNext = !!allDeps['@opennextjs/cloudflare'] || !!allDeps['@opennextjs/cloudflare'];
+    }
+    catch {
+        // Continue without check
+    }
+    if (!hasOpenNext) {
+        console.log(chalk.yellow('\n  Warning: @opennextjs/cloudflare not found in dependencies.'));
+        console.log(chalk.gray('  Install it with: pnpm add -D @opennextjs/cloudflare'));
+        console.log(chalk.gray('  Or: npx @opennextjs/cloudflare build (will use npx version)\n'));
+    }
+    // Step 1: Run Next.js build (unless skipped)
+    if (!options.skipNextBuild) {
+        const nextSpinner = ora('Building Next.js application...').start();
+        try {
+            // Try pnpm first, then npm
+            try {
+                execSync('pnpm build', { stdio: 'pipe', cwd: process.cwd() });
+            }
+            catch {
+                execSync('npm run build', { stdio: 'pipe', cwd: process.cwd() });
+            }
+            nextSpinner.succeed('Next.js build completed');
+        }
+        catch (error) {
+            nextSpinner.fail('Next.js build failed');
+            const err = error;
+            const stderr = err.stderr?.toString() || err.message || '';
+            console.log(chalk.red(`\n  ${stderr.split('\n').slice(0, 10).join('\n  ')}\n`));
+            process.exit(1);
+        }
+    }
+    else {
+        console.log(chalk.gray('  Skipping Next.js build (--skip-next-build)\n'));
+    }
+    // Step 2: Run OpenNext build for Cloudflare
+    const openNextSpinner = ora('Building for Cloudflare Workers (OpenNext)...').start();
+    try {
+        execSync('npx @opennextjs/cloudflare build', { stdio: 'pipe', cwd: process.cwd() });
+        openNextSpinner.succeed('OpenNext build completed');
+    }
+    catch (error) {
+        openNextSpinner.fail('OpenNext build failed');
+        const err = error;
+        const stderr = err.stderr?.toString() || err.message || '';
+        console.log(chalk.red(`\n  ${stderr.split('\n').slice(0, 10).join('\n  ')}\n`));
+        console.log(chalk.yellow('  Make sure @opennextjs/cloudflare is installed:'));
+        console.log(chalk.gray('    pnpm add -D @opennextjs/cloudflare\n'));
+        process.exit(1);
+    }
+    // Check output
+    const workerPath = '.open-next/worker.js';
+    if (!existsSync(workerPath)) {
+        console.log(chalk.red(`\n  Error: Worker file not found at ${workerPath}`));
+        console.log(chalk.gray('  The OpenNext build may have failed silently.\n'));
+        process.exit(1);
+    }
+    const workerStats = statSync(workerPath);
+    const sizeKB = (workerStats.size / 1024).toFixed(1);
+    console.log(chalk.green(`\n  ✓ Build successful!`));
+    console.log(chalk.gray(`    Worker: ${workerPath} (${sizeKB} KB)`));
+    console.log(chalk.gray(`\n  Next: Upload to registry with:`));
+    console.log(chalk.cyan(`    doswiftly template upload${manifest?.version ? '' : ' --version 1.0.0'}\n`));
+}
+/**
+ * Upload a built worker bundle to R2 storage.
+ * The bundle can then be deployed to Cloudflare Workers from the Admin Panel.
+ *
+ * Prerequisites:
+ * - Run `doswiftly template build` first
+ * - Template must be registered in the registry
+ */
+export async function templateUploadCommand(options = {}) {
+    requireSaasDeveloperRole();
+    console.log(chalk.bold.blue('\nDoSwiftly CLI - Upload Template Bundle\n'));
+    // Read manifest for template name
+    const manifest = readTemplateManifest();
+    const templateName = manifest?.name;
+    if (!templateName) {
+        console.log(chalk.red('  Error: No doswiftly-template.json found or missing "name" field.'));
+        console.log(chalk.gray('  Run this from a template project root.\n'));
+        process.exit(1);
+    }
+    // Determine version
+    const packageVersion = readPackageVersion();
+    const manifestVersion = manifest?.version;
+    const version = options.version || packageVersion || manifestVersion;
+    if (!version) {
+        console.log(chalk.red('  Error: No version found.'));
+        console.log(chalk.gray('  Set "version" in package.json or use --version flag\n'));
+        process.exit(1);
+    }
+    // Validate version format
+    const versionRegex = /^\d+\.\d+\.\d+(-[\w.]+)?$/;
+    if (!versionRegex.test(version)) {
+        console.log(chalk.red('  Error: Version must be semver format (e.g., 1.0.0 or 1.0.0-beta.1)\n'));
+        process.exit(1);
+    }
+    // Find worker bundle
+    const workerPath = options.workerPath || '.open-next/worker.js';
+    if (!existsSync(workerPath)) {
+        console.log(chalk.red(`  Error: Worker bundle not found at ${workerPath}`));
+        console.log(chalk.gray('  Build first with: doswiftly template build\n'));
+        process.exit(1);
+    }
+    const workerBuffer = readFileSync(workerPath);
+    const sizeKB = (workerBuffer.length / 1024).toFixed(1);
+    console.log(chalk.gray(`  Template: ${chalk.cyan(templateName)}`));
+    console.log(chalk.gray(`  Version:  ${chalk.cyan(version)}`));
+    console.log(chalk.gray(`  Bundle:   ${workerPath} (${sizeKB} KB)`));
+    console.log('');
+    // Upload to API
+    const spinner = ora('Uploading bundle to R2...').start();
+    try {
+        // Use FormData for multipart upload
+        const FormData = (await import('form-data')).default;
+        const formData = new FormData();
+        formData.append('bundle', workerBuffer, {
+            filename: 'worker.js',
+            contentType: 'application/javascript',
+        });
+        formData.append('version', version);
+        // Get OpenNext version from manifest if available
+        try {
+            const openNextManifestPath = '.open-next/open-next.output.json';
+            if (existsSync(openNextManifestPath)) {
+                const openNextManifest = JSON.parse(readFileSync(openNextManifestPath, 'utf-8'));
+                if (openNextManifest.version) {
+                    formData.append('openNextVersion', openNextManifest.version);
+                }
+            }
+        }
+        catch {
+            // Non-critical
+        }
+        // Get Node.js version
+        formData.append('nodeVersion', process.version);
+        // Make API request with multipart form data
+        const client = createSharedApiClient({ requireShopSlug: false });
+        const response = await client.request({
+            url: `/cli/templates/${encodeURIComponent(templateName)}/publish`,
+            method: 'POST',
+            data: formData,
+            headers: formData.getHeaders(),
+            maxContentLength: Infinity,
+            maxBodyLength: Infinity,
+        });
+        spinner.succeed('Bundle uploaded successfully');
+        const result = response.data;
+        console.log(chalk.gray(`\n  Bundle key: ${result.bundleKey}`));
+        console.log(chalk.gray(`  Size: ${(result.bundleSize / 1024).toFixed(1)} KB`));
+        console.log(chalk.gray(`  Uploaded: ${new Date(result.uploadedAt).toLocaleString()}`));
+        console.log(chalk.green('\n  ✓ Bundle ready for deployment!'));
+        console.log(chalk.gray('  Deploy from Admin Panel: Template Registry → Deploy to Cloudflare\n'));
+    }
+    catch (error) {
+        spinner.fail('Failed to upload bundle');
+        // Extract meaningful error message
+        if (error && typeof error === 'object' && 'response' in error) {
+            const axiosError = error;
+            const serverMessage = axiosError.response?.data?.message;
+            if (serverMessage) {
+                console.log(chalk.red(`\n  ${serverMessage}\n`));
+            }
+            else {
+                console.log(chalk.red(`\n  ${axiosError.message || 'Unknown error'}\n`));
+            }
+        }
+        else {
+            console.log(chalk.red(`\n  ${error.message}\n`));
+        }
+        process.exit(1);
+    }
+}
+/**
+ * Get information about the uploaded bundle and deployment status.
+ */
+export async function templateBundleInfoCommand(nameOrId) {
+    console.log(chalk.bold.blue('\nDoSwiftly CLI - Template Bundle Info\n'));
+    // Auto-detect from manifest if not provided
+    const manifest = readTemplateManifest();
+    const resolvedName = nameOrId || manifest?.name || null;
+    if (!resolvedName) {
+        console.log(chalk.red('  Error: Template name required.'));
+        console.log(chalk.gray('  Provide name as argument or run from a directory with doswiftly-template.json\n'));
+        process.exit(1);
+    }
+    const spinner = ora(`Fetching bundle info for '${resolvedName}'...`).start();
+    try {
+        const info = await apiRequest(`/cli/templates/${encodeURIComponent(resolvedName)}/bundle`);
+        spinner.stop();
+        console.log(`  ${chalk.bold('Template:')}   ${chalk.cyan(resolvedName)}`);
+        console.log('');
+        if (!info.hasBundleInR2) {
+            console.log(chalk.yellow('  No bundle uploaded yet.'));
+            console.log(chalk.gray('\n  Build and upload with:'));
+            console.log(chalk.cyan('    doswiftly template build'));
+            console.log(chalk.cyan('    doswiftly template upload\n'));
+            return;
+        }
+        console.log(chalk.bold('  R2 Bundle:'));
+        console.log(`    Version:  ${info.bundleVersion}`);
+        console.log(`    Size:     ${info.bundleSize ? (info.bundleSize / 1024).toFixed(1) + ' KB' : '-'}`);
+        console.log(`    Uploaded: ${info.bundleUploadedAt ? new Date(info.bundleUploadedAt).toLocaleString() : '-'}`);
+        console.log('');
+        console.log(chalk.bold('  Cloudflare Workers:'));
+        if (info.isDeployedToCloudflare) {
+            console.log(chalk.green(`    Status:   Deployed`));
+            console.log(`    Version:  ${info.deployedVersion}`);
+            if (info.needsRedeploy) {
+                console.log(chalk.yellow(`    Note:     Bundle updated, redeploy needed`));
+            }
+        }
+        else {
+            console.log(chalk.yellow(`    Status:   Not deployed`));
+            console.log(chalk.gray('    Deploy from Admin Panel: Template Registry → Deploy to Cloudflare'));
+        }
+        console.log('');
+    }
+    catch (error) {
+        spinner.fail('Failed to fetch bundle info');
+        console.log(chalk.red(`\n${error.message}\n`));
+        process.exit(1);
+    }
+}
+/**
+ * Setup or retry Cloudflare Workers Builds for a template.
+ * Connects the template's GitHub repo to CF Builds for auto-deploy on push.
+ */
+export async function templateSetupBuildsCommand(nameOrId) {
+    requireSaasDeveloperRole();
+    console.log(chalk.bold.blue('\nDoSwiftly CLI - Setup CF Workers Builds\n'));
+    // Auto-detect from manifest if not provided
+    const manifest = readTemplateManifest();
+    const resolvedName = nameOrId || manifest?.name || null;
+    if (!resolvedName) {
+        console.log(chalk.red('  Error: Template name required.'));
+        console.log(chalk.gray('  Provide name as argument or run from a directory with doswiftly-template.json\n'));
+        process.exit(1);
+    }
+    const spinner = ora(`Setting up CF Builds for '${resolvedName}'...`).start();
+    try {
+        const result = await apiRequest(`/cli/templates/${encodeURIComponent(resolvedName)}/setup-builds`, { method: 'POST' });
+        if (result.success) {
+            spinner.succeed('CF Workers Builds configured!');
+            console.log(chalk.gray(`\n  Worker: ${result.workerName}`));
+            console.log(chalk.gray('  Auto-deploy: pushes to main/master trigger build + deploy'));
+            console.log(chalk.gray('\n  Changes will be auto-deployed on push. No manual build/upload needed.\n'));
+        }
+        else {
+            spinner.fail('CF Builds setup failed');
+            console.log(chalk.red(`\n  ${result.error || 'Unknown error'}\n`));
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        spinner.fail('Failed to setup CF Builds');
+        console.log(chalk.red(`\n${error.message}\n`));
+        process.exit(1);
+    }
+}
+//# sourceMappingURL=template.js.map