@donotdev/cli 0.0.13 → 0.0.15

package/dist/bin/commands/emu.js

@@ -1975,7 +1975,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");
       }
@@ -2175,7 +2175,7 @@ var require_parse = __commonJS({
       push({ type: "eos" });
       return ast;
     };
-    module.exports = parse;
+    module.exports = parse2;
   }
 });
 
@@ -2187,7 +2187,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)) {
@@ -2207,7 +2207,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);
@@ -2864,7 +2864,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");
       }
@@ -3013,7 +3013,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") {
@@ -3538,7 +3538,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;
@@ -3604,7 +3604,7 @@ var require_parse2 = __commonJS({
       }
       return source;
     };
-    module.exports = parse;
+    module.exports = parse2;
   }
 });
 
@@ -3615,7 +3615,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);
@@ -3703,7 +3703,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) => {
@@ -3729,10 +3729,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);
     };
@@ -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;
       }
     };
   }
@@ -7715,6 +7743,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";
@@ -7742,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";
@@ -7769,6 +7844,33 @@ 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();
 
@@ -7785,6 +7887,7 @@ 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");
@@ -7805,9 +7908,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";
@@ -7827,10 +7928,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 {
@@ -7845,14 +7946,14 @@ function analyzeApp(appPath, appName) {
   const functionsPath = joinPath(appPath, "functions");
   const functionsStat = statSync2(functionsPath);
   const hasFunctions = pathExists(functionsPath) && (functionsStat?.isDirectory() ?? false);
-  let platform;
+  let platform2;
   if (hasFunctions) {
     const firebaseJsonPath = joinPath(functionsPath, "firebase.json");
     const vercelJsonPath = joinPath(appPath, "vercel.json");
     if (pathExists(firebaseJsonPath)) {
-      platform = "firebase";
+      platform2 = "firebase";
     } else if (pathExists(vercelJsonPath)) {
-      platform = "vercel";
+      platform2 = "vercel";
     }
   }
   return {
@@ -7863,7 +7964,7 @@ function analyzeApp(appPath, appName) {
     framework,
     hasFunctions,
     functionsPath: hasFunctions ? functionsPath : void 0,
-    platform
+    platform: platform2
   };
 }
 
@@ -7903,28 +8004,6 @@ async function selectApp(projectRoot, appName) {
   return apps.find((a) => a.name === selected) || null;
 }
 
-// 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,
-    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;
-}
-
 // packages/tooling/src/utils/spawn-utils.ts
 init_utils();
 import { spawnSync, execSync } from "node:child_process";
@@ -7969,16 +8048,24 @@ 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";
+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)) {
     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;
       }
@@ -8013,12 +8100,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 {
         }
@@ -8205,8 +8298,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 {
     }
   }
@@ -8243,7 +8338,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",
@@ -8261,15 +8356,78 @@ FIREBASE_AUTH_EMULATOR_HOST=${authEmulatorHost}
     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,
+    // 128 + 2
+    SIGTERM: 143
+    // 128 + 15
+  };
+  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 emulators: ${error2.message}`);
+      resolve4(1);
+    });
   });
-  return result.status || 0;
 }
 export {
   main