@rebasepro/cli 0.16.0 → 0.16.1-canary.g0d7af95

package/dist/daemon-Bdl4lrdt.js

@@ -0,0 +1,252 @@
+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 path from "path";
+import fs from "fs";
+import net from "net";
+import { fileURLToPath } from "url";
+import { randomBytes } from "crypto";
+import { spawn } from "child_process";
+//#region src/dev-db/daemon.ts
+/**
+* Starting, finding and stopping the managed database, from the caller's side.
+*
+* Every command that needs Postgres calls {@link ensureManagedDatabase} and
+* gets a connection string back. Whether that started a process or found one
+* already running is not the caller's business, which is the point: `rebase
+* db push`, `rebase dev` and `rebase studio` in three terminals must all reach
+* the same database without coordinating, because two processes opening one
+* PGlite data directory would corrupt it.
+*
+* The hard part is not starting the daemon; it is deciding whether the one the
+* state file describes is still there. A pid can be recycled after a reboot and
+* a port can be taken by a stranger, so believing either on its own would let
+* Rebase send a migration somewhere unintended. {@link isDaemonAlive} asks the
+* daemon to identify itself instead.
+*/
+var daemon_exports = /* @__PURE__ */ __exportAll({
+	ensureManagedDatabase: () => ensureManagedDatabase,
+	findRunningDaemon: () => findRunningDaemon,
+	isDaemonAlive: () => isDaemonAlive,
+	managedUrl: () => managedUrl,
+	resetManagedDatabase: () => resetManagedDatabase,
+	resolveSpawn: () => resolveSpawn,
+	stopManagedDatabase: () => stopManagedDatabase
+});
+/** How long to wait for a first boot. PGlite runs initdb on an empty data dir. */
+var START_TIMEOUT_MS = 6e4;
+/** Poll interval while waiting for the daemon to publish its state file. */
+var POLL_INTERVAL_MS = 150;
+/** How long the identity handshake may take before we call it dead. */
+var IDENTITY_TIMEOUT_MS = 1500;
+/**
+* PGlite's built-in superuser and database.
+*
+* Fixed by PGlite rather than chosen here, and asserted by the socket spike:
+* `session_user` comes back as `postgres`.
+*/
+var MANAGED_USER = "postgres";
+var MANAGED_DATABASE = "postgres";
+function managedUrl(port) {
+	return `postgresql://${MANAGED_USER}@127.0.0.1:${port}/${MANAGED_DATABASE}`;
+}
+/**
+* Ask the process behind a state record to prove it is the one we wrote down.
+*
+* A pid check alone answers "is *a* process running", and a port check alone
+* answers "is *something* listening" — after a reboot both say yes about
+* strangers. The daemon answers with the token from its own state file, so a
+* match is the only evidence accepted.
+*/
+function isDaemonAlive(state) {
+	if (!pidRunning(state.pid)) return Promise.resolve(false);
+	return new Promise((resolve) => {
+		const socket = new net.Socket();
+		let answer = "";
+		const settle = (alive) => {
+			socket.removeAllListeners();
+			socket.destroy();
+			resolve(alive);
+		};
+		socket.setTimeout(IDENTITY_TIMEOUT_MS);
+		socket.once("timeout", () => settle(false));
+		socket.once("error", () => settle(false));
+		socket.on("data", (chunk) => {
+			answer += chunk.toString("utf8");
+			if (answer.includes("\n")) settle(answer.trim() === `rebase-dev-db ${state.token}`);
+		});
+		socket.once("close", () => settle(answer.trim() === `rebase-dev-db ${state.token}`));
+		socket.connect(state.identityPort, "127.0.0.1");
+	});
+}
+/** The running daemon for this project, or `null`. Never starts anything. */
+async function findRunningDaemon(projectRoot) {
+	const state = readState(projectRoot);
+	if (!state) return null;
+	if (await isDaemonAlive(state)) return state;
+	clearState(projectRoot);
+	return null;
+}
+/**
+* Resolve the CLI entry point, so the daemon can be spawned as ourselves.
+*
+* A hidden subcommand rather than a second build entry: under `tsx` this file
+* is `src/dev-db/daemon.ts` and in a published CLI it is bundled into
+* `dist/index.js`, and in both cases the executable to re-invoke is the one
+* already running.
+*/
+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));
+}
+/**
+* How to re-invoke ourselves, which differs between a published CLI and this
+* repository.
+*
+* A published `rebase` is `node bin/rebase.js`, and re-running that is trivial.
+* Inside the monorepo the entry is TypeScript, which plain `node` cannot load —
+* so the daemon has to be started through the same loader that is running now.
+* Getting this wrong fails as a spawn that exits instantly with a syntax error,
+* which is why the caller reads `pglite.log` on failure.
+*/
+function resolveSpawn(entry) {
+	if (!/\.[cm]?ts$/.test(entry)) return {
+		execPath: process.execPath,
+		prefixArgs: []
+	};
+	return {
+		execPath: process.execPath,
+		prefixArgs: ["--import", "tsx"]
+	};
+}
+/**
+* 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
+* the winner's state file during its poll and adopts it rather than starting a
+* second daemon.
+*/
+async function ensureManagedDatabase(projectRoot, options = {}) {
+	const existing = await findRunningDaemon(projectRoot);
+	if (existing) return adopt(existing, false);
+	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 (!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.`);
+	}
+	const port = await findFreePort();
+	const token = randomBytes(16).toString("hex");
+	const entry = options.entry ?? resolveCliEntry();
+	const spawnPlan = options.spawn ?? resolveSpawn(entry);
+	const args = [
+		...spawnPlan.prefixArgs,
+		entry,
+		"__dev-db-daemon",
+		"--project",
+		projectRoot,
+		"--port",
+		String(port),
+		"--token",
+		token
+	];
+	if (options.idleTimeoutMs !== void 0) args.push("--idle-timeout", String(options.idleTimeoutMs));
+	const log = fs.openSync(path.join(devDbDir(projectRoot), "pglite.log"), "a");
+	const child = spawn(spawnPlan.execPath, args, {
+		detached: true,
+		stdio: [
+			"ignore",
+			log,
+			log
+		]
+	});
+	child.unref();
+	try {
+		const deadline = Date.now() + START_TIMEOUT_MS;
+		let announced = false;
+		while (Date.now() < deadline) {
+			const state = readState(projectRoot);
+			if (state && await isDaemonAlive(state)) return adopt(state, true);
+			if (!announced && !options.quiet) {
+				announced = true;
+				options.onProgress?.("Starting the development database…");
+			}
+			if (child.exitCode !== null && child.exitCode !== 0) throw new Error(`The development database failed to start (exit ${child.exitCode}).\n  See ${path.join(devDbDir(projectRoot), "pglite.log")} for the reason.`);
+			await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
+		}
+		throw new Error(`The development database did not start within ${Math.round(START_TIMEOUT_MS / 1e3)}s.\n  See ${path.join(devDbDir(projectRoot), "pglite.log")} for the reason.\n  To use your own Postgres instead, set DATABASE_URL or pass --database-url.`);
+	} finally {
+		releaseStartLock(projectRoot);
+	}
+}
+/** Shape a live state record as the caller's result. */
+function adopt(state, started) {
+	return {
+		url: managedUrl(state.port),
+		dataDir: state.dataDir,
+		port: state.port,
+		pid: state.pid,
+		started
+	};
+}
+/** Poll until another process publishes a live daemon, or give up. */
+async function waitForDaemon(projectRoot, timeoutMs) {
+	const deadline = Date.now() + timeoutMs;
+	while (Date.now() < deadline) {
+		const state = readState(projectRoot);
+		if (state && await isDaemonAlive(state)) return state;
+		await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
+	}
+	return null;
+}
+/** Stop the daemon. Returns false when there was nothing running. */
+async function stopManagedDatabase(projectRoot) {
+	const state = await findRunningDaemon(projectRoot);
+	if (!state) return false;
+	try {
+		process.kill(state.pid, "SIGTERM");
+	} catch {
+		clearState(projectRoot);
+		return false;
+	}
+	const deadline = Date.now() + 1e4;
+	while (Date.now() < deadline) {
+		if (!fs.existsSync(stateFile(projectRoot))) return true;
+		await new Promise((resolve) => setTimeout(resolve, 100));
+	}
+	clearState(projectRoot);
+	return true;
+}
+/**
+* Stop the daemon and delete the data directory.
+*
+* Destructive and deliberately not clever: it removes the whole directory
+* rather than dropping schemas, because "give me an empty database" is the only
+* thing anyone means by it.
+*/
+async function resetManagedDatabase(projectRoot) {
+	await stopManagedDatabase(projectRoot);
+	fs.rmSync(dataDir(projectRoot), {
+		recursive: true,
+		force: true
+	});
+	clearState(projectRoot);
+}
+/**
+* Keep the generated directory out of git.
+*
+* `.rebase/` holds a Postgres data directory and a log. A project that commits
+* it will push hundreds of megabytes and a database that only makes sense on
+* one machine, so the ignore file is written next to the data rather than
+* relying on the project's root `.gitignore` having been updated.
+*/
+function ensureGitignore(projectRoot) {
+	const target = path.join(devDbDir(projectRoot), ".gitignore");
+	if (fs.existsSync(target)) return;
+	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 };
+
+//# sourceMappingURL=daemon-Bdl4lrdt.js.map

package/dist/daemon-Bdl4lrdt.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"daemon-Bdl4lrdt.js","names":[],"sources":["../src/dev-db/daemon.ts"],"sourcesContent":["/**\n * Starting, finding and stopping the managed database, from the caller's side.\n *\n * Every command that needs Postgres calls {@link ensureManagedDatabase} and\n * gets a connection string back. Whether that started a process or found one\n * already running is not the caller's business, which is the point: `rebase\n * db push`, `rebase dev` and `rebase studio` in three terminals must all reach\n * the same database without coordinating, because two processes opening one\n * PGlite data directory would corrupt it.\n *\n * The hard part is not starting the daemon; it is deciding whether the one the\n * state file describes is still there. A pid can be recycled after a reboot and\n * a port can be taken by a stranger, so believing either on its own would let\n * Rebase send a migration somewhere unintended. {@link isDaemonAlive} asks the\n * daemon to identify itself instead.\n */\n\nimport { randomBytes } from \"crypto\";\nimport { type ChildProcess, spawn } from \"child_process\";\nimport fs from \"fs\";\nimport net from \"net\";\nimport path from \"path\";\nimport { fileURLToPath } from \"url\";\n\nimport {\n    acquireStartLock,\n    clearState,\n    type DaemonState,\n    dataDir,\n    devDbDir,\n    findFreePort,\n    pidRunning,\n    readState,\n    releaseStartLock,\n    stateFile\n} from \"./state\";\n\n/** How long to wait for a first boot. PGlite runs initdb on an empty data dir. */\nconst START_TIMEOUT_MS = 60_000;\n/** Poll interval while waiting for the daemon to publish its state file. */\nconst POLL_INTERVAL_MS = 150;\n/** How long the identity handshake may take before we call it dead. */\nconst IDENTITY_TIMEOUT_MS = 1_500;\n\nexport interface ManagedDatabase {\n    /** Connection string for this project's managed database. */\n    url: string;\n    /** Where the data lives, for diagnostics and `--reset`. */\n    dataDir: string;\n    port: number;\n    pid: number;\n    /** True when this call started the daemon rather than finding it. */\n    started: boolean;\n}\n\n/**\n * PGlite's built-in superuser and database.\n *\n * Fixed by PGlite rather than chosen here, and asserted by the socket spike:\n * `session_user` comes back as `postgres`.\n */\nconst MANAGED_USER = \"postgres\";\nconst MANAGED_DATABASE = \"postgres\";\n\nexport function managedUrl(port: number): string {\n    return `postgresql://${MANAGED_USER}@127.0.0.1:${port}/${MANAGED_DATABASE}`;\n}\n\n/**\n * Ask the process behind a state record to prove it is the one we wrote down.\n *\n * A pid check alone answers \"is *a* process running\", and a port check alone\n * answers \"is *something* listening\" — after a reboot both say yes about\n * strangers. The daemon answers with the token from its own state file, so a\n * match is the only evidence accepted.\n */\nexport function isDaemonAlive(state: DaemonState): Promise<boolean> {\n    if (!pidRunning(state.pid)) return Promise.resolve(false);\n\n    return new Promise((resolve) => {\n        const socket = new net.Socket();\n        let answer = \"\";\n        const settle = (alive: boolean) => {\n            socket.removeAllListeners();\n            socket.destroy();\n            resolve(alive);\n        };\n        socket.setTimeout(IDENTITY_TIMEOUT_MS);\n        socket.once(\"timeout\", () => settle(false));\n        socket.once(\"error\", () => settle(false));\n        socket.on(\"data\", (chunk) => {\n            answer += chunk.toString(\"utf8\");\n            if (answer.includes(\"\\n\")) settle(answer.trim() === `rebase-dev-db ${state.token}`);\n        });\n        socket.once(\"close\", () => settle(answer.trim() === `rebase-dev-db ${state.token}`));\n        socket.connect(state.identityPort, \"127.0.0.1\");\n    });\n}\n\n/** The running daemon for this project, or `null`. Never starts anything. */\nexport async function findRunningDaemon(projectRoot: string): Promise<DaemonState | null> {\n    const state = readState(projectRoot);\n    if (!state) return null;\n    if (await isDaemonAlive(state)) return state;\n\n    // The record describes something that is not there. Clearing it is the\n    // whole recovery: the next ensure call starts a fresh daemon, and leaving\n    // it would make every subsequent check pay the identity timeout.\n    clearState(projectRoot);\n\n    return null;\n}\n\n/**\n * Resolve the CLI entry point, so the daemon can be spawned as ourselves.\n *\n * A hidden subcommand rather than a second build entry: under `tsx` this file\n * is `src/dev-db/daemon.ts` and in a published CLI it is bundled into\n * `dist/index.js`, and in both cases the executable to re-invoke is the one\n * already running.\n */\nfunction resolveCliEntry(): string {\n    // `process.argv[1]` is `bin/rebase.js` for a real invocation, which is\n    // exactly what should be re-run. Under a test runner it is the runner, so\n    // fall back to this module's own directory.\n    const argvEntry = process.argv[1];\n    if (argvEntry && fs.existsSync(argvEntry)) return argvEntry;\n\n    return fileURLToPath(new URL(\"../index.js\", import.meta.url));\n}\n\n/**\n * How to re-invoke ourselves, which differs between a published CLI and this\n * repository.\n *\n * A published `rebase` is `node bin/rebase.js`, and re-running that is trivial.\n * Inside the monorepo the entry is TypeScript, which plain `node` cannot load —\n * so the daemon has to be started through the same loader that is running now.\n * Getting this wrong fails as a spawn that exits instantly with a syntax error,\n * which is why the caller reads `pglite.log` on failure.\n */\nexport function resolveSpawn(entry: string): { execPath: string; prefixArgs: string[] } {\n    if (!/\\.[cm]?ts$/.test(entry)) return { execPath: process.execPath, prefixArgs: [] };\n\n    // Node can load TypeScript when tsx is registered as an import hook. tsx is\n    // already a dependency of this package, because `rebase dev` runs the\n    // backend through it.\n    return { execPath: process.execPath, prefixArgs: [\"--import\", \"tsx\"] };\n}\n\nexport interface EnsureOptions {\n    /** Silence the \"starting…\" progress line. */\n    quiet?: boolean;\n    /** Milliseconds of inactivity before the daemon exits. 0 disables. */\n    idleTimeoutMs?: number;\n    /** Where progress goes. Injected for tests. */\n    onProgress?: (message: string) => void;\n    /** Override how the daemon process is launched. For tests. */\n    spawn?: { execPath: string; prefixArgs: string[] };\n    /**\n     * Override the CLI entry to re-invoke. For tests.\n     *\n     * Necessary because under a test runner `process.argv[1]` is the runner\n     * itself, which exists and is therefore accepted by {@link resolveCliEntry}\n     * — spawning vitest with `__dev-db-daemon` rather than the CLI.\n     */\n    entry?: string;\n}\n\n/**\n * The project's managed database, started if it is not already running.\n *\n * Safe to call concurrently from several commands: the loser of the race finds\n * the winner's state file during its poll and adopts it rather than starting a\n * second daemon.\n */\nexport async function ensureManagedDatabase(\n    projectRoot: string,\n    options: EnsureOptions = {}\n): Promise<ManagedDatabase> {\n    const existing = await findRunningDaemon(projectRoot);\n    if (existing) return adopt(existing, false);\n\n    fs.mkdirSync(devDbDir(projectRoot), { recursive: true });\n    ensureGitignore(projectRoot);\n\n    // Exactly one process may spawn a daemon. Without this, `rebase dev` and\n    // `rebase db push` started in the same second both see no state file, both\n    // spawn, and two processes open one PGlite data directory — the corruption\n    // the single-daemon design exists to prevent.\n    if (!acquireStartLock(projectRoot, START_TIMEOUT_MS)) {\n        const adopted = await waitForDaemon(projectRoot, START_TIMEOUT_MS);\n        if (adopted) return adopt(adopted, false);\n\n        // The holder gave up or died without publishing. Falling through to\n        // start one ourselves is better than failing: the lock is stale by now,\n        // so the next acquire will break it.\n        if (!acquireStartLock(projectRoot, 0)) {\n            throw new Error(\n                \"Another process is starting the development database and did not finish.\\n\" +\n                `  Remove ${path.join(devDbDir(projectRoot), \"starting.lock\")} if nothing is running.`\n            );\n        }\n    }\n\n    const port = await findFreePort();\n    const token = randomBytes(16).toString(\"hex\");\n    const entry = options.entry ?? resolveCliEntry();\n\n    const spawnPlan = options.spawn ?? resolveSpawn(entry);\n    const args = [\n        ...spawnPlan.prefixArgs,\n        entry,\n        \"__dev-db-daemon\",\n        \"--project\", projectRoot,\n        \"--port\", String(port),\n        \"--token\", token\n    ];\n    if (options.idleTimeoutMs !== undefined) {\n        args.push(\"--idle-timeout\", String(options.idleTimeoutMs));\n    }\n\n    const log = fs.openSync(path.join(devDbDir(projectRoot), \"pglite.log\"), \"a\");\n    const child: ChildProcess = spawn(spawnPlan.execPath, args, {\n        // Detached with no stdin and its output on a file: the daemon must\n        // survive the command that started it, and must not hold the terminal\n        // open when that command exits.\n        detached: true,\n        stdio: [\"ignore\", log, log]\n    });\n    child.unref();\n\n    try {\n        const deadline = Date.now() + START_TIMEOUT_MS;\n        let announced = false;\n        while (Date.now() < deadline) {\n            const state = readState(projectRoot);\n            if (state && (await isDaemonAlive(state))) return adopt(state, true);\n\n            if (!announced && !options.quiet) {\n                announced = true;\n                options.onProgress?.(\"Starting the development database…\");\n            }\n\n            // A daemon that died on startup will never publish a state file, and\n            // waiting the full minute for that is a bad way to learn it. The log\n            // is the only place the reason exists.\n            if (child.exitCode !== null && child.exitCode !== 0) {\n                throw new Error(\n                    `The development database failed to start (exit ${child.exitCode}).\\n` +\n                    `  See ${path.join(devDbDir(projectRoot), \"pglite.log\")} for the reason.`\n                );\n            }\n\n            await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));\n        }\n\n        throw new Error(\n            `The development database did not start within ${Math.round(START_TIMEOUT_MS / 1000)}s.\\n` +\n            `  See ${path.join(devDbDir(projectRoot), \"pglite.log\")} for the reason.\\n` +\n            \"  To use your own Postgres instead, set DATABASE_URL or pass --database-url.\"\n        );\n    } finally {\n        // Released whether we succeeded, timed out or threw. A lock left behind\n        // by a crash is broken by age, but only after a full timeout — which a\n        // developer should never have to wait out.\n        releaseStartLock(projectRoot);\n    }\n}\n\n/** Shape a live state record as the caller's result. */\nfunction adopt(state: DaemonState, started: boolean): ManagedDatabase {\n    return {\n        url: managedUrl(state.port),\n        dataDir: state.dataDir,\n        port: state.port,\n        pid: state.pid,\n        started\n    };\n}\n\n/** Poll until another process publishes a live daemon, or give up. */\nasync function waitForDaemon(projectRoot: string, timeoutMs: number): Promise<DaemonState | null> {\n    const deadline = Date.now() + timeoutMs;\n    while (Date.now() < deadline) {\n        const state = readState(projectRoot);\n        if (state && (await isDaemonAlive(state))) return state;\n        await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));\n    }\n\n    return null;\n}\n\n/** Stop the daemon. Returns false when there was nothing running. */\nexport async function stopManagedDatabase(projectRoot: string): Promise<boolean> {\n    const state = await findRunningDaemon(projectRoot);\n    if (!state) return false;\n\n    try {\n        process.kill(state.pid, \"SIGTERM\");\n    } catch {\n        clearState(projectRoot);\n\n        return false;\n    }\n\n    // Wait for it to clear its own state file, which is how it says it closed\n    // the data directory cleanly. A hard kill here would risk the WAL.\n    const deadline = Date.now() + 10_000;\n    while (Date.now() < deadline) {\n        if (!fs.existsSync(stateFile(projectRoot))) return true;\n        await new Promise((resolve) => setTimeout(resolve, 100));\n    }\n\n    clearState(projectRoot);\n\n    return true;\n}\n\n/**\n * Stop the daemon and delete the data directory.\n *\n * Destructive and deliberately not clever: it removes the whole directory\n * rather than dropping schemas, because \"give me an empty database\" is the only\n * thing anyone means by it.\n */\nexport async function resetManagedDatabase(projectRoot: string): Promise<void> {\n    await stopManagedDatabase(projectRoot);\n    fs.rmSync(dataDir(projectRoot), { recursive: true, force: true });\n    clearState(projectRoot);\n}\n\n/**\n * Keep the generated directory out of git.\n *\n * `.rebase/` holds a Postgres data directory and a log. A project that commits\n * it will push hundreds of megabytes and a database that only makes sense on\n * one machine, so the ignore file is written next to the data rather than\n * relying on the project's root `.gitignore` having been updated.\n */\nfunction ensureGitignore(projectRoot: string): void {\n    const target = path.join(devDbDir(projectRoot), \".gitignore\");\n    if (fs.existsSync(target)) return;\n    fs.writeFileSync(\n        target,\n        \"# Generated by `rebase dev` — a local Postgres data directory and its log.\\n\" +\n        \"# Machine-specific and large; never commit it.\\n*\\n\",\n        \"utf8\"\n    );\n}\n"],"mappings":"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"}

package/dist/daemon-entry-Brq-S8XX.js

@@ -0,0 +1,378 @@
+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 fs from "fs";
+import net from "net";
+//#region src/dev-db/notification-proxy.ts
+/**
+* A transparent Postgres proxy that puts LISTEN/NOTIFY back.
+*
+* Without this, realtime does not work against the managed database — and it
+* fails silently, which is worse than failing. The reason is specific and
+* measurable:
+*
+* PGlite is a *single* backend session, and `PGLiteSocketServer` multiplexes
+* every client connection onto it. `LISTEN` is therefore session-wide: whichever
+* client issues it arms the whole database. But a `NotificationResponse` is an
+* asynchronous message with no request to answer, so the multiplexer hands it to
+* whichever socket happens to be reading the protocol stream at that moment —
+* which is the client that *caused* the notification, not the one that asked for
+* it.
+*
+* Measured against pglite-socket 0.2.9:
+*
+*   LISTEN and NOTIFY on one connection      → delivered
+*   trigger-fired pg_notify, same connection → delivered
+*   another connection causes the notify     → NOT delivered to the listener
+*   …and the same notification IS delivered to the notifier, which never asked
+*
+* The realtime engine listens on a dedicated connection and the writes come
+* from request connections, so it is exactly the broken case, every time.
+*
+* The fix is to stop treating a notification as belonging to one connection,
+* which for a single-session database is the truth anyway: this proxy watches
+* the server→client direction, and every `NotificationResponse` frame it sees is
+* copied to every other connected client. A client that never issued `LISTEN`
+* may receive one it did not ask for; `pg` raises a `notification` event nobody
+* has subscribed to, which costs nothing. A client that *did* ask now always
+* gets it, which is the whole point.
+*
+* Two properties make this safe rather than clever:
+*
+* - **It never parses SQL and never rewrites a byte.** Frames are forwarded
+*   verbatim; the only edit is delivering a copy of one to more sockets.
+* - **Injection only happens on a message boundary.** The server→client stream
+*   is reassembled into whole protocol messages before anything is written on,
+*   so an injected frame can never land inside another message.
+*
+* This exists only for the managed development database. Against a real Postgres
+* there is no proxy, because there is no defect to correct.
+*/
+/** `NotificationResponse`. The one message type this proxy treats specially. */
+var NOTIFICATION_RESPONSE = 65;
+/**
+* The SSL negotiation request, which is the one thing on the wire that is not
+* a typed message.
+*
+* A client may open with an 8-byte `SSLRequest` (length 8, code 80877103), and
+* the server answers with a *single untyped byte* — `N` or `S`. Feeding that
+* byte to a parser expecting `type + Int32 length` would desynchronise the
+* stream for the rest of the connection, so it is recognised and passed through.
+*/
+var SSL_REQUEST_LENGTH = 8;
+var SSL_REQUEST_CODE = 80877103;
+function isSslRequest(chunk) {
+	return chunk.length >= SSL_REQUEST_LENGTH && chunk.readInt32BE(0) === SSL_REQUEST_LENGTH && chunk.readInt32BE(4) === SSL_REQUEST_CODE;
+}
+/**
+* Reassembles a server→client byte stream into whole protocol messages.
+*
+* Every backend message is `Int8 type` + `Int32 length` + payload, where the
+* length counts itself but not the type byte. Anything shorter than a full
+* message is held until the rest arrives — TCP offers no guarantee that a
+* message arrives in one chunk, and a proxy that assumed otherwise would inject
+* into the middle of a row description under load.
+*/
+var BackendMessageParser = class {
+	buffered = Buffer.alloc(0);
+	/** Set once the untyped SSL negotiation byte has been dealt with. */
+	awaitingSslReply = false;
+	expectSslReply() {
+		this.awaitingSslReply = true;
+	}
+	/** Feed bytes in; get whole messages out, in order. */
+	push(chunk) {
+		const messages = [];
+		this.buffered = this.buffered.length === 0 ? chunk : Buffer.concat([this.buffered, chunk]);
+		if (this.awaitingSslReply && this.buffered.length >= 1) {
+			messages.push(this.buffered.subarray(0, 1));
+			this.buffered = this.buffered.subarray(1);
+			this.awaitingSslReply = false;
+		}
+		while (this.buffered.length >= 5) {
+			const length = this.buffered.readInt32BE(1);
+			if (length < 4) break;
+			const total = length + 1;
+			if (this.buffered.length < total) break;
+			messages.push(this.buffered.subarray(0, total));
+			this.buffered = this.buffered.subarray(total);
+		}
+		return messages;
+	}
+	/** Bytes held back because they are not yet a whole message. */
+	get pending() {
+		return this.buffered.length;
+	}
+};
+function isNotificationFrame(message) {
+	return message.length > 0 && message[0] === NOTIFICATION_RESPONSE;
+}
+/** Channel and payload of a NotificationResponse, for logging and tests. */
+function decodeNotification(message) {
+	if (!isNotificationFrame(message) || message.length < 10) return null;
+	const body = message.subarray(9);
+	const split = body.indexOf(0);
+	if (split === -1) return null;
+	const channel = body.subarray(0, split).toString("utf8");
+	const rest = body.subarray(split + 1);
+	const end = rest.indexOf(0);
+	return {
+		channel,
+		payload: (end === -1 ? rest : rest.subarray(0, end)).toString("utf8")
+	};
+}
+/**
+* The proxy itself.
+*
+* One upstream connection per client connection, so the multiplexer downstream
+* sees exactly what it would have seen without the proxy.
+*/
+var NotificationProxy = class {
+	options;
+	server = null;
+	connections = /* @__PURE__ */ new Set();
+	constructor(options) {
+		this.options = options;
+	}
+	get connectionCount() {
+		return this.connections.size;
+	}
+	start() {
+		const host = this.options.host ?? "127.0.0.1";
+		return new Promise((resolve, reject) => {
+			const server = net.createServer((client) => this.accept(client, host));
+			server.once("error", reject);
+			server.listen(this.options.listenPort, host, () => {
+				this.server = server;
+				resolve();
+			});
+		});
+	}
+	accept(client, host) {
+		const upstream = net.connect(this.options.upstreamPort, host);
+		const connection = {
+			client,
+			upstream,
+			parser: new BackendMessageParser()
+		};
+		this.connections.add(connection);
+		client.setNoDelay(true);
+		upstream.setNoDelay(true);
+		client.on("data", (chunk) => {
+			if (isSslRequest(chunk)) connection.parser.expectSslReply();
+			upstream.write(chunk);
+		});
+		upstream.on("data", (chunk) => {
+			for (const message of connection.parser.push(chunk)) {
+				client.write(message);
+				if (isNotificationFrame(message)) this.broadcast(message, connection);
+			}
+		});
+		const close = () => {
+			this.connections.delete(connection);
+			client.destroy();
+			upstream.destroy();
+		};
+		client.on("close", close);
+		client.on("error", close);
+		upstream.on("close", close);
+		upstream.on("error", close);
+	}
+	/**
+	* Copy a notification to every other client.
+	*
+	* Written directly rather than through a parser: it is already a whole
+	* message, and every other socket is only ever written whole messages, so
+	* there is no boundary to land inside.
+	*/
+	broadcast(message, origin) {
+		let copies = 0;
+		for (const connection of this.connections) {
+			if (connection === origin) continue;
+			if (connection.client.destroyed || !connection.client.writable) continue;
+			connection.client.write(message);
+			copies += 1;
+		}
+		const decoded = decodeNotification(message);
+		if (decoded) this.options.onNotification?.(decoded.channel, decoded.payload, copies);
+	}
+	async stop() {
+		for (const connection of [...this.connections]) {
+			connection.client.destroy();
+			connection.upstream.destroy();
+		}
+		this.connections.clear();
+		const server = this.server;
+		this.server = null;
+		if (!server) return;
+		await new Promise((resolve) => server.close(() => resolve()));
+	}
+};
+//#endregion
+//#region src/dev-db/daemon-entry.ts
+/**
+* The managed database process: one PGlite instance behind a Postgres socket.
+*
+* Runs as `rebase __dev-db-daemon`, a hidden subcommand rather than a separate
+* build entry point, so the same resolution works from `src` under tsx and from
+* the bundled `dist` a published CLI ships — there is no second file for a
+* build config to forget.
+*
+* It is deliberately detached from whoever started it. `rebase db push` in one
+* terminal and `rebase dev` in another must reach the same database, because
+* two processes opening one PGlite data directory would corrupt it, so the
+* daemon belongs to the *project* rather than to a command. What starts it is
+* incidental; what stops it is an explicit `rebase db stop`, an idle timeout,
+* or the machine going away.
+*
+* PGlite is imported dynamically. It is an optional dependency carrying a 25MB
+* WASM build, and the cost of that must fall only on someone who actually uses
+* the managed database — never on `rebase init`, and never on a CLI startup
+* that is about to print help.
+*/
+/** Shut down after this long with nothing connected. */
+var DEFAULT_IDLE_TIMEOUT_MS = 30 * 6e4;
+/** How often to check for idleness. */
+var IDLE_CHECK_INTERVAL_MS = 6e4;
+/**
+* `--project <dir> --port <n> --token <t> [--idle-timeout <ms>]`.
+*
+* Every field is required and unvalidated input is fatal: this process is
+* spawned by the CLI, never typed by a person, so a malformed argument is a bug
+* in the caller and guessing would hide it.
+*/
+function parseDaemonArgs(argv) {
+	const take = (flag) => {
+		const index = argv.indexOf(flag);
+		return index >= 0 && index + 1 < argv.length ? argv[index + 1] : null;
+	};
+	const projectRoot = take("--project");
+	const port = Number(take("--port"));
+	const token = take("--token");
+	const idleRaw = take("--idle-timeout");
+	if (!projectRoot) throw new Error("__dev-db-daemon: --project is required");
+	if (!Number.isInteger(port) || port <= 0 || port > 65535) throw new Error("__dev-db-daemon: --port must be a valid port");
+	if (!token) throw new Error("__dev-db-daemon: --token is required");
+	const idleTimeoutMs = idleRaw === null ? DEFAULT_IDLE_TIMEOUT_MS : Number(idleRaw);
+	if (!Number.isFinite(idleTimeoutMs) || idleTimeoutMs < 0) throw new Error("__dev-db-daemon: --idle-timeout must be a non-negative number of milliseconds");
+	return {
+		projectRoot,
+		port,
+		token,
+		idleTimeoutMs
+	};
+}
+/**
+* Load the extension bundles PGlite needs by name.
+*
+* `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.
+*/
+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;
+	}
+	return extensions;
+}
+/**
+* A tiny sidecar listener that answers one question: "are you the daemon this
+* state file describes?"
+*
+* Liveness cannot be answered by the pid — after a reboot the number belongs to
+* something else — nor by the port alone, for the same reason. Both would let
+* Rebase send a migration to a stranger. So the daemon publishes a token on a
+* second loopback port and the answer is only yes when the token matches.
+*/
+function startIdentityServer(token, onConnection) {
+	return new Promise((resolve, reject) => {
+		const server = net.createServer((socket) => {
+			onConnection();
+			socket.end(`rebase-dev-db ${token}\n`);
+		});
+		server.once("error", reject);
+		server.listen(0, "127.0.0.1", () => resolve(server));
+	});
+}
+async function runDaemon(args) {
+	const directory = dataDir(args.projectRoot);
+	fs.mkdirSync(directory, { recursive: true });
+	const { PGlite } = await import("@electric-sql/pglite");
+	const { PGLiteSocketServer } = await import("@electric-sql/pglite-socket");
+	const extensions = await loadExtensions();
+	const db = await PGlite.create({
+		dataDir: directory,
+		extensions
+	});
+	const upstreamPort = await findFreePort();
+	const server = new PGLiteSocketServer({
+		db,
+		port: upstreamPort,
+		host: "127.0.0.1",
+		maxConnections: 4
+	});
+	await server.start();
+	const proxy = new NotificationProxy({
+		listenPort: args.port,
+		upstreamPort,
+		onNotification: (channel, _payload, copies) => {
+			if (copies > 0) process.stdout.write(`dev-db: relayed notification on ${channel} to ${copies} client(s)\n`);
+		}
+	});
+	await proxy.start();
+	let idleSince = Date.now();
+	const identity = await startIdentityServer(args.token, () => {
+		idleSince = null;
+	});
+	const identityAddress = identity.address();
+	const identityPort = identityAddress !== null && typeof identityAddress !== "string" ? identityAddress.port : 0;
+	writeState(args.projectRoot, {
+		port: args.port,
+		pid: process.pid,
+		dataDir: directory,
+		startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+		token: args.token,
+		identityPort
+	});
+	let shuttingDown = false;
+	const shutdown = async (reason) => {
+		if (shuttingDown) return;
+		shuttingDown = true;
+		process.stdout.write(`dev-db: stopping (${reason})\n`);
+		clearState(args.projectRoot);
+		try {
+			await proxy.stop();
+		} catch {}
+		try {
+			await server.stop();
+		} catch {}
+		identity.close();
+		try {
+			await db.close();
+		} catch {}
+		process.exit(0);
+	};
+	process.on("SIGINT", () => void shutdown("SIGINT"));
+	process.on("SIGTERM", () => void shutdown("SIGTERM"));
+	process.on("disconnect", () => {});
+	if (args.idleTimeoutMs > 0) setInterval(() => {
+		const stats = server.getStats();
+		if (stats.activeConnections > 0 || stats.queuedQueries > 0) {
+			idleSince = null;
+			return;
+		}
+		if (idleSince === null) {
+			idleSince = Date.now();
+			return;
+		}
+		if (Date.now() - idleSince >= args.idleTimeoutMs) shutdown(`idle for ${Math.round(args.idleTimeoutMs / 6e4)} minutes`);
+	}, IDLE_CHECK_INTERVAL_MS).unref();
+	process.stdout.write(`dev-db: ready on 127.0.0.1:${args.port}\n`);
+}
+//#endregion
+export { parseDaemonArgs, runDaemon };
+
+//# sourceMappingURL=daemon-entry-Brq-S8XX.js.map