@donotdev/cli 0.0.13 → 0.0.15

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

@@ -2139,7 +2139,7 @@ var require_parse = __commonJS({
       CHAR_NO_BREAK_SPACE,
       CHAR_ZERO_WIDTH_NOBREAK_SPACE
     } = require_constants();
-    var parse = (input, options = {}) => {
+    var parse2 = (input, options = {}) => {
       if (typeof input !== "string") {
         throw new TypeError("Expected a string");
       }
@@ -2339,7 +2339,7 @@ var require_parse = __commonJS({
       push({ type: "eos" });
       return ast;
     };
-    module.exports = parse;
+    module.exports = parse2;
   }
 });
 
@@ -2351,7 +2351,7 @@ var require_braces = __commonJS({
     var stringify2 = require_stringify();
     var compile = require_compile();
     var expand = require_expand();
-    var parse = require_parse();
+    var parse2 = require_parse();
     var braces = (input, options = {}) => {
       let output = [];
       if (Array.isArray(input)) {
@@ -2371,7 +2371,7 @@ var require_braces = __commonJS({
       }
       return output;
     };
-    braces.parse = (input, options = {}) => parse(input, options);
+    braces.parse = (input, options = {}) => parse2(input, options);
     braces.stringify = (input, options = {}) => {
       if (typeof input === "string") {
         return stringify2(braces.parse(input, options), options);
@@ -3028,7 +3028,7 @@ var require_parse2 = __commonJS({
     var syntaxError = (type, char) => {
       return `Missing ${type}: "${char}" - use "\\\\${char}" to match literal characters`;
     };
-    var parse = (input, options) => {
+    var parse2 = (input, options) => {
       if (typeof input !== "string") {
         throw new TypeError("Expected a string");
       }
@@ -3177,7 +3177,7 @@ var require_parse2 = __commonJS({
             output = token.close = `)$))${extglobStar}`;
           }
           if (token.inner.includes("*") && (rest = remaining()) && /^\.[^\\/.]+$/.test(rest)) {
-            const expression = parse(rest, { ...options, fastpaths: false }).output;
+            const expression = parse2(rest, { ...options, fastpaths: false }).output;
             output = token.close = `)${expression})${extglobStar})`;
           }
           if (token.prev.type === "bos") {
@@ -3702,7 +3702,7 @@ var require_parse2 = __commonJS({
       }
       return state;
     };
-    parse.fastpaths = (input, options) => {
+    parse2.fastpaths = (input, options) => {
       const opts = { ...options };
       const max = typeof opts.maxLength === "number" ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
       const len = input.length;
@@ -3768,7 +3768,7 @@ var require_parse2 = __commonJS({
       }
       return source;
     };
-    module.exports = parse;
+    module.exports = parse2;
   }
 });
 
@@ -3779,7 +3779,7 @@ var require_picomatch = __commonJS({
     init_utils();
     var path = __require("path");
     var scan = require_scan();
-    var parse = require_parse2();
+    var parse2 = require_parse2();
     var utils = require_utils2();
     var constants2 = require_constants2();
     var isObject = (val) => val && typeof val === "object" && !Array.isArray(val);
@@ -3867,7 +3867,7 @@ var require_picomatch = __commonJS({
     picomatch.isMatch = (str, patterns, options) => picomatch(patterns, options)(str);
     picomatch.parse = (pattern, options) => {
       if (Array.isArray(pattern)) return pattern.map((p2) => picomatch.parse(p2, options));
-      return parse(pattern, { ...options, fastpaths: false });
+      return parse2(pattern, { ...options, fastpaths: false });
     };
     picomatch.scan = (input, options) => scan(input, options);
     picomatch.compileRe = (state, options, returnOutput = false, returnState = false) => {
@@ -3893,10 +3893,10 @@ var require_picomatch = __commonJS({
       }
       let parsed = { negated: false, fastpaths: true };
       if (options.fastpaths !== false && (input[0] === "." || input[0] === "*")) {
-        parsed.output = parse.fastpaths(input, options);
+        parsed.output = parse2.fastpaths(input, options);
       }
       if (!parsed.output) {
-        parsed = parse(input, options);
+        parsed = parse2(input, options);
       }
       return picomatch.compileRe(parsed, options, returnOutput, returnState);
     };
@@ -7758,11 +7758,39 @@ var init_PathResolver = __esm({
 });
 
 // packages/tooling/src/utils/errors.ts
-var DoNotDevError;
+var DO_NOT_DEV_ERROR_CODES, DoNotDevError;
 var init_errors = __esm({
   "packages/tooling/src/utils/errors.ts"() {
     "use strict";
     init_utils();
+    DO_NOT_DEV_ERROR_CODES = {
+      CONFIGURATION_ERROR: "configuration-error",
+      CONFIG_NOT_FOUND: "config-not-found",
+      CONFIG_INVALID: "config-invalid",
+      PATH_RESOLUTION_ERROR: "path-resolution-error",
+      FILE_OPERATION_ERROR: "file-operation-error",
+      FILE_NOT_FOUND: "file-not-found",
+      PERMISSION_DENIED: "permission-denied",
+      GENERATION_ERROR: "generation-error",
+      TEMPLATE_ERROR: "template-error",
+      TEMPLATE_NOT_FOUND: "template-not-found",
+      CLI_EXECUTION_ERROR: "cli-execution-error",
+      COMMAND_NOT_FOUND: "command-not-found",
+      COMMAND_FAILED: "command-failed",
+      VALIDATION_ERROR: "validation-error",
+      SCHEMA_ERROR: "schema-error",
+      DEPENDENCY_ERROR: "dependency-error",
+      DEPENDENCY_NOT_FOUND: "dependency-not-found",
+      DEPENDENCY_VERSION_ERROR: "dependency-version-error",
+      INVALID_ARGUMENT: "invalid-argument",
+      MISSING_ARGUMENT: "missing-argument",
+      MISSING_PROJECT_ID: "missing-project-id",
+      FIREBASE_CLI_ERROR: "firebase-cli-error",
+      DEPLOYMENT_FAILED: "deployment-failed",
+      OPERATION_CANCELLED: "operation-cancelled",
+      TIMEOUT_ERROR: "timeout-error",
+      UNKNOWN_ERROR: "unknown-error"
+    };
     DoNotDevError = class _DoNotDevError extends Error {
       /** The error code categorizing this error */
       code;
@@ -7782,7 +7810,7 @@ var init_errors = __esm({
        * @param {Record<string, any>} [options.context] - Additional context data
        * @param {boolean} [options.displayable=true] - Whether this error should be displayed to the user
        */
-      constructor(message, code = "unknown-error", options) {
+      constructor(message, code = DO_NOT_DEV_ERROR_CODES.UNKNOWN_ERROR, options) {
         super(message);
         this.name = "DoNotDevError";
         this.code = code;
@@ -7813,7 +7841,7 @@ var init_errors = __esm({
        * @param {boolean} [options.displayable=true] - Whether this error should be displayed to the user
        * @returns {DoNotDevError} New DoNotDev error wrapping the original
        */
-      static from(error2, context, code = "unknown-error", options) {
+      static from(error2, context, code = DO_NOT_DEV_ERROR_CODES.UNKNOWN_ERROR, options) {
         if (!(error2 instanceof Error)) {
           return new _DoNotDevError(
             `Unknown error: ${String(error2)}`,
@@ -7850,21 +7878,21 @@ var init_errors = __esm({
         }
         const message = error2.message.toLowerCase();
         if (error2.name === "ValidationError" || message.includes("validation")) {
-          return "validation-error";
+          return DO_NOT_DEV_ERROR_CODES.VALIDATION_ERROR;
         }
         if (message.includes("not found") || message.includes("no such file")) {
-          return "file-not-found";
+          return DO_NOT_DEV_ERROR_CODES.FILE_NOT_FOUND;
         }
         if (message.includes("permission") || message.includes("access denied")) {
-          return "permission-denied";
+          return DO_NOT_DEV_ERROR_CODES.PERMISSION_DENIED;
         }
         if (message.includes("timeout") || message.includes("timed out")) {
-          return "timeout-error";
+          return DO_NOT_DEV_ERROR_CODES.TIMEOUT_ERROR;
         }
         if (message.includes("dependency") || message.includes("module not found")) {
-          return "dependency-error";
+          return DO_NOT_DEV_ERROR_CODES.DEPENDENCY_ERROR;
         }
-        return "unknown-error";
+        return DO_NOT_DEV_ERROR_CODES.UNKNOWN_ERROR;
       }
     };
   }
@@ -7884,6 +7912,7 @@ __export(pathResolver_exports, {
   ensureDirSync: () => ensureDirSync,
   findFiles: () => findFiles,
   findNodeModulesDir: () => findNodeModulesDir,
+  findPackageRootUp: () => findPackageRootUp,
   fromAppRoot: () => fromAppRoot,
   getAppRoot: () => getAppRoot,
   getBasename: () => getBasename,
@@ -7900,7 +7929,6 @@ __export(pathResolver_exports, {
   getRelativePathBetween: () => getRelativePathBetween,
   getRepoRoot: () => getRepoRoot,
   getTemplatesRoot: () => getTemplatesRoot,
-  getToolingPath: () => getToolingPath,
   glob: () => glob,
   globSync: () => globSync,
   isAbsolute: () => isAbsolute,
@@ -7939,6 +7967,7 @@ import {
   extname as extname2,
   relative as relative2,
   resolve as resolve2,
+  parse,
   isAbsolute as pathIsAbsolute
 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
@@ -7995,37 +8024,22 @@ function getBinPath(binaryName) {
   }
   return binaryName;
 }
-function getToolingPath() {
-  const mode = detectExecutionMode();
-  if (mode === "development") {
-    const repoRoot = getRepoRoot();
-    const packagesToolingPath = normalizePath(repoRoot, PACKAGE_PATHS.TOOLING);
-    if (pathExists(packagesToolingPath)) {
-      return normalizePath(packagesToolingPath);
-    }
-  }
-  throw new DoNotDevError(
-    "Could not find tooling package. This function is only available in development mode.",
-    "path-resolution-error"
-  );
-}
 function detectExecutionMode() {
-  const currentDir = process.cwd();
-  const toolingPath = joinPath(currentDir, PACKAGE_PATHS.TOOLING);
-  if (pathExists(toolingPath)) {
-    return "development";
+  const fileUrlPath = fileURLToPath2(import.meta.url);
+  if (fileUrlPath.includes("node_modules")) {
+    return "published";
   }
-  const fileUrlPath = new URL(import.meta.url).pathname;
-  if (fileUrlPath.includes("node_modules/@donotdev/cli")) {
+  if (fileUrlPath.includes("/dist/")) {
     return "published";
   }
-  return "published";
+  return "development";
 }
 function getTemplatesRoot() {
   const mode = detectExecutionMode();
   if (mode === "development") {
-    const repoRoot = getRepoRoot();
-    return normalizePath(repoRoot, PACKAGE_PATHS.CLI, "templates");
+    const fileUrlPath = fileURLToPath2(import.meta.url);
+    const frameworkRoot = normalizePath(dirname2(fileUrlPath), "../../../..");
+    return normalizePath(frameworkRoot, PACKAGE_PATHS.CLI, "templates");
   } else {
     try {
       const cliRoot2 = resolveFrameworkPackage("@donotdev/cli");
@@ -8047,10 +8061,43 @@ function getTemplatesRoot() {
       }
     } catch {
     }
+    try {
+      const currentScriptDir = getDirnameFromUrl(import.meta.url);
+      const packageRoot = findPackageRootUp(currentScriptDir, "@donotdev/cli");
+      if (packageRoot) {
+        const templatesPath = normalizePath(packageRoot, "templates");
+        if (pathExists(templatesPath)) {
+          return templatesPath;
+        }
+      }
+    } catch {
+    }
     const cliRoot = getCliRootFromBundle();
     return normalizePath(cliRoot, "templates");
   }
 }
+function findPackageRootUp(startDir, packageName) {
+  let currentDir = normalizePath(startDir);
+  const root = parse(currentDir).root;
+  const fs2 = createRequire2(import.meta.url)("node:fs");
+  while (currentDir !== root) {
+    const packageJsonPath = joinPath(currentDir, "package.json");
+    if (fs2.existsSync(packageJsonPath)) {
+      try {
+        const content = fs2.readFileSync(packageJsonPath, "utf8");
+        const pkg = JSON.parse(content);
+        if (pkg.name === packageName) {
+          return currentDir;
+        }
+      } catch {
+      }
+    }
+    const parentDir = getDirname(currentDir);
+    if (parentDir === currentDir) break;
+    currentDir = parentDir;
+  }
+  return null;
+}
 function getCliRootFromBundle() {
   const currentDir = getDirnameFromUrl(import.meta.url);
   return normalizePath(currentDir, "..", "..", "..");
@@ -8170,7 +8217,6 @@ var init_pathResolver = __esm({
     "use strict";
     init_utils();
     init_PathResolver();
-    init_errors();
     pathResolverInstance = PathResolver.getInstance({ debug: false });
     getPathResolver = (options) => PathResolver.getInstance(options);
     getRepoRoot = () => pathResolverInstance.getRepoRoot();
@@ -8244,6 +8290,48 @@ var init_pathResolver = __esm({
   }
 });
 
+// packages/tooling/src/utils/typed-file-operations.ts
+function readTurboJson(filePath) {
+  if (!pathExists(filePath)) {
+    return null;
+  }
+  const content = readSync(filePath, { format: "json" });
+  if (!content || typeof content !== "object") {
+    throw new DoNotDevError(
+      `Invalid turbo.json: ${filePath}`,
+      DO_NOT_DEV_ERROR_CODES.CONFIG_INVALID,
+      { context: { filePath } }
+    );
+  }
+  return content;
+}
+function readTsConfigJson(filePath) {
+  if (!pathExists(filePath)) {
+    throw new DoNotDevError(
+      `tsconfig.json not found: ${filePath}`,
+      DO_NOT_DEV_ERROR_CODES.FILE_NOT_FOUND,
+      { context: { filePath } }
+    );
+  }
+  const content = readSync(filePath, { format: "json" });
+  if (!content || typeof content !== "object") {
+    throw new DoNotDevError(
+      `Invalid tsconfig.json: ${filePath}`,
+      DO_NOT_DEV_ERROR_CODES.CONFIG_INVALID,
+      { context: { filePath } }
+    );
+  }
+  return content;
+}
+var init_typed_file_operations = __esm({
+  "packages/tooling/src/utils/typed-file-operations.ts"() {
+    "use strict";
+    init_utils();
+    init_pathResolver();
+    init_errors();
+  }
+});
+
 // packages/tooling/src/bundler/utils.ts
 import { Buffer as Buffer2 } from "node:buffer";
 import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2 } from "node:fs";
@@ -8271,23 +8359,12 @@ var init_utils = __esm({
   }
 });
 
-// packages/cli/src/bin/commands/create-project.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,
     placeholder: defaultValue || void 0,
-    initialValue: defaultValue || void 0
+    defaultValue: defaultValue || void 0
   });
   if (pD(result)) {
     xe("Operation cancelled.");
@@ -8323,11 +8400,28 @@ 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-project.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();
 init_cli_output();
 init_pathResolver();
+init_typed_file_operations();
 async function copyTemplateFiles(sourceDir, destDir, replacements) {
   if (!pathExists(sourceDir)) {
     log.warn(`Warning: Template directory does not exist: ${sourceDir}`);
@@ -8512,12 +8606,7 @@ async function mergeRootTsConfig(rootDir, allAppNames, includeFunctions = false)
     return;
   }
   try {
-    const tsconfig = readSync(tsconfigPath, { format: "json" });
-    if (!tsconfig) {
-      throw new Error(
-        `tsconfig.json is empty or invalid JSON at ${tsconfigPath}`
-      );
-    }
+    const tsconfig = readTsConfigJson(tsconfigPath);
     tsconfig.references = tsconfig.references || [];
     const existingPaths = new Set(
       tsconfig.references.map((ref) => ref.path)
@@ -8551,7 +8640,7 @@ async function mergeRootTurboJson(rootDir) {
     return;
   }
   try {
-    const turboJson = readSync(turboJsonPath, { format: "json" });
+    const turboJson = readTurboJson(turboJsonPath);
     if (!turboJson) {
       throw new Error(
         `turbo.json is empty or invalid JSON at ${turboJsonPath}`
@@ -8603,7 +8692,7 @@ async function mergeRootTurboJson(rootDir) {
     }
   } catch (error2) {
     log.warn(
-      `Warning: Could not merge root turbo.json: ${error2.message || "Unknown error"}`
+      `Warning: Could not merge root turbo.json: ${error2 instanceof Error ? error2.message : String(error2)}`
     );
   }
 }
@@ -8699,6 +8788,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"
       }
     ]
   },
@@ -8725,6 +8818,10 @@ var APP_QUESTIONNAIRE = [
       {
         title: "Vercel \u2014 Serverless functions (edge + node.js)",
         value: "vercel"
+      },
+      {
+        title: "Supabase \u2014 Postgres + Auth + Storage",
+        value: "supabase"
       }
     ]
   }
@@ -8791,6 +8888,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
@@ -8824,6 +8922,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";
@@ -8912,7 +9019,7 @@ 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:*";
     }
@@ -8960,6 +9067,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: null },
+  { 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: "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: "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;
@@ -9045,14 +9186,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],
@@ -9062,8 +9208,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("**/*", {
@@ -9084,118 +9235,155 @@ 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);
+          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);
+        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;
+  if (row.functionsTemplate) {
     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
-        });
+    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 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);
+    }
+    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)) {
-    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) {
-      const src = joinPath(deploymentTemplateDir, example);
-      if (pathExists(src)) {
-        const destName = example.replace(".example", "");
-        const dest = joinPath(appDir, destName);
-        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)) {
@@ -9207,7 +9395,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`;
@@ -9225,9 +9413,28 @@ Happy coding!`,
 
 // packages/tooling/src/scaffolding/create-project.ts
 init_utils();
+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;
+}
 function calculateRelativePath(from, to) {
   try {
     return getRelativePathBetween(from, to).replace(/\\/g, "/");
@@ -9336,10 +9543,6 @@ async function main(options) {
         Me("Merge mode: Merging root files, creating new apps", "\u{1F527} Mode");
       }
     }
-    let installDemoApp = await askForConfirmation(
-      "Would you like to install the demo app? (component showcase)",
-      false
-    );
     let appNames = [];
     const appConfigs = {};
     let anyAppNeedsBackend = false;
@@ -9367,21 +9570,25 @@ async function main(options) {
             {
               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 needsBackend = await askForConfirmation(
-          `Do you need a backend for "${trimmedName}"?`,
-          false
+        const backendValue = await askForSelection(
+          `Backend for "${trimmedName}"?`,
+          [...BACKEND_CHOICES],
+          getDefaultBackendIndex(framework)
         );
-        if (needsBackend) {
-          anyAppNeedsBackend = true;
-        }
+        const needsBackend = backendValue !== "none";
+        if (needsBackend) anyAppNeedsBackend = true;
         appConfigs[trimmedName] = {
           template: framework,
           needsBackend,
-          backendPlatform: needsBackend ? framework === "nextjs" ? "vercel" : "firebase" : void 0,
+          backendPlatform: needsBackend ? backendValue : void 0,
           needsCRUD: false,
           selectedEntities: [],
           userAuth: "none",
@@ -9427,17 +9634,17 @@ async function main(options) {
         ],
         0
       );
-      const needsBackend = await askForConfirmation(
-        `Do you need a backend for "${trimmedName}"?`,
-        false
+      const backendValue = await askForSelection(
+        `Backend for "${trimmedName}"?`,
+        [...BACKEND_CHOICES],
+        getDefaultBackendIndex(framework)
       );
-      if (needsBackend) {
-        anyAppNeedsBackend = true;
-      }
+      const needsBackend = backendValue !== "none";
+      if (needsBackend) anyAppNeedsBackend = true;
       appConfigs[trimmedName] = {
         template: framework,
         needsBackend,
-        backendPlatform: needsBackend ? framework === "nextjs" ? "vercel" : "firebase" : void 0,
+        backendPlatform: needsBackend ? backendValue : void 0,
         needsCRUD: false,
         selectedEntities: [],
         userAuth: "none",
@@ -9445,6 +9652,10 @@ async function main(options) {
         features: []
       };
     }
+    let installDemoApp = await askForConfirmation(
+      "Would you like to install the demo app? (component showcase)",
+      false
+    );
     let allAppNames = [...appNames];
     let appsToCreate = [];
     let appsToSkip = [];
@@ -9510,9 +9721,6 @@ async function main(options) {
     log.info(
       `Creating project "${projectName}" with ${appNames.length} app(s): ${appNames.join(", ")}`
     );
-    let needsAuth = false;
-    let needsOAuth = false;
-    let needsBilling = false;
     for (const appName of appNames) {
       if (!appConfigs[appName]) {
         log.warn(`Missing config for app "${appName}", using defaults`);
@@ -9567,12 +9775,14 @@ async function main(options) {
         overwrite: true
       });
       const relativeMonorepoPath = executionMode === "development" ? calculateRelativePath(projectDirNormalized, monorepoRoot) : "";
+      const primaryPlatform = Object.values(appConfigs).find((c) => c.backendPlatform)?.backendPlatform ?? "firebase";
       const rootPackageJson = generatePackageJson(
         "consumer-root",
         executionMode,
         {
           projectName,
-          includeFunctions: anyAppNeedsBackend
+          includeFunctions: anyAppNeedsBackend,
+          platform: primaryPlatform
         }
       );
       const packageJsonPath = joinPath(projectDirNormalized, "package.json");
@@ -9596,9 +9806,12 @@ async function main(options) {
         firebaseSecretName: projectName.toUpperCase().replace(/-/g, "_"),
         YOUR_FIREBASE_PROJECT_ID: firebaseProjectId,
         YOUR_REGION: firebaseRegion,
-        needsAuth,
-        needsOAuth,
-        needsBilling
+        needsAuth: false,
+        // Determined by agent in WAI-WAY Phase 0
+        needsOAuth: false,
+        // Determined by agent in WAI-WAY Phase 0
+        needsBilling: false
+        // Determined by agent in WAI-WAY Phase 0
       };
       const firebaseRootFiles = /* @__PURE__ */ new Set([
         "firebase.json.example",
@@ -9628,8 +9841,12 @@ async function main(options) {
         }
       }
       if (setupGithubActions) {
-        const ciTemplateDir = joinPath(templatesRoot, "github-consumer");
-        await copyTemplateFiles(ciTemplateDir, projectDirNormalized, rootReplacements);
+        const ciTemplateDir = joinPath(templatesRoot, "github");
+        await copyTemplateFiles(
+          ciTemplateDir,
+          projectDirNormalized,
+          rootReplacements
+        );
       }
       s.stop("Project structure created");
     } else {
@@ -9654,9 +9871,9 @@ async function main(options) {
       }
       const relativeMonorepoPath = executionMode === "development" ? calculateRelativePath(projectDirNormalized, monorepoRoot) : "../../packages/tooling";
       await mergeRootPackageJson(projectDirNormalized, allAppNames, {
-        needsAuth,
-        needsOAuth,
-        needsBilling,
+        needsAuth: false,
+        needsOAuth: false,
+        needsBilling: false,
         monorepoRelativePath: relativeMonorepoPath
       });
       await mergeRootTsConfig(
@@ -9740,14 +9957,18 @@ async function main(options) {
     Me(
       `1. ${cdCommand}
 2. bun install
-3. Open the project in your IDE (Cursor, VS Code, etc.)
-4. Tell your AI agent: "Read AI.md and build my app"
+3. Open the project in your IDE
+4. Tell your AI agent:
+
+   "Read AI.md and build my app"
+
+The AI agent will use the MCP server automatically.
+It handles everything: spec, scaffold, entities, pages.
 
-That's it. The agent handles the rest.
+Cursor users: enable MCP in Settings > Tools & MCP > toggle "donotdev" ON
+Claude Code / Windsurf: MCP auto-connects, nothing to do
 
-` + (anyAppNeedsBackend ? `Dev server: dndev dev | With emulators: dndev emu
-` : `Dev server: dndev dev
-`) + `AI setup: dndev agent (re-configure MCP if needed)`,
+` + (anyAppNeedsBackend ? `Dev server: dndev dev | With emulators: dndev emu` : `Dev server: dndev dev`),
       "\u{1F4CB} Next Steps"
     );
   } catch (error2) {