zuro-cli 0.0.2-beta.2 → 0.0.2-beta.4

package/README.md

@@ -1,40 +1,44 @@
 # zuro-cli
 
-The backend builder for busy developers.
+A CLI for scaffolding backend foundations and modules in your project.
 
-## Usage
+## init
 
-```bash
-npx zuro-cli@beta init
-```
+Use the `init` command to create a production-ready Express + TypeScript backend foundation.
 
-Add modules:
+The `init` command installs core dependencies, creates base files, and prepares your project for module-based backend development.
 
 ```bash
-npx zuro-cli@beta add database
-npx zuro-cli@beta add auth
+npx zuro-cli init
 ```
 
-## Docs
-
-- https://zuro-cli.devbybriyan.com/docs
+## add
 
-## Registry
+Use the `add` command to add modules to your project.
 
-Default registry:
-
-- https://registry.devbybriyan.com/channels/stable.json
-
-Override for local testing:
+The `add` command scaffolds module files, installs required dependencies, and updates relevant project setup.
 
 ```bash
-export ZURO_REGISTRY_URL=http://127.0.0.1:8787
+npx zuro-cli add [module]
 ```
 
-## Development
+Example:
 
 ```bash
-corepack pnpm install
-corepack pnpm --filter zuro-cli build
-corepack pnpm --filter zuro-cli lint
+npx zuro-cli add auth
 ```
+
+Available modules include:
+
+- `database`
+- `auth`
+- `validator`
+- `error-handler`
+
+## Documentation
+
+Visit https://zuro-cli.devbybriyan.com/docs to view the documentation.
+
+## License
+
+Licensed under the MIT license.

package/dist/index.js

@@ -250,8 +250,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");
@@ -260,14 +261,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);
@@ -584,6 +596,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"));
@@ -629,6 +642,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);
@@ -637,37 +654,165 @@ 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 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 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");
@@ -675,33 +820,59 @@ async function injectAuthRoutes(projectRoot, srcDir) {
     return false;
   }
   let content = await import_fs_extra6.default.readFile(appPath, "utf-8");
-  if (content.includes("routes/auth.routes")) {
-    return true;
-  }
   const authImport = `import authRoutes from "./routes/auth.routes";`;
   const userImport = `import userRoutes from "./routes/user.routes";`;
-  const routeSetup = `
+  const hasAuthImport = content.includes(authImport);
+  const hasUserImport = content.includes(userImport);
+  const hasAuthRoute = /app\.use\(\s*authRoutes\s*\)/.test(content);
+  const hasUserRoute = /app\.use\(\s*["']\/api\/users["']\s*,\s*userRoutes\s*\)/.test(content);
+  let modified = false;
+  let importsReady = hasAuthImport && hasUserImport;
+  if (!importsReady) {
+    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) {
+      const missingImports = [];
+      if (!hasAuthImport) {
+        missingImports.push(authImport);
+      }
+      if (!hasUserImport) {
+        missingImports.push(userImport);
+      }
+      content = content.slice(0, lastImportIndex) + `
+${missingImports.join("\n")}` + content.slice(lastImportIndex);
+      modified = true;
+      importsReady = true;
+    }
+  }
+  let setupReady = hasAuthRoute && hasUserRoute;
+  if (!setupReady) {
+    const setupLines = [];
+    if (!hasAuthRoute) {
+      setupLines.push("app.use(authRoutes);");
+    }
+    if (!hasUserRoute) {
+      setupLines.push('app.use("/api/users", userRoutes);');
+    }
+    const routeSetup = `
 // Auth routes
-app.use(authRoutes);
-app.use("/api/users", userRoutes);
+${setupLines.join("\n")}
 `;
-  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);
+      modified = true;
+      setupReady = true;
+    }
   }
-  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);
+  if (modified) {
+    await import_fs_extra6.default.writeFile(appPath, content);
   }
-  await import_fs_extra6.default.writeFile(appPath, content);
-  return true;
+  return importsReady && setupReady;
 }
 var add = async (moduleName) => {
   const projectRoot = process.cwd();
@@ -710,13 +881,18 @@ var add = async (moduleName) => {
     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",
@@ -727,22 +903,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)({
@@ -751,44 +944,69 @@ 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);
     }
     spinner.succeed("Files generated");
-    if (moduleName === "auth") {
+    if (resolvedModuleName === "auth") {
       spinner.start("Configuring routes in app.ts...");
       const injected = await injectAuthRoutes(projectRoot, srcDir);
       if (injected) {
@@ -797,7 +1015,7 @@ var add = async (moduleName) => {
         spinner.warn("Could not find app.ts - routes need manual setup");
       }
     }
-    if (moduleName === "error-handler") {
+    if (resolvedModuleName === "error-handler") {
       spinner.start("Configuring error handler in app.ts...");
       const injected = await injectErrorHandler(projectRoot, srcDir);
       if (injected) {
@@ -806,26 +1024,42 @@ 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 (databaseBackupPath) {
+      console.log(import_chalk4.default.blue(`\u2139 Backup created at: ${databaseBackupPath}
 `));
-    if (moduleName === "auth") {
+    }
+    if (resolvedModuleName === "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 (generatedAuthSecret) {
+        console.log(import_chalk4.default.yellow("1. BETTER_AUTH_SECRET generated automatically."));
+      } else {
+        console.log(import_chalk4.default.yellow("1. Review your auth env values in .env."));
+      }
+      console.log(import_chalk4.default.dim("   Make sure BETTER_AUTH_URL matches your API origin (for example http://localhost:3000).\n"));
       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"));
@@ -834,7 +1068,7 @@ var add = async (moduleName) => {
       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") {
+    } else if (resolvedModuleName === "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"));
@@ -859,25 +1093,38 @@ var add = async (moduleName) => {
       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")) {
+    } else if (isDatabaseModule(resolvedModuleName)) {
       console.log(import_chalk4.default.bold("\u{1F4CB} Next Steps:\n"));
       let stepNum = 1;
-      if (!customDbUrl) {
+      if (usedDefaultDbUrl) {
         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")
+          import_chalk4.default.dim("   We added a local default. Update it if your DB host/user/password differ.\n")
         );
         stepNum++;
       }
-      console.log(import_chalk4.default.yellow(`${stepNum}. Create schemas in src/db/schema/:`));
+      console.log(import_chalk4.default.yellow(`${stepNum}. Create schemas in ${srcDir}/db/schema/:`));
       console.log(import_chalk4.default.dim("   Add table files and export from index.ts\n"));
+      stepNum++;
+      const setupHint = getDatabaseSetupHint(
+        resolvedModuleName,
+        customDbUrl || DEFAULT_DATABASE_URLS[resolvedModuleName]
+      );
+      console.log(import_chalk4.default.yellow(`${stepNum}. Ensure the database exists:`));
+      console.log(import_chalk4.default.cyan(`   ${setupHint}
+`));
       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"));
     }
   } 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}`));
   }
 };