@rebasepro/cli 0.9.1-canary.d906fb7 → 0.9.1-canary.e3f810f

package/dist/commands/skills.d.ts

@@ -1 +1 @@
-export declare function skillsCommand(subcommand: string | undefined, _args: string[]): Promise<void>;
+export declare function skillsCommand(subcommand: string | undefined, rawArgs: string[]): Promise<void>;

package/dist/index.es.js

@@ -9,8 +9,8 @@ import { execa, execaCommandSync } from "execa";
 import { cp } from "fs/promises";
 import { fileURLToPath } from "url";
 import crypto from "crypto";
+import { execSync, spawn, spawnSync } from "child_process";
 import os from "os";
-import { execSync, spawn } from "child_process";
 import { createRebaseClient } from "@rebasepro/client";
 import { generateSDK } from "@rebasepro/codegen";
 import { createRequire } from "module";
@@ -23,28 +23,45 @@ import { createRequire } from "module";
 * the rest of the CLI never has to hardcode a specific PM.
 */
 /**
-* Detect the package manager from the environment or the target directory.
+* Whether pnpm is runnable on this machine.
+*
+* Used to decide whether a fresh project can be scaffolded with pnpm. Kept
+* cheap and non-interactive (short timeout, output discarded) so it never
+* hangs detection if a corepack shim misbehaves.
+*/
+function isPnpmAvailable() {
+	try {
+		return spawnSync("pnpm", ["--version"], {
+			stdio: "ignore",
+			timeout: 3e3
+		}).status === 0;
+	} catch {
+		return false;
+	}
+}
+/**
+* Detect the package manager for a Rebase project.
+*
+* Rebase recommends pnpm, so detection prefers it. Crucially, *how the CLI was
+* invoked* (`npx` vs `pnpm dlx`, i.e. `npm_config_user_agent`) is deliberately
+* ignored: running `npx @rebasepro/cli init` says nothing about how the user
+* wants to manage the project they're creating, and letting it pin the scaffold
+* to npm is what made every `npx`-invoked project an npm project.
 *
 * Detection order:
-* 1. Explicit override (if provided)
-* 2. `npm_config_user_agent` env var (set by npm/pnpm when running via `npx`/`pnpm dlx`)
-* 3. Lock-file presence in the target directory
-* 4. Default to pnpm (Rebase's recommended PM)
+* 1. An existing lock file — an explicit choice we always respect
+*    (`pnpm-lock.yaml` wins over `package-lock.json` when both are present).
+* 2. pnpm, whenever it is installed.
+* 3. npm, only as a fallback when pnpm is genuinely unavailable.
 */
 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";
+	const dirs = [targetDir, process.cwd()].filter((d) => !!d);
+	for (const dir of dirs) {
+		if (fs.existsSync(path.join(dir, "pnpm-lock.yaml"))) return "pnpm";
+		if (fs.existsSync(path.join(dir, "package-lock.json"))) return "npm";
 	}
-	return "pnpm";
+	if (isPnpmAvailable()) return "pnpm";
+	return "npm";
 }
 /** Build the command helpers for a given package manager. */
 function getPMCommands(pm) {
@@ -118,7 +135,8 @@ function getPMCommands(pm) {
 		runWorkspace: (workspace, script) => [
 			"pnpm",
 			"--filter",
-			workspace,
+			`./${workspace}`,
+			"run",
 			script
 		],
 		dlx: (pkg, args) => [
@@ -925,6 +943,13 @@ async function promptForOptions(rawArgs, pm) {
 			cloudUrl: resolveCloudUrl(rawArgs)
 		};
 	}
+	if (!process.stdin.isTTY) {
+		console.error(chalk.red("Cannot prompt: this is a non-interactive terminal (no TTY)."));
+		console.error(chalk.yellow("  Re-run with --yes to accept defaults, passing any choices as flags, e.g.:"));
+		console.error(chalk.yellow(`    rebase init ${nameArg || "my-app"} --yes --template blog --flavor cms`));
+		console.error(chalk.gray("  Options: --template <blog|ecommerce|blank>  --flavor <cms|baas>  --database-url <url>  --install  --git"));
+		process.exit(1);
+	}
 	const questions = buildInitQuestions({
 		nameArg,
 		templateArg,
@@ -2452,22 +2477,43 @@ function installForAgent(agentKey, skills, projectDir) {
 	}
 	return count;
 }
-async function skillsCommand(subcommand, _args) {
+async function skillsCommand(subcommand, rawArgs) {
 	switch (subcommand) {
 		case "install":
-			await skillsInstall();
+			await skillsInstall(rawArgs);
 			break;
 		case "--help":
 		case void 0:
 			printSkillsHelp();
 			break;
 		default:
-			console.log(chalk.red(`Unknown skills subcommand: ${subcommand}`));
+			console.error(chalk.red(`Unknown skills subcommand: ${subcommand}`));
 			console.log("");
 			printSkillsHelp();
+			process.exit(1);
+	}
+}
+/**
+* Agents named explicitly on the command line, e.g. `--agent claude --agent cursor`
+* (also accepts a comma-separated list). Returns null when none were given.
+*/
+function parseAgentFlags(rawArgs) {
+	const requested = [];
+	for (let i = 0; i < rawArgs.length; i++) {
+		if (rawArgs[i] !== "--agent" && rawArgs[i] !== "-a") continue;
+		const value = rawArgs[i + 1];
+		if (value && !value.startsWith("-")) requested.push(...value.split(",").map((v) => v.trim()).filter(Boolean));
+	}
+	if (requested.length === 0) return null;
+	const valid = Object.keys(AGENTS);
+	const unknown = requested.filter((a) => !valid.includes(a));
+	if (unknown.length > 0) {
+		console.error(chalk.red(`Unknown agent(s): ${unknown.join(", ")}. Available: ${valid.join(", ")}`));
+		process.exit(1);
 	}
+	return requested;
 }
-async function skillsInstall() {
+async function skillsInstall(rawArgs = []) {
 	const projectDir = process.cwd();
 	let skillsDir;
 	try {
@@ -2481,8 +2527,14 @@ async function skillsInstall() {
 		console.error(`${chalk.red.bold("ERROR")} No skills found in ${skillsDir}`);
 		process.exit(1);
 	}
-	let agents = detectAgents(projectDir);
+	let agents = parseAgentFlags(rawArgs) ?? detectAgents(projectDir);
 	if (agents.length === 0) {
+		if (!process.stdin.isTTY) {
+			console.error(chalk.red("Cannot prompt: this is a non-interactive terminal (no TTY)."));
+			console.error(chalk.yellow(`  Name the agents explicitly, e.g. rebase skills install --agent ${Object.keys(AGENTS)[0]}`));
+			console.error(chalk.gray(`  Available: ${Object.keys(AGENTS).join(", ")}`));
+			process.exit(1);
+		}
 		const choices = Object.entries(AGENTS).map(([key, agent]) => ({
 			name: agent.label,
 			value: key,
@@ -2524,8 +2576,15 @@ ${chalk.green.bold("Subcommands")}
   ${chalk.blue.bold("install")}    Install Rebase agent skills for your AI coding assistant
                Supports: Cursor, Claude Code, Windsurf, Gemini CLI, Antigravity
 
+${chalk.green.bold("Options")}
+  ${chalk.blue("--agent, -a")}   Agent(s) to install for, skipping detection and the prompt.
+                Repeat the flag or pass a comma-separated list.
+                Available: ${Object.keys(AGENTS).join(", ")}
+
 ${chalk.green.bold("Examples")}
   ${chalk.cyan("rebase skills install")}
+  ${chalk.cyan("rebase skills install --agent claude")}
+  ${chalk.cyan("rebase skills install --agent claude,cursor")}
 `);
 }
 //#endregion
@@ -2557,9 +2616,16 @@ function loadEnv(projectRoot) {
 	}
 	return env;
 }
-function resolveBaseUrl(env) {
-	const port = env.PORT || env.REBASE_PORT || "3001";
-	return env.REBASE_BASE_URL || `http://localhost:${port}`;
+function resolveBaseUrl(env, projectRoot) {
+	if (env.REBASE_BASE_URL) return env.REBASE_BASE_URL;
+	if (projectRoot) try {
+		const urlFile = path.join(projectRoot, ".rebase-dev-url");
+		if (fs.existsSync(urlFile)) {
+			const devUrl = fs.readFileSync(urlFile, "utf-8").trim();
+			if (devUrl) return devUrl;
+		}
+	} catch {}
+	return `http://localhost:${env.PORT || env.REBASE_PORT || "3001"}`;
 }
 async function apiKeysCommand(subcommand, rawArgs) {
 	if (!subcommand || subcommand === "--help") {
@@ -2584,8 +2650,9 @@ async function apiKeysCommand(subcommand, rawArgs) {
 	}
 }
 async function listKeys(_rawArgs) {
-	const env = loadEnv(requireProjectRoot());
-	const baseUrl = resolveBaseUrl(env);
+	const projectRoot = requireProjectRoot();
+	const env = loadEnv(projectRoot);
+	const baseUrl = resolveBaseUrl(env, projectRoot);
 	const serviceKey = env.SERVICE_KEY || env.REBASE_SERVICE_KEY;
 	if (!serviceKey) {
 		console.error(chalk.red("✗ SERVICE_KEY not found in .env — required for admin operations."));
@@ -2690,8 +2757,9 @@ async function createKey(rawArgs) {
 			expires_at = parsed.toISOString();
 		}
 	}
-	const env = loadEnv(requireProjectRoot());
-	const baseUrl = resolveBaseUrl(env);
+	const projectRoot = requireProjectRoot();
+	const env = loadEnv(projectRoot);
+	const baseUrl = resolveBaseUrl(env, projectRoot);
 	const serviceKey = env.SERVICE_KEY || env.REBASE_SERVICE_KEY;
 	if (!serviceKey) {
 		console.error(chalk.red("✗ SERVICE_KEY not found in .env — required for admin operations."));
@@ -2748,8 +2816,9 @@ async function revokeKey(rawArgs) {
 		console.log(chalk.gray("  Usage: rebase api-keys revoke <key-id>"));
 		process.exit(1);
 	}
-	const env = loadEnv(requireProjectRoot());
-	const baseUrl = resolveBaseUrl(env);
+	const projectRoot = requireProjectRoot();
+	const env = loadEnv(projectRoot);
+	const baseUrl = resolveBaseUrl(env, projectRoot);
 	const serviceKey = env.SERVICE_KEY || env.REBASE_SERVICE_KEY;
 	if (!serviceKey) {
 		console.error(chalk.red("✗ SERVICE_KEY not found in .env — required for admin operations."));
@@ -3218,13 +3287,18 @@ function fmtDate(value) {
 */
 var POLL_INTERVAL_MS = 1500;
 var POLL_TIMEOUT_MS = 900 * 1e3;
+var MAX_SOURCE_UPLOAD_BYTES = 100 * 1024 * 1024;
 function sleep(ms) {
 	return new Promise((r) => setTimeout(r, ms));
 }
-function run(cmd, cmdArgs, cwd) {
+function run(cmd, cmdArgs, cwd, env) {
 	return new Promise((resolve, reject) => {
 		const child = spawn(cmd, cmdArgs, {
 			cwd,
+			env: env ? {
+				...process.env,
+				...env
+			} : void 0,
 			stdio: [
 				"ignore",
 				"ignore",
@@ -3254,7 +3328,7 @@ async function createSourceTarball(sourceDir) {
 	for (const ignore of [".gitignore", ".rebaseignore"]) if (fs.existsSync(path.join(dir, ignore))) tarArgs.push(`--exclude-from=${ignore}`);
 	tarArgs.push(".");
 	try {
-		await run("tar", tarArgs, dir);
+		await run("tar", tarArgs, dir, { COPYFILE_DISABLE: "1" });
 	} catch (e) {
 		fail(`Failed to package source: ${e instanceof Error ? e.message : String(e)}`);
 	}
@@ -3264,6 +3338,7 @@ async function createSourceTarball(sourceDir) {
 async function uploadSource(url, token, projectId, tarPath) {
 	const bytes = fs.readFileSync(tarPath);
 	const sizeMb = (bytes.length / 1024 / 1024).toFixed(1);
+	if (bytes.length > MAX_SOURCE_UPLOAD_BYTES) fail(`Source context is ${sizeMb} MB — the upload cap is ${Math.round(MAX_SOURCE_UPLOAD_BYTES / 1024 / 1024)} MB.`, "Trim the build context: exclude sourcemaps (*.map), build output and large assets via .rebaseignore or .gitignore.");
 	console.log(chalk.gray(`  Uploading source (${sizeMb} MB)...`));
 	const res = await fetch(`${url}/api/functions/deploy/upload?projectId=${encodeURIComponent(projectId)}`, {
 		method: "POST",
@@ -4243,6 +4318,8 @@ ${chalk.green.bold("Options")}
   ${chalk.blue("--secret")}                  Mark a variable write-only ${chalk.gray("(set)")}
   ${chalk.blue("--json")}                    Machine-readable output
   ${chalk.blue("--project, -p")}             Project slug ${chalk.gray("(defaults to the linked project)")}
+
+${chalk.gray("Values are encrypted at rest (AES-256-GCM) and only decrypted at deploy time.")}
 `);
 }
 function printEnvHelpJson() {
@@ -5603,9 +5680,10 @@ async function entry(args) {
 			await cloudCommand(effectiveSubcommand, args);
 			break;
 		default:
-			console.log(chalk.red(`Unknown command: ${command}`));
+			console.error(chalk.red(`Unknown command: ${command}`));
 			console.log("");
 			printHelp();
+			process.exit(1);
 	}
 }
 function printHelp() {
@@ -5665,6 +5743,6 @@ ${chalk.gray("Documentation: https://rebase.pro/docs")}
 `);
 }
 //#endregion
-export { authCommand, buildCommand, buildInitQuestions, cloudCommand, configureEnvFile, createRebaseApp, dbCommand, detectPackageManager, devCommand, doctorCommand, entry, findBackendDir, findEnvFile, findFrontendDir, findProjectRoot, generateSdkCommand, getActiveBackendPlugin, getPMCommands, requireBackendDir, requireProjectRoot, resolveLocalBin, resolvePluginCliScript, resolveTsx, schemaCommand, startCommand, validateProjectName, validateTsxInstallation };
+export { authCommand, buildCommand, buildInitQuestions, cloudCommand, configureEnvFile, createRebaseApp, dbCommand, detectPackageManager, devCommand, doctorCommand, entry, findBackendDir, findEnvFile, findFrontendDir, findProjectRoot, generateSdkCommand, getActiveBackendPlugin, getPMCommands, isPnpmAvailable, requireBackendDir, requireProjectRoot, resolveLocalBin, resolvePluginCliScript, resolveTsx, schemaCommand, startCommand, validateProjectName, validateTsxInstallation };
 
 //# sourceMappingURL=index.es.js.map