@rebasepro/cli 0.17.3 → 0.18.1

package/dist/commands/dev.d.ts

@@ -1,12 +1,199 @@
+import { type PreparedDatabase } from "../dev-db/prepare.js";
+/**
+ * The line the watcher prints when it is about to run the entry again.
+ *
+ * `rebase dev` has no exit code to read: the watcher outlives the process it
+ * started, so a backend that dies leaves it running and the CLI printing
+ * "Press Ctrl+C to stop all servers." under the stack trace, as if everything
+ * were fine.
+ *
+ * What used to be here was `/Waiting for file changes before restarting/` —
+ * **Node's** message, on the theory that `--watch=…` was passed through to
+ * Node. It is not: the backend is spawned as `tsx watch …` (see `watchArgs`),
+ * so tsx does the watching and Node's line is never printed. The marker
+ * matched nothing at all — and the test guarding it ran `node --watch`
+ * directly, so it kept proving that Node's wording was intact while the CLI
+ * watched a stream that never contained it. That is precisely the silent death
+ * the old comment warned about, reached by a different route.
+ *
+ * So this is tsx's, captured from tsx 4.23.1:
+ *
+ *     6:26:11 AM [tsx] change in ./src/index.ts Rerunning...
+ *     6:26:11 AM [tsx] change in ./src/index.ts Restarting...
+ *
+ * "Rerunning" when the previous run had already exited, "Restarting" when it
+ * was still up and had to be killed first. Both mean the same thing here: the
+ * backend that was announced is gone, and whether another one arrives is an
+ * open question again — so the readiness deadline is re-armed.
+ *
+ * Exported so `dev-crash-marker.test.ts` can hold the running tsx to it.
+ */
+export declare const WATCHER_RESTART_MARKER: RegExp;
+/**
+ * The corrected banner line, when the backend says it moved port.
+ *
+ * `↳ PORT = 3014` is printed before the server binds — the backend's
+ * environment has to be fixed before it spawns — so when the port turns out to
+ * be taken and the server moves, the banner two inches up is simply wrong. The
+ * true number then appears in a `[backend]` line a hundred lines of DDL later,
+ * which nobody scrolls back through, and the banner is where a reader looks for
+ * the port.
+ *
+ * A correction rather than a rewrite: the terminal is a transcript, and a line
+ * that changes after the fact is a line nobody can trust. So the old number is
+ * named too.
+ *
+ * Exported for its test.
+ */
+export declare function portMovedNotice(line: string): {
+    from: string;
+    to: string;
+} | null;
+/**
+ * Directories `tsx watch` must be told about explicitly, as absolute paths.
+ *
+ * tsx restarts on a change to anything the entrypoint *imports*. Functions and
+ * crons are not imported: the runtime scans their directories at boot. So
+ * adding `backend/functions/new.ts` while `rebase dev` ran did nothing —
+ * `GET /api/functions/new` stayed 404, and a new cron never registered — until
+ * somebody restarted by hand. The same is true of `config/`, which is read as
+ * data.
+ *
+ * `--include` is tsx's own answer to this, it takes a directory rather than a
+ * glob, and it tolerates a directory that does not exist yet: a `crons/`
+ * created mid-session starts being watched when it appears.
+ *
+ * @param projectRoot   Absolute path the relative entries are resolved against.
+ * @param paths         The `REBASE_DEV_*` map from {@link devRuntimeEnv}.
+ * @param includeConfig Whether `config/` is watched here. It is only when
+ *                      auto-generation is off; with `--generate` a dedicated
+ *                      watcher already regenerates the schema and SDK, and tsx
+ *                      restarts on the files that produces.
+ */
+export declare function devWatchIncludes(projectRoot: string, paths: {
+    REBASE_DEV_FUNCTIONS?: string;
+    REBASE_DEV_CRONS?: string;
+}, includeConfig: boolean): string[];
 /** Well-known filename the backend writes its actual port to. */
 export declare const DEV_PORT_FILENAME = ".rebase-dev-port";
+/**
+ * The `PORT` the scaffold's own `.env.example` ships.
+ *
+ * `rebase init` copies that file into `.env` verbatim, so every new project has
+ * this value whether or not anyone meant it. `init.test.ts` asserts the
+ * template still says this number, so the two cannot drift apart in silence.
+ */
+export declare const SCAFFOLD_DEFAULT_PORT = 3001;
 /**
  * Compute a deterministic port from the project root path.
  * Range: 3001–3999 (avoids privileged ports and common services).
  * Two different project directories will almost always get different ports.
  */
 export declare function getProjectPort(projectRoot: string): number;
-export declare function resolveStartPort(projectRoot: string, explicitPort?: number): number;
+/**
+ * Which rung of the ladder below decided the port.
+ *
+ * Reported because the ladder is invisible from the outside and the two middle
+ * rungs look identical from where the developer stands: `PORT` in the shell
+ * wins, `PORT` in `.env` does not — `rebase dev` never reads the file for it —
+ * and a saved affinity port looks exactly like a derived one. A developer who
+ * sets `PORT=3001` in `.env`, sees 3774, and has nothing to read but the number
+ * concludes the setting is broken rather than out of scope.
+ */
+export type StartPortSource = "--port" | "PORT" | "affinity" | "derived";
+/** What the banner says after the port, naming the rung. */
+export declare const START_PORT_SOURCE_LABELS: Record<StartPortSource, string>;
+/**
+ * The port this project's backend starts on, and the rung that decided it:
+ * 1. `--port` (highest priority)
+ * 2. `PORT` **in the shell environment** — a `PORT` in `.env` is not read here
+ * 3. the port a previous run saved in `.rebase-dev-port` (affinity)
+ * 4. a port derived from the project path, unique per project
+ */
+export declare function resolveStartPort(projectRoot: string, explicitPort?: number): {
+    port: number;
+    source: StartPortSource;
+};
+/**
+ * Where a connection string actually points, as `host:port/name`.
+ *
+ * The banner used to name the database only by *provenance* — "your database
+ * (DATABASE_URL in the environment)" — and the boot that follows it writes
+ * thirty DDL statements. Which host, which port, which database name appeared
+ * nowhere on the success path; only a *failed* connection printed an address.
+ * So the one question after pointing a project at staging by accident — did it
+ * touch staging? — had no answer in a hundred and twenty lines of output.
+ *
+ * The password is never in it. `new URL` keeps the credentials in their own
+ * fields, so building the string out of `hostname`, `port` and `pathname`
+ * cannot carry them by accident, which string surgery on a DSN reliably does.
+ *
+ * A DSN with no host is a UNIX socket (`postgresql:///app?host=/tmp`), and the
+ * socket directory is the address there.
+ *
+ * Returns null for anything that is not a parseable URL rather than guessing:
+ * a banner line that is wrong about the database is worse than one that is
+ * missing.
+ *
+ * Exported for its test.
+ */
+export declare function databaseEndpoint(url: string | null | undefined): string | null;
+/**
+ * The `↳ Database =` line: which database, why it was chosen, and where it is.
+ *
+ * Provenance alone was what this line said, and the boot underneath it applies
+ * schema. "your database (DATABASE_URL in the environment)" and "Applied 30
+ * additive schema change(s) before boot" together still do not answer the
+ * question somebody asks after pointing a project at staging by accident.
+ *
+ * The managed database gets its address too — the daemon's port is what a
+ * `psql` in another terminal needs, and it is nowhere else in the banner.
+ *
+ * Exported for its test.
+ */
+export declare function databaseBannerValue(prepared: PreparedDatabase | null): string;
+/**
+ * Refuse a port the developer named and something else already answers on.
+ *
+ * `--port` used to be advice, not an instruction: `resolveStartPort` returned
+ * the number, the banner printed it, and the server then walked past the
+ * collision to 3141, 3142. Because dev ports are derived per project, the
+ * number typed into `--port` is very often *another Rebase backend*, so the
+ * curl that followed answered 200 from the wrong project rather than refusing
+ * — the one failure mode a port collision is supposed to rule out.
+ *
+ * Asked here as well as in the server (`listenWithPortRetry`'s `explicit`
+ * option, which `REBASE_DEV_PORT_EXPLICIT` below turns on) so the refusal
+ * arrives before a database is started and a schema is pushed, rather than a
+ * minute later underneath them.
+ *
+ * Both loopback addresses, because a listener on `::1` alone is the same
+ * collision and costs one more connect to rule out. Returns the sentence to
+ * print, or `null` when there is nothing to refuse.
+ *
+ * Exported for its test.
+ */
+export declare function pinnedPortRefusal(port: number, pinned: boolean): Promise<string | null>;
+/**
+ * The frontend port for this project, derived the same way the backend's is.
+ *
+ * `rebase dev` used to leave this entirely to Vite, which takes 5173 and, when
+ * that is busy, silently walks to 5174, 5175 and onward. The backend was then
+ * started with whatever `FRONTEND_URL` the scaffold's `.env` happened to say —
+ * `http://localhost:5173` — so the welcome email linked a port the app was not
+ * on. Deriving it here means the value handed to the backend describes the
+ * server we are about to start rather than a default nobody checked.
+ *
+ * Range 5173–5372, so the familiar port is still the common case for a single
+ * project and two projects rarely collide.
+ *
+ * Note this is passed to Vite WITHOUT `--strictPort` unless the developer
+ * pinned it explicitly. Vite keeps its fallback, so a busy port still starts —
+ * it just starts somewhere the email link does not name, which is exactly
+ * today's behaviour and no worse. Pinning REBASE_FRONTEND_PORT makes both
+ * exact.
+ */
+export declare function getProjectFrontendPort(projectRoot: string): number;
 /**
  * The flags `rebase dev` takes.
  *
@@ -36,4 +223,32 @@ export declare const DEV_FLAGS: {
     readonly "-g": "--generate";
     readonly "--no-db": BooleanConstructor;
 };
+/**
+ * One variable's value out of `.env` text, or undefined when it has none.
+ *
+ * The obvious `\s*(.+?)\s*$` does not do this, because `\s` matches a newline
+ * and `$` under /m matches at every line end: on `VITE_API_URL=` followed by
+ * `# VITE_GOOGLE_CLIENT_ID=`, the leading `\s*` ate the line break and the
+ * capture returned the *next* line. The scaffold ships `VITE_API_URL=` empty,
+ * so every first `rebase dev` read a comment as its value, decided it differed
+ * from the derived URL, and warned that a variable the developer had not set
+ * was being ignored.
+ *
+ * Horizontal whitespace only, so a value stops at its own line.
+ */
+export declare function readEnvValue(envText: string, key: string): string | undefined;
+/**
+ * The argv the first-boot schema push runs with.
+ *
+ * The database is named on the command line rather than left to be re-resolved.
+ * `runDriverDbCommand` runs the resolver again for whatever argv it is handed,
+ * and the argv it used to be handed (`["node","rebase","db","push"]`) carried
+ * nothing at all — so on the `--docker` path it read a `.env` whose
+ * `DATABASE_URL` is commented out, concluded "managed PGlite", and refused the
+ * push for a database that was not the one the preflight had just started.
+ *
+ * Exported for its test: the missing pair of arguments is the whole defect, and
+ * it is invisible in any assertion about the push's *outcome*.
+ */
+export declare function schemaPushArgv(databaseUrl: string | undefined): string[];
 export declare function devCommand(rawArgs: string[]): Promise<void>;

package/dist/commands/doctor.d.ts

@@ -1,4 +1,5 @@
 import { type LibpqUrlFinding } from "../utils/libpq-url.js";
+import { type AtlasBinaryState, type EnvironmentFinding } from "../doctor-environment.js";
 /**
  * Find connection strings libpq cannot parse, anywhere in the project.
  *
@@ -6,4 +7,54 @@ import { type LibpqUrlFinding } from "../utils/libpq-url.js";
  * keep its `.env` outside the root (see `findEnvFile`).
  */
 export declare function findLibpqUrlProblems(projectRoot: string, envFile?: string | null): LibpqUrlFinding[];
+/**
+ * Read everything the environment checks need, then run them.
+ *
+ * The reading is here and the deciding is in `doctor-environment.ts`, so every
+ * check has a fixture that fails it without a project on disk.
+ */
+export declare function collectEnvironmentFindings(projectRoot: string, envFile: string | null | undefined): EnvironmentFinding[];
+/**
+ * What is actually on disk for `@ariga/atlas`, from the project's point of view.
+ *
+ * Three separate questions, because the three states they distinguish need
+ * three different remedies — see `checkAtlasBinary`. Directories are searched
+ * from the project root upwards and through the workspaces a scaffold has,
+ * because `db push` runs from `backend/` and the install may be hoisted to the
+ * root.
+ */
+export declare function readAtlasBinaryState(projectRoot: string): AtlasBinaryState | null;
+/**
+ * Does this project declare its collections in code?
+ *
+ * `resolveBackendPaths` answers it against the manifest's own `config` path
+ * rather than the convention, because a project may move the directory. A
+ * project with no manifest, or one shaped differently, is treated as declaring
+ * them: the wrong answer there would silently skip the drift report, which is
+ * the reason the command exists.
+ */
+export declare function hasDeclaredCollections(projectRoot: string): boolean;
+/**
+ * The flags `rebase doctor` takes, and what each is for.
+ *
+ * One table, read by both the parser and the help page, because they were two
+ * things that had to agree and did not: the page listed no flags at all, so
+ * `--policies` — the form `cli/index.md` calls "the form to use as a CI gate" —
+ * was invisible to anyone who ran `rebase doctor --help` to find it. And with
+ * nothing parsing the line here, a typo travelled to the driver's permissive
+ * parser and was silently dropped, so `rebase doctor --polices` ran the ordinary
+ * doctor and reported success on a gate that never ran.
+ *
+ * The spec mirrors the driver's own (`doctorPluginCommand` in
+ * `server-postgres/src/cli.ts`), because the line is relayed to it verbatim.
+ */
+export declare const DOCTOR_FLAGS: {
+    readonly "--policies": BooleanConstructor;
+    readonly "--collections": StringConstructor;
+    readonly "-c": "--collections";
+    readonly "--schema": StringConstructor;
+    readonly "-s": "--schema";
+    readonly "--sdk": StringConstructor;
+    readonly "-k": "--sdk";
+};
 export declare function doctorCommand(rawArgs: string[]): Promise<void>;

package/dist/commands/init.d.ts

@@ -72,6 +72,7 @@ export declare function createRebaseApp(rawArgs: string[]): Promise<void>;
 export declare const INIT_FLAGS: {
     readonly "--git": BooleanConstructor;
     readonly "--install": BooleanConstructor;
+    readonly "--no-install": BooleanConstructor;
     readonly "--database-url": StringConstructor;
     readonly "--introspect": BooleanConstructor;
     readonly "--template": StringConstructor;

package/dist/commands/skills.d.ts

@@ -1,11 +1,23 @@
 /**
  * Supported agent environments and their target directories.
  *
- * `flatLayout` says where the installed rule file sits relative to the skill's
- * own assets. A subdirectory layout writes `<skill>/SKILL.md`, so a link the
- * skill spells `references/x.md` resolves as written; a flat layout writes
- * `<skill>.md` one level up, so those links have to be re-pointed at the
- * per-skill asset directory. See `rewriteAssetLinks`.
+ * Every agent `rebase init` writes a pointer file for has an entry here. That
+ * was not true: `rebase init` writes `CLAUDE.md`, `AGENTS.md`, `.cursorrules`,
+ * `.windsurfrules` and `.github/copilot-instructions.md`, and the installer
+ * covered four of the five — so a Codex or Copilot user was told, by a file in
+ * their own repository, to run an installer that had nothing to offer them.
+ *
+ * `flatLayout` marks the agents whose rules directory is loaded *whole*, into
+ * every request. Writing 21 skills there put ~84,000 characters of always-on
+ * context in front of every question a person asked Cursor — more than the task
+ * itself, on every turn, most of it about parts of Rebase they were not
+ * touching. Those agents get one short index rule instead, and the skill bodies
+ * go in per-skill subdirectories the index names, which the agent reads when it
+ * needs one. `indexFile` is the name of that rule.
+ *
+ * A subdirectory layout has no such problem: the rule file already sits beside
+ * its own assets, so `references/x.md` resolves as written and nothing is
+ * loaded until it is opened.
  */
 declare const AGENTS: {
     readonly cursor: {
@@ -13,7 +25,8 @@ declare const AGENTS: {
         readonly detectDir: ".cursor";
         readonly targetDir: ".cursor/rules";
         readonly flatLayout: true;
-        /** Cursor uses .mdc files (Markdown with Context). */
+        readonly indexFile: "rebase.mdc";
+        /** The body is not a rule file here — `indexFile` is. */
         readonly transformFile: (skillName: string, content: string) => {
             fileName: string;
             content: string;
@@ -35,7 +48,8 @@ declare const AGENTS: {
         readonly detectDir: ".windsurf";
         readonly targetDir: ".windsurf/rules";
         readonly flatLayout: true;
-        /** Windsurf uses plain .md files. */
+        readonly indexFile: "rebase.md";
+        /** The body is not a rule file here — `indexFile` is. */
         readonly transformFile: (skillName: string, content: string) => {
             fileName: string;
             content: string;
@@ -52,6 +66,41 @@ declare const AGENTS: {
             content: string;
         };
     };
+    readonly codex: {
+        readonly label: "Codex CLI";
+        readonly detectDir: ".codex";
+        readonly targetDir: ".codex/skills";
+        readonly flatLayout: false;
+        /** Codex reads AGENTS.md; the skills sit beside its own config. */
+        readonly transformFile: (skillName: string, content: string) => {
+            fileName: string;
+            content: string;
+        };
+    };
+    readonly kiro: {
+        readonly label: "Kiro";
+        readonly detectDir: ".kiro";
+        readonly targetDir: ".kiro/steering";
+        readonly flatLayout: true;
+        readonly indexFile: "rebase.md";
+        /** The body is not a rule file here — `indexFile` is. */
+        readonly transformFile: (skillName: string, content: string) => {
+            fileName: string;
+            content: string;
+        };
+    };
+    readonly copilot: {
+        readonly label: "GitHub Copilot";
+        readonly detectDir: null;
+        readonly targetDir: ".github/instructions";
+        readonly flatLayout: true;
+        readonly indexFile: "rebase.instructions.md";
+        /** The body is not a rule file here — `indexFile` is. */
+        readonly transformFile: (skillName: string, content: string) => {
+            fileName: string;
+            content: string;
+        };
+    };
 };
 type AgentKey = keyof typeof AGENTS;
 export interface LoadedSkill {
@@ -65,18 +114,38 @@ export interface LoadedSkill {
 /** Read all skill directories and return their names, content and assets. */
 export declare function loadSkills(skillsDir: string): LoadedSkill[];
 /**
- * Re-point a skill's own asset links at the per-skill subdirectory, for the
- * agents whose rule file does not live in it.
+ * The one always-on rule a flat-layout agent gets, in place of every skill.
  *
- * Only paths that name a file the skill actually ships are rewritten, and only
- * where they start a path segment — so prose that happens to contain the same
- * words is left alone.
+ * Cursor and Windsurf load their whole rules directory into each request. With
+ * a rule file per skill that was ~84,000 characters of Rebase reference in
+ * front of every question, whether or not the question was about Rebase — and
+ * an instruction an assistant skims is an instruction it does not follow.
+ *
+ * So the always-on part is this: a table of what exists and where to read it.
+ * `alwaysApply: true` because knowing the skills are there costs a few hundred
+ * characters and is the whole point; the bodies stay on disk until the agent
+ * opens one.
+ */
+export declare function renderSkillIndex(skills: LoadedSkill[], agentKey: AgentKey): string;
+/**
+ * Detect which agent environments already exist in the project.
+ *
+ * A `detectDir` has to be evidence *the user* created, not something a scaffold
+ * ships. An agent whose only marker fails that test declares `detectDir: null`
+ * and is reachable by `--agent` alone; guessing wrong here is worse than not
+ * guessing, because the wrong guess installs 21 files and reports success.
  */
-export declare function rewriteAssetLinks(content: string, assets: string[], skillName: string): string;
+export declare function detectAgents(projectDir: string): AgentKey[];
 /** Install skills for a specific agent into the project directory. */
 export declare function installForAgent(agentKey: AgentKey, skills: LoadedSkill[], projectDir: string): {
     skills: number;
     assets: number;
 };
 export declare function skillsCommand(subcommand: string | undefined, rawArgs: string[]): Promise<void>;
+/**
+ * Agents named explicitly on the command line, e.g. `--agent claude --agent cursor`
+ * (also accepts a comma-separated list, and `all`). Returns null when none were
+ * given.
+ */
+export declare function parseAgentFlags(rawArgs: string[]): AgentKey[] | null;
 export {};

package/dist/commands/status.d.ts

@@ -0,0 +1 @@
+export declare function statusCommand(rawArgs: string[]): Promise<void>;

package/dist/commands/telemetry.d.ts

@@ -1,9 +1 @@
-/**
- * `rebase telemetry` — the command that makes the rest of it inspectable.
- *
- * The whole subsystem asks for trust it cannot otherwise earn, and the cheapest
- * way to earn it is to stop describing the payload and print it. `show` runs
- * the same builder the sender uses, so what appears here is what would go, not
- * a documentation comment that quietly fell out of date two releases ago.
- */
 export declare function telemetryCommand(rawArgs: string[]): Promise<void>;

package/dist/{daemon-Bdl4lrdt.js → daemon-YDZK9NZ1.js}

@@ -1,4 +1,5 @@
-import { a as findFreePort, c as releaseStartLock, f as __exportAll, i as devDbDir, l as stateFile, n as clearState, o as pidRunning, r as dataDir, s as readState, t as acquireStartLock } from "./state-c0CJ6Kwb.js";
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
+import { a as devDbDir, c as readState, i as dataDir, l as releaseStartLock, o as findFreePort, r as clearState, s as pidRunning, t as acquireStartLock, u as stateFile } from "./state-C59Elrnt.js";
 import path from "path";
 import fs from "fs";
 import net from "net";
@@ -45,8 +46,22 @@ var IDENTITY_TIMEOUT_MS = 1500;
 */
 var MANAGED_USER = "postgres";
 var MANAGED_DATABASE = "postgres";
+/**
+* The DSN for the managed development database.
+*
+* **`sslmode=disable` is not decoration.** PGlite's socket server speaks no TLS,
+* and libpq-family clients try SSL first — so Atlas, which `rebase db push`
+* shells out to, failed the whole push with
+* `pq: SSL is not enabled on the server`. Its remedy box then told the reader to
+* append `sslmode=disable` to `DATABASE_URL`, which on this path is not set at
+* all: `rebase init` leaves it commented out precisely so the managed database
+* is used. The advice was correct and unfollowable.
+*
+* Putting it in the URL fixes every consumer at once — Atlas, `pg`, and anything
+* a driver shells out to later — rather than teaching each one about PGlite.
+*/
 function managedUrl(port) {
-	return `postgresql://${MANAGED_USER}@127.0.0.1:${port}/${MANAGED_DATABASE}`;
+	return `postgresql://${MANAGED_USER}@127.0.0.1:${port}/${MANAGED_DATABASE}?sslmode=disable`;
 }
 /**
 * Ask the process behind a state record to prove it is the one we wrote down.
@@ -96,7 +111,7 @@ async function findRunningDaemon(projectRoot) {
 function resolveCliEntry() {
 	const argvEntry = process.argv[1];
 	if (argvEntry && fs.existsSync(argvEntry)) return argvEntry;
-	return fileURLToPath(new URL("data:video/mp2t;base64,ZXhwb3J0ICogZnJvbSAiLi9jbGkiOwpleHBvcnQgKiBmcm9tICIuL2NvbW1hbmRzL2luaXQiOwpleHBvcnQgKiBmcm9tICIuL2NvbW1hbmRzL3NjaGVtYSI7CmV4cG9ydCAqIGZyb20gIi4vY29tbWFuZHMvZGIiOwpleHBvcnQgKiBmcm9tICIuL2NvbW1hbmRzL2RldiI7CmV4cG9ydCAqIGZyb20gIi4vY29tbWFuZHMvYnVpbGQiOwpleHBvcnQgKiBmcm9tICIuL2NvbW1hbmRzL2VqZWN0IjsKZXhwb3J0ICogZnJvbSAiLi9jb21tYW5kcy9zdGFydCI7CmV4cG9ydCAqIGZyb20gIi4vY29tbWFuZHMvYXV0aCI7CmV4cG9ydCAqIGZyb20gIi4vY29tbWFuZHMvZG9jdG9yIjsKZXhwb3J0ICogZnJvbSAiLi9jb21tYW5kcy9nZW5lcmF0ZV9zZGsiOwpleHBvcnQgKiBmcm9tICIuL2NvbW1hbmRzL2Nsb3VkIjsKZXhwb3J0ICogZnJvbSAiLi9jb21tYW5kcy9hcHBzIjsKZXhwb3J0ICogZnJvbSAiLi91dGlscy9wcm9qZWN0IjsKZXhwb3J0ICogZnJvbSAiLi91dGlscy9wYWNrYWdlLW1hbmFnZXIiOwoKLy8gVGhlIG1hbmlmZXN0IGFuZCBidW5kbGUgY29udHJhY3RzLgovLwovLyBFeHBvcnRlZCBiZWNhdXNlIHZhbGlkYXRpbmcgdGhlbSBpcyBub3Qgb25seSB0aGUgQ0xJJ3Mgam9iOiBhIGNvbnRyb2wgcGxhbmUKLy8gaGFzIHRvIGRlY2lkZSB3aGV0aGVyIGEgc3VibWl0dGVkIGJ1bmRsZSBjYW4gcnVuIGJlZm9yZSBpdCBkZXBsb3lzIGl0LCBhbmQgaXQKLy8gbXVzdCByZWFjaCB0aGF0IHZlcmRpY3Qgd2l0aCB0aGUgc2FtZSBjb2RlIHRoYXQgcHJvZHVjZWQgdGhlIGFydGlmYWN0LgpleHBvcnQgKiBmcm9tICIuL21hbmlmZXN0IjsKZXhwb3J0ICogZnJvbSAiLi9idW5kbGUiOwo=", "" + import.meta.url));
+	return fileURLToPath(new URL("data:video/mp2t;base64,LyoqCiAqIFRoZSBDTEkncyBwdWJsaWMgZW50cnkg4oCUIGRlbGliZXJhdGVseSBzbWFsbC4KICoKICogVGhpcyBmaWxlIHVzZWQgdG8gYGV4cG9ydCAqYCBmcm9tIHNpeHRlZW4gbW9kdWxlczogZXZlcnkgY29tbWFuZCBmdW5jdGlvbiwKICogYGRldGVjdFBhY2thZ2VNYW5hZ2VyYCwgYGZpbmRQcm9qZWN0Um9vdGAsIHRoZSB3aG9sZSBvZiBgY29tbWFuZHMvY2xvdWRgLiBOb25lCiAqIG9mIGl0IHdhcyBpbXBvcnRlZCBieSBhbnl0aGluZywgaW4gdGhpcyByZXBvc2l0b3J5IG9yIHRoZSBjb250cm9sIHBsYW5lLCBhbmQKICogbm9uZSBvZiBpdCB3YXMgbWVhbnQgdG8gYmU6IGBAcmViYXNlcHJvL2NsaWAgaXMgYSBwcm9ncmFtLCBhbmQgYSBwcm9ncmFtJ3MKICogaW50ZXJuYWxzIGJlY29tZSBhbiBBUEkgdGhlIG1vbWVudCB0aGV5IGFyZSBleHBvcnRlZCBhbmQgcHVibGlzaGVkLiBUaGUKICogYmFycmVsIHdhcyB3cml0dGVuIHRoZSB3YXkgYmFycmVscyBnZXQgd3JpdHRlbiDigJQgb25lIGxpbmUgcGVyIGZpbGUg4oCUIGFuZCB0aGUKICogc3VyZmFjZSBpdCBjcmVhdGVkIHdhcyBhbiBhY2NpZGVudCBvZiB0aGF0IGNvbnZlbnRpb24gcmF0aGVyIHRoYW4gYSBkZWNpc2lvbi4KICoKICogVGhyZWUgdGhpbmdzIGFyZSBleHBvcnRlZCwgZWFjaCBmb3IgYSBzdGF0ZWQgcmVhc29uLgogKi8KCi8qKgogKiBXaGF0IGBiaW4vcmViYXNlLmpzYCBjYWxscy4gVGhlIGJpbmFyeSBpbXBvcnRzIGBkaXN0L2luZGV4LmVzLmpzYCBhbmQgaW52b2tlcwogKiBgZW50cnkoKWAsIHNvIHRoaXMgaXMgdGhlIG9uZSBleHBvcnQgdGhlIENMSSBjYW5ub3QgcnVuIHdpdGhvdXQuCiAqLwpleHBvcnQgeyBlbnRyeSB9IGZyb20gIi4vY2xpIjsKCi8qKgogKiBUaGUgbWFuaWZlc3QgYW5kIGJ1bmRsZSBjb250cmFjdHMuCiAqCiAqIEV4cG9ydGVkIGJlY2F1c2UgdmFsaWRhdGluZyB0aGVtIGlzIG5vdCBvbmx5IHRoZSBDTEkncyBqb2I6IGEgY29udHJvbCBwbGFuZQogKiBoYXMgdG8gZGVjaWRlIHdoZXRoZXIgYSBzdWJtaXR0ZWQgYnVuZGxlIGNhbiBydW4gYmVmb3JlIGl0IGRlcGxveXMgaXQsIGFuZCBpdAogKiBtdXN0IHJlYWNoIHRoYXQgdmVyZGljdCB3aXRoIHRoZSBzYW1lIGNvZGUgdGhhdCBwcm9kdWNlZCB0aGUgYXJ0aWZhY3QuCiAqLwpleHBvcnQgKiBmcm9tICIuL21hbmlmZXN0IjsKZXhwb3J0ICogZnJvbSAiLi9idW5kbGUiOwo=", "" + import.meta.url));
 }
 /**
 * How to re-invoke ourselves, which differs between a published CLI and this
@@ -119,6 +134,61 @@ function resolveSpawn(entry) {
 	};
 }
 /**
+* Ask the running daemon for one additional database, and get its port.
+*
+* The identity socket doubles as the command channel: the daemon answers
+* with its token first, which is how the caller knows it is talking to the
+* daemon the state file describes and not to a stranger on a recycled port.
+*/
+function ensureAdditionalDatabase(state, key) {
+	return new Promise((resolve, reject) => {
+		const socket = new net.Socket();
+		let answer = "";
+		let identified = false;
+		const fail = (message) => {
+			socket.removeAllListeners();
+			socket.destroy();
+			reject(new Error(message));
+		};
+		socket.setTimeout(START_TIMEOUT_MS);
+		socket.once("timeout", () => fail(`The development database did not answer for "${key}" within ${Math.round(START_TIMEOUT_MS / 1e3)}s.`));
+		socket.once("error", (err) => fail(`Could not reach the development database for "${key}": ${err.message}`));
+		socket.on("data", (chunk) => {
+			answer += chunk.toString("utf8");
+			let newline = answer.indexOf("\n");
+			while (newline !== -1) {
+				const line = answer.slice(0, newline).trim();
+				answer = answer.slice(newline + 1);
+				if (!identified) {
+					if (line !== `rebase-dev-db ${state.token}`) return fail("The process on the development database's port is not the daemon.");
+					identified = true;
+					socket.write(`ensure ${key}\n`);
+				} else if (line.startsWith("ok ")) {
+					const port = Number(line.slice(3));
+					socket.removeAllListeners();
+					socket.destroy();
+					if (!Number.isInteger(port) || port <= 0) return reject(/* @__PURE__ */ new Error(`The development database answered with an invalid port for "${key}": ${line}`));
+					return resolve(port);
+				} else return fail(`The development database could not serve "${key}": ${line.replace(/^error\s*/, "")}`);
+				newline = answer.indexOf("\n");
+			}
+		});
+		socket.connect(state.identityPort, "127.0.0.1");
+	});
+}
+/** Every additional database the caller asked for, as connection strings. */
+async function adoptWithAdditional(state, started, keys) {
+	const additional = {};
+	for (const key of keys) {
+		const known = state.databases?.[key];
+		additional[key] = managedUrl(known ? known.port : await ensureAdditionalDatabase(state, key));
+	}
+	return {
+		...adopt(state, started),
+		additional
+	};
+}
+/**
 * The project's managed database, started if it is not already running.
 *
 * Safe to call concurrently from several commands: the loser of the race finds
@@ -126,13 +196,14 @@ function resolveSpawn(entry) {
 * second daemon.
 */
 async function ensureManagedDatabase(projectRoot, options = {}) {
+	const keys = options.additionalKeys ?? [];
 	const existing = await findRunningDaemon(projectRoot);
-	if (existing) return adopt(existing, false);
+	if (existing) return adoptWithAdditional(existing, false, keys);
 	fs.mkdirSync(devDbDir(projectRoot), { recursive: true });
 	ensureGitignore(projectRoot);
 	if (!acquireStartLock(projectRoot, START_TIMEOUT_MS)) {
 		const adopted = await waitForDaemon(projectRoot, START_TIMEOUT_MS);
-		if (adopted) return adopt(adopted, false);
+		if (adopted) return adoptWithAdditional(adopted, false, keys);
 		if (!acquireStartLock(projectRoot, 0)) throw new Error(`Another process is starting the development database and did not finish.
   Remove ${path.join(devDbDir(projectRoot), "starting.lock")} if nothing is running.`);
 	}
@@ -167,7 +238,7 @@ async function ensureManagedDatabase(projectRoot, options = {}) {
 		let announced = false;
 		while (Date.now() < deadline) {
 			const state = readState(projectRoot);
-			if (state && await isDaemonAlive(state)) return adopt(state, true);
+			if (state && await isDaemonAlive(state)) return adoptWithAdditional(state, true, keys);
 			if (!announced && !options.quiet) {
 				announced = true;
 				options.onProgress?.("Starting the development database…");
@@ -187,7 +258,8 @@ function adopt(state, started) {
 		dataDir: state.dataDir,
 		port: state.port,
 		pid: state.pid,
-		started
+		started,
+		additional: {}
 	};
 }
 /** Poll until another process publishes a live daemon, or give up. */
@@ -231,6 +303,13 @@ async function resetManagedDatabase(projectRoot) {
 		recursive: true,
 		force: true
 	});
+	const dir = devDbDir(projectRoot);
+	if (fs.existsSync(dir)) {
+		for (const entry of fs.readdirSync(dir)) if (entry.startsWith("pgdata__")) fs.rmSync(path.join(dir, entry), {
+			recursive: true,
+			force: true
+		});
+	}
 	clearState(projectRoot);
 }
 /**
@@ -247,6 +326,6 @@ function ensureGitignore(projectRoot) {
 	fs.writeFileSync(target, "# Generated by `rebase dev` — a local Postgres data directory and its log.\n# Machine-specific and large; never commit it.\n*\n", "utf8");
 }
 //#endregion
-export { ensureManagedDatabase as n, daemon_exports as t };
+export { managedUrl as i, ensureManagedDatabase as n, findRunningDaemon as r, daemon_exports as t };
 
-//# sourceMappingURL=daemon-Bdl4lrdt.js.map
+//# sourceMappingURL=daemon-YDZK9NZ1.js.map