@rebasepro/cli 0.0.1-canary.2 → 0.0.1-canary.3263433

package/dist/index.es.js

@@ -8,6 +8,8 @@ import execa from "execa";
 import ncp from "ncp";
 import { fileURLToPath } from "url";
 import crypto from "crypto";
+import { generateSDK } from "@rebasepro/sdk-generator";
+import { execSync, spawn } from "child_process";
 import * as os from "os";
 const access = promisify(fs.access);
 const copy = promisify(ncp);
@@ -35,7 +37,9 @@ async function promptForOptions(rawArgs) {
   const args = arg(
     {
       "--git": Boolean,
-      "-g": "--git"
+      "--install": Boolean,
+      "-g": "--git",
+      "-i": "--install"
     },
     {
       argv: rawArgs.slice(3),
@@ -68,15 +72,39 @@ async function promptForOptions(rawArgs) {
       default: true
     });
   }
+  if (!args["--install"]) {
+    questions.push({
+      type: "confirm",
+      name: "installDeps",
+      message: "Install dependencies with pnpm?",
+      default: true
+    });
+  }
+  questions.push({
+    type: "input",
+    name: "databaseUrl",
+    message: "Enter your PostgreSQL database connection string (leave blank to use a local default):",
+    default: ""
+  });
+  questions.push({
+    type: "confirm",
+    name: "introspect",
+    message: "Would you like to introspect this database to automatically generate collections?",
+    default: true,
+    when: (answers2) => !!answers2.databaseUrl?.trim()
+  });
   const answers = await inquirer.prompt(questions);
-  const projectName = nameArg || answers.projectName;
-  const targetDirectory = path.resolve(process.cwd(), projectName);
+  const targetDirectory = path.resolve(process.cwd(), nameArg || answers.projectName);
+  const projectName = path.basename(targetDirectory);
   const templateDirectory = path.resolve(cliRoot, "templates", "template");
   return {
     projectName,
     git: args["--git"] || answers.git || false,
+    installDeps: args["--install"] || answers.installDeps || false,
     targetDirectory,
-    templateDirectory
+    templateDirectory,
+    databaseUrl: answers.databaseUrl?.trim() || void 0,
+    introspect: answers.introspect || false
   };
 }
 async function createProject(options) {
@@ -95,36 +123,21 @@ async function createProject(options) {
     process.exit(1);
   }
   console.log(chalk.gray("  Copying project files..."));
-  await copy(options.templateDirectory, options.targetDirectory, {
-    clobber: false,
-    dot: true,
-    filter: (source) => {
-      const basename = path.basename(source);
-      return basename !== "node_modules" && basename !== ".DS_Store";
-    }
-  });
-  await replacePlaceholders(options);
-  const envTemplatePath = path.join(options.targetDirectory, ".env.template");
-  const envPath = path.join(options.targetDirectory, ".env");
-  if (fs.existsSync(envTemplatePath) && !fs.existsSync(envPath)) {
-    fs.renameSync(envTemplatePath, envPath);
-    const jwtSecret = crypto.randomBytes(32).toString("hex");
-    const dbPassword = crypto.randomBytes(16).toString("hex");
-    let envContent = fs.readFileSync(envPath, "utf-8");
-    envContent = envContent.replace(
-      "postgresql://rebase:password@localhost:5432/rebase",
-      `postgresql://rebase:${dbPassword}@localhost:5432/rebase`
-    );
-    envContent = envContent.replace(
-      "change-this-to-a-secure-random-string",
-      jwtSecret
-    );
-    envContent += `
-# Docker Compose Database Password
-POSTGRES_PASSWORD=${dbPassword}
-`;
-    fs.writeFileSync(envPath, envContent, "utf-8");
+  try {
+    await copy(options.templateDirectory, options.targetDirectory, {
+      clobber: false,
+      dot: true,
+      filter: (source) => {
+        const basename = path.basename(source);
+        return basename !== "node_modules" && basename !== ".DS_Store";
+      }
+    });
+  } catch (err) {
+    console.error(`${chalk.red.bold("ERROR")} Failed to copy template files: ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(1);
   }
+  await replacePlaceholders(options);
+  configureEnvFile(options.targetDirectory, options.databaseUrl);
   if (options.git) {
     console.log(chalk.gray("  Initializing git repository..."));
     try {
@@ -133,23 +146,65 @@ POSTGRES_PASSWORD=${dbPassword}
       console.warn(chalk.yellow("  Warning: Failed to initialize git repository"));
     }
   }
+  if (options.installDeps) {
+    console.log("");
+    console.log(chalk.gray("  Installing dependencies with pnpm..."));
+    console.log("");
+    try {
+      await execa("pnpm", ["install"], {
+        cwd: options.targetDirectory,
+        stdio: "inherit"
+      });
+    } catch {
+      console.warn(chalk.yellow("  Warning: Failed to install dependencies. You may need to run `pnpm install` manually."));
+    }
+  }
+  if (options.introspect) {
+    console.log("");
+    if (options.installDeps) {
+      console.log(chalk.gray("  Introspecting database and generating collections..."));
+      console.log("");
+      try {
+        await execa("pnpm", ["exec", "rebase", "schema", "introspect", "--force"], {
+          cwd: options.targetDirectory,
+          stdio: "inherit"
+        });
+        console.log(chalk.green("  Database successfully introspected!"));
+      } catch {
+        console.warn(chalk.yellow("  Warning: Failed to introspect database automatically."));
+        console.warn(chalk.yellow("  You can run `pnpm exec rebase schema introspect` manually after setup."));
+      }
+    } else {
+      console.warn(chalk.yellow("  Skipping introspection because dependencies were not installed."));
+      console.warn(chalk.yellow("  Run `pnpm install` then `pnpm exec rebase schema introspect` manually."));
+    }
+  }
   console.log("");
   console.log(`${chalk.green.bold("✓")} Project ${chalk.bold(options.projectName)} created successfully!`);
   console.log("");
   console.log(chalk.bold("Next steps:"));
   console.log("");
   console.log(`  ${chalk.cyan("cd")} ${options.projectName}`);
-  console.log(`  ${chalk.cyan("pnpm install")}`);
+  if (!options.installDeps) {
+    console.log(`  ${chalk.cyan("pnpm install")}`);
+  }
   console.log("");
-  console.log(chalk.gray("  # Set up your database connection in .env"));
-  console.log(chalk.gray("  # Then run:"));
+  if (options.databaseUrl) {
+    console.log(chalk.gray("  # Your database is configured! Start the dev server:"));
+  } else {
+    console.log(chalk.gray("  # A local database configuration has been generated in .env."));
+    console.log(chalk.gray("  # If using the included docker-compose.yml, start it with:"));
+    console.log(`  ${chalk.cyan("docker compose up -d")}`);
+    console.log("");
+    console.log(chalk.gray("  # Then start the dev server:"));
+  }
   console.log("");
   console.log(`  ${chalk.cyan("pnpm dev")}`);
   console.log("");
-  console.log(chalk.gray("This starts both the backend (Express + PostgreSQL)") + chalk.gray(" and the frontend (Vite + React) concurrently."));
+  console.log(chalk.gray("This starts both the backend (Hono + PostgreSQL)") + chalk.gray(" and the frontend (Vite + React) concurrently."));
   console.log("");
   console.log(chalk.gray("Docs: https://rebase.pro/docs"));
-  console.log(chalk.gray("GitHub: https://github.com/rebaseco/rebase"));
+  console.log(chalk.gray("GitHub: https://github.com/rebasepro/rebase"));
   console.log("");
 }
 async function replacePlaceholders(options) {
@@ -157,17 +212,899 @@ async function replacePlaceholders(options) {
     "package.json",
     "frontend/package.json",
     "backend/package.json",
-    "shared/package.json",
+    "config/package.json",
     "frontend/index.html"
   ];
+  const packageJsonPath = path.resolve(cliRoot, "package.json");
+  let cliVersion = "latest";
+  if (fs.existsSync(packageJsonPath)) {
+    const pkg = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+    cliVersion = pkg.version || "latest";
+  }
+  const versionCache = /* @__PURE__ */ new Map();
+  const getPackageVersion = async (pkgName) => {
+    if (versionCache.has(pkgName)) return versionCache.get(pkgName);
+    let versionToUse = cliVersion;
+    try {
+      const { stdout } = await execa("pnpm", ["view", `${pkgName}@${cliVersion}`, "version"]);
+      if (!stdout.trim()) throw new Error("Not found");
+      versionToUse = stdout.trim();
+    } catch {
+      try {
+        const tag = cliVersion.includes("canary") ? "canary" : "latest";
+        const { stdout } = await execa("pnpm", ["view", `${pkgName}@${tag}`, "version"]);
+        if (!stdout.trim()) throw new Error("Not found");
+        versionToUse = stdout.trim();
+      } catch {
+        try {
+          const { stdout } = await execa("pnpm", ["view", pkgName, "version"]);
+          versionToUse = stdout.trim() || "latest";
+        } catch {
+          versionToUse = "latest";
+        }
+      }
+    }
+    versionCache.set(pkgName, versionToUse);
+    return versionToUse;
+  };
+  const allPackages = /* @__PURE__ */ new Set();
+  const fileContents = /* @__PURE__ */ new Map();
   for (const file of filesToProcess) {
     const fullPath = path.resolve(options.targetDirectory, file);
     if (!fs.existsSync(fullPath)) continue;
-    let content = fs.readFileSync(fullPath, "utf-8");
-    content = content.replace(/\{\{PROJECT_NAME\}\}/g, options.projectName);
+    const content = fs.readFileSync(fullPath, "utf-8");
+    fileContents.set(fullPath, content);
+    const matches = [...content.matchAll(/"(@rebasepro\/[^"]+)":\s*"workspace:\*"/g)];
+    for (const match of matches) {
+      allPackages.add(match[1]);
+    }
+  }
+  console.log(chalk.gray("  Resolving package versions..."));
+  await Promise.all(Array.from(allPackages).map(getPackageVersion));
+  for (const [fullPath, originalContent] of fileContents.entries()) {
+    let content = originalContent.replace(/\{\{PROJECT_NAME\}\}/g, options.projectName);
+    const matches = [...content.matchAll(/"(@rebasepro\/[^"]+)":\s*"workspace:\*"/g)];
+    for (const match of matches) {
+      const pkgName = match[1];
+      const resolvedVersion = versionCache.get(pkgName) || "latest";
+      content = content.replace(new RegExp(`"${pkgName}":\\s*"workspace:\\*"`, "g"), `"${pkgName}": "${resolvedVersion}"`);
+    }
     fs.writeFileSync(fullPath, content, "utf-8");
   }
 }
+function configureEnvFile(targetDirectory, databaseUrl) {
+  const envExamplePath = path.join(targetDirectory, ".env.example");
+  const envPath = path.join(targetDirectory, ".env");
+  if (fs.existsSync(envExamplePath) && !fs.existsSync(envPath)) {
+    fs.copyFileSync(envExamplePath, envPath);
+    const jwtSecret = crypto.randomBytes(32).toString("hex");
+    const dbPassword = crypto.randomBytes(16).toString("hex");
+    let envContent = fs.readFileSync(envPath, "utf-8");
+    envContent = envContent.replace(
+      /^JWT_SECRET=.*$/m,
+      `JWT_SECRET=${jwtSecret}`
+    );
+    if (databaseUrl) {
+      envContent = envContent.replace(
+        /^DATABASE_URL=.*$/m,
+        `DATABASE_URL=${databaseUrl}`
+      );
+    } else {
+      envContent = envContent.replace(
+        /^DATABASE_URL=.*$/m,
+        `DATABASE_URL=postgresql://rebase:${dbPassword}@localhost:5432/rebase`
+      );
+    }
+    fs.writeFileSync(envPath, envContent, "utf-8");
+  }
+}
+async function loadCollections(collectionsDir) {
+  const absDir = path.resolve(collectionsDir);
+  if (!fs.existsSync(absDir)) {
+    throw new Error(`Collections directory not found: ${absDir}`);
+  }
+  let jiti;
+  try {
+    const jitiModule = await import("jiti");
+    jiti = jitiModule.default || jitiModule;
+  } catch {
+    throw new Error(
+      "Could not load 'jiti'. Install it with: pnpm add -D jiti\njiti is required to dynamically import TypeScript collection definitions."
+    );
+  }
+  const jitiInstance = jiti(absDir, {
+    interopDefault: true,
+    esmResolve: true
+  });
+  const indexCandidates = ["index.ts", "index.js", "index.mjs"];
+  let indexPath = null;
+  for (const candidate of indexCandidates) {
+    const p = path.join(absDir, candidate);
+    if (fs.existsSync(p)) {
+      indexPath = p;
+      break;
+    }
+  }
+  if (!indexPath) {
+    console.log(chalk.yellow("  No index file found, scanning individual collection files..."));
+    const collections = [];
+    const files = fs.readdirSync(absDir).filter(
+      (f) => (f.endsWith(".ts") || f.endsWith(".js")) && !f.startsWith(".")
+    );
+    for (const file of files) {
+      try {
+        const mod2 = jitiInstance(path.join(absDir, file));
+        const exported2 = mod2.default || mod2;
+        if (exported2 && typeof exported2 === "object" && "slug" in exported2) {
+          collections.push(exported2);
+        } else if (Array.isArray(exported2)) {
+          collections.push(...exported2);
+        }
+      } catch (err) {
+        console.warn(chalk.yellow(`  ⚠ Skipping ${file}: ${err.message}`));
+      }
+    }
+    return collections;
+  }
+  const mod = jitiInstance(indexPath);
+  const exported = mod.default || mod;
+  if (Array.isArray(exported)) {
+    return exported;
+  } else if (typeof exported === "object" && exported !== null) {
+    if ("collections" in exported && Array.isArray(exported.collections)) {
+      return exported.collections;
+    }
+    const collections = [];
+    for (const value of Object.values(exported)) {
+      if (value && typeof value === "object" && "slug" in value) {
+        collections.push(value);
+      }
+    }
+    if (collections.length > 0) return collections;
+  }
+  throw new Error(
+    `Could not extract collections from ${indexPath}.
+Expected a default export of EntityCollection[] or an object with named collection exports.`
+  );
+}
+function writeFiles(outputDir, files) {
+  const absOutput = path.resolve(outputDir);
+  fs.mkdirSync(absOutput, { recursive: true });
+  for (const file of files) {
+    const filePath = path.join(absOutput, file.path);
+    const dir = path.dirname(filePath);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    fs.writeFileSync(filePath, file.content, "utf-8");
+  }
+}
+async function generateSdkCommand(args) {
+  const { collectionsDir, output, cwd } = args;
+  const resolvedCollectionsDir = path.isAbsolute(collectionsDir) ? collectionsDir : path.join(cwd, collectionsDir);
+  const resolvedOutput = path.isAbsolute(output) ? output : path.join(cwd, output);
+  console.log("");
+  console.log(chalk.bold("  🔧 Rebase SDK Generator"));
+  console.log("");
+  console.log(`  ${chalk.gray("Collections:")} ${resolvedCollectionsDir}`);
+  console.log(`  ${chalk.gray("Output:")}      ${resolvedOutput}`);
+  console.log("");
+  console.log(chalk.cyan("  → Loading collection definitions..."));
+  const collections = await loadCollections(resolvedCollectionsDir);
+  if (collections.length === 0) {
+    console.log(chalk.red("  ✗ No collections found. Nothing to generate."));
+    process.exit(1);
+  }
+  console.log(chalk.green(`  ✓ Found ${collections.length} collection(s): ${collections.map((c) => c.slug).join(", ")}`));
+  console.log("");
+  console.log(chalk.cyan("  → Generating SDK files..."));
+  const files = generateSDK(collections);
+  console.log(chalk.green(`  ✓ Generated ${files.length} file(s)`));
+  console.log(chalk.cyan(`  → Writing to ${resolvedOutput}...`));
+  writeFiles(resolvedOutput, files);
+  console.log("");
+  console.log(chalk.green.bold("  ✓ SDK generated successfully!"));
+  console.log("");
+  console.log(chalk.gray("  Usage:"));
+  console.log(chalk.gray("    import { createRebaseClient } from '@rebasepro/client';"));
+  console.log(chalk.gray(`    import type { Database } from './${path.relative(cwd, path.join(resolvedOutput, "database.types"))}';`));
+  console.log("");
+  console.log(chalk.gray("    const rebase = createRebaseClient<Database>({"));
+  console.log(chalk.gray("        baseUrl: 'http://localhost:3001',"));
+  console.log(chalk.gray("        // token: 'your-jwt-token',"));
+  console.log(chalk.gray("    });"));
+  console.log("");
+  console.log(chalk.gray(`    const { data } = await rebase.collection('${collections[0]?.slug || "my_collection"}').find();`));
+  console.log("");
+}
+function findProjectRoot(startDir = process.cwd()) {
+  let dir = path.resolve(startDir);
+  const root = path.parse(dir).root;
+  while (dir !== root) {
+    const pkgPath = path.join(dir, "package.json");
+    if (fs.existsSync(pkgPath)) {
+      try {
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+        if (pkg.workspaces && Array.isArray(pkg.workspaces)) {
+          const hasBackend = pkg.workspaces.some(
+            (w) => w === "backend" || w.includes("backend")
+          );
+          if (hasBackend) return dir;
+        }
+      } catch {
+      }
+      if (fs.existsSync(path.join(dir, "backend")) && fs.existsSync(path.join(dir, "config"))) {
+        return dir;
+      }
+    }
+    dir = path.dirname(dir);
+  }
+  return null;
+}
+function findBackendDir(projectRoot) {
+  const backendDir = path.join(projectRoot, "backend");
+  return fs.existsSync(backendDir) ? backendDir : null;
+}
+function getActiveBackendPlugin(backendDir) {
+  const pkgPath = path.join(backendDir, "package.json");
+  if (!fs.existsSync(pkgPath)) return null;
+  try {
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+    const deps = {
+      ...pkg.dependencies,
+      ...pkg.devDependencies
+    };
+    for (const dep of Object.keys(deps)) {
+      if (dep.startsWith("@rebasepro/server-") && dep !== "@rebasepro/server-core") {
+        return dep;
+      }
+    }
+  } catch {
+  }
+  return null;
+}
+function resolvePluginCliScript(backendDir, pluginName) {
+  const candidates = [
+    path.join(backendDir, "node_modules", pluginName, "src", "cli.ts"),
+    path.join(backendDir, "node_modules", pluginName, "dist", "cli.js"),
+    // For monorepo dev mode:
+    path.resolve(backendDir, "..", "..", "..", "packages", pluginName.replace("@rebasepro/", ""), "src", "cli.ts"),
+    path.resolve(backendDir, "..", "..", "packages", pluginName.replace("@rebasepro/", ""), "src", "cli.ts"),
+    path.resolve(backendDir, "..", "packages", pluginName.replace("@rebasepro/", ""), "src", "cli.ts")
+  ];
+  for (const candidate of candidates) {
+    if (fs.existsSync(candidate)) return candidate;
+  }
+  return null;
+}
+function findFrontendDir(projectRoot) {
+  const frontendDir = path.join(projectRoot, "frontend");
+  return fs.existsSync(frontendDir) ? frontendDir : null;
+}
+function findEnvFile(projectRoot) {
+  const candidates = [
+    path.join(projectRoot, ".env"),
+    path.join(projectRoot, "backend", ".env")
+  ];
+  for (const candidate of candidates) {
+    if (fs.existsSync(candidate)) return candidate;
+  }
+  return null;
+}
+function resolveLocalBin(projectRoot, binName) {
+  const candidates = [
+    path.join(projectRoot, "backend", "node_modules", ".bin", binName),
+    path.join(projectRoot, "node_modules", ".bin", binName)
+  ];
+  let parent = path.dirname(projectRoot);
+  const rootDir = path.parse(parent).root;
+  while (parent !== rootDir) {
+    candidates.push(path.join(parent, "node_modules", ".bin", binName));
+    parent = path.dirname(parent);
+  }
+  for (const candidate of candidates) {
+    if (fs.existsSync(candidate)) return candidate;
+  }
+  try {
+    const globalPath = execSync(`which ${binName}`, { encoding: "utf-8" }).trim();
+    if (globalPath && fs.existsSync(globalPath)) return globalPath;
+  } catch {
+  }
+  return null;
+}
+function resolveTsx(projectRoot) {
+  return resolveLocalBin(projectRoot, "tsx");
+}
+function requireProjectRoot() {
+  const root = findProjectRoot();
+  if (!root) {
+    console.error(chalk.red("✗ Could not find a Rebase project root."));
+    console.error(chalk.gray("  Make sure you are inside a Rebase project directory"));
+    console.error(chalk.gray("  (one with backend/, frontend/, and shared/ directories)."));
+    process.exit(1);
+  }
+  return root;
+}
+function requireBackendDir(projectRoot) {
+  const backendDir = findBackendDir(projectRoot);
+  if (!backendDir) {
+    console.error(chalk.red("✗ Could not find a backend/ directory."));
+    console.error(chalk.gray(`  Expected at: ${path.join(projectRoot, "backend")}`));
+    process.exit(1);
+  }
+  return backendDir;
+}
+async function schemaCommand(subcommand, rawArgs) {
+  if (!subcommand || subcommand === "--help") {
+    printSchemaHelp();
+    return;
+  }
+  const projectRoot = requireProjectRoot();
+  const backendDir = requireBackendDir(projectRoot);
+  const activePlugin = getActiveBackendPlugin(backendDir);
+  if (!activePlugin) {
+    console.error(chalk.red("✗ Could not detect an active database plugin."));
+    console.error(chalk.gray("  Make sure a package like @rebasepro/server-postgresql is installed in backend/package.json."));
+    process.exit(1);
+  }
+  const pluginCli = resolvePluginCliScript(backendDir, activePlugin);
+  if (!pluginCli) {
+    console.error(chalk.red(`✗ Could not find CLI entry point for ${activePlugin}.`));
+    process.exit(1);
+  }
+  const envFile = findEnvFile(projectRoot);
+  const env = { ...process.env };
+  if (envFile) {
+    env.DOTENV_CONFIG_PATH = envFile;
+  }
+  try {
+    const isTs = pluginCli.endsWith(".ts");
+    if (isTs) {
+      const tsxBin = resolveTsx(projectRoot);
+      if (!tsxBin) {
+        console.error(chalk.red("✗ Could not find tsx binary."));
+        process.exit(1);
+      }
+      await execa(tsxBin, [pluginCli, ...rawArgs.slice(2)], {
+        cwd: backendDir,
+        stdio: "inherit",
+        env
+      });
+    } else {
+      await execa("node", [pluginCli, ...rawArgs.slice(2)], {
+        cwd: backendDir,
+        stdio: "inherit",
+        env
+      });
+    }
+  } catch (err) {
+    process.exit(1);
+  }
+}
+function printSchemaHelp() {
+  console.log(`
+${chalk.bold("rebase schema")} — Schema management commands
+
+${chalk.green.bold("Usage")}
+  rebase schema ${chalk.blue("<command>")} [options]
+
+${chalk.green.bold("Commands")}
+  ${chalk.gray("(Commands are provided by your active database driver plugin)")}
+  ${chalk.blue.bold("generate")}    Generate Schema from collection definitions
+  ${chalk.blue.bold("introspect")}  Introspect an existing database to generate collection definitions
+
+${chalk.green.bold("generate Options")}
+  ${chalk.blue("--collections, -c")}  Path to collections directory
+  ${chalk.blue("--output, -o")}       Output path for generated schema
+  ${chalk.blue("--watch, -w")}        Watch for changes and regenerate automatically
+
+${chalk.green.bold("introspect Options")}
+  ${chalk.blue("--output, -o")}       Output directory for generated collection files
+`);
+}
+async function dbCommand(subcommand, rawArgs) {
+  if (!subcommand || subcommand === "--help") {
+    printDbHelp();
+    return;
+  }
+  const projectRoot = requireProjectRoot();
+  const backendDir = requireBackendDir(projectRoot);
+  const activePlugin = getActiveBackendPlugin(backendDir);
+  if (!activePlugin) {
+    console.error(chalk.red("✗ Could not detect an active database plugin."));
+    console.error(chalk.gray("  Make sure a package like @rebasepro/server-postgresql is installed in backend/package.json."));
+    process.exit(1);
+  }
+  const pluginCli = resolvePluginCliScript(backendDir, activePlugin);
+  if (!pluginCli) {
+    console.error(chalk.red(`✗ Could not find CLI entry point for ${activePlugin}.`));
+    process.exit(1);
+  }
+  const envFile = findEnvFile(projectRoot);
+  const env = { ...process.env };
+  if (envFile) {
+    env.DOTENV_CONFIG_PATH = envFile;
+  }
+  try {
+    const isTs = pluginCli.endsWith(".ts");
+    if (isTs) {
+      const tsxBin = resolveTsx(projectRoot);
+      if (!tsxBin) {
+        console.error(chalk.red("✗ Could not find tsx binary."));
+        process.exit(1);
+      }
+      await execa(tsxBin, [pluginCli, ...rawArgs.slice(2)], {
+        cwd: backendDir,
+        stdio: "inherit",
+        env
+      });
+    } else {
+      await execa("node", [pluginCli, ...rawArgs.slice(2)], {
+        cwd: backendDir,
+        stdio: "inherit",
+        env
+      });
+    }
+  } catch (err) {
+    process.exit(1);
+  }
+}
+function printDbHelp() {
+  console.log(`
+${chalk.bold("rebase db")} — Database management commands
+
+${chalk.green.bold("Usage")}
+  rebase db ${chalk.blue("<command>")} [options]
+
+${chalk.green.bold("Commands")}
+  ${chalk.gray("(Commands are provided by your active database driver plugin)")}
+  ${chalk.blue.bold("push")}       Apply schema directly to database (development)
+  ${chalk.blue.bold("pull")}       Introspect database → Schema
+  ${chalk.blue.bold("generate")}   Generate migration files
+  ${chalk.blue.bold("migrate")}    Run pending migrations
+  ${chalk.blue.bold("studio")}     Open Studio viewer
+  ${chalk.blue.bold("branch")}     Database branching (create, list, delete, info)
+
+${chalk.green.bold("Examples")}
+  ${chalk.gray("# Quick development workflow")}
+  rebase schema generate && rebase db push
+
+  ${chalk.gray("# Production migration workflow")}
+  rebase db generate
+  rebase db migrate
+
+  ${chalk.gray("# Create a database branch")}
+  rebase db branch create feature_auth
+`);
+}
+const DEV_PORT_FILENAME = ".rebase-dev-port";
+function getProjectPort(projectRoot) {
+  let hash = 0;
+  for (let i = 0; i < projectRoot.length; i++) {
+    hash = (hash << 5) - hash + projectRoot.charCodeAt(i) | 0;
+  }
+  return 3001 + Math.abs(hash) % 999;
+}
+function resolveStartPort(projectRoot, explicitPort) {
+  if (explicitPort) return explicitPort;
+  if (process.env.PORT) return parseInt(process.env.PORT, 10);
+  try {
+    const portFile = path.join(projectRoot, DEV_PORT_FILENAME);
+    if (fs.existsSync(portFile)) {
+      const saved = parseInt(fs.readFileSync(portFile, "utf-8").trim(), 10);
+      if (saved > 0 && saved < 65536) return saved;
+    }
+  } catch {
+  }
+  return getProjectPort(projectRoot);
+}
+async function devCommand(rawArgs) {
+  const args = arg(
+    {
+      "--backend-only": Boolean,
+      "--frontend-only": Boolean,
+      "--port": Number,
+      "--help": Boolean,
+      "-b": "--backend-only",
+      "-f": "--frontend-only",
+      "-p": "--port",
+      "-h": "--help"
+    },
+    {
+      argv: rawArgs.slice(3),
+      // skip "node rebase dev"
+      permissive: true
+    }
+  );
+  if (args["--help"]) {
+    printDevHelp();
+    return;
+  }
+  const projectRoot = requireProjectRoot();
+  const backendDir = findBackendDir(projectRoot);
+  const frontendDir = findFrontendDir(projectRoot);
+  const backendOnly = args["--backend-only"] || false;
+  const frontendOnly = args["--frontend-only"] || false;
+  const startPort = resolveStartPort(projectRoot, args["--port"]);
+  console.log("");
+  console.log(chalk.bold("  🚀 Rebase Dev Server"));
+  console.log("");
+  const children = [];
+  let frontendUrl = "";
+  let backendUrl = "";
+  let debounceSummary = null;
+  let bannerPrinted = false;
+  let resolvedBackendPort = null;
+  const stripAnsi = (str) => str.replace(/[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g, "");
+  function printSummary() {
+    if (!frontendUrl || !backendUrl) return;
+    if (debounceSummary) clearTimeout(debounceSummary);
+    debounceSummary = setTimeout(() => {
+      if (bannerPrinted) return;
+      console.log("");
+      console.log(chalk.cyan("┌────────────────────────────────────────────────────────────┐"));
+      console.log(chalk.cyan("│                                                            │"));
+      console.log(chalk.cyan("│   ✨ Rebase Admin App is ready!                            │"));
+      const cleanUrl = stripAnsi(frontendUrl);
+      const paddedUrl = cleanUrl.padEnd(40);
+      console.log(chalk.cyan("│   👉 Frontend URL: ") + chalk.white(paddedUrl) + chalk.cyan("│"));
+      console.log(chalk.cyan("│                                                            │"));
+      console.log(chalk.cyan("└────────────────────────────────────────────────────────────┘"));
+      console.log("");
+      bannerPrinted = true;
+    }, 500);
+  }
+  const cleanup = () => {
+    try {
+      const portFile = path.join(projectRoot, DEV_PORT_FILENAME);
+      if (fs.existsSync(portFile)) fs.unlinkSync(portFile);
+      const urlFile = path.join(projectRoot, ".rebase-dev-url");
+      if (fs.existsSync(urlFile)) fs.unlinkSync(urlFile);
+    } catch {
+    }
+    children.forEach((child) => {
+      if (child.pid && !child.killed) {
+        try {
+          if (process.platform === "win32") {
+            execa.commandSync(`taskkill /pid ${child.pid} /T /F`);
+          } else {
+            process.kill(-child.pid, "SIGKILL");
+          }
+        } catch (e) {
+          try {
+            child.kill("SIGKILL");
+          } catch (err) {
+          }
+        }
+      }
+    });
+    process.exit(0);
+  };
+  process.on("SIGINT", cleanup);
+  process.on("SIGTERM", cleanup);
+  function startFrontend(backendPort) {
+    if (!frontendDir) return;
+    console.log(`  ${chalk.magenta("▶")} Frontend: ${chalk.gray(frontendDir)}`);
+    const frontendEnv = { ...process.env };
+    if (backendPort) {
+      frontendEnv.VITE_API_URL = `http://localhost:${backendPort}`;
+      console.log(`  ${chalk.gray("↳ VITE_API_URL")} = ${chalk.white(`http://localhost:${backendPort}`)}`);
+    }
+    const frontendChild = execa(
+      "pnpm",
+      ["run", "dev"],
+      {
+        cwd: frontendDir,
+        stdio: ["inherit", "pipe", "pipe"],
+        env: frontendEnv,
+        shell: true,
+        detached: process.platform !== "win32"
+      }
+    );
+    frontendChild.catch(() => {
+    });
+    frontendChild.stdout?.on("data", (data) => {
+      const lines = data.toString().split("\n").filter(Boolean);
+      lines.forEach((line) => {
+        console.log(`${chalk.magenta.bold("[admin]")} ${line}`);
+        const cleanLine = stripAnsi(line);
+        const urlMatch = cleanLine.match(/(http:\/\/(?:localhost|127\.0\.0\.1):\d+)/);
+        if (cleanLine.includes("Local:") && urlMatch) {
+          frontendUrl = urlMatch[1];
+          printSummary();
+        }
+      });
+    });
+    frontendChild.stderr?.on("data", (data) => {
+      const lines = data.toString().split("\n").filter(Boolean);
+      lines.forEach((line) => {
+        console.log(`${chalk.magenta.bold("[admin]")} ${line}`);
+      });
+    });
+    children.push(frontendChild);
+  }
+  if (!frontendOnly && backendDir) {
+    const tsxBin = resolveTsx(projectRoot);
+    if (!tsxBin) {
+      console.error(chalk.red("  ✗ Could not find tsx binary for backend."));
+      console.error(chalk.gray("    Install it with: pnpm add -D tsx"));
+      process.exit(1);
+    }
+    const envFile = findEnvFile(projectRoot);
+    const env = { ...process.env };
+    if (envFile) {
+      env.DOTENV_CONFIG_PATH = envFile;
+    }
+    env.PORT = String(startPort);
+    console.log(`  ${chalk.cyan("▶")} Backend:  ${chalk.gray(backendDir)}`);
+    console.log(`  ${chalk.gray("↳ PORT")} = ${chalk.white(String(startPort))}`);
+    let frontendLaunched = false;
+    const backendChild = execa(
+      tsxBin,
+      ["watch", `--watch="${path.join("..", "config", "**", "*")}"`, "--conditions", "development", "src/index.ts"],
+      {
+        cwd: backendDir,
+        stdio: ["inherit", "pipe", "pipe"],
+        env,
+        shell: true,
+        detached: process.platform !== "win32"
+      }
+    );
+    backendChild.catch(() => {
+    });
+    backendChild.stdout?.on("data", (data) => {
+      const lines = data.toString().split("\n").filter(Boolean);
+      lines.forEach((line) => {
+        console.log(`${chalk.cyan.bold("[backend]")}  ${line}`);
+        const cleanLine = stripAnsi(line);
+        const serverMatch = cleanLine.match(/Server running at http:\/\/(?:localhost|127\.0\.0\.1):(\d+)/);
+        if (serverMatch) {
+          resolvedBackendPort = parseInt(serverMatch[1], 10);
+          backendUrl = "started";
+          printSummary();
+          const urlFile = path.join(projectRoot, ".rebase-dev-url");
+          fs.writeFileSync(urlFile, `http://localhost:${resolvedBackendPort}`, "utf-8");
+          const portFile = path.join(projectRoot, DEV_PORT_FILENAME);
+          fs.writeFileSync(portFile, String(resolvedBackendPort), "utf-8");
+          if (!backendOnly && frontendDir && !frontendLaunched) {
+            frontendLaunched = true;
+            startFrontend(resolvedBackendPort);
+          }
+        }
+      });
+    });
+    backendChild.stderr?.on("data", (data) => {
+      const lines = data.toString().split("\n").filter(Boolean);
+      lines.forEach((line) => {
+        console.log(`${chalk.cyan.bold("[backend]")}  ${line}`);
+      });
+    });
+    children.push(backendChild);
+  } else if (!frontendOnly && !backendDir) {
+    console.warn(chalk.yellow("  ⚠ No backend/ directory found, skipping backend."));
+  }
+  if (!backendOnly && frontendDir && (frontendOnly || !backendDir)) {
+    startFrontend(null);
+  } else if (!backendOnly && !frontendDir) {
+    console.warn(chalk.yellow("  ⚠ No frontend/ directory found, skipping frontend."));
+  }
+  if (children.length === 0) {
+    console.error(chalk.red("  ✗ Nothing to start. Check your project structure."));
+    process.exit(1);
+  }
+  console.log("");
+  console.log(chalk.gray("  Press Ctrl+C to stop all servers."));
+  console.log("");
+  await Promise.all(
+    children.map(
+      (child) => new Promise((resolve) => {
+        child.finally(() => resolve());
+      })
+    )
+  );
+}
+function printDevHelp() {
+  console.log(`
+${chalk.bold("rebase dev")} — Start the development server
+
+${chalk.green.bold("Usage")}
+  rebase dev [options]
+
+${chalk.green.bold("Options")}
+  ${chalk.blue("--backend-only, -b")}   Only start the backend server
+  ${chalk.blue("--frontend-only, -f")}  Only start the frontend server
+  ${chalk.blue("--port, -p")}           Backend port (default: auto-detected per project)
+
+${chalk.green.bold("Description")}
+  Starts both the backend (tsx watch + Hono) and frontend (Vite)
+  dev servers concurrently with color-coded output prefixes.
+
+  Each project automatically receives a unique default port derived
+  from its directory path, preventing collisions when running multiple
+  Rebase instances simultaneously.
+
+  If the assigned port is already in use, the server will automatically
+  try the next available port. The frontend is started only after the
+  backend is ready, and VITE_API_URL is injected automatically.
+`);
+}
+async function authCommand(subcommand, rawArgs) {
+  if (!subcommand || subcommand === "--help") {
+    printAuthHelp();
+    return;
+  }
+  switch (subcommand) {
+    case "reset-password":
+      await resetPassword(rawArgs);
+      break;
+    default:
+      console.error(chalk.red(`Unknown auth command: ${subcommand}`));
+      console.log("");
+      printAuthHelp();
+      process.exit(1);
+  }
+}
+async function resetPassword(rawArgs) {
+  const args = arg(
+    {
+      "--email": String,
+      "--password": String,
+      "-e": "--email",
+      "-p": "--password"
+    },
+    {
+      argv: rawArgs.slice(4),
+      // skip "node rebase auth reset-password"
+      permissive: true
+    }
+  );
+  const email = args["--email"] || args._[0];
+  const newPassword = args["--password"] || args._[1];
+  if (!email) {
+    console.error(chalk.red("✗ Email is required."));
+    console.log("");
+    console.log(chalk.gray("  Usage: rebase auth reset-password <email> [new-password]"));
+    console.log(chalk.gray("         rebase auth reset-password --email user@example.com --password NewPass123!"));
+    process.exit(1);
+  }
+  const projectRoot = requireProjectRoot();
+  const backendDir = requireBackendDir(projectRoot);
+  const tsxBin = resolveTsx(projectRoot);
+  if (!tsxBin) {
+    console.error(chalk.red("✗ Could not find tsx binary."));
+    process.exit(1);
+  }
+  const envFile = findEnvFile(projectRoot);
+  const env = { ...process.env };
+  if (envFile) {
+    env.DOTENV_CONFIG_PATH = envFile;
+  }
+  const scriptContent = `
+import { createPostgresDatabaseConnection } from "@rebasepro/server-core";
+import { hashPassword } from "@rebasepro/server-core/src/auth/password";
+import { eq } from "drizzle-orm";
+import { users } from "@rebasepro/server-core/src/db/auth-schema";
+import * as dotenv from "dotenv";
+import path from "path";
+
+dotenv.config({ path: "${envFile || path.join(projectRoot, ".env")}" });
+
+const email = "${email}";
+const newPassword = "${newPassword || "NewPassword123!"}";
+
+async function resetPassword() {
+    const { db } = createPostgresDatabaseConnection(process.env.DATABASE_URL!);
+    const hash = await hashPassword(newPassword);
+
+    const result = await db.update(users)
+        .set({ passwordHash: hash })
+        .where(eq(users.email, email))
+        .returning({
+            id: users.id,
+            email: users.email
+        });
+
+    if (result.length > 0) {
+        console.log("✅ Password reset for: " + result[0].email);
+        ${!newPassword ? 'console.log("   New password: " + newPassword);' : ""}
+    } else {
+        console.log("✗ User not found: " + email);
+    }
+    process.exit(0);
+}
+
+resetPassword().catch(console.error);
+`;
+  const tmpScriptPath = path.join(backendDir, ".tmp-reset-password.ts");
+  fs.writeFileSync(tmpScriptPath, scriptContent, "utf-8");
+  console.log("");
+  console.log(chalk.bold("  🔑 Rebase Auth — Reset Password"));
+  console.log("");
+  console.log(`  ${chalk.gray("Email:")} ${email}`);
+  if (newPassword) {
+    console.log(`  ${chalk.gray("Password:")} ${"*".repeat(newPassword.length)}`);
+  }
+  console.log("");
+  const child = spawn(tsxBin, [tmpScriptPath], {
+    cwd: backendDir,
+    stdio: "inherit",
+    env
+  });
+  return new Promise((resolve) => {
+    child.on("close", (code) => {
+      try {
+        fs.unlinkSync(tmpScriptPath);
+      } catch {
+      }
+      if (code !== 0) {
+        process.exit(code ?? 1);
+      }
+      resolve();
+    });
+  });
+}
+function printAuthHelp() {
+  console.log(`
+${chalk.bold("rebase auth")} — Authentication management commands
+
+${chalk.green.bold("Usage")}
+  rebase auth ${chalk.blue("<command>")} [options]
+
+${chalk.green.bold("Commands")}
+  ${chalk.blue.bold("reset-password")}    Reset a user's password
+
+${chalk.green.bold("reset-password Options")}
+  ${chalk.blue("--email, -e")}        User's email address
+  ${chalk.blue("--password, -p")}     New password (default: NewPassword123!)
+
+${chalk.green.bold("Examples")}
+  rebase auth reset-password user@example.com
+  rebase auth reset-password --email user@example.com --password MyNewPass!
+`);
+}
+async function doctorCommand(rawArgs) {
+  const projectRoot = requireProjectRoot();
+  const backendDir = requireBackendDir(projectRoot);
+  const activePlugin = getActiveBackendPlugin(backendDir);
+  if (!activePlugin) {
+    console.error(chalk.red("✗ Could not detect an active database plugin."));
+    console.error(chalk.gray("  Make sure a package like @rebasepro/server-postgresql is installed in backend/package.json."));
+    process.exit(1);
+  }
+  const pluginCli = resolvePluginCliScript(backendDir, activePlugin);
+  if (!pluginCli) {
+    console.error(chalk.red(`✗ Could not find CLI entry point for ${activePlugin}.`));
+    process.exit(1);
+  }
+  const envFile = findEnvFile(projectRoot);
+  const env = { ...process.env };
+  if (envFile) {
+    env.DOTENV_CONFIG_PATH = envFile;
+  }
+  try {
+    const isTs = pluginCli.endsWith(".ts");
+    if (isTs) {
+      const tsxBin = resolveTsx(projectRoot);
+      if (!tsxBin) {
+        console.error(chalk.red("✗ Could not find tsx binary."));
+        process.exit(1);
+      }
+      await execa(tsxBin, [pluginCli, ...rawArgs.slice(2)], {
+        cwd: backendDir,
+        stdio: "inherit",
+        env
+      });
+    } else {
+      await execa("node", [pluginCli, ...rawArgs.slice(2)], {
+        cwd: backendDir,
+        stdio: "inherit",
+        env
+      });
+    }
+  } catch {
+    process.exit(1);
+  }
+}
 const __filename$1 = fileURLToPath(import.meta.url);
 const __dirname$1 = path.dirname(__filename$1);
 function getVersion() {
@@ -198,16 +1135,56 @@ async function entry(args) {
     return;
   }
   const command = parsedArgs._[0];
-  if (!command || parsedArgs["--help"]) {
+  const subcommand = parsedArgs._[1];
+  const namespacedCommands = ["schema", "db", "dev", "auth", "doctor"];
+  if (!command || parsedArgs["--help"] && !namespacedCommands.includes(command)) {
     printHelp();
     return;
   }
-  if (command === "init") {
-    await createRebaseApp(args);
-  } else {
-    console.log(chalk.red(`Unknown command: ${command}`));
-    console.log("");
-    printHelp();
+  const effectiveSubcommand = parsedArgs["--help"] ? "--help" : subcommand;
+  switch (command) {
+    case "init":
+      await createRebaseApp(args);
+      break;
+    case "generate-sdk": {
+      const sdkArgs = arg(
+        {
+          "--collections-dir": String,
+          "--output": String,
+          "-c": "--collections-dir",
+          "-o": "--output"
+        },
+        {
+          argv: args.slice(3),
+          permissive: true
+        }
+      );
+      await generateSdkCommand({
+        collectionsDir: sdkArgs["--collections-dir"] || "./config/collections",
+        output: sdkArgs["--output"] || "./generated/sdk",
+        cwd: process.cwd()
+      });
+      break;
+    }
+    case "schema":
+      await schemaCommand(effectiveSubcommand, args);
+      break;
+    case "db":
+      await dbCommand(effectiveSubcommand, args);
+      break;
+    case "dev":
+      await devCommand(args);
+      break;
+    case "auth":
+      await authCommand(effectiveSubcommand, args);
+      break;
+    case "doctor":
+      await doctorCommand(args);
+      break;
+    default:
+      console.log(chalk.red(`Unknown command: ${command}`));
+      console.log("");
+      printHelp();
   }
 }
 function printHelp() {
@@ -218,7 +1195,30 @@ ${chalk.green.bold("Usage")}
   rebase ${chalk.blue("<command>")} [options]
 
 ${chalk.green.bold("Commands")}
-  ${chalk.blue.bold("init")}      Create a new Rebase project
+  ${chalk.blue.bold("init")}                    Create a new Rebase project
+  ${chalk.blue.bold("dev")}                     Start the development server
+
+${chalk.green.bold("Schema")}
+  ${chalk.blue.bold("schema generate")}         Generate Drizzle schema from collections
+  ${chalk.blue.bold("schema")} ${chalk.gray("--help")}           Show schema command help
+
+${chalk.green.bold("Database")}
+  ${chalk.blue.bold("db push")}                 Apply schema directly to database ${chalk.gray("(dev)")}
+  ${chalk.blue.bold("db pull")}                 Introspect database → Drizzle schema
+  ${chalk.blue.bold("db generate")}             Generate SQL migration files
+  ${chalk.blue.bold("db migrate")}              Run pending migrations
+  ${chalk.blue.bold("db studio")}               Open Drizzle Studio
+  ${chalk.blue.bold("db")} ${chalk.gray("--help")}               Show database command help
+
+${chalk.green.bold("SDK")}
+  ${chalk.blue.bold("generate-sdk")}            Generate a typed JS SDK from collections
+
+${chalk.green.bold("Auth")}
+  ${chalk.blue.bold("auth reset-password")}     Reset a user's password
+  ${chalk.blue.bold("auth")} ${chalk.gray("--help")}              Show auth command help
+
+${chalk.green.bold("Diagnostics")}
+  ${chalk.blue.bold("doctor")}                  Detect schema drift between collections, schema, and DB
 
 ${chalk.green.bold("Options")}
   ${chalk.blue("--version, -v")}   Show version number
@@ -271,12 +1271,27 @@ async function logout(env, _debug) {
   }
 }
 export {
+  authCommand,
+  configureEnvFile,
   createRebaseApp,
+  dbCommand,
+  devCommand,
   entry,
+  findBackendDir,
+  findEnvFile,
+  findFrontendDir,
+  findProjectRoot,
+  getActiveBackendPlugin,
   getTokens,
   login,
   logout,
   parseJwt,
-  refreshCredentials
+  refreshCredentials,
+  requireBackendDir,
+  requireProjectRoot,
+  resolveLocalBin,
+  resolvePluginCliScript,
+  resolveTsx,
+  schemaCommand
 };
 //# sourceMappingURL=index.es.js.map