@rebasepro/cli 0.9.1-canary.ff338b5 → 0.10.1-canary.14e53ae

package/README.md

@@ -20,7 +20,7 @@ The CLI is also bundled with every Rebase project as a local dependency.
 | `rebase start` | Start the backend server (production) |
 | `rebase schema generate` | Generate Drizzle schema from collection definitions |
 | `rebase schema introspect` | Introspect an existing database → Rebase collections |
-| `rebase db push` | Apply schema directly to database (dev) |
+| `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 generate-sdk` | Generate a typed TypeScript SDK from collections |

package/dist/bundle.d.ts

@@ -0,0 +1,111 @@
+import { type NativeDependency, type RebaseBundleManifest, type RebaseBackendAppConfig } from "@rebasepro/types";
+export declare const DEFAULT_BUNDLE_DIR = "dist-bundle";
+export interface BuildBundleOptions {
+    projectRoot: string;
+    appName: string;
+    app: RebaseBackendAppConfig;
+    /** Output directory, absolute or relative to the project root. */
+    outDir?: string;
+    /** Runtime range from the manifest, recorded for compatibility checks. */
+    runtimeRange: string;
+    /** Skip type checking. Faster, and strictly worse — for iteration only. */
+    skipTypeCheck?: boolean;
+    /** Skip regenerating the Drizzle schema from the collections. */
+    skipSchema?: boolean;
+    /** Emit progress. */
+    log?: (message: string) => void;
+}
+export interface BuildBundleResult {
+    outDir: string;
+    manifest: RebaseBundleManifest;
+    collectionCount: number;
+}
+/**
+ * Whether the compiled config package exports a `storageAuthorize` hook.
+ *
+ * Recorded in the manifest so a host can refuse a deploy that would enable file
+ * storage with no access model, rather than let the runtime's boot guard turn it
+ * into a crash loop the developer cannot read.
+ *
+ * Read from the *compiled* index, deliberately: that is the exact module the
+ * runtime imports and reads the export off, so this cannot disagree with what
+ * actually happens at boot. It is a textual check rather than an import because
+ * a freshly built bundle cannot resolve its own dependencies until it is
+ * deployed — the same reason schema hashing reads source.
+ *
+ * Errs toward `false`: a missed detection costs a deploy rejection whose message
+ * says exactly how to proceed, while a false positive would hand back the crash
+ * loop this exists to prevent.
+ */
+export declare function detectStorageAuthorize(compiledConfigDir: string): boolean;
+/**
+ * Detect native code in the dependency closure.
+ *
+ * Walks declared runtime dependencies breadth-first through `node_modules`,
+ * flagging anything with a `binding.gyp`, a prebuilt `.node` binary, or an
+ * install script that builds one. The managed runtime cannot run these: a
+ * binary compiled for one image will not load in another, and finding that out
+ * at deploy time is far better than in a crash loop.
+ *
+ * The walk is bounded. A dependency graph can be enormous, and this is a
+ * heuristic gate whose false negatives are caught at deploy time anyway.
+ */
+export declare function detectNativeDependencies(projectRoot: string, declared: Record<string, string>, limit?: number): NativeDependency[];
+/**
+ * Collect the runtime dependencies a bundle needs installed beside it.
+ *
+ * Packages the runtime image already provides are excluded — reinstalling a
+ * second copy of the server next to the one running the process is at best
+ * wasted space and at worst a version conflict. Workspace packages are excluded
+ * too: they are not on the registry the runtime installs from, and the project's
+ * own config package already travels inside the bundle.
+ */
+export declare function collectDeclaredDependencies(projectRoot: string): Record<string, string>;
+/**
+ * Rewrite relative import specifiers in emitted JavaScript so Node can resolve them.
+ *
+ * TypeScript deliberately does not touch specifiers: `moduleResolution: "bundler"`
+ * lets a project write `from "./posts"` or `from "./collections"`, and TypeScript
+ * emits them unchanged on the assumption that a bundler will finish the job.
+ * Nothing bundles a Rebase bundle — the runtime imports these files directly with
+ * Node's ESM loader, which requires a full path with an extension and refuses
+ * directory imports outright.
+ *
+ * Without this, adopting the bundle would mean asking every project written in
+ * the (extremely common) extensionless style to rewrite all of its imports. The
+ * rewrite is mechanical and verifiable: only relative specifiers are touched, and
+ * only when the target file actually exists on disk.
+ */
+export declare function normalizeEsmSpecifiers(outDir: string): {
+    rewritten: number;
+    unresolved: string[];
+};
+/**
+ * Compile and assemble a bundle.
+ */
+export declare function buildBundle(options: BuildBundleOptions): Promise<BuildBundleResult>;
+/**
+ * Package a built static app (a `static` or bundled-`admin` app) into a bundle.
+ *
+ * A static bundle is the counterpart to a backend bundle: the same shape, the
+ * same runtime image runs it, but its manifest says `mode: "static"` and it
+ * carries only the built assets under `static/`. That is what lets a frontend or
+ * admin app be its own deployable, scalable unit rather than something baked into
+ * the backend container.
+ *
+ * `assetsDir` is the app's built output (e.g. `frontend/dist`), already produced
+ * by its own build command. This copies it into the bundle and writes the
+ * manifest — no compilation, no dependency closure (a static bundle installs
+ * nothing at boot).
+ */
+export declare function buildStaticBundle(options: {
+    projectRoot: string;
+    appName: string;
+    assetsDir: string;
+    outDir: string;
+    runtimeRange: string;
+}): {
+    outDir: string;
+    manifest: RebaseBundleManifest;
+    fileCount: number;
+};

package/dist/commands/apps.d.ts

@@ -0,0 +1 @@
+export declare function appsCommand(subcommand: string | undefined, rawArgs?: string[]): Promise<void>;

package/dist/commands/build.d.ts

@@ -1 +1 @@
-export declare function buildCommand(): Promise<void>;
+export declare function buildCommand(rawArgs?: string[]): Promise<void>;

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

@@ -0,0 +1,28 @@
+import type { RebaseBundleManifest } from "@rebasepro/types";
+/** Read and shallow-validate a built bundle's manifest. */
+export declare function readBundleManifest(bundleDir: string): RebaseBundleManifest;
+/**
+ * Tar a built bundle into a gzipped archive.
+ *
+ * `node_modules` is excluded on purpose: the bundle ships a `package.json`, and
+ * the managed runtime installs the declared dependencies at boot. Uploading an
+ * installed `node_modules` would bloat the archive and could carry a
+ * platform-specific build that will not run on the runtime image.
+ */
+export declare function packBundle(bundleDir: string, outPath: string): Promise<void>;
+/**
+ * Assemble the deploy-trigger body for a bundle deploy.
+ *
+ * The manifest travels with the trigger so the control plane can validate intake
+ * without unpacking the uploaded archive first — a rejection (native deps, no
+ * matching runtime) is then a fast, cheap answer.
+ */
+export declare function bundleDeployBody(input: {
+    projectId: string;
+    bundleId: string;
+    manifest: RebaseBundleManifest;
+    app?: string;
+    message?: string;
+}): Record<string, unknown>;
+/** Upload a bundle archive; returns the control-plane bundle id. */
+export declare function uploadBundle(url: string, token: string, projectId: string, tarPath: string): Promise<string>;

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

@@ -62,6 +62,24 @@ export interface ProjectLink {
     slug?: string;
     projectName?: string;
     orgId?: string;
+    /**
+     * Base URL of the project's own API.
+     *
+     * For a cloud project this is a convenience derived from the subdomain. For
+     * a **self-hosted** project it is the entire link: there is no control plane
+     * to look anything up in, so `projectId` is empty and this is what commands
+     * resolve against.
+     *
+     * Keeping both kinds of link in one file is deliberate. A second link file
+     * for self-hosting would fork every command that reads one, and the tooling
+     * would drift into being cloud-only by accident.
+     */
+    apiUrl?: string;
+    /**
+     * How this checkout is linked. Absent means `cloud` — which is every link
+     * written before this field existed.
+     */
+    mode?: "cloud" | "direct";
 }
 export declare function readLink(cwd?: string): ProjectLink | null;
 export declare function writeLink(link: ProjectLink, cwd?: string): void;
@@ -100,6 +118,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/debug.d.ts

@@ -0,0 +1,117 @@
+/** How a probe's outcome should be read. */
+export type Verdict = 
+/** Behaving as a healthy deployment should. */
+"ok"
+/** Reachable and legal, but worth a human look (e.g. a public read). */
+ | "warn"
+/** Broken, or wired up wrong. */
+ | "fail"
+/** We could not classify the response. */
+ | "unknown";
+export interface ProbeReading {
+    verdict: Verdict;
+    /** What this status code *means for this endpoint*, in one sentence. */
+    meaning: string;
+}
+export interface ProbeSpec {
+    id: string;
+    /** Column label in human output. */
+    label: string;
+    method: "GET" | "POST";
+    /** Path relative to the project origin. */
+    path: (opts: ProbeTargets) => string;
+    body?: unknown;
+    /** One-line statement of what a healthy deployment answers here. */
+    healthy: string;
+    interpret: (status: number | null) => ProbeReading;
+    /**
+     * Read the response body as well. Set only where the body carries a fact the
+     * status code cannot — today, the function listing.
+     */
+    needsBody?: boolean;
+    /**
+     * Sharpen the status-code reading using the parsed body. Returning null
+     * keeps {@link interpret}'s verdict.
+     */
+    refine?: (body: unknown, targets: ProbeTargets) => ProbeReading | null;
+}
+export interface ProbeTargets {
+    /** Collection used for the unauthenticated-read probe. */
+    collection: string;
+    /** Function to confirm exists, if the caller named one. */
+    fn?: string;
+}
+/**
+ * The probe set, in the order a failure cascades: if `health` is down, nothing
+ * below it is meaningful, so it is checked first and reported first.
+ */
+export declare const PROBES: ProbeSpec[];
+/** The function names out of a listing body, or null when it is not one. */
+export declare function functionNames(body: unknown): string[] | null;
+export interface ProbeResult {
+    id: string;
+    label: string;
+    method: string;
+    url: string;
+    status: number | null;
+    ms: number;
+    verdict: Verdict;
+    meaning: string;
+    healthy: string;
+    /**
+     * Whether the STATUS CODE alone looked healthy. False means the code itself
+     * was wrong; true with a failing `verdict` means the code was fine and the
+     * body carried the bad news (a named function that did not load). The
+     * summary uses this so it never tells you to expect a 200 you already got.
+     */
+    statusOk: boolean;
+}
+/**
+ * Run one probe. A transport failure is a `null` status, never a thrown error:
+ * "nothing answered" is a diagnosis in its own right and the other probes still
+ * need to run.
+ */
+export declare function runProbe(origin: string, spec: ProbeSpec, targets: ProbeTargets): Promise<ProbeResult>;
+/** The worst verdict across probes — what the command's exit code keys off. */
+export declare function overallVerdict(results: ProbeResult[]): Verdict;
+export interface ParsedLogLine {
+    ts: string | null;
+    pod: string | null;
+    text: string;
+}
+export declare function parseLogLine(line: string): ParsedLogLine;
+/**
+ * Lines an operator scanning for a fault wants to see.
+ *
+ * Matches the structured `severity` field first, then the shapes that show up
+ * in unstructured output. `refus`/`denied` are in the list because a permission
+ * failure often logs at info level and is exactly what one is hunting for.
+ */
+export declare function isErrorLine(text: string): boolean;
+export interface RequestLogEntry {
+    status: number | null;
+    method: string;
+    path: string;
+    latencyMs: number | null;
+}
+/**
+ * Pull an HTTP request record out of a log line, or null when it is not one.
+ *
+ * Only structured request lines are recognised. Guessing at prose would produce
+ * a table with invented columns, which is worse than a short one.
+ */
+export declare function parseRequestLine(text: string): RequestLogEntry | null;
+/**
+ * Startup lines: what the server *decided* it was going to do. Which storage
+ * backend it bound, which functions it loaded, whether auth tables were found.
+ * This is the fastest way to tell a misconfiguration from a runtime fault.
+ */
+export declare function isBootLine(text: string): boolean;
+/** Render a number of seconds back as the compact duration a user would type. */
+export declare function formatDuration(seconds: number): string;
+/**
+ * Parse a duration like `15m`, `2h`, `90s`, `1d` (or a bare number of seconds)
+ * into seconds. Returns null when it is not a duration.
+ */
+export declare function parseSince(input: string | undefined): number | null;
+export declare function debugCommand(action: string | undefined, rawArgs: string[]): Promise<void>;

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/commands/generate_sdk.d.ts

@@ -10,6 +10,18 @@ interface GenerateSDKArgs {
     collectionsDir: string;
     output: string;
     cwd: string;
+    /**
+     * Where to read the schema from instead of local source.
+     *
+     * `link` uses this checkout's linked project; anything else is treated as
+     * the base URL of a Rebase backend. This is what lets a repository that
+     * contains no collections — a separate frontend, a second web app — generate
+     * a typed client from the project it talks to.
+     */
+    from?: string;
+    /** Bearer token for the contract endpoint. Falls back to REBASE_SERVICE_KEY. */
+    token?: string;
+    help?: boolean;
 }
 /**
  * Main entry point for the generate-sdk command.

package/dist/commands/init.d.ts

@@ -24,6 +24,8 @@ export interface InitOptions {
     introspect?: boolean;
     /** Starter template preset. */
     preset: TemplatePreset;
+    /** Whether `preset` came from an explicit --template rather than the default. */
+    explicitPreset?: boolean;
     /** Which parts of Rebase to scaffold. */
     flavor: TemplateFlavor;
     /** Detected package manager (pnpm or npm). */
@@ -51,5 +53,15 @@ export interface BuildQuestionsParams {
  * types registered by the installed version of inquirer.
  */
 export declare function buildInitQuestions(params: BuildQuestionsParams): Record<string, unknown>[];
+/**
+ * The `cd` a user must type to enter the new project.
+ *
+ * Not the project's basename: `init apps/my-app` has to say `cd apps/my-app`,
+ * and `init .` returns "" because they are already in the project.
+ */
+export declare function formatCdTarget(cwd: string, targetDirectory: string): string;
+/** Help for `rebase init` — the flags were previously only discoverable by
+ * triggering the non-TTY error. */
+export declare function printInitHelp(): void;
 export declare function createRebaseApp(rawArgs: string[]): Promise<void>;
 export declare function configureEnvFile(targetDirectory: string, databaseUrl?: string): Promise<void>;

package/dist/commands/start.d.ts

@@ -1 +1 @@
-export declare function startCommand(): Promise<void>;
+export declare function startCommand(rawArgs?: string[]): Promise<void>;

package/dist/index.d.ts

@@ -9,5 +9,8 @@ export * from "./commands/auth";
 export * from "./commands/doctor";
 export * from "./commands/generate_sdk";
 export * from "./commands/cloud";
+export * from "./commands/apps";
 export * from "./utils/project";
 export * from "./utils/package-manager";
+export * from "./manifest";
+export * from "./bundle";