@rebasepro/cli 0.11.0 → 0.11.1-canary.gf2b0ff7

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

@@ -35,6 +35,26 @@ export declare function describeStorageState(state: StorageState | undefined): s
  * type; the verdict appears once there is one.
  */
 export declare function describeDatabaseState(db: Record<string, unknown> | undefined): string | undefined;
+/**
+ * One line describing what engine is serving this project.
+ *
+ * Three numbers are in play and they are easy to conflate — I have watched it
+ * happen. The **runtime version** (`1.2.0`) is the contract line a bundle's
+ * range resolves against; its major IS the contract major. The **framework
+ * version** (`0.11.0`) is the `@rebasepro` release the runtime image ships. They
+ * move independently on purpose: tying the contract line to the framework would
+ * make `^1` become `^0.11`, and pre-1.0 caret is restrictive, so every framework
+ * minor would fall outside every project's range and force a rebuild to receive
+ * an engine upgrade — the opposite of what the bundle/runtime split is for.
+ *
+ * So both are printed, rather than leaving anyone to infer one from a Docker tag.
+ */
+export declare function describeRuntime(project: {
+    runtimeMode?: string | null;
+    runtimeVersion?: string | null;
+    runtimeFrameworkVersion?: string | null;
+    runtimeVersionPin?: string | null;
+}): string;
 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>;

package/dist/index.es.js

@@ -8346,6 +8346,27 @@ function describeDatabaseState(db) {
 	if (connection === "connected" || connection === "failed") return `${type} (${colorStatus(connection)})`;
 	return `${type} ${chalk.gray("· not tested (`rebase cloud db test`)")}`;
 }
+/**
+* One line describing what engine is serving this project.
+*
+* Three numbers are in play and they are easy to conflate — I have watched it
+* happen. The **runtime version** (`1.2.0`) is the contract line a bundle's
+* range resolves against; its major IS the contract major. The **framework
+* version** (`0.11.0`) is the `@rebasepro` release the runtime image ships. They
+* move independently on purpose: tying the contract line to the framework would
+* make `^1` become `^0.11`, and pre-1.0 caret is restrictive, so every framework
+* minor would fall outside every project's range and force a rebuild to receive
+* an engine upgrade — the opposite of what the bundle/runtime split is for.
+*
+* So both are printed, rather than leaving anyone to infer one from a Docker tag.
+*/
+function describeRuntime(project) {
+	if (project.runtimeMode !== "managed") return `custom ${chalk.gray("· your own image")}`;
+	const version = project.runtimeVersion ?? "unknown";
+	const framework = project.runtimeFrameworkVersion;
+	const pin = project.runtimeVersionPin ? chalk.gray(` · pinned to ${project.runtimeVersionPin}`) : "";
+	return `managed ${version}${framework ? chalk.gray(` · framework ${framework}`) : ""}${pin}`;
+}
 async function statusCommand(rawArgs) {
 	const { client, url } = await requireClient(rawArgs);
 	const projectId = await requireProject(rawArgs, client);
@@ -8371,6 +8392,7 @@ async function statusCommand(rawArgs) {
 				["URL", projectHost(project, baseDomain)],
 				["Branch", project.gitBranch],
 				["Last deploy", deploy ? `${colorStatus(deploy.status)} · ${fmtDate(deploy.createdAt)}` : "never"],
+				["Runtime", describeRuntime(project)],
 				["Database", databaseLine],
 				["Storage", storageLine]
 			]);
@@ -8387,6 +8409,14 @@ async function statusCommand(rawArgs) {
 				status: deploy.status ?? null,
 				createdAt: deploy.createdAt ?? null
 			} : null,
+			runtime: {
+				mode: project.runtimeMode ?? "custom",
+				version: project.runtimeVersion ?? null,
+				frameworkVersion: project.runtimeFrameworkVersion ?? null,
+				contract: project.runtimeContract ?? null,
+				range: project.runtimeRange ?? null,
+				pin: project.runtimeVersionPin ?? null
+			},
 			database: db ? {
 				type: db.type ?? null,
 				connectionStatus: db.connectionStatus ?? null