@rebasepro/cli 0.9.1-canary.97e305f → 0.9.1-canary.a639738

package/bin/rebase.js

@@ -1,4 +1,70 @@
 #!/usr/bin/env node
-import { entry } from "../dist/index.es.js";
+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");
 
 entry(process.argv);

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

@@ -1,10 +1,6 @@
 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;
@@ -104,8 +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. */
-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,7 +19,6 @@ 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,4 +1,3 @@
 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(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>;

package/dist/index.es.js

@@ -5227,7 +5227,10 @@ async function webhooksCommand(subcommand, rawArgs) {
 		reportError(e, "Webhook operation failed");
 	}
 }
-async function storageCommand(rawArgs) {
+async function storageCommand(action, rawArgs) {
+	if (action === "create") return storageCreateCommand(rawArgs);
+	if (action === "attach") return storageAttachCommand(rawArgs);
+	if (action === "help") return printStorageHelp();
 	const { client } = await requireClient(rawArgs);
 	const projectId = await requireProject(rawArgs, client);
 	try {
@@ -5252,6 +5255,107 @@ async function storageCommand(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 {
@@ -5469,7 +5573,7 @@ async function cloudCommand(subcommand, rawArgs) {
 			await webhooksCommand(action, rawArgs);
 			break;
 		case "storage":
-			await storageCommand(rawArgs);
+			await storageCommand(action, rawArgs);
 			break;
 		case "clusters":
 			await clustersCommand(rawArgs);
@@ -5572,6 +5676,8 @@ ${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