@brightsideoy/kama 0.1.0-alpha.16 → 0.1.0-alpha.161

package/bin/cli.js

@@ -1,119 +1,423 @@
 #!/usr/bin/env node
-import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
+import { execSync } from 'node:child_process';
+import { existsSync, mkdirSync, writeFileSync, readFileSync, readdirSync, cpSync, unlinkSync, appendFileSync } from 'node:fs';
+import { join, dirname, basename, resolve } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
 import * as readline from 'node:readline/promises';
 
+// 🎯 Always use the absolute newest ecosystem
+const ASTRO_LATEST = "latest";
+const ASTRO_NODE_LATEST = "latest";
+const ASTRO_CF_LATEST = "latest";
+const WRANGLER_LATEST = "latest";
+
+// Dynamically resolve current package version
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+let currentKamaVersion = 'alpha';
+try {
+    const pkgPath = join(__dirname, '../package.json');
+    if (existsSync(pkgPath)) {
+        const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+        if (pkg.version) currentKamaVersion = `^${pkg.version}`;
+    }
+} catch (e) {
+    console.warn("⚠️ Could not detect Kama version, defaulting to 'alpha'");
+}
+
 const rl = readline.createInterface({
     input: process.stdin,
     output: process.stdout,
 });
 
+function showHelp() {
+    console.log('\n🔥 --- KAMA ENGINE CLI --- 🔥\n');
+    console.log('Usage: npx kama <command> [options]\n');
+    console.log('Commands:');
+    console.log('  init         Kickstart a new Monorepo (CMS Worker + Optional Astro Site)');
+    console.log('  add site     Add a new Astro Frontend Site to the current workspace (sites/)');
+    console.log('  bundle       Compile and bundle YAML schemas into bundled-definitions.js for Edge deployment');
+    console.log('  promote      Promote the current Local workspace to Cloudflare Edge');
+    console.log('  help, -h     Show this help message\n');
+
+    console.log('Workspace Scripts (Run from project root):');
+    console.log('  npm update           Update to latest KAMA version');
+    console.log('  npm run dev          Boot up the CMS backend and Astro frontend concurrently');
+    console.log('  npm run deploy:cms   Deploy the backend worker and database to Cloudflare');
+    console.log('  npm run deploy:site  Deploy the Astro frontend site to Cloudflare\n');
+
+    console.log('Examples:');
+    console.log('  npx kama init');
+    console.log('  npx kama add site');
+    console.log('  npx kama bundle\n');
+}
+
 async function main() {
-    console.log('\n🔥 --- KAMA SITE GENERATOR --- 🔥\n');
+    const args = process.argv.slice(2);
+    const command = args[0]?.toLowerCase();
+    const subCommand = args[1]?.toLowerCase();
 
-    console.log('Select mode:');
-    console.log('  1) Kickstart new Kama Monorepo (CMS + Initial Site)');
-    console.log('  2) Add a new Astro Site to current workspace (sites/)');
+    if (command === 'help' || command === '--help' || command === '-h') {
+        showHelp();
+        rl.close();
+        process.exit(0);
+    }
 
-    const choice = await rl.question('\nChoice [1/2]: ');
+    console.log('\n🔥 --- KAMA ENGINE CLI --- 🔥\n');
 
-    if (choice.trim() === '2') {
+    if (command === 'init') {
+        await createFullWorkspace();
+    } else if (command === 'add' && subCommand === 'site') {
         await createNewSiteOnly();
+    } else if (command === 'promote') {
+        await promoteLocalToCloudflare();
+    } else if (command === 'bundle') {
+        await bundleWorkspaceSchemas();
     } else {
-        await createFullWorkspace();
+        console.log('Available Commands:');
+        console.log('  1) npx kama init         - Kickstart new Monorepo (CMS + Optional Site)');
+        console.log('  2) npx kama add site     - Add new Astro Site to current workspace (sites/)');
+        console.log('  3) npx kama bundle       - Compile and bundle YAML schemas for Edge deployment');
+        console.log('  4) npx kama promote      - Promote current Local workspace to Cloudflare Edge');
+        console.log('  5) Help                  - Show all commands and usage');
+
+        const choice = (await rl.question('\nSelect choice [1/2/3/4/5]: ')).trim();
+
+        if (choice === '5') {
+            showHelp();
+        } else if (choice === '4') {
+            await promoteLocalToCloudflare();
+        } else if (choice === '3') {
+            await bundleWorkspaceSchemas();
+        } else if (choice === '2') {
+            await createNewSiteOnly();
+        } else {
+            await createFullWorkspace();
+        }
     }
 
     rl.close();
 }
 
 /**
- * MODE 1: Kickstart full Monorepo Workspace
+ * Helper to update astro.config.mjs for Cloudflare
+ */
+function convertAstroConfigToCloudflare(siteDir) {
+    const configPath = join(siteDir, 'astro.config.mjs');
+    if (existsSync(configPath)) {
+        let content = readFileSync(configPath, 'utf-8');
+        content = content
+            .replace("import node from '@astrojs/node';", "import cloudflare from '@astrojs/cloudflare';")
+            .replace('adapter: node({ mode: "standalone" })', 'adapter: cloudflare({ imageService: process.env.NODE_ENV === "production" ? "cloudflare" : "passthrough" })');
+        writeFileSync(configPath, content, 'utf-8');
+    }
+}
+
+/**
+ * COMMAND: npx kama init
+ * Kickstart full Monorepo Workspace
  */
 async function createFullWorkspace() {
-    const projName = (await rl.question('Project folder name [kama-network]: ')) || 'kama-network';
-    const cmsDomain = (await rl.question('CMS Admin Domain [kama.t3cloud.eu]: ')) || 'kama.t3cloud.eu';
-    const siteDomain = (await rl.question('First Website Domain [demo.t3cloud.eu]: ')) || 'demo.t3cloud.eu';
+    const cwdName = basename(process.cwd());
+    const hasExistingPkg = existsSync(join(process.cwd(), 'package.json'));
+
+    const defaultDirPrompt = hasExistingPkg ? '.' : cwdName;
+    const inputName = await rl.question(`Project folder name (use '.' for current dir) [${defaultDirPrompt}]: `);
+
+    const chosenFolder = inputName.trim() || defaultDirPrompt;
+    const isCurrentDir = chosenFolder === '.';
 
-    const rootDir = join(process.cwd(), projName);
+    const projName = isCurrentDir ? cwdName : chosenFolder;
+    const rootDir = isCurrentDir ? process.cwd() : join(process.cwd(), projName);
 
-    console.log(`\n📁 Creating workspace folder at ./${projName}...`);
-    mkdirSync(rootDir, { recursive: true });
+    console.log('\n🌍 Choose your Deployment Architecture:');
+    console.log('  1) VPS / Local Server (Node.js, SQLite, Sharp cropping)');
+    console.log('  2) Cloudflare Edge (Workers, D1, R2, CF Image Resizing)');
+    const envChoice = await rl.question('\nChoice [1/2]: ');
+    const isCloudflare = envChoice.trim() === '2';
+
+    const createSiteInput = await rl.question('\n🚀 Do you want to scaffold an initial Astro frontend site? (y/n) [y]: ');
+    const shouldCreateSite = createSiteInput.trim().toLowerCase() !== 'n';
+
+    let siteFolderName = 'kama-starter';
+    let siteDomain = 'localhost:4321';
+    let cmsDomain = 'localhost:8787';
+
+    if (shouldCreateSite) {
+        siteFolderName = (await rl.question('Astro package/folder name (e.g., my-website) [kama-starter]: ')).trim() || 'kama-starter';
+    }
+
+    if (isCloudflare) {
+        cmsDomain = (await rl.question('\nCMS Admin Domain (e.g., admin.yourdomain.com): ')).trim();
+        if (shouldCreateSite) {
+            siteDomain = (await rl.question('First Website Domain (e.g., yourdomain.com): ')).trim();
+        }
+    }
+
+    const cmsProtocol = isCloudflare ? 'https://' : 'http://';
+    const cmsFullUrl = cmsDomain ? `${cmsProtocol}${cmsDomain.replace(/^https?:\/\//, '')}` : 'http://localhost:8787';
+
+    const workerName = `${projName}-worker`.toLowerCase().replace(/[^a-z0-9_-]/g, '-');
+    let dbName = `${projName}-db`.replace(/[^a-zA-Z0-9_-]/g, '_');
+    const bucketName = `${projName}-media-prod`.toLowerCase().replace(/[^a-z0-9_-]/g, '-');
+
+    if (!isCurrentDir) {
+        console.log(`\n📁 Creating workspace folder at ./${projName}...`);
+        mkdirSync(rootDir, { recursive: true });
+    } else {
+        console.log(`\n📁 Initializing workspace in current directory (${rootDir})...`);
+    }
 
-    // 1. Root package.json
     writeFileSync(
-        join(rootDir, 'package.json'),
-        JSON.stringify({
-            name: projName,
-            private: true,
-            type: 'module',
-            workspaces: ['cms-worker', 'sites/*'],
-            scripts: {
-                'dev:cms': 'npm run dev -w cms-worker',
-                'deploy:cms': 'npm run deploy -w cms-worker',
-            },
-        }, null, 2)
+        join(rootDir, '.gitignore'),
+        `node_modules/\n.env\n.DS_Store\nkama-worker/.dev.vars\nkama-worker/.env\nkama-worker/.wrangler/\nkama-worker/public/\nkama-worker/*.db\nsites/*/.env\nsites/*/.astro/\nsites/*/dist/\nkama-worker/bundled-definitions.js\n`
     );
 
-    // 2. Setup CMS Worker
-    console.log(`\n☁️ Configuring CMS Worker (${cmsDomain})...`);
-    const cmsDir = join(rootDir, 'cms-worker');
+    console.log(`\n📄 Copying default content definitions...`);
+    const sourceDefsDir = join(__dirname, '../content/definitions');
+    const targetDefsDir = join(rootDir, 'content', 'definitions');
+    if (existsSync(sourceDefsDir)) {
+        cpSync(sourceDefsDir, targetDefsDir, { recursive: true });
+    } else {
+        console.warn(`⚠️ Could not find default content definitions at ${sourceDefsDir}`);
+    }
+
+    let d1DatabaseId = '00000000-0000-0000-0000-000000000000';
+    let isAuthenticated = false;
+
+    if (isCloudflare) {
+        console.log(`\n🔑 Checking Cloudflare authentication...`);
+        try {
+            // Pass stdio: 'ignore' so child process doesn't drain parent stdin stream!
+            execSync('npx wrangler whoami', { stdio: 'ignore' });
+            isAuthenticated = true;
+            console.log(`✅ Logged in to Cloudflare.`);
+        } catch (error) {
+            console.log(`⚠️ You are not logged in to Cloudflare.`);
+            console.log(`🌐 Launching browser for Cloudflare login...`);
+            try {
+                execSync('npx wrangler login', { stdio: 'ignore' });
+                isAuthenticated = true;
+                console.log(`✅ Successfully logged in!`);
+            } catch (loginError) {
+                console.log(`❌ Login failed or was cancelled.`);
+            }
+        }
+
+        if (isAuthenticated) {
+            try {
+                console.log(`\n🗄️ Checking existing Cloudflare D1 databases...`);
+                const listOutput = execSync(`npx wrangler d1 list --json`, { encoding: 'utf-8', stdio: ['ignore', 'pipe', 'pipe'] });
+                const jsonStart = listOutput.indexOf('[');
+                const jsonEnd = listOutput.lastIndexOf(']') + 1;
+                let databases = [];
+
+                if (jsonStart !== -1 && jsonEnd !== -1) {
+                    databases = JSON.parse(listOutput.substring(jsonStart, jsonEnd));
+                }
+
+                const existingDb = databases.find(db => db.name === dbName);
+
+                if (existingDb) {
+                    console.log(`⚠️ Database '${dbName}' already exists on your account.`);
+                    const useExisting = await rl.question(`Do you want to link this existing database? (y/n) [y]: `);
+
+                    if (useExisting.toLowerCase() !== 'n') {
+                        d1DatabaseId = existingDb.uuid;
+                        console.log(`✅ Linked existing database ID: ${d1DatabaseId}`);
+                    } else {
+                        dbName = (await rl.question(`Enter a new database name: `)).trim();
+                        console.log(`\n🗄️ Creating new database '${dbName}'...`);
+                        const d1Output = execSync(`npx wrangler d1 create ${dbName}`, { encoding: 'utf-8', stdio: ['ignore', 'pipe', 'pipe'] });
+                        const match = d1Output.match(/[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}/);
+                        if (match) {
+                            d1DatabaseId = match[0];
+                            console.log(`✅ Success! Database ID bound: ${d1DatabaseId}`);
+                        }
+                    }
+                } else {
+                    console.log(`\n🗄️ Attempting to auto-create Cloudflare D1 Database '${dbName}'...`);
+                    const d1Output = execSync(`npx wrangler d1 create ${dbName}`, { encoding: 'utf-8', stdio: ['ignore', 'pipe', 'pipe'] });
+                    const match = d1Output.match(/[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}/);
+                    if (match) {
+                        d1DatabaseId = match[0];
+                        console.log(`✅ Success! Database ID bound: ${d1DatabaseId}`);
+                    }
+                }
+            } catch (error) {
+                console.log(`⚠️ Database operation failed. We'll leave a placeholder.`);
+            }
+        } else {
+            console.log(`⚠️ Skipping database creation. We'll leave a placeholder in wrangler.json.`);
+        }
+    } else {
+        console.log(`\n💻 Local VPS mode selected. Skipping Cloudflare authentication and domain setup...`);
+    }
+
+    const rootScripts = {
+        'dev:cms': 'npm run dev -w kama-worker',
+        'deploy:cms': 'npm run deploy -w kama-worker',
+    };
+
+    const rootPkg = {
+        name: projName,
+        private: true,
+        type: 'module',
+        workspaces: ['kama-worker', 'sites/*'],
+        scripts: rootScripts,
+        dependencies: {
+            '@brightsideoy/kama': currentKamaVersion,
+        },
+        devDependencies: {}
+    };
+
+    if (isCloudflare) {
+        rootPkg.devDependencies['wrangler'] = WRANGLER_LATEST;
+    }
+
+    if (shouldCreateSite) {
+        rootPkg.devDependencies['concurrently'] = '^9.0.0';
+        rootPkg.scripts['dev:site'] = `npm run dev -w sites/${siteFolderName}`;
+        rootPkg.scripts['predev'] = 'npx kama bundle';
+        rootPkg.scripts['dev'] = 'npx concurrently "npm run dev:cms" "npm run dev:site"';
+        rootPkg.scripts['deploy:site'] = `npm run deploy -w sites/${siteFolderName}`;
+    } else {
+        rootPkg.scripts['predev'] = 'npx kama bundle';
+        rootPkg.scripts['dev'] = 'npm run dev:cms';
+    }
+
+    writeFileSync(join(rootDir, 'package.json'), JSON.stringify(rootPkg, null, 2));
+
+    console.log(`\n☁️ Configuring CMS Worker '${workerName}' (${cmsDomain || 'localhost:8787'})...`);
+    const cmsDir = join(rootDir, 'kama-worker');
     mkdirSync(cmsDir, { recursive: true });
 
-    writeFileSync(
-        join(cmsDir, 'package.json'),
-        JSON.stringify({
-            name: 'kama-worker',
-            type: 'module',
-            version: '1.0.0',
-            scripts: {
-                dev: 'wrangler dev',
-                deploy: 'wrangler deploy',
-            },
-            dependencies: {
-                '@brightsideoy/kama': 'latest',
-            },
-            devDependencies: {
-                wrangler: '^4.127.1',
-                tsx: '^4.19.2',
-            },
-        }, null, 2)
-    );
+    writeFileSync(join(cmsDir, 'seed.sql'), '-- Kama Auto-Generated Seed File\nSELECT 1;\n');
 
-    writeFileSync(
-        join(cmsDir, 'wrangler.json'),
-        JSON.stringify({
-            $schema: 'node_modules/wrangler/config-schema.json',
-            name: 'kama-worker',
-            main: 'node_modules/@brightsideoy/kama/dist/index.js',
-            compatibility_date: '2026-08-01',
+    const emptyDefs = `{ nodes: {}, trees: {}, blocks: {}, nodeLayouts: {}, blockLayouts: {}, channels: {} }`;
+    writeFileSync(join(cmsDir, 'bundled-definitions.js'), `const defs = ${emptyDefs};\nexport const BUNDLED_DEFINITIONS = defs;\nexport default defs;\n`);
+
+    if (isCloudflare) {
+        const templateIndexPath = join(__dirname, '../templates/kama-worker/index.js');
+        if (existsSync(templateIndexPath)) {
+            cpSync(templateIndexPath, join(cmsDir, 'index.js'));
+        }
+
+        writeFileSync(
+            join(cmsDir, 'package.json'),
+            JSON.stringify({
+                name: workerName,
+                type: 'module',
+                version: '1.0.0',
+                scripts: {
+                    "schema:local": `wrangler d1 execute ${dbName} --local --file=../node_modules/@brightsideoy/kama/schema.sql > /dev/null 2>&1`,
+                    "schema:remote": `wrangler d1 execute ${dbName} --remote --file=../node_modules/@brightsideoy/kama/schema.sql`,
+                    "seed:local": `wrangler d1 execute ${dbName} --local --file=seed.sql > /dev/null 2>&1`,
+                    "seed:remote": `wrangler d1 execute ${dbName} --remote --file=seed.sql`,
+                    "dev": "npm run schema:local && npm run seed:local && wrangler dev --port 8787 --inspector-port 9239",
+                    "deploy": "npm run schema:remote && npm run seed:remote && wrangler deploy"
+                },
+                dependencies: {
+                    '@brightsideoy/kama': currentKamaVersion,
+                    '@libsql/client': '^0.14.0'
+                },
+                devDependencies: {
+                    "wrangler": WRANGLER_LATEST
+                },
+            }, null, 2)
+        );
+
+        const cmsWranglerConfig = {
+            $schema: '../node_modules/wrangler/config-schema.json',
+            name: workerName,
+            main: 'index.js',
+            compatibility_date: '2024-09-23',
             compatibility_flags: ['nodejs_compat'],
-            assets: { directory: './dist', binding: 'ASSETS' },
-            routes: [{ pattern: cmsDomain, custom_domain: true }],
-            vars: { CDN_DOMAIN: cmsDomain },
-            d1_databases: [{
-                binding: 'DB',
-                database_name: 'kama_cms_db',
-                database_id: 'REPLACE_WITH_YOUR_D1_ID',
-            }],
-            r2_buckets: [{
-                binding: 'MEDIA_BUCKET',
-                bucket_name: 'kama-media-prod',
-            }],
-        }, null, 2)
-    );
+            dev: { host: 'localhost', port: 8787 },
+            cache: { enabled: true },
+            assets: { directory: '../node_modules/@brightsideoy/kama/dist', binding: 'ASSETS' },
+            images: { binding: 'IMAGES' },
+            vars: {
+                CDN_DOMAIN: cmsDomain || 'localhost:8787',
+                PUBLIC_FRONTEND_URL: (shouldCreateSite) ? (siteDomain && siteDomain !== 'localhost:4321' ? `https://${siteDomain}` : 'http://localhost:4321') : 'http://localhost:4321',
+                CLOUDFLARE_ZONE_ID: "REPLACE_WITH_YOUR_32_CHAR_ZONE_ID",
+                KAMA_RUNTIME: 'cloudflare'
+            },
+            d1_databases: [{ binding: 'DB', database_name: dbName, database_id: d1DatabaseId }],
+            r2_buckets: [{ binding: 'MEDIA_BUCKET', bucket_name: bucketName }],
+            routes: cmsDomain ? [{ pattern: cmsDomain, custom_domain: true }] : [{ pattern: "", custom_domain: true }]
+        };
+
+        writeFileSync(join(cmsDir, 'wrangler.json'), JSON.stringify(cmsWranglerConfig, null, 2));
 
-    // 3. Setup First Astro Site
-    const siteFolderName = siteDomain.split('.')[0]; // e.g. "demo" from "demo.t3cloud.eu"
-    await generateAstroSite(rootDir, siteFolderName, siteDomain, cmsDomain);
+        writeFileSync(join(cmsDir, '.dev.vars'), `# Cloudflare Edge Cache Purging Secrets
+CLOUDFLARE_API_TOKEN=cfut_YOUR_CUSTOM_PURGE_TOKEN
+
+# Local Development Overrides
+CDN_DOMAIN=
+PUBLIC_FRONTEND_URL=http://localhost:4321
+`);
+    } else {
+        const templateServerPath = join(__dirname, '../templates/kama-worker/server.js');
+        if (existsSync(templateServerPath)) {
+            cpSync(templateServerPath, join(cmsDir, 'server.js'));
+        }
+
+        writeFileSync(
+            join(cmsDir, 'package.json'),
+            JSON.stringify({
+                name: workerName,
+                type: 'module',
+                version: '1.0.0',
+                scripts: {
+                    "schema:local": "sqlite3 kama.db < ../node_modules/@brightsideoy/kama/schema.sql",
+                    "seed:local": "sqlite3 kama.db < seed.sql",
+                    "dev": "npm run schema:local && npm run seed:local && tsx server.js",
+                    "start": "node server.js"
+                },
+                dependencies: {
+                    '@brightsideoy/kama': currentKamaVersion,
+                    '@hono/node-server': '^1.13.0',
+                    '@libsql/client': '^0.14.0',
+                    'sharp': '^0.33.5',
+                    'dotenv': '^16.4.5'
+                },
+                devDependencies: {
+                    "tsx": "^4.19.0"
+                },
+            }, null, 2)
+        );
+
+        writeFileSync(join(cmsDir, '.env'), `PORT=8787\nKAMA_RUNTIME=node\nDB_PATH=./kama.db\nLOCAL_MEDIA_PATH=./public/media\nPUBLIC_CMS_URL=http://127.0.0.1:8787\nPUBLIC_API_URL=http://127.0.0.1:8787\nPUBLIC_FRONTEND_URL=http://127.0.0.1:4321\n`);
+    }
+
+    await bundleWorkspaceSchemas(rootDir);
+
+    if (shouldCreateSite) {
+        await generateAstroSite(rootDir, siteFolderName, siteDomain, cmsFullUrl, workerName, isCloudflare);
+    } else {
+        console.log(`\nℹ️ Skipping Astro site creation. You can add a site later by running 'npx kama add site' inside this workspace.`);
+    }
 
     console.log(`\n✨ Workspace ready! Next steps:`);
-    console.log(`  1. cd ${projName}`);
+    if (!isCurrentDir) console.log(`  1. cd ${projName}`);
     console.log(`  2. npm install`);
-    console.log(`  3. Update D1 ID in cms-worker/wrangler.json`);
+
+    if (isCloudflare) {
+        if (d1DatabaseId === '00000000-0000-0000-0000-000000000000') {
+            console.log(`  3. Run 'npx wrangler login' and create a D1 database manually.`);
+        }
+        console.log(`  4. Update CLOUDFLARE_ZONE_ID in kama-worker/wrangler.json`);
+        console.log(`  5. Securely store your purge token: cd kama-worker && npx wrangler secret put CLOUDFLARE_API_TOKEN`);
+        console.log(`  6. Run 'npm run dev' from the workspace root to start everything.`);
+    } else {
+        console.log(`  3. Run 'npm run dev' from the workspace root to start the local backend and frontend.`);
+        console.log(`\n💡 Note: You can deploy to Cloudflare later by running 'npx kama promote'.`);
+    }
 }
 
 /**
- * MODE 2: Add Site to existing workspace
+ * COMMAND: npx kama add site
  */
 async function createNewSiteOnly() {
     const rootDir = process.cwd();
@@ -123,96 +427,323 @@ async function createNewSiteOnly() {
         return;
     }
 
-    const siteFolder = await rl.question('Site folder name (e.g., site-two): ');
-    const siteDomain = await rl.question('Website Domain (e.g., brand.com): ');
-    const cmsDomain = (await rl.question('CMS API Domain [kama.t3cloud.eu]: ')) || 'kama.t3cloud.eu';
+    let targetWorkerName = 'kama-worker';
+    let detectedCmsDomain = '';
+
+    const cmsWranglerPath = join(rootDir, 'kama-worker', 'wrangler.json');
+    if (existsSync(cmsWranglerPath)) {
+        try {
+            const cmsWrangler = JSON.parse(readFileSync(cmsWranglerPath, 'utf-8'));
+            if (cmsWrangler.name) targetWorkerName = cmsWrangler.name;
+            if (cmsWrangler.vars?.CDN_DOMAIN) detectedCmsDomain = cmsWrangler.vars.CDN_DOMAIN;
+            else if (cmsWrangler.routes?.[0]?.pattern) detectedCmsDomain = cmsWrangler.routes[0].pattern;
+        } catch (e) { }
+    }
+
+    console.log('\n🌍 Deployment Mode:');
+    console.log('  1) VPS / Local Server (Node.js)');
+    console.log('  2) Cloudflare Edge');
+    const envChoice = await rl.question('\nChoice [1/2]: ');
+    const isCloudflare = envChoice.trim() === '2';
+
+    const siteFolder = (await rl.question('Astro package/folder name (e.g., my-new-site) [kama-starter]: ')).trim() || 'kama-starter';
+    let siteDomain = 'localhost:4321';
+    let cmsFullUrl = 'http://localhost:8787';
+
+    if (isCloudflare) {
+        siteDomain = (await rl.question('Website Domain (e.g., brand.com): ')).trim();
+        if (detectedCmsDomain) {
+            cmsFullUrl = detectedCmsDomain.startsWith('http') ? detectedCmsDomain : `https://${detectedCmsDomain.replace(/^https?:\/\//, '')}`;
+        } else {
+            const cmsDomainInput = (await rl.question('CMS API Domain (e.g., admin.brand.com): ')).trim();
+            cmsFullUrl = `https://${cmsDomainInput.replace(/^https?:\/\//, '')}`;
+        }
+    }
+
+    await generateAstroSite(rootDir, siteFolder, siteDomain, cmsFullUrl, targetWorkerName, isCloudflare);
+
+    console.log(`\n✨ Site created in sites/${siteFolder}!`);
+    console.log(`📦 Run 'npm install' at workspace root.`);
+}
+
+/**
+ * COMMAND: npx kama bundle
+ */
+async function bundleWorkspaceSchemas(targetRootDir) {
+    let rootDir = targetRootDir || process.cwd();
+    if (basename(rootDir) === 'kama-worker') rootDir = resolve(rootDir, '..');
+
+    try {
+        let compilerPath = join(__dirname, '../dist/schema-compiler.js');
+        if (!existsSync(compilerPath)) compilerPath = join(__dirname, '../scripts/schema-compiler.ts');
+        await import(pathToFileURL(compilerPath).href);
+    } catch (e) {
+        console.error(`❌ Schema compilation failed:`, e.message || e);
+    }
+}
+
+/**
+ * COMMAND: npx kama promote
+ */
+async function promoteLocalToCloudflare() {
+    const rootDir = process.cwd();
+    const workerDir = join(rootDir, 'kama-worker');
+    const rootPkgPath = join(rootDir, 'package.json');
+
+    if (!existsSync(workerDir) || !existsSync(rootPkgPath)) {
+        console.error('❌ Error: Could not find kama-worker folder or package.json. Run this command inside your workspace root.');
+        return;
+    }
+
+    console.log('\n🌐 --- UPGRADING WORKSPACE TO CLOUDFLARE EDGE --- 🌐\n');
+
+    try {
+        execSync('npx wrangler whoami', { stdio: 'ignore' });
+        console.log('✅ Logged in to Cloudflare.');
+    } catch (e) {
+        console.log('🌐 Launching browser for Cloudflare login...');
+        try { execSync('npx wrangler login', { stdio: 'ignore' }); }
+        catch (loginError) { console.log('❌ Cloudflare login failed.'); return; }
+    }
+
+    const cmsDomain = (await rl.question('\nCMS Admin Domain (e.g., admin.yourdomain.com): ')).trim();
+
+    const sitesFolderDir = join(rootDir, 'sites');
+    let siteDomain = '';
+    let siteDir = null;
+    if (existsSync(sitesFolderDir)) {
+        const sites = readdirSync(sitesFolderDir);
+        if (sites.length > 0) {
+            siteDir = join(sitesFolderDir, sites[0]);
+            siteDomain = (await rl.question('Frontend Website Domain (e.g., yourdomain.com): ')).trim();
+        }
+    }
+
+    const projName = basename(rootDir);
+    let dbName = `${projName}-db`.replace(/[^a-zA-Z0-9_-]/g, '_');
+    let d1DatabaseId = '00000000-0000-0000-0000-000000000000';
+
+    try {
+        const d1Output = execSync(`npx wrangler d1 create ${dbName}`, { encoding: 'utf-8', stdio: ['ignore', 'pipe', 'pipe'] });
+        const match = d1Output.match(/[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}/);
+        if (match) d1DatabaseId = match[0];
+    } catch (err) { }
+
+    const rootPkg = JSON.parse(readFileSync(rootPkgPath, 'utf-8'));
+    rootPkg.devDependencies = rootPkg.devDependencies || {};
+    rootPkg.devDependencies['wrangler'] = WRANGLER_LATEST;
+    writeFileSync(rootPkgPath, JSON.stringify(rootPkg, null, 2));
+
+    const workerName = `${projName}-worker`.toLowerCase().replace(/[^a-z0-9_-]/g, '-');
+    const bucketName = `${projName}-media-prod`.toLowerCase().replace(/[^a-z0-9_-]/g, '-');
+    const workerWranglerPath = join(workerDir, 'wrangler.json');
+
+    let currentConfig = existsSync(workerWranglerPath)
+        ? JSON.parse(readFileSync(workerWranglerPath, 'utf-8'))
+        : {
+            $schema: '../node_modules/wrangler/config-schema.json',
+            name: workerName,
+            main: 'index.js',
+            compatibility_date: '2024-09-23',
+            compatibility_flags: ['nodejs_compat'],
+            assets: { directory: '../node_modules/@brightsideoy/kama/dist', binding: 'ASSETS' },
+            images: { binding: 'IMAGES' },
+            vars: { CLOUDFLARE_ZONE_ID: "REPLACE_WITH_YOUR_32_CHAR_ZONE_ID", KAMA_RUNTIME: 'cloudflare' }
+        };
+
+    currentConfig.dev = currentConfig.dev || { host: 'localhost', port: 8787 };
+    currentConfig.cache = { enabled: true };
+    currentConfig.vars.CDN_DOMAIN = cmsDomain;
+    if (siteDomain) currentConfig.vars.PUBLIC_FRONTEND_URL = `https://${siteDomain}`;
+    currentConfig.routes = [{ pattern: cmsDomain, custom_domain: true }];
+    currentConfig.d1_databases = [{ binding: 'DB', database_name: dbName, database_id: d1DatabaseId }];
+    currentConfig.r2_buckets = [{ binding: 'MEDIA_BUCKET', bucket_name: bucketName }];
+
+    writeFileSync(workerWranglerPath, JSON.stringify(currentConfig, null, 2));
+
+    if (!existsSync(join(workerDir, '.dev.vars'))) {
+        writeFileSync(join(workerDir, '.dev.vars'), `CLOUDFLARE_API_TOKEN=cfut_YOUR_CUSTOM_PURGE_TOKEN\nCDN_DOMAIN=\nPUBLIC_FRONTEND_URL=http://localhost:4321\n`);
+    }
+
+    const workerIndexPath = join(workerDir, 'index.js');
+    if (!existsSync(workerIndexPath)) {
+        const templateIndexPath = join(__dirname, '../templates/kama-worker/index.js');
+        if (existsSync(templateIndexPath)) {
+            cpSync(templateIndexPath, workerIndexPath);
+        }
+    }
+
+    const workerPkgPath = join(workerDir, 'package.json');
+    if (existsSync(workerPkgPath)) {
+        const workerPkg = JSON.parse(readFileSync(workerPkgPath, 'utf-8'));
+        workerPkg.scripts.dev = "npm run schema:local && npm run seed:local && wrangler dev --port 8787 --inspector-port 9239";
+        workerPkg.scripts.deploy = "npm run schema:remote && npm run seed:remote && wrangler deploy";
+        workerPkg.scripts["schema:remote"] = `wrangler d1 execute ${dbName} --remote --file=../node_modules/@brightsideoy/kama/schema.sql`;
+        workerPkg.scripts["seed:remote"] = `wrangler d1 execute ${dbName} --remote --file=seed.sql`;
+        workerPkg.devDependencies = workerPkg.devDependencies || {};
+        workerPkg.devDependencies.wrangler = WRANGLER_LATEST;
+        writeFileSync(workerPkgPath, JSON.stringify(workerPkg, null, 2));
+    }
 
-    await generateAstroSite(rootDir, siteFolder, siteDomain, cmsDomain.replace(/^https?:\/\//, ''));
+    if (siteDir && siteDomain) {
+        let sessionId = "REPLACE_WITH_YOUR_SESSION_KV_ID";
+        let htmlCacheId = "REPLACE_WITH_YOUR_HTML_CACHE_KV_ID";
+        const prefix = basename(siteDir).replace(/[^a-zA-Z0-9]/g, '_').toUpperCase();
 
-    console.log(`\n✨ Site created in sites/${siteFolder}! Run 'npm install' at workspace root.`);
+        try {
+            const sessionOut = execSync(`npx wrangler kv namespace create "SESSION_${prefix}"`, { encoding: 'utf-8', stdio: ['ignore', 'pipe', 'pipe'] });
+            if (sessionOut.match(/"id":\s*"([a-f0-9]{32})"/)) sessionId = sessionOut.match(/"id":\s*"([a-f0-9]{32})"/)[1];
+            const cacheOut = execSync(`npx wrangler kv namespace create "HTML_CACHE_${prefix}"`, { encoding: 'utf-8', stdio: ['ignore', 'pipe', 'pipe'] });
+            if (cacheOut.match(/"id":\s*"([a-f0-9]{32})"/)) htmlCacheId = cacheOut.match(/"id":\s*"([a-f0-9]{32})"/)[1];
+        } catch (err) { }
+
+        const siteWranglerPath = join(siteDir, 'wrangler.json');
+        const siteConfig = {
+            $schema: "node_modules/wrangler/config-schema.json",
+            name: `${basename(siteDir).toLowerCase().replace(/[^a-z0-9-]/g, '-')}-site`,
+            compatibility_date: "2024-09-23",
+            compatibility_flags: ["nodejs_compat"],
+            dev: { host: 'localhost', port: 4321 },
+            cache: { enabled: true },
+            assets: { directory: "./dist/client", binding: "ASSETS", run_worker_first: true },
+            kv_namespaces: [{ binding: "SESSION", id: sessionId }, { binding: "HTML_CACHE", id: htmlCacheId }],
+            services: [{ binding: "CMS_WORKER", service: currentConfig.name }],
+            routes: [{ pattern: siteDomain, zone_name: siteDomain, custom_domain: true, enabled: true, previews_enabled: false }],
+            vars: { PUBLIC_CMS_URL: `https://${cmsDomain}`, PUBLIC_API_URL: `https://${cmsDomain}` }
+        };
+        writeFileSync(siteWranglerPath, JSON.stringify(siteConfig, null, 2));
+
+        const sitePkgPath = join(siteDir, 'package.json');
+        if (existsSync(sitePkgPath)) {
+            const sitePkg = JSON.parse(readFileSync(sitePkgPath, 'utf-8'));
+            sitePkg.dependencies = sitePkg.dependencies || {};
+            sitePkg.dependencies['astro'] = ASTRO_LATEST;
+
+            if (sitePkg.dependencies['@astrojs/node']) delete sitePkg.dependencies['@astrojs/node'];
+            sitePkg.dependencies['@astrojs/cloudflare'] = ASTRO_CF_LATEST;
+
+            sitePkg.devDependencies = sitePkg.devDependencies || {};
+            sitePkg.devDependencies['wrangler'] = WRANGLER_LATEST;
+
+            writeFileSync(sitePkgPath, JSON.stringify(sitePkg, null, 2));
+        }
+
+        convertAstroConfigToCloudflare(siteDir);
+
+        const tsConfigPath = join(siteDir, 'tsconfig.json');
+        if (existsSync(tsConfigPath)) {
+            const tsConfig = JSON.parse(readFileSync(tsConfigPath, 'utf-8'));
+            tsConfig.compilerOptions = tsConfig.compilerOptions || {};
+            tsConfig.compilerOptions.types = ["@cloudflare/workers-types"];
+            writeFileSync(tsConfigPath, JSON.stringify(tsConfig, null, 2));
+        }
+    }
+
+    console.log(`\n✅ Workspace successfully upgraded to Cloudflare Edge!`);
 }
 
 /**
- * Helper: Scaffolds the Astro site with middleware, wrangler.json, & slug page
+ * Helper: Copies the Astro starter template and hydrates runtime tokens
  */
-async function generateAstroSite(rootDir, siteFolder, siteDomain, cmsDomain) {
-    console.log(`\n🚀 Scaffolding Astro site (${siteFolder}) mapped to ${siteDomain}...`);
+async function generateAstroSite(rootDir, siteFolder, siteDomain, cmsFullUrl, workerName = 'kama-worker', isCloudflare = false) {
+    console.log(`\n🚀 Scaffolding Astro site (${siteFolder}) mapped to ${siteDomain} (Service: ${workerName})...`);
 
     const siteDir = join(rootDir, 'sites', siteFolder);
-    mkdirSync(join(siteDir, 'src/pages'), { recursive: true });
-    mkdirSync(join(siteDir, 'src/layouts'), { recursive: true });
-    mkdirSync(join(siteDir, 'src/components/blocks'), { recursive: true });
-    mkdirSync(join(siteDir, 'src/lib'), { recursive: true });
+    const templateDir = join(__dirname, '../templates/astro-starter');
 
-    writeFileSync(
-        join(siteDir, 'package.json'),
-        JSON.stringify({
-            name: siteFolder,
-            type: 'module',
-            version: '0.0.1',
-            engines: { node: '>=22.12.0' },
-            scripts: {
-                dev: 'astro dev',
-                build: 'astro build',
-                preview: 'astro preview',
-                deploy: 'astro build && wrangler deploy',
-            },
-            dependencies: {
-                '@astrojs/cloudflare': '^14.2.5',
-                '@brightsideoy/kama': 'latest',
-                astro: '^7.2.2',
-                wrangler: '^4.127.1',
-            },
-        }, null, 2)
-    );
+    if (!existsSync(templateDir)) {
+        console.error(`❌ Error: Astro template not found at ${templateDir}`);
+        return;
+    }
 
-    writeFileSync(
-        join(siteDir, 'wrangler.json'),
-        JSON.stringify({
-            $schema: 'node_modules/wrangler/config-schema.json',
-            name: siteFolder,
-            compatibility_date: '2026-08-01',
-            compatibility_flags: ['nodejs_compat'],
-            assets: {
-                directory: './dist',
-                binding: 'ASSETS',
-                html_handling: 'drop-trailing-slash',
-                not_found_handling: '404-page',
-            },
-            services: [{ binding: 'CMS_WORKER', service: 'kama-worker' }],
-            routes: [{ pattern: siteDomain, custom_domain: true }],
-            vars: {
-                PUBLIC_CMS_URL: `https://${cmsDomain}`,
-                PUBLIC_API_URL: `https://${cmsDomain}`,
-            },
-        }, null, 2)
-    );
+    cpSync(templateDir, siteDir, { recursive: true });
 
-    const astroConfig = `import { defineConfig } from 'astro/config';
-import cloudflare from '@astrojs/cloudflare';
-
-export default defineConfig({
-  output: 'static',
-  trailingSlash: 'ignore',
-  image: {
-    remotePatterns: [
-      { protocol: 'http', hostname: 'localhost', port: '3000' },
-      { protocol: 'https', hostname: '${cmsDomain}' }
-    ]
-  },
-  build: {
-    inlineStylesheets: 'always',
-  },
-  adapter: cloudflare({
-    imageService: 'cloudflare',
-  })
-});`;
-    writeFileSync(join(siteDir, 'astro.config.mjs'), astroConfig);
+    const tsConfig = {
+        extends: "astro/tsconfigs/strict",
+        compilerOptions: { baseUrl: ".", paths: { "@/*": ["src/*"] } }
+    };
+    if (isCloudflare) tsConfig.compilerOptions.types = ["@cloudflare/workers-types"];
+    writeFileSync(join(siteDir, 'tsconfig.json'), JSON.stringify(tsConfig, null, 2));
 
-    writeFileSync(
-        join(siteDir, '.env'),
-        `PUBLIC_CMS_URL="https://${cmsDomain}"\nPUBLIC_API_URL="https://${cmsDomain}"\n`
-    );
+    const templatePkgPath = join(siteDir, 'package.json.template');
+    if (existsSync(templatePkgPath)) {
+        const rawContent = readFileSync(templatePkgPath, 'utf-8')
+            .replace(/\{\{SITE_NAME\}\}/g, siteFolder)
+            .replace(/\{\{KAMA_VERSION\}\}/g, currentKamaVersion);
+
+        const sitePkg = JSON.parse(rawContent);
+
+        sitePkg.dependencies = sitePkg.dependencies || {};
+        sitePkg.dependencies['astro'] = ASTRO_LATEST;
+
+        if (!isCloudflare) {
+            if (sitePkg.dependencies['@astrojs/cloudflare']) delete sitePkg.dependencies['@astrojs/cloudflare'];
+            if (sitePkg.dependencies['wrangler']) delete sitePkg.dependencies['wrangler'];
+            if (sitePkg.devDependencies && sitePkg.devDependencies['wrangler']) delete sitePkg.devDependencies['wrangler'];
+
+            sitePkg.dependencies['@astrojs/node'] = ASTRO_NODE_LATEST;
+        } else {
+            sitePkg.dependencies['@astrojs/cloudflare'] = ASTRO_CF_LATEST;
+            if (sitePkg.dependencies['wrangler']) delete sitePkg.dependencies['wrangler'];
+            sitePkg.devDependencies = sitePkg.devDependencies || {};
+            sitePkg.devDependencies['wrangler'] = WRANGLER_LATEST;
+
+            convertAstroConfigToCloudflare(siteDir);
+        }
+
+        writeFileSync(join(siteDir, 'package.json'), JSON.stringify(sitePkg, null, 2));
+        unlinkSync(templatePkgPath);
+    }
+
+    const siteLabel = siteFolder.split(/[-_]/).map(word => word.charAt(0).toUpperCase() + word.slice(1)).join(' ');
+    const safeSiteLabel = siteLabel.replace(/'/g, "''");
+    const channelKey = siteFolder.replace(/[^a-z0-9_-]/gi, '-').toLowerCase();
+    const treeKey = 'main-tree';
+    const safeWorkerName = `${siteFolder.toLowerCase().replace(/[^a-z0-9-]/g, '-')}-site`;
+
+    if (isCloudflare) {
+        let sessionId = "REPLACE_WITH_YOUR_SESSION_KV_ID";
+        let htmlCacheId = "REPLACE_WITH_YOUR_HTML_CACHE_KV_ID";
+
+        try {
+            const prefix = siteFolder.replace(/[^a-zA-Z0-9]/g, '_').toUpperCase();
+            const sessionOut = execSync(`npx wrangler kv namespace create "SESSION_${prefix}"`, { encoding: 'utf-8', stdio: ['ignore', 'pipe', 'pipe'] });
+            if (sessionOut.match(/"id":\s*"([a-f0-9]{32})"/)) sessionId = sessionOut.match(/"id":\s*"([a-f0-9]{32})"/)[1];
+            const cacheOut = execSync(`npx wrangler kv namespace create "HTML_CACHE_${prefix}"`, { encoding: 'utf-8', stdio: ['ignore', 'pipe', 'pipe'] });
+            if (cacheOut.match(/"id":\s*"([a-f0-9]{32})"/)) htmlCacheId = cacheOut.match(/"id":\s*"([a-f0-9]{32})"/)[1];
+        } catch (err) { }
+
+        const siteConfig = {
+            $schema: "node_modules/wrangler/config-schema.json",
+            name: safeWorkerName,
+            compatibility_date: "2024-09-23",
+            compatibility_flags: ["nodejs_compat"],
+            dev: { host: "localhost", port: 4321 },
+            cache: { enabled: true },
+            assets: { directory: "./dist/client", binding: "ASSETS", run_worker_first: true },
+            kv_namespaces: [{ binding: "SESSION", id: sessionId }, { binding: "HTML_CACHE", id: htmlCacheId }],
+            services: [{ binding: "CMS_WORKER", service: workerName }],
+            vars: { PUBLIC_CMS_URL: cmsFullUrl, PUBLIC_API_URL: cmsFullUrl, PUBLIC_CHANNEL_ID: channelKey, PUBLIC_TREE_ID: treeKey, PUBLIC_HOME_SLUG: "home", PUBLIC_SITE_NAME: siteLabel }
+        };
+
+        if (siteDomain !== 'localhost:4321') siteConfig.routes = [{ pattern: siteDomain, custom_domain: true, enabled: true, previews_enabled: false }];
+        writeFileSync(join(siteDir, 'wrangler.json'), JSON.stringify(siteConfig, null, 2));
+    }
+
+    const seedSql = `
+-- Seed data for site: ${safeSiteLabel}
+INSERT OR IGNORE INTO channels (key, label, channelType, defaultLanguage, isHidden, dataJson) VALUES ('${channelKey}', '${safeSiteLabel}', 'website', 'en', 0, '{}');
+INSERT OR IGNORE INTO trees (key, label, treeType, channelId, isHidden, dataJson) VALUES ('${treeKey}', 'Main Tree', 'navigation', (SELECT id FROM channels WHERE key = '${channelKey}'), 0, '{}');
+INSERT OR IGNORE INTO channel_trees (channelId, treeId, key) VALUES ((SELECT id FROM channels WHERE key = '${channelKey}'), (SELECT id FROM trees WHERE key = '${treeKey}'), 'main');
+INSERT INTO content_nodes (contentType, title, slug, language, status, dataJson) SELECT 'page', 'Welcome to ${safeSiteLabel}', 'home', 'en', 'published', '{"titleSuffix":"– ${safeSiteLabel}","layoutId":"single-column","subpageLayoutId":"two-column","logoText":"${safeSiteLabel}"}' WHERE NOT EXISTS (SELECT 1 FROM content_nodes WHERE slug = 'home' AND title = 'Welcome to ${safeSiteLabel}');
+INSERT OR IGNORE INTO node_channels (nodeId, channelId) VALUES ((SELECT id FROM content_nodes WHERE slug = 'home' AND title = 'Welcome to ${safeSiteLabel}' ORDER BY id DESC LIMIT 1), (SELECT id FROM channels WHERE key = '${channelKey}'));
+INSERT OR IGNORE INTO tree_nodes (treeId, contentId, parentId, sortOrder) VALUES ((SELECT id FROM trees WHERE key = '${treeKey}'), (SELECT id FROM content_nodes WHERE slug = 'home' AND title = 'Welcome to ${safeSiteLabel}' ORDER BY id DESC LIMIT 1), NULL, 0);
+`;
+
+    const workerDir = join(rootDir, 'kama-worker');
+    if (existsSync(workerDir)) appendFileSync(join(workerDir, 'seed.sql'), seedSql);
+
+    writeFileSync(join(siteDir, '.env'), `# Local Development Overrides\nPUBLIC_CMS_URL="http://127.0.0.1:8787"\nPUBLIC_API_URL="http://127.0.0.1:8787"\nPUBLIC_CHANNEL_ID="${channelKey}"\nPUBLIC_TREE_ID="${treeKey}"\nPUBLIC_HOME_SLUG="home"\nPUBLIC_SITE_NAME="${siteLabel.replace(/"/g, '\\"')}"\n`);
 }
 
 main().catch(console.error);