@rebasepro/cli 0.23.0 → 0.24.0

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

@@ -0,0 +1,53 @@
+import { type CloudClient } from "./context.js";
+/** The control-plane function that mints runtime tokens. */
+export declare const RUNTIME_TOKEN_FUNCTION = "runtime-token";
+/** The one scope these commands ask the platform for. */
+export declare const CRON_READ_SCOPE = "cron:read";
+/** What `runtime-token` answers. */
+export interface RuntimeTokenResponse {
+    /** `rpt_…` — the bearer the runtime accepts. */
+    token: string;
+    /** ISO timestamp; past it the runtime refuses the token. */
+    expiresAt?: string;
+    /** What the token was granted, which may be narrower than what was asked. */
+    scopes?: string[];
+}
+/**
+ * A 404 that is about the route, not the project: the JSON envelope a Rebase
+ * backend answers for an unmatched path, or the bare one a router answers
+ * before that handler exists.
+ */
+export declare function isMissingRoute(message: string | undefined): boolean;
+/**
+ * Ask the control plane for a token the project's runtime will accept.
+ *
+ * A missing route means this control plane has no `runtime-token` function
+ * yet, which is a different fix from "no such project" and is said so.
+ */
+export declare function mintRuntimeToken(client: CloudClient, projectId: string, scopes: string[]): Promise<RuntimeTokenResponse>;
+/**
+ * GET a path on the runtime with a platform token, and refuse — with what it
+ * means for this command — anything but a 2xx.
+ *
+ * `notFound` words the 404, which means different things per route: no cron
+ * surface at all on the list, no such job on its logs.
+ */
+export declare function runtimeGet<T>(origin: string, path: string, token: string, notFound: {
+    message: string;
+    hint?: string;
+    code: string;
+}): Promise<T>;
+/** `2026-10-05T10:31:00.000Z` → `2026-10-05 10:31:00Z`, or `—`. */
+export declare function shortTime(iso: string | undefined): string;
+/** Milliseconds as `850ms`, `2.4s` or `3m 10s`. */
+export declare function shortDuration(ms: number | undefined): string;
+/** The flags `cron list` parses — the help page lists exactly these. */
+export declare const CRON_LIST_FLAGS: {
+    "--host": StringConstructor;
+};
+/** The flags `cron logs` parses — the help page lists exactly these. */
+export declare const CRON_LOGS_FLAGS: {
+    "--limit": NumberConstructor;
+    "--host": StringConstructor;
+};
+export declare function cronCommand(action: string | undefined, rawArgs: string[]): Promise<void>;

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

@@ -1,3 +1,4 @@
+import { type CloudClient } from "./context.js";
 /** How a probe's outcome should be read. */
 export type Verdict = 
 /** Behaving as a healthy deployment should. */
@@ -114,5 +115,138 @@ export declare function formatDuration(seconds: number): string;
  * into seconds. Returns null when it is not a duration.
  */
 export declare function parseSince(input: string | undefined): number | null;
+/** One pod's entry in a `runtime-logs` answer. */
+export interface RuntimeLogsPod {
+    pod: string;
+    state: string;
+    /** Lines this pod returned. */
+    lines: number;
+    message: string | null;
+    hint: string | null;
+    /** The server's per-pod BYTE budget cut this pod's output. Says nothing about the line limit. */
+    truncated?: boolean;
+}
+export interface RuntimeLogsResponse {
+    logs?: string;
+    pods?: RuntimeLogsPod[];
+    ordering?: string;
+    /** A byte budget or the pod-count ceiling cut the result. Says nothing about the line limit. */
+    truncated?: boolean;
+    state?: string;
+    message?: string | null;
+}
+/**
+ * The most lines `runtime-logs` returns per pod.
+ *
+ * The control plane enforces this (`MAX_TAIL_LINES` in
+ * `saas/backend/functions/runtime-logs.ts`) by clamping a larger `tailLines`
+ * without saying so: its answer names neither the limit nor the value it used.
+ * `--tail 200000` therefore came back as 2000 lines reported as untruncated.
+ * The CLI clamps first, with the same number, so the lowering is something it
+ * can print rather than something that happened out of sight.
+ */
+export declare const SERVER_MAX_TAIL_LINES = 2000;
+/** How many lines per pod a read asks for, and why that may be less than requested. */
+export interface TailLimit {
+    /** What `--tail` asked for, or the view's default. */
+    requested: number;
+    /** What is sent: `requested`, lowered to {@link SERVER_MAX_TAIL_LINES}. */
+    applied: number;
+    /** Whether `--tail` was given, so a message can name the flag or the default. */
+    explicit: boolean;
+    /** Set when `applied < requested`: the sentence that says so. */
+    note: string | null;
+}
+export declare function resolveTail(requested: number, explicit: boolean): TailLimit;
+/** What one pod's lines actually cover. */
+export interface PodCoverage extends RuntimeLogsPod {
+    /** Earliest and latest timestamps among the lines this pod returned. */
+    firstTimestamp: string | null;
+    lastTimestamp: string | null;
+    /** A limit cut what this pod would otherwise have returned for the window. */
+    truncated: boolean;
+    /** Which limit: the per-pod line limit, or the server's byte budget. */
+    truncatedBy: "tail" | "bytes" | null;
+    /** The plain explanation, when truncated. */
+    truncatedReason: string | null;
+    /**
+     * Every line this pod holds in the window came back. With no window (read
+     * from the start), its first line is the start of its log.
+     */
+    complete: boolean;
+}
+/** The window asked for against the window delivered. */
+export interface LogCoverage {
+    /** Start of the window asked for, ISO. Null when reading each pod from its start. */
+    requestedFrom: string | null;
+    /** Earliest and latest timestamps across every line returned. */
+    firstTimestamp: string | null;
+    lastTimestamp: string | null;
+    pods: PodCoverage[];
+    truncated: boolean;
+    truncatedReasons: string[];
+}
+/** A span of milliseconds as `29d 23h`, `2h 5m`, `35m`, `40s`. */
+export declare function formatSpan(ms: number): string;
+/**
+ * Compare what a read covered with what it asked for.
+ *
+ * The server's `truncated` describes only its byte budgets and pod ceiling, so
+ * a pod that filled the line limit came back marked complete however much of
+ * the window it left unread. The line limit is the cut that matters most, and
+ * it is detected here: a pod that returned as many lines as the limit, whose
+ * earliest line is later than the start of the window, was cut by it.
+ *
+ * Filling the limit is the half that separates a cut from a young pod. A pod
+ * that started an hour ago also has no line older than an hour; it returned
+ * fewer lines than the limit, so what came back is its whole log, and nothing
+ * was cut.
+ */
+export declare function assessCoverage(opts: {
+    res: RuntimeLogsResponse;
+    lines: ParsedLogLine[];
+    /** The window asked for. Null reads each pod from its start. */
+    sinceSeconds: number | null;
+    tail: TailLimit;
+    now: number;
+}): LogCoverage;
+/**
+ * Resolve the public origin a project is served at — or `--host`, when given.
+ *
+ * Shared with `rebase cloud cron`, which reads the runtime at the same address
+ * `debug health` probes.
+ */
+export declare function resolveOrigin(rawArgs: string[], client: CloudClient, url: string, projectId: string): Promise<string>;
+/** What `debug logs`, `errors` and `boot` parse. Their help pairs against this. */
+export declare const LOG_VIEW_FLAGS: {
+    readonly "--since": StringConstructor;
+    readonly "--tail": NumberConstructor;
+    readonly "--previous": BooleanConstructor;
+};
+/** What `debug requests` parses. */
+export declare const REQUESTS_FLAGS: {
+    readonly "--since": StringConstructor;
+    readonly "--tail": NumberConstructor;
+};
+/** What `debug health` parses. */
+export declare const HEALTH_FLAGS: {
+    readonly "--collection": StringConstructor;
+    readonly "--function": StringConstructor;
+    readonly "--host": StringConstructor;
+};
+/**
+ * Whether a boot read reached each pod's start, which is where its startup
+ * lines are. A pod whose read was cut has not been looked at there, so finding
+ * no startup lines in it means nothing — and a line from later in its life
+ * that happens to mention `storage` is not its startup.
+ *
+ * Under `--since` a pod is never counted as reached: a complete read of the
+ * window starts at the pod's first line only if the pod started inside it, and
+ * nothing in the answer says whether it did.
+ */
+export declare function bootReach(pods: PodCoverage[], sinceSeconds: number | null): {
+    reachedStart: boolean;
+    unreached: string[];
+};
 export declare function debugCommand(action: string | undefined, rawArgs: string[]): Promise<void>;
 export declare function printDebugHelp(): void;

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

@@ -1,19 +1,96 @@
 import { type HelpAction } from "./context.js";
+/**
+ * Every flag in the `rebase cloud` family that takes a value, and the short
+ * spellings of them — the globals aside, which `GLOBAL_CLOUD_FLAGS` declares.
+ *
+ * {@link positionals} needs them for one reason: `arg` only consumes a flag's
+ * value when the flag is declared, and an undeclared one leaves its value
+ * behind as a bare word in the action's position. `rebase cloud deployments
+ * --limit 5` dispatched to an action called "5", `rebase cloud debug --host
+ * staging.example.com` to one called "staging.example.com", and `rebase cloud
+ * projects --name shop create` to one called "shop" — each refused as an unknown
+ * command, for a line the command's own help offers.
+ *
+ * Every value is `String` whatever the command reads it as: only consumption
+ * matters here, and the command parses the value itself. One list for the whole
+ * family works because no flag takes a value in one command and none in
+ * another; `value-flags.test.ts` holds that, and holds this list to the specs
+ * the commands declare in both directions, so a new value flag fails a test
+ * until it is added here.
+ */
+export declare const CLOUD_VALUE_FLAGS: {
+    readonly "--access-key-id": StringConstructor;
+    readonly "--autoscale-cpu-target": StringConstructor;
+    readonly "--autoscale-max": StringConstructor;
+    readonly "--backup-access-key-id": StringConstructor;
+    readonly "--backup-bucket": StringConstructor;
+    readonly "--backup-endpoint": StringConstructor;
+    readonly "--backup-secret-access-key": StringConstructor;
+    readonly "--base-domain": StringConstructor;
+    readonly "--branch": StringConstructor;
+    readonly "--bucket": StringConstructor;
+    readonly "--bundle-dir": StringConstructor;
+    readonly "--can": StringConstructor;
+    readonly "--collection": StringConstructor;
+    readonly "--connection-string": StringConstructor;
+    readonly "--cpu": StringConstructor;
+    readonly "--db": StringConstructor;
+    readonly "--db-cpu": StringConstructor;
+    readonly "--db-instances": StringConstructor;
+    readonly "--db-memory": StringConstructor;
+    readonly "--email": StringConstructor;
+    readonly "--endpoint": StringConstructor;
+    readonly "--events": StringConstructor;
+    readonly "--expires-in": StringConstructor;
+    readonly "--function": StringConstructor;
+    readonly "--host": StringConstructor;
+    readonly "--ingress-address": StringConstructor;
+    readonly "--kubeconfig": StringConstructor;
+    readonly "--limit": StringConstructor;
+    readonly "--memory": StringConstructor;
+    readonly "--message": StringConstructor;
+    readonly "--name": StringConstructor;
+    readonly "--org": StringConstructor;
+    readonly "--output": StringConstructor;
+    readonly "--password": StringConstructor;
+    readonly "--platform-rebuilds": StringConstructor;
+    readonly "--port": StringConstructor;
+    readonly "--provider": StringConstructor;
+    readonly "--region": StringConstructor;
+    readonly "--replicas": StringConstructor;
+    readonly "--repo": StringConstructor;
+    readonly "--scale-to-zero": StringConstructor;
+    readonly "--secret-access-key": StringConstructor;
+    readonly "--since": StringConstructor;
+    readonly "--slug": StringConstructor;
+    readonly "--source": StringConstructor;
+    readonly "--spot": StringConstructor;
+    readonly "--storage": StringConstructor;
+    readonly "--subdomain": StringConstructor;
+    readonly "--table": StringConstructor;
+    readonly "--tail": StringConstructor;
+    readonly "--target": StringConstructor;
+    readonly "--timeout": StringConstructor;
+    readonly "--type": StringConstructor;
+    readonly "--out": "--output";
+    readonly "-e": "--email";
+    readonly "-m": "--message";
+    readonly "-n": "--name";
+};
 /**
  * Positional tokens after `rebase cloud` (group, action, …).
  *
- * Two things stop a flag being mistaken for the group. `GLOBAL_CLOUD_FLAGS` is
- * declared so `arg` *consumes* the flags that may precede it — critically
- * together with their values, which is the half that filtering cannot do. The
- * leading-`-` skip then covers a flag nobody declared, so an unrecognised
- * boolean shifts nothing.
- *
- * Only leading tokens are skipped: past the group and action, an undeclared
- * flag and its value are somebody else's positionals and none of our business.
- * A flag this file has never heard of, that takes a value, placed before the
- * group, is the one shape still unresolvable here — there is no way to know
- * whether the token after it is its value or the group, and guessing either way
- * is worse than the handler reporting an unknown group.
+ * Two things stop a flag being mistaken for the group or the action.
+ * `GLOBAL_CLOUD_FLAGS` and {@link CLOUD_VALUE_FLAGS} are declared so `arg`
+ * *consumes* every flag of the family that takes a value — critically together
+ * with its value, which is the half that filtering cannot do. The leading-`-`
+ * skip then covers a flag nobody declared, so an unrecognised boolean shifts
+ * nothing.
+ *
+ * A flag this family has never heard of, that takes a value, is the one shape
+ * still unresolvable here — there is no way to know whether the token after it
+ * is its value or the action. The command's own strict parse refuses that flag
+ * anyway, so the only cost is which refusal the caller reads.
  *
  * Exported so its tests can drive the real thing. The dispatch test used to
  * re-implement it locally as `slice(3).filter(a => !a.startsWith("-"))` — which

package/dist/commands/cloud/token-capabilities.d.ts

@@ -0,0 +1,76 @@
+/**
+ * What a Rebase Cloud token may do, named the way a person asks for it.
+ *
+ * A token is a personal API key on the control plane: it acts as the account
+ * that created it, and holds only the scopes it was given. Nobody should have
+ * to know that `rebase cloud deploy` reads the `deployments` collection, uploads
+ * through the `deploy` function and needs `project:deploy` on one project — so
+ * `rebase cloud tokens create --can deploy` and the console's token screen both
+ * ask for a capability, and this module turns capabilities into scopes.
+ *
+ * One map, read by the CLI and by the console. Each capability covers exactly
+ * the control-plane calls its commands make, traced from the commands
+ * themselves and held there by `token-capabilities.test.ts`, which runs them
+ * against a stand-in control plane that refuses everything a token does not
+ * hold:
+ *
+ * - `deploy`   — `rebase cloud deploy` (bundle and source paths, uploads, the
+ *                build follow) and `rebase cloud deployments`.
+ * - `logs`     — `rebase cloud logs` (build, `--follow`, `--runtime`),
+ *                `rebase cloud metrics` and `rebase cloud cron` — whose
+ *                `runtime-token` call is how a token reads the app's own
+ *                cron history.
+ * - `env`      — `rebase cloud env list|set|unset|reveal|pull`.
+ * - `database` — `rebase cloud db list|info|connect`.
+ * - `backups`  — `rebase cloud db backup list|create|status|download` and
+ *                `db pitr status`. Restoring takes `project:restore`, which no
+ *                capability grants: putting old data over a live database is
+ *                for a signed-in person.
+ *
+ * Every project-level scope is narrowed to the one project the token is for
+ * (`project:deploy:<projectId>`). The data and function scopes cannot be: they
+ * name a collection or a function, not a row, and the control plane's
+ * row-level security keeps the token to what its owner can see.
+ *
+ * Deliberately free of imports, so the control plane's console can read the
+ * same file.
+ *
+ * @module
+ */
+/** A capability a token can be given. */
+export type TokenCapability = "deploy" | "logs" | "env" | "database" | "backups";
+/** Every capability, in the order they are offered. */
+export declare const TOKEN_CAPABILITY_NAMES: readonly TokenCapability[];
+/**
+ * Scopes every token holds, whatever it was created for: resolving a project
+ * by its slug, reading the deployment a command follows, the organization a
+ * project belongs to, and the control plane's public description of itself.
+ */
+export declare const ALWAYS_SCOPES: string[];
+/** Each capability: what it lets a token do, and the scopes that does on one project. */
+export declare const TOKEN_CAPABILITIES: Record<TokenCapability, {
+    label: string;
+    scopes: (projectId: string) => string[];
+}>;
+/** Whether a word names a capability. */
+export declare function isTokenCapability(value: string): value is TokenCapability;
+/**
+ * The scopes a token for `capabilities` on one project holds: {@link ALWAYS_SCOPES}
+ * first, then each capability's, each scope once.
+ *
+ * Throws on a project id a scope cannot carry — empty, or with whitespace — and
+ * on an unknown capability, both of which are a caller's mistake rather than
+ * something to mint a token from.
+ */
+export declare function scopesForCapabilities(projectId: string, capabilities: readonly TokenCapability[]): string[];
+/**
+ * Read a token's scopes back as capabilities: the projects its project scopes
+ * name, and, for each, the capabilities it holds every scope of.
+ *
+ * For showing a token — `rebase cloud tokens list`, `rebase cloud whoami` — so
+ * a list of fifteen scope strings reads as "deploy, logs on <project>".
+ */
+export declare function capabilitiesInScopes(scopes: readonly string[]): Array<{
+    projectId: string;
+    capabilities: TokenCapability[];
+}>;

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

@@ -0,0 +1,23 @@
+import { type TokenCapability } from "./token-capabilities.js";
+/** Every action the group dispatches. */
+export declare const TOKENS_ACTIONS: readonly ["list", "create", "revoke"];
+/** What `rebase cloud tokens create` parses, beside the global flags (`--project` among them). */
+export declare const CREATE_TOKEN_FLAGS: {
+    "--can": [StringConstructor];
+    "--name": StringConstructor;
+    "--expires-in": StringConstructor;
+};
+export declare function tokensCommand(action: string | undefined, rawArgs: string[]): Promise<void>;
+/**
+ * The capabilities `--can` names, comma-separated or repeated, each once.
+ *
+ * Exported so its tests can drive it without a session.
+ */
+export declare function parseCapabilities(values: readonly string[] | undefined): TokenCapability[];
+/**
+ * `--expires-in <days>` as an ISO timestamp, or null for a token that does not
+ * expire.
+ *
+ * Exported so its tests can drive it without a session.
+ */
+export declare function resolveTokenExpiry(value: string | undefined, now?: Date): string | null;

package/dist/commands/db.d.ts

@@ -17,6 +17,20 @@ import { type DevDatabase } from "../dev-db/resolve.js";
  * it open.
  */
 export declare function databaseUrlOf(prepared: Pick<PreparedDatabase, "env" | "database">, envFile: Record<string, string>): string | undefined;
+/**
+ * The flags whose value is a local path, on every line the CLI relays.
+ *
+ * All three spellings of the destination, because the driver accepts all
+ * three: `backup-cli.ts` maps `--output` and `-o` onto `--out`, and `rebase db
+ * backup --help` advertises `--output` as an alias. Only `--out` and `-o` were
+ * absolutised once, so the one spelling the help page names was the one that
+ * landed in `backend/` — and the success line still echoed the path as typed.
+ *
+ * And `--collections`, which was not absolutised at all: from the project root,
+ * `rebase schema generate --collections ./config/collections` was "not found",
+ * while the same spelling worked for `generate-sdk`. See `utils/path-flags.ts`.
+ */
+export declare const LOCAL_PATH_FLAGS: readonly string[];
 /**
  * Rewrite local path arguments so they mean what the user typed.
  *
@@ -31,7 +45,7 @@ export declare function databaseUrlOf(prepared: Pick<PreparedDatabase, "env" | "
  * Absolutising here rather than inside the plugin keeps the fix where the cwd
  * is actually changed, and leaves the plugin usable on its own terms.
  */
-export declare function absolutizeLocalPathArgs(args: string[], cwd: string): string[];
+export declare function absolutizeLocalPathArgs(args: string[], cwd: string, pathFlags?: readonly string[]): string[];
 /**
  * A managed-database refusal, raised so the caller decides what it costs.
  *

package/dist/commands/dev.d.ts

@@ -1,3 +1,4 @@
+import { type AppAddress, type RebaseProjectManifest } from "@rebasepro/types";
 import { type PreparedDatabase } from "../dev-db/prepare.js";
 /**
  * The line the watcher prints when it is about to run the entry again.
@@ -65,15 +66,40 @@ export declare function portMovedNotice(line: string): {
  *
  * @param projectRoot   Absolute path the relative entries are resolved against.
  * @param paths         The `REBASE_DEV_*` map from {@link devRuntimeEnv}.
- * @param includeConfig Whether `config/` is watched here. It is only when
- *                      auto-generation is off; with `--generate` a dedicated
- *                      watcher already regenerates the schema and SDK, and tsx
- *                      restarts on the files that produces.
  */
 export declare function devWatchIncludes(projectRoot: string, paths: {
     REBASE_DEV_FUNCTIONS?: string;
     REBASE_DEV_CRONS?: string;
-}, includeConfig: boolean): string[];
+}): string[];
+/**
+ * The file dev writes to restart the backend, or `null` when tsx would not see it.
+ *
+ * Outside the project, so nothing appears in the developer's tree, and keyed by
+ * the project so two `rebase dev`s never restart each other. tsx ignores every
+ * path with a dot-named segment (its built-in `**\/.*\/**`), so a trigger under
+ * `.rebase/` — or under a TMPDIR inside a dot directory — would never fire; in
+ * that case there is no trigger and {@link devWatchArgs} leaves the
+ * collections to tsx, as before.
+ */
+export declare function devRestartTrigger(projectRoot: string): string | null;
+/**
+ * The `tsx watch` argument list for the backend (unquoted).
+ *
+ * One save of a collection file must restart the backend once. The runtime
+ * `import()`s the collections, so tsx tracks them as dependencies and used to
+ * restart the moment a file was saved — before dev had regenerated
+ * `schema.generated.ts`. That boot warned "schema.generated.ts no longer
+ * describes the database … Run `rebase schema generate`", telling the reader to
+ * run what dev was running at that moment, and the regeneration then rewrote
+ * the file and restarted the backend a second time. So tsx is told to leave the
+ * collections directory alone (`--exclude` wins over its dependency tracking),
+ * and dev restarts the backend itself, once, after the regeneration — through
+ * `restartTrigger`, which tsx watches.
+ */
+export declare function devWatchArgs(projectRoot: string, paths: {
+    REBASE_DEV_FUNCTIONS?: string;
+    REBASE_DEV_CRONS?: string;
+}, entryTarget: string, restartTrigger: string | null): string[];
 /** Well-known filename the backend writes its actual port to. */
 export declare const DEV_PORT_FILENAME = ".rebase-dev-port";
 /**
@@ -138,6 +164,53 @@ export declare function resolveStartPort(projectRoot: string, explicitPort?: num
  * Exported for its test.
  */
 export declare function databaseEndpoint(url: string | null | undefined): string | null;
+/**
+ * What the start banner needs to know about a project's static apps.
+ *
+ * `rebase dev` runs one frontend: Vite in `frontend/`, at the root of its own
+ * localhost port, whatever path or hostname the manifest declares for it. So an
+ * app's local address and its deployed one are different things, and for an app
+ * with a hostname of its own they share nothing at all — appending its address
+ * to the local URL would print `http://localhost:5173https://admin.example.com`.
+ */
+export interface DevStaticShape {
+    declaresStaticApp: boolean;
+    /** The declared app whose `root` is the `frontend/` that `rebase dev` runs, if one is. */
+    served?: {
+        appName: string;
+        address: AppAddress;
+    };
+    /** Where the CMS is, when an app declares one. */
+    cms?: {
+        appName: string;
+        /** Always a path. */
+        path: string;
+        /** The serving app's hostname, when its `path` names one. */
+        host?: string;
+        /** Whether the app serving it is the one `rebase dev` runs, so it has a local address. */
+        servedLocally: boolean;
+    };
+}
+/**
+ * Read {@link DevStaticShape} out of a loaded manifest. Exported for its test.
+ *
+ * Which declared app is running is decided by its `root` being `frontend/`,
+ * because that directory is what `startFrontend` launches and nothing else is.
+ * When no declared app has that root, which app serves the CMS cannot be told,
+ * and it is read as the frontend that does run — what the banner has always
+ * assumed, and right for every project `rebase init` scaffolds.
+ */
+export declare function devStaticShape(manifest: RebaseProjectManifest, projectRoot: string, frontendDir: string | null): DevStaticShape;
+/**
+ * The banner's lines for a project with a frontend. Exported for its test.
+ *
+ * Every address is printed whole, once: the local one Vite answers on, and —
+ * for an app with a hostname — the https URL it answers on once deployed, on a
+ * line of its own beneath it. A CMS in an app `rebase dev` does not run gets its
+ * deployed address and a note saying so, rather than a localhost URL that the
+ * running frontend's SPA fallback would answer with the wrong app.
+ */
+export declare function appBannerLines(frontendUrl: string, api: string, shape: DevStaticShape): Array<[string, string]>;
 /**
  * The `↳ Database =` line: which database, why it was chosen, and where it is.
  *
@@ -206,7 +279,6 @@ export declare const DEV_FLAGS: {
     readonly "--backend-only": BooleanConstructor;
     readonly "--frontend-only": BooleanConstructor;
     readonly "--port": NumberConstructor;
-    readonly "--generate": BooleanConstructor;
     /**
      * Point this run at a database of your own, ahead of everything else.
      *
@@ -220,7 +292,6 @@ export declare const DEV_FLAGS: {
     readonly "-b": "--backend-only";
     readonly "-f": "--frontend-only";
     readonly "-P": "--port";
-    readonly "-g": "--generate";
     readonly "--no-db": BooleanConstructor;
 };
 /**

package/dist/commands/doctor.d.ts

@@ -57,4 +57,9 @@ export declare const DOCTOR_FLAGS: {
     readonly "--sdk": StringConstructor;
     readonly "-k": "--sdk";
 };
+/**
+ * The line handed to the driver, every path on it resolved from where the
+ * command was run — the driver runs in `backend/`. See `utils/path-flags.ts`.
+ */
+export declare function doctorDriverArgs(rawArgs: string[], cwd: string): string[];
 export declare function doctorCommand(rawArgs: string[]): Promise<void>;

package/dist/commands/generate_sdk.d.ts

@@ -1,8 +1,9 @@
 /**
  * CLI command: generate-sdk
  *
- * Reads collection definitions from a specified directory (default: ./config/collections),
- * generates a typed TypeScript SDK, and writes it to the output directory (default: ./generated/sdk).
+ * Reads every collection file in a directory (default: ./config/collections) —
+ * the files the backend serves, not the barrel's list — generates a typed
+ * TypeScript SDK, and writes it to the output directory (default: ./generated/sdk).
  *
  * Uses jiti for dynamic TypeScript import of collection files.
  */