@rebasepro/cli 0.0.1-canary.4d4fb3e → 0.0.1-canary.5584634

package/dist/index.es.js

@@ -80,16 +80,31 @@ async function promptForOptions(rawArgs) {
       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) {
@@ -127,20 +142,27 @@ async function createProject(options) {
   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 += `
+    if (options.databaseUrl) {
+      envContent = envContent.replace(
+        "postgresql://rebase:password@localhost:5432/rebase",
+        options.databaseUrl
+      );
+    } else {
+      const dbPassword = crypto.randomBytes(16).toString("hex");
+      envContent = envContent.replace(
+        "postgresql://rebase:password@localhost:5432/rebase",
+        `postgresql://rebase:${dbPassword}@localhost:5432/rebase`
+      );
+      envContent += `
 # Docker Compose Database Password
 POSTGRES_PASSWORD=${dbPassword}
 `;
+    }
     fs.writeFileSync(envPath, envContent, "utf-8");
   }
   if (options.git) {
@@ -164,6 +186,26 @@ POSTGRES_PASSWORD=${dbPassword}
       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"], {
+          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("");
@@ -174,12 +216,19 @@ POSTGRES_PASSWORD=${dbPassword}
     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/rebasepro/rebase"));
@@ -190,14 +239,63 @@ 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("npm", ["--loglevel", "error", "info", `${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("npm", ["--loglevel", "error", "info", `${pkgName}@${tag}`, "version"]);
+        if (!stdout.trim()) throw new Error("Not found");
+        versionToUse = stdout.trim();
+      } catch {
+        try {
+          const { stdout } = await execa("npm", ["--loglevel", "error", "info", 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");
   }
 }
@@ -309,7 +407,7 @@ async function generateSdkCommand(args) {
   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 { 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>({"));
@@ -336,7 +434,7 @@ function findProjectRoot(startDir = process.cwd()) {
         }
       } catch {
       }
-      if (fs.existsSync(path.join(dir, "backend")) && fs.existsSync(path.join(dir, "shared"))) {
+      if (fs.existsSync(path.join(dir, "backend")) && fs.existsSync(path.join(dir, "config"))) {
         return dir;
       }
     }
@@ -353,7 +451,10 @@ function getActiveBackendPlugin(backendDir) {
   if (!fs.existsSync(pkgPath)) return null;
   try {
     const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
-    const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+    const deps = {
+      ...pkg.dependencies,
+      ...pkg.devDependencies
+    };
     for (const dep of Object.keys(deps)) {
       if (dep.startsWith("@rebasepro/server-") && dep !== "@rebasepro/server-core") {
         return dep;
@@ -368,6 +469,7 @@ function resolvePluginCliScript(backendDir, pluginName) {
     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")
   ];
@@ -464,13 +566,13 @@ async function schemaCommand(subcommand, rawArgs) {
         console.error(chalk.red("✗ Could not find tsx binary."));
         process.exit(1);
       }
-      await execa(tsxBin, [pluginCli, "schema", subcommand, ...rawArgs.slice(2)], {
+      await execa(tsxBin, [pluginCli, ...rawArgs.slice(2)], {
         cwd: backendDir,
         stdio: "inherit",
         env
       });
     } else {
-      await execa("node", [pluginCli, "schema", subcommand, ...rawArgs.slice(2)], {
+      await execa("node", [pluginCli, ...rawArgs.slice(2)], {
         cwd: backendDir,
         stdio: "inherit",
         env
@@ -490,11 +592,15 @@ ${chalk.green.bold("Usage")}
 ${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) {
@@ -528,13 +634,13 @@ async function dbCommand(subcommand, rawArgs) {
         console.error(chalk.red("✗ Could not find tsx binary."));
         process.exit(1);
       }
-      await execa(tsxBin, [pluginCli, "db", subcommand, ...rawArgs.slice(2)], {
+      await execa(tsxBin, [pluginCli, ...rawArgs.slice(2)], {
         cwd: backendDir,
         stdio: "inherit",
         env
       });
     } else {
-      await execa("node", [pluginCli, "db", subcommand, ...rawArgs.slice(2)], {
+      await execa("node", [pluginCli, ...rawArgs.slice(2)], {
         cwd: backendDir,
         stdio: "inherit",
         env
@@ -572,6 +678,27 @@ ${chalk.green.bold("Examples")}
   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(
     {
@@ -599,6 +726,7 @@ async function devCommand(rawArgs) {
   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("");
@@ -607,6 +735,7 @@ async function devCommand(rawArgs) {
   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;
@@ -619,7 +748,7 @@ async function devCommand(rawArgs) {
       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("│   👉 Frontend URL: ") + chalk.white(paddedUrl) + chalk.cyan("│"));
       console.log(chalk.cyan("│                                                            │"));
       console.log(chalk.cyan("└────────────────────────────────────────────────────────────┘"));
       console.log("");
@@ -627,15 +756,74 @@ async function devCommand(rawArgs) {
     }, 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.killed) {
-        child.kill("SIGTERM");
+      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) {
@@ -648,22 +836,19 @@ async function devCommand(rawArgs) {
     if (envFile) {
       env.DOTENV_CONFIG_PATH = envFile;
     }
-    if (args["--port"]) {
-      env.PORT = String(args["--port"]);
-    }
-    path.join(backendDir, "src", "index.ts");
-    const watchDirs = [
-      `--watch="${path.join("..", "shared", "**", "*")}"`
-    ];
+    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", ...watchDirs, "--conditions", "development", "src/index.ts"],
+      ["watch", `--watch="${path.join("..", "config", "**", "*")}"`, "--conditions", "development", "src/index.ts"],
       {
         cwd: backendDir,
         stdio: ["inherit", "pipe", "pipe"],
         env,
-        shell: true
+        shell: true,
+        detached: process.platform !== "win32"
       }
     );
     backendChild.catch(() => {
@@ -673,9 +858,19 @@ async function devCommand(rawArgs) {
       lines.forEach((line) => {
         console.log(`${chalk.cyan.bold("[backend]")}  ${line}`);
         const cleanLine = stripAnsi(line);
-        if (cleanLine.includes("Server running at http://")) {
+        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);
+          }
         }
       });
     });
@@ -689,39 +884,8 @@ async function devCommand(rawArgs) {
   } else if (!frontendOnly && !backendDir) {
     console.warn(chalk.yellow("  ⚠ No backend/ directory found, skipping backend."));
   }
-  if (!backendOnly && frontendDir) {
-    console.log(`  ${chalk.magenta("▶")} Frontend: ${chalk.gray(frontendDir)}`);
-    const frontendChild = execa(
-      "pnpm",
-      ["run", "dev"],
-      {
-        cwd: frontendDir,
-        stdio: ["inherit", "pipe", "pipe"],
-        env: process.env,
-        shell: true
-      }
-    );
-    frontendChild.catch(() => {
-    });
-    frontendChild.stdout?.on("data", (data) => {
-      const lines = data.toString().split("\n").filter(Boolean);
-      lines.forEach((line) => {
-        console.log(`${chalk.magenta.bold("[frontend]")} ${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("[frontend]")} ${line}`);
-      });
-    });
-    children.push(frontendChild);
+  if (!backendOnly && frontendDir && (frontendOnly || !backendDir)) {
+    startFrontend(null);
   } else if (!backendOnly && !frontendDir) {
     console.warn(chalk.yellow("  ⚠ No frontend/ directory found, skipping frontend."));
   }
@@ -750,11 +914,19 @@ ${chalk.green.bold("Usage")}
 ${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: 3001)
+  ${chalk.blue("--port, -p")}           Backend port (default: auto-detected per project)
 
 ${chalk.green.bold("Description")}
-  Starts both the backend (tsx watch + Express) and frontend (Vite)
+  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) {
@@ -891,6 +1063,49 @@ ${chalk.green.bold("Examples")}
   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() {
@@ -922,7 +1137,7 @@ async function entry(args) {
   }
   const command = parsedArgs._[0];
   const subcommand = parsedArgs._[1];
-  const namespacedCommands = ["schema", "db", "dev", "auth"];
+  const namespacedCommands = ["schema", "db", "dev", "auth", "doctor"];
   if (!command || parsedArgs["--help"] && !namespacedCommands.includes(command)) {
     printHelp();
     return;
@@ -932,7 +1147,7 @@ async function entry(args) {
     case "init":
       await createRebaseApp(args);
       break;
-    case "generate-sdk":
+    case "generate-sdk": {
       const sdkArgs = arg(
         {
           "--collections-dir": String,
@@ -946,11 +1161,12 @@ async function entry(args) {
         }
       );
       await generateSdkCommand({
-        collectionsDir: sdkArgs["--collections-dir"] || "./shared/collections",
+        collectionsDir: sdkArgs["--collections-dir"] || "./config/collections",
         output: sdkArgs["--output"] || "./generated/sdk",
         cwd: process.cwd()
       });
       break;
+    }
     case "schema":
       await schemaCommand(effectiveSubcommand, args);
       break;
@@ -963,6 +1179,9 @@ async function entry(args) {
     case "auth":
       await authCommand(effectiveSubcommand, args);
       break;
+    case "doctor":
+      await doctorCommand(args);
+      break;
     default:
       console.log(chalk.red(`Unknown command: ${command}`));
       console.log("");
@@ -999,6 +1218,9 @@ ${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
   ${chalk.blue("--help, -h")}      Show this help message