@donotdev/cli 0.0.15 → 0.0.17

package/dist/bin/commands/doctor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"doctor.js","sourceRoot":"","sources":["../../../src/bin/commands/doctor.ts"],"names":[],"mappings":"AAAA,0CAA0C;AAC1C;;;GAGG;AAEH,OAAO,EAAE,MAAM,IAAI,IAAI,EAAE,MAAM,mBAAmB,CAAC"}

package/dist/bin/commands/emu.js

@@ -7844,50 +7844,7 @@ var init_utils = __esm({
   }
 });
 
-// packages/tooling/src/utils/cli-input.ts
-async function askForMultiSelection(message, choices, defaultIndices = []) {
-  const options = choices.map((choice) => ({
-    value: choice.value,
-    label: choice.title,
-    hint: choice.hint
-  }));
-  const initialValues = defaultIndices.map((i) => choices[i]?.value).filter(Boolean);
-  const result = await fe({
-    message,
-    options,
-    initialValues: initialValues.length > 0 ? initialValues : void 0
-  });
-  if (pD(result)) {
-    xe("Operation cancelled.");
-    process.exit(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/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();
-init_typed_file_operations();
 function detectApps(projectRoot) {
   const apps = [];
   const appsDir = joinPath(projectRoot, "apps");
@@ -7946,14 +7903,23 @@ function analyzeApp(appPath, appName) {
   const functionsPath = joinPath(appPath, "functions");
   const functionsStat = statSync2(functionsPath);
   const hasFunctions = pathExists(functionsPath) && (functionsStat?.isDirectory() ?? false);
-  let platform2;
-  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)) {
-      platform2 = "firebase";
-    } else if (pathExists(vercelJsonPath)) {
-      platform2 = "vercel";
+    if (pathExists(vercelJsonPath)) {
+      platform4 = "vercel";
     }
   }
   return {
@@ -7964,12 +7930,19 @@ function analyzeApp(appPath, appName) {
     framework,
     hasFunctions,
     functionsPath: hasFunctions ? functionsPath : void 0,
-    platform: platform2
+    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) {
@@ -8003,6 +7976,51 @@ 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
+async function askForMultiSelection(message, choices, defaultIndices = []) {
+  const options = choices.map((choice) => ({
+    value: choice.value,
+    label: choice.title,
+    hint: choice.hint
+  }));
+  const initialValues = defaultIndices.map((i) => choices[i]?.value).filter(Boolean);
+  const result = await fe({
+    message,
+    options,
+    initialValues: initialValues.length > 0 ? initialValues : void 0
+  });
+  if (pD(result)) {
+    xe("Operation cancelled.");
+    process.exit(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/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();
@@ -8048,18 +8066,23 @@ function createEmulatorEnv(appPath, framework = "vite", options) {
 
 // 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,
   spawnSync as spawnSync2,
   execSync as execSync2
 } from "node:child_process";
 import { platform } 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)) {
@@ -8091,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}`);
@@ -8153,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",
@@ -8178,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) {
@@ -8350,7 +8332,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");
@@ -8372,9 +8354,7 @@ FIREBASE_AUTH_EMULATOR_HOST=${authEmulatorHost}
   );
   const SIGNAL_EXIT_CODES = {
     SIGINT: 130,
-    // 128 + 2
     SIGTERM: 143
-    // 128 + 15
   };
   const cleanup = (signal) => {
     if (!childProcess.pid) return;
@@ -8424,11 +8404,219 @@ 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/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 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
 };