@brightsideoy/kama 0.1.0-alpha.113 → 0.1.0-alpha.115

package/bin/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { execSync } from 'node:child_process';
-import { existsSync, mkdirSync, writeFileSync, readFileSync, readdirSync } from 'node:fs';
-import { join, dirname, basename } from 'node:path';
+import { existsSync, mkdirSync, writeFileSync, readFileSync, readdirSync, cpSync, unlinkSync, statSync } from 'node:fs';
+import { join, dirname, basename, relative, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import * as readline from 'node:readline/promises';
 
@@ -37,17 +37,21 @@ async function main() {
         await createNewSiteOnly();
     } else if (command === 'promote') {
         await promoteLocalToCloudflare();
+    } else if (command === 'bundle') {
+        await bundleWorkspaceSchemas();
     } else {
-        // Interactive menu when invoked without arguments or unrecognized command
         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 promote      - Promote current Local workspace to Cloudflare Edge');
+        console.log('  3) npx kama bundle       - Bundle YAML schemas for Edge deployment');
+        console.log('  4) npx kama promote      - Promote current Local workspace to Cloudflare Edge');
 
-        const choice = await rl.question('\nSelect choice [1/2/3]: ');
+        const choice = await rl.question('\nSelect choice [1/2/3/4]: ');
 
-        if (choice.trim() === '3') {
+        if (choice.trim() === '4') {
             await promoteLocalToCloudflare();
+        } else if (choice.trim() === '3') {
+            await bundleWorkspaceSchemas();
         } else if (choice.trim() === '2') {
             await createNewSiteOnly();
         } else {
@@ -101,6 +105,8 @@ async function createFullWorkspace() {
     let dbName = `${projName}-db`.replace(/[^a-zA-Z0-9_-]/g, '_');
     const bucketName = `${projName}-media-prod`.toLowerCase().replace(/[^a-z0-9_-]/g, '-');
 
+    const siteFolderName = isCloudflare ? siteDomain.split('.')[0] : 'web';
+
     if (!isCurrentDir) {
         console.log(`\n📁 Creating workspace folder at ./${projName}...`);
         mkdirSync(rootDir, { recursive: true });
@@ -114,31 +120,23 @@ async function createFullWorkspace() {
 .env
 .DS_Store
 kama-worker/.dev.vars
-kama-worker/bundled-definitions.js
-kama-worker/bundled-definitions.ts
 kama-worker/.wrangler/
 sites/*/.env
 sites/*/.astro/
 sites/*/dist/
+kama-worker/workspace-schemas.js
 `
     );
 
-    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 });
+    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}`);
     }
 
-    scaffoldSampleSchemas(rootDir);
-
     let d1DatabaseId = '00000000-0000-0000-0000-000000000000';
     let isAuthenticated = false;
 
@@ -164,7 +162,6 @@ sites/*/dist/
             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 = [];
@@ -211,46 +208,63 @@ sites/*/dist/
         console.log(`\n💻 Local 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: {
+            'wrangler': '^4.130.0' // 🎯 UPDATED TO V4
+        }
+    };
+
+    const bundleScript = 'npx kama bundle || node ./node_modules/@brightsideoy/kama/bin/cli.js bundle';
+
+    if (shouldCreateSite) {
+        rootPkg.devDependencies['concurrently'] = '^9.0.0';
+        rootPkg.scripts['dev:site'] = `npm run dev -w sites/${siteFolderName}`;
+
+        // 🎯 Inject schema bundling hook with fallback execution path
+        rootPkg.scripts['predev'] = bundleScript;
+        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'] = bundleScript;
+        rootPkg.scripts['dev'] = 'npm run dev:cms';
+    }
+
     writeFileSync(
         join(rootDir, 'package.json'),
-        JSON.stringify({
-            name: projName,
-            private: true,
-            type: 'module',
-            workspaces: ['kama-worker', 'sites/*'],
-            scripts: {
-                'bundle:schemas': 'node node_modules/@brightsideoy/kama/scripts/bundle-definitions.js',
-                'dev:cms': 'npm run bundle:schemas && npm run dev -w kama-worker',
-                'deploy:cms': 'npm run bundle:schemas && npm run deploy -w kama-worker',
-            },
-            dependencies: {
-                '@brightsideoy/kama': currentKamaVersion,
-            }
-        }, null, 2)
+        JSON.stringify(rootPkg, null, 2)
     );
 
     console.log(`\n☁️ Configuring CMS Worker '${workerName}' (${cmsDomain})...`);
     const cmsDir = join(rootDir, 'kama-worker');
     mkdirSync(cmsDir, { recursive: true });
 
+    // 🎯 Worker entry point now attempts to load the workspace schemas
     const cmsWorkerIndexContent = `import kamaWorker from '@brightsideoy/kama';
-import * as bundledModule from './bundled-definitions.js';
-
-const BUNDLED_DEFINITIONS =
-  bundledModule.BUNDLED_DEFINITIONS ||
-  bundledModule.default?.BUNDLED_DEFINITIONS ||
-  bundledModule.default ||
-  bundledModule;
+import customSchemas from './workspace-schemas.js';
 
 export default {
   async fetch(request, env, ctx) {
-    const customEnv = {
-      ...env,
-      BUNDLED_DEFINITIONS,
-    };
-
-    return kamaWorker.fetch(request, customEnv, ctx);
-  },
+    if (typeof kamaWorker === 'function') {
+      return kamaWorker(request, env, ctx, customSchemas);
+    }
+    if (kamaWorker && typeof kamaWorker.fetch === 'function') {
+      return kamaWorker.fetch(request, env, ctx, customSchemas);
+    }
+    return new Response('Kama Engine Worker Ready', { status: 200 });
+  }
 };
 `;
 
@@ -263,9 +277,9 @@ export default {
             type: 'module',
             version: '1.0.0',
             scripts: {
-                "bundle:schemas": "node ../node_modules/@brightsideoy/kama/scripts/bundle-definitions.js",
-                "schema:local": `npm run bundle:schemas && wrangler d1 execute ${dbName} --local --file=../node_modules/@brightsideoy/kama/schema.sql`,
-                "schema:remote": `npm run bundle:schemas && wrangler d1 execute ${dbName} --remote --file=../node_modules/@brightsideoy/kama/schema.sql`,
+                // 🎯 SILENCED SQL ARRAYS ON LOCAL DEV
+                "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`,
                 "dev": "npm run schema:local && wrangler dev",
                 "deploy": "npm run schema:remote && wrangler deploy"
             },
@@ -273,8 +287,8 @@ export default {
                 '@brightsideoy/kama': currentKamaVersion,
             },
             devDependencies: {
-                wrangler: '^4.0.0',
-                tsx: '^4.19.2',
+                "wrangler": "^4.130.0", // 🎯 UPDATED TO V4
+                "tsx": "^4.19.2",
             },
         }, null, 2)
     );
@@ -319,8 +333,10 @@ export default {
         `# Cloudflare Edge Cache Purging Secrets\nCLOUDFLARE_API_TOKEN=${isCloudflare ? 'cfut_YOUR_CUSTOM_PURGE_TOKEN' : 'local_token'}\n`
     );
 
+    // Attempt an initial bundle right away so it exists before the user runs anything
+    await bundleWorkspaceSchemas(rootDir);
+
     if (shouldCreateSite) {
-        const siteFolderName = isCloudflare ? siteDomain.split('.')[0] : 'web';
         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.`);
@@ -340,9 +356,9 @@ export default {
         }
         console.log(`  4. Update CLOUDFLARE_ZONE_ID in kama-worker/wrangler.json with your actual Zone ID`);
         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:cms' from the workspace root to start the backend.`);
+        console.log(`  6. Run 'npm run dev' from the workspace root to start everything.`);
     } else {
-        console.log(`  3. Run 'npm run dev:cms' from the workspace root to start the local SQLite backend.`);
+        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'.`);
     }
 }
@@ -390,6 +406,63 @@ async function createNewSiteOnly() {
     console.log(`\n✨ Site created in sites/${siteFolder}! Run 'npm install' at workspace root.`);
 }
 
+/**
+ * COMMAND: npx kama bundle
+ * Reads YAML from workspace and builds a static module for the worker
+ */
+async function bundleWorkspaceSchemas(targetRootDir) {
+    const rootDir = targetRootDir || process.cwd();
+    const defsDir = join(rootDir, 'content', 'definitions');
+    const workerDir = join(rootDir, 'kama-worker');
+
+    if (!existsSync(defsDir)) {
+        console.warn(`\n⚠️  Skipping schema bundling: 'content/definitions' folder not found at ${defsDir}`);
+        return;
+    }
+
+    console.log(`\n📦 Bundling workspace YAML schemas for Edge deployment...`);
+
+    function crawlDirectory(dir, baseDir, result = {}) {
+        if (!existsSync(dir)) return result;
+        const items = readdirSync(dir);
+        for (const item of items) {
+            const fullPath = join(dir, item);
+            if (existsSync(fullPath) && statSync(fullPath).isDirectory()) {
+                crawlDirectory(fullPath, baseDir, result);
+            } else if (fullPath.endsWith('.yaml') || fullPath.endsWith('.yml')) {
+                const relativePath = './' + relative(baseDir, fullPath).replace(/\\/g, '/');
+                result[relativePath] = readFileSync(fullPath, 'utf-8');
+            }
+        }
+        return result;
+    }
+
+    const rawGlobs = {
+        nodes: crawlDirectory(join(defsDir, 'nodes'), defsDir),
+        trees: crawlDirectory(join(defsDir, 'trees'), defsDir),
+        blocks: crawlDirectory(join(defsDir, 'blocks'), defsDir),
+        nodeLayouts: crawlDirectory(join(defsDir, 'node-layouts'), defsDir),
+        blockLayouts: crawlDirectory(join(defsDir, 'block-layouts'), defsDir),
+        fieldSets: crawlDirectory(join(defsDir, 'field-sets'), defsDir),
+        channels: crawlDirectory(join(defsDir, 'channels'), defsDir),
+    };
+
+    const fileContent = `// AUTO-GENERATED BUNDLE - DO NOT EDIT
+// This file is generated by 'npx kama bundle' prior to local dev or deployment.
+
+export default ${JSON.stringify(rawGlobs, null, 2)};
+`;
+
+    if (!existsSync(workerDir)) {
+        mkdirSync(workerDir, { recursive: true });
+    }
+
+    const outPath = join(workerDir, 'workspace-schemas.js');
+    writeFileSync(outPath, fileContent, 'utf-8');
+
+    console.log(`✅ Schema bundle generated successfully at ${outPath}`);
+}
+
 /**
  * COMMAND: npx kama promote
  * Promote current Local workspace to Cloudflare Edge
@@ -470,342 +543,62 @@ async function promoteLocalToCloudflare() {
     console.log(`  1. Run 'npm run deploy:cms' from the root to publish your backend and database.`);
 }
 
-function scaffoldSampleSchemas(rootDir) {
-    const defsDir = join(rootDir, 'content', 'definitions');
-
-    writeFileSync(join(defsDir, 'channels', 'website.yaml'), `id: website
-label: Main Website
-defaultLanguage: en
-languages:
-  - en
-  - fi
-`);
-
-    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
-`);
-
-    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
-`);
-
-    writeFileSync(join(defsDir, 'block-layouts', 'two-column.yaml'), `id: two-column
-label: Two Column Layout
-regions:
-  left:
-    label: Left Column
-  right:
-    label: Right Column
-`);
-
-    writeFileSync(join(defsDir, 'node-layouts', 'single-column.yml'), `id: single-column
-label: Single Column Page
-regions:
-  main:
-    label: Main Content Area
-`);
-
-    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
-`);
-
-    writeFileSync(join(defsDir, 'trees', 'navigation.yaml'), `id: navigation
-label: Main Navigation Tree
-maxDepth: 3
-allowedNodeTypes:
-  - page
-`);
-}
-
+/**
+ * Helper: Copies the Astro starter template and hydrates runtime tokens
+ */
 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 });
-
-    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': currentKamaVersion,
-                astro: '^7.2.0',
-                wrangler: '^4.0.0',
-            },
-        }, null, 2)
-    );
+    const templateDir = join(__dirname, '../templates/astro-starter');
 
-    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 }];
+    if (!existsSync(templateDir)) {
+        console.error(`❌ Error: Astro template not found at ${templateDir}`);
+        console.error(`Please ensure your Kama package installation is complete and templates are published.`);
+        return;
     }
 
-    writeFileSync(
-        join(siteDir, 'wrangler.json'),
-        JSON.stringify(siteWranglerConfig, null, 2)
-    );
-
-    const cmsHostname = cmsFullUrl.replace(/^https?:\/\//, '').split(':')[0];
-
-    const astroConfig = `import { defineConfig } from 'astro/config';
-import cloudflare from '@astrojs/cloudflare';
-
-export default defineConfig({
-  output: 'server',
-  trailingSlash: 'ignore',
-  image: {
-    remotePatterns: [
-      { protocol: 'http', hostname: 'localhost', port: '8787' },
-      { protocol: '${isCloudflare ? 'https' : 'http'}', hostname: '${cmsHostname}' }
-    ]
-  },
-  build: {
-    inlineStylesheets: 'always',
-  },
-  adapter: cloudflare({
-    imageService: 'cloudflare',
-  })
-});`;
-    writeFileSync(join(siteDir, 'astro.config.mjs'), astroConfig);
-
-    writeFileSync(
-        join(siteDir, '.env'),
-        `PUBLIC_CMS_URL="${cmsFullUrl}"\nPUBLIC_API_URL="${cmsFullUrl}"\n`
-    );
+    // 1. Copy the full, complete starter template directory directly
+    cpSync(templateDir, siteDir, { recursive: true });
 
-    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>`
-    );
-
-    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;
----
-<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>`
-    );
+    // 2. Hydrate package.json from template
+    const templatePkgPath = join(siteDir, 'package.json.template');
+    if (existsSync(templatePkgPath)) {
+        const pkgContent = readFileSync(templatePkgPath, 'utf-8')
+            .replace(/\{\{SITE_NAME\}\}/g, siteFolder)
+            .replace(/\{\{KAMA_VERSION\}\}/g, currentKamaVersion);
 
-    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; 
-    const cleanLookupPath = pathname.replace(/\\/$/, "") || "/";
-
-    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);
-                    }));
-                }
-                
-                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:\${cleanLookupPath}\`)
-                        ]);
-                        if (siteVer || pageVer) {
-                            await HTML_CACHE.delete(\`\${path}:v:\${siteVer || "1"}:\${pageVer || "1"}\`);
-                        }
-                        await HTML_CACHE.delete(\`v:\${path}\`);
-                    }));
-                }
-            }
-            
-            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 });
-        }
+        writeFileSync(join(siteDir, 'package.json'), pkgContent);
+        unlinkSync(templatePkgPath);
     }
 
-    const isWarmer = context.request.headers.get("X-Cache-Warmer") === "true";
-    const isHtmlPage = !pathname.includes('.') && !pathname.startsWith('/api/');
-    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);
+    // 3. Hydrate wrangler.json tokens
+    const wranglerPath = join(siteDir, 'wrangler.json');
+    if (existsSync(wranglerPath)) {
+        let wranglerStr = readFileSync(wranglerPath, 'utf-8')
+            .replace(/\{\{SITE_NAME\}\}/g, siteFolder)
+            .replace(/\{\{WORKER_NAME\}\}/g, workerName)
+            .replace(/\{\{CMS_URL\}\}/g, cmsFullUrl);
+
+        if (isCloudflare) {
+            const configObj = JSON.parse(wranglerStr);
+            configObj.routes = [{ pattern: siteDomain, custom_domain: true }];
+            wranglerStr = JSON.stringify(configObj, null, 2);
         }
-    }
 
-    const response = await next();
-
-    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);
+        writeFileSync(wranglerPath, wranglerStr);
     }
 
-    return response;
-});`
-    );
+    // 4. Create dynamic .env file
+    const envContent = [
+        `PUBLIC_CMS_URL="${cmsFullUrl}"`,
+        `PUBLIC_API_URL="${cmsFullUrl}"`,
+        `PUBLIC_CHANNEL_ID="website"`,
+        `PUBLIC_TREE_ID="main-navigation"`,
+        `PUBLIC_SITE_NAME="KAMA Starter"`
+    ].join('\n') + '\n';
 
-    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`);
-    }
+    writeFileSync(join(siteDir, '.env'), envContent);
 }
 
 main().catch(console.error);