clawfire 0.6.5 → 0.6.7

package/dist/{dev-server-LCKIGM6U.js → dev-server-5SXODXYN.js}

@@ -9,7 +9,7 @@ import {
 // src/dev/dev-server.ts
 import http from "http";
 import { resolve as resolve5, relative as relative2, extname as extname3 } from "path";
-import { existsSync as existsSync6, readFileSync as readFileSync5, writeFileSync as writeFileSync3 } from "fs";
+import { existsSync as existsSync6, readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "fs";
 import { pathToFileURL } from "url";
 
 // src/core/schema.ts
@@ -645,8 +645,8 @@ var FileWatcher = class extends EventEmitter {
 };
 
 // src/dev/page-compiler.ts
-import { resolve, join as join2, dirname, basename } from "path";
-import { existsSync as existsSync2, readFileSync } from "fs";
+import { resolve, join as join2, relative, dirname, basename } from "path";
+import { existsSync as existsSync2, readFileSync, readdirSync as readdirSync2, statSync as statSync2, writeFileSync, mkdirSync } from "fs";
 var MAX_COMPONENT_DEPTH = 10;
 var META_REGEX = /<!--\s*@(\w+):\s*(.+?)\s*-->/g;
 var COMPONENT_REGEX = /<c-([a-z][a-z0-9-]*)\s*\/>/g;
@@ -741,6 +741,62 @@ var PageCompiler = class {
       path: pathname
     };
   }
+  /**
+   * Build all pages into static HTML for production deployment.
+   * Walks app/pages/ recursively, compiles each page, and writes to outputDir.
+   *
+   * - Skips _layout.html (wrapper-only, not standalone)
+   * - _404.html → 404.html (Firebase auto-serves for 404s)
+   * - Injects optional script (e.g. production router) before </body>
+   */
+  buildForProduction(outputDir, scriptToInject) {
+    const pages = [];
+    const errors = [];
+    if (!this.isActive()) {
+      return { pages, errors };
+    }
+    const walk = (dir) => {
+      const entries = readdirSync2(dir);
+      for (const entry of entries) {
+        const fullPath = join2(dir, entry);
+        const stat = statSync2(fullPath);
+        if (stat.isDirectory()) {
+          walk(fullPath);
+          continue;
+        }
+        if (!entry.endsWith(".html")) continue;
+        if (entry === "_layout.html") continue;
+        try {
+          const compiled = this.compile(fullPath);
+          let html = compiled.html;
+          if (scriptToInject) {
+            if (html.includes("</body>")) {
+              html = html.replace("</body>", scriptToInject + "\n</body>");
+            } else {
+              html += scriptToInject;
+            }
+          }
+          const relPath = relative(this.pagesDir, fullPath);
+          let outputPath;
+          if (entry === "_404.html") {
+            const parentRel = relative(this.pagesDir, dir);
+            outputPath = parentRel ? join2(outputDir, parentRel, "404.html") : join2(outputDir, "404.html");
+          } else {
+            outputPath = join2(outputDir, relPath);
+          }
+          const outputDirPath = dirname(outputPath);
+          mkdirSync(outputDirPath, { recursive: true });
+          writeFileSync(outputPath, html, "utf-8");
+          pages.push(relPath);
+        } catch (err) {
+          const relPath = relative(this.pagesDir, fullPath);
+          errors.push(`${relPath}: ${err instanceof Error ? err.message : "Unknown error"}`);
+        }
+      }
+    };
+    walk(this.pagesDir);
+    return { pages, errors };
+  }
   // ─── Internal Methods ────────────────────────────────────────────
   /**
    * Extract <!-- @key: value --> metadata from HTML.
@@ -819,7 +875,7 @@ ${html}
 };
 
 // src/dev/env-manager.ts
-import { readFileSync as readFileSync2, writeFileSync, existsSync as existsSync3 } from "fs";
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, existsSync as existsSync3 } from "fs";
 import { resolve as resolve2 } from "path";
 var KEY_PATTERN = /^[A-Z_][A-Z0-9_]*$/i;
 var PLACEHOLDER_PATTERNS = [
@@ -893,7 +949,7 @@ var EnvManager = class {
         lines.push(`${key}=${value}`);
       }
     }
-    writeFileSync(this.envPath, lines.join("\n"), "utf-8");
+    writeFileSync2(this.envPath, lines.join("\n"), "utf-8");
     if (description !== void 0) {
       const descriptions = this.readDescriptions();
       descriptions[key] = description;
@@ -911,7 +967,7 @@ var EnvManager = class {
       if (eqIdx === -1) return true;
       return trimmed.slice(0, eqIdx).trim() !== key;
     });
-    writeFileSync(this.envPath, filtered.join("\n"), "utf-8");
+    writeFileSync2(this.envPath, filtered.join("\n"), "utf-8");
     const descriptions = this.readDescriptions();
     if (key in descriptions) {
       delete descriptions[key];
@@ -928,7 +984,7 @@ var EnvManager = class {
     }
   }
   writeDescriptions(descriptions) {
-    writeFileSync(
+    writeFileSync2(
       this.descriptionsPath,
       JSON.stringify(descriptions, null, 2) + "\n",
       "utf-8"
@@ -1856,8 +1912,9 @@ function generateDashboardHtml(options) {
     }
 
     btn.disabled = true;
-    btn.textContent = 'Setting...';
-    status.style.display = 'none';
+    btn.textContent = 'Setting up...';
+    status.textContent = 'Selecting project, detecting web app, auto-filling config...';
+    status.style.cssText = 'display:block;margin-top:8px;font-size:13px;padding:8px 12px;border-radius:6px;background:#0a0a1c;border:1px solid #3b82f6;color:#93c5fd;';
 
     fetch(API + '/__dev/setup/select-project', {
       method: 'POST',
@@ -1867,8 +1924,11 @@ function generateDashboardHtml(options) {
     .then(function(r) { return r.json(); })
     .then(function(data) {
       if (data.success) {
-        status.textContent = data.message;
-        status.style.cssText = 'display:block;margin-top:8px;font-size:13px;padding:8px 12px;border-radius:6px;background:#0a1a0a;border:1px solid #22c55e;color:#22c55e;';
+        var msg = data.steps ? data.steps.join('\\n') : data.message;
+        status.textContent = msg;
+        status.style.whiteSpace = 'pre-line';
+        status.style.cssText = 'display:block;margin-top:8px;font-size:13px;padding:8px 12px;border-radius:6px;background:#0a1a0a;border:1px solid #22c55e;color:#22c55e;white-space:pre-line;';
+        btn.textContent = 'Done';
         setTimeout(refreshSetupStatus, 1000);
       } else {
         status.textContent = data.message;
@@ -2577,7 +2637,7 @@ function generateDashboardHtml(options) {
 
 // src/dev/firebase-setup.ts
 import { execFile as execFile2, spawn } from "child_process";
-import { existsSync as existsSync5, readFileSync as readFileSync4, writeFileSync as writeFileSync2 } from "fs";
+import { existsSync as existsSync5, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "fs";
 import { resolve as resolve4, join as join3 } from "path";
 import { tmpdir, platform, homedir } from "os";
 var FirebaseSetup = class {
@@ -2600,7 +2660,7 @@ var FirebaseSetup = class {
   saveState(partial) {
     const current = this.loadState();
     const merged = { ...current, ...partial, lastUpdated: (/* @__PURE__ */ new Date()).toISOString() };
-    writeFileSync2(this.stateFilePath, JSON.stringify(merged, null, 2) + "\n", "utf-8");
+    writeFileSync3(this.stateFilePath, JSON.stringify(merged, null, 2) + "\n", "utf-8");
   }
   // ─── Status Check ──────────────────────────────────────────────────
   async getStatus() {
@@ -2702,7 +2762,7 @@ var FirebaseSetup = class {
     try {
       if (os === "darwin") {
         const scriptPath = join3(tmpdir(), "clawfire-firebase-login.command");
-        writeFileSync2(scriptPath, [
+        writeFileSync3(scriptPath, [
           "#!/bin/bash",
           `cd "${this.projectDir}"`,
           cmd,
@@ -2724,7 +2784,7 @@ var FirebaseSetup = class {
         child.unref();
       } else {
         const scriptPath = join3(tmpdir(), "clawfire-firebase-login.sh");
-        writeFileSync2(scriptPath, [
+        writeFileSync3(scriptPath, [
           "#!/bin/bash",
           `cd "${this.projectDir}"`,
           cmd,
@@ -2833,7 +2893,7 @@ var FirebaseSetup = class {
         rc.projects = {};
       }
       rc.projects.default = projectId;
-      writeFileSync2(firebasercPath, JSON.stringify(rc, null, 2) + "\n", "utf-8");
+      writeFileSync3(firebasercPath, JSON.stringify(rc, null, 2) + "\n", "utf-8");
       return { success: true, message: `Active project set to "${projectId}".` };
     } catch {
       try {
@@ -2841,7 +2901,7 @@ var FirebaseSetup = class {
         const rc = {
           projects: { default: projectId }
         };
-        writeFileSync2(firebasercPath, JSON.stringify(rc, null, 2) + "\n", "utf-8");
+        writeFileSync3(firebasercPath, JSON.stringify(rc, null, 2) + "\n", "utf-8");
         return { success: true, message: `Active project set to "${projectId}" (via .firebaserc).` };
       } catch (writeErr) {
         const msg = writeErr instanceof Error ? writeErr.message : "Unknown error";
@@ -2960,7 +3020,11 @@ var FirebaseSetup = class {
           config.hosting = {
             public: "public",
             ignore: ["firebase.json", "**/.*", "**/node_modules/**"],
-            rewrites: [{ source: "**", destination: "/index.html" }]
+            cleanUrls: true,
+            rewrites: [
+              { source: "/api/**", function: "api" },
+              { source: "**", destination: "/index.html" }
+            ]
           };
         }
         break;
@@ -2974,14 +3038,14 @@ var FirebaseSetup = class {
         }
         const rulesPath = resolve4(this.projectDir, "firestore.rules");
         if (!existsSync5(rulesPath)) {
-          writeFileSync2(
+          writeFileSync3(
             rulesPath,
             "rules_version = '2';\nservice cloud.firestore {\n  match /databases/{database}/documents {\n    match /{document=**} {\n      allow read, write: if request.auth != null;\n    }\n  }\n}\n"
           );
         }
         const indexesPath = resolve4(this.projectDir, "firestore.indexes.json");
         if (!existsSync5(indexesPath)) {
-          writeFileSync2(indexesPath, JSON.stringify({ indexes: [], fieldOverrides: [] }, null, 2) + "\n");
+          writeFileSync3(indexesPath, JSON.stringify({ indexes: [], fieldOverrides: [] }, null, 2) + "\n");
         }
         break;
       }
@@ -2991,7 +3055,7 @@ var FirebaseSetup = class {
         }
         const storageRulesPath = resolve4(this.projectDir, "storage.rules");
         if (!existsSync5(storageRulesPath)) {
-          writeFileSync2(
+          writeFileSync3(
             storageRulesPath,
             "rules_version = '2';\nservice firebase.storage {\n  match /b/{bucket}/o {\n    match /{allPaths=**} {\n      allow read, write: if request.auth != null;\n    }\n  }\n}\n"
           );
@@ -2999,7 +3063,7 @@ var FirebaseSetup = class {
         break;
       }
     }
-    writeFileSync2(firebaseJsonPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+    writeFileSync3(firebaseJsonPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
     return { success: true, message: `${service} enabled in firebase.json.` };
   }
   // ─── Firestore Database Automation ──────────────────────────────────
@@ -3119,41 +3183,48 @@ https://console.developers.google.com/apis/api/firestore.googleapis.com/overview
    * Handles "ALREADY_EXISTS" gracefully — returns success.
    */
   async createFirestoreDatabase(location = "nam5") {
-    try {
-      await this.execTimeout(
-        "firebase",
-        ["firestore:databases:create", "(default)", "--location", location, "--json"],
-        6e4
-      );
-      return { success: true, message: `Firestore database created (location: ${location}).` };
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : "Unknown error";
-      if (msg.includes("ALREADY_EXISTS") || msg.includes("already exists")) {
-        return { success: true, message: "Firestore database already exists." };
-      }
-      if (msg.includes("403") || msg.includes("has not been used") || msg.includes("is disabled")) {
-        const enableResult = await this.enableFirestoreApi();
-        if (!enableResult.success) {
-          return enableResult;
+    const dbArgs = ["firestore:databases:create", "(default)", "--location", location, "--json"];
+    const tryCreate = async () => {
+      try {
+        await this.execTimeout("firebase", dbArgs, 6e4);
+        return { ok: true, alreadyExists: false, needsApi: false, msg: "" };
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : "Unknown error";
+        if (msg.includes("ALREADY_EXISTS") || msg.includes("already exists")) {
+          return { ok: true, alreadyExists: true, needsApi: false, msg };
         }
-        await new Promise((r) => setTimeout(r, 5e3));
-        try {
-          await this.execTimeout(
-            "firebase",
-            ["firestore:databases:create", "(default)", "--location", location, "--json"],
-            6e4
-          );
-          return { success: true, message: `Firestore API enabled and database created (location: ${location}).` };
-        } catch (retryErr) {
-          const retryMsg = retryErr instanceof Error ? retryErr.message : "Unknown error";
-          if (retryMsg.includes("ALREADY_EXISTS") || retryMsg.includes("already exists")) {
-            return { success: true, message: "Firestore database already exists." };
-          }
-          return { success: false, message: `Failed to create Firestore database after enabling API: ${retryMsg}` };
+        if (msg.includes("403") || msg.includes("has not been used") || msg.includes("is disabled")) {
+          return { ok: false, alreadyExists: false, needsApi: true, msg };
         }
+        return { ok: false, alreadyExists: false, needsApi: false, msg };
+      }
+    };
+    const first = await tryCreate();
+    if (first.ok) {
+      return { success: true, message: first.alreadyExists ? "Firestore database already exists." : `Firestore database created (location: ${location}).` };
+    }
+    if (!first.needsApi) {
+      return { success: false, message: `Failed to create Firestore database: ${first.msg}` };
+    }
+    const enableResult = await this.enableFirestoreApi();
+    if (!enableResult.success) {
+      return enableResult;
+    }
+    const waits = [5e3, 5e3, 1e4, 1e4, 15e3];
+    for (let i = 0; i < waits.length; i++) {
+      await new Promise((r) => setTimeout(r, waits[i]));
+      const retry = await tryCreate();
+      if (retry.ok) {
+        return { success: true, message: `Firestore API enabled and database created (location: ${location}).` };
+      }
+      if (!retry.needsApi) {
+        return { success: false, message: `Failed to create Firestore database: ${retry.msg}` };
       }
-      return { success: false, message: `Failed to create Firestore database: ${msg}` };
     }
+    return {
+      success: false,
+      message: "Firestore API was enabled but database creation timed out waiting for propagation. Please wait a minute and try again."
+    };
   }
   /**
    * Deploy open Firestore security rules for dev testing.
@@ -3163,7 +3234,7 @@ https://console.developers.google.com/apis/api/firestore.googleapis.com/overview
     const rulesPath = resolve4(this.projectDir, "firestore.rules");
     try {
       if (openForDev) {
-        writeFileSync2(
+        writeFileSync3(
           rulesPath,
           "rules_version = '2';\nservice cloud.firestore {\n  match /databases/{database}/documents {\n    match /{document=**} {\n      allow read, write: if true;\n    }\n  }\n}\n"
         );
@@ -3429,6 +3500,92 @@ function generateRouterScript() {
 })();
 </script>`;
 }
+function generateProductionRouterScript() {
+  return `
+<script data-clawfire-router>
+(function() {
+  function updateActiveNav() {
+    var path = location.pathname;
+    var links = document.querySelectorAll('#nav-links a[href]');
+    for (var i = 0; i < links.length; i++) {
+      var href = links[i].getAttribute('href');
+      if (!href || href.startsWith('http')) continue;
+      var isActive = (path === '/' && href === '/') || (href !== '/' && path.startsWith(href));
+      links[i].setAttribute('data-active', isActive ? 'true' : 'false');
+    }
+  }
+
+  function navigate(url) {
+    var target = new URL(url, location.href);
+    if (target.origin !== location.origin) return false;
+    if (target.pathname === location.pathname && target.hash) return false;
+
+    fetch(target.pathname)
+    .then(function(res) {
+      if (!res.ok) throw new Error('Page not found');
+      return res.text();
+    })
+    .then(function(html) {
+      // Parse the fetched full HTML and extract #clawfire-page content
+      var parser = new DOMParser();
+      var doc = parser.parseFromString(html, 'text/html');
+      var newPage = doc.getElementById('clawfire-page');
+      if (!newPage) throw new Error('No #clawfire-page found');
+
+      var container = document.getElementById('clawfire-page');
+      if (container) {
+        container.innerHTML = newPage.innerHTML;
+        // Execute scripts in new content
+        var scripts = container.querySelectorAll('script');
+        for (var i = 0; i < scripts.length; i++) {
+          var newScript = document.createElement('script');
+          if (scripts[i].src) {
+            newScript.src = scripts[i].src;
+          } else {
+            newScript.textContent = scripts[i].textContent;
+          }
+          scripts[i].parentNode.replaceChild(newScript, scripts[i]);
+        }
+      }
+      // Update title from fetched document
+      var newTitle = doc.querySelector('title');
+      if (newTitle) document.title = newTitle.textContent || '';
+      // Update URL
+      history.pushState(null, '', target.pathname);
+      updateActiveNav();
+      document.dispatchEvent(new CustomEvent('clawfire:navigate', { detail: { path: target.pathname } }));
+      window.scrollTo(0, 0);
+    })
+    .catch(function() {
+      // Fallback: full page navigation
+      location.href = url;
+    });
+
+    return true;
+  }
+
+  document.addEventListener('click', function(e) {
+    var anchor = e.target.closest ? e.target.closest('a[href]') : null;
+    if (!anchor) return;
+    var href = anchor.getAttribute('href');
+    if (!href) return;
+    if (href.startsWith('http') || href.startsWith('//')) return;
+    if (anchor.target === '_blank') return;
+    if (e.ctrlKey || e.metaKey || e.shiftKey || e.altKey) return;
+    if (anchor.hasAttribute('download')) return;
+
+    e.preventDefault();
+    navigate(href);
+  });
+
+  window.addEventListener('popstate', function() {
+    navigate(location.pathname);
+  });
+
+  updateActiveNav();
+})();
+</script>`;
+}
 var DevServer = class {
   frontendServer = null;
   apiServer = null;
@@ -4173,10 +4330,57 @@ ${liveReloadScript}
             sendJson({ success: false, message: "projectId is required" }, 400);
             return;
           }
-          this.firebaseSetup.selectProject(data.projectId).then((result) => {
+          (async () => {
+            const selectResult = await this.firebaseSetup.selectProject(data.projectId);
+            if (!selectResult.success) {
+              sendJson(selectResult);
+              return;
+            }
+            const steps = [selectResult.message];
+            try {
+              const { apps } = await this.firebaseSetup.listWebApps();
+              let webAppId = "";
+              if (apps.length > 0) {
+                webAppId = apps[0].appId;
+                this.firebaseSetup.selectWebApp(apps[0].appId, apps[0].displayName);
+                steps.push(`Web app "${apps[0].displayName}" selected.`);
+              } else {
+                const createResult = await this.firebaseSetup.createWebApp(data.projectId);
+                if (createResult.success && createResult.appId) {
+                  webAppId = createResult.appId;
+                  steps.push(`Web app "${data.projectId}" created.`);
+                } else {
+                  steps.push(`Web app creation skipped: ${createResult.message}`);
+                }
+              }
+              if (webAppId) {
+                try {
+                  const sdkConfig = await fetchFirebaseSdkConfig(this.options.projectDir, webAppId);
+                  const fields = {};
+                  for (const [key, value] of Object.entries(sdkConfig)) {
+                    if (value && typeof value === "string") {
+                      fields[key] = value;
+                    }
+                  }
+                  if (Object.keys(fields).length > 0) {
+                    for (const [key, value] of Object.entries(fields)) {
+                      try {
+                        this.updateProjectConfig(key, value);
+                      } catch {
+                      }
+                    }
+                    steps.push("Config auto-filled in clawfire.config.ts.");
+                  }
+                } catch (configErr) {
+                  steps.push(`Config auto-fill skipped: ${configErr instanceof Error ? configErr.message : "unknown error"}`);
+                }
+              }
+            } catch (autoFillErr) {
+              steps.push(`Auto-setup partial: ${autoFillErr instanceof Error ? autoFillErr.message : "unknown error"}`);
+            }
             clearFirebaseStatusCache();
-            sendJson(result);
-          }).catch((err) => sendJson({ success: false, message: err instanceof Error ? err.message : "Failed" }, 500));
+            sendJson({ success: true, message: steps.join(" "), steps });
+          })().catch((err) => sendJson({ success: false, message: err instanceof Error ? err.message : "Failed" }, 500));
         } catch {
           sendJson({ success: false, message: "Invalid JSON body" }, 400);
         }
@@ -4210,10 +4414,25 @@ ${liveReloadScript}
       return;
     }
     if (url.pathname === "/__dev/deploy/hosting" && req.method === "POST") {
-      this.firebaseSetup.deployHosting().then((result) => {
-        clearFirebaseStatusCache();
-        sendJson(result);
-      }).catch((err) => sendJson({ success: false, message: err instanceof Error ? err.message : "Failed" }, 500));
+      (async () => {
+        try {
+          if (this.pageCompiler.isActive()) {
+            const routerScript = generateProductionRouterScript();
+            const buildResult = this.pageCompiler.buildForProduction(this.publicDir, routerScript);
+            console.log(`  \x1B[32m\u2713\x1B[0m Built ${buildResult.pages.length} pages for production`);
+            if (buildResult.errors.length > 0) {
+              for (const err of buildResult.errors) {
+                console.log(`  \x1B[31m\u2717\x1B[0m ${err}`);
+              }
+            }
+          }
+          const result = await this.firebaseSetup.deployHosting();
+          clearFirebaseStatusCache();
+          sendJson(result);
+        } catch (err) {
+          sendJson({ success: false, message: err instanceof Error ? err.message : "Failed" }, 500);
+        }
+      })();
       return;
     }
     if (url.pathname === "/__dev/enable-service" && req.method === "POST") {
@@ -4360,7 +4579,7 @@ ${liveReloadScript}
       throw new Error(`Key "${key}" not found in config`);
     }
     content = content.replace(pattern, `$1"${value.replace(/"/g, '\\"')}"`);
-    writeFileSync3(configPath, content, "utf-8");
+    writeFileSync4(configPath, content, "utf-8");
   }
   escapeRegex(s) {
     return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");