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

package/dist/commands/build.d.ts

@@ -0,0 +1 @@
+export declare function buildCommand(): Promise<void>;

package/dist/commands/init.d.ts

@@ -1,3 +1,4 @@
+import type { PackageManager, PMCommands } from "../utils/package-manager";
 export interface InitOptions {
     projectName: string;
     git: boolean;
@@ -6,5 +7,10 @@ export interface InitOptions {
     templateDirectory: string;
     databaseUrl?: string;
     introspect?: boolean;
+    /** Detected package manager (pnpm or npm). */
+    pm: PackageManager;
+    /** Command helpers for the detected PM. */
+    pmCommands: PMCommands;
 }
 export declare function createRebaseApp(rawArgs: string[]): Promise<void>;
+export declare function configureEnvFile(targetDirectory: string, databaseUrl?: string): void;

package/dist/commands/start.d.ts

@@ -0,0 +1 @@
+export declare function startCommand(): Promise<void>;

package/dist/index.cjs

@@ -20,6 +20,45 @@
     return Object.freeze(n);
   }
   const os__namespace = /* @__PURE__ */ _interopNamespaceDefault(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 = util.promisify(fs.access);
   const copy = util.promisify(ncp);
   const __filename$2 = 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);
@@ -39,10 +78,11 @@
     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,
@@ -85,7 +125,7 @@ ${chalk.bold("Rebase")} — Create a new project 🚀
       questions.push({
         type: "confirm",
         name: "installDeps",
-        message: "Install dependencies with pnpm?",
+        message: `Install dependencies with ${pm}?`,
         default: true
       });
     }
@@ -106,6 +146,7 @@ ${chalk.bold("Rebase")} — Create a new project 🚀
     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,
@@ -113,7 +154,9 @@ ${chalk.bold("Rebase")} — Create a new project 🚀
       targetDirectory,
       templateDirectory,
       databaseUrl: answers.databaseUrl?.trim() || void 0,
-      introspect: answers.introspect || false
+      introspect: answers.introspect || false,
+      pm,
+      pmCommands
     };
   }
   async function createProject(options) {
@@ -146,34 +189,7 @@ ${chalk.bold("Rebase")} — Create a new project 🚀
       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 {
@@ -182,17 +198,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) {
@@ -201,18 +220,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("");
@@ -220,22 +239,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("");
@@ -249,7 +269,8 @@ POSTGRES_PASSWORD=${dbPassword}
       "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";
@@ -258,22 +279,23 @@ POSTGRES_PASSWORD=${dbPassword}
       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";
@@ -308,6 +330,32 @@ POSTGRES_PASSWORD=${dbPassword}
       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)) {
@@ -460,15 +508,20 @@ Expected a default export of EntityCollection[] or an object with named collecti
     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;
@@ -669,7 +722,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
@@ -800,9 +852,12 @@ ${chalk.green.bold("Examples")}
         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"],
@@ -836,8 +891,10 @@ ${chalk.green.bold("Examples")}
     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);
@@ -938,6 +995,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();
@@ -1146,7 +1243,7 @@ ${chalk.green.bold("Examples")}
     }
     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;
@@ -1185,6 +1282,12 @@ ${chalk.green.bold("Examples")}
       case "dev":
         await devCommand(args);
         break;
+      case "build":
+        await buildCommand();
+        break;
+      case "start":
+        await startCommand();
+        break;
       case "auth":
         await authCommand(effectiveSubcommand, args);
         break;
@@ -1207,14 +1310,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
@@ -1281,6 +1386,8 @@ ${chalk.gray("Documentation: https://rebase.pro/docs")}
     }
   }
   exports2.authCommand = authCommand;
+  exports2.buildCommand = buildCommand;
+  exports2.configureEnvFile = configureEnvFile;
   exports2.createRebaseApp = createRebaseApp;
   exports2.dbCommand = dbCommand;
   exports2.devCommand = devCommand;
@@ -1301,6 +1408,7 @@ ${chalk.gray("Documentation: https://rebase.pro/docs")}
   exports2.resolvePluginCliScript = resolvePluginCliScript;
   exports2.resolveTsx = resolveTsx;
   exports2.schemaCommand = schemaCommand;
+  exports2.startCommand = startCommand;
   Object.defineProperty(exports2, Symbol.toStringTag, { value: "Module" });
 }));
 //# sourceMappingURL=index.cjs.map