@donotdev/cli 0.0.15 → 0.0.16

package/dist/index.js

@@ -8510,6 +8510,148 @@ var init_utils = __esm({
   }
 });
 
+// packages/tooling/src/utils/app-detection.ts
+function detectApps(projectRoot) {
+  const apps = [];
+  const appsDir = joinPath(projectRoot, "apps");
+  const appsDirStat = statSync2(appsDir);
+  if (pathExists(appsDir) && appsDirStat?.isDirectory()) {
+    const appDirs = readdirSync2(appsDir, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name).sort();
+    for (const appDir of appDirs) {
+      const appPath = joinPath(appsDir, appDir);
+      const packageJsonPath = joinPath(appPath, "package.json");
+      if (pathExists(packageJsonPath)) {
+        const appInfo = analyzeApp(appPath, appDir);
+        if (appInfo) {
+          apps.push(appInfo);
+        }
+      }
+    }
+  } else {
+    const packageJsonPath = joinPath(projectRoot, "package.json");
+    if (pathExists(packageJsonPath)) {
+      try {
+        const packageJson = readPackageJson(packageJsonPath);
+        if (packageJson && (packageJson.dependencies?.vite || packageJson.devDependencies?.vite || packageJson.dependencies?.next || packageJson.devDependencies?.next)) {
+          const pathParts = projectRoot.split(/[/\\]/);
+          const appName = pathParts[pathParts.length - 1] || "app";
+          const appInfo = analyzeApp(projectRoot, appName);
+          if (appInfo) {
+            apps.push(appInfo);
+          }
+        }
+      } catch {
+      }
+    }
+  }
+  return apps;
+}
+function analyzeApp(appPath, appName) {
+  const packageJsonPath = joinPath(appPath, "package.json");
+  if (!pathExists(packageJsonPath)) {
+    return null;
+  }
+  let packageJson = null;
+  try {
+    packageJson = readPackageJson(packageJsonPath);
+    if (!packageJson.name) {
+      return null;
+    }
+  } catch {
+    return null;
+  }
+  let framework = "unknown";
+  if (pathExists(joinPath(appPath, "next.config.js")) || pathExists(joinPath(appPath, "next.config.ts")) || pathExists(joinPath(appPath, "next.config.mjs")) || packageJson.dependencies?.next || packageJson.devDependencies?.next) {
+    framework = "nextjs";
+  } else if (pathExists(joinPath(appPath, "vite.config.ts")) || pathExists(joinPath(appPath, "vite.config.js")) || pathExists(joinPath(appPath, "vite.config.mjs")) || packageJson.dependencies?.vite || packageJson.devDependencies?.vite) {
+    framework = "vite";
+  }
+  const functionsPath = joinPath(appPath, "functions");
+  const functionsStat = statSync2(functionsPath);
+  const hasFunctions = pathExists(functionsPath) && (functionsStat?.isDirectory() ?? false);
+  let platform6;
+  const firebaseJsonInFunctions = hasFunctions && pathExists(joinPath(functionsPath, "firebase.json"));
+  const firebaseJsonInApp = pathExists(joinPath(appPath, "firebase.json"));
+  if (firebaseJsonInFunctions || firebaseJsonInApp) {
+    platform6 = "firebase";
+  }
+  if (!platform6) {
+    const supabaseConfigPath = joinPath(appPath, "supabase", "config.toml");
+    const hasSupabaseDep = !!(packageJson.dependencies?.["@donotdev/supabase"] || packageJson.dependencies?.["@supabase/supabase-js"]);
+    if (pathExists(supabaseConfigPath) || hasSupabaseDep) {
+      platform6 = "supabase";
+    }
+  }
+  if (!platform6) {
+    const vercelJsonPath = joinPath(appPath, "vercel.json");
+    if (pathExists(vercelJsonPath)) {
+      platform6 = "vercel";
+    }
+  }
+  return {
+    name: appName,
+    packageName: packageJson.name || appName,
+    path: appPath,
+    packageJsonPath,
+    framework,
+    hasFunctions,
+    functionsPath: hasFunctions ? functionsPath : void 0,
+    platform: platform6
+  };
+}
+var init_app_detection = __esm({
+  "packages/tooling/src/utils/app-detection.ts"() {
+    "use strict";
+    init_utils();
+    init_pathResolver();
+    init_typed_file_operations();
+  }
+});
+
+// packages/tooling/src/utils/app-selector.ts
+async function selectApp(projectRoot, appName) {
+  const apps = detectApps(projectRoot);
+  if (apps.length === 0) {
+    log.error("No apps found in this project.");
+    log.info('Run "dndev init" to create a new project.');
+    return null;
+  }
+  if (appName) {
+    const app = apps.find((a) => a.name === appName);
+    if (!app) {
+      log.warn(`App "${appName}" not found.`);
+      log.info("Available apps:");
+      apps.forEach((a) => log.info(`  - ${a.name}`));
+      log.info("Please select from the list:");
+    } else {
+      return app;
+    }
+  }
+  if (apps.length === 1) {
+    return apps[0] || null;
+  }
+  const selected = await ve({
+    message: "Select app:",
+    options: apps.map((app) => ({
+      value: app.name,
+      label: `${app.name} (${app.framework === "nextjs" ? "Next.js" : "Vite"}${app.hasFunctions ? ` + ${app.platform || "functions"}` : ""})`
+    }))
+  });
+  if (typeof selected !== "string") {
+    return null;
+  }
+  return apps.find((a) => a.name === selected) || null;
+}
+var init_app_selector = __esm({
+  "packages/tooling/src/utils/app-selector.ts"() {
+    "use strict";
+    init_utils();
+    init_dist2();
+    init_app_detection();
+    init_cli_output();
+  }
+});
+
 // packages/tooling/src/utils/cli-input.ts
 async function askForInput(message, defaultValue = "") {
   const result = await he({
@@ -8677,7 +8819,7 @@ function checkTsx() {
   return checkCLI("tsx");
 }
 function getCLIInstallInstructions(tool) {
-  const platform4 = process.platform;
+  const platform6 = process.platform;
   const instructions = {
     [CLI_TOOLS.BUN]: {
       win32: [
@@ -8730,15 +8872,15 @@ function getCLIInstallInstructions(tool) {
     },
     [CLI_TOOLS.SUPABASE]: {
       win32: [
-        "npm install -g supabase",
+        "scoop install supabase",
+        "Or: winget install Supabase.CLI",
         "Or download from: https://github.com/supabase/cli/releases"
       ],
       darwin: [
-        "brew install supabase/tap/supabase",
-        "Or: npm install -g supabase"
+        "brew install supabase/tap/supabase"
       ],
       linux: [
-        "npm install -g supabase",
+        "brew install supabase/tap/supabase",
         "Or see: https://supabase.com/docs/guides/cli"
       ]
     },
@@ -8791,7 +8933,7 @@ function getCLIInstallInstructions(tool) {
       linux: ["npm install -g tsx"]
     }
   };
-  const platformInstructions = instructions[tool]?.[platform4] || instructions[tool]?.linux || [];
+  const platformInstructions = instructions[tool]?.[platform6] || instructions[tool]?.linux || [];
   return platformInstructions.join("\n  \u2022 ");
 }
 function formatCLIMissingError(tool, additionalContext) {
@@ -8806,9 +8948,9 @@ function formatCLIMissingError(tool, additionalContext) {
     M2.info(`
 ${additionalContext}`);
   }
-  const platform4 = process.platform;
+  const platform6 = process.platform;
   M2.info("\nIf already installed, ensure it's in your PATH:");
-  if (platform4 === "win32") {
+  if (platform6 === "win32") {
     M2.message("  \u2022 Check with: where " + tool);
     M2.message(
       "  \u2022 Common location: C:\\Users\\<username>\\AppData\\Roaming\\npm\\"
@@ -8865,6 +9007,40 @@ var init_cli_tools = __esm({
   }
 });
 
+// packages/tooling/src/cli/setup/vercel-token.ts
+function readEnvVar(filePath, varName) {
+  if (!pathExists(filePath)) return null;
+  const content = readSync(filePath, { format: "text" });
+  if (typeof content !== "string") return null;
+  for (const line of content.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    if (trimmed.startsWith(`${varName}=`)) {
+      const val = trimmed.substring(`${varName}=`.length).trim();
+      if (val.startsWith('"') && val.endsWith('"') || val.startsWith("'") && val.endsWith("'")) {
+        return val.slice(1, -1);
+      }
+      return val || null;
+    }
+  }
+  return null;
+}
+function resolveVercelToken(appDir) {
+  if (process.env.VERCEL_TOKEN) return process.env.VERCEL_TOKEN;
+  const fromEnv = readEnvVar(joinPath(appDir, ".env"), "VERCEL_TOKEN");
+  if (fromEnv) return fromEnv;
+  const fromLocal = readEnvVar(joinPath(appDir, ".env.local"), "VERCEL_TOKEN");
+  if (fromLocal) return fromLocal;
+  return null;
+}
+var init_vercel_token = __esm({
+  "packages/tooling/src/cli/setup/vercel-token.ts"() {
+    "use strict";
+    init_utils();
+    init_pathResolver();
+  }
+});
+
 // node_modules/.bun/yaml@2.8.2/node_modules/yaml/dist/nodes/identity.js
 var require_identity = __commonJS({
   "node_modules/.bun/yaml@2.8.2/node_modules/yaml/dist/nodes/identity.js"(exports) {
@@ -16226,13 +16402,36 @@ var require_dist = __commonJS({
   }
 });
 
+// packages/tooling/src/utils/error-handling.ts
+function isError(error2) {
+  return error2 instanceof Error;
+}
+function getErrorMessage(error2) {
+  if (isError(error2)) {
+    return error2.message;
+  }
+  if (typeof error2 === "string") {
+    return error2;
+  }
+  if (error2 && typeof error2 === "object" && "message" in error2) {
+    return String(error2.message);
+  }
+  return String(error2);
+}
+var init_error_handling = __esm({
+  "packages/tooling/src/utils/error-handling.ts"() {
+    "use strict";
+    init_utils();
+  }
+});
+
 // packages/tooling/src/apps/sync-secrets.ts
 var sync_secrets_exports = {};
 __export(sync_secrets_exports, {
   default: () => sync_secrets_default,
   main: () => main5
 });
-import { spawnSync as spawnSync8 } from "node:child_process";
+import { spawnSync as spawnSync9 } from "node:child_process";
 function parseEnvFile(filePath) {
   if (!pathExists(filePath)) {
     throw new DoNotDevError(
@@ -16425,7 +16624,7 @@ async function setFirebaseSecret(key, value, projectId, dryRun = false, cwd) {
         NODE_OPTIONS: ""
         // Clear to avoid conflicts
       };
-      const result = spawnSync8(firebaseCmd, args, {
+      const result = spawnSync9(firebaseCmd, args, {
         input: value,
         encoding: "utf8",
         stdio: ["pipe", "pipe", "pipe"],
@@ -16521,7 +16720,7 @@ function setVercelSecret(key, value, projectId, dryRun = false) {
     if (projectId) {
       args.push("--project", projectId);
     }
-    const result = spawnSync8("vercel", args, {
+    const result = spawnSync9("vercel", args, {
       input: value,
       encoding: "utf8",
       stdio: ["pipe", "inherit", "inherit"]
@@ -16550,7 +16749,7 @@ function setVercelSecret(key, value, projectId, dryRun = false) {
 }
 function detectGitHubRepo() {
   try {
-    const result = spawnSync8("git", ["remote", "get-url", "origin"], {
+    const result = spawnSync9("git", ["remote", "get-url", "origin"], {
       encoding: "utf8",
       stdio: ["pipe", "pipe", "pipe"]
     });
@@ -16578,7 +16777,7 @@ function setGitHubSecret(key, value, repo, dryRun = false) {
     if (repo) {
       args.push("--repo", repo);
     }
-    const result = spawnSync8("gh", args, {
+    const result = spawnSync9("gh", args, {
       input: value,
       encoding: "utf8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -16752,12 +16951,12 @@ Examples:
       }
       return 0;
     }
-    const platform4 = config.platform || detectPlatform();
+    const platform6 = config.platform || detectPlatform();
     log.info(`Reading secrets from: ${envFilePath}`);
     if (config.verbose) {
       log.debug(`Working directory: ${currentDir}`);
       log.debug(`Environment file: ${envFilePath}`);
-      log.debug(`Platform: ${platform4}`);
+      log.debug(`Platform: ${platform6}`);
       log.debug(`Dry run mode: ${config.dryRun}`);
     }
     const secrets = parseEnvFile(envFilePath);
@@ -16766,7 +16965,7 @@ Examples:
       log.info("No secrets found in .env file");
       return 0;
     }
-    log.info(`Found ${secretKeys.length} secrets to sync to ${platform4}:`);
+    log.info(`Found ${secretKeys.length} secrets to sync to ${platform6}:`);
     secretKeys.forEach((key) => {
       if (config.verbose) {
         const value = secrets[key];
@@ -16777,12 +16976,12 @@ Examples:
         log.info(`  ${key}`);
       }
     });
-    const finalFirebaseProjectDir = platform4 === "firebase" ? firebaseProjectDir || findFirebaseProjectDir(config.envFile) : void 0;
+    const finalFirebaseProjectDir = platform6 === "firebase" ? firebaseProjectDir || findFirebaseProjectDir(config.envFile) : void 0;
     if (config.verbose && finalFirebaseProjectDir) {
       log.debug(`Firebase project directory: ${finalFirebaseProjectDir}`);
     }
     for (const [key, value] of Object.entries(secrets)) {
-      if (platform4 === "firebase") {
+      if (platform6 === "firebase") {
         await setFirebaseSecret(
           key,
           value,
@@ -16790,18 +16989,18 @@ Examples:
           config.dryRun,
           finalFirebaseProjectDir
         );
-      } else if (platform4 === "vercel") {
+      } else if (platform6 === "vercel") {
         setVercelSecret(key, value, config.vercelProjectId, config.dryRun);
       }
     }
     if (config.dryRun) {
       log.success(
         `
-Dry run completed. No secrets were actually set to ${platform4}.`
+Dry run completed. No secrets were actually set to ${platform6}.`
       );
     } else {
       log.success(`
-All secrets synced successfully to ${platform4}!`);
+All secrets synced successfully to ${platform6}!`);
     }
     return 0;
   } catch (err) {
@@ -16830,7 +17029,7 @@ var deploy_supabase_functions_exports = {};
 __export(deploy_supabase_functions_exports, {
   deploySupabaseFunctions: () => deploySupabaseFunctions
 });
-import { execSync as execSync8 } from "node:child_process";
+import { execSync as execSync9 } from "node:child_process";
 async function deploySupabaseFunctions(appDir, config) {
   const supabaseDir = joinPath(appDir, "supabase");
   const functionsDir = joinPath(supabaseDir, "functions");
@@ -16859,7 +17058,7 @@ async function deploySupabaseFunctions(appDir, config) {
   for (const functionName of functionDirs) {
     s.start(`Deploying Edge Function: ${functionName}...`);
     try {
-      execSync8(`supabase functions deploy ${functionName}`, {
+      execSync9(`supabase functions deploy ${functionName}`, {
         cwd: supabaseDir,
         stdio: config.verbose ? "inherit" : "pipe",
         env: {
@@ -16898,167 +17097,42 @@ init_utils();
 
 // packages/tooling/src/apps/build.ts
 init_utils();
-import { spawnSync, execSync } from "node:child_process";
-
-// packages/tooling/src/utils/app-selector.ts
-init_utils();
-init_dist2();
-
-// packages/tooling/src/utils/app-detection.ts
-init_utils();
+init_app_selector();
+init_cli_input();
+init_cli_output();
+init_errors();
 init_pathResolver();
 init_typed_file_operations();
-function detectApps(projectRoot) {
-  const apps = [];
-  const appsDir = joinPath(projectRoot, "apps");
-  const appsDirStat = statSync2(appsDir);
-  if (pathExists(appsDir) && appsDirStat?.isDirectory()) {
-    const appDirs = readdirSync2(appsDir, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name).sort();
-    for (const appDir of appDirs) {
-      const appPath = joinPath(appsDir, appDir);
-      const packageJsonPath = joinPath(appPath, "package.json");
-      if (pathExists(packageJsonPath)) {
-        const appInfo = analyzeApp(appPath, appDir);
-        if (appInfo) {
-          apps.push(appInfo);
-        }
-      }
-    }
-  } else {
-    const packageJsonPath = joinPath(projectRoot, "package.json");
-    if (pathExists(packageJsonPath)) {
-      try {
-        const packageJson = readPackageJson(packageJsonPath);
-        if (packageJson && (packageJson.dependencies?.vite || packageJson.devDependencies?.vite || packageJson.dependencies?.next || packageJson.devDependencies?.next)) {
-          const pathParts = projectRoot.split(/[/\\]/);
-          const appName = pathParts[pathParts.length - 1] || "app";
-          const appInfo = analyzeApp(projectRoot, appName);
-          if (appInfo) {
-            apps.push(appInfo);
-          }
-        }
-      } catch {
-      }
-    }
-  }
-  return apps;
-}
-function analyzeApp(appPath, appName) {
-  const packageJsonPath = joinPath(appPath, "package.json");
-  if (!pathExists(packageJsonPath)) {
-    return null;
+import { spawnSync, execSync } from "node:child_process";
+function validateFirebaseJson(appDir) {
+  const firebaseJsonPath = joinPath(appDir, "firebase.json");
+  if (!pathExists(firebaseJsonPath)) {
+    return {
+      valid: false,
+      hasHosting: false,
+      hasFunctions: false
+    };
   }
-  let packageJson = null;
   try {
-    packageJson = readPackageJson(packageJsonPath);
-    if (!packageJson.name) {
-      return null;
+    const config = readFirebaseJson(firebaseJsonPath);
+    if (!config.projectId) {
+      return {
+        valid: false,
+        hasHosting: false,
+        hasFunctions: false
+      };
     }
+    return {
+      valid: true,
+      hasHosting: !!config.hosting,
+      hasFunctions: !!config.functions && Array.isArray(config.functions)
+    };
   } catch {
-    return null;
-  }
-  let framework = "unknown";
-  if (pathExists(joinPath(appPath, "next.config.js")) || pathExists(joinPath(appPath, "next.config.ts")) || pathExists(joinPath(appPath, "next.config.mjs")) || packageJson.dependencies?.next || packageJson.devDependencies?.next) {
-    framework = "nextjs";
-  } else if (pathExists(joinPath(appPath, "vite.config.ts")) || pathExists(joinPath(appPath, "vite.config.js")) || pathExists(joinPath(appPath, "vite.config.mjs")) || packageJson.dependencies?.vite || packageJson.devDependencies?.vite) {
-    framework = "vite";
-  }
-  const functionsPath = joinPath(appPath, "functions");
-  const functionsStat = statSync2(functionsPath);
-  const hasFunctions = pathExists(functionsPath) && (functionsStat?.isDirectory() ?? false);
-  let platform4;
-  if (hasFunctions) {
-    const firebaseJsonPath = joinPath(functionsPath, "firebase.json");
-    const vercelJsonPath = joinPath(appPath, "vercel.json");
-    if (pathExists(firebaseJsonPath)) {
-      platform4 = "firebase";
-    } else if (pathExists(vercelJsonPath)) {
-      platform4 = "vercel";
-    }
-  }
-  return {
-    name: appName,
-    packageName: packageJson.name || appName,
-    path: appPath,
-    packageJsonPath,
-    framework,
-    hasFunctions,
-    functionsPath: hasFunctions ? functionsPath : void 0,
-    platform: platform4
-  };
-}
-
-// packages/tooling/src/utils/app-selector.ts
-init_cli_output();
-async function selectApp(projectRoot, appName) {
-  const apps = detectApps(projectRoot);
-  if (apps.length === 0) {
-    log.error("No apps found in this project.");
-    log.info('Run "dndev init" to create a new project.');
-    return null;
-  }
-  if (appName) {
-    const app = apps.find((a) => a.name === appName);
-    if (!app) {
-      log.warn(`App "${appName}" not found.`);
-      log.info("Available apps:");
-      apps.forEach((a) => log.info(`  - ${a.name}`));
-      log.info("Please select from the list:");
-    } else {
-      return app;
-    }
-  }
-  if (apps.length === 1) {
-    return apps[0] || null;
-  }
-  const selected = await ve({
-    message: "Select app:",
-    options: apps.map((app) => ({
-      value: app.name,
-      label: `${app.name} (${app.framework === "nextjs" ? "Next.js" : "Vite"}${app.hasFunctions ? ` + ${app.platform || "functions"}` : ""})`
-    }))
-  });
-  if (typeof selected !== "string") {
-    return null;
-  }
-  return apps.find((a) => a.name === selected) || null;
-}
-
-// packages/tooling/src/apps/build.ts
-init_cli_input();
-init_cli_output();
-init_errors();
-init_pathResolver();
-init_typed_file_operations();
-function validateFirebaseJson(appDir) {
-  const firebaseJsonPath = joinPath(appDir, "firebase.json");
-  if (!pathExists(firebaseJsonPath)) {
-    return {
-      valid: false,
-      hasHosting: false,
-      hasFunctions: false
-    };
-  }
-  try {
-    const config = readFirebaseJson(firebaseJsonPath);
-    if (!config.projectId) {
-      return {
-        valid: false,
-        hasHosting: false,
-        hasFunctions: false
-      };
-    }
-    return {
-      valid: true,
-      hasHosting: !!config.hosting,
-      hasFunctions: !!config.functions && Array.isArray(config.functions)
-    };
-  } catch {
-    return {
-      valid: false,
-      hasHosting: false,
-      hasFunctions: false
-    };
+    return {
+      valid: false,
+      hasHosting: false,
+      hasFunctions: false
+    };
   }
 }
 function parseBuildArgs(args) {
@@ -17220,11 +17294,12 @@ async function main() {
 
 // packages/tooling/src/apps/dev.ts
 init_utils();
-import { spawn, execSync as execSync3 } from "node:child_process";
-import { platform } from "node:os";
+init_app_selector();
 init_cli_output();
 init_errors();
 init_pathResolver();
+import { spawn, execSync as execSync3 } from "node:child_process";
+import { platform } from "node:os";
 
 // packages/tooling/src/utils/spawn-utils.ts
 init_utils();
@@ -17470,18 +17545,23 @@ async function main2() {
 
 // packages/tooling/src/apps/emu.ts
 init_utils();
+init_app_selector();
+init_cli_output();
+init_errors();
+init_pathResolver();
+
+// packages/tooling/src/apps/emu-firebase.ts
+init_utils();
+init_cli_input();
+init_cli_output();
+init_pathResolver();
+init_typed_file_operations();
 import {
   spawn as spawn2,
   spawnSync as spawnSync3,
   execSync as execSync4
 } from "node:child_process";
 import { platform as platform2 } from "node:os";
-init_cli_input();
-init_cli_output();
-init_errors();
-init_pathResolver();
-init_pathResolver();
-init_typed_file_operations();
 function discoverFirebaseProjectId(appPath) {
   const firebasercPath = joinPath(appPath, ".firebaserc");
   if (pathExists(firebasercPath)) {
@@ -17513,7 +17593,7 @@ function killPorts(ports) {
             pids.add(match[1]);
           }
         }
-        for (const pid of pids) {
+        for (const pid of Array.from(pids)) {
           try {
             execSync4(`taskkill /F /PID ${pid}`, { stdio: "ignore" });
             log.debug(`Killed process ${pid} on port ${port}`);
@@ -17575,9 +17655,9 @@ function loadEnvFile(filePath) {
   } catch {
   }
 }
-async function main3(options) {
-  const args = process.argv.slice(2);
-  const debug = options?.debug ?? false;
+async function startFirebase(app, projectRoot, options = {}) {
+  const debug = options.debug ?? false;
+  let selectedServices = options.selectedServices ?? [];
   const serviceChoices = [
     {
       title: "Auth",
@@ -17600,47 +17680,6 @@ async function main3(options) {
       hint: "Stripe webhook forwarding (for payment testing)"
     }
   ];
-  let selectedServices = [];
-  const appName = args.find(
-    (arg) => arg !== "emu" && arg !== "--debug" && !arg.startsWith("--")
-  );
-  if (options?.services) {
-    selectedServices = options.services.split(",").map((s) => s.trim());
-  } else {
-    const servicesArg = args.find((arg) => arg.startsWith("--services="));
-    if (servicesArg) {
-      const servicesList = servicesArg.split("=")[1];
-      if (servicesList) {
-        selectedServices = servicesList.split(",").map((s) => s.trim());
-      }
-    } else {
-      if (options?.auth || args.includes("--auth"))
-        selectedServices.push("auth");
-      if (args.includes("--functions")) selectedServices.push("functions");
-      if (options?.firestore || args.includes("--firestore"))
-        selectedServices.push("firestore");
-      if (options?.stripe || args.includes("--stripe"))
-        selectedServices.push("stripe");
-    }
-  }
-  const validServices = serviceChoices.map((c) => c.value);
-  selectedServices = selectedServices.filter((s) => validServices.includes(s));
-  const projectRoot = getRepoRoot();
-  if (!projectRoot) {
-    throw new DoNotDevError(
-      "Could not determine repository root",
-      "path-resolution-error"
-    );
-  }
-  const app = await selectApp(projectRoot, appName);
-  if (!app) {
-    return 1;
-  }
-  if (!app.hasFunctions || app.platform !== "firebase") {
-    log.error(`App "${app.name}" does not have Firebase functions.`);
-    log.error('Use "dndev dev" for apps without functions.\n');
-    return 1;
-  }
   log.info(`Starting Firebase emulators + dev server for ${app.name}...
 `);
   if (selectedServices.length === 0) {
@@ -17772,7 +17811,7 @@ FIREBASE_AUTH_EMULATOR_HOST=${authEmulatorHost}
     const stripeWebhookUrl = `http://localhost:5001/${projectId}/${region}/stripeWebhook`;
     concurrentlyArgs.push(`stripe listen --forward-to ${stripeWebhookUrl}`);
     log.info("");
-    log.info("\u2705 Stripe webhook forwarding will start automatically");
+    log.info("Stripe webhook forwarding will start automatically");
     log.info(`   Webhook URL: ${stripeWebhookUrl}`);
     log.info("   To trigger test events, run in another terminal:");
     log.info("     stripe trigger checkout.session.completed");
@@ -17794,9 +17833,7 @@ FIREBASE_AUTH_EMULATOR_HOST=${authEmulatorHost}
   );
   const SIGNAL_EXIT_CODES3 = {
     SIGINT: 130,
-    // 128 + 2
     SIGTERM: 143
-    // 128 + 15
   };
   const cleanup = (signal) => {
     if (!childProcess.pid) return;
@@ -17846,23 +17883,234 @@ FIREBASE_AUTH_EMULATOR_HOST=${authEmulatorHost}
     });
     childProcess.on("error", (error2) => {
       handlers.forEach((h2) => h2());
-      log.error(`Failed to start emulators: ${error2.message}`);
+      log.error(`Failed to start Firebase emulators: ${error2.message}`);
       resolve4(1);
     });
   });
 }
 
-// packages/tooling/src/apps/preview.ts
+// packages/tooling/src/apps/emu-supabase.ts
 init_utils();
+init_cli_output();
 import {
   spawn as spawn3,
-  spawnSync as spawnSync4,
   execSync as execSync5
 } from "node:child_process";
 import { platform as platform3 } from "node:os";
+function isDockerRunning() {
+  try {
+    execSync5("docker info", { stdio: "pipe", timeout: 5e3 });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function startSupabase(app, _projectRoot) {
+  log.info(`Starting Supabase local stack + dev server for ${app.name}...
+`);
+  if (!isDockerRunning()) {
+    log.error("Docker is not running. Supabase local dev requires Docker.");
+    log.error("Start Docker Desktop and try again.\n");
+    return 1;
+  }
+  try {
+    execSync5("supabase --version", { stdio: "pipe" });
+  } catch {
+    log.error("Supabase CLI not found. Install it:");
+    log.error("  npm install -g supabase\n");
+    return 1;
+  }
+  const isWindows = platform3() === "win32";
+  const concurrentlyArgs = [
+    "--kill-others-on-fail",
+    "--prefix-colors",
+    "cyan,green",
+    "--prefix",
+    "[{name}]",
+    "--names",
+    "supabase,dev",
+    "supabase start",
+    `bunx turbo dev --filter=${app.packageName}`
+  ];
+  const childProcess = spawn3(
+    "bunx",
+    ["concurrently", ...concurrentlyArgs],
+    {
+      stdio: "inherit",
+      cwd: app.path,
+      shell: isWindows
+    }
+  );
+  const cleanup = () => {
+    if (!childProcess.pid) return;
+    if (isWindows) {
+      try {
+        execSync5(`taskkill /F /T /PID ${childProcess.pid}`, { stdio: "ignore", timeout: 2e3 });
+      } catch {
+      }
+    } else {
+      try {
+        process.kill(childProcess.pid, "SIGTERM");
+      } catch {
+      }
+    }
+  };
+  process.on("SIGINT", () => {
+    cleanup();
+    process.exit(130);
+  });
+  process.on("SIGTERM", () => {
+    cleanup();
+    process.exit(143);
+  });
+  return new Promise((resolve4) => {
+    childProcess.on("exit", (code) => resolve4(code ?? 0));
+    childProcess.on("error", (error2) => {
+      log.error(`Failed to start Supabase local dev: ${error2.message}`);
+      resolve4(1);
+    });
+  });
+}
+
+// packages/tooling/src/apps/emu-vercel.ts
+init_utils();
+init_cli_output();
+import {
+  spawn as spawn4,
+  execSync as execSync6
+} from "node:child_process";
+import { platform as platform4 } from "node:os";
+async function startVercel(app, _projectRoot) {
+  log.info(`Starting Vercel dev server for ${app.name}...
+`);
+  try {
+    execSync6("vercel --version", { stdio: "pipe" });
+  } catch {
+    log.error("Vercel CLI not found. Install it:");
+    log.error("  npm install -g vercel\n");
+    return 1;
+  }
+  const isWindows = platform4() === "win32";
+  const childProcess = spawn4(
+    "vercel",
+    ["dev"],
+    {
+      stdio: "inherit",
+      cwd: app.path,
+      shell: isWindows
+    }
+  );
+  const cleanup = () => {
+    if (!childProcess.pid) return;
+    if (isWindows) {
+      try {
+        execSync6(`taskkill /F /T /PID ${childProcess.pid}`, { stdio: "ignore", timeout: 2e3 });
+      } catch {
+      }
+    } else {
+      try {
+        process.kill(childProcess.pid, "SIGTERM");
+      } catch {
+      }
+    }
+  };
+  process.on("SIGINT", () => {
+    cleanup();
+    process.exit(130);
+  });
+  process.on("SIGTERM", () => {
+    cleanup();
+    process.exit(143);
+  });
+  return new Promise((resolve4) => {
+    childProcess.on("exit", (code) => resolve4(code ?? 0));
+    childProcess.on("error", (error2) => {
+      log.error(`Failed to start Vercel dev: ${error2.message}`);
+      resolve4(1);
+    });
+  });
+}
+
+// packages/tooling/src/apps/emu.ts
+async function main3(options) {
+  const args = process.argv.slice(2);
+  const projectRoot = getRepoRoot();
+  if (!projectRoot) {
+    throw new DoNotDevError(
+      "Could not determine repository root",
+      "path-resolution-error"
+    );
+  }
+  const appName = args.find(
+    (arg) => arg !== "emu" && arg !== "--debug" && !arg.startsWith("--")
+  );
+  const app = await selectApp(projectRoot, appName);
+  if (!app) {
+    return 1;
+  }
+  switch (app.platform) {
+    case "firebase": {
+      if (!app.hasFunctions) {
+        log.error(`App "${app.name}" has Firebase config but no functions directory.`);
+        log.error('Use "dndev dev" for apps without backend functions.\n');
+        return 1;
+      }
+      const selectedServices = parseFirebaseServices(args, options);
+      return startFirebase(app, projectRoot, {
+        debug: options?.debug ?? false,
+        selectedServices
+      });
+    }
+    case "supabase":
+      return startSupabase(app, projectRoot);
+    case "vercel":
+      return startVercel(app, projectRoot);
+    default:
+      log.error(`App "${app.name}" does not have a detected backend platform.`);
+      log.error(
+        "Expected: firebase.json (Firebase), supabase/config.toml or @donotdev/supabase (Supabase), or vercel.json (Vercel)."
+      );
+      log.error('Use "dndev dev" for apps without a backend.\n');
+      return 1;
+  }
+}
+function parseFirebaseServices(args, options) {
+  const validServices = ["auth", "functions", "firestore", "stripe"];
+  let selectedServices = [];
+  if (options?.services) {
+    selectedServices = options.services.split(",").map((s) => s.trim());
+  } else {
+    const servicesArg = args.find((arg) => arg.startsWith("--services="));
+    if (servicesArg) {
+      const servicesList = servicesArg.split("=")[1];
+      if (servicesList) {
+        selectedServices = servicesList.split(",").map((s) => s.trim());
+      }
+    } else {
+      if (options?.auth || args.includes("--auth"))
+        selectedServices.push("auth");
+      if (args.includes("--functions")) selectedServices.push("functions");
+      if (options?.firestore || args.includes("--firestore"))
+        selectedServices.push("firestore");
+      if (options?.stripe || args.includes("--stripe"))
+        selectedServices.push("stripe");
+    }
+  }
+  return selectedServices.filter((s) => validServices.includes(s));
+}
+
+// packages/tooling/src/apps/preview.ts
+init_utils();
+init_app_selector();
 init_cli_output();
 init_errors();
 init_pathResolver();
+import {
+  spawn as spawn5,
+  spawnSync as spawnSync4,
+  execSync as execSync7
+} from "node:child_process";
+import { platform as platform5 } from "node:os";
 var SIGNAL_EXIT_CODES2 = {
   SIGINT: 130,
   // 128 + 2
@@ -17905,8 +18153,8 @@ async function main4() {
   log.info(`Previewing ${app.name}...
 `);
   const turboArgs = ["preview", "--filter", app.packageName];
-  const isWindows = platform3() === "win32";
-  const childProcess = spawn3("bunx", ["turbo", ...turboArgs], {
+  const isWindows = platform5() === "win32";
+  const childProcess = spawn5("bunx", ["turbo", ...turboArgs], {
     stdio: "inherit",
     env: createAppEnv(app.path),
     cwd: projectRoot,
@@ -17917,7 +18165,7 @@ async function main4() {
     log.debug(`Received ${signal}, cleaning up processes...`);
     if (isWindows) {
       try {
-        execSync5(`taskkill /F /T /PID ${childProcess.pid}`, {
+        execSync7(`taskkill /F /T /PID ${childProcess.pid}`, {
           stdio: "ignore",
           timeout: 2e3
         });
@@ -17929,7 +18177,7 @@ async function main4() {
       } catch {
       }
       try {
-        execSync5(`pkill -P ${childProcess.pid}`, {
+        execSync7(`pkill -P ${childProcess.pid}`, {
           stdio: "ignore",
           timeout: 1e3
         });
@@ -17968,7 +18216,7 @@ async function main4() {
 
 // packages/tooling/src/apps/deploy.ts
 init_utils();
-import { execSync as execSync9 } from "node:child_process";
+import { execSync as execSync10 } from "node:child_process";
 
 // packages/tooling/src/apps/deploy-frontend.ts
 init_utils();
@@ -18269,15 +18517,10 @@ function getMatrixPath(mode) {
   }
   const executionMode = mode || detectExecutionMode();
   if (executionMode === "development") {
-    const repoRoot = getRepoRoot();
-    if (repoRoot) {
-      const devPath = normalizePath(
-        repoRoot,
-        "packages/cli/dependencies-matrix.json"
-      );
-      if (pathExists(devPath)) {
-        return devPath;
-      }
+    const templatesRoot = getTemplatesRoot();
+    const devPath = normalizePath(templatesRoot, "..", "dependencies-matrix.json");
+    if (pathExists(devPath)) {
+      return devPath;
     }
   }
   return null;
@@ -18292,8 +18535,8 @@ function getCliVersion(mode) {
   }
   const executionMode = mode || detectExecutionMode();
   if (executionMode === "development") {
-    const repoRoot = getRepoRoot();
-    const cliPackageJson = joinPath(repoRoot, "packages/cli/package.json");
+    const templatesRoot = getTemplatesRoot();
+    const cliPackageJson = normalizePath(templatesRoot, "..", "package.json");
     if (pathExists(cliPackageJson)) {
       const pkg = readSync(cliPackageJson, { format: "json" });
       return String(pkg?.version || "0.0.0");
@@ -18470,15 +18713,31 @@ async function deployFrontend(appDir, serviceAccountPath, projectId, config) {
 
 // packages/tooling/src/apps/deploy-vercel-frontend.ts
 init_utils();
-import { execSync as execSync6 } from "node:child_process";
+init_cli_output();
+init_vercel_token();
+import { spawnSync as spawnSync6 } from "node:child_process";
 async function deployVercelFrontend(appDir, _config) {
   const s = Y2();
   s.start("Deploying frontend to Vercel...");
+  const token = resolveVercelToken(appDir);
+  if (token) {
+    log.debug("Using VERCEL_TOKEN from .env (token-based auth)");
+  }
+  const args = ["vercel", "--prod", "--yes"];
+  if (token) {
+    args.push("--token", token);
+  }
   try {
-    execSync6("npx vercel --prod --yes", {
+    const result = spawnSync6("bunx", args, {
       cwd: appDir,
-      stdio: "inherit"
+      stdio: "pipe",
+      encoding: "utf-8"
     });
+    if (result.status !== 0) {
+      s.stop("Vercel deployment failed");
+      const errOutput = result.stderr?.trim();
+      throw new Error(errOutput || `Vercel deploy exited with code ${result.status}`);
+    }
     s.stop("Frontend deployed to Vercel");
   } catch (err) {
     s.stop("Vercel deployment failed");
@@ -18489,7 +18748,7 @@ async function deployVercelFrontend(appDir, _config) {
 // packages/tooling/src/apps/deploy-functions.ts
 init_utils();
 var import_yaml = __toESM(require_dist(), 1);
-import { execSync as execSync7, spawnSync as spawnSync6 } from "node:child_process";
+import { execSync as execSync8, spawnSync as spawnSync7 } from "node:child_process";
 init_pathResolver();
 init_cli_tools();
 init_typed_file_operations();
@@ -18658,7 +18917,7 @@ function updateCloudRunIAM(functionNames, projectId, region, serviceAccountPath,
   let failCount = 0;
   for (const funcName of functionNames) {
     try {
-      const result = spawnSync6(
+      const result = spawnSync7(
         "gcloud",
         [
           "run",
@@ -18776,7 +19035,7 @@ async function autoSyncSecrets(functionsDir, projectId, config) {
     let failCount = 0;
     for (const { key, value } of secrets) {
       try {
-        const result = spawnSync6(
+        const result = spawnSync7(
           firebaseCmd,
           ["functions:secrets:set", key, "--project", projectId],
           {
@@ -18858,7 +19117,7 @@ To fix this, run:
       const s2 = Y2();
       s2.start("Building functions...");
       try {
-        execSync7("bun run build", {
+        execSync8("bun run build", {
           cwd: functionsDir,
           stdio: config.verbose ? "inherit" : "pipe"
         });
@@ -18958,29 +19217,10 @@ async function deployRules(appDir, serviceAccountPath, projectId, config, option
 
 // packages/tooling/src/apps/deploy-utils.ts
 init_utils();
-import { spawnSync as spawnSync7 } from "node:child_process";
+import { spawnSync as spawnSync8 } from "node:child_process";
 init_pathResolver();
 init_typed_file_operations();
-
-// packages/tooling/src/utils/error-handling.ts
-init_utils();
-function isError(error2) {
-  return error2 instanceof Error;
-}
-function getErrorMessage(error2) {
-  if (isError(error2)) {
-    return error2.message;
-  }
-  if (typeof error2 === "string") {
-    return error2;
-  }
-  if (error2 && typeof error2 === "object" && "message" in error2) {
-    return String(error2.message);
-  }
-  return String(error2);
-}
-
-// packages/tooling/src/apps/deploy-utils.ts
+init_error_handling();
 function detectAvailableApps() {
   const currentDir = process.cwd();
   const appsDir = joinPath(currentDir, "apps");
@@ -19165,7 +19405,7 @@ How to fix:
     if (shouldOpen) {
       try {
         const openCommand = process.platform === "win32" ? "start" : process.platform === "darwin" ? "open" : "xdg-open";
-        spawnSync7(openCommand, [consoleUrl], { shell: true });
+        spawnSync8(openCommand, [consoleUrl], { shell: true });
         log.success("Opening Firebase Console...");
       } catch {
         log.warn("Could not open browser. Please open the URL manually.");
@@ -19236,7 +19476,7 @@ function detectProvider(appDir) {
   if (hasFirebase) {
     try {
       const config = readSync(firebaseJsonPath, { format: "json" });
-      if (config && typeof config === "object" && "projectId" in config) {
+      if (config && typeof config === "object") {
         const firebaseConfigObj = config;
         firebaseConfig = {
           projectId: firebaseConfigObj.projectId,
@@ -19245,8 +19485,6 @@ function detectProvider(appDir) {
           hasFirestoreRules: !!firebaseConfigObj.firestore?.rules,
           hasStorageRules: !!firebaseConfigObj.storage?.rules
         };
-      } else {
-        throw new Error("Invalid firebase.json structure");
       }
     } catch {
       firebaseConfig = {
@@ -19554,7 +19792,7 @@ async function main6(options = {}) {
           isStaging ? "Building (staging mode)..." : "Building application..."
         );
         try {
-          execSync9(buildCmd, {
+          execSync10(buildCmd, {
             cwd: appDir,
             stdio: "inherit",
             env: {
@@ -19799,10 +20037,10 @@ function generatePackageJson(templateName, mode, options = {}) {
   }
   if (templateName.includes("functions")) {
     result.main = "lib/index.js";
-    result.engines = { node: "20" };
+    result.engines = { node: "22" };
     if (options.appName) {
-      const platform4 = templateName.includes("vercel") ? "Vercel" : "Firebase";
-      result.description = `${options.appName} ${platform4} Functions`;
+      const platform6 = templateName.includes("vercel") ? "Vercel" : "Firebase";
+      result.description = `${options.appName} ${platform6} Functions`;
     }
     if (mode === "development") {
       const workspacePkgs = [
@@ -19846,15 +20084,15 @@ init_utils();
 var MATRIX = [
   { builder: "vite", backend: "none", baseTemplate: "app-vite", overlay: null, deployConfig: null, functionsTemplate: null },
   { builder: "vite", backend: "firebase", baseTemplate: "app-vite", overlay: "overlay-firebase", deployConfig: "firebase", functionsTemplate: "functions-firebase" },
-  { builder: "vite", backend: "supabase", baseTemplate: "app-vite", overlay: "overlay-supabase", deployConfig: "vercel-supabase", functionsTemplate: null },
+  { builder: "vite", backend: "supabase", baseTemplate: "app-vite", overlay: "overlay-supabase", deployConfig: "vercel-supabase", functionsTemplate: "functions-supabase" },
   { builder: "vite", backend: "vercel", baseTemplate: "app-vite", overlay: "overlay-vercel", deployConfig: "vercel-vercel", functionsTemplate: "functions-vercel" },
   { builder: "nextjs", backend: "none", baseTemplate: "app-next", overlay: null, deployConfig: null, functionsTemplate: null },
   { builder: "nextjs", backend: "firebase", baseTemplate: "app-next", overlay: "overlay-firebase", deployConfig: "firebase", functionsTemplate: "functions-firebase" },
-  { builder: "nextjs", backend: "supabase", baseTemplate: "app-next", overlay: "overlay-supabase", deployConfig: "vercel-supabase", functionsTemplate: null },
+  { builder: "nextjs", backend: "supabase", baseTemplate: "app-next", overlay: "overlay-supabase", deployConfig: "vercel-supabase", functionsTemplate: "functions-supabase" },
   { builder: "nextjs", backend: "vercel", baseTemplate: "app-next", overlay: "overlay-vercel", deployConfig: "vercel-vercel", functionsTemplate: "functions-vercel" },
   { builder: "expo", backend: "none", baseTemplate: "app-expo", overlay: null, deployConfig: null, functionsTemplate: null },
   { builder: "expo", backend: "firebase", baseTemplate: "app-expo", overlay: "overlay-firebase", deployConfig: null, functionsTemplate: "functions-firebase" },
-  { builder: "expo", backend: "supabase", baseTemplate: "app-expo", overlay: "overlay-supabase", deployConfig: null, functionsTemplate: null },
+  { builder: "expo", backend: "supabase", baseTemplate: "app-expo", overlay: "overlay-supabase", deployConfig: null, functionsTemplate: "functions-supabase" },
   { builder: "demo", backend: "none", baseTemplate: "app-demo", overlay: null, deployConfig: null, functionsTemplate: null }
 ];
 function comboKey(builder, backend) {
@@ -20029,7 +20267,7 @@ async function createApp(appName, appConfig, workspaceRoot, templatesRoot) {
           if (providersVariant[1] !== appTemplate) continue;
           const destPath2 = joinPath(appDir, "src/config/providers.ts");
           await ensureDir(getDirname(destPath2));
-          await copy(joinPath(overlayDir, file), destPath2);
+          await copy(joinPath(overlayDir, file), destPath2, { overwrite: true });
           if (await isTextFile(destPath2)) await replacePlaceholders(destPath2, replacements);
           continue;
         }
@@ -20040,7 +20278,7 @@ async function createApp(appName, appConfig, workspaceRoot, templatesRoot) {
         }
         const destPath = joinPath(appDir, destFileName);
         await ensureDir(getDirname(destPath));
-        await copy(sourcePath, destPath);
+        await copy(sourcePath, destPath, { overwrite: true });
         if (await isTextFile(destPath)) {
           await replacePlaceholders(destPath, replacements);
         }
@@ -20083,23 +20321,26 @@ async function createApp(appName, appConfig, workspaceRoot, templatesRoot) {
     overwrite: true
   });
   if (row.functionsTemplate) {
-    const functionsRootDir = joinPath(appDir, "functions");
     const functionsTemplateName = row.functionsTemplate;
     const functionsTemplateExists = pathExists(joinPath(templatesRoot, functionsTemplateName));
     if (!functionsTemplateExists) {
       log.warn(`Functions template "${functionsTemplateName}" not found \u2014 skipping functions scaffolding.`);
     } else {
-      const functionsPackageJson = generatePackageJson(
-        functionsTemplateName,
-        executionMode,
-        { appName, platform: row.functionsTemplate.replace("functions-", "") }
-      );
-      const packageJsonPath2 = joinPath(functionsRootDir, "package.json");
-      await ensureDir(functionsRootDir);
-      await write(packageJsonPath2, functionsPackageJson, {
-        format: "json",
-        overwrite: true
-      });
+      const isSupabaseFunctions = functionsTemplateName === "functions-supabase";
+      const functionsRootDir = isSupabaseFunctions ? appDir : joinPath(appDir, "functions");
+      if (!isSupabaseFunctions) {
+        const functionsPackageJson = generatePackageJson(
+          functionsTemplateName,
+          executionMode,
+          { appName, platform: row.functionsTemplate.replace("functions-", "") }
+        );
+        const packageJsonPath2 = joinPath(functionsRootDir, "package.json");
+        await ensureDir(functionsRootDir);
+        await write(packageJsonPath2, functionsPackageJson, {
+          format: "json",
+          overwrite: true
+        });
+      }
       const templateDir2 = joinPath(templatesRoot, functionsTemplateName);
       const templateFiles2 = await glob("**/*", {
         cwd: templateDir2,
@@ -20132,6 +20373,18 @@ async function createApp(appName, appConfig, workspaceRoot, templatesRoot) {
       await copy(firebaseJsonSource, joinPath(appDir, "firebase.json"));
       const firebaseJsonDest = joinPath(appDir, "firebase.json");
       if (await isTextFile(firebaseJsonDest)) await replacePlaceholders(firebaseJsonDest, replacements);
+      if (appTemplate === "nextjs") {
+        const firebaseJson = readSync(firebaseJsonDest, { format: "json" });
+        if (firebaseJson.hosting?.rewrites) {
+          firebaseJson.hosting.rewrites = firebaseJson.hosting.rewrites.filter(
+            (r2) => r2.destination !== "/index.html"
+          );
+        }
+        if (firebaseJson.hosting) {
+          firebaseJson.hosting.public = "out";
+        }
+        await write(firebaseJsonDest, firebaseJson, { format: "json", overwrite: true });
+      }
     }
     const firebasercSource = joinPath(deploymentTemplateDir, ".firebaserc.example");
     if (pathExists(firebasercSource)) {
@@ -20148,6 +20401,44 @@ async function createApp(appName, appConfig, workspaceRoot, templatesRoot) {
       }
     }
   }
+  if (!deployConfig && backend === "firebase" && row.functionsTemplate) {
+    const firebaseJsonPath = joinPath(appDir, "firebase.json");
+    if (!pathExists(firebaseJsonPath)) {
+      const expoFirebaseJson = {
+        functions: [
+          {
+            source: "functions",
+            codebase: "default",
+            ignore: ["node_modules", ".git", "firebase-debug.log", "firebase-debug.*.log", "**/.*", "**/*.test.ts", "**/__tests__/**"],
+            runtime: "nodejs22"
+          }
+        ],
+        firestore: { rules: "firestore.rules", indexes: "firestore.indexes.json" },
+        storage: { rules: "storage.rules" },
+        emulators: {
+          auth: { port: 9099 },
+          functions: { port: 5001 },
+          firestore: { port: 8080 },
+          storage: { port: 9199 },
+          ui: { enabled: true, port: 4e3 }
+        }
+      };
+      await write(firebaseJsonPath, expoFirebaseJson, { format: "json", overwrite: true });
+    }
+    const firebasercSource = joinPath(deploymentTemplateDir, ".firebaserc.example");
+    const firebasercDest = joinPath(appDir, ".firebaserc");
+    if (pathExists(firebasercSource) && !pathExists(firebasercDest)) {
+      await copy(firebasercSource, firebasercDest);
+      if (await isTextFile(firebasercDest)) await replacePlaceholders(firebasercDest, replacements);
+    }
+    for (const example of ["firestore.rules.example", "firestore.indexes.json.example", "storage.rules.example"]) {
+      const src = joinPath(deploymentTemplateDir, example);
+      const dest = joinPath(appDir, example.replace(".example", ""));
+      if (pathExists(src) && !pathExists(dest)) {
+        await copy(src, dest);
+      }
+    }
+  }
   if (deployConfig === "vercel-vercel") {
     const vercelJsonSource = joinPath(deploymentTemplateDir, "vercel.json.example");
     if (pathExists(vercelJsonSource)) {
@@ -20228,23 +20519,25 @@ init_cli_input();
 init_cli_output();
 init_pathResolver();
 var SHOW_WIP2 = process.env.SHOW_WIP === "true" || process.argv.includes("--wip");
-var BACKEND_CHOICES = [
-  { title: "None", value: "none" },
-  {
-    title: "Firebase \u2014 Full platform (Auth, Firestore, Storage, Functions, Hosting)",
-    value: "firebase"
-  },
-  {
-    title: "Supabase \u2014 Auth, Postgres, Storage, Functions",
-    value: "supabase"
-  },
-  {
-    title: "Vercel \u2014 Serverless functions + Hosting (e.g. Next.js API routes)",
-    value: "vercel"
-  }
-];
-function getDefaultBackendIndex(framework) {
-  return framework === "nextjs" ? 3 : 1;
+async function collectAppConfig(appName) {
+  const answers = await runQuestionnaire(APP_QUESTIONNAIRE, {}, SHOW_WIP2, {
+    selection: askForSelection,
+    confirmation: askForConfirmation,
+    input: askForInput
+  });
+  const framework = answers.framework || "vite";
+  const needsBackend = answers.needsBackend || false;
+  const defaultPlatform = framework === "nextjs" ? "vercel" : "firebase";
+  return {
+    template: framework,
+    needsBackend,
+    backendPlatform: needsBackend ? answers.backendPlatform || defaultPlatform : void 0,
+    needsCRUD: false,
+    selectedEntities: [],
+    userAuth: "none",
+    billing: false,
+    features: []
+  };
 }
 function calculateRelativePath(from, to) {
   try {
@@ -20286,8 +20579,8 @@ async function main9(options) {
   try {
     Ie("\u{1F680} DoNotDev Project Creator");
     try {
-      const { execSync: execSync10 } = await import("node:child_process");
-      execSync10("bun --version", { stdio: "ignore" });
+      const { execSync: execSync11 } = await import("node:child_process");
+      execSync11("bun --version", { stdio: "ignore" });
     } catch {
       log.error("bun is required but not installed.");
       Me(
@@ -20357,71 +20650,22 @@ async function main9(options) {
     let appNames = [];
     const appConfigs = {};
     let anyAppNeedsBackend = false;
-    const firstAppName = await askForInput(
-      "What's your first app name? (press Enter to skip)",
-      ""
-    );
-    if (firstAppName && firstAppName.trim() !== "") {
-      const trimmedName = firstAppName.trim();
-      if (isReservedAppName(trimmedName)) {
-        log.warn(`'${trimmedName}' is reserved for framework demos.`);
-      } else if (!isValidFileName(trimmedName)) {
-        log.warn(
-          `Invalid app name. Use only letters, numbers, dashes (-), and underscores (_).`
-        );
-      } else {
-        appNames.push(trimmedName);
-        const framework = await askForSelection(
-          `Builder for "${trimmedName}"?`,
-          [
-            {
-              title: "Vite \u2014 SPA/SaaS (client-side rendering, fast dev)",
-              value: "vite"
-            },
-            {
-              title: "Next.js \u2014 Static content/SEO (SSR, SSG) \u2014 DoNotDev support: BETA",
-              value: "nextjs"
-            },
-            {
-              title: "Expo \u2014 Mobile app (iOS + Android, single codebase)",
-              value: "expo"
-            }
-          ],
-          0
-        );
-        const backendValue = await askForSelection(
-          `Backend for "${trimmedName}"?`,
-          [...BACKEND_CHOICES],
-          getDefaultBackendIndex(framework)
-        );
-        const needsBackend = backendValue !== "none";
-        if (needsBackend) anyAppNeedsBackend = true;
-        appConfigs[trimmedName] = {
-          template: framework,
-          needsBackend,
-          backendPlatform: needsBackend ? backendValue : void 0,
-          needsCRUD: false,
-          selectedEntities: [],
-          userAuth: "none",
-          billing: false,
-          features: []
-        };
-      }
-    }
-    while (appNames.length > 0) {
-      const appName = await askForInput("App name (press Enter to finish)", "");
-      if (!appName || appName.trim() === "") {
+    let isFirstApp = true;
+    while (true) {
+      const prompt = isFirstApp ? "What's your first app name? (press Enter to skip)" : "App name (press Enter to finish)";
+      const appNameInput = await askForInput(prompt, "");
+      if (!appNameInput || appNameInput.trim() === "") {
+        if (isFirstApp) break;
         break;
       }
-      const trimmedName = appName.trim();
+      const trimmedName = appNameInput.trim();
+      isFirstApp = false;
       if (appNames.includes(trimmedName)) {
         log.warn(`'${trimmedName}' already exists. Choose a different name.`);
         continue;
       }
       if (isReservedAppName(trimmedName)) {
-        log.warn(
-          `'${trimmedName}' is reserved for framework demos. Choose a different name.`
-        );
+        log.warn(`'${trimmedName}' is reserved for framework demos.`);
         continue;
       }
       if (!isValidFileName(trimmedName)) {
@@ -20431,37 +20675,10 @@ async function main9(options) {
         continue;
       }
       appNames.push(trimmedName);
-      const framework = await askForSelection(
-        `Builder for "${trimmedName}"?`,
-        [
-          {
-            title: "Vite \u2014 SPA/SaaS (client-side rendering, fast dev)",
-            value: "vite"
-          },
-          {
-            title: "Next.js \u2014 Static content/SEO (SSR, SSG) \u2014 DoNotDev support: BETA",
-            value: "nextjs"
-          }
-        ],
-        0
-      );
-      const backendValue = await askForSelection(
-        `Backend for "${trimmedName}"?`,
-        [...BACKEND_CHOICES],
-        getDefaultBackendIndex(framework)
-      );
-      const needsBackend = backendValue !== "none";
-      if (needsBackend) anyAppNeedsBackend = true;
-      appConfigs[trimmedName] = {
-        template: framework,
-        needsBackend,
-        backendPlatform: needsBackend ? backendValue : void 0,
-        needsCRUD: false,
-        selectedEntities: [],
-        userAuth: "none",
-        billing: false,
-        features: []
-      };
+      Me(`Configuring "${trimmedName}"...`, "\u2699\uFE0F");
+      const config = await collectAppConfig(trimmedName);
+      appConfigs[trimmedName] = config;
+      if (config.needsBackend) anyAppNeedsBackend = true;
     }
     let installDemoApp = await askForConfirmation(
       "Would you like to install the demo app? (component showcase)",
@@ -20793,7 +21010,7 @@ init_utils();
 init_cli_output();
 init_errors();
 init_pathResolver();
-import { spawnSync as spawnSync9 } from "node:child_process";
+import { spawnSync as spawnSync10 } from "node:child_process";
 import { EOL as EOL2 } from "node:os";
 async function main10(options = {}) {
   const dryRun = options.dryRun ?? false;
@@ -21270,7 +21487,7 @@ async function runPrettier(rootDir, dryRun, verbose) {
       log.info("DRY RUN: Would run Prettier");
       return stats;
     }
-    const result = spawnSync9("bunx", prettierArgs, {
+    const result = spawnSync10("bunx", prettierArgs, {
       cwd: rootDir,
       stdio: "pipe",
       shell: true,