@rebasepro/cli 0.0.1-canary.dbf160a → 0.0.1-canary.e17585f

package/dist/index.es.js

@@ -11,6 +11,45 @@ import crypto from "crypto";
 import { generateSDK } from "@rebasepro/sdk-generator";
 import { execSync, spawn } from "child_process";
 import * as os from "os";
+function detectPackageManager(targetDir) {
+  const userAgent = process.env.npm_config_user_agent ?? "";
+  if (userAgent.startsWith("npm/")) return "npm";
+  if (userAgent.startsWith("pnpm/")) return "pnpm";
+  if (targetDir) {
+    if (fs.existsSync(path.join(targetDir, "package-lock.json"))) return "npm";
+    if (fs.existsSync(path.join(targetDir, "pnpm-lock.yaml"))) return "pnpm";
+  }
+  const cwd = process.cwd();
+  if (cwd !== targetDir) {
+    if (fs.existsSync(path.join(cwd, "package-lock.json"))) return "npm";
+    if (fs.existsSync(path.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  }
+  return "pnpm";
+}
+function getPMCommands(pm) {
+  if (pm === "npm") {
+    return {
+      name: "npm",
+      install: ["npm", "install"],
+      run: (script) => ["npm", "run", script],
+      exec: (bin, args) => ["npx", bin, ...args],
+      view: (pkg, field) => ["npm", "view", pkg, field],
+      runAll: (script) => ["npm", "run", script, "--workspaces", "--if-present"],
+      runWorkspace: (workspace, script) => ["npm", "run", script, "-w", workspace],
+      workspaceProtocol: "*"
+    };
+  }
+  return {
+    name: "pnpm",
+    install: ["pnpm", "install"],
+    run: (script) => ["pnpm", "run", script],
+    exec: (bin, args) => ["pnpm", "exec", bin, ...args],
+    view: (pkg, field) => ["pnpm", "view", pkg, field],
+    runAll: (script) => ["pnpm", "-r", "run", script],
+    runWorkspace: (workspace, script) => ["pnpm", "--filter", workspace, script],
+    workspaceProtocol: "workspace:*"
+  };
+}
 const access = promisify(fs.access);
 const copy = promisify(ncp);
 const __filename$2 = fileURLToPath(import.meta.url);
@@ -30,10 +69,11 @@ async function createRebaseApp(rawArgs) {
   console.log(`
 ${chalk.bold("Rebase")} — Create a new project 🚀
 `);
-  const options = await promptForOptions(rawArgs);
+  const pm = detectPackageManager();
+  const options = await promptForOptions(rawArgs, pm);
   await createProject(options);
 }
-async function promptForOptions(rawArgs) {
+async function promptForOptions(rawArgs, pm) {
   const args = arg(
     {
       "--git": Boolean,
@@ -76,7 +116,7 @@ async function promptForOptions(rawArgs) {
     questions.push({
       type: "confirm",
       name: "installDeps",
-      message: "Install dependencies with pnpm?",
+      message: `Install dependencies with ${pm}?`,
       default: true
     });
   }
@@ -97,6 +137,7 @@ async function promptForOptions(rawArgs) {
   const targetDirectory = path.resolve(process.cwd(), nameArg || answers.projectName);
   const projectName = path.basename(targetDirectory);
   const templateDirectory = path.resolve(cliRoot, "templates", "template");
+  const pmCommands = getPMCommands(pm);
   return {
     projectName,
     git: args["--git"] || answers.git || false,
@@ -104,7 +145,9 @@ async function promptForOptions(rawArgs) {
     targetDirectory,
     templateDirectory,
     databaseUrl: answers.databaseUrl?.trim() || void 0,
-    introspect: answers.introspect || false
+    introspect: answers.introspect || false,
+    pm,
+    pmCommands
   };
 }
 async function createProject(options) {
@@ -137,34 +180,7 @@ async function createProject(options) {
     process.exit(1);
   }
   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");
-    let envContent = fs.readFileSync(envPath, "utf-8");
-    envContent = envContent.replace(
-      "change-this-to-a-secure-random-string",
-      jwtSecret
-    );
-    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");
-  }
+  configureEnvFile(options.targetDirectory, options.databaseUrl);
   if (options.git) {
     console.log(chalk.gray("  Initializing git repository..."));
     try {
@@ -173,17 +189,20 @@ POSTGRES_PASSWORD=${dbPassword}
       console.warn(chalk.yellow("  Warning: Failed to initialize git repository"));
     }
   }
+  const { pm, pmCommands } = options;
+  const installCmd = pmCommands.install;
+  const execCmd = pmCommands.exec("rebase", ["schema", "introspect", "--force"]);
   if (options.installDeps) {
     console.log("");
-    console.log(chalk.gray("  Installing dependencies with pnpm..."));
+    console.log(chalk.gray(`  Installing dependencies with ${pm}...`));
     console.log("");
     try {
-      await execa("pnpm", ["install"], {
+      await execa(installCmd[0], installCmd.slice(1), {
         cwd: options.targetDirectory,
         stdio: "inherit"
       });
     } catch {
-      console.warn(chalk.yellow("  Warning: Failed to install dependencies. You may need to run `pnpm install` manually."));
+      console.warn(chalk.yellow(`  Warning: Failed to install dependencies. You may need to run \`${installCmd.join(" ")}\` manually.`));
     }
   }
   if (options.introspect) {
@@ -192,18 +211,18 @@ POSTGRES_PASSWORD=${dbPassword}
       console.log(chalk.gray("  Introspecting database and generating collections..."));
       console.log("");
       try {
-        await execa("pnpm", ["exec", "rebase", "schema", "introspect"], {
+        await execa(execCmd[0], execCmd.slice(1), {
           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."));
+        console.warn(chalk.yellow(`  You can run \`${execCmd.join(" ")}\` 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.warn(chalk.yellow(`  Run \`${installCmd.join(" ")}\` then \`${execCmd.join(" ")}\` manually.`));
     }
   }
   console.log("");
@@ -211,22 +230,23 @@ POSTGRES_PASSWORD=${dbPassword}
   console.log("");
   console.log(chalk.bold("Next steps:"));
   console.log("");
+  const runDev = pmCommands.run("dev");
   console.log(`  ${chalk.cyan("cd")} ${options.projectName}`);
   if (!options.installDeps) {
-    console.log(`  ${chalk.cyan("pnpm install")}`);
+    console.log(`  ${chalk.cyan(installCmd.join(" "))}`);
   }
   console.log("");
   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("  # 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(`  ${chalk.cyan(runDev.join(" "))}`);
   console.log("");
   console.log(chalk.gray("This starts both the backend (Hono + PostgreSQL)") + chalk.gray(" and the frontend (Vite + React) concurrently."));
   console.log("");
@@ -240,7 +260,8 @@ async function replacePlaceholders(options) {
     "frontend/package.json",
     "backend/package.json",
     "config/package.json",
-    "frontend/index.html"
+    "frontend/index.html",
+    "README.md"
   ];
   const packageJsonPath = path.resolve(cliRoot, "package.json");
   let cliVersion = "latest";
@@ -249,22 +270,23 @@ async function replacePlaceholders(options) {
     cliVersion = pkg.version || "latest";
   }
   const versionCache = /* @__PURE__ */ new Map();
+  const viewBin = "npm";
   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"]);
+      const { stdout } = await execa(viewBin, ["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("npm", ["--loglevel", "error", "info", `${pkgName}@${tag}`, "version"]);
+        const { stdout } = await execa(viewBin, ["view", `${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"]);
+          const { stdout } = await execa(viewBin, ["view", pkgName, "version"]);
           versionToUse = stdout.trim() || "latest";
         } catch {
           versionToUse = "latest";
@@ -299,6 +321,32 @@ async function replacePlaceholders(options) {
     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)) {
@@ -451,15 +499,20 @@ 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
-    };
-    for (const dep of Object.keys(deps)) {
-      if (dep.startsWith("@rebasepro/server-") && dep !== "@rebasepro/server-core") {
-        return dep;
+    const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+    const candidates = Object.keys(deps).filter(
+      (dep) => dep.startsWith("@rebasepro/server-") && dep !== "@rebasepro/server-core"
+    );
+    if (candidates.length === 0) return null;
+    if (candidates.includes("@rebasepro/server-postgresql")) {
+      return "@rebasepro/server-postgresql";
+    }
+    for (const candidate of candidates) {
+      if (resolvePluginCliScript(backendDir, candidate)) {
+        return candidate;
       }
     }
+    return candidates[0];
   } catch {
   }
   return null;
@@ -660,7 +713,6 @@ ${chalk.green.bold("Usage")}
 ${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
@@ -791,9 +843,12 @@ async function devCommand(rawArgs) {
       frontendEnv.VITE_API_URL = `http://localhost:${backendPort}`;
       console.log(`  ${chalk.gray("↳ VITE_API_URL")} = ${chalk.white(`http://localhost:${backendPort}`)}`);
     }
+    const pm = detectPackageManager(projectRoot);
+    const pmCmds = getPMCommands(pm);
+    const runDevCmd = pmCmds.run("dev");
     const frontendChild = execa(
-      "pnpm",
-      ["run", "dev"],
+      runDevCmd[0],
+      runDevCmd.slice(1),
       {
         cwd: frontendDir,
         stdio: ["inherit", "pipe", "pipe"],
@@ -827,8 +882,10 @@ async function devCommand(rawArgs) {
   if (!frontendOnly && backendDir) {
     const tsxBin = resolveTsx(projectRoot);
     if (!tsxBin) {
+      const pmName = detectPackageManager(projectRoot);
+      const addCmd = pmName === "npm" ? "npm install -D tsx" : "pnpm add -D tsx";
       console.error(chalk.red("  ✗ Could not find tsx binary for backend."));
-      console.error(chalk.gray("    Install it with: pnpm add -D tsx"));
+      console.error(chalk.gray(`    Install it with: ${addCmd}`));
       process.exit(1);
     }
     const envFile = findEnvFile(projectRoot);
@@ -929,6 +986,46 @@ ${chalk.green.bold("Description")}
   backend is ready, and VITE_API_URL is injected automatically.
 `);
 }
+async function buildCommand() {
+  const projectRoot = requireProjectRoot();
+  const pm = detectPackageManager(projectRoot);
+  const cmds = getPMCommands(pm);
+  const buildCmd = cmds.runAll("build");
+  console.log(`${chalk.bold("Rebase")} — Building all workspaces with ${chalk.cyan(pm)}...
+`);
+  try {
+    await execa(buildCmd[0], buildCmd.slice(1), {
+      cwd: projectRoot,
+      stdio: "inherit"
+    });
+  } catch {
+    console.error(chalk.red("\n✗ Build failed."));
+    process.exit(1);
+  }
+}
+async function startCommand() {
+  const projectRoot = requireProjectRoot();
+  const pm = detectPackageManager(projectRoot);
+  const cmds = getPMCommands(pm);
+  const startCmd = cmds.runWorkspace("backend", "start");
+  const envFile = findEnvFile(projectRoot);
+  const env = { ...process.env };
+  if (envFile) {
+    env.DOTENV_CONFIG_PATH = envFile;
+  }
+  console.log(`${chalk.bold("Rebase")} — Starting backend server...
+`);
+  try {
+    await execa(startCmd[0], startCmd.slice(1), {
+      cwd: projectRoot,
+      stdio: "inherit",
+      env
+    });
+  } catch {
+    console.error(chalk.red("\n✗ Failed to start server."));
+    process.exit(1);
+  }
+}
 async function authCommand(subcommand, rawArgs) {
   if (!subcommand || subcommand === "--help") {
     printAuthHelp();
@@ -1137,7 +1234,7 @@ async function entry(args) {
   }
   const command = parsedArgs._[0];
   const subcommand = parsedArgs._[1];
-  const namespacedCommands = ["schema", "db", "dev", "auth", "doctor"];
+  const namespacedCommands = ["schema", "db", "dev", "build", "start", "auth", "doctor"];
   if (!command || parsedArgs["--help"] && !namespacedCommands.includes(command)) {
     printHelp();
     return;
@@ -1176,6 +1273,12 @@ async function entry(args) {
     case "dev":
       await devCommand(args);
       break;
+    case "build":
+      await buildCommand();
+      break;
+    case "start":
+      await startCommand();
+      break;
     case "auth":
       await authCommand(effectiveSubcommand, args);
       break;
@@ -1198,14 +1301,16 @@ ${chalk.green.bold("Usage")}
 ${chalk.green.bold("Commands")}
   ${chalk.blue.bold("init")}                    Create a new Rebase project
   ${chalk.blue.bold("dev")}                     Start the development server
+  ${chalk.blue.bold("build")}                   Build all workspace packages
+  ${chalk.blue.bold("start")}                   Start the backend server ${chalk.gray("(production)")}
 
 ${chalk.green.bold("Schema")}
   ${chalk.blue.bold("schema generate")}         Generate Drizzle schema from collections
+  ${chalk.blue.bold("schema introspect")}       Introspect database → Rebase 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
@@ -1273,6 +1378,8 @@ async function logout(env, _debug) {
 }
 export {
   authCommand,
+  buildCommand,
+  configureEnvFile,
   createRebaseApp,
   dbCommand,
   devCommand,
@@ -1292,6 +1399,7 @@ export {
   resolveLocalBin,
   resolvePluginCliScript,
   resolveTsx,
-  schemaCommand
+  schemaCommand,
+  startCommand
 };
 //# sourceMappingURL=index.es.js.map