@donotdev/cli 0.0.14 → 0.0.16

package/dist/bin/commands/dev.js

@@ -7511,11 +7511,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;
@@ -7535,7 +7563,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;
@@ -7566,7 +7594,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)}`,
@@ -7603,21 +7631,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;
       }
     };
   }
@@ -7659,6 +7687,34 @@ var init_pathResolver = __esm({
   }
 });
 
+// packages/tooling/src/utils/typed-file-operations.ts
+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";
@@ -7686,22 +7742,7 @@ var init_utils = __esm({
   }
 });
 
-// packages/cli/src/bin/commands/dev.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");
@@ -7722,9 +7763,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";
@@ -7744,10 +7783,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 {
@@ -7762,14 +7801,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 platform2;
+  const firebaseJsonInFunctions = hasFunctions && pathExists(joinPath(functionsPath, "firebase.json"));
+  const firebaseJsonInApp = pathExists(joinPath(appPath, "firebase.json"));
+  if (firebaseJsonInFunctions || firebaseJsonInApp) {
+    platform2 = "firebase";
+  }
+  if (!platform2) {
+    const supabaseConfigPath = joinPath(appPath, "supabase", "config.toml");
+    const hasSupabaseDep = !!(packageJson.dependencies?.["@donotdev/supabase"] || packageJson.dependencies?.["@supabase/supabase-js"]);
+    if (pathExists(supabaseConfigPath) || hasSupabaseDep) {
+      platform2 = "supabase";
+    }
+  }
+  if (!platform2) {
     const vercelJsonPath = joinPath(appPath, "vercel.json");
-    if (pathExists(firebaseJsonPath)) {
-      platform = "firebase";
-    } else if (pathExists(vercelJsonPath)) {
-      platform = "vercel";
+    if (pathExists(vercelJsonPath)) {
+      platform2 = "vercel";
     }
   }
   return {
@@ -7780,12 +7828,19 @@ function analyzeApp(appPath, appName) {
     framework,
     hasFunctions,
     functionsPath: hasFunctions ? functionsPath : void 0,
-    platform
+    platform: platform2
   };
 }
+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) {
@@ -7819,13 +7874,33 @@ 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/cli/src/bin/commands/dev.ts
+init_utils();
+
+// packages/tooling/src/index.ts
+init_utils();
+
+// packages/tooling/src/cli/index.ts
+init_utils();
 
 // packages/tooling/src/apps/dev.ts
 init_utils();
-import { spawnSync as spawnSync2 } from "node:child_process";
+init_app_selector();
 init_cli_output();
 init_errors();
 init_pathResolver();
+import { spawn, execSync as execSync2 } from "node:child_process";
+import { platform } from "node:os";
 
 // packages/tooling/src/utils/spawn-utils.ts
 init_utils();
@@ -7838,6 +7913,12 @@ function createAppEnv(appPath) {
 }
 
 // packages/tooling/src/apps/dev.ts
+var SIGNAL_EXIT_CODES = {
+  SIGINT: 130,
+  // 128 + 2
+  SIGTERM: 143
+  // 128 + 15
+};
 async function main() {
   const args = process.argv.slice(2);
   const appName = args[0] && args[0] !== "dev" ? args[0] : void 0;
@@ -7855,12 +7936,65 @@ async function main() {
   log.info(`Starting dev server for ${app.name}...
 `);
   const turboArgs = ["dev", "--filter", app.packageName];
-  const result = spawnSync2("bunx", ["turbo", ...turboArgs], {
+  const isWindows = platform() === "win32";
+  const childProcess = spawn("bunx", ["turbo", ...turboArgs], {
     stdio: "inherit",
     env: createAppEnv(app.path),
-    cwd: projectRoot
+    cwd: projectRoot,
+    shell: isWindows
+  });
+  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 dev server: ${error2.message}`);
+      resolve4(1);
+    });
   });
-  return result.status || 0;
 }
 export {
   main

package/dist/bin/commands/doctor.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @fileoverview Doctor Command Wrapper
+ * @description Re-exports doctor from tooling for CLI bundling.
+ */
+export { doctor as main } from '@donotdev/tooling';
+//# sourceMappingURL=doctor.d.ts.map

package/dist/bin/commands/doctor.d.ts.map

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