@rebasepro/cli 0.10.0 → 0.10.1-canary.18115ba

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

@@ -100,6 +100,16 @@ 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,6 +18,10 @@ 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
@@ -33,6 +37,18 @@ 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,3 +4,5 @@ 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,6 +1,44 @@
+/** 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,21 +23,61 @@ 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 (short timeout, output discarded) so it never
-* hangs detection if a corepack shim misbehaves.
+* 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.
 */
 function isPnpmAvailable() {
+	if (cachedPnpmAvailable !== void 0) return cachedPnpmAvailable;
 	try {
-		return spawnSync("pnpm", ["--version"], {
+		cachedPnpmAvailable = pnpmAvailabilityFromProbe(spawnSync("pnpm", ["--version"], {
 			stdio: "ignore",
-			timeout: 3e3
-		}).status === 0;
+			timeout: PNPM_PROBE_TIMEOUT_MS
+		}));
 	} catch {
-		return false;
+		cachedPnpmAvailable = 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.
@@ -636,9 +676,17 @@ 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. */
+/**
+* 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.
+*/
 function printJson(value) {
-	process.stdout.write(JSON.stringify(value) + "\n");
+	process.stdout.write(JSON.stringify(value, null, 2) + "\n");
 }
 /**
 * The one output primitive every new command uses: in JSON mode emit `json`
@@ -3421,6 +3469,35 @@ 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);
@@ -3446,7 +3523,9 @@ async function uploadSource(url, token, projectId, tarPath) {
 async function deployCommand(rawArgs, projectRef) {
 	const args = arg({
 		"--no-follow": Boolean,
-		"--source": String
+		"--source": String,
+		"--message": String,
+		"-m": "--message"
 	}, {
 		argv: rawArgs.slice(2),
 		permissive: true
@@ -3466,32 +3545,87 @@ async function deployCommand(rawArgs, projectRef) {
 	}
 	console.log("");
 	console.log(`  🚀 Triggering deployment for project ${chalk.bold(projectRef)}${source ? " from uploaded source" : ""}...`);
-	let deploymentId;
+	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;
 	try {
-		const res = await client.functions.invoke("deploy", source ? {
-			projectId,
-			source
-		} : { projectId });
+		const res = await client.functions.invoke("deploy", body);
 		if (!res?.deployment?.id) fail("Control plane did not return a deployment id.");
-		deploymentId = String(res.deployment.id);
+		triggered = {
+			deploymentId: String(res.deployment.id),
+			deduplicated: res.deduplicated === true
+		};
 	} catch (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");
+		triggered = resolveTriggerFailure(e);
 	}
-	console.log(chalk.gray(`  Deployment ${deploymentId} created.`));
+	const { deploymentId, deduplicated } = triggered;
+	if (!isJsonMode()) console.log(chalk.gray(deduplicated ? `  Deployment ${deploymentId} is already running — following it.` : `  Deployment ${deploymentId} created.${frameworkVersion ? `  (@rebasepro/* ${frameworkVersion})` : ""}`));
 	if (args["--no-follow"]) {
-		console.log(chalk.gray("  Not following logs (--no-follow). Check status with `rebase cloud logs`."));
-		console.log("");
+		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;
 	}
-	console.log(chalk.gray("  Streaming build logs (Ctrl-C to stop watching — the build keeps running):"));
-	console.log("");
-	await streamBuildLogs(client, deploymentId);
+	if (!isJsonMode()) {
+		console.log(chalk.gray("  Streaming build logs (Ctrl-C to stop watching — the build keeps running):"));
+		console.log("");
+	}
+	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");
 }
-/** Poll a deployment record and print new log output as it arrives. */
-async function 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;
 	let printed = 0;
 	const started = Date.now();
 	for (;;) {
@@ -3501,26 +3635,37 @@ async function streamBuildLogs(client, deploymentId) {
 		} catch (e) {
 			reportError(e, "Failed to read deployment status");
 		}
-		if (!dep) fail(`Deployment ${deploymentId} disappeared.`);
+		if (!dep) fail(`Deployment ${deploymentId} disappeared.`, void 0, "not_found");
 		const logs = dep.logs ?? "";
-		if (logs.length > printed) {
-			process.stdout.write(logs.slice(printed));
-			printed = logs.length;
-		}
+		if (!quiet && logs.length > printed) process.stdout.write(logs.slice(printed));
+		printed = logs.length;
 		if (dep.status && dep.status !== "deploying") {
-			console.log("");
-			if (dep.status === "success") console.log(chalk.bold.green("  ✓ Deployment succeeded"));
-			else {
+			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(chalk.bold.red(`  ✗ Deployment ${dep.status}`));
 				console.log("");
 				process.exit(1);
 			}
-			console.log("");
-			return;
+			if (!quiet) {
+				console.log("");
+				console.log(chalk.bold.green("  ✓ Deployment succeeded"));
+				console.log("");
+			}
+			return dep.status;
 		}
 		if (Date.now() - started > POLL_TIMEOUT_MS) {
-			console.log("");
-			fail("Timed out waiting for the build to finish.", "The deployment may still be running — check `rebase cloud logs`.");
+			if (!quiet) console.log("");
+			fail("Timed out waiting for the build to finish.", "The deployment may still be running — check `rebase cloud logs`.", "timeout");
 		}
 		await sleep(POLL_INTERVAL_MS);
 	}
@@ -4233,9 +4378,35 @@ 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"
 	}, {
@@ -4247,6 +4418,8 @@ 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
@@ -4403,10 +4576,13 @@ ${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() {
@@ -5002,6 +5178,8 @@ 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")
@@ -5015,12 +5193,31 @@ 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)).map(deploymentView);
+		const views = (await fetchDeployments(client, projectId, limit)).map(deploymentView);
+		const truncated = views.length === limit;
 		emit(() => {
 			console.log("");
 			console.log(chalk.bold(`  🚀 Deployments — project ${projectRef}`));
@@ -5035,10 +5232,18 @@ 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) {
@@ -5938,29 +6143,95 @@ ${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.`);
+		if (!project) fail(`Project ${displayProjectRef(rawArgs)} not found.`, void 0, "not_found");
 		const [db, storage, deploy, baseDomain] = await Promise.all([
 			firstRow(client, "databases", projectId),
-			firstRow(client, "storages", projectId),
+			client.functions.invoke("storage-provision", void 0, {
+				method: "GET",
+				path: projectId
+			}).catch(() => void 0),
 			latestDeployment(client, projectId),
 			fetchTenantBaseDomain(client, url)
 		]);
-		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("");
+		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
+		});
 	} catch (e) {
 		reportError(e, "Failed to load status");
 	}
@@ -6471,9 +6742,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 .]")}     Deploy the linked project + stream build logs
+  ${chalk.blue.bold("deploy")} ${chalk.gray("[--source .] [-m msg]")}  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")}        Deployment history ${chalk.gray("(status, duration, trigger)")}
+  ${chalk.blue.bold("deployments list")} ${chalk.gray("[--limit N|--all]")}  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)")}
@@ -6672,6 +6943,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, printInitHelp, 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, formatCdTarget, generateSdkCommand, getActiveBackendPlugin, getPMCommands, isPnpmAvailable, pnpmAvailabilityFromProbe, printInitHelp, requireBackendDir, requireProjectRoot, resetPnpmAvailabilityCache, resolveLocalBin, resolvePluginCliScript, resolveTsx, schemaCommand, startCommand, validateProjectName, validateTsxInstallation };
 
 //# sourceMappingURL=index.es.js.map