zuro-cli 0.0.2-beta.0

package/dist/index.js

@@ -0,0 +1,841 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/index.ts
+var import_commander = require("commander");
+
+// src/commands/init.ts
+var import_ora = __toESM(require("ora"));
+var import_chalk2 = __toESM(require("chalk"));
+var import_fs_extra4 = __toESM(require("fs-extra"));
+var import_path4 = __toESM(require("path"));
+var import_prompts = __toESM(require("prompts"));
+
+// src/utils/registry.ts
+var import_node_crypto = require("crypto");
+var DEFAULT_REGISTRY_BASE_URL = "https://zuro-cli.devbybriyan.com/registry";
+var DEFAULT_REGISTRY_ENTRY_URL = `${DEFAULT_REGISTRY_BASE_URL}/channels/stable.json`;
+var REGISTRY_ENV_VAR = "ZURO_REGISTRY_URL";
+var REQUEST_TIMEOUT_MS = 8e3;
+var MAX_RETRIES = 2;
+function withTrailingSlash(url) {
+  return url.endsWith("/") ? url : `${url}/`;
+}
+function resolveRegistryEntryUrl() {
+  const override = process.env[REGISTRY_ENV_VAR]?.trim();
+  if (!override) {
+    return DEFAULT_REGISTRY_ENTRY_URL;
+  }
+  let parsed;
+  try {
+    parsed = new URL(override);
+  } catch {
+    throw new Error(
+      `Invalid ${REGISTRY_ENV_VAR} value '${override}'. Expected a valid http(s) URL.`
+    );
+  }
+  if (parsed.pathname.endsWith(".json")) {
+    return parsed.toString();
+  }
+  return new URL("channels/stable.json", withTrailingSlash(parsed.toString())).toString();
+}
+function isRegistryManifest(data) {
+  if (!data || typeof data !== "object") {
+    return false;
+  }
+  const candidate = data;
+  return !!candidate.modules && typeof candidate.modules === "object";
+}
+function isChannelPointer(data) {
+  if (!data || typeof data !== "object") {
+    return false;
+  }
+  const candidate = data;
+  return typeof candidate.indexPath === "string" || typeof candidate.indexUrl === "string";
+}
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function fetchWithRetry(url) {
+  let lastError;
+  for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+    try {
+      const response = await fetch(url, {
+        headers: { Accept: "application/json, text/plain, */*" },
+        signal: controller.signal
+      });
+      if (response.ok) {
+        return response;
+      }
+      const shouldRetry = response.status >= 500 && attempt < MAX_RETRIES;
+      if (shouldRetry) {
+        await delay(250 * (attempt + 1));
+        continue;
+      }
+      throw new Error(`Request failed (${response.status} ${response.statusText}) for ${url}`);
+    } catch (error) {
+      lastError = error;
+      if (attempt === MAX_RETRIES) {
+        break;
+      }
+      await delay(250 * (attempt + 1));
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
+  if (lastError instanceof Error) {
+    throw lastError;
+  }
+  throw new Error(`Failed to fetch ${url}`);
+}
+async function fetchJson(url) {
+  const response = await fetchWithRetry(url);
+  const data = await response.json();
+  return {
+    data,
+    resolvedUrl: response.url || url
+  };
+}
+function resolveManifestUrl(pointer, pointerUrl) {
+  const explicit = pointer.indexUrl || pointer.indexPath;
+  if (!explicit) {
+    throw new Error("Registry channel pointer is missing indexUrl/indexPath");
+  }
+  return new URL(explicit, pointerUrl).toString();
+}
+async function fetchRegistry() {
+  const registryEntryUrl = resolveRegistryEntryUrl();
+  let entry;
+  try {
+    entry = await fetchJson(registryEntryUrl);
+  } catch (error) {
+    throw new Error(
+      `Unable to fetch registry from ${registryEntryUrl}. For local testing set ${REGISTRY_ENV_VAR}=http://127.0.0.1:8787.`,
+      { cause: error }
+    );
+  }
+  if (isRegistryManifest(entry.data)) {
+    return {
+      manifest: entry.data,
+      manifestUrl: entry.resolvedUrl,
+      fileBaseUrl: withTrailingSlash(new URL(".", entry.resolvedUrl).toString())
+    };
+  }
+  if (!isChannelPointer(entry.data)) {
+    throw new Error(
+      `Invalid registry payload at ${registryEntryUrl}. Expected manifest or channel pointer.`
+    );
+  }
+  const manifestUrl = resolveManifestUrl(entry.data, entry.resolvedUrl);
+  const manifestResult = await fetchJson(manifestUrl);
+  if (!isRegistryManifest(manifestResult.data)) {
+    throw new Error(`Invalid manifest payload at ${manifestUrl}.`);
+  }
+  return {
+    manifest: manifestResult.data,
+    manifestUrl: manifestResult.resolvedUrl,
+    fileBaseUrl: withTrailingSlash(new URL(".", manifestResult.resolvedUrl).toString())
+  };
+}
+async function fetchFile(filePath, options) {
+  const normalizedPath = filePath.replace(/^\//, "");
+  const fileUrl = new URL(normalizedPath, withTrailingSlash(options.baseUrl)).toString();
+  const response = await fetchWithRetry(fileUrl);
+  const content = await response.text();
+  if (typeof options.expectedSize === "number") {
+    const actualSize = Buffer.byteLength(content, "utf8");
+    if (actualSize !== options.expectedSize) {
+      throw new Error(
+        `Size mismatch for ${filePath}. Expected ${options.expectedSize}, got ${actualSize}.`
+      );
+    }
+  }
+  if (options.expectedSha256) {
+    const actualSha256 = (0, import_node_crypto.createHash)("sha256").update(content, "utf8").digest("hex");
+    if (actualSha256 !== options.expectedSha256) {
+      throw new Error(
+        `Checksum mismatch for ${filePath}. Expected ${options.expectedSha256}, got ${actualSha256}.`
+      );
+    }
+  }
+  return content;
+}
+
+// src/utils/pm.ts
+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) {
+  const pkgPath = import_path.default.join(cwd, "package.json");
+  if (force || !await import_fs_extra.default.pathExists(pkgPath)) {
+    await import_fs_extra.default.writeJson(pkgPath, {
+      name: "zuro-app",
+      version: "0.0.1",
+      private: true,
+      scripts: {
+        "dev": "tsx watch src/server.ts",
+        "build": "tsc",
+        "start": "node dist/server.js"
+      }
+    }, { spaces: 2 });
+  }
+}
+async function installDependencies(pm, deps, cwd, options = {}) {
+  const uniqueDeps = [...new Set(deps)].filter(Boolean);
+  if (uniqueDeps.length === 0) {
+    return;
+  }
+  const isDev = options.dev ?? false;
+  if (pm === "npm") {
+    const args = ["install", ...isDev ? ["--save-dev"] : [], ...uniqueDeps];
+    await (0, import_execa.execa)("npm", args, { cwd });
+    return;
+  }
+  if (pm === "pnpm") {
+    const args = ["add", ...isDev ? ["-D"] : [], ...uniqueDeps];
+    await (0, import_execa.execa)("pnpm", args, { cwd });
+    return;
+  }
+  if (pm === "yarn") {
+    const args = ["add", ...isDev ? ["-D"] : [], ...uniqueDeps];
+    await (0, import_execa.execa)("yarn", args, { cwd });
+    return;
+  }
+  if (pm === "bun") {
+    const args = ["add", ...isDev ? ["-d"] : [], ...uniqueDeps];
+    await (0, import_execa.execa)("bun", args, { cwd });
+    return;
+  }
+  throw new Error(`Unsupported package manager: ${pm}`);
+}
+
+// src/utils/env-manager.ts
+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) => {
+  const envPath = import_path2.default.join(cwd, ".env");
+  let content = "";
+  if (import_fs_extra2.default.existsSync(envPath)) {
+    content = await import_fs_extra2.default.readFile(envPath, "utf-8");
+  } else if (!createIfMissing) {
+    return;
+  }
+  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;
+      }
+      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);
+  }
+};
+var updateEnvSchema = async (cwd, srcDir, fields) => {
+  const envPath = import_path2.default.join(cwd, srcDir, "env.ts");
+  if (!import_fs_extra2.default.existsSync(envPath)) {
+    return false;
+  }
+  let content = await import_fs_extra2.default.readFile(envPath, "utf-8");
+  let modified = false;
+  for (const field of fields) {
+    if (content.includes(`${field.name}:`)) {
+      continue;
+    }
+    const schemaEndRegex = /(\n\s*)(}\);?\s*\n\s*export const env)/;
+    const match = content.match(schemaEndRegex);
+    if (match) {
+      const indent = "    ";
+      const newField = `${indent}${field.name}: ${field.schema},
+`;
+      content = content.replace(
+        schemaEndRegex,
+        `
+${newField}$1$2`
+      );
+      modified = true;
+    }
+  }
+  if (modified) {
+    await import_fs_extra2.default.writeFile(envPath, content);
+  }
+  return modified;
+};
+var createInitialEnv = async (cwd) => {
+  const envPath = import_path2.default.join(cwd, ".env");
+  if (import_fs_extra2.default.existsSync(envPath)) {
+    return;
+  }
+  const content = `# Environment Variables
+PORT=3000
+NODE_ENV=development
+`;
+  await import_fs_extra2.default.writeFile(envPath, content);
+};
+var ENV_CONFIGS = {
+  "database-pg": {
+    envVars: {
+      DATABASE_URL: "postgresql://postgres@localhost:5432/mydb"
+    },
+    schemaFields: [
+      { name: "DATABASE_URL", schema: "z.string().url()" }
+    ]
+  },
+  "database-mysql": {
+    envVars: {
+      DATABASE_URL: "mysql://root@localhost:3306/mydb"
+    },
+    schemaFields: [
+      { name: "DATABASE_URL", schema: "z.string().url()" }
+    ]
+  },
+  auth: {
+    envVars: {
+      BETTER_AUTH_SECRET: "your-secret-key-at-least-32-characters-long",
+      BETTER_AUTH_URL: "http://localhost:3000"
+    },
+    schemaFields: [
+      { name: "BETTER_AUTH_SECRET", schema: "z.string().min(32)" },
+      { name: "BETTER_AUTH_URL", schema: "z.string().url()" }
+    ]
+  }
+};
+
+// src/utils/config.ts
+var import_fs_extra3 = __toESM(require("fs-extra"));
+var import_path3 = __toESM(require("path"));
+function sanitizeConfig(input) {
+  if (!input || typeof input !== "object") {
+    return {};
+  }
+  const raw = input;
+  const config = {};
+  if (typeof raw.name === "string") {
+    config.name = raw.name;
+  }
+  if (typeof raw.pm === "string") {
+    config.pm = raw.pm;
+  }
+  if (typeof raw.srcDir === "string") {
+    config.srcDir = raw.srcDir;
+  }
+  return config;
+}
+function getConfigPath(cwd) {
+  return import_path3.default.join(cwd, "zuro.json");
+}
+async function readZuroConfig(cwd) {
+  const configPath = getConfigPath(cwd);
+  if (!await import_fs_extra3.default.pathExists(configPath)) {
+    return null;
+  }
+  const raw = await import_fs_extra3.default.readJson(configPath);
+  return sanitizeConfig(raw);
+}
+async function writeZuroConfig(cwd, config) {
+  const configPath = getConfigPath(cwd);
+  await import_fs_extra3.default.writeJson(configPath, sanitizeConfig(config), { spaces: 2 });
+}
+
+// src/utils/project-guard.ts
+var import_chalk = __toESM(require("chalk"));
+function showNonZuroProjectMessage() {
+  console.log(import_chalk.default.yellow("This directory looks like an existing project that wasn't created with Zuro CLI."));
+  console.log("");
+  console.log(import_chalk.default.yellow("We stopped here because we don't want to make unnecessary changes to your project."));
+  console.log("");
+  console.log("Zuro CLI works in:");
+  console.log("- a fresh/empty directory, or");
+  console.log("- an existing project already managed by Zuro CLI.");
+}
+
+// src/commands/init.ts
+function resolveSafeTargetPath(projectRoot, srcDir, file) {
+  const relativeTargetPath = import_path4.default.join(srcDir, file.target);
+  const targetPath = import_path4.default.resolve(projectRoot, relativeTargetPath);
+  const normalizedRoot = import_path4.default.resolve(projectRoot);
+  if (targetPath !== normalizedRoot && !targetPath.startsWith(`${normalizedRoot}${import_path4.default.sep}`)) {
+    throw new Error(`Refusing to write outside project directory: ${file.target}`);
+  }
+  return {
+    relativeTargetPath,
+    targetPath
+  };
+}
+async function init() {
+  const cwd = process.cwd();
+  const isExistingProject = await import_fs_extra4.default.pathExists(import_path4.default.join(cwd, "package.json"));
+  const existingZuroConfig = await readZuroConfig(cwd);
+  if (isExistingProject && !existingZuroConfig) {
+    showNonZuroProjectMessage();
+    return;
+  }
+  let targetDir = cwd;
+  let pm = "npm";
+  let srcDir = "src";
+  let projectName = import_path4.default.basename(cwd);
+  if (isExistingProject) {
+    console.log(import_chalk2.default.blue("\u2139 Existing project detected."));
+    projectName = import_path4.default.basename(cwd);
+    if (await import_fs_extra4.default.pathExists(import_path4.default.join(cwd, "pnpm-lock.yaml"))) {
+      pm = "pnpm";
+    } else if (await import_fs_extra4.default.pathExists(import_path4.default.join(cwd, "bun.lockb"))) {
+      pm = "bun";
+    } else if (await import_fs_extra4.default.pathExists(import_path4.default.join(cwd, "yarn.lock"))) {
+      pm = "yarn";
+    }
+    const response = await (0, import_prompts.default)({
+      type: "text",
+      name: "srcDir",
+      message: "Where is your source code located?",
+      initial: "src"
+    });
+    srcDir = response.srcDir || "src";
+  } else {
+    console.log(import_chalk2.default.dim(`  Tip: Leave blank to use current folder (${import_path4.default.basename(cwd)})
+`));
+    const response = await (0, import_prompts.default)([
+      {
+        type: "text",
+        name: "path",
+        message: "Project name (blank for current folder)",
+        initial: ""
+      },
+      {
+        type: "select",
+        name: "pm",
+        message: "Package Manager?",
+        choices: [
+          { title: "npm", value: "npm" },
+          { title: "pnpm", value: "pnpm" },
+          { title: "bun", value: "bun" }
+        ],
+        initial: 0
+      }
+    ]);
+    if (response.pm === void 0) {
+      console.log(import_chalk2.default.red("Operation cancelled."));
+      return;
+    }
+    pm = response.pm;
+    srcDir = "src";
+    if (!response.path || response.path.trim() === "") {
+      projectName = import_path4.default.basename(cwd);
+      targetDir = cwd;
+      console.log(import_chalk2.default.blue(`\u2139 Using current folder: ${projectName}`));
+    } else {
+      projectName = response.path.trim();
+      targetDir = import_path4.default.resolve(cwd, projectName);
+      await import_fs_extra4.default.ensureDir(targetDir);
+    }
+  }
+  const existingConfig = targetDir === cwd ? existingZuroConfig : await readZuroConfig(targetDir);
+  const zuroConfig = {
+    name: projectName,
+    pm,
+    srcDir: srcDir || existingConfig?.srcDir || "src"
+  };
+  await writeZuroConfig(targetDir, zuroConfig);
+  const spinner = (0, import_ora.default)("Connecting to Zuro Registry...").start();
+  try {
+    const registryContext = await fetchRegistry();
+    const coreModule = registryContext.manifest.modules.core;
+    if (!coreModule) {
+      spinner.fail("Core module not found in registry.");
+      return;
+    }
+    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);
+    }
+    spinner.text = `Installing dependencies using ${pm}...`;
+    let runtimeDeps = [];
+    let devDeps = [];
+    if (isExistingProject) {
+      const safeDeps = ["zod", "dotenv"];
+      const coreDeps = coreModule.dependencies || [];
+      runtimeDeps = coreDeps.filter((dependency) => safeDeps.includes(dependency));
+      devDeps = coreModule.devDependencies || [];
+    } else {
+      runtimeDeps = coreModule.dependencies || [];
+      devDeps = coreModule.devDependencies || [];
+    }
+    await installDependencies(pm, runtimeDeps, targetDir);
+    await installDependencies(pm, devDeps, targetDir, { dev: true });
+    spinner.text = "Fetching core module files...";
+    for (const file of coreModule.files) {
+      const { relativeTargetPath, targetPath } = resolveSafeTargetPath(targetDir, srcDir, file);
+      const fileName = import_path4.default.basename(targetPath);
+      if (isExistingProject) {
+        if (fileName === "app.ts" || fileName === "server.ts") {
+          continue;
+        }
+        const relativeParts = relativeTargetPath.split(import_path4.default.sep);
+        const isSafe = fileName === "env.ts" || relativeParts.includes("lib");
+        if (!isSafe) {
+          continue;
+        }
+      }
+      const content = await fetchFile(file.path, {
+        baseUrl: registryContext.fileBaseUrl,
+        expectedSha256: file.sha256,
+        expectedSize: file.size
+      });
+      await import_fs_extra4.default.ensureDir(import_path4.default.dirname(targetPath));
+      await import_fs_extra4.default.writeFile(targetPath, content);
+    }
+    await createInitialEnv(targetDir);
+    spinner.succeed(import_chalk2.default.green("Project initialized successfully!"));
+    console.log(`
+${import_chalk2.default.bold("Next steps:")}`);
+    if (targetDir !== cwd) {
+      console.log(import_chalk2.default.cyan(`  cd ${projectName}`));
+    }
+    console.log(import_chalk2.default.cyan(`  ${pm} run dev`));
+    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);
+  }
+}
+
+// src/commands/add.ts
+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"));
+
+// src/utils/dependency.ts
+var import_fs_extra5 = __toESM(require("fs-extra"));
+var import_path5 = __toESM(require("path"));
+var import_chalk3 = __toESM(require("chalk"));
+var BLOCK_SIGNATURES = {
+  core: "env.ts",
+  "database-pg": "db/index.ts",
+  "database-mysql": "db/index.ts",
+  validator: "middleware/validate.ts",
+  "error-handler": "lib/errors.ts",
+  logger: "lib/logger.ts",
+  auth: "lib/auth.ts"
+};
+var resolveDependencies = async (moduleDependencies, cwd) => {
+  if (!moduleDependencies || moduleDependencies.length === 0) {
+    return;
+  }
+  const config = await readZuroConfig(cwd);
+  const srcDir = config?.srcDir || "src";
+  for (const dep of moduleDependencies) {
+    if (dep === "database") {
+      const pgExists = import_fs_extra5.default.existsSync(import_path5.default.join(cwd, srcDir, BLOCK_SIGNATURES["database-pg"]));
+      const mysqlExists = import_fs_extra5.default.existsSync(import_path5.default.join(cwd, srcDir, BLOCK_SIGNATURES["database-mysql"]));
+      if (pgExists || mysqlExists) {
+        continue;
+      }
+      console.log(import_chalk3.default.blue(`\u2139 Dependency '${dep}' is missing. Triggering install...`));
+      await add("database");
+      continue;
+    }
+    const signature = BLOCK_SIGNATURES[dep];
+    if (!signature) {
+      continue;
+    }
+    if (import_fs_extra5.default.existsSync(import_path5.default.join(cwd, srcDir, signature))) {
+      continue;
+    }
+    console.log(import_chalk3.default.blue(`\u2139 Installing missing dependency: ${dep}...`));
+    await add(dep);
+  }
+};
+
+// src/commands/add.ts
+var import_chalk4 = __toESM(require("chalk"));
+function resolveSafeTargetPath2(projectRoot, srcDir, file) {
+  const targetPath = import_path6.default.resolve(projectRoot, srcDir, file.target);
+  const normalizedRoot = import_path6.default.resolve(projectRoot);
+  if (targetPath !== normalizedRoot && !targetPath.startsWith(`${normalizedRoot}${import_path6.default.sep}`)) {
+    throw new Error(`Refusing to write outside project directory: ${file.target}`);
+  }
+  return targetPath;
+}
+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) + `
+${errorImport}` + content.slice(lastImportIndex);
+  }
+  const errorSetup = `
+// Error handling (must be last)
+app.use(notFoundHandler);
+app.use(errorHandler);
+`;
+  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);
+  }
+  await import_fs_extra6.default.writeFile(appPath, content);
+  return true;
+}
+async function injectAuthRoutes(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("routes/auth.routes")) {
+    return true;
+  }
+  const authImport = `import authRoutes from "./routes/auth.routes";`;
+  const userImport = `import userRoutes from "./routes/user.routes";`;
+  const routeSetup = `
+// Auth routes
+app.use(authRoutes);
+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);
+  return true;
+}
+var add = async (moduleName) => {
+  const projectRoot = process.cwd();
+  const projectConfig = await readZuroConfig(projectRoot);
+  if (!projectConfig) {
+    showNonZuroProjectMessage();
+    return;
+  }
+  let srcDir = projectConfig.srcDir || "src";
+  let customDbUrl;
+  const DEFAULT_URLS = {
+    "database-pg": "postgresql://root@localhost:5432/mydb",
+    "database-mysql": "mysql://root@localhost:3306/mydb"
+  };
+  if (moduleName === "database") {
+    const variantResponse = await (0, import_prompts2.default)({
+      type: "select",
+      name: "variant",
+      message: "Which database dialect?",
+      choices: [
+        { title: "PostgreSQL", value: "database-pg" },
+        { title: "MySQL", value: "database-mysql" }
+      ]
+    });
+    if (!variantResponse.variant) {
+      process.exit(0);
+    }
+    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;
+  }
+  if ((moduleName === "database-pg" || moduleName === "database-mysql") && customDbUrl === void 0) {
+    const defaultUrl = DEFAULT_URLS[moduleName];
+    console.log(import_chalk4.default.dim(`  Tip: Leave blank to use ${defaultUrl}
+`));
+    const response = await (0, import_prompts2.default)({
+      type: "text",
+      name: "dbUrl",
+      message: "Database URL",
+      initial: ""
+    });
+    customDbUrl = response.dbUrl?.trim() || defaultUrl;
+  }
+  const spinner = (0, import_ora2.default)(`Checking registry for ${moduleName}...`).start();
+  try {
+    const registryContext = await fetchRegistry();
+    const module2 = registryContext.manifest.modules[moduleName];
+    if (!module2) {
+      spinner.fail(`Module '${moduleName}' not found.`);
+      return;
+    }
+    spinner.succeed(`Found module: ${import_chalk4.default.cyan(moduleName)}`);
+    const moduleDeps = module2.moduleDependencies || [];
+    await resolveDependencies(moduleDeps, projectRoot);
+    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");
+    spinner.start("Scaffolding files...");
+    for (const file of module2.files) {
+      const content = await fetchFile(file.path, {
+        baseUrl: registryContext.fileBaseUrl,
+        expectedSha256: file.sha256,
+        expectedSize: file.size
+      });
+      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") {
+      spinner.start("Configuring routes in app.ts...");
+      const injected = await injectAuthRoutes(projectRoot, srcDir);
+      if (injected) {
+        spinner.succeed("Routes configured in app.ts");
+      } else {
+        spinner.warn("Could not find app.ts - routes need manual setup");
+      }
+    }
+    if (moduleName === "error-handler") {
+      spinner.start("Configuring error handler in app.ts...");
+      const injected = await injectErrorHandler(projectRoot, srcDir);
+      if (injected) {
+        spinner.succeed("Error handler configured in app.ts");
+      } else {
+        spinner.warn("Could not find app.ts - error handler needs manual setup");
+      }
+    }
+    const envConfig = ENV_CONFIGS[moduleName];
+    if (envConfig) {
+      spinner.start("Updating environment configuration...");
+      const envVars = { ...envConfig.envVars };
+      if (customDbUrl && (moduleName === "database-pg" || moduleName === "database-mysql")) {
+        envVars.DATABASE_URL = customDbUrl;
+      }
+      await updateEnvFile(projectRoot, envVars);
+      await updateEnvSchema(projectRoot, srcDir, envConfig.schemaFields);
+      spinner.succeed("Environment configured");
+    }
+    console.log(import_chalk4.default.green(`
+\u2714 ${moduleName} 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")
+      );
+      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(`${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"));
+    }
+  } catch (error) {
+    spinner.fail(`Failed to add module: ${error.message}`);
+  }
+};
+
+// src/index.ts
+var program = new import_commander.Command();
+program.name("zuro-cli").description("Zuro CLI tool").version("0.0.1");
+program.command("init").description("Initialize a new Zuro project").action(init);
+program.command("add <module>").description("Add a module to your project").action(add);
+program.parse(process.argv);
+//# sourceMappingURL=index.js.map