@rebasepro/cli 0.17.1 → 0.17.2-canary.g4d21a53

package/dist/commands/cloud/action-help.d.ts

@@ -0,0 +1,26 @@
+export interface ActionHelp {
+    /** `cloud projects create` — no leading `rebase`. */
+    command: string;
+    /** The usage line, minus the `rebase ` prefix. */
+    usage: string;
+    /** One paragraph: what the command does, and what it does not. */
+    summary: string;
+    /** `[flag, description]`, in the order a reader needs them. */
+    flags: Array<[string, string]>;
+    examples: string[];
+    /** Anything a caller gets wrong more than once. */
+    notes?: string[];
+}
+/**
+ * Flags every cloud command accepts, documented once.
+ *
+ * Excluded from the spec comparison below — they are merged in by
+ * `parseCloudArgs` for every command in the family, so repeating them per entry
+ * would be nine copies of the same four lines.
+ */
+export declare const GLOBAL_HELP_FLAGS: Array<[string, string]>;
+/** Flag names that `parseCloudArgs` adds to every command in the family. */
+export declare const GLOBAL_SPEC_KEYS: Set<string>;
+export declare const ACTION_HELP: Record<string, ActionHelp>;
+/** Print one action's page — human, or its JSON description when piped. */
+export declare function printActionHelp(entry: ActionHelp): void;

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

@@ -347,6 +347,22 @@ export declare function parseCloudArgs<S extends arg.Spec>(opts: {
     flags: arg.Result<S & typeof GLOBAL_CLOUD_FLAGS>;
     positionals: string[];
 };
+/**
+ * `--timeout <seconds>` as milliseconds, or `fallbackMs` when it was not given.
+ *
+ * One function rather than one per command, because two commands take this flag
+ * and a second copy is where the two would come to disagree about what
+ * `--timeout 0` means.
+ *
+ * A value this cannot read is a refusal, not a fall back to the default. The
+ * whole reason a caller passes a timeout is that it has a deadline of its own;
+ * quietly substituting a different one is how a fifteen-minute wait turns up
+ * inside a five-minute CI step, having been asked for `--timeout 30s`.
+ */
+export declare function resolveTimeoutMs(value: string | undefined, opts: {
+    fallbackMs: number;
+    command: string;
+}): number;
 /**
  * Announce an outcome — "Logged in as …", "Deleted project …".
  *
@@ -392,6 +408,12 @@ export declare function keyValues(rows: Array<[string, string | null | undefined
 /**
  * Surface an SDK/HTTP error consistently. The SDK throws RebaseApiError with
  * a `.status` and `.message`; anything else falls back to its string form.
+ *
+ * The message is summarised rather than printed — see `summarizeError`. What
+ * arrives here is routinely a whole Kubernetes `Status` object with the request
+ * headers appended, and the one sentence worth reading is inside it. The
+ * untouched body is still available, behind `--debug`, on stderr where it
+ * cannot corrupt the JSON value on stdout.
  */
 export declare function reportError(e: unknown, context: string): never;
 /**

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

@@ -7,7 +7,54 @@
  *   db backup list|create|restore
  */
 import arg from "arg";
+import { type CloudClient } from "./context.js";
+interface DatabaseRow {
+    id: string | number;
+    type?: string;
+    connectionStatus?: string;
+    useSshTunnel?: boolean;
+    pitrEnabled?: boolean;
+}
 export declare function dbCommand(subcommand: string | undefined, rawArgs: string[]): Promise<void>;
+/**
+ * Attach a database row to a project.
+ *
+ * Extracted so `rebase cloud projects create` can do it in the same breath as
+ * creating the project — see `--db` there. Two call sites, one insert, so the
+ * shape of the row cannot drift between "attached at creation" and "attached
+ * afterwards".
+ */
+export declare function attachDatabaseRow(client: CloudClient, input: {
+    projectId: string;
+    type: string;
+    connectionString?: string;
+}): Promise<DatabaseRow>;
+/** What `rebase cloud db create` parses. Exported so its help page cannot drift. */
+export declare const CREATE_DATABASE_FLAGS: {
+    readonly "--type": StringConstructor;
+    readonly "--connection-string": StringConstructor;
+    readonly "--wait": BooleanConstructor;
+    readonly "--timeout": StringConstructor;
+    readonly "--project": StringConstructor;
+    readonly "-p": "--project";
+};
+/**
+ * Wait for an attached database to become usable, where "usable" means
+ * something.
+ *
+ * Returns `waited: false` for the managed case, and says why — the caller then
+ * knows the state it is looking at is final rather than early.
+ */
+export declare function waitForDatabase(client: CloudClient, opts: {
+    projectId: string;
+    type: string;
+    timeoutMs: number;
+    pollMs?: number;
+}): Promise<{
+    waited: boolean;
+    connectionStatus: string;
+    note?: string;
+}>;
 /**
  * `db backup [action] [filename]`, resolved in one strict parse.
  *
@@ -39,3 +86,4 @@ export declare function resolveBackupArgs(rawArgs: string[]): {
     filename: string;
 };
 export declare function printDbHelp(): void;
+export {};

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

@@ -124,6 +124,26 @@ export declare function ejectRefusal(opts: EjectContext, projectRef: string): {
 export declare function deployWarnings(opts: EjectContext, projectRef: string): DeployWarning[];
 /** The warning half of a deploy's JSON payload — merged into whatever it emits. */
 export declare function warningPayload(warnings: DeployWarning[]): Record<string, unknown>;
+/**
+ * Every flag `rebase cloud deploy` accepts.
+ *
+ * Hoisted out of the `parseCloudArgs` call so that one declaration serves three
+ * readers: the parser, `action-help.ts`'s page for this command, and the test
+ * that holds the two to each other. A flag added here with no line in the help
+ * page is a failing test rather than a flag nobody can discover.
+ */
+export declare const DEPLOY_FLAGS: {
+    readonly "--no-follow": BooleanConstructor;
+    readonly "--wait": BooleanConstructor;
+    readonly "--timeout": StringConstructor;
+    readonly "--source": StringConstructor;
+    readonly "--message": StringConstructor;
+    readonly "--bundle": BooleanConstructor;
+    readonly "--bundle-dir": StringConstructor;
+    readonly "--skip-type-check": BooleanConstructor;
+    readonly "--force": BooleanConstructor;
+    readonly "-m": "--message";
+};
 /**
  * `rebase cloud deploy [app]` — its flags, and which app of this repository the
  * line named.
@@ -148,14 +168,16 @@ export declare function warningPayload(warnings: DeployWarning[]): Record<string
  */
 export declare function resolveDeployArgs(rawArgs: string[]): {
     flags: arg.Result<{
-        "--no-follow": BooleanConstructor;
-        "--source": StringConstructor;
-        "--message": StringConstructor;
-        "--bundle": BooleanConstructor;
-        "--bundle-dir": StringConstructor;
-        "--skip-type-check": BooleanConstructor;
-        "--force": BooleanConstructor;
-        "-m": string;
+        readonly "--no-follow": BooleanConstructor;
+        readonly "--wait": BooleanConstructor;
+        readonly "--timeout": StringConstructor;
+        readonly "--source": StringConstructor;
+        readonly "--message": StringConstructor;
+        readonly "--bundle": BooleanConstructor;
+        readonly "--bundle-dir": StringConstructor;
+        readonly "--skip-type-check": BooleanConstructor;
+        readonly "--force": BooleanConstructor;
+        readonly "-m": "--message";
     } & {
         readonly "--json": BooleanConstructor;
         readonly "--yes": BooleanConstructor;
@@ -169,4 +191,6 @@ export declare function resolveDeployArgs(rawArgs: string[]): {
     appName: string | undefined;
 };
 export declare function deployCommand(rawArgs: string[], projectRef: string): Promise<void>;
+/** `--timeout <seconds>` for a deploy, or the 15-minute default. */
+export declare function resolveDeployTimeout(value: string | undefined): number;
 export declare function logsCommand(rawArgs: string[], projectRef: string): Promise<void>;

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

@@ -0,0 +1,80 @@
+/**
+ * Turning a control-plane failure into something the caller can act on.
+ *
+ * The control plane talks to Kubernetes, and when Kubernetes refuses it, the
+ * refusal travels back verbatim: a whole `Status` object, the request headers,
+ * an `audit-id`, an `x-kubernetes-pf-flowschema-uid`. That reached the user's
+ * terminal unedited. Two things are wrong with it beyond the noise.
+ *
+ * The first is that the one sentence that matters is buried in the middle of a
+ * JSON blob, so the remedy — if there is one — is the hardest part to find.
+ *
+ * The second is worse, and is the reason this file exists rather than a
+ * `slice(0, 200)`. A `403` naming a `system:serviceaccount:` is a statement
+ * about the PLATFORM's own credentials: some role the control plane runs as is
+ * missing a grant. Nothing in the user's project can change that — not the
+ * collections, not `rebase.json`, not the deploy flags — and the error, printed
+ * raw in the middle of `rebase cloud deploy`, reads exactly like a project
+ * fault. Someone acting on that reading deletes working code looking for the
+ * cause. (That is not hypothetical: three cron jobs were removed from a project
+ * to test whether they caused a `cronjobs.batch` 403. They did not.)
+ *
+ * So this classifies before it summarises, and says whose problem it is.
+ */
+/** What a Kubernetes API refusal carries, once it is found. */
+export interface KubernetesStatus {
+    message?: string;
+    reason?: string;
+    code?: number;
+    details?: {
+        group?: string;
+        kind?: string;
+        name?: string;
+    };
+}
+export interface ErrorSummary {
+    /** One line, safe to print. Never the raw body. */
+    message: string;
+    /** A remedy, when one exists — or the reason there is none. */
+    hint?: string;
+    /** A stable code for `--json` callers to branch on. */
+    code: string;
+    /**
+     * Whether the failure is the platform's rather than the project's.
+     *
+     * The whole point of the summary: a caller that retries or mutates the
+     * project on a platform-side refusal makes things worse, and an agent
+     * cannot tell from the prose.
+     */
+    platform: boolean;
+    /** The untouched original, printed only under `--debug`. */
+    raw: string;
+}
+/**
+ * A Kubernetes `Status` object embedded anywhere in a message.
+ *
+ * Scanned for rather than parsed off the front: the control plane wraps it
+ * ("Failed to create the tenant namespace: …"), the client library appends
+ * headers after it, and both halves are worth keeping out of the summary.
+ * Balanced-brace scanning rather than a regex, because `details.causes` nests
+ * and a lazy `\{.*?\}` truncates the object at the first inner brace — which
+ * parses to nothing and silently falls through to the raw message.
+ */
+export declare function extractKubernetesStatus(text: string): KubernetesStatus | undefined;
+/**
+ * One actionable line (plus a hint) from whatever the control plane returned.
+ *
+ * `status` is the HTTP status of the control-plane call itself, which is a
+ * different number from the `code` inside an embedded Kubernetes `Status` — the
+ * control plane routinely answers 500 while the cluster answered 403, and it is
+ * the inner one that says what happened.
+ */
+export declare function summarizeError(error: unknown, context: string): ErrorSummary;
+/**
+ * Whether the caller asked for the untouched body.
+ *
+ * `--debug` is already what `bin/rebase.js` prints after every failure as the
+ * thing to add, so the raw payload hangs off the flag people are told to reach
+ * for rather than off one invented here.
+ */
+export declare function wantsRawError(argv?: readonly string[]): boolean;

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

@@ -42,6 +42,23 @@ export declare const CREATE_PROJECT_FLAGS: {
     readonly "--region": StringConstructor;
     readonly "--org": StringConstructor;
     readonly "--link": BooleanConstructor;
+    /**
+     * Which database the new project gets — `managed` (the default), `byodb`,
+     * or `none`.
+     *
+     * A default rather than a prompt, and `managed` rather than `none`, because
+     * the state this removes is not a missing convenience: a project with no
+     * database is written `status: "provisioning"` and can never deploy, and
+     * nothing in that word says a second command is owed. Attaching one here
+     * means the two-command sequence that every project needs is one command,
+     * and `--db none` is there for the case that genuinely wants to decide later.
+     *
+     * Distinct from `--db-mode`/`--db-cpu` next to it, which are resource dials
+     * on a database that exists. This is whether there is one.
+     */
+    readonly "--db": StringConstructor;
+    /** For `--db byodb`. Same spelling as `rebase cloud db create` uses. */
+    readonly "--connection-string": StringConstructor;
     readonly "-n": "--name";
     readonly "--cpu": StringConstructor;
     readonly "--memory": StringConstructor;

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

@@ -35,6 +35,41 @@ export declare function describeStorageState(state: StorageState | undefined): s
  * type; the verdict appears once there is one.
  */
 export declare function describeDatabaseState(db: Record<string, unknown> | undefined): string | undefined;
+/**
+ * The one thing standing between this project and a live URL, if anything is.
+ *
+ * `status` alone cannot answer that, and the gap is not cosmetic. A project
+ * created through `projects create` is written `status: "provisioning"` and has
+ * no database until one is attached — so the platform is not provisioning
+ * anything, it is waiting for a second command that nothing in the output names.
+ * "Provisioning" reads as *work in progress*, and the correct response to work
+ * in progress is to wait. So the correct response to this state, for a person
+ * and an agent alike, is the one thing that is guaranteed never to resolve it.
+ *
+ * That cost 43 minutes of polling on a first deploy, and an unattended agent
+ * would still be polling: nothing about the state changes, ever, so there is no
+ * timeout short enough to be wrong and no timeout long enough to be right.
+ *
+ * `blockedOn: null` is therefore load-bearing — it is the CLI saying "waiting is
+ * the correct thing to do here", which is the only condition under which a
+ * caller should poll. Everything else names a command.
+ */
+export interface BlockedState {
+    /** A stable slug, or `null` when the platform genuinely is working. */
+    blockedOn: string | null;
+    /** The exact command that unblocks it. `null` when nothing is blocked. */
+    nextAction: string | null;
+}
+export declare function resolveBlockedState(input: {
+    projectStatus?: string | null;
+    /** The project's database row, or undefined when none is attached. */
+    database?: {
+        connectionStatus?: string | null;
+    } | undefined;
+    lastDeploy?: {
+        status?: string | null;
+    } | undefined;
+}): BlockedState;
 /**
  * One line describing what engine is serving this project.
  *
@@ -82,6 +117,37 @@ export declare function printStorageHelp(): void;
  * cluster" flow is a different feature with a different threat model.
  */
 export declare function clustersCommand(action: string | undefined, rawArgs: string[]): Promise<void>;
+/**
+ * Ask a registered cluster whether it can actually host a tenant.
+ *
+ * The question this exists to answer early is the one that otherwise gets
+ * answered by a customer's first deploy failing halfway through provisioning,
+ * with an error they cannot act on and half a tenant already created.
+ */
+/**
+ * Which cluster `clusters verify` was asked about, and whether `--baseline`
+ * was given.
+ *
+ * Resolved against a real spec, not scanned out of `rawArgs` by hand — and this
+ * is not a tidy-up. `rawArgs` is the whole `process.argv`, so the old scan
+ * ("the first token that is not `--…` and is neither `clusters` nor `verify`")
+ * matched `argv[0]`, the **node binary path**. Every `rebase cloud clusters
+ * verify <id>` therefore asked the control plane about a cluster called
+ * `/usr/local/bin/node`, and came back 404.
+ *
+ * So the one diagnostic that reports `permissions.allowed` /
+ * `permissions.denied` was unreachable, and its 404 read as "this command is
+ * not deployed yet" rather than "the id never left this machine intact". It is
+ * the command that names a missing `cronjobs.batch` grant in a single call
+ * instead of a twenty-minute A/B against a live project.
+ *
+ * Same failure as `cloud deploy` reading `_[0]` as `"cloud"`, and the same fix:
+ * one parser, exported so its test drives the real thing rather than a copy.
+ */
+export declare function resolveClusterVerifyArgs(rawArgs: string[]): {
+    id?: string;
+    baseline: boolean;
+};
 export declare function billingCommand(rawArgs: string[]): Promise<void>;
 /**
  * `rebase cloud resources` — show what a project is given, and change it.

package/dist/constraints-DKGbNfUW.js

@@ -0,0 +1,48 @@
+//#region src/dev-db/constraints.ts
+/**
+* Extensions to hand PGlite's constructor.
+*
+* `CREATE EXTENSION` alone cannot install these — PGlite resolves them from
+* bundles supplied at construction time, so anything missing here is missing
+* from the database no matter what the migration says.
+*
+* The module is spelled out per extension rather than derived from the name,
+* because they do not all live in the same place: the two contrib ones are
+* subpaths of PGlite itself, and pgvector is a package of its own. Deriving the
+* path is what left `vector` off this list — `@electric-sql/pglite/contrib/vector`
+* does not exist, so a project declaring a `{ type: "vector" }` property could
+* not use the managed dev database at all.
+*/
+var PGLITE_EXTENSIONS = [
+	{
+		name: "pg_trgm",
+		module: "@electric-sql/pglite/contrib/pg_trgm",
+		export: "pg_trgm"
+	},
+	{
+		name: "unaccent",
+		module: "@electric-sql/pglite/contrib/unaccent",
+		export: "unaccent"
+	},
+	{
+		name: "vector",
+		module: "@electric-sql/pglite-pgvector",
+		export: "vector"
+	}
+];
+/**
+* Announced at startup, every time, rather than discovered.
+*
+* A developer who does not know realtime is off will read the silence as a bug
+* in their own code, which is a worse outcome than not offering the managed
+* database at all.
+*/
+var MANAGED_LIMITATIONS = [{
+	id: "concurrency",
+	summary: "Requests are served one at a time. Behaviour is correct but serialized, so lock contention and job-queue concurrency cannot be reproduced here.",
+	remedy: "Reproduce concurrency against a real Postgres: rebase dev --docker"
+}];
+//#endregion
+export { PGLITE_EXTENSIONS as n, MANAGED_LIMITATIONS as t };
+
+//# sourceMappingURL=constraints-DKGbNfUW.js.map

package/dist/constraints-DKGbNfUW.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constraints-DKGbNfUW.js","names":[],"sources":["../src/dev-db/constraints.ts"],"sourcesContent":["/**\n * What PGlite can and cannot do as a development database, measured rather\n * than assumed.\n *\n * Everything in this directory is shaped by four facts, each established by\n * running it against `@electric-sql/pglite` 0.5.6 and\n * `@electric-sql/pglite-socket` 0.2.9 rather than by reading their docs. They\n * are recorded here because two of them are silent failures — the kind that\n * make a developer lose an evening to a feature that reports success and does\n * nothing.\n *\n * 1. **It is really PostgreSQL 18.3.** `select version()` over the socket\n *    returns `PostgreSQL 18.3 (PGlite 0.5.6) on wasm32`, which is the same\n *    major as the `postgres:18-alpine` the eject template ships. So a dev\n *    database here and a compose database there are the same Postgres, and\n *    schema behaviour does not diverge between them.\n *\n * 2. **`pg_trgm` and `unaccent` are available**, which is what search\n *    collections need. They are not installed by a bare `CREATE EXTENSION`,\n *    though — PGlite ships them as separate bundles that must be passed to the\n *    constructor, and without that `CREATE EXTENSION pg_trgm` fails with\n *    `extension \"pg_trgm\" is not available`. {@link PGLITE_EXTENSIONS} is that\n *    list, and it has to stay in step with what the schema generator emits.\n *\n * 3. **RLS is enforced exactly as it is on a real server.** With\n *    `SET LOCAL ROLE \"rebase_user\"` inside a transaction — which is how\n *    `PostgresBackendDriver` isolates every request — `current_user` becomes\n *    the restricted role, `session_user` stays the owner, and a policy using\n *    `current_setting('app.tenant')` filters rows correctly, including under\n *    `FORCE ROW LEVEL SECURITY`. Measured: an owner saw 3 rows and the\n *    role-switched transaction saw 2, with the cross-tenant probe returning 0.\n *    This is the one that mattered most: a dev database that quietly failed to\n *    apply RLS would give false confidence about the product's central claim.\n *\n * 4. **Concurrency is the real limit, and it fails badly.** PGlite is a single\n *    session, and `PGLiteSocketServer` multiplexes connections onto it. Two\n *    pooled clients that hold *overlapping transactions* deadlock — not error,\n *    hang — which is precisely what a request-per-transaction server does under\n *    any concurrent load. {@link MANAGED_POOL_MAX} is the answer: one client\n *    connection, so requests queue in the pool instead of deadlocking in the\n *    multiplexer. Measured: with a pool of 1, four concurrent queries and a\n *    role-switched RLS transaction all pass; with a pool of 5 the same script\n *    hangs indefinitely.\n *\n * 5. **LISTEN/NOTIFY needed repairing, and now works.** A notification is an\n *    asynchronous message with no request to answer, and the multiplexer hands\n *    it to whichever socket is reading rather than to the one that issued\n *    `LISTEN` — so a dedicated listener connection, which is exactly how the\n *    realtime engine works, received nothing while the *writer* received\n *    notifications it never asked for. `notification-proxy.ts` corrects that by\n *    copying every `NotificationResponse` frame to every client, which for a\n *    single-session database is simply the truth. Realtime therefore works\n *    against the managed database, with no change to the server: it does\n *    ordinary `LISTEN` over ordinary libpq.\n */\n\n/** One extension bundle, and where to import it from. */\nexport interface PgliteExtension {\n    /** The name `CREATE EXTENSION` uses, and the key PGlite is handed. */\n    name: string;\n    /** Module the bundle is imported from. */\n    module: string;\n    /** The named export carrying the bundle. */\n    export: string;\n}\n\n/**\n * Extensions to hand PGlite's constructor.\n *\n * `CREATE EXTENSION` alone cannot install these — PGlite resolves them from\n * bundles supplied at construction time, so anything missing here is missing\n * from the database no matter what the migration says.\n *\n * The module is spelled out per extension rather than derived from the name,\n * because they do not all live in the same place: the two contrib ones are\n * subpaths of PGlite itself, and pgvector is a package of its own. Deriving the\n * path is what left `vector` off this list — `@electric-sql/pglite/contrib/vector`\n * does not exist, so a project declaring a `{ type: \"vector\" }` property could\n * not use the managed dev database at all.\n */\nexport const PGLITE_EXTENSIONS: readonly PgliteExtension[] = [\n    { name: \"pg_trgm\", module: \"@electric-sql/pglite/contrib/pg_trgm\", export: \"pg_trgm\" },\n    { name: \"unaccent\", module: \"@electric-sql/pglite/contrib/unaccent\", export: \"unaccent\" },\n    { name: \"vector\", module: \"@electric-sql/pglite-pgvector\", export: \"vector\" }\n];\n\n/**\n * Client connections the managed database tolerates: exactly one.\n *\n * Not a tuning choice. Two concurrent transactions over the socket\n * multiplexer deadlock, and a request-per-transaction server produces those\n * the moment two requests overlap. One connection converts that deadlock into\n * ordinary queueing, which is slower and correct.\n */\nexport const MANAGED_POOL_MAX = 1;\n\n/**\n * Connections the socket server will accept.\n *\n * Above {@link MANAGED_POOL_MAX} so that a second *non-transactional* client —\n * `rebase db push` in another terminal while `rebase dev` runs — is refused\n * with a connection error rather than corrupting the multiplexer. The pool\n * limit is what prevents overlapping transactions; this only stops a stampede.\n */\nexport const MANAGED_SERVER_MAX_CONNECTIONS = 4;\n\n/** What a managed PGlite database cannot do, in the words the user needs. */\nexport interface ManagedLimitation {\n    /** Stable id, so a warning can be suppressed or tested for. */\n    id: string;\n    /** One line, naming the feature rather than the mechanism. */\n    summary: string;\n    /** What to do instead. Always a concrete command. */\n    remedy: string;\n}\n\n/**\n * Announced at startup, every time, rather than discovered.\n *\n * A developer who does not know realtime is off will read the silence as a bug\n * in their own code, which is a worse outcome than not offering the managed\n * database at all.\n */\nexport const MANAGED_LIMITATIONS: readonly ManagedLimitation[] = [\n    {\n        id: \"concurrency\",\n        summary:\n            \"Requests are served one at a time. Behaviour is correct but serialized, so \" +\n            \"lock contention and job-queue concurrency cannot be reproduced here.\",\n        remedy: \"Reproduce concurrency against a real Postgres: rebase dev --docker\"\n    }\n] as const;\n"],"mappings":";;;;;;;;;;;;;;;AAgFA,IAAa,oBAAgD;CACzD;EAAE,MAAM;EAAW,QAAQ;EAAwC,QAAQ;CAAU;CACrF;EAAE,MAAM;EAAY,QAAQ;EAAyC,QAAQ;CAAW;CACxF;EAAE,MAAM;EAAU,QAAQ;EAAiC,QAAQ;CAAS;AAChF;;;;;;;;AAuCA,IAAa,sBAAoD,CAC7D;CACI,IAAI;CACJ,SACI;CAEJ,QAAQ;AACZ,CACJ"}

package/dist/{daemon-entry-Brq-S8XX.js → daemon-entry-CmJn83zu.js}

@@ -1,5 +1,5 @@
 import { a as findFreePort, d as writeState, n as clearState, r as dataDir } from "./state-c0CJ6Kwb.js";
-import { n as PGLITE_EXTENSION_NAMES } from "./constraints-BK1_4vci.js";
+import { n as PGLITE_EXTENSIONS } from "./constraints-DKGbNfUW.js";
 import fs from "fs";
 import net from "net";
 //#region src/dev-db/notification-proxy.ts
@@ -262,19 +262,29 @@ function parseDaemonArgs(argv) {
 	};
 }
 /**
-* Load the extension bundles PGlite needs by name.
+* Load the extension bundles PGlite needs.
 *
 * `CREATE EXTENSION pg_trgm` cannot install anything on its own here — PGlite
 * resolves extensions from bundles handed to the constructor, and a missing one
 * fails at migration time with `extension "pg_trgm" is not available`, which
 * reads like a broken database rather than a missing import.
+*
+* Every failure here is loud for that reason, including the one that is new:
+* pgvector arrives from a package of its own, so unlike the contrib bundles it
+* can be absent while PGlite itself is fine.
 */
 async function loadExtensions() {
 	const extensions = {};
-	for (const name of PGLITE_EXTENSION_NAMES) {
-		const bundle = (await import(`@electric-sql/pglite/contrib/${name}`))[name];
-		if (!bundle) throw new Error(`@electric-sql/pglite/contrib/${name} did not export "${name}". The installed PGlite version may not ship this extension.`);
-		extensions[name] = bundle;
+	for (const extension of PGLITE_EXTENSIONS) {
+		let module;
+		try {
+			module = await import(extension.module);
+		} catch (err) {
+			throw new Error(`Could not load "${extension.module}", which supplies the ${extension.name} extension: ${err instanceof Error ? err.message : String(err)}\nIt is an optional dependency of @rebasepro/cli — reinstall the project, or run \`rebase dev --docker\` to use a real Postgres instead.`);
+		}
+		const bundle = module[extension.export];
+		if (!bundle) throw new Error(`${extension.module} did not export "${extension.export}". The installed PGlite version may not ship this extension.`);
+		extensions[extension.name] = bundle;
 	}
 	return extensions;
 }
@@ -375,4 +385,4 @@ async function runDaemon(args) {
 //#endregion
 export { parseDaemonArgs, runDaemon };
 
-//# sourceMappingURL=daemon-entry-Brq-S8XX.js.map
+//# sourceMappingURL=daemon-entry-CmJn83zu.js.map

package/dist/daemon-entry-CmJn83zu.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"daemon-entry-CmJn83zu.js","names":[],"sources":["../src/dev-db/notification-proxy.ts","../src/dev-db/daemon-entry.ts"],"sourcesContent":["/**\n * A transparent Postgres proxy that puts LISTEN/NOTIFY back.\n *\n * Without this, realtime does not work against the managed database — and it\n * fails silently, which is worse than failing. The reason is specific and\n * measurable:\n *\n * PGlite is a *single* backend session, and `PGLiteSocketServer` multiplexes\n * every client connection onto it. `LISTEN` is therefore session-wide: whichever\n * client issues it arms the whole database. But a `NotificationResponse` is an\n * asynchronous message with no request to answer, so the multiplexer hands it to\n * whichever socket happens to be reading the protocol stream at that moment —\n * which is the client that *caused* the notification, not the one that asked for\n * it.\n *\n * Measured against pglite-socket 0.2.9:\n *\n *   LISTEN and NOTIFY on one connection      → delivered\n *   trigger-fired pg_notify, same connection → delivered\n *   another connection causes the notify     → NOT delivered to the listener\n *   …and the same notification IS delivered to the notifier, which never asked\n *\n * The realtime engine listens on a dedicated connection and the writes come\n * from request connections, so it is exactly the broken case, every time.\n *\n * The fix is to stop treating a notification as belonging to one connection,\n * which for a single-session database is the truth anyway: this proxy watches\n * the server→client direction, and every `NotificationResponse` frame it sees is\n * copied to every other connected client. A client that never issued `LISTEN`\n * may receive one it did not ask for; `pg` raises a `notification` event nobody\n * has subscribed to, which costs nothing. A client that *did* ask now always\n * gets it, which is the whole point.\n *\n * Two properties make this safe rather than clever:\n *\n * - **It never parses SQL and never rewrites a byte.** Frames are forwarded\n *   verbatim; the only edit is delivering a copy of one to more sockets.\n * - **Injection only happens on a message boundary.** The server→client stream\n *   is reassembled into whole protocol messages before anything is written on,\n *   so an injected frame can never land inside another message.\n *\n * This exists only for the managed development database. Against a real Postgres\n * there is no proxy, because there is no defect to correct.\n */\n\nimport net from \"net\";\n\n/** `NotificationResponse`. The one message type this proxy treats specially. */\nconst NOTIFICATION_RESPONSE = 0x41; // 'A'\n\n/**\n * The SSL negotiation request, which is the one thing on the wire that is not\n * a typed message.\n *\n * A client may open with an 8-byte `SSLRequest` (length 8, code 80877103), and\n * the server answers with a *single untyped byte* — `N` or `S`. Feeding that\n * byte to a parser expecting `type + Int32 length` would desynchronise the\n * stream for the rest of the connection, so it is recognised and passed through.\n */\nconst SSL_REQUEST_LENGTH = 8;\nconst SSL_REQUEST_CODE = 80877103;\n\nfunction isSslRequest(chunk: Buffer): boolean {\n    return (\n        chunk.length >= SSL_REQUEST_LENGTH &&\n        chunk.readInt32BE(0) === SSL_REQUEST_LENGTH &&\n        chunk.readInt32BE(4) === SSL_REQUEST_CODE\n    );\n}\n\n/**\n * Reassembles a server→client byte stream into whole protocol messages.\n *\n * Every backend message is `Int8 type` + `Int32 length` + payload, where the\n * length counts itself but not the type byte. Anything shorter than a full\n * message is held until the rest arrives — TCP offers no guarantee that a\n * message arrives in one chunk, and a proxy that assumed otherwise would inject\n * into the middle of a row description under load.\n */\nexport class BackendMessageParser {\n    private buffered: Buffer = Buffer.alloc(0);\n    /** Set once the untyped SSL negotiation byte has been dealt with. */\n    private awaitingSslReply = false;\n\n    expectSslReply(): void {\n        this.awaitingSslReply = true;\n    }\n\n    /** Feed bytes in; get whole messages out, in order. */\n    push(chunk: Buffer): Buffer[] {\n        const messages: Buffer[] = [];\n        this.buffered = this.buffered.length === 0 ? chunk : Buffer.concat([this.buffered, chunk]);\n\n        if (this.awaitingSslReply && this.buffered.length >= 1) {\n            // Single untyped byte: 'N' (no SSL) or 'S' (proceed).\n            messages.push(this.buffered.subarray(0, 1));\n            this.buffered = this.buffered.subarray(1);\n            this.awaitingSslReply = false;\n        }\n\n        while (this.buffered.length >= 5) {\n            const length = this.buffered.readInt32BE(1);\n            // A length below 4 cannot describe itself; the stream is not one we\n            // understand, so stop parsing and let the rest through untouched\n            // rather than guessing.\n            if (length < 4) break;\n            const total = length + 1;\n            if (this.buffered.length < total) break;\n            messages.push(this.buffered.subarray(0, total));\n            this.buffered = this.buffered.subarray(total);\n        }\n\n        return messages;\n    }\n\n    /** Bytes held back because they are not yet a whole message. */\n    get pending(): number {\n        return this.buffered.length;\n    }\n}\n\nexport function isNotificationFrame(message: Buffer): boolean {\n    return message.length > 0 && message[0] === NOTIFICATION_RESPONSE;\n}\n\n/** Channel and payload of a NotificationResponse, for logging and tests. */\nexport function decodeNotification(message: Buffer): { channel: string; payload: string } | null {\n    if (!isNotificationFrame(message) || message.length < 10) return null;\n    // 1 type byte + 4 length + 4 process id, then two null-terminated strings.\n    const body = message.subarray(9);\n    const split = body.indexOf(0);\n    if (split === -1) return null;\n    const channel = body.subarray(0, split).toString(\"utf8\");\n    const rest = body.subarray(split + 1);\n    const end = rest.indexOf(0);\n\n    return { channel, payload: (end === -1 ? rest : rest.subarray(0, end)).toString(\"utf8\") };\n}\n\nexport interface NotificationProxyOptions {\n    /** Port clients connect to. */\n    listenPort: number;\n    /** Port the real PGlite socket server is on. */\n    upstreamPort: number;\n    host?: string;\n    /** Called for every notification broadcast. For diagnostics and tests. */\n    onNotification?: (channel: string, payload: string, copies: number) => void;\n}\n\ninterface Connection {\n    client: net.Socket;\n    upstream: net.Socket;\n    parser: BackendMessageParser;\n}\n\n/**\n * The proxy itself.\n *\n * One upstream connection per client connection, so the multiplexer downstream\n * sees exactly what it would have seen without the proxy.\n */\nexport class NotificationProxy {\n    private server: net.Server | null = null;\n    private readonly connections = new Set<Connection>();\n\n    constructor(private readonly options: NotificationProxyOptions) {}\n\n    get connectionCount(): number {\n        return this.connections.size;\n    }\n\n    start(): Promise<void> {\n        const host = this.options.host ?? \"127.0.0.1\";\n\n        return new Promise((resolve, reject) => {\n            const server = net.createServer((client) => this.accept(client, host));\n            server.once(\"error\", reject);\n            server.listen(this.options.listenPort, host, () => {\n                this.server = server;\n                resolve();\n            });\n        });\n    }\n\n    private accept(client: net.Socket, host: string): void {\n        const upstream = net.connect(this.options.upstreamPort, host);\n        const connection: Connection = { client, upstream, parser: new BackendMessageParser() };\n        this.connections.add(connection);\n\n        // Nagle would batch a notification behind nothing at all, adding latency\n        // to the one message whose entire value is arriving promptly.\n        client.setNoDelay(true);\n        upstream.setNoDelay(true);\n\n        client.on(\"data\", (chunk: Buffer) => {\n            if (isSslRequest(chunk)) connection.parser.expectSslReply();\n            upstream.write(chunk);\n        });\n\n        upstream.on(\"data\", (chunk: Buffer) => {\n            for (const message of connection.parser.push(chunk)) {\n                client.write(message);\n                if (isNotificationFrame(message)) this.broadcast(message, connection);\n            }\n        });\n\n        const close = () => {\n            this.connections.delete(connection);\n            client.destroy();\n            upstream.destroy();\n        };\n        client.on(\"close\", close);\n        client.on(\"error\", close);\n        upstream.on(\"close\", close);\n        upstream.on(\"error\", close);\n    }\n\n    /**\n     * Copy a notification to every other client.\n     *\n     * Written directly rather than through a parser: it is already a whole\n     * message, and every other socket is only ever written whole messages, so\n     * there is no boundary to land inside.\n     */\n    private broadcast(message: Buffer, origin: Connection): void {\n        let copies = 0;\n        for (const connection of this.connections) {\n            if (connection === origin) continue;\n            if (connection.client.destroyed || !connection.client.writable) continue;\n            connection.client.write(message);\n            copies += 1;\n        }\n\n        const decoded = decodeNotification(message);\n        if (decoded) this.options.onNotification?.(decoded.channel, decoded.payload, copies);\n    }\n\n    async stop(): Promise<void> {\n        for (const connection of [...this.connections]) {\n            connection.client.destroy();\n            connection.upstream.destroy();\n        }\n        this.connections.clear();\n\n        const server = this.server;\n        this.server = null;\n        if (!server) return;\n\n        await new Promise<void>((resolve) => server.close(() => resolve()));\n    }\n}\n","/**\n * The managed database process: one PGlite instance behind a Postgres socket.\n *\n * Runs as `rebase __dev-db-daemon`, a hidden subcommand rather than a separate\n * build entry point, so the same resolution works from `src` under tsx and from\n * the bundled `dist` a published CLI ships — there is no second file for a\n * build config to forget.\n *\n * It is deliberately detached from whoever started it. `rebase db push` in one\n * terminal and `rebase dev` in another must reach the same database, because\n * two processes opening one PGlite data directory would corrupt it, so the\n * daemon belongs to the *project* rather than to a command. What starts it is\n * incidental; what stops it is an explicit `rebase db stop`, an idle timeout,\n * or the machine going away.\n *\n * PGlite is imported dynamically. It is an optional dependency carrying a 25MB\n * WASM build, and the cost of that must fall only on someone who actually uses\n * the managed database — never on `rebase init`, and never on a CLI startup\n * that is about to print help.\n */\n\nimport fs from \"fs\";\nimport net from \"net\";\n\nimport {\n    MANAGED_SERVER_MAX_CONNECTIONS,\n    PGLITE_EXTENSIONS\n} from \"./constraints\";\nimport { NotificationProxy } from \"./notification-proxy\";\nimport { clearState, dataDir, findFreePort, writeState } from \"./state\";\n\n/** Shut down after this long with nothing connected. */\nconst DEFAULT_IDLE_TIMEOUT_MS = 30 * 60_000;\n\n/** How often to check for idleness. */\nconst IDLE_CHECK_INTERVAL_MS = 60_000;\n\nexport interface DaemonArgs {\n    projectRoot: string;\n    port: number;\n    token: string;\n    idleTimeoutMs: number;\n}\n\n/**\n * `--project <dir> --port <n> --token <t> [--idle-timeout <ms>]`.\n *\n * Every field is required and unvalidated input is fatal: this process is\n * spawned by the CLI, never typed by a person, so a malformed argument is a bug\n * in the caller and guessing would hide it.\n */\nexport function parseDaemonArgs(argv: readonly string[]): DaemonArgs {\n    const take = (flag: string): string | null => {\n        const index = argv.indexOf(flag);\n\n        return index >= 0 && index + 1 < argv.length ? argv[index + 1] : null;\n    };\n\n    const projectRoot = take(\"--project\");\n    const port = Number(take(\"--port\"));\n    const token = take(\"--token\");\n    const idleRaw = take(\"--idle-timeout\");\n\n    if (!projectRoot) throw new Error(\"__dev-db-daemon: --project is required\");\n    if (!Number.isInteger(port) || port <= 0 || port > 65535) {\n        throw new Error(\"__dev-db-daemon: --port must be a valid port\");\n    }\n    if (!token) throw new Error(\"__dev-db-daemon: --token is required\");\n\n    const idleTimeoutMs = idleRaw === null ? DEFAULT_IDLE_TIMEOUT_MS : Number(idleRaw);\n    if (!Number.isFinite(idleTimeoutMs) || idleTimeoutMs < 0) {\n        throw new Error(\"__dev-db-daemon: --idle-timeout must be a non-negative number of milliseconds\");\n    }\n\n    return { projectRoot, port, token, idleTimeoutMs };\n}\n\n/**\n * Load the extension bundles PGlite needs.\n *\n * `CREATE EXTENSION pg_trgm` cannot install anything on its own here — PGlite\n * resolves extensions from bundles handed to the constructor, and a missing one\n * fails at migration time with `extension \"pg_trgm\" is not available`, which\n * reads like a broken database rather than a missing import.\n *\n * Every failure here is loud for that reason, including the one that is new:\n * pgvector arrives from a package of its own, so unlike the contrib bundles it\n * can be absent while PGlite itself is fine.\n */\nasync function loadExtensions(): Promise<Record<string, unknown>> {\n    const extensions: Record<string, unknown> = {};\n    for (const extension of PGLITE_EXTENSIONS) {\n        let module: Record<string, unknown>;\n        try {\n            module = (await import(extension.module)) as Record<string, unknown>;\n        } catch (err) {\n            throw new Error(\n                `Could not load \"${extension.module}\", which supplies the ${extension.name} extension: ` +\n                `${err instanceof Error ? err.message : String(err)}\\n` +\n                \"It is an optional dependency of @rebasepro/cli — reinstall the project, \" +\n                \"or run `rebase dev --docker` to use a real Postgres instead.\"\n            );\n        }\n        const bundle = module[extension.export];\n        if (!bundle) {\n            throw new Error(\n                `${extension.module} did not export \"${extension.export}\". ` +\n                \"The installed PGlite version may not ship this extension.\"\n            );\n        }\n        extensions[extension.name] = bundle;\n    }\n\n    return extensions;\n}\n\n/**\n * A tiny sidecar listener that answers one question: \"are you the daemon this\n * state file describes?\"\n *\n * Liveness cannot be answered by the pid — after a reboot the number belongs to\n * something else — nor by the port alone, for the same reason. Both would let\n * Rebase send a migration to a stranger. So the daemon publishes a token on a\n * second loopback port and the answer is only yes when the token matches.\n */\nfunction startIdentityServer(token: string, onConnection: () => void): Promise<net.Server> {\n    return new Promise((resolve, reject) => {\n        const server = net.createServer((socket) => {\n            onConnection();\n            socket.end(`rebase-dev-db ${token}\\n`);\n        });\n        server.once(\"error\", reject);\n        server.listen(0, \"127.0.0.1\", () => resolve(server));\n    });\n}\n\nexport async function runDaemon(args: DaemonArgs): Promise<void> {\n    const directory = dataDir(args.projectRoot);\n    fs.mkdirSync(directory, { recursive: true });\n\n    const { PGlite } = (await import(\"@electric-sql/pglite\")) as {\n        PGlite: { create(options: unknown): Promise<unknown> };\n    };\n    const { PGLiteSocketServer } = (await import(\"@electric-sql/pglite-socket\")) as {\n        PGLiteSocketServer: new (options: unknown) => {\n            start(): Promise<void>;\n            stop(): Promise<void>;\n            getStats(): { activeConnections: number; queuedQueries: number };\n        };\n    };\n\n    const extensions = await loadExtensions();\n    const db = (await PGlite.create({ dataDir: directory, extensions })) as { close(): Promise<void> };\n\n    // The socket server listens privately; clients reach it through the\n    // notification proxy on `args.port`. Realtime does not work otherwise —\n    // PGlite is one session, so a NotificationResponse is handed to whichever\n    // socket is reading rather than to the one that issued LISTEN. See\n    // `notification-proxy.ts` for the measurements.\n    const upstreamPort = await findFreePort();\n    const server = new PGLiteSocketServer({\n        db,\n        port: upstreamPort,\n        host: \"127.0.0.1\",\n        // Above the client pool limit so a second *non-transactional* client is\n        // refused with a connection error rather than deadlocking the\n        // multiplexer. See `constraints.ts` — the pool limit is what actually\n        // prevents overlapping transactions.\n        maxConnections: MANAGED_SERVER_MAX_CONNECTIONS\n    });\n    await server.start();\n\n    const proxy = new NotificationProxy({\n        listenPort: args.port,\n        upstreamPort,\n        onNotification: (channel, _payload, copies) => {\n            if (copies > 0) process.stdout.write(`dev-db: relayed notification on ${channel} to ${copies} client(s)\\n`);\n        }\n    });\n    await proxy.start();\n\n    // \"Idle\" means nothing is connected to the *database*. An earlier version\n    // tracked identity pings instead, which meant a daemon serving queries\n    // steadily for an hour would decide it was idle and shut down under a\n    // running dev server.\n    let idleSince: number | null = Date.now();\n    const identity = await startIdentityServer(args.token, () => {\n        idleSince = null;\n    });\n    const identityAddress = identity.address();\n    const identityPort = identityAddress !== null && typeof identityAddress !== \"string\" ? identityAddress.port : 0;\n\n    writeState(args.projectRoot, {\n        port: args.port,\n        pid: process.pid,\n        dataDir: directory,\n        startedAt: new Date().toISOString(),\n        token: args.token,\n        identityPort\n    });\n\n    let shuttingDown = false;\n    const shutdown = async (reason: string) => {\n        if (shuttingDown) return;\n        shuttingDown = true;\n        process.stdout.write(`dev-db: stopping (${reason})\\n`);\n        // The state file goes first: a command that reads it during shutdown\n        // should conclude \"not running\" and start a fresh daemon, rather than\n        // connect to a socket that is closing under it.\n        clearState(args.projectRoot);\n        try {\n            await proxy.stop();\n        } catch { /* already down */ }\n        try {\n            await server.stop();\n        } catch { /* already down */ }\n        identity.close();\n        try {\n            await db.close();\n        } catch { /* already closed */ }\n        process.exit(0);\n    };\n\n    process.on(\"SIGINT\", () => void shutdown(\"SIGINT\"));\n    process.on(\"SIGTERM\", () => void shutdown(\"SIGTERM\"));\n    // The parent going away must not take the database with it — the daemon\n    // belongs to the project. But an orphan with nobody left to serve should\n    // not outlive the session either, which is what the idle timer is for.\n    process.on(\"disconnect\", () => { /* detached on purpose */ });\n\n    if (args.idleTimeoutMs > 0) {\n        const timer = setInterval(() => {\n            const stats = server.getStats();\n            const busy = stats.activeConnections > 0 || stats.queuedQueries > 0;\n            if (busy) {\n                idleSince = null;\n\n                return;\n            }\n            if (idleSince === null) {\n                idleSince = Date.now();\n\n                return;\n            }\n            if (Date.now() - idleSince >= args.idleTimeoutMs) {\n                void shutdown(`idle for ${Math.round(args.idleTimeoutMs / 60_000)} minutes`);\n            }\n        }, IDLE_CHECK_INTERVAL_MS);\n        timer.unref();\n    }\n\n    process.stdout.write(`dev-db: ready on 127.0.0.1:${args.port}\\n`);\n}\n"],"mappings":"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"}

package/dist/dev-db/constraints.d.ts

@@ -53,14 +53,30 @@
  *    against the managed database, with no change to the server: it does
  *    ordinary `LISTEN` over ordinary libpq.
  */
+/** One extension bundle, and where to import it from. */
+export interface PgliteExtension {
+    /** The name `CREATE EXTENSION` uses, and the key PGlite is handed. */
+    name: string;
+    /** Module the bundle is imported from. */
+    module: string;
+    /** The named export carrying the bundle. */
+    export: string;
+}
 /**
  * Extensions to hand PGlite's constructor.
  *
  * `CREATE EXTENSION` alone cannot install these — PGlite resolves them from
  * bundles supplied at construction time, so anything missing here is missing
  * from the database no matter what the migration says.
+ *
+ * The module is spelled out per extension rather than derived from the name,
+ * because they do not all live in the same place: the two contrib ones are
+ * subpaths of PGlite itself, and pgvector is a package of its own. Deriving the
+ * path is what left `vector` off this list — `@electric-sql/pglite/contrib/vector`
+ * does not exist, so a project declaring a `{ type: "vector" }` property could
+ * not use the managed dev database at all.
  */
-export declare const PGLITE_EXTENSION_NAMES: readonly ["pg_trgm", "unaccent"];
+export declare const PGLITE_EXTENSIONS: readonly PgliteExtension[];
 /**
  * Client connections the managed database tolerates: exactly one.
  *