@donotdev/cli 0.0.14 → 0.0.16

package/dist/bin/commands/create-app.js

@@ -7884,16 +7884,19 @@ function getBinPath(binaryName) {
   return binaryName;
 }
 function detectExecutionMode() {
-  const fileUrlPath = new URL(import.meta.url).pathname;
-  if (!fileUrlPath.includes("node_modules")) {
-    return "development";
+  const fileUrlPath = fileURLToPath2(import.meta.url);
+  if (fileUrlPath.includes("node_modules")) {
+    return "published";
   }
-  return "published";
+  if (fileUrlPath.includes("/dist/")) {
+    return "published";
+  }
+  return "development";
 }
 function getTemplatesRoot() {
   const mode = detectExecutionMode();
   if (mode === "development") {
-    const fileUrlPath = new URL(import.meta.url).pathname;
+    const fileUrlPath = fileURLToPath2(import.meta.url);
     const frameworkRoot = normalizePath(dirname2(fileUrlPath), "../../../..");
     return normalizePath(frameworkRoot, PACKAGE_PATHS.CLI, "templates");
   } else {
@@ -8173,18 +8176,7 @@ var init_utils = __esm({
   }
 });
 
-// packages/cli/src/bin/commands/create-app.ts
-init_utils();
-
-// packages/tooling/src/index.ts
-init_utils();
-
-// packages/tooling/src/cli/index.ts
-init_utils();
-
 // packages/tooling/src/utils/cli-input.ts
-init_utils();
-init_dist2();
 async function askForInput(message, defaultValue = "") {
   const result = await he({
     message,
@@ -8225,6 +8217,22 @@ async function askForSelection(message, choices, defaultValue = 0) {
   }
   return result;
 }
+var init_cli_input = __esm({
+  "packages/tooling/src/utils/cli-input.ts"() {
+    "use strict";
+    init_utils();
+    init_dist2();
+  }
+});
+
+// packages/cli/src/bin/commands/create-app.ts
+init_utils();
+
+// packages/tooling/src/index.ts
+init_utils();
+
+// packages/tooling/src/cli/index.ts
+init_utils();
 
 // packages/tooling/src/utils/create-utils.ts
 init_utils();
@@ -8385,15 +8393,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;
@@ -8408,8 +8411,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");
@@ -8460,6 +8463,10 @@ var APP_QUESTIONNAIRE = [
       {
         title: "Next.js \u2014 Static content/SEO (SSR, SSG) \u2014 BETA",
         value: "nextjs"
+      },
+      {
+        title: "Expo \u2014 Mobile app (iOS + Android)",
+        value: "expo"
       }
     ]
   },
@@ -8486,6 +8493,10 @@ var APP_QUESTIONNAIRE = [
       {
         title: "Vercel \u2014 Serverless functions (edge + node.js)",
         value: "vercel"
+      },
+      {
+        title: "Supabase \u2014 Postgres + Auth + Storage",
+        value: "supabase"
       }
     ]
   }
@@ -8552,6 +8563,7 @@ async function runQuestionnaire(questions, initialAnswers, showWIP, askFor) {
 
 // packages/tooling/src/scaffolding/create-app.ts
 init_utils();
+init_cli_input();
 init_cli_output();
 
 // packages/tooling/src/utils/dependency-resolver.ts
@@ -8585,6 +8597,15 @@ function generateScripts(templateName, options) {
     scripts.preview = "next start";
     scripts.lint = "eslint src/";
     scripts["type-check"] = "tsc --noEmit";
+  } else if (templateName.includes("expo")) {
+    scripts.dev = "expo start";
+    scripts.start = "expo start";
+    scripts.android = "expo start --android";
+    scripts.ios = "expo start --ios";
+    scripts.web = "expo start --web";
+    scripts.build = "expo export";
+    scripts.lint = "eslint .";
+    scripts["type-check"] = "tsc --noEmit";
   } else if (templateName === "consumer-root") {
     scripts.dev = "turbo run dev";
     scripts.build = "turbo run build";
@@ -8673,14 +8694,14 @@ function generatePackageJson(templateName, mode, options = {}) {
     result.main = "./index.ts";
     result.types = "./index.ts";
   }
-  if (templateName.includes("vite") || templateName.includes("nextjs") || templateName.includes("functions")) {
+  if (templateName.includes("vite") || templateName.includes("nextjs") || templateName.includes("expo") || templateName.includes("functions")) {
     if (!dependencies.entities) {
       dependencies.entities = "workspace:*";
     }
   }
   if (templateName.includes("functions")) {
     result.main = "lib/index.js";
-    result.engines = { node: "20" };
+    result.engines = { node: "22" };
     if (options.appName) {
       const platform = templateName.includes("vercel") ? "Vercel" : "Firebase";
       result.description = `${options.appName} ${platform} Functions`;
@@ -8721,6 +8742,40 @@ function generatePackageJson(templateName, mode, options = {}) {
 // packages/tooling/src/scaffolding/create-app.ts
 init_pathResolver();
 init_pathResolver();
+
+// packages/tooling/src/scaffolding/scaffold-matrix.ts
+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: "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: "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: "functions-supabase" },
+  { builder: "demo", backend: "none", baseTemplate: "app-demo", overlay: null, deployConfig: null, functionsTemplate: null }
+];
+function comboKey(builder, backend) {
+  return `${builder}-${backend}`;
+}
+var ROWS_BY_KEY = /* @__PURE__ */ new Map();
+for (const row of MATRIX) {
+  ROWS_BY_KEY.set(comboKey(row.builder, row.backend), row);
+}
+function getScaffoldRow(builder, backend) {
+  const key = comboKey(builder, backend);
+  const row = ROWS_BY_KEY.get(key);
+  if (!row) {
+    throw new Error(`Unsupported scaffold combo: ${key}. Supported: ${[...ROWS_BY_KEY.keys()].join(", ")}`);
+  }
+  return row;
+}
+
+// packages/tooling/src/scaffolding/create-app.ts
 var SHOW_WIP = process.env.SHOW_WIP === "true" || process.argv.includes("--wip");
 async function createApp(appName, appConfig, workspaceRoot, templatesRoot) {
   const isInteractive = !appName || !appConfig;
@@ -8806,14 +8861,19 @@ async function createApp(appName, appConfig, workspaceRoot, templatesRoot) {
   const s = Y2();
   s.start(`Creating app: ${appName}`);
   await ensureDir(appDir);
-  const templateDir = appTemplate === "demo" ? "app-demo" : appTemplate === "nextjs" ? "app-next" : "app-vite";
+  const builder = appTemplate;
+  const backend = appConfig.needsBackend && appConfig.backendPlatform ? appConfig.backendPlatform : "none";
+  const row = getScaffoldRow(builder, backend);
+  const templateDir = row.baseTemplate;
   const firebaseProjectId = (appConfig?.firebaseProjectId ?? "").trim() || appName.toLowerCase().replace(/\s+/g, "-");
   const firebaseRegion = appConfig?.firebaseRegion ?? "europe-west1";
+  const backendPlatform = appConfig.backendPlatform ?? "firebase";
+  const deployConfig = row.deployConfig;
   const replacements = {
     projectName: appName,
     appName,
     appShortName: appName.toUpperCase().replace(/-/g, " "),
-    includeFunctions: Boolean(appConfig.needsBackend),
+    includeFunctions: Boolean(row.functionsTemplate),
     needsCRUD: Boolean(appConfig.needsCRUD),
     setupGithubActions: false,
     appNames: [appName],
@@ -8823,8 +8883,13 @@ async function createApp(appName, appConfig, workspaceRoot, templatesRoot) {
     monorepoRelativePath: "../../packages/tooling",
     appTemplate,
     isNextjs: appTemplate === "nextjs",
+    isExpo: appTemplate === "expo",
     YOUR_FIREBASE_PROJECT_ID: firebaseProjectId,
-    YOUR_REGION: firebaseRegion
+    YOUR_REGION: firebaseRegion,
+    backendPlatform,
+    isFirebase: backendPlatform === "firebase",
+    isSupabase: backendPlatform === "supabase",
+    isVercel: backendPlatform === "vercel"
   };
   const templateSourceDir = joinPath(templatesRoot, templateDir);
   const templateFiles = await glob("**/*", {
@@ -8845,118 +8910,208 @@ async function createApp(appName, appConfig, workspaceRoot, templatesRoot) {
       await replacePlaceholders(destPath, replacements);
     }
   }
+  if (row.overlay) {
+    const overlayDir = joinPath(templatesRoot, row.overlay);
+    if (pathExists(overlayDir)) {
+      const overlayFiles = await glob("**/*", {
+        cwd: overlayDir,
+        dot: true,
+        onlyFiles: true
+      });
+      for (const file of overlayFiles) {
+        if (file.startsWith("env.fragment")) continue;
+        if (file === "vercel.headers.example") continue;
+        if (file === "vercel.json.example") continue;
+        if (file === "src/config/providers.ts.example") {
+          const variantFile = `src/config/providers.${appTemplate}.ts.example`;
+          if (overlayFiles.includes(variantFile)) continue;
+        }
+        const providersVariant = file.match(/^src\/config\/providers\.(\w+)\.ts\.example$/);
+        if (providersVariant) {
+          if (providersVariant[1] !== appTemplate) continue;
+          const destPath2 = joinPath(appDir, "src/config/providers.ts");
+          await ensureDir(getDirname(destPath2));
+          await copy(joinPath(overlayDir, file), destPath2, { overwrite: true });
+          if (await isTextFile(destPath2)) await replacePlaceholders(destPath2, replacements);
+          continue;
+        }
+        const sourcePath = joinPath(overlayDir, file);
+        let destFileName = file;
+        if (destFileName.endsWith(".example")) {
+          destFileName = destFileName.slice(0, -8);
+        }
+        const destPath = joinPath(appDir, destFileName);
+        await ensureDir(getDirname(destPath));
+        await copy(sourcePath, destPath, { overwrite: true });
+        if (await isTextFile(destPath)) {
+          await replacePlaceholders(destPath, replacements);
+        }
+      }
+      const fragmentName = appTemplate === "nextjs" ? "env.fragment.nextjs.example" : appTemplate === "expo" ? "env.fragment.expo.example" : "env.fragment.example";
+      const fragmentPath = joinPath(overlayDir, fragmentName);
+      const envPath = joinPath(appDir, ".env");
+      if (pathExists(fragmentPath) && pathExists(envPath)) {
+        const baseEnv = readSync(envPath);
+        const fragment = readSync(fragmentPath);
+        await write(envPath, baseEnv + "\n" + fragment, { overwrite: true });
+      }
+      if (deployConfig === "vercel-supabase") {
+        const vercelPath = joinPath(appDir, "vercel.json");
+        const headersFragmentPath = joinPath(overlayDir, "vercel.headers.example");
+        const fullVercelPath = joinPath(overlayDir, "vercel.json.example");
+        if (pathExists(vercelPath) && pathExists(headersFragmentPath)) {
+          const vercelJson = readSync(vercelPath, { format: "json" });
+          const headersFragment = readSync(headersFragmentPath, { format: "json" });
+          vercelJson.headers = [...vercelJson.headers ?? [], ...headersFragment];
+          await write(vercelPath, vercelJson, { format: "json", overwrite: true });
+        } else if (pathExists(fullVercelPath)) {
+          await copy(fullVercelPath, vercelPath);
+          if (await isTextFile(vercelPath)) await replacePlaceholders(vercelPath, replacements);
+        }
+      }
+    }
+  }
   const executionMode = detectExecutionMode();
   const templateName = appTemplate === "demo" ? "demo" : executionMode === "development" ? `dev-${appTemplate}` : `consumer-${appTemplate}`;
   const packageJson = generatePackageJson(templateName, executionMode, {
     appName,
     template: appTemplate === "demo" ? "vite" : appTemplate,
-    includeFunctions: Boolean(appConfig.needsBackend)
+    includeFunctions: Boolean(row.functionsTemplate),
+    platform: appTemplate === "demo" ? void 0 : backendPlatform
   });
   const packageJsonPath = joinPath(appDir, "package.json");
   await write(packageJsonPath, packageJson, {
     format: "json",
     overwrite: true
   });
-  if (appConfig.needsBackend && appConfig.backendPlatform) {
-    const platform = appConfig.backendPlatform;
-    const functionsRootDir = joinPath(appDir, "functions");
-    const functionsTemplateName = `functions-${platform}`;
-    const functionsPackageJson = generatePackageJson(
-      functionsTemplateName,
-      executionMode,
-      {
-        appName,
-        platform
-      }
-    );
-    const packageJsonPath2 = joinPath(functionsRootDir, "package.json");
-    await ensureDir(functionsRootDir);
-    await write(packageJsonPath2, functionsPackageJson, {
-      format: "json",
-      overwrite: true
-    });
-    const templateSourceDir2 = joinPath(
-      templatesRoot,
-      functionsTemplateName,
-      functionsTemplateName
-    );
-    const fallbackTemplateDir = joinPath(templatesRoot, functionsTemplateName);
-    const templateDir2 = pathExists(templateSourceDir2) ? templateSourceDir2 : fallbackTemplateDir;
-    const templateFiles2 = await glob("**/*", {
-      cwd: templateDir2,
-      dot: true,
-      onlyFiles: true
-    });
-    for (const file of templateFiles2) {
-      if (file === "package.json.example") continue;
-      const sourcePath = joinPath(templateDir2, file);
-      let destFileName = file;
-      if (destFileName.endsWith(".example")) {
-        destFileName = destFileName.slice(0, -8);
-      }
-      const destPath = joinPath(functionsRootDir, destFileName);
-      await ensureDir(getDirname(destPath));
-      await copy(sourcePath, destPath);
-      if (await isTextFile(destPath)) {
-        await replacePlaceholders(destPath, {
-          ...replacements,
-          APP_NAME: appName
+  if (row.functionsTemplate) {
+    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 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,
+        dot: true,
+        onlyFiles: true
+      });
+      for (const file of templateFiles2) {
+        if (file === "package.json.example") continue;
+        const sourcePath = joinPath(templateDir2, file);
+        let destFileName = file;
+        if (destFileName.endsWith(".example")) {
+          destFileName = destFileName.slice(0, -8);
+        }
+        const destPath = joinPath(functionsRootDir, destFileName);
+        await ensureDir(getDirname(destPath));
+        await copy(sourcePath, destPath);
+        if (await isTextFile(destPath)) {
+          await replacePlaceholders(destPath, {
+            ...replacements,
+            APP_NAME: appName
+          });
+        }
+      }
     }
   }
   const deploymentTemplateDir = joinPath(templatesRoot, "root-consumer");
-  const firebaseJsonSource = joinPath(
-    deploymentTemplateDir,
-    "firebase.json.example"
-  );
-  if (pathExists(firebaseJsonSource)) {
-    const firebaseJsonDest = joinPath(appDir, "firebase.json");
-    await copy(firebaseJsonSource, firebaseJsonDest);
-    if (await isTextFile(firebaseJsonDest)) {
-      await replacePlaceholders(firebaseJsonDest, replacements);
+  if (deployConfig === "firebase") {
+    const firebaseJsonSource = joinPath(deploymentTemplateDir, "firebase.json.example");
+    if (pathExists(firebaseJsonSource)) {
+      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)) {
+      await copy(firebasercSource, joinPath(appDir, ".firebaserc"));
+      const firebasercDest = joinPath(appDir, ".firebaserc");
+      if (await isTextFile(firebasercDest)) await replacePlaceholders(firebasercDest, replacements);
+    }
+    if (row.functionsTemplate === "functions-firebase") {
+      for (const example of ["firestore.rules.example", "firestore.indexes.json.example", "storage.rules.example"]) {
+        const src = joinPath(deploymentTemplateDir, example);
+        if (pathExists(src)) {
+          await copy(src, joinPath(appDir, example.replace(".example", "")));
+        }
+      }
     }
   }
-  const firebasercSource = joinPath(
-    deploymentTemplateDir,
-    ".firebaserc.example"
-  );
-  if (pathExists(firebasercSource)) {
+  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");
-    await copy(firebasercSource, firebasercDest);
-    if (await isTextFile(firebasercDest)) {
-      await replacePlaceholders(firebasercDest, replacements);
-    }
-  }
-  if (appConfig.needsBackend && appConfig.backendPlatform === "firebase") {
-    const rulesFiles = [
-      "firestore.rules.example",
-      "firestore.indexes.json.example",
-      "storage.rules.example"
-    ];
-    for (const example of rulesFiles) {
+    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);
-      if (pathExists(src)) {
-        const destName = example.replace(".example", "");
-        const dest = joinPath(appDir, destName);
+      const dest = joinPath(appDir, example.replace(".example", ""));
+      if (pathExists(src) && !pathExists(dest)) {
         await copy(src, dest);
       }
     }
   }
-  if (appTemplate === "nextjs" || appConfig.needsBackend && appConfig.backendPlatform === "vercel") {
-    const vercelJsonSource = joinPath(
-      deploymentTemplateDir,
-      "vercel.json.example"
-    );
+  if (deployConfig === "vercel-vercel") {
+    const vercelJsonSource = joinPath(deploymentTemplateDir, "vercel.json.example");
     if (pathExists(vercelJsonSource)) {
+      await copy(vercelJsonSource, joinPath(appDir, "vercel.json"));
       const vercelJsonDest = joinPath(appDir, "vercel.json");
-      await copy(vercelJsonSource, vercelJsonDest);
-      if (await isTextFile(vercelJsonDest)) {
-        await replacePlaceholders(vercelJsonDest, replacements);
-      }
+      if (await isTextFile(vercelJsonDest)) await replacePlaceholders(vercelJsonDest, replacements);
     }
   }
-  const backendInfo = appConfig.needsBackend && appConfig.backendPlatform ? ` with ${appConfig.backendPlatform} functions` : "";
+  const backendInfo = row.functionsTemplate ? ` with ${row.functionsTemplate.replace("functions-", "")} functions` : "";
   s.stop(`Created ${appName}${backendInfo}`);
   const rootPackageJsonPath = joinPath(workspaceRoot, "package.json");
   if (pathExists(rootPackageJsonPath)) {
@@ -8968,7 +9123,7 @@ async function createApp(appName, appConfig, workspaceRoot, templatesRoot) {
   }
   if (isInteractive) {
     Se("\u{1F389} App created successfully!");
-    const firebaseStep = appConfig.needsBackend && appConfig.backendPlatform === "firebase" ? `2. Set Firebase project: cd apps/${appName} && firebase use --add (or edit .firebase rc)
+    const firebaseStep = row.functionsTemplate === "functions-firebase" ? `2. Set Firebase project: cd apps/${appName} && firebase use --add (or edit .firebaserc)
 3. bun install
 4. bun run dev` : `2. bun install
 3. bun run dev`;
@@ -8985,8 +9140,8 @@ Happy coding!`,
 }
 async function main(options) {
   try {
-    const hasCliOptions = options?.name || options?.builder !== void 0;
-    if (hasCliOptions && options?.name) {
+    const hasExplicitFlags = options?.builder !== void 0 || options?.functions !== void 0;
+    if (hasExplicitFlags && options?.name) {
       const appName = options.name;
       const builder = options.builder || "vite";
       const includeFunctions = options.functions ?? false;
@@ -9001,7 +9156,7 @@ async function main(options) {
         );
       }
       const appConfig = {
-        template: builder === "next" ? "nextjs" : "vite",
+        template: builder === "next" ? "nextjs" : builder === "expo" ? "expo" : "vite",
         needsBackend: includeFunctions,
         backendPlatform: includeFunctions ? "firebase" : void 0,
         needsCRUD: true,
@@ -9014,7 +9169,7 @@ async function main(options) {
       };
       await createApp(appName, appConfig);
     } else {
-      await createApp();
+      await createApp(options?.name);
     }
   } catch (error2) {
     log.error("\n\u274C Error creating app:", error2);