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

package/dist/index.cjs

@@ -1,6 +1,6 @@
 (function(global, factory) {
-  typeof exports === "object" && typeof module !== "undefined" ? factory(exports, require("chalk"), require("arg"), require("inquirer"), require("path"), require("fs"), require("util"), require("execa"), require("ncp"), require("url"), require("crypto"), require("os")) : typeof define === "function" && define.amd ? define(["exports", "chalk", "arg", "inquirer", "path", "fs", "util", "execa", "ncp", "url", "crypto", "os"], factory) : (global = typeof globalThis !== "undefined" ? globalThis : global || self, factory(global["Rebase CLI"] = {}, global.chalk, global.arg, global.inquirer, global.path, global.fs, global.util, global.execa, global.ncp, global.url, global.crypto, global.os));
-})(this, (function(exports2, chalk, arg, inquirer, path, fs, util, execa, ncp, url, crypto, os) {
+  typeof exports === "object" && typeof module !== "undefined" ? factory(exports, require("chalk"), require("arg"), require("inquirer"), require("path"), require("fs"), require("util"), require("execa"), require("ncp"), require("url"), require("crypto"), require("@rebasepro/sdk-generator"), require("child_process"), require("os")) : typeof define === "function" && define.amd ? define(["exports", "chalk", "arg", "inquirer", "path", "fs", "util", "execa", "ncp", "url", "crypto", "@rebasepro/sdk-generator", "child_process", "os"], factory) : (global = typeof globalThis !== "undefined" ? globalThis : global || self, factory(global["Rebase CLI"] = {}, global.chalk, global.arg, global.inquirer, global.path, global.fs, global.util, global.execa, global.ncp, global.url, global.crypto, global.sdkGenerator, global.child_process, global.os));
+})(this, (function(exports2, chalk, arg, inquirer, path, fs, util, execa, ncp, url, crypto, sdkGenerator, child_process, os) {
   "use strict";
   var _documentCurrentScript = typeof document !== "undefined" ? document.currentScript : null;
   function _interopNamespaceDefault(e) {
@@ -46,7 +46,9 @@ ${chalk.bold("Rebase")} — Create a new project 🚀
     const args = arg(
       {
         "--git": Boolean,
-        "-g": "--git"
+        "--install": Boolean,
+        "-g": "--git",
+        "-i": "--install"
       },
       {
         argv: rawArgs.slice(3),
@@ -79,15 +81,39 @@ ${chalk.bold("Rebase")} — Create a new project 🚀
         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) {
@@ -106,36 +132,21 @@ ${chalk.bold("Rebase")} — Create a new project 🚀
       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 {
@@ -144,23 +155,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) {
@@ -168,17 +221,899 @@ POSTGRES_PASSWORD=${dbPassword}
       "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 = sdkGenerator.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 = child_process.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 = child_process.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 = url.fileURLToPath(typeof document === "undefined" && typeof location === "undefined" ? require("url").pathToFileURL(__filename).href : typeof document === "undefined" ? location.href : _documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === "SCRIPT" && _documentCurrentScript.src || new URL("index.cjs", document.baseURI).href);
   const __dirname$1 = path.dirname(__filename$1);
   function getVersion() {
@@ -209,16 +1144,56 @@ POSTGRES_PASSWORD=${dbPassword}
       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() {
@@ -229,7 +1204,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
@@ -281,13 +1279,28 @@ ${chalk.gray("Documentation: https://rebase.pro/docs")}
       console.log("You are not logged in.");
     }
   }
+  exports2.authCommand = authCommand;
+  exports2.configureEnvFile = configureEnvFile;
   exports2.createRebaseApp = createRebaseApp;
+  exports2.dbCommand = dbCommand;
+  exports2.devCommand = devCommand;
   exports2.entry = entry;
+  exports2.findBackendDir = findBackendDir;
+  exports2.findEnvFile = findEnvFile;
+  exports2.findFrontendDir = findFrontendDir;
+  exports2.findProjectRoot = findProjectRoot;
+  exports2.getActiveBackendPlugin = getActiveBackendPlugin;
   exports2.getTokens = getTokens;
   exports2.login = login;
   exports2.logout = logout;
   exports2.parseJwt = parseJwt;
   exports2.refreshCredentials = refreshCredentials;
+  exports2.requireBackendDir = requireBackendDir;
+  exports2.requireProjectRoot = requireProjectRoot;
+  exports2.resolveLocalBin = resolveLocalBin;
+  exports2.resolvePluginCliScript = resolvePluginCliScript;
+  exports2.resolveTsx = resolveTsx;
+  exports2.schemaCommand = schemaCommand;
   Object.defineProperty(exports2, Symbol.toStringTag, { value: "Module" });
 }));
 //# sourceMappingURL=index.cjs.map