@rebasepro/cli 0.13.0 → 0.13.1-canary.g249daa1

package/dist/commands/auth.d.ts

@@ -1 +1,32 @@
+/** A user as the admin API returns it, reduced to what this command needs. */
+export interface ResolvedUser {
+    id: string;
+    email: string;
+}
+/**
+ * Pick the user with exactly this email out of a search response.
+ *
+ * `/api/admin/users?search=` is an `ILIKE '%…%'` over email **or display
+ * name**, ordered by role count descending. This used to take row `[0]` and
+ * reset it, then print the email it had been *given* as confirmation — so two
+ * ordinary situations ended in a successful-looking reset of somebody else's
+ * account:
+ *
+ *   - a substring collision: `bob@example.com` also matches
+ *     `robert.bob@example.com`;
+ *   - a display name, which is user-controlled and accepted up to 255
+ *     characters with no constraint on its content, containing an address
+ *     belonging to someone else.
+ *
+ * The ordering makes it worse rather than better — `array_length(roles) DESC
+ * NULLS LAST` puts the most privileged match first, so the account most likely
+ * to be reset by mistake is an admin's.
+ *
+ * Returns `undefined` when nothing matched exactly, which the caller reports
+ * rather than falling through to a guess. The direct-database fallback below
+ * has always matched with `eq(usersTable.email, email)`; this is the same
+ * definition, so the command no longer resets different accounts depending on
+ * whether the backend happened to be running.
+ */
+export declare function selectUserForEmail(payload: unknown, email: string): ResolvedUser | undefined;
 export declare function authCommand(subcommand: string | undefined, rawArgs: string[]): Promise<void>;

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

@@ -1 +1,2 @@
 export declare function dbCommand(subcommand: string | undefined, rawArgs: string[]): Promise<void>;
+export declare function printDbHelp(): void;

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

@@ -115,3 +115,4 @@ export declare function formatDuration(seconds: number): string;
  */
 export declare function parseSince(input: string | undefined): number | null;
 export declare function debugCommand(action: string | undefined, rawArgs: string[]): Promise<void>;
+export declare function printDebugHelp(): void;

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

@@ -1 +1,2 @@
 export declare function domainsCommand(action: string | undefined, rawArgs: string[]): Promise<void>;
+export declare function printDomainsHelp(): void;

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

@@ -6,3 +6,4 @@ export declare function parseEnvAssignment(operands: string[]): {
 } | null;
 /** The prefix that makes `key` a build-time variable, or undefined. */
 export declare function buildTimeEnvPrefix(key: string): string | undefined;
+export declare function printEnvHelp(): void;

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

@@ -1,3 +1,4 @@
 /** The identifier CREATE EXTENSION takes. `pgvector` is a common alias. */
 export declare function resolveExtensionAlias(name: string): string;
 export declare function extensionsCommand(action: string | undefined, rawArgs: string[]): Promise<void>;
+export declare function printExtensionsHelp(): void;

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

@@ -1 +1,2 @@
 export declare function orgsCommand(subcommand: string | undefined, rawArgs: string[]): Promise<void>;
+export declare function printOrgsHelp(): void;

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

@@ -59,6 +59,7 @@ 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 printStorageHelp(): void;
 export declare function clustersCommand(rawArgs: string[]): Promise<void>;
 export declare function billingCommand(rawArgs: string[]): Promise<void>;
 export {};

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

@@ -6,3 +6,4 @@ export declare function buildSettingsPatch(args: {
     repo?: string;
     branch?: string;
 }): Record<string, string>;
+export declare function printSettingsHelp(): void;

package/dist/commands/dev.d.ts

@@ -6,12 +6,5 @@ export declare const DEV_PORT_FILENAME = ".rebase-dev-port";
  * Two different project directories will almost always get different ports.
  */
 export declare function getProjectPort(projectRoot: string): number;
-/**
- * Resolve the best starting port for this project:
- * 1. Explicit --port flag (highest priority)
- * 2. PORT env var
- * 3. Previously used port from .rebase-dev-port (port affinity across restarts)
- * 4. Deterministic hash from project path (unique per project)
- */
 export declare function resolveStartPort(projectRoot: string, explicitPort?: number): number;
 export declare function devCommand(rawArgs: string[]): Promise<void>;

package/dist/commands/init.d.ts

@@ -68,4 +68,55 @@ export declare function formatCdTarget(cwd: string, targetDirectory: string): st
  * triggering the non-TTY error. */
 export declare function printInitHelp(): void;
 export declare function createRebaseApp(rawArgs: string[]): Promise<void>;
+/**
+ * Whether `port` is free — on the wildcard address *and* on both loopback addresses.
+ *
+ * All three, because on macOS/BSD a successful bind does not mean the port is
+ * unused. Sockets carry `SO_REUSEADDR` (Node sets it), under which a wildcard
+ * bind and a specific-address bind on the same port do not conflict — in either
+ * direction. So each probe alone has a blind spot, and they are different ones:
+ *
+ * - **Wildcard only** (what this used to do) misses a server bound to
+ *   `127.0.0.1` and `[::1]` — a Homebrew or Postgres.app install, i.e. most
+ *   developer machines. 5432 was reported free while it was already serving
+ *   another project's database. Docker then published `*:5432` for the same
+ *   reason and the container started cleanly, with no "port already allocated"
+ *   error anywhere to hint at the collision. `DATABASE_URL` pointed at
+ *   `localhost:5432`, `localhost` resolves to `::1` first, and every command
+ *   reported success while reading and writing the *pre-existing* database — a
+ *   `db push` would have created tables, roles and RLS policies inside it.
+ *
+ * - **Loopback only** misses the opposite case: Docker Desktop publishes a
+ *   container's port on `*`, and a specific-address bind succeeds right past it.
+ *   That port is free to probe and unusable to publish, so `docker compose up -d
+ *   db` fails on "Bind for 0.0.0.0:PORT failed: port is already allocated" —
+ *   loudly, but only after the project has been generated around the bad port.
+ *
+ * Requiring all three costs three sockets and leaves neither gap. The wildcard
+ * bind is the one the container itself has to make; the loopback binds are the
+ * addresses `DATABASE_URL` will actually name.
+ */
+export declare function isPortAvailable(port: number): Promise<boolean>;
+/**
+ * The runtime image tag to pin, given the version of the CLI doing the scaffolding.
+ *
+ * Only a stable release publishes `rebasepro/server` — a multi-arch build on
+ * every push to main would cost minutes per commit for an image nobody pulls.
+ * So pinning a prerelease CLI's own version writes a tag that cannot exist, and
+ * `docker compose up` fails on `manifest unknown`, which is the same dead end
+ * as the missing-repository bug this pinning was added to prevent.
+ *
+ * A prerelease therefore falls back to `latest`, which is correct rather than
+ * merely available: a bundle's manifest declares the runtime range it needs
+ * (`^1`), the image supplies only `@rebasepro/server`, and the framework a
+ * bundle runs is installed from its own `deps.declared` at boot. The current
+ * stable runtime boots a canary bundle by design.
+ *
+ * A floating tag is a real cost — it is what pinning exists to avoid — so say
+ * so in the file rather than leaving a reader to discover it.
+ */
+export declare function resolveRuntimeImageTag(cliVersion: string): {
+    tag: string;
+    note?: string;
+};
 export declare function configureEnvFile(targetDirectory: string, databaseUrl?: string): Promise<void>;

package/dist/fold-static.d.ts

@@ -62,6 +62,53 @@ export declare function foldableApps(manifest: FoldableManifest): {
  * evidence of a misbuild.
  */
 export declare function assertBuiltForPath(indexHtml: string, basePath: string, appName: string): void;
+/**
+ * The environment every static app is built with, wherever that build is driven from.
+ *
+ * Shared because there are two drivers — `foldFrontendIntoBundle` here, and
+ * `buildAssetApp` in `build.ts` for a standalone `type: "static"` app — and they
+ * had already drifted: the path variables were duplicated into both, so a fix
+ * applied to one shipped a bundle built the old way from the other. One function
+ * makes that impossible rather than merely unlikely.
+ *
+ * ## REBASE_APP_*
+ *
+ * The declared path is a build-time input, not only a serving concern: Vite
+ * reads `base` from REBASE_APP_BASE, and the trailing slash is that field's
+ * convention. See `assertBuiltForPath`.
+ *
+ * ## NODE_ENV
+ *
+ * A built app is a production artifact by construction, so build it as one. Not
+ * a formality: the scaffold's `.env` carries `NODE_ENV=development` for the dev
+ * backend, and Vite's `loadEnv` promotes a `NODE_ENV` found in an env file into
+ * the build unless the environment already sets one. So `rebase build` and
+ * `rebase cloud deploy` shipped a *development* bundle — `import.meta.env.DEV
+ * === true`, development React, dev-only branches live — from commands whose
+ * whole purpose is to produce something deployable. Setting it here is what
+ * closes it: Vite consults the env file's NODE_ENV only when `process.env`
+ * has none.
+ *
+ * ## VITE_API_URL
+ *
+ * An app served by the backend it talks to has its API on its own origin by
+ * construction, so a baked-in absolute URL can only be wrong. It was: that same
+ * `.env` carries `VITE_API_URL=http://localhost:3001` and
+ * `frontend/vite.config.ts` reads the project root via `envDir: ".."`, so a
+ * stock deploy shipped a site whose every request went to whoever ran the build
+ * — passing every server-side health check on the way out. Blanking it here
+ * fixes the bundle even for a project whose `.env` predates the `init` fix, or
+ * was written by hand. Empty is the right value rather than a missing one: the
+ * client falls back to `window.location.origin`, which keeps working when a
+ * custom domain is added.
+ *
+ * Vite prioritises `process.env.VITE_*` over `.env` files, so an explicit
+ * `VITE_API_URL=https://api.example.com rebase cloud deploy` still wins — the
+ * cross-origin escape hatch stays open, it just has to be deliberate. Nothing on
+ * this path loads the project `.env` into `process.env`, so a value inherited
+ * here really was set by the caller.
+ */
+export declare function staticBuildEnv(appPath: string, appName: string): Record<string, string>;
 /**
  * Build the project's static apps and fold them into the backend bundle.
  *