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

package/bin/rebase.js

@@ -1,70 +1,4 @@
 #!/usr/bin/env node
-import { existsSync, readdirSync, statSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-
-const here = dirname(fileURLToPath(import.meta.url));
-const distEntry = join(here, "..", "dist", "index.es.js");
-const srcDir = join(here, "..", "src");
-
-/**
- * Warn when the built CLI is older than the source it was built from.
- *
- * `rebase` runs `dist/`, and a global install of this package is usually a
- * symlink to a working checkout — so every agent and shell on the machine runs
- * whatever was last built, not what is in the code. A stale build is invisible:
- * the command works, it just silently lacks the subcommand you added, which
- * reads as "my change did nothing" rather than "you forgot to build".
- *
- * Development-only by construction: `src/` is not in the published `files`
- * list, so this is skipped entirely for installed copies.
- *
- * Writes to **stderr**. Agents parse stdout as JSON under `--json`, and a
- * warning there would corrupt the one guarantee those commands make.
- */
-function newestMtimeMs(dir, deadline) {
-    let newest = 0;
-    for (const entry of readdirSync(dir, { withFileTypes: true })) {
-        if (Date.now() > deadline) break; // never let a warning cost real time
-        if (entry.name === "node_modules" || entry.name.startsWith(".")) continue;
-        const full = join(dir, entry.name);
-        if (entry.isDirectory()) {
-            newest = Math.max(newest, newestMtimeMs(full, deadline));
-        } else if (/\.tsx?$/.test(entry.name) && !/\.(test|spec)\.tsx?$/.test(entry.name)) {
-            // Tests are not bundled, so editing one does not make dist stale.
-            // Counting them cried wolf on the ordinary edit-test-run loop.
-            newest = Math.max(newest, statSync(full).mtimeMs);
-        }
-    }
-    return newest;
-}
-
-function warnIfStale() {
-    if (!existsSync(srcDir) || !existsSync(distEntry)) return;
-    const builtAt = statSync(distEntry).mtimeMs;
-    const editedAt = newestMtimeMs(srcDir, Date.now() + 150);
-    // A couple of seconds of slack: a build writes dist while src is being
-    // stat'd, and a sub-second delta is that race, not a stale build.
-    const staleByMs = editedAt - builtAt;
-    if (staleByMs <= 2000) return;
-
-    const seconds = Math.round(staleByMs / 1000);
-    const ago = seconds >= 3600
-        ? `${Math.round(seconds / 3600)}h`
-        : seconds >= 60 ? `${Math.round(seconds / 60)}m` : `${seconds}s`;
-    process.stderr.write(
-        `⚠ rebase CLI: dist/ is ${ago} older than src/ — you are running a stale build.\n` +
-        `  Rebuild with: (cd ${join(here, "..")} && npm run build)\n`
-    );
-}
-
-// A broken staleness check must never stop the CLI from running.
-try {
-    warnIfStale();
-} catch {
-    /* ignore */
-}
-
-const { entry } = await import("../dist/index.es.js");
+import { entry } from "../dist/index.es.js";
 
 entry(process.argv);

package/dist/commands/cloud/context.d.ts

@@ -1,6 +1,10 @@
 import { createRebaseClient } from "@rebasepro/client";
+/** Default hosted control plane (the Rebase Cloud console origin). */
+export declare const DEFAULT_CLOUD_URL = "https://app.rebase.pro";
 /** Project-local link file: <project>/.rebase/cloud.json */
 export declare function projectLinkPath(cwd?: string): string;
+/** Host that a bare `rebase cloud` command should target, if any. */
+export declare function currentContextUrl(): string | undefined;
 /** Persist the active organization id for a host. */
 export declare function setContextOrg(url: string, org: string | undefined): void;
 export declare function getContextOrg(url: string): string | undefined;
@@ -100,6 +104,8 @@ export declare function initOutputMode(rawArgs: string[]): boolean;
 export declare function isJsonMode(): boolean;
 /** Force the mode (tests only — production latches it via `initOutputMode`). */
 export declare function setJsonModeForTest(value: boolean): void;
+/** Write one JSON value to stdout, followed by a newline. */
+export declare function printJson(value: unknown): void;
 /**
  * The one output primitive every new command uses: in JSON mode emit `json`
  * (and nothing else); otherwise run `human`. Keeping the two behind a single

package/dist/commands/cloud/deployments.d.ts

@@ -19,6 +19,7 @@ export interface DeploymentRow {
     gitCommitHash?: string;
     gitCommitMessage?: string;
 }
+export declare function deploymentImage(dep: DeploymentRow): string | null;
 /**
  * The backend's rule EXACTLY: a rollback is honoured only for a successful
  * deploy that recorded an image. Any other row 409s `deploy_not_rollbackable`.

package/dist/commands/cloud/power.d.ts

@@ -1,3 +1,4 @@
 type PowerAction = "start" | "stop" | "restart";
 export declare function powerCommand(action: PowerAction, rawArgs: string[]): Promise<void>;
+export declare function isPowerAction(v: string | undefined): v is PowerAction;
 export {};

package/dist/commands/cloud/resources.d.ts

@@ -1,6 +1,6 @@
 export declare function statusCommand(rawArgs: string[]): Promise<void>;
 export declare function metricsCommand(rawArgs: string[]): Promise<void>;
 export declare function webhooksCommand(subcommand: string | undefined, rawArgs: string[]): Promise<void>;
-export declare function storageCommand(action: string | undefined, rawArgs: string[]): Promise<void>;
+export declare function storageCommand(rawArgs: string[]): Promise<void>;
 export declare function clustersCommand(rawArgs: string[]): Promise<void>;
 export declare function billingCommand(rawArgs: string[]): Promise<void>;

package/dist/commands/skills.d.ts

@@ -1 +1 @@
-export declare function skillsCommand(subcommand: string | undefined, rawArgs: string[]): Promise<void>;
+export declare function skillsCommand(subcommand: string | undefined, _args: 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,45 +23,28 @@ import { createRequire } from "module";
 * the rest of the CLI never has to hardcode a specific PM.
 */
 /**
-* 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.
+* Detect the package manager from the environment or the target directory.
 *
 * Detection order:
-* 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.
+* 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)
 */
 function detectPackageManager(targetDir) {
-	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";
+	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";
 	}
-	if (isPnpmAvailable()) return "pnpm";
-	return "npm";
+	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";
 }
 /** Build the command helpers for a given package manager. */
 function getPMCommands(pm) {
@@ -135,8 +118,7 @@ function getPMCommands(pm) {
 		runWorkspace: (workspace, script) => [
 			"pnpm",
 			"--filter",
-			`./${workspace}`,
-			"run",
+			workspace,
 			script
 		],
 		dlx: (pkg, args) => [
@@ -943,13 +925,6 @@ 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,
@@ -2477,43 +2452,22 @@ function installForAgent(agentKey, skills, projectDir) {
 	}
 	return count;
 }
-async function skillsCommand(subcommand, rawArgs) {
+async function skillsCommand(subcommand, _args) {
 	switch (subcommand) {
 		case "install":
-			await skillsInstall(rawArgs);
+			await skillsInstall();
 			break;
 		case "--help":
 		case void 0:
 			printSkillsHelp();
 			break;
 		default:
-			console.error(chalk.red(`Unknown skills subcommand: ${subcommand}`));
+			console.log(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(rawArgs = []) {
+async function skillsInstall() {
 	const projectDir = process.cwd();
 	let skillsDir;
 	try {
@@ -2527,14 +2481,8 @@ async function skillsInstall(rawArgs = []) {
 		console.error(`${chalk.red.bold("ERROR")} No skills found in ${skillsDir}`);
 		process.exit(1);
 	}
-	let agents = parseAgentFlags(rawArgs) ?? detectAgents(projectDir);
+	let agents = 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,
@@ -2576,15 +2524,8 @@ ${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
@@ -2616,16 +2557,9 @@ function loadEnv(projectRoot) {
 	}
 	return env;
 }
-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"}`;
+function resolveBaseUrl(env) {
+	const port = env.PORT || env.REBASE_PORT || "3001";
+	return env.REBASE_BASE_URL || `http://localhost:${port}`;
 }
 async function apiKeysCommand(subcommand, rawArgs) {
 	if (!subcommand || subcommand === "--help") {
@@ -2650,9 +2584,8 @@ async function apiKeysCommand(subcommand, rawArgs) {
 	}
 }
 async function listKeys(_rawArgs) {
-	const projectRoot = requireProjectRoot();
-	const env = loadEnv(projectRoot);
-	const baseUrl = resolveBaseUrl(env, projectRoot);
+	const env = loadEnv(requireProjectRoot());
+	const baseUrl = resolveBaseUrl(env);
 	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."));
@@ -2757,9 +2690,8 @@ async function createKey(rawArgs) {
 			expires_at = parsed.toISOString();
 		}
 	}
-	const projectRoot = requireProjectRoot();
-	const env = loadEnv(projectRoot);
-	const baseUrl = resolveBaseUrl(env, projectRoot);
+	const env = loadEnv(requireProjectRoot());
+	const baseUrl = resolveBaseUrl(env);
 	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."));
@@ -2816,9 +2748,8 @@ async function revokeKey(rawArgs) {
 		console.log(chalk.gray("  Usage: rebase api-keys revoke <key-id>"));
 		process.exit(1);
 	}
-	const projectRoot = requireProjectRoot();
-	const env = loadEnv(projectRoot);
-	const baseUrl = resolveBaseUrl(env, projectRoot);
+	const env = loadEnv(requireProjectRoot());
+	const baseUrl = resolveBaseUrl(env);
 	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."));
@@ -3287,18 +3218,13 @@ 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, env) {
+function run(cmd, cmdArgs, cwd) {
 	return new Promise((resolve, reject) => {
 		const child = spawn(cmd, cmdArgs, {
 			cwd,
-			env: env ? {
-				...process.env,
-				...env
-			} : void 0,
 			stdio: [
 				"ignore",
 				"ignore",
@@ -3328,7 +3254,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, { COPYFILE_DISABLE: "1" });
+		await run("tar", tarArgs, dir);
 	} catch (e) {
 		fail(`Failed to package source: ${e instanceof Error ? e.message : String(e)}`);
 	}
@@ -3338,7 +3264,6 @@ 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",
@@ -4318,8 +4243,6 @@ ${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() {
@@ -5227,10 +5150,7 @@ async function webhooksCommand(subcommand, rawArgs) {
 		reportError(e, "Webhook operation failed");
 	}
 }
-async function storageCommand(action, rawArgs) {
-	if (action === "create") return storageCreateCommand(rawArgs);
-	if (action === "attach") return storageAttachCommand(rawArgs);
-	if (action === "help") return printStorageHelp();
+async function storageCommand(rawArgs) {
 	const { client } = await requireClient(rawArgs);
 	const projectId = await requireProject(rawArgs, client);
 	try {
@@ -5255,107 +5175,6 @@ async function storageCommand(action, rawArgs) {
 		reportError(e, "Failed to list storage");
 	}
 }
-function printStorageHelp() {
-	console.log("");
-	console.log(chalk.bold("  rebase cloud storage"));
-	console.log("");
-	console.log("  " + chalk.blue.bold("storage") + "                   List this project's storage");
-	console.log("  " + chalk.blue.bold("storage create") + "            Provision platform-managed storage");
-	console.log("  " + chalk.blue.bold("storage attach") + "            Attach your own S3-compatible bucket");
-	console.log("");
-	console.log(chalk.gray("  attach options:"));
-	console.log(chalk.gray("    --bucket <name>          Bucket name (required)"));
-	console.log(chalk.gray("    --access-key-id <id>     Access key ID (required)"));
-	console.log(chalk.gray("    --secret-access-key <s>  Secret access key (required)"));
-	console.log(chalk.gray("    --endpoint <url>         S3 endpoint; omit for AWS"));
-	console.log(chalk.gray("    --region <region>        Region"));
-	console.log(chalk.gray("    --force-path-style       Required by MinIO and some gateways"));
-	console.log("");
-	console.log(chalk.gray("  Without either, a tenant falls back to the container filesystem and"));
-	console.log(chalk.gray("  loses uploaded files on its next restart."));
-	console.log("");
-}
-async function storageCreateCommand(rawArgs) {
-	const { client } = await requireClient(rawArgs);
-	const projectId = await requireProject(rawArgs, client);
-	try {
-		console.log("");
-		console.log(chalk.gray("  Provisioning managed storage — this creates a bucket and its credentials..."));
-		const res = await client.functions.invoke(`storage-provision/${encodeURIComponent(projectId)}`, void 0, { method: "POST" });
-		const info = res.data ?? res.data;
-		success(`Managed storage provisioned for ${displayProjectRef(rawArgs)}.`);
-		keyValues([
-			["Bucket", info.bucketName],
-			["Region", info.region],
-			["Endpoint", info.endpoint],
-			["Access key", info.accessKeyId]
-		]);
-		console.log("");
-		console.log(chalk.gray("  The secret key is stored encrypted and injected at deploy time; it is not displayed."));
-		console.log(chalk.gray("  Redeploy for the tenant to pick it up:  ") + chalk.bold("rebase cloud deploy"));
-		console.log("");
-	} catch (e) {
-		reportError(e, "Failed to provision managed storage");
-	}
-}
-async function storageAttachCommand(rawArgs) {
-	const parsed = arg({
-		"--bucket": String,
-		"--access-key-id": String,
-		"--secret-access-key": String,
-		"--endpoint": String,
-		"--region": String,
-		"--force-path-style": Boolean
-	}, {
-		argv: rawArgs.slice(3),
-		permissive: true
-	});
-	const bucket = parsed["--bucket"];
-	const accessKeyId = parsed["--access-key-id"];
-	const secretAccessKey = parsed["--secret-access-key"];
-	const missing = [
-		!bucket && "--bucket",
-		!accessKeyId && "--access-key-id",
-		!secretAccessKey && "--secret-access-key"
-	].filter(Boolean);
-	if (missing.length > 0) fail(`Missing ${missing.join(", ")}.`, "A bucket without credentials cannot be used, and would be stored as though it could. Run `rebase cloud storage --help` for the full list.");
-	const { client } = await requireClient(rawArgs);
-	const projectId = await requireProject(rawArgs, client);
-	try {
-		const existing = (await client.data.collection("storages").find({
-			where: { project: ["==", projectId] },
-			limit: 1
-		})).data[0];
-		const row = {
-			project: projectId,
-			type: "byos",
-			status: "active",
-			s3Bucket: bucket,
-			s3AccessKeyId: accessKeyId,
-			s3SecretAccessKey: secretAccessKey,
-			bucketName: bucket
-		};
-		if (parsed["--endpoint"]) row.s3Endpoint = parsed["--endpoint"];
-		if (parsed["--region"]) {
-			row.s3Region = parsed["--region"];
-			row.region = parsed["--region"];
-		}
-		if (parsed["--force-path-style"]) row.s3ForcePathStyle = true;
-		if (existing?.id) await client.data.collection("storages").update(String(existing.id), row);
-		else await client.data.collection("storages").create(row);
-		success(`Storage attached to ${displayProjectRef(rawArgs)}.`);
-		keyValues([
-			["Bucket", bucket],
-			["Endpoint", parsed["--endpoint"] ?? "AWS S3"],
-			["Region", parsed["--region"] ?? "(default)"]
-		]);
-		console.log("");
-		console.log(chalk.gray("  Redeploy for the tenant to pick it up:  ") + chalk.bold("rebase cloud deploy"));
-		console.log("");
-	} catch (e) {
-		reportError(e, "Failed to attach storage");
-	}
-}
 async function clustersCommand(rawArgs) {
 	const { client } = await requireClient(rawArgs);
 	try {
@@ -5573,7 +5392,7 @@ async function cloudCommand(subcommand, rawArgs) {
 			await webhooksCommand(action, rawArgs);
 			break;
 		case "storage":
-			await storageCommand(action, rawArgs);
+			await storageCommand(rawArgs);
 			break;
 		case "clusters":
 			await clustersCommand(rawArgs);
@@ -5676,8 +5495,6 @@ ${chalk.green.bold("Databases")}
 ${chalk.green.bold("Other resources")}
   ${chalk.blue.bold("webhooks list|create|delete")}
   ${chalk.blue.bold("storage")}                 List storage buckets
-  ${chalk.blue.bold("storage create")}          Provision platform-managed storage
-  ${chalk.blue.bold("storage attach")}          Attach your own S3-compatible bucket
   ${chalk.blue.bold("clusters")}                List compute clusters
   ${chalk.blue.bold("billing setup")}           Attach a card to the org ${chalk.gray("(one-time, opens browser)")}
   ${chalk.blue.bold("billing")}                 Show billing account + card on file
@@ -5786,10 +5603,9 @@ async function entry(args) {
 			await cloudCommand(effectiveSubcommand, args);
 			break;
 		default:
-			console.error(chalk.red(`Unknown command: ${command}`));
+			console.log(chalk.red(`Unknown command: ${command}`));
 			console.log("");
 			printHelp();
-			process.exit(1);
 	}
 }
 function printHelp() {
@@ -5849,6 +5665,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, isPnpmAvailable, 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, requireBackendDir, requireProjectRoot, resolveLocalBin, resolvePluginCliScript, resolveTsx, schemaCommand, startCommand, validateProjectName, validateTsxInstallation };
 
 //# sourceMappingURL=index.es.js.map