@brightsideoy/kama 0.1.0-alpha.101 → 0.1.0-alpha.108

package/bin/cli.js

@@ -1,9 +1,24 @@
 #!/usr/bin/env node
 import { execSync } from 'node:child_process';
 import { existsSync, mkdirSync, writeFileSync, readFileSync } from 'node:fs';
-import { join } from 'node:path';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
 import * as readline from 'node:readline/promises';
 
+// Dynamically resolve the current CLI version to inject into package.json files
+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,
@@ -32,8 +47,25 @@ async function main() {
  */
 async function createFullWorkspace() {
     const projName = (await rl.question('Project folder name [kama-workspace]: ')) || 'kama-workspace';
-    const cmsDomain = (await rl.question('CMS Admin Domain (e.g., admin.t3cloud.eu): ')) || 'admin.t3cloud.eu';
-    const siteDomain = (await rl.question('First Website Domain (e.g., kama.t3cloud.eu): ')) || 'kama.t3cloud.eu';
+
+    console.log('\n🌍 Where do you plan to deploy KAMA?');
+    console.log('  1) Local Development Only (SQLite / Testing)');
+    console.log('  2) Cloudflare Edge (Workers / D1 / R2)');
+    const envChoice = await rl.question('\nChoice [1/2]: ');
+    const isCloudflare = envChoice.trim() === '2';
+
+    let cmsDomain = 'localhost:8787';
+    let siteDomain = 'localhost:4321';
+
+    // Only ask for domains if deploying to Cloudflare Edge
+    if (isCloudflare) {
+        cmsDomain = (await rl.question('\nCMS Admin Domain (e.g., admin.t3cloud.eu): ')) || 'admin.t3cloud.eu';
+        siteDomain = (await rl.question('First Website Domain (e.g., kama.t3cloud.eu): ')) || 'kama.t3cloud.eu';
+    }
+
+    // Standardize scheme for localhost vs custom edge domains
+    const cmsProtocol = isCloudflare ? 'https://' : 'http://';
+    const cmsFullUrl = `${cmsProtocol}${cmsDomain.replace(/^https?:\/\//, '')}`;
 
     const rootDir = join(process.cwd(), projName);
 
@@ -45,56 +77,95 @@ async function createFullWorkspace() {
     console.log(`\n📁 Creating workspace folder at ./${projName}...`);
     mkdirSync(rootDir, { recursive: true });
 
-    // 🎯 Scaffold schemas directory for project-level custom YAML definitions
-    mkdirSync(join(rootDir, 'schemas', 'nodes'), { recursive: true });
-    mkdirSync(join(rootDir, 'schemas', 'blocks'), { recursive: true });
+    // 🎯 Generate root .gitignore so auto-generated bundles and secrets stay out of git
+    writeFileSync(
+        join(rootDir, '.gitignore'),
+        `node_modules/
+.env
+.DS_Store
+cms-worker/.dev.vars
+cms-worker/bundled-definitions.js
+cms-worker/.wrangler/
+sites/*/.env
+sites/*/.astro/
+sites/*/dist/
+`
+    );
+
+    // 🎯 Scaffold full schema directory structure
+    const schemaCategories = [
+        'block-layouts',
+        'blocks',
+        'channels',
+        'field-sets',
+        'node-layouts',
+        'nodes',
+        'trees'
+    ];
+
+    for (const category of schemaCategories) {
+        mkdirSync(join(rootDir, 'content', 'definitions', category), { recursive: true });
+    }
+
+    // 🎯 Populate starter example YAML files
+    scaffoldSampleSchemas(rootDir);
 
     // --- AUTO D1 CREATION MAGIC ---
-    let d1DatabaseId = 'REPLACE_WITH_YOUR_D1_ID';
+    let d1DatabaseId = '00000000-0000-0000-0000-000000000000';
     let isAuthenticated = false;
 
-    console.log(`\n🔑 Checking Cloudflare authentication...`);
-    try {
-        execSync('npx wrangler whoami', { stdio: 'pipe' });
-        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...`);
+    if (isCloudflare) {
+        console.log(`\n🔑 Checking Cloudflare authentication...`);
         try {
-            execSync('npx wrangler login', { stdio: 'inherit' });
+            execSync('npx wrangler whoami', { stdio: 'pipe' });
             isAuthenticated = true;
-            console.log(`✅ Successfully logged in!`);
-        } catch (loginError) {
-            console.log(`❌ Login failed or was cancelled.`);
+            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: 'inherit' });
+                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: 'pipe' });
-
-            const jsonStart = listOutput.indexOf('[');
-            const jsonEnd = listOutput.lastIndexOf(']') + 1;
-            let databases = [];
+        if (isAuthenticated) {
+            try {
+                console.log(`\n🗄️ Checking existing Cloudflare D1 databases...`);
+                const listOutput = execSync(`npx wrangler d1 list --json`, { encoding: 'utf-8', stdio: 'pipe' });
 
-            if (jsonStart !== -1 && jsonEnd !== -1) {
-                databases = JSON.parse(listOutput.substring(jsonStart, jsonEnd));
-            }
+                const jsonStart = listOutput.indexOf('[');
+                const jsonEnd = listOutput.lastIndexOf(']') + 1;
+                let databases = [];
 
-            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 (jsonStart !== -1 && jsonEnd !== -1) {
+                    databases = JSON.parse(listOutput.substring(jsonStart, jsonEnd));
+                }
 
-                if (useExisting.toLowerCase() !== 'n') {
-                    d1DatabaseId = existingDb.uuid;
-                    console.log(`✅ Linked existing database ID: ${d1DatabaseId}`);
+                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: '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 {
-                    dbName = (await rl.question(`Enter a new database name: `)).trim();
-                    console.log(`\n🗄️ Creating new database '${dbName}'...`);
+                    console.log(`\n🗄️ Attempting to auto-create Cloudflare D1 Database '${dbName}'...`);
                     const d1Output = execSync(`npx wrangler d1 create ${dbName}`, { encoding: 'utf-8', stdio: '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) {
@@ -102,20 +173,14 @@ async function createFullWorkspace() {
                         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: '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.`);
             }
-        } 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(`⚠️ Skipping database creation. We'll leave a placeholder in wrangler.json.`);
+        console.log(`\n💻 Local mode selected. Skipping Cloudflare authentication and domain setup...`);
     }
     // ------------------------------
 
@@ -133,7 +198,7 @@ async function createFullWorkspace() {
                 'deploy:cms': 'npm run bundle:schemas && npm run deploy -w cms-worker',
             },
             dependencies: {
-                '@brightsideoy/kama': 'alpha',
+                '@brightsideoy/kama': currentKamaVersion,
             }
         }, null, 2)
     );
@@ -143,9 +208,32 @@ async function createFullWorkspace() {
     const cmsDir = join(rootDir, 'cms-worker');
     mkdirSync(cmsDir, { recursive: true });
 
+    // 🎯 Properly wrap and inject BUNDLED_DEFINITIONS from LOCAL workspace, not node_modules
+    const cmsWorkerIndexContent = `import kamaWorker from '@brightsideoy/kama';
+import * as bundledModule from './bundled-definitions.js';
+
+// Resolve BUNDLED_DEFINITIONS across all module resolution formats
+const BUNDLED_DEFINITIONS =
+  bundledModule.BUNDLED_DEFINITIONS ||
+  bundledModule.default?.BUNDLED_DEFINITIONS ||
+  bundledModule.default ||
+  bundledModule;
+
+export default {
+  async fetch(request, env, ctx) {
+    const customEnv = {
+      ...env,
+      BUNDLED_DEFINITIONS,
+    };
+
+    return kamaWorker.fetch(request, customEnv, ctx);
+  },
+};
+`;
+
     writeFileSync(
         join(cmsDir, 'index.js'),
-        `export { default } from '@brightsideoy/kama';\n`
+        cmsWorkerIndexContent
     );
 
     writeFileSync(
@@ -162,68 +250,79 @@ async function createFullWorkspace() {
                 "deploy": "npm run schema:remote && wrangler deploy"
             },
             dependencies: {
-                '@brightsideoy/kama': 'alpha',
+                '@brightsideoy/kama': currentKamaVersion,
             },
             devDependencies: {
-                wrangler: '^4.127.1',
+                wrangler: '^3.80.0',
                 tsx: '^4.19.2',
             },
         }, null, 2)
     );
 
-    // 🎯 Fixed CMS wrangler.json (Added PUBLIC_FRONTEND_URL & CLOUDFLARE_ZONE_ID to public vars)
+    // 🎯 Fixed CMS wrangler.json
+    const cmsWranglerConfig = {
+        $schema: '../node_modules/wrangler/config-schema.json',
+        name: workerName,
+        main: 'index.js',
+        compatibility_date: '2026-08-01',
+        compatibility_flags: ['nodejs_compat'],
+        assets: {
+            directory: '../node_modules/@brightsideoy/kama/dist',
+            binding: 'ASSETS'
+        },
+        images: {
+            binding: 'IMAGES'
+        },
+        vars: {
+            CDN_DOMAIN: cmsDomain,
+            PUBLIC_FRONTEND_URL: isCloudflare ? `https://${siteDomain}` : 'http://localhost:4321',
+            CLOUDFLARE_ZONE_ID: isCloudflare ? "REPLACE_WITH_YOUR_32_CHAR_ZONE_ID" : "local-zone-not-needed"
+        },
+        d1_databases: [{
+            binding: 'DB',
+            database_name: dbName,
+            database_id: d1DatabaseId,
+        }],
+        r2_buckets: [{
+            binding: 'MEDIA_BUCKET',
+            bucket_name: bucketName,
+        }],
+    };
+
+    if (isCloudflare) {
+        cmsWranglerConfig.routes = [{ pattern: cmsDomain, custom_domain: true }];
+    }
+
     writeFileSync(
         join(cmsDir, 'wrangler.json'),
-        JSON.stringify({
-            $schema: '../node_modules/wrangler/config-schema.json',
-            name: workerName,
-            main: 'index.js',
-            compatibility_date: '2026-08-01',
-            compatibility_flags: ['nodejs_compat'],
-            assets: {
-                directory: '../node_modules/@brightsideoy/kama/dist',
-                binding: 'ASSETS'
-            },
-            images: {
-                binding: 'IMAGES'
-            },
-            routes: [{ pattern: cmsDomain, custom_domain: true }],
-            vars: {
-                CDN_DOMAIN: cmsDomain,
-                PUBLIC_FRONTEND_URL: `https://${siteDomain}`,
-                CLOUDFLARE_ZONE_ID: "REPLACE_WITH_YOUR_32_CHAR_ZONE_ID"
-            },
-            d1_databases: [{
-                binding: 'DB',
-                database_name: dbName,
-                database_id: d1DatabaseId,
-            }],
-            r2_buckets: [{
-                binding: 'MEDIA_BUCKET',
-                bucket_name: bucketName,
-            }],
-        }, null, 2)
+        JSON.stringify(cmsWranglerConfig, null, 2)
     );
 
-    // 🎯 Fixed .dev.vars (Only contains API token for local dev, not public Zone ID)
+    // 🎯 Fixed .dev.vars
     writeFileSync(
         join(cmsDir, '.dev.vars'),
-        `# Cloudflare Edge Cache Purging Secrets\nCLOUDFLARE_API_TOKEN=cfut_YOUR_CUSTOM_PURGE_TOKEN\n`
+        `# Cloudflare Edge Cache Purging Secrets\nCLOUDFLARE_API_TOKEN=${isCloudflare ? 'cfut_YOUR_CUSTOM_PURGE_TOKEN' : 'local_token'}\n`
     );
 
     // 🎯 3. Setup First Astro Site tied to target workerName
-    const siteFolderName = siteDomain.split('.')[0];
-    await generateAstroSite(rootDir, siteFolderName, siteDomain, cmsDomain, workerName);
+    const siteFolderName = isCloudflare ? siteDomain.split('.')[0] : 'web';
+    await generateAstroSite(rootDir, siteFolderName, siteDomain, cmsFullUrl, workerName, isCloudflare);
 
     console.log(`\n✨ Workspace ready! Next steps:`);
     console.log(`  1. cd ${projName}`);
     console.log(`  2. npm install`);
-    if (d1DatabaseId === 'REPLACE_WITH_YOUR_D1_ID') {
-        console.log(`  3. Run 'npx wrangler login' and create a D1 database.`);
+
+    if (isCloudflare) {
+        if (d1DatabaseId === '00000000-0000-0000-0000-000000000000' || d1DatabaseId === 'REPLACE_WITH_YOUR_D1_ID') {
+            console.log(`  3. Run 'npx wrangler login' and create a D1 database manually.`);
+        }
+        console.log(`  4. Update CLOUDFLARE_ZONE_ID in cms-worker/wrangler.json with your actual Zone ID`);
+        console.log(`  5. Securely store your purge token: cd cms-worker && npx wrangler secret put CLOUDFLARE_API_TOKEN`);
+        console.log(`  6. Run 'npm run dev:cms' from the workspace root to start the backend.`);
+    } else {
+        console.log(`  3. Run 'npm run dev:cms' from the workspace root to start the local SQLite backend.`);
+        console.log(`\n💡 Note: You can deploy to Cloudflare later by updating 'cms-worker/wrangler.json' with real IDs.`);
     }
-    console.log(`  4. Update CLOUDFLARE_ZONE_ID in cms-worker/wrangler.json with your actual Zone ID`);
-    console.log(`  5. Securely store your purge token: cd cms-worker && npx wrangler secret put CLOUDFLARE_API_TOKEN`);
-    console.log(`  6. Run 'npm run dev:cms' from the workspace root to start the backend.`);
 }
 
 /**
@@ -246,19 +345,146 @@ async function createNewSiteOnly() {
         } catch (e) { }
     }
 
+    console.log('\n🌍 Deployment Mode:');
+    console.log('  1) Local Development');
+    console.log('  2) Cloudflare Edge');
+    const envChoice = await rl.question('\nChoice [1/2]: ');
+    const isCloudflare = envChoice.trim() === '2';
+
     const siteFolder = await rl.question('Site folder name (e.g., my-new-site): ');
-    const siteDomain = await rl.question('Website Domain (e.g., brand.com): ');
-    const cmsDomain = (await rl.question('CMS API Domain (e.g., admin.t3cloud.eu): ')) || 'admin.t3cloud.eu';
 
-    await generateAstroSite(rootDir, siteFolder, siteDomain, cmsDomain.replace(/^https?:\/\//, ''), targetWorkerName);
+    let siteDomain = 'localhost:4321';
+    let cmsFullUrl = 'http://localhost:8787';
+
+    if (isCloudflare) {
+        siteDomain = await rl.question('Website Domain (e.g., brand.com): ');
+        const cmsDomainInput = (await rl.question('CMS API Domain (e.g., admin.t3cloud.eu): ')) || 'admin.t3cloud.eu';
+        cmsFullUrl = `https://${cmsDomainInput.replace(/^https?:\/\//, '')}`;
+    }
+
+    await generateAstroSite(rootDir, siteFolder, siteDomain, cmsFullUrl, targetWorkerName, isCloudflare);
 
     console.log(`\n✨ Site created in sites/${siteFolder}! Run 'npm install' at workspace root.`);
 }
 
+/**
+ * Helper: Scaffolds initial starter schemas for all category folders
+ */
+function scaffoldSampleSchemas(rootDir) {
+    const defsDir = join(rootDir, 'content', 'definitions');
+
+    // 1. Channels
+    writeFileSync(join(defsDir, 'channels', 'website.yaml'), `id: website
+label: Main Website
+defaultLanguage: en
+languages:
+  - en
+  - fi
+`);
+
+    // 2. Nodes
+    writeFileSync(join(defsDir, 'nodes', 'page.yaml'), `id: page
+label: Page
+inTree: true
+inVault: false
+hasCanvas: true
+tabs:
+  settings:
+    label: Settings
+    fields:
+      title:
+        label: Page Title
+        type: text
+        required: true
+      slug:
+        label: URL Slug
+        type: slug
+        linkedTo: title
+`);
+
+    writeFileSync(join(defsDir, 'nodes', 'article.yaml'), `id: article
+label: Article
+inTree: false
+inVault: true
+hasCanvas: true
+tabs:
+  settings:
+    label: Settings
+    fields:
+      title:
+        label: Title
+        type: text
+        required: true
+      slug:
+        label: Slug
+        type: slug
+        linkedTo: title
+`);
+
+    // 3. Blocks
+    writeFileSync(join(defsDir, 'blocks', 'hero.yaml'), `id: hero
+label: Hero Section
+fields:
+  heading:
+    label: Heading
+    type: text
+    required: true
+  subheading:
+    label: Subheading
+    type: text
+`);
+
+    writeFileSync(join(defsDir, 'blocks', 'text.yaml'), `id: text
+label: Text Block
+fields:
+  content:
+    label: Content
+    type: richtext
+`);
+
+    // 4. Block Layouts
+    writeFileSync(join(defsDir, 'block-layouts', 'two-column.yaml'), `id: two-column
+label: Two Column Layout
+regions:
+  left:
+    label: Left Column
+  right:
+    label: Right Column
+`);
+
+    // 5. Node Layouts
+    writeFileSync(join(defsDir, 'node-layouts', 'single-column.yml'), `id: single-column
+label: Single Column Page
+regions:
+  main:
+    label: Main Content Area
+`);
+
+    // 6. Field Sets
+    writeFileSync(join(defsDir, 'field-sets', 'page-base.yaml'), `id: page-base
+label: Base Page Fields
+fields:
+  metaTitle:
+    label: Meta Title
+    type: text
+  metaDescription:
+    label: Meta Description
+    type: text
+`);
+
+    // 7. Trees
+    writeFileSync(join(defsDir, 'trees', 'navigation.yaml'), `id: navigation
+label: Main Navigation Tree
+maxDepth: 3
+allowedNodeTypes:
+  - page
+`);
+}
+
 /**
  * Helper: Scaffolds the Astro site with middleware, wrangler.json, & slug page
  */
-async function generateAstroSite(rootDir, siteFolder, siteDomain, cmsDomain, workerName = 'kama-worker') {
+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);
@@ -282,37 +508,44 @@ async function generateAstroSite(rootDir, siteFolder, siteDomain, cmsDomain, wor
             },
             dependencies: {
                 '@astrojs/cloudflare': '^14.2.5',
-                '@brightsideoy/kama': 'alpha',
-                astro: '^7.2.2',
-                wrangler: '^4.127.1',
+                '@brightsideoy/kama': currentKamaVersion,
+                astro: '^5.0.0', // Ensure using modern Astro
+                wrangler: '^3.80.0',
             },
         }, null, 2)
     );
 
-    // 🎯 Fixed Astro wrangler.json: Added `run_worker_first: true` to prevent media routing 404s on Edge
+    const siteWranglerConfig = {
+        $schema: 'node_modules/wrangler/config-schema.json',
+        name: siteFolder,
+        compatibility_date: '2026-08-01',
+        compatibility_flags: ['nodejs_compat'],
+        assets: {
+            directory: './dist/client',
+            binding: 'ASSETS',
+            html_handling: 'drop-trailing-slash',
+            not_found_handling: '404-page',
+            run_worker_first: true
+        },
+        services: [{ binding: 'CMS_WORKER', service: workerName }],
+        kv_namespaces: [{ binding: "HTML_CACHE", id: "REPLACE_WITH_YOUR_KV_ID", preview_id: "LOCAL_DEV_KV" }],
+        vars: {
+            PUBLIC_CMS_URL: cmsFullUrl,
+            PUBLIC_API_URL: cmsFullUrl,
+        },
+    };
+
+    if (isCloudflare) {
+        siteWranglerConfig.routes = [{ pattern: siteDomain, custom_domain: true }];
+    }
+
     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/client',
-                binding: 'ASSETS',
-                html_handling: 'drop-trailing-slash',
-                not_found_handling: '404-page',
-                run_worker_first: true
-            },
-            services: [{ binding: 'CMS_WORKER', service: workerName }],
-            routes: [{ pattern: siteDomain, custom_domain: true }],
-            vars: {
-                PUBLIC_CMS_URL: `https://${cmsDomain}`,
-                PUBLIC_API_URL: `https://${cmsDomain}`,
-            },
-        }, null, 2)
+        JSON.stringify(siteWranglerConfig, null, 2)
     );
 
+    const cmsHostname = cmsFullUrl.replace(/^https?:\/\//, '').split(':')[0];
+
     const astroConfig = `import { defineConfig } from 'astro/config';
 import cloudflare from '@astrojs/cloudflare';
 
@@ -321,8 +554,8 @@ export default defineConfig({
   trailingSlash: 'ignore',
   image: {
     remotePatterns: [
-      { protocol: 'http', hostname: 'localhost', port: '3000' },
-      { protocol: 'https', hostname: '${cmsDomain}' }
+      { protocol: 'http', hostname: 'localhost', port: '8787' },
+      { protocol: '${isCloudflare ? 'https' : 'http'}', hostname: '${cmsHostname}' }
     ]
   },
   build: {
@@ -336,8 +569,165 @@ export default defineConfig({
 
     writeFileSync(
         join(siteDir, '.env'),
-        `PUBLIC_CMS_URL="https://${cmsDomain}"\nPUBLIC_API_URL="https://${cmsDomain}"\n`
+        `PUBLIC_CMS_URL="${cmsFullUrl}"\nPUBLIC_API_URL="${cmsFullUrl}"\n`
+    );
+
+    // 🎯 Scaffold the Base Layout
+    writeFileSync(
+        join(siteDir, 'src/layouts/Layout.astro'),
+        `---
+export interface Props {
+\ttitle: string;
+}
+const { title } = Astro.props;
+---
+<!DOCTYPE html>
+<html lang="en">
+\t<head>
+\t\t<meta charset="UTF-8" />
+\t\t<meta name="viewport" content="width=device-width" />
+\t\t<link rel="icon" type="image/svg+xml" href="/favicon.svg" />
+\t\t<meta name="generator" content={Astro.generator} />
+\t\t<title>{title}</title>
+\t</head>
+\t<body>
+\t\t<slot />
+\t</body>
+</html>`
+    );
+
+    // 🎯 Scaffold the Dynamic Slug Page
+    writeFileSync(
+        join(siteDir, 'src/pages/[...slug].astro'),
+        `---
+import Layout from '../layouts/Layout.astro';
+
+const { slug } = Astro.params;
+const cmsUrl = import.meta.env.PUBLIC_CMS_URL;
+
+// Example Data Fetch: Replace with actual KAMA fetch logic
+// const response = await fetch(\`\${cmsUrl}/api/pages/\${slug || 'home'}\`);
+// const pageData = await response.json();
+---
+<Layout title="Kama Generated Site">
+\t<main>
+\t\t<h1>Welcome to your new Kama Site</h1>
+\t\t<p>Current route: <strong>{slug || '/'}</strong></p>
+\t</main>
+</Layout>`
+    );
+
+    // 🎯 Scaffold the Full Edge-Caching Middleware
+    writeFileSync(
+        join(siteDir, 'src/middleware.ts'),
+        `import { defineMiddleware } from "astro:middleware";
+import { env } from "cloudflare:workers";
+
+export const onRequest = defineMiddleware(async (context, next) => {
+    const pathname = context.url.pathname;
+    const cfContext = (context.locals as any).cfContext;
+    const workerEnv = cfContext?.env || (env as any);
+    const HTML_CACHE = workerEnv?.HTML_CACHE; 
+
+    // 🎯 1. CACHE PURGE ENDPOINT
+    if (pathname === "/api/purge" || pathname === "/api/purge/") {
+        if (context.request.method !== "POST") return new Response("Method Not Allowed", { status: 405 });
+        
+        try {
+            const body = await context.request.json();
+            const now = Date.now().toString();
+
+            if (HTML_CACHE) {
+                if (body.purge_everything) {
+                    await HTML_CACHE.put("site_version", now);
+                } else if (Array.isArray(body.urls) && body.urls.length > 0) {
+                    await Promise.all(body.urls.map((u: string) => {
+                        const path = new URL(u).pathname.replace(/\\/$/, "") || "/";
+                        return HTML_CACHE.put(\`v:\${path}\`, now);
+                    }));
+                }
+                
+                // Surgical delete
+                if (Array.isArray(body.deleted_urls) && body.deleted_urls.length > 0) {
+                    await Promise.all(body.deleted_urls.map(async (u: string) => {
+                        const path = new URL(u).pathname.replace(/\\/$/, "") || "/";
+                        const [siteVer, pageVer] = await Promise.all([
+                            HTML_CACHE.get("site_version"), HTML_CACHE.get(\`v:\${path}\`)
+                        ]);
+                        if (siteVer || pageVer) {
+                            await HTML_CACHE.delete(\`\${path}:v:\${siteVer || "1"}:\${pageVer || "1"}\`);
+                        }
+                        await HTML_CACHE.delete(\`v:\${path}\`);
+                    }));
+                }
+            }
+            
+            // Astro Worker Cache layer flush
+            if (typeof cfContext?.cache?.purge === 'function') await cfContext.cache.purge({ purgeEverything: true });
+
+            return new Response(JSON.stringify({ success: true }), { status: 200 });
+        } catch (err: any) {
+            return new Response(JSON.stringify({ error: err.message }), { status: 500 });
+        }
+    }
+
+    // 🎯 2. KV HTML STATIC LOOKUP
+    const isWarmer = context.request.headers.get("X-Cache-Warmer") === "true";
+    const isHtmlPage = !pathname.includes('.') && !pathname.startsWith('/api/');
+    const cleanLookupPath = pathname.replace(/\\/$/, "") || "/";
+    let activeCacheKey = cleanLookupPath;
+
+    if (isHtmlPage && HTML_CACHE && !isWarmer) {
+        try {
+            const [siteVer, pageVer] = await Promise.all([
+                HTML_CACHE.get("site_version"),
+                HTML_CACHE.get(\`v:\${cleanLookupPath}\`)
+            ]);
+            activeCacheKey = \`\${cleanLookupPath}:v:\${siteVer || "1"}:\${pageVer || "1"}\`;
+
+            const cachedHtml = await HTML_CACHE.get(activeCacheKey);
+            if (cachedHtml) {
+                return new Response(cachedHtml, {
+                    status: 200,
+                    headers: {
+                        "Content-Type": "text/html; charset=utf-8",
+                        "X-Cache-Status": "HIT-KV-STATICFILE",
+                        "Cache-Control": "no-store, no-cache, must-revalidate"
+                    }
+                });
+            }
+        } catch (e) {
+            console.warn("[Middleware] KV skip:", e);
+        }
+    }
+
+    const response = await next();
+
+    // 🎯 3. KV HTML STATIC WRITE
+    if (isHtmlPage && HTML_CACHE && response.status === 200 && response.headers.get("content-type")?.includes("text/html")) {
+        const htmlText = await response.clone().text();
+        const writeTask = (async () => {
+            if (activeCacheKey === cleanLookupPath || isWarmer) {
+                const forcedVersion = Date.now().toString();
+                await HTML_CACHE.put(\`v:\${cleanLookupPath}\`, forcedVersion);
+                const siteVer = await HTML_CACHE.get("site_version") || "1";
+                activeCacheKey = \`\${cleanLookupPath}:v:\${siteVer}:\${forcedVersion}\`;
+            }
+            await HTML_CACHE.put(activeCacheKey, htmlText);
+        })();
+
+        if (cfContext?.waitUntil) cfContext.waitUntil(writeTask);
+    }
+
+    return response;
+});`
     );
+
+    if (isCloudflare) {
+        console.log(`\n⚠️ Note for Astro Frontend: You will need to create a KV Namespace for the HTML Cache.`);
+        console.log(`   Run: npx wrangler kv:namespace create HTML_CACHE`);
+        console.log(`   Then update the ID in sites/${siteFolder}/wrangler.json`);
+    }
 }
 
 main().catch(console.error);