@rebasepro/cli 0.10.1-canary.18115ba → 0.10.1-canary.811b3da

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

@@ -100,16 +100,6 @@ 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.
- *
- * Indented, because the overwhelmingly common reader is a person or an agent
- * looking at a terminal — JSON mode is entered automatically whenever stdout is
- * not a TTY, so `rebase cloud deployments list` piped anywhere at all produced
- * a project's entire deployment history as one unwrapped line. `JSON.parse`
- * does not care about the whitespace; everything else does.
- */
-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

@@ -18,10 +18,6 @@ export interface DeploymentRow {
     triggered_by_user_id?: string;
     gitCommitHash?: string;
     gitCommitMessage?: string;
-    deployMessage?: string;
-    deploy_message?: string;
-    frameworkVersion?: string;
-    framework_version?: string;
 }
 /**
  * The backend's rule EXACTLY: a rollback is honoured only for a successful
@@ -37,18 +33,6 @@ export declare function triggerInfo(dep: DeploymentRow): {
 };
 /** Shape one deployment row into the stable JSON view the CLI publishes. */
 export declare function deploymentView(dep: DeploymentRow): Record<string, unknown>;
-/**
- * Rows shown when `--limit` is not given.
- *
- * History is unbounded and grows one row per deploy, so "all of it" is the
- * wrong default in both directions: a wall of near-identical lines in a
- * terminal, and — since JSON mode is entered automatically for any non-TTY
- * stdout — a project's entire history dumped at anything that pipes the
- * command. Recent deploys are what the question is almost always about.
- */
-export declare const DEFAULT_DEPLOYMENTS_LIMIT = 20;
-/** `--limit N`, bounded. A garbage value is a refusal, never a silent default. */
-export declare function parseDeploymentsLimit(raw: number | undefined): number;
 export declare function deploymentsListCommand(rawArgs: string[]): Promise<void>;
 export declare function rollbackCommand(rawArgs: string[]): Promise<void>;
 export declare function cancelCommand(rawArgs: string[]): Promise<void>;

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

@@ -4,5 +4,3 @@ export declare function parseEnvAssignment(operands: string[]): {
     key: string;
     value: string;
 } | null;
-/** The prefix that makes `key` a build-time variable, or undefined. */
-export declare function buildTimeEnvPrefix(key: string): string | undefined;

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

@@ -1,44 +1,6 @@
-/** The control plane's verdict on what a tenant's uploads actually do. */
-interface StorageState {
-    effective?: {
-        kind?: string;
-        summary?: string;
-        storageType?: string;
-        missing?: string[];
-    };
-    source?: string;
-    configured?: string;
-    overridden?: boolean;
-}
-/**
- * One line describing this project's storage — or `undefined` when the control
- * plane could not be asked, which prints as a blank rather than a guess.
- *
- * `status` used to render the `storages` row and nothing else, so a project
- * whose bucket is configured through its own `STORAGE_TYPE`/`S3_*` variables —
- * the supported path, and the one `mergeStorageEnv` deliberately lets WIN over
- * the row — was reported as `Storage: none` while its pod logged `Initialized
- * storage backends count: 1` against a live bucket. Storage is the thing an app
- * refuses to boot without, so that false negative sends someone off to
- * provision a bucket they already have. The row is not the answer; the tenant's
- * resolved environment is, and the control plane computes it with the same two
- * functions the build log uses.
- */
-export declare function describeStorageState(state: StorageState | undefined): string | undefined;
-/**
- * One line describing the database.
- *
- * `connectionStatus` is written `"untested"` at creation and only ever changed
- * by `rebase cloud db test`, so `managed (untested)` was reporting the absence
- * of a manual test as though it were the database's condition — on a project
- * that had just deployed against it. A never-tested database says only its
- * type; the verdict appears once there is one.
- */
-export declare function describeDatabaseState(db: Record<string, unknown> | undefined): string | undefined;
 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 clustersCommand(rawArgs: string[]): Promise<void>;
 export declare function billingCommand(rawArgs: string[]): Promise<void>;
-export {};

package/dist/index.es.js

@@ -23,61 +23,21 @@ import { createRequire } from "module";
 * the rest of the CLI never has to hardcode a specific PM.
 */
 /**
-* How long to wait for `pnpm --version` before giving up on the probe.
-*
-* `pnpm --version` is a cold Node start, and on a machine that is busy — a
-* parallel install, a full test run — it routinely takes seconds. Measured at
-* 630ms, 990ms and 4293ms on three consecutive runs of one developer laptop
-* under load, so the previous 3s budget was inside the normal spread rather
-* than safely outside it.
-*/
-var PNPM_PROBE_TIMEOUT_MS = 5e3;
-/** Memoised result of the probe. pnpm cannot appear or vanish mid-process. */
-var cachedPnpmAvailable;
-/**
-* Decide availability from a `spawnSync` outcome.
-*
-* Split out from the spawn itself so the decision is testable without starting
-* a process — which is what made the old test load-sensitive and occasionally
-* red for reasons that had nothing to do with the code under test.
-*
-* The three outcomes are distinguishable, and the old code conflated two of
-* them by asking only `status === 0`:
-*
-*   not installed   status null, signal null,    error.code ENOENT
-*   timed out       status null, signal SIGTERM, error.code ETIMEDOUT
-*   broken install  status non-zero, no error
-*/
-function pnpmAvailabilityFromProbe(res) {
-	const code = res.error?.code;
-	if (code === "ENOENT") return false;
-	if (code === "ETIMEDOUT" || res.signal) return true;
-	if (res.error) return false;
-	return res.status === 0;
-}
-/**
 * Whether pnpm is runnable on this machine.
 *
 * Used to decide whether a fresh project can be scaffolded with pnpm. Kept
-* cheap and non-interactive (bounded timeout, output discarded) so it never
-* hangs detection if a corepack shim misbehaves, and memoised so that repeated
-* detection in one CLI run costs one process rather than one per call.
+* cheap and non-interactive (short timeout, output discarded) so it never
+* hangs detection if a corepack shim misbehaves.
 */
 function isPnpmAvailable() {
-	if (cachedPnpmAvailable !== void 0) return cachedPnpmAvailable;
 	try {
-		cachedPnpmAvailable = pnpmAvailabilityFromProbe(spawnSync("pnpm", ["--version"], {
+		return spawnSync("pnpm", ["--version"], {
 			stdio: "ignore",
-			timeout: PNPM_PROBE_TIMEOUT_MS
-		}));
+			timeout: 3e3
+		}).status === 0;
 	} catch {
-		cachedPnpmAvailable = false;
+		return false;
 	}
-	return cachedPnpmAvailable;
-}
-/** Forget the memoised probe. For tests; nothing in a CLI run needs it. */
-function resetPnpmAvailabilityCache() {
-	cachedPnpmAvailable = void 0;
 }
 /**
 * Detect the package manager for a Rebase project.
@@ -676,17 +636,9 @@ var ANSI_RE = /\[[0-9;]*m/g;
 function stripAnsi(s) {
 	return s.replace(ANSI_RE, "");
 }
-/**
-* Write one JSON value to stdout, followed by a newline.
-*
-* Indented, because the overwhelmingly common reader is a person or an agent
-* looking at a terminal — JSON mode is entered automatically whenever stdout is
-* not a TTY, so `rebase cloud deployments list` piped anywhere at all produced
-* a project's entire deployment history as one unwrapped line. `JSON.parse`
-* does not care about the whitespace; everything else does.
-*/
+/** Write one JSON value to stdout, followed by a newline. */
 function printJson(value) {
-	process.stdout.write(JSON.stringify(value, null, 2) + "\n");
+	process.stdout.write(JSON.stringify(value) + "\n");
 }
 /**
 * The one output primitive every new command uses: in JSON mode emit `json`
@@ -3469,35 +3421,6 @@ async function createSourceTarball(sourceDir) {
 	}
 	return tarPath;
 }
-/**
-* The `@rebasepro/*` version this source directory actually resolves.
-*
-* Recorded on the deployment so a row in Deployment History says which
-* framework build shipped. Nothing else on the platform knows: an app that
-* links the framework locally pins it at package time, and a silent bump is
-* invisible afterwards — it has already cost one debugging session.
-*
-* `@rebasepro/server` first, because that is what the deployed backend runs;
-* `@rebasepro/client` is the fallback for a frontend-only bundle. Resolution is
-* a plain walk up from the source directory rather than `require.resolve`,
-* which would answer for the CLI's own install tree instead of the app's.
-*
-* Best effort by construction: a version that cannot be read is simply not
-* recorded. Nothing about a deploy should fail over a bookkeeping string.
-*/
-function resolveFrameworkVersion(sourceDir) {
-	let dir = path.resolve(sourceDir);
-	for (;;) {
-		for (const pkg of ["@rebasepro/server", "@rebasepro/client"]) try {
-			const manifest = path.join(dir, "node_modules", ...pkg.split("/"), "package.json");
-			const version = JSON.parse(fs.readFileSync(manifest, "utf8")).version;
-			if (typeof version === "string" && version.trim() !== "") return version.trim();
-		} catch {}
-		const parent = path.dirname(dir);
-		if (parent === dir) return void 0;
-		dir = parent;
-	}
-}
 /** Upload a build-context tarball; returns the opaque `source` ref for deploy. */
 async function uploadSource(url, token, projectId, tarPath) {
 	const bytes = fs.readFileSync(tarPath);
@@ -3523,9 +3446,7 @@ async function uploadSource(url, token, projectId, tarPath) {
 async function deployCommand(rawArgs, projectRef) {
 	const args = arg({
 		"--no-follow": Boolean,
-		"--source": String,
-		"--message": String,
-		"-m": "--message"
+		"--source": String
 	}, {
 		argv: rawArgs.slice(2),
 		permissive: true
@@ -3545,87 +3466,32 @@ async function deployCommand(rawArgs, projectRef) {
 	}
 	console.log("");
 	console.log(`  🚀 Triggering deployment for project ${chalk.bold(projectRef)}${source ? " from uploaded source" : ""}...`);
-	const body = { projectId };
-	if (source) body.source = source;
-	if (args["--message"]) body.message = args["--message"];
-	body.client = "cli";
-	const frameworkVersion = resolveFrameworkVersion(args["--source"] ?? process.cwd());
-	if (frameworkVersion) body.frameworkVersion = frameworkVersion;
-	let triggered;
+	let deploymentId;
 	try {
-		const res = await client.functions.invoke("deploy", body);
+		const res = await client.functions.invoke("deploy", source ? {
+			projectId,
+			source
+		} : { projectId });
 		if (!res?.deployment?.id) fail("Control plane did not return a deployment id.");
-		triggered = {
-			deploymentId: String(res.deployment.id),
-			deduplicated: res.deduplicated === true
-		};
+		deploymentId = String(res.deployment.id);
 	} catch (e) {
-		triggered = resolveTriggerFailure(e);
+		const err = e;
+		if (err?.status === 409) fail("A deployment is already in progress for this project.");
+		if (err?.status === 402) fail(err.message || "Payment required before deploying.", "Attach a card once with `rebase cloud billing setup`, then deploy again.");
+		reportError(e, "Failed to trigger deployment");
 	}
-	const { deploymentId, deduplicated } = triggered;
-	if (!isJsonMode()) console.log(chalk.gray(deduplicated ? `  Deployment ${deploymentId} is already running — following it.` : `  Deployment ${deploymentId} created.${frameworkVersion ? `  (@rebasepro/* ${frameworkVersion})` : ""}`));
+	console.log(chalk.gray(`  Deployment ${deploymentId} created.`));
 	if (args["--no-follow"]) {
-		emit(() => {
-			console.log(chalk.gray("  Not following logs (--no-follow). Check status with `rebase cloud logs`."));
-			console.log("");
-		}, {
-			deploymentId,
-			deduplicated,
-			frameworkVersion: frameworkVersion ?? null,
-			following: false
-		});
-		return;
-	}
-	if (!isJsonMode()) {
-		console.log(chalk.gray("  Streaming build logs (Ctrl-C to stop watching — the build keeps running):"));
+		console.log(chalk.gray("  Not following logs (--no-follow). Check status with `rebase cloud logs`."));
 		console.log("");
+		return;
 	}
-	const status = await streamBuildLogs(client, deploymentId, { quiet: isJsonMode() });
-	emit(() => {}, {
-		deploymentId,
-		deduplicated,
-		frameworkVersion: frameworkVersion ?? null,
-		following: true,
-		status
-	});
-}
-/**
-* Turn a failed trigger into either a deployment to follow, or an exit.
-*
-* The 409 is the interesting one. A deploy trigger can reach the control plane
-* twice without anybody asking twice — the SDK transport replays a request once
-* after refreshing an expired token, and any lost response has the same effect
-* — so "a deployment is already in progress" was routinely describing the
-* deployment this very command had just created. With no id in the message the
-* only available reading was "someone else is deploying, back off", and the
-* build stream was lost either way.
-*
-* So: if the control plane says the blocking deployment is ours, we attach to
-* it. If it is not ours, we still name it, because "which one, since when, from
-* where" is the difference between an actionable refusal and a dead end.
-*/
-function resolveTriggerFailure(e) {
-	const err = e;
-	if (err?.status === 409) {
-		const blocking = err.details?.deployment;
-		if (blocking?.id && blocking.mine) return {
-			deploymentId: String(blocking.id),
-			deduplicated: true
-		};
-		fail(blocking?.id ? `Deployment ${blocking.id} is already in progress for this project${blocking.triggerSource && blocking.triggerSource !== "unknown" ? `, triggered from the ${blocking.triggerSource}` : ""}${blocking.createdAt ? ` at ${fmtDate(blocking.createdAt)}` : ""}.` : "A deployment is already in progress for this project.", blocking?.id ? `Follow it with \`rebase cloud logs -f\`, or stop it with \`rebase cloud cancel ${blocking.id}\`.` : "Follow it with `rebase cloud logs -f`.", "deploy_in_progress");
-	}
-	if (err?.status === 402) fail(err.message || "Payment required before deploying.", "Attach a card once with `rebase cloud billing setup`, then deploy again.", "payment_required");
-	reportError(e, "Failed to trigger deployment");
+	console.log(chalk.gray("  Streaming build logs (Ctrl-C to stop watching — the build keeps running):"));
+	console.log("");
+	await streamBuildLogs(client, deploymentId);
 }
-/**
-* Poll a deployment record and print new log output as it arrives. Returns the
-* terminal status; a non-success still exits non-zero, as it always has.
-*
-* `quiet` follows without printing — JSON mode, where the log stream would
-* corrupt the one object the caller is parsing.
-*/
-async function streamBuildLogs(client, deploymentId, opts = {}) {
-	const quiet = opts.quiet === true;
+/** Poll a deployment record and print new log output as it arrives. */
+async function streamBuildLogs(client, deploymentId) {
 	let printed = 0;
 	const started = Date.now();
 	for (;;) {
@@ -3635,37 +3501,26 @@ async function streamBuildLogs(client, deploymentId, opts = {}) {
 		} catch (e) {
 			reportError(e, "Failed to read deployment status");
 		}
-		if (!dep) fail(`Deployment ${deploymentId} disappeared.`, void 0, "not_found");
+		if (!dep) fail(`Deployment ${deploymentId} disappeared.`);
 		const logs = dep.logs ?? "";
-		if (!quiet && logs.length > printed) process.stdout.write(logs.slice(printed));
-		printed = logs.length;
+		if (logs.length > printed) {
+			process.stdout.write(logs.slice(printed));
+			printed = logs.length;
+		}
 		if (dep.status && dep.status !== "deploying") {
-			if (dep.status !== "success") {
-				if (quiet) {
-					printJson({ error: {
-						message: `Deployment ${deploymentId} ${dep.status}.`,
-						code: "deploy_failed",
-						status: null,
-						deploymentId,
-						logs
-					} });
-					process.exit(1);
-				}
-				console.log("");
+			console.log("");
+			if (dep.status === "success") console.log(chalk.bold.green("  ✓ Deployment succeeded"));
+			else {
 				console.log(chalk.bold.red(`  ✗ Deployment ${dep.status}`));
 				console.log("");
 				process.exit(1);
 			}
-			if (!quiet) {
-				console.log("");
-				console.log(chalk.bold.green("  ✓ Deployment succeeded"));
-				console.log("");
-			}
-			return dep.status;
+			console.log("");
+			return;
 		}
 		if (Date.now() - started > POLL_TIMEOUT_MS) {
-			if (!quiet) console.log("");
-			fail("Timed out waiting for the build to finish.", "The deployment may still be running — check `rebase cloud logs`.", "timeout");
+			console.log("");
+			fail("Timed out waiting for the build to finish.", "The deployment may still be running — check `rebase cloud logs`.");
 		}
 		await sleep(POLL_INTERVAL_MS);
 	}
@@ -4378,35 +4233,9 @@ function parseEnvAssignment(operands) {
 		value: operands[1] ?? ""
 	};
 }
-/**
-* Prefixes whose variables are read by a BUNDLER at build time, not by the
-* process at run time.
-*
-* These are the ones this command cannot deliver. A project's environment is
-* applied at rollout — after Kaniko has already built the image — so a
-* `VITE_API_URL` set here is present in the running container and absent from
-* the JavaScript that was compiled minutes earlier. Nothing fails: the variable
-* exists, the deploy succeeds, and the bundle carries `undefined` where the
-* value should be. The bug then presents in the browser as missing
-* configuration, which is several steps away from the cause.
-*
-* `import.meta.env` inlining is Vite's; `NEXT_PUBLIC_`/`PUBLIC_`/`REACT_APP_`
-* are the same contract in Next, Astro/SvelteKit and CRA.
-*/
-var BUILD_TIME_ENV_PREFIXES = [
-	"VITE_",
-	"NEXT_PUBLIC_",
-	"PUBLIC_",
-	"REACT_APP_"
-];
-/** The prefix that makes `key` a build-time variable, or undefined. */
-function buildTimeEnvPrefix(key) {
-	return BUILD_TIME_ENV_PREFIXES.find((prefix) => key.toUpperCase().startsWith(prefix));
-}
 async function setEnv(rawArgs) {
 	const args = arg({
 		"--secret": Boolean,
-		"--force": Boolean,
 		"--project": String,
 		"-p": "--project"
 	}, {
@@ -4418,8 +4247,6 @@ async function setEnv(rawArgs) {
 	displayProjectRef(rawArgs);
 	const parsed = parseEnvAssignment(cloudPositionals(rawArgs).slice(2));
 	if (!parsed || !parsed.key) fail("Usage: rebase cloud env set KEY=VALUE [--secret]", void 0, "usage");
-	const buildTimePrefix = buildTimeEnvPrefix(parsed.key);
-	if (buildTimePrefix && !args["--force"]) fail(`${parsed.key} is read by your bundler at BUILD time, and project variables are applied at rollout — after the image is built. Setting it here would not reach the bundle.`, `Put ${buildTimePrefix}* variables in the source you deploy (a committed .env, or your build config), then \`rebase cloud deploy\`. Pass --force if your build genuinely reads this at run time.`, "build_time_variable");
 	const body = {
 		key: parsed.key,
 		value: parsed.value
@@ -4576,13 +4403,10 @@ ${chalk.green.bold("Commands")}
 
 ${chalk.green.bold("Options")}
   ${chalk.blue("--secret")}                  Mark a variable write-only ${chalk.gray("(set)")}
-  ${chalk.blue("--force")}                   Set a build-time key anyway ${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.")}
-${chalk.gray("VITE_* / NEXT_PUBLIC_* / PUBLIC_* / REACT_APP_* are read by your bundler at BUILD time;")}
-${chalk.gray("these are applied at rollout, after the image is built, so they never reach the bundle.")}
 `);
 }
 function printEnvHelpJson() {
@@ -5178,8 +5002,6 @@ function deploymentView(dep) {
 		isRollback: str(dep, "rollbackOf", "rollback_of") !== null,
 		rollbackable: isRollbackable(dep),
 		trigger: triggerInfo(dep),
-		message: str(dep, "deployMessage", "deploy_message"),
-		frameworkVersion: str(dep, "frameworkVersion", "framework_version"),
 		commit: {
 			hash: str(dep, "gitCommitHash", "gitCommitHash"),
 			message: str(dep, "gitCommitMessage", "gitCommitMessage")
@@ -5193,31 +5015,12 @@ async function fetchDeployments(client, projectId, limit = 100) {
 		limit
 	})).data;
 }
-/** Hard ceiling on `--limit`, matching the backend's own page size. */
-var MAX_DEPLOYMENTS_LIMIT = 100;
-/** `--limit N`, bounded. A garbage value is a refusal, never a silent default. */
-function parseDeploymentsLimit(raw) {
-	if (raw === void 0) return 20;
-	if (!Number.isInteger(raw) || raw < 1 || raw > MAX_DEPLOYMENTS_LIMIT) fail(`--limit must be a whole number between 1 and ${MAX_DEPLOYMENTS_LIMIT}.`, void 0, "usage");
-	return raw;
-}
 async function deploymentsListCommand(rawArgs) {
-	const args = arg({
-		"--limit": Number,
-		"--all": Boolean,
-		"--project": String,
-		"-p": "--project"
-	}, {
-		argv: rawArgs.slice(2),
-		permissive: true
-	});
-	const limit = args["--all"] ? MAX_DEPLOYMENTS_LIMIT : parseDeploymentsLimit(args["--limit"]);
 	const { client } = await requireClient(rawArgs);
 	const projectId = await requireProject(rawArgs, client);
 	const projectRef = displayProjectRef(rawArgs);
 	try {
-		const views = (await fetchDeployments(client, projectId, limit)).map(deploymentView);
-		const truncated = views.length === limit;
+		const views = (await fetchDeployments(client, projectId)).map(deploymentView);
 		emit(() => {
 			console.log("");
 			console.log(chalk.bold(`  🚀 Deployments — project ${projectRef}`));
@@ -5232,18 +5035,10 @@ async function deploymentsListCommand(rawArgs) {
 				const trig = v.trigger.source;
 				const roll = v.rollbackable ? chalk.green(" ↺ rollbackable") : "";
 				console.log(`  ${chalk.gray(`[${v.id}]`)} ${colorStatus(v.status)}  ${chalk.gray(String(v.createdAt ?? "—"))}  ${dur}  ${chalk.gray(trig)}${roll}`);
-				const label = [v.message, v.frameworkVersion ? `@rebasepro/* ${v.frameworkVersion}` : null].filter(Boolean).join("  ·  ");
-				if (label) console.log(`      ${chalk.gray(label)}`);
-			}
-			if (truncated) {
-				console.log("");
-				console.log(chalk.gray(`  Showing the ${limit} most recent. Use \`--limit N\` or \`--all\` for more.`));
 			}
 			console.log("");
 		}, {
 			projectId,
-			limit,
-			truncated,
 			deployments: views
 		});
 	} catch (e) {
@@ -6143,95 +5938,29 @@ ${chalk.gray("so it works in a deploy script. To restart a workload, use `rebase
 * `rebase cloud` resource subcommands: status, metrics, webhooks, storage,
 * clusters, billing.
 */
-/**
-* One line describing this project's storage — or `undefined` when the control
-* plane could not be asked, which prints as a blank rather than a guess.
-*
-* `status` used to render the `storages` row and nothing else, so a project
-* whose bucket is configured through its own `STORAGE_TYPE`/`S3_*` variables —
-* the supported path, and the one `mergeStorageEnv` deliberately lets WIN over
-* the row — was reported as `Storage: none` while its pod logged `Initialized
-* storage backends count: 1` against a live bucket. Storage is the thing an app
-* refuses to boot without, so that false negative sends someone off to
-* provision a bucket they already have. The row is not the answer; the tenant's
-* resolved environment is, and the control plane computes it with the same two
-* functions the build log uses.
-*/
-function describeStorageState(state) {
-	const verdict = state?.effective;
-	if (!verdict?.kind) return void 0;
-	const via = state?.overridden ? chalk.gray(" · from env vars") : "";
-	switch (verdict.kind) {
-		case "durable": return `${chalk.green("durable")}${verdict.summary ? ` · ${verdict.summary}` : ""}${via}`;
-		case "ephemeral": return `${chalk.yellow("ephemeral")} ${chalk.gray("· uploads are lost on restart")}`;
-		case "incomplete": return `${chalk.red("incomplete")} ${chalk.gray(`· missing ${(verdict.missing ?? []).join(", ")}`)}`;
-		case "unrecognized": return `${chalk.red("unrecognized")} ${chalk.gray(`· STORAGE_TYPE=${verdict.storageType ?? "?"}`)}`;
-		default: return;
-	}
-}
-/**
-* One line describing the database.
-*
-* `connectionStatus` is written `"untested"` at creation and only ever changed
-* by `rebase cloud db test`, so `managed (untested)` was reporting the absence
-* of a manual test as though it were the database's condition — on a project
-* that had just deployed against it. A never-tested database says only its
-* type; the verdict appears once there is one.
-*/
-function describeDatabaseState(db) {
-	if (!db) return void 0;
-	const type = typeof db.type === "string" ? db.type : "database";
-	const connection = db.connectionStatus;
-	if (connection === "connected" || connection === "failed") return `${type} (${colorStatus(connection)})`;
-	return `${type} ${chalk.gray("· not tested (`rebase cloud db test`)")}`;
-}
 async function statusCommand(rawArgs) {
 	const { client, url } = await requireClient(rawArgs);
 	const projectId = await requireProject(rawArgs, client);
 	try {
 		const project = await client.data.collection("projects").findById(projectId);
-		if (!project) fail(`Project ${displayProjectRef(rawArgs)} not found.`, void 0, "not_found");
+		if (!project) fail(`Project ${displayProjectRef(rawArgs)} not found.`);
 		const [db, storage, deploy, baseDomain] = await Promise.all([
 			firstRow(client, "databases", projectId),
-			client.functions.invoke("storage-provision", void 0, {
-				method: "GET",
-				path: projectId
-			}).catch(() => void 0),
+			firstRow(client, "storages", projectId),
 			latestDeployment(client, projectId),
 			fetchTenantBaseDomain(client, url)
 		]);
-		const storageLine = describeStorageState(storage);
-		const databaseLine = describeDatabaseState(db);
-		emit(() => {
-			console.log("");
-			console.log(`  ${chalk.bold(project.name ?? project.subdomain ?? "")} ${chalk.gray(`[${project.subdomain ?? displayProjectRef(rawArgs)}]`)} ${colorStatus(project.status)}`);
-			console.log("");
-			keyValues([
-				["URL", projectHost(project, baseDomain)],
-				["Branch", project.gitBranch],
-				["Last deploy", deploy ? `${colorStatus(deploy.status)} · ${fmtDate(deploy.createdAt)}` : "never"],
-				["Database", databaseLine],
-				["Storage", storageLine]
-			]);
-			console.log("");
-		}, {
-			projectId: String(project.id),
-			name: project.name ?? null,
-			subdomain: project.subdomain ?? null,
-			status: project.status ?? null,
-			url: projectHost(project, baseDomain) ?? null,
-			branch: project.gitBranch ?? null,
-			lastDeploy: deploy ? {
-				id: String(deploy.id),
-				status: deploy.status ?? null,
-				createdAt: deploy.createdAt ?? null
-			} : null,
-			database: db ? {
-				type: db.type ?? null,
-				connectionStatus: db.connectionStatus ?? null
-			} : null,
-			storage: storage ?? null
-		});
+		console.log("");
+		console.log(`  ${chalk.bold(project.name ?? project.subdomain ?? "")} ${chalk.gray(`[${project.subdomain ?? displayProjectRef(rawArgs)}]`)} ${colorStatus(project.status)}`);
+		console.log("");
+		keyValues([
+			["URL", projectHost(project, baseDomain)],
+			["Branch", project.gitBranch],
+			["Last deploy", deploy ? `${colorStatus(deploy.status)} · ${fmtDate(deploy.createdAt)}` : "never"],
+			["Database", db ? `${db.type} (${colorStatus(db.connectionStatus)})` : "none"],
+			["Storage", storage ? `${storage.type} (${colorStatus(storage.status)})` : "none"]
+		]);
+		console.log("");
 	} catch (e) {
 		reportError(e, "Failed to load status");
 	}
@@ -6742,9 +6471,9 @@ ${chalk.green.bold("Projects")}
   ${chalk.blue.bold("projects delete")} ${chalk.gray("[id]")}    Delete a project
 
 ${chalk.green.bold("Deploy & observe")}
-  ${chalk.blue.bold("deploy")} ${chalk.gray("[--source .] [-m msg]")}  Deploy the linked project + stream build logs
+  ${chalk.blue.bold("deploy")} ${chalk.gray("[--source .]")}     Deploy the linked project + stream build logs
   ${chalk.blue.bold("logs")} ${chalk.gray("[--runtime] [-f]")}   Show build (or runtime) logs
-  ${chalk.blue.bold("deployments list")} ${chalk.gray("[--limit N|--all]")}  Deployment history ${chalk.gray("(status, duration, trigger)")}
+  ${chalk.blue.bold("deployments list")}        Deployment history ${chalk.gray("(status, duration, trigger)")}
   ${chalk.blue.bold("rollback")} ${chalk.gray("[id] [-y]")}       Roll back to a successful deploy
   ${chalk.blue.bold("cancel")} ${chalk.gray("[-y]")}             Cancel the in-flight build
   ${chalk.blue.bold("start|stop|restart")} ${chalk.gray("[-y]")}  Power ops ${chalk.gray("(stop/restart need -y)")}
@@ -6943,6 +6672,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, formatCdTarget, generateSdkCommand, getActiveBackendPlugin, getPMCommands, isPnpmAvailable, pnpmAvailabilityFromProbe, printInitHelp, requireBackendDir, requireProjectRoot, resetPnpmAvailabilityCache, resolveLocalBin, resolvePluginCliScript, resolveTsx, schemaCommand, startCommand, validateProjectName, validateTsxInstallation };
+export { authCommand, buildCommand, buildInitQuestions, cloudCommand, configureEnvFile, createRebaseApp, dbCommand, detectPackageManager, devCommand, doctorCommand, entry, findBackendDir, findEnvFile, findFrontendDir, findProjectRoot, formatCdTarget, generateSdkCommand, getActiveBackendPlugin, getPMCommands, isPnpmAvailable, printInitHelp, requireBackendDir, requireProjectRoot, resolveLocalBin, resolvePluginCliScript, resolveTsx, schemaCommand, startCommand, validateProjectName, validateTsxInstallation };
 
 //# sourceMappingURL=index.es.js.map