zuro-cli 0.0.2-beta.1 → 0.0.2-beta.11

package/dist/index.js

@@ -189,18 +189,36 @@ async function fetchFile(filePath, options) {
 var import_fs_extra = __toESM(require("fs-extra"));
 var import_path = __toESM(require("path"));
 var import_execa = require("execa");
-async function initPackageJson(cwd, force = false) {
+function normalizePackageName(name) {
+  const normalized = name.trim().toLowerCase().replace(/[^a-z0-9._-]/g, "-").replace(/-+/g, "-").replace(/^[._-]+|[._-]+$/g, "");
+  return normalized || "zuro-app";
+}
+async function ensurePackageManagerAvailable(pm) {
+  try {
+    await (0, import_execa.execa)(pm, ["--version"], { stdio: "ignore" });
+  } catch {
+    throw new Error(
+      `Package manager '${pm}' is not installed or not available in PATH. Install it or choose npm.`
+    );
+  }
+}
+async function initPackageJson(cwd, force = false, packageName = "zuro-app", srcDir = "src", options = {}) {
   const pkgPath = import_path.default.join(cwd, "package.json");
   if (force || !await import_fs_extra.default.pathExists(pkgPath)) {
+    const scripts = {
+      "dev": `tsx watch ${srcDir}/server.ts`,
+      "build": "tsc",
+      "start": "node dist/server.js"
+    };
+    if (options.enablePrettier) {
+      scripts["format"] = "prettier --write .";
+      scripts["format:check"] = "prettier --check .";
+    }
     await import_fs_extra.default.writeJson(pkgPath, {
-      name: "zuro-app",
+      name: normalizePackageName(packageName),
       version: "0.0.1",
       private: true,
-      scripts: {
-        "dev": "tsx watch src/server.ts",
-        "build": "tsc",
-        "start": "node dist/server.js"
-      }
+      scripts
     }, { spaces: 2 });
   }
 }
@@ -237,8 +255,9 @@ async function installDependencies(pm, deps, cwd, options = {}) {
 var import_fs_extra2 = __toESM(require("fs-extra"));
 var import_path2 = __toESM(require("path"));
 var import_os = __toESM(require("os"));
-var updateEnvFile = async (cwd, variables, createIfMissing = true) => {
+var updateEnvFile = async (cwd, variables, createIfMissing = true, options = {}) => {
   const envPath = import_path2.default.join(cwd, ".env");
+  const overwriteExisting = options.overwriteExisting ?? false;
   let content = "";
   if (import_fs_extra2.default.existsSync(envPath)) {
     content = await import_fs_extra2.default.readFile(envPath, "utf-8");
@@ -247,14 +266,25 @@ var updateEnvFile = async (cwd, variables, createIfMissing = true) => {
   }
   let modified = false;
   for (const [key, value] of Object.entries(variables)) {
-    const regex = new RegExp(`^${key}=`, "m");
-    if (!regex.test(content)) {
-      if (content && !content.endsWith("\n")) {
-        content += import_os.default.EOL;
+    const escapedKey = key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const regex = new RegExp(`^${escapedKey}=.*$`, "m");
+    if (regex.test(content)) {
+      if (!overwriteExisting) {
+        continue;
       }
-      content += `${key}=${value}${import_os.default.EOL}`;
-      modified = true;
+      const nextLine = `${key}=${value}`;
+      const updated = content.replace(regex, nextLine);
+      if (updated !== content) {
+        content = updated;
+        modified = true;
+      }
+      continue;
     }
+    if (content && !content.endsWith("\n")) {
+      content += import_os.default.EOL;
+    }
+    content += `${key}=${value}${import_os.default.EOL}`;
+    modified = true;
   }
   if (modified || !import_fs_extra2.default.existsSync(envPath)) {
     await import_fs_extra2.default.writeFile(envPath, content);
@@ -377,6 +407,13 @@ function showNonZuroProjectMessage() {
   console.log("- a fresh/empty directory, or");
   console.log("- an existing project already managed by Zuro CLI.");
 }
+function showInitFirstMessage() {
+  console.log(import_chalk.default.yellow("No Zuro project found in this directory."));
+  console.log("");
+  console.log(import_chalk.default.yellow("Run init first, then add modules."));
+  console.log("");
+  console.log(import_chalk.default.cyan("npx zuro-cli init"));
+}
 
 // src/commands/init.ts
 function resolveSafeTargetPath(projectRoot, srcDir, file) {
@@ -391,6 +428,48 @@ function resolveSafeTargetPath(projectRoot, srcDir, file) {
     targetPath
   };
 }
+async function ensureSafeTargetDirectory(targetDir, cwd, projectName) {
+  await import_fs_extra4.default.ensureDir(targetDir);
+  const entries = await import_fs_extra4.default.readdir(targetDir);
+  if (entries.length === 0) {
+    return true;
+  }
+  const isCurrentFolder = targetDir === cwd;
+  const response = await (0, import_prompts.default)({
+    type: "confirm",
+    name: "proceed",
+    message: isCurrentFolder ? `Current folder '${projectName}' is not empty. Continue anyway?` : `Target folder '${projectName}' already exists and is not empty. Continue anyway?`,
+    initial: false
+  });
+  return response.proceed === true;
+}
+async function setupPrettier(targetDir) {
+  const prettierConfigPath = import_path4.default.join(targetDir, ".prettierrc");
+  const prettierIgnorePath = import_path4.default.join(targetDir, ".prettierignore");
+  if (!await import_fs_extra4.default.pathExists(prettierConfigPath)) {
+    const prettierConfig = {
+      semi: true,
+      singleQuote: false,
+      trailingComma: "es5",
+      printWidth: 100,
+      tabWidth: 2
+    };
+    await import_fs_extra4.default.writeJson(prettierConfigPath, prettierConfig, { spaces: 2 });
+  }
+  if (!await import_fs_extra4.default.pathExists(prettierIgnorePath)) {
+    const ignoreContent = `node_modules
+dist
+build
+coverage
+.next
+pnpm-lock.yaml
+package-lock.json
+bun.lock
+bun.lockb
+`;
+    await import_fs_extra4.default.writeFile(prettierIgnorePath, ignoreContent);
+  }
+}
 async function init() {
   const cwd = process.cwd();
   const isExistingProject = await import_fs_extra4.default.pathExists(import_path4.default.join(cwd, "package.json"));
@@ -403,6 +482,7 @@ async function init() {
   let pm = "npm";
   let srcDir = "src";
   let projectName = import_path4.default.basename(cwd);
+  let enablePrettier = false;
   if (isExistingProject) {
     console.log(import_chalk2.default.blue("\u2139 Existing project detected."));
     projectName = import_path4.default.basename(cwd);
@@ -440,6 +520,12 @@ async function init() {
           { title: "bun", value: "bun" }
         ],
         initial: 0
+      },
+      {
+        type: "confirm",
+        name: "prettier",
+        message: "Setup Prettier?",
+        initial: true
       }
     ]);
     if (response.pm === void 0) {
@@ -447,6 +533,7 @@ async function init() {
       return;
     }
     pm = response.pm;
+    enablePrettier = response.prettier === true;
     srcDir = "src";
     if (!response.path || response.path.trim() === "") {
       projectName = import_path4.default.basename(cwd);
@@ -455,7 +542,11 @@ async function init() {
     } else {
       projectName = response.path.trim();
       targetDir = import_path4.default.resolve(cwd, projectName);
-      await import_fs_extra4.default.ensureDir(targetDir);
+    }
+    const isSafeTarget = await ensureSafeTargetDirectory(targetDir, cwd, projectName);
+    if (!isSafeTarget) {
+      console.log(import_chalk2.default.red("Operation cancelled."));
+      return;
     }
   }
   const existingConfig = targetDir === cwd ? existingZuroConfig : await readZuroConfig(targetDir);
@@ -464,20 +555,26 @@ async function init() {
     pm,
     srcDir: srcDir || existingConfig?.srcDir || "src"
   };
-  await writeZuroConfig(targetDir, zuroConfig);
   const spinner = (0, import_ora.default)("Connecting to Zuro Registry...").start();
+  let currentStep = "package manager preflight";
   try {
+    spinner.text = `Checking ${pm} availability...`;
+    await ensurePackageManagerAvailable(pm);
+    currentStep = "registry fetch";
+    spinner.text = "Connecting to Zuro Registry...";
     const registryContext = await fetchRegistry();
     const coreModule = registryContext.manifest.modules.core;
     if (!coreModule) {
       spinner.fail("Core module not found in registry.");
       return;
     }
+    currentStep = "project initialization";
     spinner.text = "Initializing project...";
     const hasPackageJson = await import_fs_extra4.default.pathExists(import_path4.default.join(targetDir, "package.json"));
     if (!hasPackageJson) {
-      await initPackageJson(targetDir, true);
+      await initPackageJson(targetDir, true, projectName, srcDir, { enablePrettier });
     }
+    currentStep = "dependency installation";
     spinner.text = `Installing dependencies using ${pm}...`;
     let runtimeDeps = [];
     let devDeps = [];
@@ -492,6 +589,10 @@ async function init() {
     }
     await installDependencies(pm, runtimeDeps, targetDir);
     await installDependencies(pm, devDeps, targetDir, { dev: true });
+    if (enablePrettier) {
+      await installDependencies(pm, ["prettier"], targetDir, { dev: true });
+    }
+    currentStep = "module file generation";
     spinner.text = "Fetching core module files...";
     for (const file of coreModule.files) {
       const { relativeTargetPath, targetPath } = resolveSafeTargetPath(targetDir, srcDir, file);
@@ -514,7 +615,14 @@ async function init() {
       await import_fs_extra4.default.ensureDir(import_path4.default.dirname(targetPath));
       await import_fs_extra4.default.writeFile(targetPath, content);
     }
+    currentStep = "environment file setup";
     await createInitialEnv(targetDir);
+    if (enablePrettier) {
+      currentStep = "prettier setup";
+      await setupPrettier(targetDir);
+    }
+    currentStep = "config write";
+    await writeZuroConfig(targetDir, zuroConfig);
     spinner.succeed(import_chalk2.default.green("Project initialized successfully!"));
     console.log(`
 ${import_chalk2.default.bold("Next steps:")}`);
@@ -525,8 +633,15 @@ ${import_chalk2.default.bold("Next steps:")}`);
     console.log(`
 ${import_chalk2.default.dim("Add modules: zuro-cli add database, zuro-cli add auth")}`);
   } catch (error) {
-    spinner.fail(import_chalk2.default.red("Failed to initialize project."));
-    console.error(error);
+    spinner.fail(import_chalk2.default.red(`Failed during ${currentStep}.`));
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    console.error(import_chalk2.default.red(errorMessage));
+    console.log(`
+${import_chalk2.default.bold("Retry:")}`);
+    if (targetDir !== cwd) {
+      console.log(import_chalk2.default.cyan(`  cd ${projectName}`));
+    }
+    console.log(import_chalk2.default.cyan("  npx zuro-cli init"));
   }
 }
 
@@ -535,6 +650,7 @@ var import_prompts2 = __toESM(require("prompts"));
 var import_ora2 = __toESM(require("ora"));
 var import_path6 = __toESM(require("path"));
 var import_fs_extra6 = __toESM(require("fs-extra"));
+var import_node_crypto2 = require("crypto");
 
 // src/utils/dependency.ts
 var import_fs_extra5 = __toESM(require("fs-extra"));
@@ -580,6 +696,10 @@ var resolveDependencies = async (moduleDependencies, cwd) => {
 
 // src/commands/add.ts
 var import_chalk4 = __toESM(require("chalk"));
+var DEFAULT_DATABASE_URLS = {
+  "database-pg": "postgresql://postgres@localhost:5432/mydb",
+  "database-mysql": "mysql://root@localhost:3306/mydb"
+};
 function resolveSafeTargetPath2(projectRoot, srcDir, file) {
   const targetPath = import_path6.default.resolve(projectRoot, srcDir, file.target);
   const normalizedRoot = import_path6.default.resolve(projectRoot);
@@ -588,86 +708,338 @@ function resolveSafeTargetPath2(projectRoot, srcDir, file) {
   }
   return targetPath;
 }
+function resolvePackageManager(projectRoot) {
+  if (import_fs_extra6.default.existsSync(import_path6.default.join(projectRoot, "pnpm-lock.yaml"))) {
+    return "pnpm";
+  }
+  if (import_fs_extra6.default.existsSync(import_path6.default.join(projectRoot, "bun.lockb")) || import_fs_extra6.default.existsSync(import_path6.default.join(projectRoot, "bun.lock"))) {
+    return "bun";
+  }
+  if (import_fs_extra6.default.existsSync(import_path6.default.join(projectRoot, "yarn.lock"))) {
+    return "yarn";
+  }
+  return "npm";
+}
+function parseDatabaseDialect(value) {
+  const normalized = value?.trim().toLowerCase();
+  if (!normalized) {
+    return null;
+  }
+  if (normalized === "pg" || normalized === "postgres" || normalized === "postgresql" || normalized === "database-pg") {
+    return "database-pg";
+  }
+  if (normalized === "mysql" || normalized === "database-mysql") {
+    return "database-mysql";
+  }
+  return null;
+}
+function isDatabaseModule(moduleName) {
+  return moduleName === "database-pg" || moduleName === "database-mysql";
+}
+function validateDatabaseUrl(rawUrl, moduleName) {
+  const dbUrl = rawUrl.trim();
+  if (!dbUrl) {
+    throw new Error("Database URL cannot be empty.");
+  }
+  let parsed;
+  try {
+    parsed = new URL(dbUrl);
+  } catch {
+    throw new Error(`Invalid database URL: '${dbUrl}'.`);
+  }
+  const protocol = parsed.protocol.toLowerCase();
+  if (moduleName === "database-pg" && protocol !== "postgresql:" && protocol !== "postgres:") {
+    throw new Error("PostgreSQL URL must start with postgres:// or postgresql://");
+  }
+  if (moduleName === "database-mysql" && protocol !== "mysql:") {
+    throw new Error("MySQL URL must start with mysql://");
+  }
+  return dbUrl;
+}
+async function detectInstalledDatabaseDialect(projectRoot, srcDir) {
+  const dbIndexPath = import_path6.default.join(projectRoot, srcDir, "db", "index.ts");
+  if (!import_fs_extra6.default.existsSync(dbIndexPath)) {
+    return null;
+  }
+  const content = await import_fs_extra6.default.readFile(dbIndexPath, "utf-8");
+  if (content.includes("drizzle-orm/node-postgres") || content.includes(`from "pg"`)) {
+    return "database-pg";
+  }
+  if (content.includes("drizzle-orm/mysql2") || content.includes(`from "mysql2`)) {
+    return "database-mysql";
+  }
+  return null;
+}
+async function backupDatabaseFiles(projectRoot, srcDir) {
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  const backupRoot = import_path6.default.join(projectRoot, ".zuro", "backups", `database-${timestamp}`);
+  const candidates = [
+    import_path6.default.join(projectRoot, srcDir, "db", "index.ts"),
+    import_path6.default.join(projectRoot, "drizzle.config.ts")
+  ];
+  let copied = false;
+  for (const filePath of candidates) {
+    if (!import_fs_extra6.default.existsSync(filePath)) {
+      continue;
+    }
+    const relativePath = import_path6.default.relative(projectRoot, filePath);
+    const backupPath = import_path6.default.join(backupRoot, relativePath);
+    await import_fs_extra6.default.ensureDir(import_path6.default.dirname(backupPath));
+    await import_fs_extra6.default.copyFile(filePath, backupPath);
+    copied = true;
+  }
+  return copied ? backupRoot : null;
+}
+function databaseLabel(moduleName) {
+  return moduleName === "database-pg" ? "PostgreSQL" : "MySQL";
+}
+function getDatabaseSetupHint(moduleName, dbUrl) {
+  try {
+    const parsed = new URL(dbUrl);
+    const dbName = parsed.pathname.replace(/^\/+/, "") || "mydb";
+    if (moduleName === "database-pg") {
+      return `createdb ${dbName}`;
+    }
+    return `mysql -e "CREATE DATABASE IF NOT EXISTS ${dbName};"`;
+  } catch {
+    return moduleName === "database-pg" ? "createdb <database_name>" : `mysql -e "CREATE DATABASE IF NOT EXISTS <database_name>;"`;
+  }
+}
+function getModuleDocsPath(moduleName) {
+  if (isDatabaseModule(moduleName)) {
+    return "database";
+  }
+  return moduleName;
+}
+function escapeRegex(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+async function hasEnvVariable(projectRoot, key) {
+  const envPath = import_path6.default.join(projectRoot, ".env");
+  if (!await import_fs_extra6.default.pathExists(envPath)) {
+    return false;
+  }
+  const content = await import_fs_extra6.default.readFile(envPath, "utf-8");
+  const pattern = new RegExp(`^${escapeRegex(key)}=`, "m");
+  return pattern.test(content);
+}
+async function isLikelyEmptyDirectory(cwd) {
+  const entries = await import_fs_extra6.default.readdir(cwd);
+  const ignored = /* @__PURE__ */ new Set([".ds_store", "thumbs.db"]);
+  return entries.filter((entry) => !ignored.has(entry.toLowerCase())).length === 0;
+}
+async function ensureSchemaExport(projectRoot, srcDir, schemaFileName) {
+  const schemaIndexPath = import_path6.default.join(projectRoot, srcDir, "db", "schema", "index.ts");
+  if (!await import_fs_extra6.default.pathExists(schemaIndexPath)) {
+    return;
+  }
+  const exportLine = `export * from "./${schemaFileName}";`;
+  const content = await import_fs_extra6.default.readFile(schemaIndexPath, "utf-8");
+  const normalized = content.replace(/\r\n/g, "\n");
+  const exportPattern = new RegExp(
+    `^\\s*export\\s*\\*\\s*from\\s*["']\\./${escapeRegex(schemaFileName)}["'];?\\s*$`,
+    "m"
+  );
+  if (exportPattern.test(normalized)) {
+    return;
+  }
+  let next = normalized.replace(/^\s*export\s*\{\s*\};?\s*$/m, "").trimEnd();
+  if (next.length > 0) {
+    next += "\n\n";
+  }
+  next += `${exportLine}
+`;
+  await import_fs_extra6.default.writeFile(schemaIndexPath, next);
+}
 async function injectErrorHandler(projectRoot, srcDir) {
   const appPath = import_path6.default.join(projectRoot, srcDir, "app.ts");
   if (!import_fs_extra6.default.existsSync(appPath)) {
     return false;
   }
   let content = await import_fs_extra6.default.readFile(appPath, "utf-8");
-  if (content.includes("errorHandler")) {
-    return true;
-  }
   const errorImport = `import { errorHandler, notFoundHandler } from "./middleware/error-handler";`;
-  const importRegex = /^import .+ from .+;?\s*$/gm;
-  let lastImportIndex = 0;
-  let match;
-  while ((match = importRegex.exec(content)) !== null) {
-    lastImportIndex = match.index + match[0].length;
-  }
-  if (lastImportIndex > 0) {
-    content = content.slice(0, lastImportIndex) + `
+  const hasErrorImport = content.includes(errorImport);
+  const hasNotFoundUse = /app\.use\(\s*notFoundHandler\s*\)/.test(content);
+  const hasErrorUse = /app\.use\(\s*errorHandler\s*\)/.test(content);
+  let modified = false;
+  let importInserted = hasErrorImport;
+  if (!hasErrorImport) {
+    const importRegex = /^import .+ from .+;?\s*$/gm;
+    let lastImportIndex = 0;
+    let match;
+    while ((match = importRegex.exec(content)) !== null) {
+      lastImportIndex = match.index + match[0].length;
+    }
+    if (lastImportIndex > 0) {
+      content = content.slice(0, lastImportIndex) + `
 ${errorImport}` + content.slice(lastImportIndex);
+      modified = true;
+      importInserted = true;
+    }
   }
-  const errorSetup = `
+  let setupInserted = hasNotFoundUse && hasErrorUse;
+  if (!setupInserted) {
+    const setupLines = [];
+    if (!hasNotFoundUse) {
+      setupLines.push("app.use(notFoundHandler);");
+    }
+    if (!hasErrorUse) {
+      setupLines.push("app.use(errorHandler);");
+    }
+    const errorSetup = `
 // Error handling (must be last)
-app.use(notFoundHandler);
-app.use(errorHandler);
+${setupLines.join("\n")}
 `;
-  const exportMatch = content.match(/export default app;?\s*$/m);
-  if (exportMatch && exportMatch.index !== void 0) {
-    content = content.slice(0, exportMatch.index) + errorSetup + "\n" + content.slice(exportMatch.index);
+    const exportMatch = content.match(/export default app;?\s*$/m);
+    if (exportMatch && exportMatch.index !== void 0) {
+      content = content.slice(0, exportMatch.index) + errorSetup + "\n" + content.slice(exportMatch.index);
+      modified = true;
+      setupInserted = true;
+    }
   }
-  await import_fs_extra6.default.writeFile(appPath, content);
-  return true;
+  if (modified) {
+    await import_fs_extra6.default.writeFile(appPath, content);
+  }
+  return importInserted && setupInserted;
 }
 async function injectAuthRoutes(projectRoot, srcDir) {
   const appPath = import_path6.default.join(projectRoot, srcDir, "app.ts");
-  if (!import_fs_extra6.default.existsSync(appPath)) {
+  if (!await import_fs_extra6.default.pathExists(appPath)) {
     return false;
   }
-  let content = await import_fs_extra6.default.readFile(appPath, "utf-8");
-  if (content.includes("routes/auth.routes")) {
-    return true;
+  let appContent = await import_fs_extra6.default.readFile(appPath, "utf-8");
+  const authHandlerImport = `import { toNodeHandler } from "better-auth/node";`;
+  const authImport = `import { auth } from "./lib/auth";`;
+  const routeIndexUserImport = `import userRoutes from "./user.routes";`;
+  const appUserImport = `import userRoutes from "./routes/user.routes";`;
+  let appModified = false;
+  const appendImport = (source, line) => {
+    if (source.includes(line)) {
+      return { source, inserted: true };
+    }
+    const importRegex = /^import .+ from .+;?\s*$/gm;
+    let lastImportIndex = 0;
+    let match;
+    while ((match = importRegex.exec(source)) !== null) {
+      lastImportIndex = match.index + match[0].length;
+    }
+    if (lastImportIndex <= 0) {
+      return { source, inserted: false };
+    }
+    return {
+      source: source.slice(0, lastImportIndex) + `
+${line}` + source.slice(lastImportIndex),
+      inserted: true
+    };
+  };
+  for (const importLine of [authHandlerImport, authImport]) {
+    const next = appendImport(appContent, importLine);
+    if (!next.inserted) {
+      return false;
+    }
+    if (next.source !== appContent) {
+      appContent = next.source;
+      appModified = true;
+    }
+  }
+  const hasAuthMount = /toNodeHandler\(\s*auth\s*\)/.test(appContent) && /\/api\/auth/.test(appContent);
+  if (!hasAuthMount) {
+    const authMountLine = "app.all(/^\\/api\\/auth(?:\\/.*)?$/, toNodeHandler(auth));\n";
+    const jsonIndex = appContent.search(/^\s*app\.use\(\s*express\.json\(\)\s*\);\s*$/m);
+    let insertionIndex = jsonIndex;
+    if (insertionIndex < 0) {
+      const healthIndex = appContent.search(/^\s*app\.get\(\s*["']\/health["']\s*,/m);
+      insertionIndex = healthIndex;
+    }
+    if (insertionIndex < 0) {
+      const exportMatch = appContent.match(/export default app;?\s*$/m);
+      insertionIndex = exportMatch?.index ?? -1;
+    }
+    if (insertionIndex < 0) {
+      return false;
+    }
+    appContent = appContent.slice(0, insertionIndex) + authMountLine + appContent.slice(insertionIndex);
+    appModified = true;
   }
-  const authImport = `import authRoutes from "./routes/auth.routes";`;
-  const userImport = `import userRoutes from "./routes/user.routes";`;
-  const routeSetup = `
-// Auth routes
-app.use(authRoutes);
+  const routeIndexPath = import_path6.default.join(projectRoot, srcDir, "routes", "index.ts");
+  if (await import_fs_extra6.default.pathExists(routeIndexPath)) {
+    let routeContent = await import_fs_extra6.default.readFile(routeIndexPath, "utf-8");
+    let routeModified = false;
+    const userImportResult = appendImport(routeContent, routeIndexUserImport);
+    if (!userImportResult.inserted) {
+      return false;
+    }
+    if (userImportResult.source !== routeContent) {
+      routeContent = userImportResult.source;
+      routeModified = true;
+    }
+    const hasUserRoute = /rootRouter\.use\(\s*["']\/users["']\s*,\s*userRoutes\s*\)/.test(routeContent);
+    if (!hasUserRoute) {
+      const routeSetup = `
+// User routes
+rootRouter.use("/users", userRoutes);
+`;
+      const exportMatch = routeContent.match(/export default rootRouter;?\s*$/m);
+      if (!exportMatch || exportMatch.index === void 0) {
+        return false;
+      }
+      routeContent = routeContent.slice(0, exportMatch.index) + routeSetup + "\n" + routeContent.slice(exportMatch.index);
+      routeModified = true;
+    }
+    if (routeModified) {
+      await import_fs_extra6.default.writeFile(routeIndexPath, routeContent);
+    }
+  } else {
+    const hasUserRoute = /app\.use\(\s*["']\/api\/users["']\s*,\s*userRoutes\s*\)/.test(appContent);
+    if (!hasUserRoute) {
+      const exportMatch = appContent.match(/export default app;?\s*$/m);
+      if (!exportMatch || exportMatch.index === void 0) {
+        return false;
+      }
+      const routeSetup = `
+// User routes
 app.use("/api/users", userRoutes);
 `;
-  const importRegex = /^import .+ from .+;?\s*$/gm;
-  let lastImportIndex = 0;
-  let match;
-  while ((match = importRegex.exec(content)) !== null) {
-    lastImportIndex = match.index + match[0].length;
-  }
-  if (lastImportIndex > 0) {
-    content = content.slice(0, lastImportIndex) + `
-${authImport}
-${userImport}` + content.slice(lastImportIndex);
-  }
-  const exportMatch = content.match(/export default app;?\s*$/m);
-  if (exportMatch && exportMatch.index !== void 0) {
-    content = content.slice(0, exportMatch.index) + routeSetup + "\n" + content.slice(exportMatch.index);
-  }
-  await import_fs_extra6.default.writeFile(appPath, content);
+      appContent = appContent.slice(0, exportMatch.index) + routeSetup + "\n" + appContent.slice(exportMatch.index);
+      appModified = true;
+    }
+    const userImportResult = appendImport(appContent, appUserImport);
+    if (!userImportResult.inserted) {
+      return false;
+    }
+    if (userImportResult.source !== appContent) {
+      appContent = userImportResult.source;
+      appModified = true;
+    }
+  }
+  if (appModified) {
+    await import_fs_extra6.default.writeFile(appPath, appContent);
+  }
   return true;
 }
 var add = async (moduleName) => {
   const projectRoot = process.cwd();
   const projectConfig = await readZuroConfig(projectRoot);
   if (!projectConfig) {
+    if (await isLikelyEmptyDirectory(projectRoot)) {
+      showInitFirstMessage();
+      return;
+    }
     showNonZuroProjectMessage();
     return;
   }
-  let srcDir = projectConfig.srcDir || "src";
+  const srcDir = projectConfig.srcDir || "src";
+  let resolvedModuleName = moduleName;
+  const parsedDialect = parseDatabaseDialect(moduleName);
+  if (parsedDialect) {
+    resolvedModuleName = parsedDialect;
+  }
   let customDbUrl;
-  const DEFAULT_URLS = {
-    "database-pg": "postgresql://root@localhost:5432/mydb",
-    "database-mysql": "mysql://root@localhost:3306/mydb"
-  };
-  if (moduleName === "database") {
+  let usedDefaultDbUrl = false;
+  let databaseBackupPath = null;
+  let generatedAuthSecret = false;
+  let authDatabaseDialect = null;
+  if (resolvedModuleName === "database") {
     const variantResponse = await (0, import_prompts2.default)({
       type: "select",
       name: "variant",
@@ -678,22 +1050,39 @@ var add = async (moduleName) => {
       ]
     });
     if (!variantResponse.variant) {
-      process.exit(0);
+      console.log(import_chalk4.default.yellow("Operation cancelled."));
+      return;
     }
-    moduleName = variantResponse.variant;
-    const defaultUrl = DEFAULT_URLS[moduleName];
-    console.log(import_chalk4.default.dim(`  Tip: Leave blank to use ${defaultUrl}
-`));
-    const urlResponse = await (0, import_prompts2.default)({
-      type: "text",
-      name: "dbUrl",
-      message: "Database URL",
-      initial: ""
-    });
-    customDbUrl = urlResponse.dbUrl?.trim() || defaultUrl;
+    resolvedModuleName = variantResponse.variant;
   }
-  if ((moduleName === "database-pg" || moduleName === "database-mysql") && customDbUrl === void 0) {
-    const defaultUrl = DEFAULT_URLS[moduleName];
+  if (isDatabaseModule(resolvedModuleName)) {
+    const installedDialect = await detectInstalledDatabaseDialect(projectRoot, srcDir);
+    if (installedDialect && installedDialect !== resolvedModuleName) {
+      console.log(
+        import_chalk4.default.yellow(
+          `
+\u26A0 Existing database setup detected: ${databaseLabel(installedDialect)}.`
+        )
+      );
+      console.log(
+        import_chalk4.default.yellow(
+          `  Switching to ${databaseLabel(resolvedModuleName)} will overwrite db files and drizzle config.
+`
+        )
+      );
+      const switchResponse = await (0, import_prompts2.default)({
+        type: "confirm",
+        name: "proceed",
+        message: "Continue and switch database dialect?",
+        initial: false
+      });
+      if (!switchResponse.proceed) {
+        console.log(import_chalk4.default.yellow("Operation cancelled."));
+        return;
+      }
+      databaseBackupPath = await backupDatabaseFiles(projectRoot, srcDir);
+    }
+    const defaultUrl = DEFAULT_DATABASE_URLS[resolvedModuleName];
     console.log(import_chalk4.default.dim(`  Tip: Leave blank to use ${defaultUrl}
 `));
     const response = await (0, import_prompts2.default)({
@@ -702,53 +1091,82 @@ var add = async (moduleName) => {
       message: "Database URL",
       initial: ""
     });
-    customDbUrl = response.dbUrl?.trim() || defaultUrl;
+    if (response.dbUrl === void 0) {
+      console.log(import_chalk4.default.yellow("Operation cancelled."));
+      return;
+    }
+    const enteredUrl = response.dbUrl?.trim() || "";
+    usedDefaultDbUrl = enteredUrl.length === 0;
+    customDbUrl = validateDatabaseUrl(enteredUrl || defaultUrl, resolvedModuleName);
   }
-  const spinner = (0, import_ora2.default)(`Checking registry for ${moduleName}...`).start();
+  const pm = resolvePackageManager(projectRoot);
+  const spinner = (0, import_ora2.default)(`Checking registry for ${resolvedModuleName}...`).start();
+  let currentStep = "package manager preflight";
   try {
+    spinner.text = `Checking ${pm} availability...`;
+    await ensurePackageManagerAvailable(pm);
+    currentStep = "registry fetch";
+    spinner.text = `Checking registry for ${resolvedModuleName}...`;
     const registryContext = await fetchRegistry();
-    const module2 = registryContext.manifest.modules[moduleName];
+    const module2 = registryContext.manifest.modules[resolvedModuleName];
     if (!module2) {
-      spinner.fail(`Module '${moduleName}' not found.`);
+      spinner.fail(`Module '${resolvedModuleName}' not found.`);
       return;
     }
-    spinner.succeed(`Found module: ${import_chalk4.default.cyan(moduleName)}`);
+    spinner.succeed(`Found module: ${import_chalk4.default.cyan(resolvedModuleName)}`);
     const moduleDeps = module2.moduleDependencies || [];
+    currentStep = "module dependency resolution";
     await resolveDependencies(moduleDeps, projectRoot);
+    currentStep = "dependency installation";
     spinner.start("Installing dependencies...");
-    let pm = "npm";
-    if (import_fs_extra6.default.existsSync(import_path6.default.join(projectRoot, "pnpm-lock.yaml"))) {
-      pm = "pnpm";
-    } else if (import_fs_extra6.default.existsSync(import_path6.default.join(projectRoot, "bun.lockb"))) {
-      pm = "bun";
-    } else if (import_fs_extra6.default.existsSync(import_path6.default.join(projectRoot, "yarn.lock"))) {
-      pm = "yarn";
-    }
     await installDependencies(pm, module2.dependencies || [], projectRoot);
     await installDependencies(pm, module2.devDependencies || [], projectRoot, { dev: true });
     spinner.succeed("Dependencies installed");
+    currentStep = "module scaffolding";
     spinner.start("Scaffolding files...");
+    if (resolvedModuleName === "auth") {
+      authDatabaseDialect = await detectInstalledDatabaseDialect(projectRoot, srcDir);
+    }
     for (const file of module2.files) {
-      const content = await fetchFile(file.path, {
+      let fetchPath = file.path;
+      let expectedSha256 = file.sha256;
+      let expectedSize = file.size;
+      if (resolvedModuleName === "auth" && file.target === "db/schema/auth.ts" && authDatabaseDialect === "database-mysql") {
+        fetchPath = "express/db/schema/auth.mysql.ts";
+        expectedSha256 = void 0;
+        expectedSize = void 0;
+      }
+      let content = await fetchFile(fetchPath, {
         baseUrl: registryContext.fileBaseUrl,
-        expectedSha256: file.sha256,
-        expectedSize: file.size
+        expectedSha256,
+        expectedSize
       });
+      if (isDatabaseModule(resolvedModuleName) && file.target === "../drizzle.config.ts") {
+        const normalizedSrcDir = srcDir.replace(/\\/g, "/");
+        content = content.replace(
+          /schema:\s*["'][^"']+["']/,
+          `schema: "./${normalizedSrcDir}/db/schema/*"`
+        );
+      }
       const targetPath = resolveSafeTargetPath2(projectRoot, srcDir, file);
       await import_fs_extra6.default.ensureDir(import_path6.default.dirname(targetPath));
       await import_fs_extra6.default.writeFile(targetPath, content);
     }
+    const schemaExports = module2.files.map((file) => file.target.replace(/\\/g, "/")).filter((target) => /^db\/schema\/[^/]+\.ts$/.test(target)).map((target) => import_path6.default.posix.basename(target, ".ts")).filter((name) => name !== "index");
+    for (const schemaFileName of schemaExports) {
+      await ensureSchemaExport(projectRoot, srcDir, schemaFileName);
+    }
     spinner.succeed("Files generated");
-    if (moduleName === "auth") {
-      spinner.start("Configuring routes in app.ts...");
+    if (resolvedModuleName === "auth") {
+      spinner.start("Configuring routes...");
       const injected = await injectAuthRoutes(projectRoot, srcDir);
       if (injected) {
-        spinner.succeed("Routes configured in app.ts");
+        spinner.succeed("Routes configured");
       } else {
-        spinner.warn("Could not find app.ts - routes need manual setup");
+        spinner.warn("Could not configure routes automatically");
       }
     }
-    if (moduleName === "error-handler") {
+    if (resolvedModuleName === "error-handler") {
       spinner.start("Configuring error handler in app.ts...");
       const injected = await injectErrorHandler(projectRoot, srcDir);
       if (injected) {
@@ -757,78 +1175,63 @@ var add = async (moduleName) => {
         spinner.warn("Could not find app.ts - error handler needs manual setup");
       }
     }
-    const envConfig = ENV_CONFIGS[moduleName];
+    const envConfig = ENV_CONFIGS[resolvedModuleName];
     if (envConfig) {
+      currentStep = "environment configuration";
       spinner.start("Updating environment configuration...");
       const envVars = { ...envConfig.envVars };
-      if (customDbUrl && (moduleName === "database-pg" || moduleName === "database-mysql")) {
+      if (customDbUrl && isDatabaseModule(resolvedModuleName)) {
         envVars.DATABASE_URL = customDbUrl;
       }
-      await updateEnvFile(projectRoot, envVars);
+      if (resolvedModuleName === "auth") {
+        const hasExistingSecret = await hasEnvVariable(projectRoot, "BETTER_AUTH_SECRET");
+        if (!hasExistingSecret) {
+          envVars.BETTER_AUTH_SECRET = (0, import_node_crypto2.randomBytes)(32).toString("hex");
+          generatedAuthSecret = true;
+        }
+      }
+      await updateEnvFile(projectRoot, envVars, true, {
+        overwriteExisting: isDatabaseModule(resolvedModuleName)
+      });
       await updateEnvSchema(projectRoot, srcDir, envConfig.schemaFields);
       spinner.succeed("Environment configured");
     }
     console.log(import_chalk4.default.green(`
-\u2714 ${moduleName} added successfully!
+\u2714 ${resolvedModuleName} added successfully!
 `));
-    if (moduleName === "auth") {
-      console.log(import_chalk4.default.bold("\u{1F4CB} Next Steps:\n"));
-      console.log(import_chalk4.default.yellow("1. Update your .env file:"));
-      console.log(
-        import_chalk4.default.dim("   We added placeholder values. Update BETTER_AUTH_SECRET with a secure key.\n")
+    if (databaseBackupPath) {
+      console.log(import_chalk4.default.blue(`\u2139 Backup created at: ${databaseBackupPath}
+`));
+    }
+    const docsPath = getModuleDocsPath(resolvedModuleName);
+    const docsUrl = `https://zuro-cli.devbybriyan.com/docs/${docsPath}`;
+    console.log(import_chalk4.default.blue(`\u2139 Docs: ${docsUrl}`));
+    if (isDatabaseModule(resolvedModuleName)) {
+      if (usedDefaultDbUrl) {
+        console.log(import_chalk4.default.yellow("\u2139 Review DATABASE_URL in .env if your local DB config differs."));
+      }
+      const setupHint = getDatabaseSetupHint(
+        resolvedModuleName,
+        customDbUrl || DEFAULT_DATABASE_URLS[resolvedModuleName]
       );
-      console.log(import_chalk4.default.yellow("2. Run database migrations:"));
-      console.log(import_chalk4.default.cyan("   npx drizzle-kit generate"));
-      console.log(import_chalk4.default.cyan("   npx drizzle-kit migrate\n"));
-      console.log(import_chalk4.default.yellow("3. Available endpoints:"));
-      console.log(import_chalk4.default.dim("   POST /auth/sign-up/email  - Register"));
-      console.log(import_chalk4.default.dim("   POST /auth/sign-in/email  - Login"));
-      console.log(import_chalk4.default.dim("   POST /auth/sign-out       - Logout"));
-      console.log(import_chalk4.default.dim("   GET  /api/users/me        - Current user\n"));
-    } else if (moduleName === "error-handler") {
-      console.log(import_chalk4.default.bold("\u{1F4CB} Usage:\n"));
-      console.log(import_chalk4.default.yellow("Throw errors in your controllers:"));
-      console.log(import_chalk4.default.dim("   \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
-      console.log(import_chalk4.default.white(`   import { UnauthorizedError, NotFoundError } from "./lib/errors";`));
-      console.log("");
-      console.log(import_chalk4.default.white(`   throw new UnauthorizedError("Invalid credentials");`));
-      console.log(import_chalk4.default.white(`   throw new NotFoundError("User not found");`));
-      console.log(import_chalk4.default.dim("   \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n"));
-      console.log(import_chalk4.default.yellow("Available error classes:"));
-      console.log(import_chalk4.default.dim("   BadRequestError     (400)"));
-      console.log(import_chalk4.default.dim("   UnauthorizedError   (401)"));
-      console.log(import_chalk4.default.dim("   ForbiddenError      (403)"));
-      console.log(import_chalk4.default.dim("   NotFoundError       (404)"));
-      console.log(import_chalk4.default.dim("   ConflictError       (409)"));
-      console.log(import_chalk4.default.dim("   ValidationError     (422)"));
-      console.log(import_chalk4.default.dim("   InternalServerError (500)\n"));
-      console.log(import_chalk4.default.yellow("Wrap async handlers:"));
-      console.log(import_chalk4.default.dim("   \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
-      console.log(import_chalk4.default.white(`   import { asyncHandler } from "./middleware/error-handler";`));
-      console.log("");
-      console.log(import_chalk4.default.white(`   router.get("/users", asyncHandler(async (req, res) => {`));
-      console.log(import_chalk4.default.white("       // errors auto-caught"));
-      console.log(import_chalk4.default.white("   }));"));
-      console.log(import_chalk4.default.dim("   \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n"));
-    } else if (moduleName.includes("database")) {
-      console.log(import_chalk4.default.bold("\u{1F4CB} Next Steps:\n"));
-      let stepNum = 1;
-      if (!customDbUrl) {
-        console.log(import_chalk4.default.yellow(`${stepNum}. Update DATABASE_URL in .env:`));
-        console.log(
-          import_chalk4.default.dim("   We added a placeholder. Update with your actual database credentials.\n")
-        );
-        stepNum++;
+      console.log(import_chalk4.default.yellow(`\u2139 Ensure DB exists: ${setupHint}`));
+      console.log(import_chalk4.default.yellow("\u2139 Run migrations: npx drizzle-kit generate && npx drizzle-kit migrate"));
+    }
+    if (resolvedModuleName === "auth") {
+      if (generatedAuthSecret) {
+        console.log(import_chalk4.default.yellow("\u2139 BETTER_AUTH_SECRET was generated automatically."));
+      } else {
+        console.log(import_chalk4.default.yellow("\u2139 Review BETTER_AUTH_SECRET and BETTER_AUTH_URL in .env."));
       }
-      console.log(import_chalk4.default.yellow(`${stepNum}. Create schemas in src/db/schema/:`));
-      console.log(import_chalk4.default.dim("   Add table files and export from index.ts\n"));
-      stepNum++;
-      console.log(import_chalk4.default.yellow(`${stepNum}. Run migrations:`));
-      console.log(import_chalk4.default.cyan("   npx drizzle-kit generate"));
-      console.log(import_chalk4.default.cyan("   npx drizzle-kit migrate\n"));
+      console.log(import_chalk4.default.yellow("\u2139 Run migrations: npx drizzle-kit generate && npx drizzle-kit migrate"));
     }
   } catch (error) {
-    spinner.fail(`Failed to add module: ${error.message}`);
+    spinner.fail(import_chalk4.default.red(`Failed during ${currentStep}.`));
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    console.error(import_chalk4.default.red(errorMessage));
+    console.log(`
+${import_chalk4.default.bold("Retry:")}`);
+    console.log(import_chalk4.default.cyan(`  npx zuro-cli add ${resolvedModuleName}`));
   }
 };