@rebasepro/cli 0.21.0 → 0.21.1

package/README.md

@@ -9,8 +9,8 @@ pnpm add -g @rebasepro/cli
 ```
 
 ESM-only: `"type": "module"` with no CommonJS build, so it is loaded with
-`import`. `require()` of it resolves only on Node 22.12+, which supports
-`require(esm)`.
+`import`. It needs Node `>=22.22.0` (its `engines` floor), where `require()`
+of it resolves too: Node has supported `require(esm)` since 22.12.
 
 The CLI is also bundled with every Rebase project as a local dependency.
 
@@ -20,19 +20,29 @@ The CLI is also bundled with every Rebase project as a local dependency.
 |---------|-------------|
 | `rebase init` | Scaffold a new Rebase project |
 | `rebase dev` | Start the development server (backend + frontend) |
-| `rebase build` | Build all workspace packages |
+| `rebase build` | Build the apps declared in `rebase.json` into a bundle |
+| `rebase normalize-imports` | Complete compiled output's relative imports for Node ESM |
 | `rebase start` | Start the backend server (production) |
+| `rebase apps list` | Show the apps this repository declares |
 | `rebase schema generate` | Generate Drizzle schema from collection definitions |
 | `rebase schema introspect` | Introspect an existing database → Rebase collections |
+| `rebase schema stale` | Report generated schema files the collections have moved past |
 | `rebase db push` | Apply schema directly to database (dev). Previews the plan and refuses destructive changes (e.g. dropped columns) unless confirmed interactively or run with `--allow-destructive`. |
 | `rebase db generate` | Generate SQL migration files |
 | `rebase db migrate` | Run pending migrations |
+| `rebase db pull` | Copy another database into local development |
+| `rebase db branch` | Create, list, switch and delete database branches |
+| `rebase db stop` | Stop the managed development database (data is kept) |
+| `rebase db reset` | Delete the managed development database and start over |
 | `rebase generate-sdk` | Generate a typed TypeScript SDK from collections |
 | `rebase auth reset-password` | Reset a user's password |
+| `rebase api-keys list \| create \| revoke` | Manage scoped service API keys |
 | `rebase doctor` | Detect schema drift between collections, Drizzle schema, and database |
 | `rebase status` | Show every resource this project declares and whether its variables are set |
 | `rebase resources` | List the databases, buckets and topics this project declares |
+| `rebase eject` | Own the server process and the image (one-way) |
 | `rebase skills install` | Install Rebase agent skills for your AI coding assistant |
+| `rebase telemetry` | Anonymous usage sharing (opt-in, off by default) |
 | `rebase cloud <command>` | Manage your apps on Rebase Cloud (auth, deploy, databases, …) |
 
 Run `rebase --help` or `rebase <command> --help` for detailed usage.

package/bin/rebase.js

@@ -188,7 +188,10 @@ const { entry } = await import("../dist/index.es.js");
  * `utils/args.ts` marks those with `isUsageError` rather than a class, because
  * this file imports the bundle and `instanceof` cannot reach across it.
  */
-const wantsStack = process.argv.includes("--debug") || process.env.REBASE_DEBUG === "1";
+// After the bundle, which already imports this package, and spelled as the
+// commands spell it: `wantsRawError` in `commands/cloud/errors.ts`.
+const { parseEnvBoolean } = await import("@rebasepro/types");
+const wantsStack = process.argv.includes("--debug") || parseEnvBoolean(process.env.REBASE_DEBUG) === true;
 
 entry(process.argv).catch((error) => {
     const message = error instanceof Error ? error.message : String(error);

package/dist/commands/cloud/bundle-deploy.d.ts

@@ -1,4 +1,5 @@
 import type { RebaseBundleManifest } from "@rebasepro/types";
+import type { RebuildSource } from "./rebuild-source.js";
 /** Read and shallow-validate a built bundle's manifest. */
 export declare function readBundleManifest(bundleDir: string): RebaseBundleManifest;
 /**
@@ -65,6 +66,14 @@ export declare function bundleDeployBody(input: {
      * look" indistinguishable from "we looked and there was nothing".
      */
     commit?: BundleCommit | null;
+    /**
+     * The source this bundle was built from, uploaded so a platform upgrade can
+     * rebuild it on a newer release. Omitted when none was uploaded — `--no-source`,
+     * a static app, or an upload that failed — never sent empty.
+     */
+    rebuildSource?: RebuildSource | null;
+    /** `--allow-downgrade`: deploy a bundle built on an older release than the project runs. */
+    allowFrameworkDowngrade?: boolean;
 }): Record<string, unknown>;
 /** An app as `rebase.json` declares it, reduced to what the registry stores. */
 export interface DeclaredApp {

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

@@ -187,6 +187,8 @@ export declare const DEPLOY_FLAGS: {
     readonly "--bundle-dir": StringConstructor;
     readonly "--skip-type-check": BooleanConstructor;
     readonly "--eject": BooleanConstructor;
+    readonly "--no-source": BooleanConstructor;
+    readonly "--allow-downgrade": BooleanConstructor;
     readonly "-m": "--message";
 };
 /**
@@ -222,6 +224,8 @@ export declare function resolveDeployArgs(rawArgs: string[]): {
         readonly "--bundle-dir": StringConstructor;
         readonly "--skip-type-check": BooleanConstructor;
         readonly "--eject": BooleanConstructor;
+        readonly "--no-source": BooleanConstructor;
+        readonly "--allow-downgrade": BooleanConstructor;
         readonly "-m": "--message";
     } & {
         readonly "--json": BooleanConstructor;
@@ -238,6 +242,35 @@ export declare function resolveDeployArgs(rawArgs: string[]): {
 export declare function deployCommand(rawArgs: string[], projectRef: string): Promise<void>;
 /** `--timeout <seconds>` for a deploy, or the 15-minute default. */
 export declare function resolveDeployTimeout(value: string | undefined): number;
+/**
+ * Whether the project's owner turned platform rebuilds off.
+ *
+ * Only an explicit `false` counts: a project row that predates the switch, or
+ * one that could not be read, is on — which is the default, and the control
+ * plane refuses an upload it should not have anyway.
+ */
+export declare function platformRebuildsOff(client: CloudClient, projectId: string): Promise<boolean>;
+/** The intake code for a bundle built on an older framework release than the project runs. */
+export declare const FRAMEWORK_DOWNGRADE = "FRAMEWORK_DOWNGRADE";
+/**
+ * An intake refusal, which is a decision about what was deployed rather than a
+ * transport error — or undefined for anything else.
+ *
+ * It carries a stable code in `details.intakeCode` and usually a remedy in
+ * `details.hint`, and both used to be discarded: the deploy printed `Failed to
+ * trigger deployment (400): …` and threw the hint away. The managed path, where
+ * bundles are refused, never looked for either. Both paths answer through this
+ * now, in the three-argument shape `fail` takes, so `--json` carries the code
+ * and a person sees the fix.
+ *
+ * A downgrade gets one more line, because its two remedies are both in this
+ * CLI: move the project forward, or say the step back is meant.
+ */
+export declare function intakeRefusal(e: unknown): {
+    message: string;
+    hint: string;
+    code: string;
+} | undefined;
 /**
  * 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.

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

@@ -76,5 +76,10 @@ export declare function summarizeError(error: unknown, context: string): ErrorSu
  * `--debug` is already what `bin/rebase.js` prints after every failure as the
  * thing to add, so the raw payload hangs off the flag people are told to reach
  * for rather than off one invented here.
+ *
+ * The one reader of `REBASE_DEBUG` in the commands, spelled as the bin spells
+ * it. It used to be `=== "1"` here while the quote fallbacks in `resources.ts`
+ * tested the raw string for truthiness, so `=true` hid the body and `=0`
+ * printed the fallback.
  */
 export declare function wantsRawError(argv?: readonly string[]): boolean;

package/dist/commands/cloud/rebuild-source.d.ts

@@ -0,0 +1,110 @@
+import type { RebaseProjectManifest } from "@rebasepro/types";
+/**
+ * The control plane's cap on an uploaded source archive.
+ *
+ * Keep in sync with its build-context cap (deploy/upload `MAX_BYTES` and the
+ * backend's `maxBodySize`). Checked before uploading, so an oversized archive is
+ * a message in milliseconds rather than a bare 413 after the upload.
+ */
+export declare const MAX_SOURCE_UPLOAD_BYTES: number;
+/**
+ * Whether a file must never be uploaded, whatever the ignore rules said.
+ *
+ * `relativePath` is POSIX. Installed packages, git's own directory and built
+ * bundles are never source. Every `.env` and `.env.*` is excluded except the
+ * three template names, and so is direnv's `.envrc`, which is the same thing
+ * under another name.
+ */
+export declare function neverUploaded(relativePath: string): boolean;
+export interface SourceListing {
+    /** The directory the archive is rooted at: the repository's top level, or the project root. */
+    root: string;
+    /** Regular files to pack, relative to `root`, POSIX, sorted. */
+    files: string[];
+    /** The project root relative to `root`, POSIX; `""` when they are the same directory. */
+    projectPath: string;
+    /** Whether git chose the files. */
+    fromGit: boolean;
+}
+/** `git -C <cwd> …`, returning stdout. Throws when git is missing or refuses. */
+export type GitRunner = (cwd: string, args: string[]) => string;
+/**
+ * The files a source upload carries, and where they are rooted.
+ *
+ * The project's repository first — or the project walked, outside git. Then
+ * every repository a local `link:`/`file:` dependency reaches outside it, until
+ * nothing new is reached, rooted together at their deepest common directory.
+ * That is dadaki's shape: its Rebase project is a repository of its own, nested
+ * inside the editor's repository (which ignores it), and its frontend links
+ * `../../packages/editor` from there. A listing of the project's repository
+ * alone rebuilt into "Rollup failed to resolve import @dadaki/editor".
+ *
+ * Paths are resolved through `realpath` first: git reports its top level with
+ * symlinks resolved (`/private/var/…` for a macOS temp directory), and a
+ * project path computed against the unresolved one would climb out of the
+ * archive with `../`.
+ */
+export declare function listSourceFiles(projectRoot: string, git?: GitRunner): SourceListing;
+/**
+ * Pack a listing into a gzipped tarball at `outPath`.
+ *
+ * The list goes to tar as a NUL-separated file (`--null -T`), so a path with a
+ * space or a newline in it is one path. `--no-xattrs` and `COPYFILE_DISABLE`
+ * keep macOS's extended attributes and AppleDouble `._*` sidecars out of the
+ * archive, as `packBundle` does; GNU tar accepts both. Every path handed to tar
+ * is absolute, because GNU tar resolves a `-T` file after it has applied `-C`.
+ */
+export declare function packSource(listing: SourceListing, outPath: string): Promise<void>;
+/** Upload a source archive; returns the control plane's id for it. */
+export declare function uploadRebuildSource(url: string, token: string, projectId: string, tarPath: string): Promise<string>;
+/**
+ * The `VITE_*` values a rebuild of this project's frontend needs.
+ *
+ * The `.env` files are never uploaded, so the values a static app is built with
+ * have to travel separately — and only the `VITE_*` ones, which Vite inlines
+ * into the client bundle and are public by construction. Nothing else is read.
+ *
+ * Read the way Vite reads them for `vite build`: `.env`, `.env.local`,
+ * `.env.production`, `.env.production.local`, later winning — from the project
+ * root, then from each static app's own `root`, which is where its Vite config
+ * usually points. `process.env` wins over every file, as it does in Vite.
+ *
+ * `VITE_API_URL` is the one exception, taken from `process.env` only.
+ * `staticBuildEnv` sets it to `process.env.VITE_API_URL ?? ""` for every
+ * static build, so a value in a `.env` file never reaches a deployed bundle —
+ * it is the `http://localhost:3001` of local development. Sending it would make
+ * the rebuild bake in exactly the address the local build refuses to.
+ */
+export declare function collectBuildEnv(projectRoot: string, appRoots: string[], env?: NodeJS.ProcessEnv): Record<string, string>;
+/** The `root` of every static app a manifest declares, in declaration order. */
+export declare function staticAppRoots(manifest: RebaseProjectManifest | undefined): string[];
+/** What the deploy trigger carries about an uploaded source. */
+export interface RebuildSource {
+    sourceId: string;
+    projectPath: string;
+    buildEnv: Record<string, string>;
+}
+/** The steps, injectable so a test can fail any one of them. */
+export interface RebuildSourceSteps {
+    list: (projectRoot: string) => SourceListing;
+    pack: (listing: SourceListing, outPath: string) => Promise<void>;
+    upload: (url: string, token: string, projectId: string, tarPath: string) => Promise<string>;
+}
+/**
+ * List, pack and upload the project's source. Never throws.
+ *
+ * Returns what the trigger should carry, or null — after a warning saying why
+ * and what it costs — when the source could not be sent. The caller deploys
+ * either way.
+ */
+export declare function prepareRebuildSource(opts: {
+    projectRoot: string;
+    url: string;
+    token: string;
+    projectId: string;
+    manifest?: RebaseProjectManifest;
+    progress: (line: string) => void;
+    warn: (message: string, hint?: string) => void;
+    steps?: Partial<RebuildSourceSteps>;
+    maxBytes?: number;
+}): Promise<RebuildSource | null>;

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

@@ -1,16 +1,21 @@
 export declare function settingsCommand(action: string | undefined, rawArgs: string[]): Promise<void>;
+/** `on`/`off` (or `true`/`false`) as a boolean, or null for anything else. */
+export declare function parseOnOff(value: string): boolean | null;
 /** Build the update patch from the flags actually supplied (pure/testable). */
 export declare function buildSettingsPatch(args: {
     name?: string;
     subdomain?: string;
     repo?: string;
     branch?: string;
-}): Record<string, string>;
+    /** Already parsed with {@link parseOnOff}. */
+    platformRebuilds?: boolean;
+}): Record<string, string | boolean>;
 /** What `rebase cloud settings set` parses. Its page is the group's own. */
 export declare const SET_SETTINGS_FLAGS: {
     readonly "--name": StringConstructor;
     readonly "--subdomain": StringConstructor;
     readonly "--repo": StringConstructor;
     readonly "--branch": StringConstructor;
+    readonly "--platform-rebuilds": StringConstructor;
 };
 export declare function printSettingsHelp(): void;

package/dist/commands/upgrade.d.ts

@@ -0,0 +1,38 @@
+import { type ChangedPin, type OverrideFinding, type SkippedSpec, type UnreadableFile } from "../upgrade.js";
+/** Every flag `rebase upgrade` accepts. Its help page and the docs verifier read this. */
+export declare const UPGRADE_FLAGS: {
+    readonly "--to": StringConstructor;
+    readonly "--drop-local-overrides": BooleanConstructor;
+    readonly "--no-install": BooleanConstructor;
+    readonly "--dry-run": BooleanConstructor;
+    readonly "--json": BooleanConstructor;
+};
+/** What the command reports, human or `--json`. */
+export interface UpgradeResult {
+    target: string;
+    changed: ChangedPin[];
+    skipped: SkippedSpec[];
+    overrides: OverrideFinding[];
+    unreadable: UnreadableFile[];
+    installed: boolean;
+    dryRun: boolean;
+}
+/**
+ * The two things this command does outside the project's files: ask the
+ * registry what a tag points at, and install. Injectable, so a test runs the
+ * whole command without either.
+ */
+export interface UpgradeIo {
+    npmView: (spec: string, cwd: string) => Promise<string>;
+    /** `quietStdout`: route the installer's stdout to stderr, so `--json` keeps stdout to itself. */
+    install: (command: [string, string[]], cwd: string, quietStdout: boolean) => Promise<void>;
+}
+/**
+ * The one line of a failed `npm view` worth printing.
+ *
+ * execa's own message is the command line that failed, which says nothing the
+ * reader does not know. npm's stderr says why — `404 No match found for version
+ * nosuchtag` — under an `npm error code E404` line that says less.
+ */
+export declare function npmFailure(err: unknown): string;
+export declare function upgradeCommand(rawArgs: string[], io?: UpgradeIo): Promise<void>;