@rebasepro/cli 0.21.1-canary.g8c5a265 → 0.21.1

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/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>;