@donotdev/cli 0.0.14 → 0.0.16

package/dist/bin/commands/emu.js

@@ -7594,11 +7594,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;
@@ -7618,7 +7646,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;
@@ -7649,7 +7677,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)}`,
@@ -7686,21 +7714,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;
       }
     };
   }
@@ -7743,6 +7771,52 @@ var init_pathResolver = __esm({
   }
 });
 
+// packages/tooling/src/utils/typed-file-operations.ts
+function readFirebaseJson(filePath) {
+  if (!pathExists(filePath)) {
+    throw new DoNotDevError(
+      `firebase.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 firebase.json: ${filePath}`,
+      DO_NOT_DEV_ERROR_CODES.CONFIG_INVALID,
+      { context: { filePath } }
+    );
+  }
+  return content;
+}
+function readPackageJson(filePath) {
+  if (!pathExists(filePath)) {
+    throw new DoNotDevError(
+      `package.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" || !("name" in content)) {
+    throw new DoNotDevError(
+      `Invalid package.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";
@@ -7770,22 +7844,7 @@ var init_utils = __esm({
   }
 });
 
-// packages/cli/src/bin/commands/emu.ts
-init_utils();
-
-// packages/tooling/src/index.ts
-init_utils();
-
-// packages/tooling/src/cli/index.ts
-init_utils();
-
-// packages/tooling/src/utils/app-selector.ts
-init_utils();
-init_dist2();
-
 // packages/tooling/src/utils/app-detection.ts
-init_utils();
-init_pathResolver();
 function detectApps(projectRoot) {
   const apps = [];
   const appsDir = joinPath(projectRoot, "apps");
@@ -7806,9 +7865,7 @@ function detectApps(projectRoot) {
     const packageJsonPath = joinPath(projectRoot, "package.json");
     if (pathExists(packageJsonPath)) {
       try {
-        const packageJson = readSync(packageJsonPath, {
-          format: "json"
-        });
+        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";
@@ -7828,10 +7885,10 @@ function analyzeApp(appPath, appName) {
   if (!pathExists(packageJsonPath)) {
     return null;
   }
-  let packageJson;
+  let packageJson = null;
   try {
-    packageJson = readSync(packageJsonPath, { format: "json" });
-    if (!packageJson) {
+    packageJson = readPackageJson(packageJsonPath);
+    if (!packageJson.name) {
       return null;
     }
   } catch {
@@ -7846,14 +7903,23 @@ function analyzeApp(appPath, appName) {
   const functionsPath = joinPath(appPath, "functions");
   const functionsStat = statSync2(functionsPath);
   const hasFunctions = pathExists(functionsPath) && (functionsStat?.isDirectory() ?? false);
-  let platform;
-  if (hasFunctions) {
-    const firebaseJsonPath = joinPath(functionsPath, "firebase.json");
+  let platform4;
+  const firebaseJsonInFunctions = hasFunctions && pathExists(joinPath(functionsPath, "firebase.json"));
+  const firebaseJsonInApp = pathExists(joinPath(appPath, "firebase.json"));
+  if (firebaseJsonInFunctions || firebaseJsonInApp) {
+    platform4 = "firebase";
+  }
+  if (!platform4) {
+    const supabaseConfigPath = joinPath(appPath, "supabase", "config.toml");
+    const hasSupabaseDep = !!(packageJson.dependencies?.["@donotdev/supabase"] || packageJson.dependencies?.["@supabase/supabase-js"]);
+    if (pathExists(supabaseConfigPath) || hasSupabaseDep) {
+      platform4 = "supabase";
+    }
+  }
+  if (!platform4) {
     const vercelJsonPath = joinPath(appPath, "vercel.json");
-    if (pathExists(firebaseJsonPath)) {
-      platform = "firebase";
-    } else if (pathExists(vercelJsonPath)) {
-      platform = "vercel";
+    if (pathExists(vercelJsonPath)) {
+      platform4 = "vercel";
     }
   }
   return {
@@ -7864,12 +7930,19 @@ function analyzeApp(appPath, appName) {
     framework,
     hasFunctions,
     functionsPath: hasFunctions ? functionsPath : void 0,
-    platform
+    platform: platform4
   };
 }
+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
-init_cli_output();
 async function selectApp(projectRoot, appName) {
   const apps = detectApps(projectRoot);
   if (apps.length === 0) {
@@ -7903,10 +7976,17 @@ async function selectApp(projectRoot, appName) {
   }
   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
-init_utils();
-init_dist2();
 async function askForMultiSelection(message, choices, defaultIndices = []) {
   const options = choices.map((choice) => ({
     value: choice.value,
@@ -7925,6 +8005,22 @@ async function askForMultiSelection(message, choices, defaultIndices = []) {
   }
   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/emu.ts
+init_utils();
+
+// packages/tooling/src/index.ts
+init_utils();
+
+// packages/tooling/src/cli/index.ts
+init_utils();
 
 // packages/tooling/src/utils/spawn-utils.ts
 init_utils();
@@ -7970,16 +8066,29 @@ function createEmulatorEnv(appPath, framework = "vite", options) {
 
 // packages/tooling/src/apps/emu.ts
 init_utils();
-import { spawnSync as spawnSync2, execSync as execSync2 } from "node:child_process";
+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,
+  spawnSync as spawnSync2,
+  execSync as execSync2
+} from "node:child_process";
+import { platform } from "node:os";
 function discoverFirebaseProjectId(appPath) {
   const firebasercPath = joinPath(appPath, ".firebaserc");
   if (pathExists(firebasercPath)) {
     try {
-      const firebaserc = readSync(firebasercPath, { format: "json" });
+      const firebasercRaw = readSync(firebasercPath, { format: "json" });
+      const firebaserc = firebasercRaw && typeof firebasercRaw === "object" ? firebasercRaw : null;
       if (firebaserc?.projects?.default) {
         return firebaserc.projects.default;
       }
@@ -8005,7 +8114,7 @@ function killPorts(ports) {
             pids.add(match[1]);
           }
         }
-        for (const pid of pids) {
+        for (const pid of Array.from(pids)) {
           try {
             execSync2(`taskkill /F /PID ${pid}`, { stdio: "ignore" });
             log.debug(`Killed process ${pid} on port ${port}`);
@@ -8014,12 +8123,18 @@ function killPorts(ports) {
         }
       } else {
         try {
-          const pid = execSync2(`lsof -ti:${port}`, {
+          const output = execSync2(`lsof -ti:${port}`, {
             encoding: "utf-8"
           }).trim();
-          if (pid) {
-            execSync2(`kill -9 ${pid}`, { stdio: "ignore" });
-            log.debug(`Killed process ${pid} on port ${port}`);
+          if (output) {
+            const pids = output.split("\n").filter(Boolean);
+            for (const pid of pids) {
+              try {
+                execSync2(`kill -9 ${pid}`, { stdio: "ignore" });
+                log.debug(`Killed process ${pid} on port ${port}`);
+              } catch {
+              }
+            }
           }
         } catch {
         }
@@ -8061,9 +8176,9 @@ function loadEnvFile(filePath) {
   } catch {
   }
 }
-async function main(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",
@@ -8086,47 +8201,6 @@ async function main(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) {
@@ -8206,8 +8280,10 @@ FIREBASE_AUTH_EMULATOR_HOST=${authEmulatorHost}
   let emulatorConfig = null;
   if (pathExists(appFirebaseJson)) {
     try {
-      const firebaseConfig = readSync(appFirebaseJson, { format: "json" });
-      emulatorConfig = firebaseConfig?.emulators;
+      const firebaseConfig = readFirebaseJson(appFirebaseJson);
+      if (firebaseConfig.emulators) {
+        emulatorConfig = firebaseConfig.emulators;
+      }
     } catch {
     }
   }
@@ -8244,7 +8320,7 @@ FIREBASE_AUTH_EMULATOR_HOST=${authEmulatorHost}
   const concurrentlyArgs = [
     "--kill-others-on-fail",
     "--prefix-colors",
-    "cyan,green,yellow",
+    useStripe ? "cyan,green,yellow" : "cyan,green",
     "--prefix",
     "[{name}]",
     "--names",
@@ -8256,21 +8332,292 @@ 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");
     log.info("");
   }
-  const result = spawnSync2("bunx", ["concurrently", ...concurrentlyArgs], {
-    stdio: "inherit",
-    env: createEmulatorEnv(app.path, app.framework, {
-      useEmulatorAuth: useAuth,
-      useEmulatorFirestore: useFirestore
-    }),
-    cwd: app.path
+  const isWindows = platform() === "win32";
+  const childProcess = spawn(
+    "bunx",
+    ["concurrently", ...concurrentlyArgs],
+    {
+      stdio: "inherit",
+      env: createEmulatorEnv(app.path, app.framework, {
+        useEmulatorAuth: useAuth,
+        useEmulatorFirestore: useFirestore
+      }),
+      cwd: app.path,
+      shell: isWindows
+    }
+  );
+  const SIGNAL_EXIT_CODES = {
+    SIGINT: 130,
+    SIGTERM: 143
+  };
+  const cleanup = (signal) => {
+    if (!childProcess.pid) return;
+    log.debug(`Received ${signal}, cleaning up processes...`);
+    if (isWindows) {
+      try {
+        execSync2(`taskkill /F /T /PID ${childProcess.pid}`, {
+          stdio: "ignore",
+          timeout: 2e3
+        });
+      } catch {
+      }
+    } else {
+      try {
+        process.kill(childProcess.pid, signal);
+      } catch {
+      }
+      try {
+        execSync2(`pkill -P ${childProcess.pid}`, {
+          stdio: "ignore",
+          timeout: 1e3
+        });
+      } catch {
+      }
+    }
+  };
+  const signals = ["SIGINT", "SIGTERM"];
+  const handlers = [];
+  for (const signal of signals) {
+    const handler = () => {
+      cleanup(signal);
+      handlers.forEach((h2) => h2());
+      process.exit(SIGNAL_EXIT_CODES[signal] ?? 130);
+    };
+    process.on(signal, handler);
+    handlers.push(() => process.removeListener(signal, handler));
+  }
+  return new Promise((resolve4) => {
+    childProcess.on("exit", (code, signal) => {
+      handlers.forEach((h2) => h2());
+      if (signal) {
+        log.debug(`Process killed by signal: ${signal}`);
+        resolve4(SIGNAL_EXIT_CODES[signal] ?? 130);
+      } else {
+        resolve4(code ?? 0);
+      }
+    });
+    childProcess.on("error", (error2) => {
+      handlers.forEach((h2) => h2());
+      log.error(`Failed to start Firebase emulators: ${error2.message}`);
+      resolve4(1);
+    });
+  });
+}
+
+// packages/tooling/src/apps/emu-supabase.ts
+init_utils();
+init_cli_output();
+import {
+  spawn as spawn2,
+  execSync as execSync3
+} from "node:child_process";
+import { platform as platform2 } from "node:os";
+function isDockerRunning() {
+  try {
+    execSync3("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 {
+    execSync3("supabase --version", { stdio: "pipe" });
+  } catch {
+    log.error("Supabase CLI not found. Install it:");
+    log.error("  npm install -g supabase\n");
+    return 1;
+  }
+  const isWindows = platform2() === "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 = spawn2(
+    "bunx",
+    ["concurrently", ...concurrentlyArgs],
+    {
+      stdio: "inherit",
+      cwd: app.path,
+      shell: isWindows
+    }
+  );
+  const cleanup = () => {
+    if (!childProcess.pid) return;
+    if (isWindows) {
+      try {
+        execSync3(`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 result.status || 0;
+  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 spawn3,
+  execSync as execSync4
+} from "node:child_process";
+import { platform as platform3 } from "node:os";
+async function startVercel(app, _projectRoot) {
+  log.info(`Starting Vercel dev server for ${app.name}...
+`);
+  try {
+    execSync4("vercel --version", { stdio: "pipe" });
+  } catch {
+    log.error("Vercel CLI not found. Install it:");
+    log.error("  npm install -g vercel\n");
+    return 1;
+  }
+  const isWindows = platform3() === "win32";
+  const childProcess = spawn3(
+    "vercel",
+    ["dev"],
+    {
+      stdio: "inherit",
+      cwd: app.path,
+      shell: isWindows
+    }
+  );
+  const cleanup = () => {
+    if (!childProcess.pid) return;
+    if (isWindows) {
+      try {
+        execSync4(`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 main(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));
 }
 export {
   main