@rebasepro/cli 0.25.1 → 0.26.0

package/dist/collections-dir-DlvDhime.js

@@ -0,0 +1,69 @@
+import { d as findBackendApp, g as resolveBackendPaths, n as DEFAULT_CONFIG_DIR, p as loadManifest } from "./manifest-BtzDy7KQ.js";
+import path from "path";
+//#region src/utils/collections-dir.ts
+/**
+* Where this project's collections are: one answer for every command.
+*
+* `rebase.json`'s `apps.<backend>.config` names the config package, and the
+* collections live in `<config>/collections`. The dev runtime, `rebase build`
+* and `rebase generate view` honoured it; `verify`, `doctor`, `generate-sdk`,
+* `console`, and dev's watcher and schema/SDK regeneration each hardcoded
+* `config/collections`. In a project with `"config": "shared"` the runtime
+* loaded `shared/collections` while `rebase verify` reported "no collections
+* directory … 0 errors", `generate-sdk` said the API derives from the
+* database, `doctor` found no collections, and dev never regenerated on an
+* edit.
+*
+* A `--collections` typed on the command line still wins wherever a command
+* takes one; this is only the default.
+*/
+/** The config package directory, relative to the project root, as the backend app declares it. */
+function resolveConfigDir(projectRoot) {
+	try {
+		const backend = findBackendApp(loadManifest(projectRoot).manifest);
+		if (backend) return resolveBackendPaths(backend.app, projectRoot).config;
+	} catch {}
+	return DEFAULT_CONFIG_DIR;
+}
+/** `<config>/collections`, absolute. */
+function resolveCollectionsDir(projectRoot) {
+	return path.join(projectRoot, resolveConfigDir(projectRoot), "collections");
+}
+/** Whether a command line already names a collections directory. */
+function namesCollections(args) {
+	return args.some((arg) => arg === "--collections" || arg === "-c" || arg.startsWith("--collections=") || arg.startsWith("-c="));
+}
+/**
+* The driver commands that read collections and take `--collections` — the
+* driver defaults each of them to `../config/collections` from `backend/`.
+* Keyed as the driver's argv starts: domain, then subcommand.
+*/
+var DRIVER_COMMANDS_READING_COLLECTIONS = /* @__PURE__ */ new Set([
+	"db push",
+	"db generate",
+	"schema generate",
+	"schema stale",
+	"doctor",
+	"console"
+]);
+/**
+* `["--collections", <dir>]` to append to a driver command line, or nothing.
+*
+* `driverArgs` is the line as the driver gets it (`["db", "push", …]`,
+* `["doctor", …]`). Nothing for a command that does not read collections, nothing
+* when the line already names a directory, and nothing when the project keeps
+* its collections where the driver looks by default, so a conventional
+* project's command lines are unchanged.
+*/
+function collectionsDirArgs(projectRoot, driverArgs) {
+	const command = DRIVER_COMMANDS_READING_COLLECTIONS.has(driverArgs[0]) ? driverArgs[0] : `${driverArgs[0]} ${driverArgs[1]}`;
+	if (!DRIVER_COMMANDS_READING_COLLECTIONS.has(command)) return [];
+	if (namesCollections(driverArgs)) return [];
+	const dir = resolveCollectionsDir(projectRoot);
+	if (dir === path.join(projectRoot, "config", "collections")) return [];
+	return ["--collections", dir];
+}
+//#endregion
+export { collectionsDirArgs, resolveCollectionsDir, resolveConfigDir };
+
+//# sourceMappingURL=collections-dir-DlvDhime.js.map

package/dist/collections-dir-DlvDhime.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"collections-dir-DlvDhime.js","names":[],"sources":["../src/utils/collections-dir.ts"],"sourcesContent":["/**\n * Where this project's collections are: one answer for every command.\n *\n * `rebase.json`'s `apps.<backend>.config` names the config package, and the\n * collections live in `<config>/collections`. The dev runtime, `rebase build`\n * and `rebase generate view` honoured it; `verify`, `doctor`, `generate-sdk`,\n * `console`, and dev's watcher and schema/SDK regeneration each hardcoded\n * `config/collections`. In a project with `\"config\": \"shared\"` the runtime\n * loaded `shared/collections` while `rebase verify` reported \"no collections\n * directory … 0 errors\", `generate-sdk` said the API derives from the\n * database, `doctor` found no collections, and dev never regenerated on an\n * edit.\n *\n * A `--collections` typed on the command line still wins wherever a command\n * takes one; this is only the default.\n */\nimport path from \"path\";\nimport { DEFAULT_CONFIG_DIR, findBackendApp, loadManifest, resolveBackendPaths } from \"../manifest\";\n\n/** The config package directory, relative to the project root, as the backend app declares it. */\nexport function resolveConfigDir(projectRoot: string): string {\n    try {\n        const backend = findBackendApp(loadManifest(projectRoot).manifest);\n        if (backend) return resolveBackendPaths(backend.app, projectRoot).config;\n    } catch {\n        // A malformed rebase.json is reported by the commands that own it; the\n        // conventional layout is the answer until then.\n    }\n    return DEFAULT_CONFIG_DIR;\n}\n\n/** `<config>/collections`, absolute. */\nexport function resolveCollectionsDir(projectRoot: string): string {\n    return path.join(projectRoot, resolveConfigDir(projectRoot), \"collections\");\n}\n\n/** Whether a command line already names a collections directory. */\nfunction namesCollections(args: readonly string[]): boolean {\n    return args.some(arg => arg === \"--collections\" || arg === \"-c\" || arg.startsWith(\"--collections=\") || arg.startsWith(\"-c=\"));\n}\n\n/**\n * The driver commands that read collections and take `--collections` — the\n * driver defaults each of them to `../config/collections` from `backend/`.\n * Keyed as the driver's argv starts: domain, then subcommand.\n */\nconst DRIVER_COMMANDS_READING_COLLECTIONS = new Set([\n    \"db push\",\n    \"db generate\",\n    \"schema generate\",\n    \"schema stale\",\n    \"doctor\",\n    \"console\"\n]);\n\n/**\n * `[\"--collections\", <dir>]` to append to a driver command line, or nothing.\n *\n * `driverArgs` is the line as the driver gets it (`[\"db\", \"push\", …]`,\n * `[\"doctor\", …]`). Nothing for a command that does not read collections, nothing\n * when the line already names a directory, and nothing when the project keeps\n * its collections where the driver looks by default, so a conventional\n * project's command lines are unchanged.\n */\nexport function collectionsDirArgs(projectRoot: string, driverArgs: readonly string[]): string[] {\n    const command = DRIVER_COMMANDS_READING_COLLECTIONS.has(driverArgs[0])\n        ? driverArgs[0]\n        : `${driverArgs[0]} ${driverArgs[1]}`;\n    if (!DRIVER_COMMANDS_READING_COLLECTIONS.has(command)) return [];\n    if (namesCollections(driverArgs)) return [];\n    const dir = resolveCollectionsDir(projectRoot);\n    if (dir === path.join(projectRoot, DEFAULT_CONFIG_DIR, \"collections\")) return [];\n    return [\"--collections\", dir];\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAoBA,SAAgB,iBAAiB,aAA6B;CAC1D,IAAI;EACA,MAAM,UAAU,eAAe,aAAa,WAAW,CAAC,CAAC,QAAQ;EACjE,IAAI,SAAS,OAAO,oBAAoB,QAAQ,KAAK,WAAW,CAAC,CAAC;CACtE,QAAQ,CAGR;CACA,OAAO;AACX;;AAGA,SAAgB,sBAAsB,aAA6B;CAC/D,OAAO,KAAK,KAAK,aAAa,iBAAiB,WAAW,GAAG,aAAa;AAC9E;;AAGA,SAAS,iBAAiB,MAAkC;CACxD,OAAO,KAAK,MAAK,QAAO,QAAQ,mBAAmB,QAAQ,QAAQ,IAAI,WAAW,gBAAgB,KAAK,IAAI,WAAW,KAAK,CAAC;AAChI;;;;;;AAOA,IAAM,sDAAsC,IAAI,IAAI;CAChD;CACA;CACA;CACA;CACA;CACA;AACJ,CAAC;;;;;;;;;;AAWD,SAAgB,mBAAmB,aAAqB,YAAyC;CAC7F,MAAM,UAAU,oCAAoC,IAAI,WAAW,EAAE,IAC/D,WAAW,KACX,GAAG,WAAW,GAAG,GAAG,WAAW;CACrC,IAAI,CAAC,oCAAoC,IAAI,OAAO,GAAG,OAAO,CAAC;CAC/D,IAAI,iBAAiB,UAAU,GAAG,OAAO,CAAC;CAC1C,MAAM,MAAM,sBAAsB,WAAW;CAC7C,IAAI,QAAQ,KAAK,KAAK,aAAA,UAAiC,aAAa,GAAG,OAAO,CAAC;CAC/E,OAAO,CAAC,iBAAiB,GAAG;AAChC"}

package/dist/commands/agent-setup.d.ts

@@ -114,3 +114,61 @@ export declare function printAgentSetup({ results, skillsError, mcpDependency }:
  * the developer says no or unticks everything.
  */
 export declare function promptForAgents(home?: string): Promise<AgentKey[]>;
+/**
+ * The guardrail every scaffold ships for Claude Code: a PostToolUse hook that
+ * runs `rebase verify --quiet` after each edit under `config/collections/` and
+ * hands any problem back to the agent (exit 2, the message on stderr).
+ *
+ * The files live in the template, under `.claude/`, so `rebase init` copies
+ * them like everything else and `rebase skills --hooks` installs the very same
+ * bytes into a project that predates them. Paths are project-relative.
+ */
+export declare const AGENT_HOOK_SCRIPT = ".claude/hooks/post-edit-collection.sh";
+export declare const AGENT_HOOK_SETTINGS = ".claude/settings.json";
+/** What installing one hook file did. */
+export type HookWriteStatus = 
+/** Written, or merged into the settings beside the hooks already there. */
+"added"
+/** Already there, unchanged — or, for the settings, already registered. */
+ | "present"
+/** There, and edited: left as it was. `--force` replaces it. */
+ | "kept"
+/** There, edited, and replaced because `--force` asked. */
+ | "replaced"
+/** The settings file is not plain JSON with a `hooks` object: left alone. */
+ | "unreadable";
+export interface HookWriteResult {
+    file: string;
+    status: HookWriteStatus;
+}
+/**
+ * The SHA-256 of every version of `post-edit-collection.sh` this CLI has ever
+ * written, oldest first, the current one last — hashed with CRLF read as LF,
+ * so a Windows checkout of an untouched copy still matches.
+ *
+ * A copy that differs from today's script was read as "edited" and kept, so a
+ * fix to the hook never reached a project scaffolded before it: `rebase skills
+ * install --hooks` answered "was edited, so it was kept — pass --force" about a
+ * file nobody had touched. A copy whose hash is one of ours is our old
+ * version, and is replaced like any stale file; only a copy we never shipped is
+ * the developer's.
+ *
+ * Append, never replace: `agent-hooks.test.ts` fails when the shipped script's
+ * hash is not here, so changing the hook means adding its new hash — and the
+ * old one stays, which is the whole point.
+ */
+export declare const SHIPPED_HOOK_SCRIPT_SHA256S: readonly string[];
+/** The hash {@link SHIPPED_HOOK_SCRIPT_SHA256S} records for a script's text. */
+export declare function hookScriptSha256(text: string): string;
+/**
+ * Install the Claude Code guardrail into a project: the hook script, and its
+ * registration in `.claude/settings.json`.
+ *
+ * A script the developer edited is kept unless `force`; a version this CLI
+ * shipped earlier is replaced. The settings are always merged, never
+ * overwritten.
+ */
+export declare function installAgentHooks(projectDir: string, { force, templateDir }?: {
+    force?: boolean;
+    templateDir?: string;
+}): HookWriteResult[];

package/dist/commands/api-keys.d.ts

@@ -13,6 +13,14 @@ export declare const API_KEYS_SUBCOMMANDS: readonly ["list", "get", "create", "r
 export type BackendAddress = {
     url: string;
     source: "configured" | "running";
+    /**
+     * Set when the address came from `.env` and is the cloud project this
+     * directory is linked to — which `rebase cloud init --claim` writes
+     * there for the app and the SDK, not as a choice of where local
+     * commands go. The command still goes there; {@link cloudTargetNote}
+     * says so.
+     */
+    cloudProject?: string;
 } | {
     url: null;
     reason: string;
@@ -35,6 +43,11 @@ export type BackendAddress = {
  * other server may have taken since.
  */
 export declare function resolveBackendAddress(env: Record<string, string>, projectRoot: string): BackendAddress;
+/**
+ * What a local command says before it sends the service key to the cloud
+ * project `.env` names (see `BackendAddress.cloudProject`), or undefined.
+ */
+export declare function cloudTargetNote(address: BackendAddress): string | undefined;
 /**
  * The address to send the service key to, or the end of the command.
  *

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

@@ -0,0 +1,25 @@
+export declare const ACTIVITY_FLAGS: {
+    readonly "--org": StringConstructor;
+    readonly "--action": StringConstructor;
+    readonly "--actor": StringConstructor;
+    readonly "--limit": StringConstructor;
+    readonly "--before": StringConstructor;
+};
+/** One event, as the control plane sends it. */
+export interface CliAuditEvent {
+    id: string;
+    createdAt: string;
+    action: string;
+    target: string | null;
+    projectId: string | null;
+    projectLabel: string | null;
+    actorKind: string;
+    actorLabel: string | null;
+    actorUserId: string | null;
+    metadata: Record<string, unknown>;
+}
+/** Who, in a few words: an email, a token's name and owner, a hook, the platform. */
+export declare function actorText(event: CliAuditEvent): string;
+/** The line under an event, when its metadata says more than its action does. */
+export declare function detailText(event: CliAuditEvent): string;
+export declare function activityCommand(rawArgs: string[]): Promise<void>;

package/dist/commands/cloud/app-key.d.ts

@@ -0,0 +1,18 @@
+export declare const APP_KEY_FLAGS: {};
+export declare const APP_KEY_ACTIONS: readonly ["rotate"];
+/** An agent key on the app, as the control plane lists it. Never the key itself. */
+export interface CliAgentKey {
+    id: string;
+    prefix: string | null;
+    createdAt: string | null;
+    expiresAt: string | null;
+}
+/** What a rotation answers: the new key, once. */
+export interface CliRotatedAppKey {
+    apiKey: string;
+    keyId: string;
+    scopes: string[];
+    expiresAt: string | null;
+    revoked: string[];
+}
+export declare function appKeyCommand(rawArgs: string[]): Promise<void>;

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

@@ -9,6 +9,7 @@
 export declare const LOGIN_FLAGS: {
     readonly "--email": StringConstructor;
     readonly "--password": StringConstructor;
+    readonly "--code": BooleanConstructor;
     readonly "-e": "--email";
 };
 /**

package/dist/commands/cloud/billing-invoices.d.ts

@@ -0,0 +1,39 @@
+import { type CloudClient } from "./context.js";
+/** One issued invoice, as the control plane sends it. */
+export interface CliInvoice {
+    id: string;
+    number: string | null;
+    status: string | null;
+    created: string | null;
+    periodStart: string | null;
+    periodEnd: string | null;
+    total: number;
+    amountDue: number;
+    currency: string;
+    hostedInvoiceUrl: string | null;
+    invoicePdf: string | null;
+}
+/** What one subscription will invoice next. */
+export interface CliUpcomingInvoice {
+    subscriptionId: string;
+    kind: "project" | "usage";
+    projectId: string | null;
+    projectName: string | null;
+    total: number;
+    amountDue: number;
+    currency: string;
+    expectedAt: string | null;
+    periodStart: string | null;
+    periodEnd: string | null;
+    lines: {
+        description: string | null;
+        amount: number;
+        currency: string;
+        quantity: number | null;
+    }[];
+    moreLines: boolean;
+}
+/** An amount in a currency's minor unit, for a person. The divisor is the currency's own. */
+export declare function formatMinor(amount: number, currency: string): string;
+export declare function billingInvoices(client: CloudClient, org: string, limit?: number): Promise<void>;
+export declare function billingUpcoming(client: CloudClient, org: string): Promise<void>;

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

@@ -0,0 +1,7 @@
+/** What `rebase cloud claim` parses, beside the global flags. Its page pairs against this. */
+export declare const CLAIM_FLAGS: {
+    readonly "--open": BooleanConstructor;
+};
+/** "41h", "25m", "under a minute": how long is left, for a person. */
+export declare function timeLeft(expiresAt: string, now?: number): string;
+export declare function claimCommand(rawArgs: string[], now?: () => number): Promise<void>;

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

@@ -13,6 +13,70 @@ import { createRebaseClient } from "@rebasepro/client";
  */
 export declare function billingAccountIdOf(org: unknown): string | number | undefined;
 export declare function projectLinkPath(cwd?: string): string;
+/**
+ * What an account-less provision hands back, kept until it stops mattering.
+ *
+ * Both values are bearer secrets — the token deploys to the project, the claim
+ * link moves it into the organization of whoever opens it — so they live here, in
+ * the private credentials file, and never in the repository: not in `.env`,
+ * where `REBASE_API_TOKEN` beside `REBASE_BASE_URL` is what the MCP server and
+ * the SDK send to the APP (which knows nothing of a control-plane token; `init`
+ * writes a key minted on the app there instead), and not in
+ * `.rebase/cloud.json`, which a cloned repository supplies.
+ */
+export interface EphemeralGrant {
+    token: string;
+    claimUrl: string;
+    /** ISO time the project, and the token with it, expires unless claimed. */
+    expiresAt: string;
+}
+/** Keep an unclaimed project's token and claim link for this host. */
+export declare function saveEphemeralGrant(url: string, projectId: string, grant: EphemeralGrant): void;
+/** Drop a grant — once its project is claimed, or its token is refused. */
+export declare function forgetEphemeralGrant(url: string, projectId: string): void;
+/** The grant for a project on a host, while it has not expired. */
+export declare function ephemeralGrantFor(url: string, projectId: string, now?: number): EphemeralGrant | undefined;
+/**
+ * The grant as it is stored, expired or not: what a message about a refused
+ * token can still show (the claim link) after the token itself stops counting.
+ */
+export declare function storedEphemeralGrant(url: string, projectId: string): EphemeralGrant | undefined;
+/**
+ * The grant for the project this directory is linked to, when the command
+ * targets the host it was provisioned on.
+ */
+export declare function linkedEphemeralGrant(url: string): {
+    projectId: string;
+    grant: EphemeralGrant;
+} | undefined;
+/**
+ * The unexpired grant for the project a link names, on the host it names: what
+ * `status`, `unlink` and `init` read the claim URL back from. Undefined for a
+ * claimed project (its grant is gone), a direct link, or no link.
+ */
+export declare function grantForLink(link: ProjectLink | null | undefined): EphemeralGrant | undefined;
+/**
+ * The grant a link names as it is stored, expired or not, with the host it is
+ * kept under: what `rebase cloud claim` reads, so it can say "expired" rather
+ * than "never had one".
+ */
+export declare function storedGrantForLink(link: ProjectLink | null | undefined): {
+    url: string;
+    grant: EphemeralGrant;
+} | undefined;
+/** Whether a `.env` sets a variable to something: an empty `KEY=` or `KEY=""` does not. */
+export declare function dotenvSets(file: string, key: string): boolean;
+/** Whether this project's `.env` (at its root, else here) holds an app key. */
+export declare function projectDotenvSetsAppKey(): boolean;
+/**
+ * When the app key `init --claim` minted stops working, and what to do about
+ * it. It is minted to expire with the claim window; a claim hands it over to
+ * the person who claims (the control plane lifts its expiry), so an unclaimed
+ * project's key stops at the window's end and a claimed one's does not. The
+ * claimer replaces it — the agent holds a copy — with `rebase cloud app-key
+ * rotate`. Every command that knows the date says so.
+ */
+export declare function appKeyExpiryNote(expiresAt: string): string;
 /** 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;
@@ -67,6 +131,12 @@ export declare function createCloudClient(url: string): CloudClient;
 export declare const TOKEN_ENV = "REBASE_TOKEN";
 /** `REBASE_TOKEN`, trimmed, or undefined when it is unset or blank. */
 export declare function envToken(): string | undefined;
+/**
+ * The project whose `rebase cloud init --claim` token a client holds, or
+ * undefined for a session or `REBASE_TOKEN`: what `whoami` reports, since
+ * {@link requireClient} may pick the grant over `REBASE_TOKEN`.
+ */
+export declare function grantProjectOf(client: object): string | undefined;
 /**
  * A client that sends `token` as its bearer and nothing else.
  *
@@ -76,7 +146,30 @@ export declare function envToken(): string | undefined;
  * rather than by the SDK's session refresh, because there is no session to
  * refresh and "log in again" is the wrong remedy for a token.
  */
-export declare function createTokenClient(url: string, token: string): CloudClient;
+export declare function createTokenClient(url: string, token: string, ephemeralProjectId?: string): CloudClient;
+/**
+ * Say, once, that the control plane marked a token's request as deprecated.
+ *
+ * The control plane answers a request it still serves, but will not in a later
+ * release, with `Deprecation: true` (RFC 9745), a `Link` with
+ * `rel="deprecation"` to the page that explains it, and an
+ * `X-Rebase-Deprecation` sentence saying what to do — a token from before
+ * `org:billing` reading billing is the first. CI logs are where that is seen,
+ * so it goes to stderr as a warning, once per notice per process, and never
+ * into the `--json` value on stdout.
+ *
+ * Exported so its test can hand it a response.
+ */
+export declare function noticeDeprecation(response: Response): void;
+/** Forget what {@link tokenScopes} asked and who was told — each test is a new process. */
+export declare function resetTokenScopesForTest(): void;
+/**
+ * Whether the control plane still accepts a token: one request to
+ * `/api/auth/scopes`, the route every token may read. `refused` only when it
+ * answered 401 or 403; `unknown` when it could not be asked, or answered
+ * something else — which proves nothing about the token.
+ */
+export declare function probeToken(url: string, token: string): Promise<"accepted" | "refused" | "unknown">;
 /** The half of a client that holds its session — all {@link freshAccessToken} reads. */
 export interface SessionHolder {
     auth: {
@@ -108,8 +201,14 @@ export declare function freshAccessToken(client: SessionHolder): Promise<string>
  * Return an authenticated client for the resolved host.
  *
  * With `REBASE_TOKEN` set, that token is the credential for every request and
- * the stored login is not consulted at all. Otherwise it is the `cloud login`
- * session — see {@link requireSessionClient}.
+ * the stored login is not consulted at all — except in a directory linked to a
+ * project `init --claim` provisioned, when `REBASE_TOKEN` holds no scope on that
+ * project (one `/api/auth/scopes` call): the project's own token acts there
+ * instead, and the command says so once. Next, a directory linked to a
+ * project `rebase cloud init --claim` provisioned uses the token stored for it
+ * (see {@link EphemeralGrant}) until it expires: nobody can sign in as that
+ * project's owner, so a login could not reach it anyway. Otherwise it is the
+ * `cloud login` session — see {@link requireSessionClient}.
  */
 export declare function requireClient(rawArgs: string[]): Promise<{
     client: CloudClient;
@@ -123,9 +222,11 @@ export declare function requireClient(rawArgs: string[]): Promise<{
  *
  * For the commands a token cannot run — minting and revoking tokens: a key that
  * could mint keys could mint its own successor, so the control plane refuses
- * every key on those routes.
+ * every key on those routes. Inviting people is the other: it hands out access
+ * to every project in an organization, which no token capability grants.
+ * `action` names what the refusal says a token cannot do.
  */
-export declare function requireSessionClient(rawArgs: string[]): Promise<{
+export declare function requireSessionClient(rawArgs: string[], action?: string): Promise<{
     client: CloudClient;
     url: string;
 }>;
@@ -279,7 +380,15 @@ export declare function displayProjectRef(rawArgs: string[]): string;
  * `cloudCommand`, before anything can print or `fail`. Returns the resolved mode
  * (handy for tests, which otherwise leave it at its `false` default).
  */
-export declare function initOutputMode(rawArgs: string[]): boolean;
+export declare function initOutputMode(rawArgs: string[], opts?: {
+    /**
+     * What a piped run with no explicit choice gets. `json` for the family.
+     * `human` for a command whose output a person needs to read even when a
+     * program is relaying it — `cloud deploy`, whose JSON told an agent's
+     * user neither where the app was nor whether it was live.
+     */
+    whenPiped?: "json" | "human";
+}): boolean;
 /** Whether the current invocation is emitting machine-readable JSON. */
 export declare function isJsonMode(): boolean;
 /** Force the mode (tests only — production latches it via `initOutputMode`). */

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

@@ -0,0 +1,162 @@
+import type { RebaseBundleManifest } from "@rebasepro/types";
+import type { DeployHost } from "./bundle-deploy.js";
+/**
+ * Where a backend's API is mounted on its host. The runtime's default
+ * `REBASE_BASE_PATH`, which the platform does not let a project change.
+ */
+export declare const BACKEND_API_PATH = "/api";
+/** How long the live check waits by default before saying it could not confirm. */
+export declare const DEFAULT_LIVE_TIMEOUT_MS = 60000;
+/** One app a deploy shipped, and the address it now answers on. */
+export interface DeployedApp {
+    name: string;
+    type: "backend" | "static";
+    /**
+     * The address a person would open — the site for a static app, the API
+     * root for a backend. Absent when the host it is served on is unknown:
+     * a guessed URL is worse than none.
+     */
+    url?: string;
+    /** The hostname `url` is on. */
+    host?: string;
+}
+/**
+ * The apps a bundle ships, read off the bundle's own manifest.
+ *
+ * The manifest rather than `rebase.json`, because it is what was uploaded: it
+ * covers `--bundle-dir` and a static app deployed alone exactly as it covers a
+ * backend with its frontends folded in. A static app with a hostname of its own
+ * answers there; every other app answers on the project's host.
+ */
+export declare function bundleApps(manifest: Pick<RebaseBundleManifest, "app" | "kind"> & {
+    entry?: {
+        static?: RebaseBundleManifest["entry"]["static"];
+    };
+}, projectHost: string | undefined): DeployedApp[];
+/**
+ * The one app a source build ships: whatever image the build produced, on the
+ * project's host. The CLI did not build it, so it cannot say what is inside.
+ */
+export declare function sourceBuildApps(appName: string | undefined, projectHost: string | undefined): DeployedApp[];
+/**
+ * Every hostname this deploy is served on: the project's own host, then the
+ * hostnames the control plane registered for apps that declare one.
+ *
+ * The control plane's `hosts` lists only the second kind — hostnames an app's
+ * `path` names, which a deploy has to register — so for the ordinary project,
+ * served on its own `<slug>.rebase.website`, it was always empty. That read as
+ * "this deploy is served nowhere". The project's host is served by the platform
+ * from the moment the project exists, so it goes first, as verified.
+ */
+export declare function deployHosts(registered: DeployHost[] | undefined, projectHost: string | undefined): DeployHost[];
+/** What probing one app's address found. */
+export interface LiveCheck {
+    app: string;
+    /** The address probed: the site itself, or a backend's `/health` (or `/api/health`). */
+    url: string;
+    live: boolean;
+    /** The HTTP status of the last answer, when there was one. */
+    httpStatus?: number;
+    /**
+     * The deployment the answer says it came from (`x-rebase-deployment`), when
+     * it says. Only the platform's static hosting stamps it; a managed pod's
+     * readiness is the control plane's to confirm, and it did before `success`.
+     */
+    servingDeployment?: string;
+    /** Why it is not live, in a few words. */
+    reason?: string;
+}
+/**
+ * The URL that proves an app is up.
+ *
+ * For a backend, the bare `/health`: every rebase-server registers it, beside
+ * `<REBASE_BASE_PATH>/health`, and the platform routes it to the backend ahead
+ * of any static app. `/api/health` is only where it lives when the base path is
+ * the default — a project with `REBASE_BASE_PATH=/v1` and a site at `/` answers
+ * it with the site's index.html, and its deploy read as not live.
+ */
+export declare function probeUrl(app: DeployedApp): string | undefined;
+type FetchLike = typeof fetch;
+/**
+ * Probe one app once.
+ *
+ * A backend is live when its health route answers `200 {"status":"ok"}` — a
+ * site at `/` with client-side routing answers 200 to *any* path, so a bare
+ * status would let a folded SPA vouch for an API that is down. A static app is
+ * live when its address answers below 400 and, if the answer names the
+ * deployment it came from, that deployment is this one.
+ */
+export declare function probeOnce(app: DeployedApp, deploymentId: string, fetchImpl: FetchLike): Promise<LiveCheck | undefined>;
+/**
+ * Probe every app on a verified host until each is live or `timeoutMs` passes.
+ *
+ * An app on a hostname whose DNS is not verified is reported, not probed: the
+ * platform does not route it, and waiting on it would only spend the timeout.
+ * Returns one entry per app that has a URL.
+ */
+export declare function checkLive(apps: DeployedApp[], opts: {
+    deploymentId: string;
+    hosts: DeployHost[];
+    timeoutMs: number;
+    intervalMs?: number;
+    fetchImpl?: FetchLike;
+    sleep?: (ms: number) => Promise<void>;
+    now?: () => number;
+}): Promise<LiveCheck[]>;
+/** `42s`, `1m 12s`, `12m`. */
+export declare function formatDuration(ms: number): string;
+export interface DeploySummaryInput {
+    projectRef: string;
+    deploymentId: string;
+    elapsedMs: number;
+    apps: DeployedApp[];
+    /**
+     * The live check's results; `undefined` when it was not run
+     * (`--live-timeout 0`), which is said rather than passed over.
+     */
+    live: LiveCheck[] | undefined;
+    liveTimeoutMs: number;
+}
+/**
+ * The human summary a successful deploy ends on: the project, each app with its
+ * address and whether it answers, the deployment id and how long it took, and
+ * one line that says whether the new version is live.
+ */
+export declare function deploySummaryLines(input: DeploySummaryInput): string[];
+/**
+ * Whether the new version is live, as one sentence and one boolean.
+ *
+ * `live: null` when nothing was checked — the check was skipped, or no app had
+ * an address to check — which is not the same answer as "no".
+ */
+export declare function liveVerdict(live: LiveCheck[] | undefined, timeoutMs: number): {
+    live: boolean | null;
+    message: string;
+};
+/**
+ * Why a deployment failed, in one line, from its build log.
+ *
+ * The control plane ends a failed job's log on a `❌ <heading>: <why>` line (a
+ * cancelled one on `🛑`), so that line is the reason. A log without one — an
+ * older control plane, a job that died mid-write — gives its last line instead,
+ * which is still closer to the truth than "failed".
+ */
+export declare function failureReason(logs: string): string | undefined;
+/**
+ * The one line a failed deploy ends on: which app, why, and where the rest is.
+ */
+export declare function failureLine(opts: {
+    apps: string[];
+    status: string;
+    deploymentId: string;
+    logs: string;
+}): string;
+/**
+ * Where to read the rest of a failed deploy's story.
+ *
+ * A preview's build log is not production's: bare `rebase cloud logs` reads
+ * the newest PRODUCTION deployment, so pointing a failed preview at it showed
+ * the last good production build under the preview's deployment id.
+ */
+export declare function failureHint(deploymentId: string, preview?: string): string;
+export {};