@rebasepro/cli 0.16.0 → 0.16.1-canary.g0d7af95

package/dist/manifest.d.ts

@@ -41,7 +41,7 @@ export declare function validateManifest(raw: unknown): {
  * else. It used to be inferred from the presence of `backend/src/index.ts`,
  * which every scaffolded project had whether or not it wanted its own server, so
  * projects predating the manifest silently landed on the custom runtime and paid
- * for it (see `docs/cloud-deploy-workspace-vendoring.md`).
+ * for it (see `docs/plans/cloud-deploy-workspace-vendoring.md`).
  */
 export declare function synthesizeManifest(projectRoot: string): RebaseProjectManifest;
 export declare function manifestPath(projectRoot: string): string;
@@ -76,6 +76,29 @@ export declare function findBackendApp(manifest: RebaseProjectManifest): {
     name: string;
     app: RebaseBackendAppConfig;
 } | undefined;
+/**
+ * The app a deploy targets: the one named, or the obvious one.
+ *
+ * A repository declares apps; a project owns them. So "which app" is a question
+ * a multi-repo setup asks routinely and a single-app repository should never
+ * have to answer — hence the fallbacks, in the order that makes each of them
+ * unambiguous:
+ *
+ * - A name, when one is given. Wrong names fail loudly, listing what is there;
+ *   guessing past a typo would deploy the wrong app to a live project.
+ * - The backend, when this repository declares one. It is the app whose deploy
+ *   people mean when they do not say, and it is what every existing invocation
+ *   already did.
+ * - The only app, when there is exactly one. This is what makes a static-only
+ *   repository — an admin panel, a marketing site — deploy with no argument.
+ * - Otherwise a refusal that lists the choices. A repository with two static
+ *   apps and no backend has no obvious default, and picking one would publish
+ *   somebody's admin panel at their marketing domain.
+ */
+export declare function selectDeployApp(manifest: RebaseProjectManifest, requested?: string): {
+    name: string;
+    app: RebaseAppConfig;
+};
 /** Apps that produce build output, in the order they should be built. */
 export declare function buildableApps(manifest: RebaseProjectManifest): {
     name: string;

package/dist/pull-DqPRu1te.js

@@ -0,0 +1,167 @@
+import { execa } from "execa";
+//#region src/dev-db/pull.ts
+/**
+* `rebase db pull` — copy a database's contents into local development.
+*
+* The common case is production into local, and the reason it exists is that
+* the alternative is worse: without it people hand-roll a `pg_dump | psql` and
+* get the flags wrong in ways that either fail loudly at 2am or, more often,
+* quietly restore half a schema.
+*
+* Three things this command insists on, because copying a production database
+* onto a laptop is a data-protection event whether or not anyone calls it one:
+*
+* 1. **It says what it is about to do, in full, before doing it** — which
+*    database it will read, which one it will overwrite, and where the data will
+*    come to rest on disk. The target path matters: people forget that
+*    `.rebase/pgdata` is a directory their backup software may be indexing.
+*
+* 2. **It refuses to run unattended without being told to.** The target is
+*    destroyed, so a mistyped `--from` with no confirmation would take the
+*    developer's working database with it.
+*
+* 3. **It will not write to a remote database.** The target is always the local
+*    development database; there is no flag that makes this push. A tool that
+*    can copy in both directions eventually copies in the wrong one.
+*
+* Anonymization is opt-in (`--anonymize`), which is a deliberate choice and not
+* an obviously safe one — the flag nobody types is the flag nobody gets. It is
+* a best-effort pass over columns whose *names* look like personal data, and
+* {@link ANONYMIZE_PATTERNS} says exactly which. It cannot find personal data in
+* a column called `notes`, and this file says so rather than implying a
+* guarantee it cannot keep.
+*/
+/**
+* Column-name patterns the anonymizer overwrites.
+*
+* Names, not contents: inspecting values would be slower, and would still miss
+* the same things. This is a reasonable-effort measure for making a local copy
+* less dangerous, and it is not a compliance control.
+*/
+var ANONYMIZE_PATTERNS = [
+	{
+		pattern: /^(.*_)?e?mail(_.*)?$/i,
+		replacement: "concat('user', id::text, '@example.invalid')"
+	},
+	{
+		pattern: /^(.*_)?(phone|mobile|tel|telephone)(_.*)?$/i,
+		replacement: "'+10000000000'"
+	},
+	{
+		pattern: /^(.*_)?(first_name|last_name|full_name|surname|given_name)(_.*)?$/i,
+		replacement: "'Redacted'"
+	},
+	{
+		pattern: /^(.*_)?(address|street|postcode|zip|zipcode)(_.*)?$/i,
+		replacement: "'Redacted'"
+	},
+	{
+		pattern: /^(.*_)?(ssn|tax_id|national_id|passport)(_.*)?$/i,
+		replacement: "'REDACTED'"
+	},
+	{
+		pattern: /^(.*_)?(password|password_hash|secret|token|api_key|access_token|refresh_token)(_.*)?$/i,
+		replacement: "'REDACTED'"
+	},
+	{
+		pattern: /^(.*_)?(ip|ip_address|user_agent)(_.*)?$/i,
+		replacement: "'REDACTED'"
+	}
+];
+function shouldAnonymize(columnName) {
+	return ANONYMIZE_PATTERNS.some((rule) => rule.pattern.test(columnName));
+}
+function replacementFor(columnName) {
+	return ANONYMIZE_PATTERNS.find((rule) => rule.pattern.test(columnName))?.replacement ?? null;
+}
+/**
+* Anonymizable columns: name looks personal, and the type can hold the
+* replacement.
+*
+* The type check is what stops this generating `UPDATE … SET user_id =
+* 'Redacted'` for an integer column called `user_id_email_seq` and failing the
+* whole pass on a technicality.
+*/
+function anonymizableColumns(columns) {
+	const textual = /* @__PURE__ */ new Set([
+		"text",
+		"character varying",
+		"varchar",
+		"character",
+		"char",
+		"citext"
+	]);
+	return columns.filter((column) => shouldAnonymize(column.column) && textual.has(column.dataType.toLowerCase()));
+}
+/** `UPDATE` statements for one anonymization pass, in a stable order. */
+function anonymizeStatements(columns) {
+	const byTable = /* @__PURE__ */ new Map();
+	for (const column of anonymizableColumns(columns)) {
+		const key = `${column.schema}.${column.table}`;
+		byTable.set(key, [...byTable.get(key) ?? [], column]);
+	}
+	return [...byTable.entries()].sort(([a], [b]) => a.localeCompare(b)).map(([table, cols]) => {
+		const assignments = [...cols].sort((a, b) => a.column.localeCompare(b.column)).map((column) => `"${column.column}" = ${replacementFor(column.column)}`).join(", ");
+		return `UPDATE ${table.split(".").map((part) => `"${part}"`).join(".")} SET ${assignments};`;
+	});
+}
+/** Host and database of a connection string, with no credentials in it. */
+function describeTarget(connectionString) {
+	try {
+		const url = new URL(connectionString);
+		const database = url.pathname.replace(/^\//, "") || "(default)";
+		return `${url.hostname}${url.port ? `:${url.port}` : ""}/${database}`;
+	} catch {
+		return "(unparseable connection string)";
+	}
+}
+/**
+* `pg_dump` arguments for the source.
+*
+* `--no-owner` and `--no-acl` because the roles on a production server do not
+* exist locally, and without them every `ALTER … OWNER TO` in the dump fails and
+* buries the real output in noise. `--format=custom` so `pg_restore` can be told
+* to continue past errors selectively rather than all-or-nothing.
+*/
+function dumpArgs(plan) {
+	const args = [
+		"--format=custom",
+		"--no-owner",
+		"--no-acl",
+		"--no-privileges"
+	];
+	for (const schema of plan.schemas) args.push("--schema", schema);
+	args.push("--dbname", plan.source);
+	return args;
+}
+/**
+* `pg_restore` arguments for the target.
+*
+* `--clean --if-exists` because a pull replaces what is there: restoring into a
+* database that already has the tables would otherwise fail on every one of
+* them. `--no-owner` for the same reason as the dump.
+*/
+function restoreArgs(plan, dumpFile) {
+	return [
+		"--clean",
+		"--if-exists",
+		"--no-owner",
+		"--no-privileges",
+		"--dbname",
+		plan.target,
+		dumpFile
+	];
+}
+/** Is `pg_dump` on PATH, and what version? Checked before anything destructive. */
+async function findPgDump() {
+	try {
+		const { stdout } = await execa("pg_dump", ["--version"]);
+		return stdout.trim();
+	} catch {
+		return null;
+	}
+}
+//#endregion
+export { anonymizeStatements, describeTarget, dumpArgs, findPgDump, restoreArgs };
+
+//# sourceMappingURL=pull-DqPRu1te.js.map

package/dist/pull-DqPRu1te.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pull-DqPRu1te.js","names":[],"sources":["../src/dev-db/pull.ts"],"sourcesContent":["/**\n * `rebase db pull` — copy a database's contents into local development.\n *\n * The common case is production into local, and the reason it exists is that\n * the alternative is worse: without it people hand-roll a `pg_dump | psql` and\n * get the flags wrong in ways that either fail loudly at 2am or, more often,\n * quietly restore half a schema.\n *\n * Three things this command insists on, because copying a production database\n * onto a laptop is a data-protection event whether or not anyone calls it one:\n *\n * 1. **It says what it is about to do, in full, before doing it** — which\n *    database it will read, which one it will overwrite, and where the data will\n *    come to rest on disk. The target path matters: people forget that\n *    `.rebase/pgdata` is a directory their backup software may be indexing.\n *\n * 2. **It refuses to run unattended without being told to.** The target is\n *    destroyed, so a mistyped `--from` with no confirmation would take the\n *    developer's working database with it.\n *\n * 3. **It will not write to a remote database.** The target is always the local\n *    development database; there is no flag that makes this push. A tool that\n *    can copy in both directions eventually copies in the wrong one.\n *\n * Anonymization is opt-in (`--anonymize`), which is a deliberate choice and not\n * an obviously safe one — the flag nobody types is the flag nobody gets. It is\n * a best-effort pass over columns whose *names* look like personal data, and\n * {@link ANONYMIZE_PATTERNS} says exactly which. It cannot find personal data in\n * a column called `notes`, and this file says so rather than implying a\n * guarantee it cannot keep.\n */\n\nimport { execa } from \"execa\";\n\n/**\n * Column-name patterns the anonymizer overwrites.\n *\n * Names, not contents: inspecting values would be slower, and would still miss\n * the same things. This is a reasonable-effort measure for making a local copy\n * less dangerous, and it is not a compliance control.\n */\nexport const ANONYMIZE_PATTERNS: readonly { pattern: RegExp; replacement: string }[] = [\n    { pattern: /^(.*_)?e?mail(_.*)?$/i, replacement: \"concat('user', id::text, '@example.invalid')\" },\n    { pattern: /^(.*_)?(phone|mobile|tel|telephone)(_.*)?$/i, replacement: \"'+10000000000'\" },\n    { pattern: /^(.*_)?(first_name|last_name|full_name|surname|given_name)(_.*)?$/i, replacement: \"'Redacted'\" },\n    { pattern: /^(.*_)?(address|street|postcode|zip|zipcode)(_.*)?$/i, replacement: \"'Redacted'\" },\n    { pattern: /^(.*_)?(ssn|tax_id|national_id|passport)(_.*)?$/i, replacement: \"'REDACTED'\" },\n    { pattern: /^(.*_)?(password|password_hash|secret|token|api_key|access_token|refresh_token)(_.*)?$/i, replacement: \"'REDACTED'\" },\n    { pattern: /^(.*_)?(ip|ip_address|user_agent)(_.*)?$/i, replacement: \"'REDACTED'\" }\n];\n\nexport function shouldAnonymize(columnName: string): boolean {\n    return ANONYMIZE_PATTERNS.some((rule) => rule.pattern.test(columnName));\n}\n\nexport function replacementFor(columnName: string): string | null {\n    return ANONYMIZE_PATTERNS.find((rule) => rule.pattern.test(columnName))?.replacement ?? null;\n}\n\n/** A text-ish column the anonymizer can overwrite without a type error. */\nexport interface ColumnRef {\n    schema: string;\n    table: string;\n    column: string;\n    dataType: string;\n}\n\n/**\n * Anonymizable columns: name looks personal, and the type can hold the\n * replacement.\n *\n * The type check is what stops this generating `UPDATE … SET user_id =\n * 'Redacted'` for an integer column called `user_id_email_seq` and failing the\n * whole pass on a technicality.\n */\nexport function anonymizableColumns(columns: readonly ColumnRef[]): ColumnRef[] {\n    const textual = new Set([\"text\", \"character varying\", \"varchar\", \"character\", \"char\", \"citext\"]);\n\n    return columns.filter((column) => shouldAnonymize(column.column) && textual.has(column.dataType.toLowerCase()));\n}\n\n/** `UPDATE` statements for one anonymization pass, in a stable order. */\nexport function anonymizeStatements(columns: readonly ColumnRef[]): string[] {\n    const byTable = new Map<string, ColumnRef[]>();\n    for (const column of anonymizableColumns(columns)) {\n        const key = `${column.schema}.${column.table}`;\n        byTable.set(key, [...(byTable.get(key) ?? []), column]);\n    }\n\n    return [...byTable.entries()]\n        .sort(([a], [b]) => a.localeCompare(b))\n        .map(([table, cols]) => {\n            const assignments = [...cols]\n                .sort((a, b) => a.column.localeCompare(b.column))\n                .map((column) => `\"${column.column}\" = ${replacementFor(column.column)}`)\n                .join(\", \");\n\n            return `UPDATE ${table.split(\".\").map((part) => `\"${part}\"`).join(\".\")} SET ${assignments};`;\n        });\n}\n\n/** Host and database of a connection string, with no credentials in it. */\nexport function describeTarget(connectionString: string): string {\n    try {\n        const url = new URL(connectionString);\n        const database = url.pathname.replace(/^\\//, \"\") || \"(default)\";\n\n        return `${url.hostname}${url.port ? `:${url.port}` : \"\"}/${database}`;\n    } catch {\n        // Never echo the raw string: it carries a password, and this line is\n        // printed to a terminal people paste into issues.\n        return \"(unparseable connection string)\";\n    }\n}\n\nexport interface PullPlan {\n    /** Where the data comes from. */\n    source: string;\n    /** Where it lands. Always local. */\n    target: string;\n    anonymize: boolean;\n    /** Schemas to copy. Empty means every non-system schema. */\n    schemas: string[];\n}\n\n/**\n * `pg_dump` arguments for the source.\n *\n * `--no-owner` and `--no-acl` because the roles on a production server do not\n * exist locally, and without them every `ALTER … OWNER TO` in the dump fails and\n * buries the real output in noise. `--format=custom` so `pg_restore` can be told\n * to continue past errors selectively rather than all-or-nothing.\n */\nexport function dumpArgs(plan: PullPlan): string[] {\n    const args = [\"--format=custom\", \"--no-owner\", \"--no-acl\", \"--no-privileges\"];\n    for (const schema of plan.schemas) args.push(\"--schema\", schema);\n    args.push(\"--dbname\", plan.source);\n\n    return args;\n}\n\n/**\n * `pg_restore` arguments for the target.\n *\n * `--clean --if-exists` because a pull replaces what is there: restoring into a\n * database that already has the tables would otherwise fail on every one of\n * them. `--no-owner` for the same reason as the dump.\n */\nexport function restoreArgs(plan: PullPlan, dumpFile: string): string[] {\n    return [\"--clean\", \"--if-exists\", \"--no-owner\", \"--no-privileges\", \"--dbname\", plan.target, dumpFile];\n}\n\n/** Is `pg_dump` on PATH, and what version? Checked before anything destructive. */\nexport async function findPgDump(): Promise<string | null> {\n    try {\n        const { stdout } = await execa(\"pg_dump\", [\"--version\"]);\n\n        return stdout.trim();\n    } catch {\n        return null;\n    }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyCA,IAAa,qBAA0E;CACnF;EAAE,SAAS;EAAyB,aAAa;CAA+C;CAChG;EAAE,SAAS;EAA+C,aAAa;CAAiB;CACxF;EAAE,SAAS;EAAsE,aAAa;CAAa;CAC3G;EAAE,SAAS;EAAwD,aAAa;CAAa;CAC7F;EAAE,SAAS;EAAoD,aAAa;CAAa;CACzF;EAAE,SAAS;EAA2F,aAAa;CAAa;CAChI;EAAE,SAAS;EAA6C,aAAa;CAAa;AACtF;AAEA,SAAgB,gBAAgB,YAA6B;CACzD,OAAO,mBAAmB,MAAM,SAAS,KAAK,QAAQ,KAAK,UAAU,CAAC;AAC1E;AAEA,SAAgB,eAAe,YAAmC;CAC9D,OAAO,mBAAmB,MAAM,SAAS,KAAK,QAAQ,KAAK,UAAU,CAAC,CAAC,EAAE,eAAe;AAC5F;;;;;;;;;AAkBA,SAAgB,oBAAoB,SAA4C;CAC5E,MAAM,0BAAU,IAAI,IAAI;EAAC;EAAQ;EAAqB;EAAW;EAAa;EAAQ;CAAQ,CAAC;CAE/F,OAAO,QAAQ,QAAQ,WAAW,gBAAgB,OAAO,MAAM,KAAK,QAAQ,IAAI,OAAO,SAAS,YAAY,CAAC,CAAC;AAClH;;AAGA,SAAgB,oBAAoB,SAAyC;CACzE,MAAM,0BAAU,IAAI,IAAyB;CAC7C,KAAK,MAAM,UAAU,oBAAoB,OAAO,GAAG;EAC/C,MAAM,MAAM,GAAG,OAAO,OAAO,GAAG,OAAO;EACvC,QAAQ,IAAI,KAAK,CAAC,GAAI,QAAQ,IAAI,GAAG,KAAK,CAAC,GAAI,MAAM,CAAC;CAC1D;CAEA,OAAO,CAAC,GAAG,QAAQ,QAAQ,CAAC,CAAC,CACxB,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,cAAc,CAAC,CAAC,CAAC,CACtC,KAAK,CAAC,OAAO,UAAU;EACpB,MAAM,cAAc,CAAC,GAAG,IAAI,CAAC,CACxB,MAAM,GAAG,MAAM,EAAE,OAAO,cAAc,EAAE,MAAM,CAAC,CAAC,CAChD,KAAK,WAAW,IAAI,OAAO,OAAO,MAAM,eAAe,OAAO,MAAM,GAAG,CAAC,CACxE,KAAK,IAAI;EAEd,OAAO,UAAU,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,SAAS,IAAI,KAAK,EAAE,CAAC,CAAC,KAAK,GAAG,EAAE,OAAO,YAAY;CAC9F,CAAC;AACT;;AAGA,SAAgB,eAAe,kBAAkC;CAC7D,IAAI;EACA,MAAM,MAAM,IAAI,IAAI,gBAAgB;EACpC,MAAM,WAAW,IAAI,SAAS,QAAQ,OAAO,EAAE,KAAK;EAEpD,OAAO,GAAG,IAAI,WAAW,IAAI,OAAO,IAAI,IAAI,SAAS,GAAG,GAAG;CAC/D,QAAQ;EAGJ,OAAO;CACX;AACJ;;;;;;;;;AAoBA,SAAgB,SAAS,MAA0B;CAC/C,MAAM,OAAO;EAAC;EAAmB;EAAc;EAAY;CAAiB;CAC5E,KAAK,MAAM,UAAU,KAAK,SAAS,KAAK,KAAK,YAAY,MAAM;CAC/D,KAAK,KAAK,YAAY,KAAK,MAAM;CAEjC,OAAO;AACX;;;;;;;;AASA,SAAgB,YAAY,MAAgB,UAA4B;CACpE,OAAO;EAAC;EAAW;EAAe;EAAc;EAAmB;EAAY,KAAK;EAAQ;CAAQ;AACxG;;AAGA,eAAsB,aAAqC;CACvD,IAAI;EACA,MAAM,EAAE,WAAW,MAAM,MAAM,WAAW,CAAC,WAAW,CAAC;EAEvD,OAAO,OAAO,KAAK;CACvB,QAAQ;EACJ,OAAO;CACX;AACJ"}

package/dist/resources/derive.d.ts

@@ -0,0 +1,47 @@
+import { type ResourceGraph } from "@rebasepro/types";
+/** The committed, generated record of what a project needs. */
+export declare const RESOURCE_GRAPH_FILENAME = "rebase.resources.json";
+/** A problem found while deriving, reported with the rest rather than thrown one at a time. */
+export interface ResourceIssue {
+    path: string;
+    message: string;
+}
+export interface DeriveOptions {
+    /** Absolute path to the project's config directory. */
+    configDir: string;
+    /**
+     * Whether to evaluate collection files too. Resources are conventionally
+     * declared in `resources.ts`, but nothing stops a bucket being declared
+     * beside the collection that stores into it, and a graph that missed it
+     * would under-report what the project needs.
+     */
+    includeCollections?: boolean;
+}
+/**
+ * Evaluate a project's config and return the graph it declares.
+ *
+ * Clears any previously registered declarations first, so deriving twice in one
+ * process — a watch mode, a test — describes the project rather than the union
+ * of every project seen so far.
+ */
+export declare function deriveResourceGraph(options: DeriveOptions): Promise<{
+    graph: ResourceGraph;
+    issues: ResourceIssue[];
+}>;
+/** The graph as it is written to disk: stable key order, trailing newline. */
+export declare function serializeResourceGraph(graph: ResourceGraph): string;
+/** Read the committed graph, or null when a project has none yet. */
+export declare function readResourceGraphFile(projectRoot: string): string | null;
+/**
+ * Write the graph, and say whether the file changed.
+ *
+ * The boolean is what a `--check` mode reports on: a project whose committed
+ * graph disagrees with its config has a host reading one thing and a runtime
+ * doing another.
+ */
+export declare function writeResourceGraphFile(projectRoot: string, graph: ResourceGraph): {
+    changed: boolean;
+    file: string;
+};
+/** Parse a committed graph file, tolerating the `$generated` banner. */
+export declare function parseResourceGraph(contents: string): ResourceGraph;

package/dist/state-c0CJ6Kwb.js

@@ -0,0 +1,190 @@
+import path from "path";
+import fs from "fs";
+import net from "net";
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+//#region src/dev-db/state.ts
+/**
+* The managed database's state file, and the rules for trusting it.
+*
+* The daemon outlives the command that started it — `rebase db push` in one
+* terminal and `rebase dev` in another have to reach the *same* PGlite, because
+* two processes opening one data directory would corrupt it. So the daemon
+* records where it is, and every command reads that record.
+*
+* A record on disk is a claim, not a fact. The process it names may have been
+* killed, the machine may have rebooted and handed the pid to something else,
+* and the port may now belong to a stranger. {@link readState} therefore only
+* parses; deciding whether a record is live is {@link isDaemonAlive}'s job, and
+* it asks the daemon rather than the operating system.
+*/
+var state_exports = /* @__PURE__ */ __exportAll({
+	DATA_DIR_NAME: () => DATA_DIR_NAME,
+	DEV_DB_DIR: () => DEV_DB_DIR,
+	START_LOCK_NAME: () => START_LOCK_NAME,
+	STATE_FILE_NAME: () => STATE_FILE_NAME,
+	acquireStartLock: () => acquireStartLock,
+	clearState: () => clearState,
+	dataDir: () => dataDir,
+	devDbDir: () => devDbDir,
+	findFreePort: () => findFreePort,
+	pidRunning: () => pidRunning,
+	readState: () => readState,
+	releaseStartLock: () => releaseStartLock,
+	startLockFile: () => startLockFile,
+	stateFile: () => stateFile,
+	writeState: () => writeState
+});
+/** Everything under here is generated and gitignored. */
+var DEV_DB_DIR = ".rebase";
+/** PGlite's own data directory. Deleting it is what `--reset` means. */
+var DATA_DIR_NAME = "pgdata";
+/** The record the daemon writes once it is accepting connections. */
+var STATE_FILE_NAME = "pglite.json";
+/**
+* Held by whoever is currently starting a daemon.
+*
+* Without it, `rebase dev` and `rebase db push` started in the same second both
+* see no state file, both spawn, and two processes open one PGlite data
+* directory — the exact corruption the single-daemon design exists to prevent.
+* Observed as `ENOTEMPTY` during cleanup, which is the harmless way for it to
+* show up; the harmful way is a damaged database.
+*/
+var START_LOCK_NAME = "starting.lock";
+function devDbDir(projectRoot) {
+	return path.join(projectRoot, DEV_DB_DIR);
+}
+function dataDir(projectRoot) {
+	return path.join(devDbDir(projectRoot), DATA_DIR_NAME);
+}
+function stateFile(projectRoot) {
+	return path.join(devDbDir(projectRoot), STATE_FILE_NAME);
+}
+function startLockFile(projectRoot) {
+	return path.join(devDbDir(projectRoot), START_LOCK_NAME);
+}
+/**
+* Take the start lock, or report that somebody else holds it.
+*
+* `wx` is the whole mechanism: create-if-absent is a single atomic syscall, so
+* exactly one of two racing processes can succeed no matter how close together
+* they arrive.
+*
+* A lock older than `staleAfterMs` is broken rather than waited on — the holder
+* may have been killed between creating it and starting anything, and a
+* developer should never have to know this file exists in order to unstick
+* their project.
+*/
+function acquireStartLock(projectRoot, staleAfterMs) {
+	const target = startLockFile(projectRoot);
+	fs.mkdirSync(devDbDir(projectRoot), { recursive: true });
+	const attempt = () => {
+		try {
+			const handle = fs.openSync(target, "wx");
+			fs.writeSync(handle, `${process.pid} ${(/* @__PURE__ */ new Date()).toISOString()}\n`);
+			fs.closeSync(handle);
+			return true;
+		} catch (error) {
+			if (error.code !== "EEXIST") throw error;
+			return false;
+		}
+	};
+	if (attempt()) return true;
+	try {
+		if (Math.max(0, Date.now() - fs.statSync(target).mtimeMs) < staleAfterMs) return false;
+		fs.unlinkSync(target);
+	} catch {}
+	return attempt();
+}
+function releaseStartLock(projectRoot) {
+	try {
+		fs.unlinkSync(startLockFile(projectRoot));
+	} catch {}
+}
+/**
+* Parse the record, or `null` for anything that is not one.
+*
+* Every failure is the same answer — absent — because every failure has the
+* same remedy: start a daemon. A corrupt state file is not worth an error
+* message to a user who never wrote it.
+*/
+function readState(projectRoot) {
+	let raw;
+	try {
+		raw = fs.readFileSync(stateFile(projectRoot), "utf8");
+	} catch {
+		return null;
+	}
+	try {
+		const parsed = JSON.parse(raw);
+		if (typeof parsed.port !== "number" || !Number.isInteger(parsed.port) || parsed.port <= 0 || parsed.port > 65535 || typeof parsed.pid !== "number" || typeof parsed.dataDir !== "string" || typeof parsed.token !== "string" || parsed.token.length === 0 || typeof parsed.identityPort !== "number" || !Number.isInteger(parsed.identityPort) || parsed.identityPort <= 0 || parsed.identityPort > 65535) return null;
+		return {
+			port: parsed.port,
+			pid: parsed.pid,
+			dataDir: parsed.dataDir,
+			startedAt: typeof parsed.startedAt === "string" ? parsed.startedAt : "",
+			token: parsed.token,
+			identityPort: parsed.identityPort
+		};
+	} catch {
+		return null;
+	}
+}
+function writeState(projectRoot, state) {
+	fs.mkdirSync(devDbDir(projectRoot), { recursive: true });
+	const target = stateFile(projectRoot);
+	const temporary = `${target}.${process.pid}.tmp`;
+	fs.writeFileSync(temporary, `${JSON.stringify(state, null, 2)}\n`, "utf8");
+	fs.renameSync(temporary, target);
+}
+function clearState(projectRoot) {
+	try {
+		fs.unlinkSync(stateFile(projectRoot));
+	} catch {}
+}
+/** Is *some* process with this pid running? A fast, cheap negative check. */
+function pidRunning(pid) {
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch (error) {
+		return error.code === "EPERM";
+	}
+}
+/**
+* Ask a port for a free one, then hand back the number.
+*
+* Deliberately not the probe `rebase init` uses: that one has a documented
+* failure where a port is free to probe and unusable to publish. This binds on
+* loopback only, which is also where the daemon listens, so a port that binds
+* here binds there.
+*/
+function findFreePort() {
+	return new Promise((resolve, reject) => {
+		const server = net.createServer();
+		server.once("error", reject);
+		server.listen(0, "127.0.0.1", () => {
+			const address = server.address();
+			if (address === null || typeof address === "string") {
+				server.close(() => reject(/* @__PURE__ */ new Error("Could not determine a free port.")));
+				return;
+			}
+			const { port } = address;
+			server.close(() => resolve(port));
+		});
+	});
+}
+//#endregion
+export { findFreePort as a, releaseStartLock as c, writeState as d, __exportAll as f, devDbDir as i, stateFile as l, clearState as n, pidRunning as o, dataDir as r, readState as s, acquireStartLock as t, state_exports as u };
+
+//# sourceMappingURL=state-c0CJ6Kwb.js.map

package/dist/state-c0CJ6Kwb.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"state-c0CJ6Kwb.js","names":[],"sources":["../src/dev-db/state.ts"],"sourcesContent":["/**\n * The managed database's state file, and the rules for trusting it.\n *\n * The daemon outlives the command that started it — `rebase db push` in one\n * terminal and `rebase dev` in another have to reach the *same* PGlite, because\n * two processes opening one data directory would corrupt it. So the daemon\n * records where it is, and every command reads that record.\n *\n * A record on disk is a claim, not a fact. The process it names may have been\n * killed, the machine may have rebooted and handed the pid to something else,\n * and the port may now belong to a stranger. {@link readState} therefore only\n * parses; deciding whether a record is live is {@link isDaemonAlive}'s job, and\n * it asks the daemon rather than the operating system.\n */\n\nimport fs from \"fs\";\nimport net from \"net\";\nimport path from \"path\";\n\n/** Everything under here is generated and gitignored. */\nexport const DEV_DB_DIR = \".rebase\";\n/** PGlite's own data directory. Deleting it is what `--reset` means. */\nexport const DATA_DIR_NAME = \"pgdata\";\n/** The record the daemon writes once it is accepting connections. */\nexport const STATE_FILE_NAME = \"pglite.json\";\n/**\n * Held by whoever is currently starting a daemon.\n *\n * Without it, `rebase dev` and `rebase db push` started in the same second both\n * see no state file, both spawn, and two processes open one PGlite data\n * directory — the exact corruption the single-daemon design exists to prevent.\n * Observed as `ENOTEMPTY` during cleanup, which is the harmless way for it to\n * show up; the harmful way is a damaged database.\n */\nexport const START_LOCK_NAME = \"starting.lock\";\n\nexport interface DaemonState {\n    /** TCP port the socket server is listening on, chosen when it started. */\n    port: number;\n    /** The daemon process. Used only as a fast negative check. */\n    pid: number;\n    /** Absolute path of the PGlite data directory this daemon has open. */\n    dataDir: string;\n    /** ISO timestamp, for diagnostics. */\n    startedAt: string;\n    /**\n     * A random token the daemon also answers with over the wire, on\n     * {@link identityPort}.\n     *\n     * Without it, \"is the daemon alive?\" degrades to \"is something listening on\n     * that port?\", which is a different question and answers yes for whatever\n     * process happened to take the port after a reboot. Rebase would then send\n     * migrations to a stranger.\n     */\n    token: string;\n    /** Loopback port that answers the identity check. */\n    identityPort: number;\n}\n\nexport function devDbDir(projectRoot: string): string {\n    return path.join(projectRoot, DEV_DB_DIR);\n}\n\nexport function dataDir(projectRoot: string): string {\n    return path.join(devDbDir(projectRoot), DATA_DIR_NAME);\n}\n\nexport function stateFile(projectRoot: string): string {\n    return path.join(devDbDir(projectRoot), STATE_FILE_NAME);\n}\n\nexport function startLockFile(projectRoot: string): string {\n    return path.join(devDbDir(projectRoot), START_LOCK_NAME);\n}\n\n/**\n * Take the start lock, or report that somebody else holds it.\n *\n * `wx` is the whole mechanism: create-if-absent is a single atomic syscall, so\n * exactly one of two racing processes can succeed no matter how close together\n * they arrive.\n *\n * A lock older than `staleAfterMs` is broken rather than waited on — the holder\n * may have been killed between creating it and starting anything, and a\n * developer should never have to know this file exists in order to unstick\n * their project.\n */\nexport function acquireStartLock(projectRoot: string, staleAfterMs: number): boolean {\n    const target = startLockFile(projectRoot);\n    fs.mkdirSync(devDbDir(projectRoot), { recursive: true });\n\n    const attempt = (): boolean => {\n        try {\n            const handle = fs.openSync(target, \"wx\");\n            fs.writeSync(handle, `${process.pid} ${new Date().toISOString()}\\n`);\n            fs.closeSync(handle);\n\n            return true;\n        } catch (error) {\n            if ((error as NodeJS.ErrnoException).code !== \"EEXIST\") throw error;\n\n            return false;\n        }\n    };\n\n    if (attempt()) return true;\n\n    try {\n        // Clamped at zero: a filesystem whose timestamp granularity rounds the\n        // mtime *up* reports a negative age for a lock created moments ago,\n        // and a negative age is below every threshold — so `staleAfterMs: 0`,\n        // which means \"break any lock\", would refuse to break one.\n        const age = Math.max(0, Date.now() - fs.statSync(target).mtimeMs);\n        if (age < staleAfterMs) return false;\n        fs.unlinkSync(target);\n    } catch {\n        // Vanished under us, which means the holder finished. Either way the\n        // next attempt is the answer.\n    }\n\n    return attempt();\n}\n\nexport function releaseStartLock(projectRoot: string): void {\n    try {\n        fs.unlinkSync(startLockFile(projectRoot));\n    } catch {\n        // Already released is the desired end state.\n    }\n}\n\n/**\n * Parse the record, or `null` for anything that is not one.\n *\n * Every failure is the same answer — absent — because every failure has the\n * same remedy: start a daemon. A corrupt state file is not worth an error\n * message to a user who never wrote it.\n */\nexport function readState(projectRoot: string): DaemonState | null {\n    let raw: string;\n    try {\n        raw = fs.readFileSync(stateFile(projectRoot), \"utf8\");\n    } catch {\n        return null;\n    }\n\n    try {\n        const parsed = JSON.parse(raw) as Partial<DaemonState>;\n        if (\n            typeof parsed.port !== \"number\" ||\n            !Number.isInteger(parsed.port) ||\n            parsed.port <= 0 ||\n            parsed.port > 65535 ||\n            typeof parsed.pid !== \"number\" ||\n            typeof parsed.dataDir !== \"string\" ||\n            typeof parsed.token !== \"string\" ||\n            parsed.token.length === 0 ||\n            typeof parsed.identityPort !== \"number\" ||\n            !Number.isInteger(parsed.identityPort) ||\n            parsed.identityPort <= 0 ||\n            parsed.identityPort > 65535\n        ) {\n            return null;\n        }\n\n        return {\n            port: parsed.port,\n            pid: parsed.pid,\n            dataDir: parsed.dataDir,\n            startedAt: typeof parsed.startedAt === \"string\" ? parsed.startedAt : \"\",\n            token: parsed.token,\n            identityPort: parsed.identityPort\n        };\n    } catch {\n        return null;\n    }\n}\n\nexport function writeState(projectRoot: string, state: DaemonState): void {\n    fs.mkdirSync(devDbDir(projectRoot), { recursive: true });\n    // Written whole then moved, so a reader never sees half a record — commands\n    // poll this file while the daemon is starting.\n    const target = stateFile(projectRoot);\n    const temporary = `${target}.${process.pid}.tmp`;\n    fs.writeFileSync(temporary, `${JSON.stringify(state, null, 2)}\\n`, \"utf8\");\n    fs.renameSync(temporary, target);\n}\n\nexport function clearState(projectRoot: string): void {\n    try {\n        fs.unlinkSync(stateFile(projectRoot));\n    } catch {\n        // Already gone is the desired end state.\n    }\n}\n\n/** Is *some* process with this pid running? A fast, cheap negative check. */\nexport function pidRunning(pid: number): boolean {\n    try {\n        // Signal 0 performs the permission and existence checks without\n        // delivering anything.\n        process.kill(pid, 0);\n\n        return true;\n    } catch (error) {\n        // EPERM means it exists and belongs to someone else, which for our\n        // purposes is still \"running\".\n        return (error as NodeJS.ErrnoException).code === \"EPERM\";\n    }\n}\n\n/** Can a TCP connection be opened to this port on loopback? */\nexport function portAccepting(port: number, timeoutMs = 1000): Promise<boolean> {\n    return new Promise((resolve) => {\n        const socket = new net.Socket();\n        const settle = (answer: boolean) => {\n            socket.removeAllListeners();\n            socket.destroy();\n            resolve(answer);\n        };\n        socket.setTimeout(timeoutMs);\n        socket.once(\"connect\", () => settle(true));\n        socket.once(\"timeout\", () => settle(false));\n        socket.once(\"error\", () => settle(false));\n        socket.connect(port, \"127.0.0.1\");\n    });\n}\n\n/**\n * Ask a port for a free one, then hand back the number.\n *\n * Deliberately not the probe `rebase init` uses: that one has a documented\n * failure where a port is free to probe and unusable to publish. This binds on\n * loopback only, which is also where the daemon listens, so a port that binds\n * here binds there.\n */\nexport function findFreePort(): Promise<number> {\n    return new Promise((resolve, reject) => {\n        const server = net.createServer();\n        server.once(\"error\", reject);\n        server.listen(0, \"127.0.0.1\", () => {\n            const address = server.address();\n            if (address === null || typeof address === \"string\") {\n                server.close(() => reject(new Error(\"Could not determine a free port.\")));\n\n                return;\n            }\n            const { port } = address;\n            server.close(() => resolve(port));\n        });\n    });\n}\n"],"mappings":"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"}

package/dist/telemetry/consent.d.ts

@@ -1,4 +1,4 @@
-import { TelemetryEventName } from "./payload";
+import { TelemetryEventName } from "./payload.js";
 /**
  * Asking, and what the question looks like.
  *

package/dist/telemetry/index.d.ts

@@ -1,10 +1,10 @@
-import { TelemetryEvent, TelemetryEventName } from "./payload";
-export { TELEMETRY_SCHEMA_VERSION, bucket, durationBucket, errorClass, buildEvent, sanitize } from "./payload";
-export type { TelemetryEvent, TelemetryEventName, TelemetryValue } from "./payload";
-export { configPath, readConfig, writeConfig } from "./identity";
-export type { TelemetryConfig } from "./identity";
-export { readProjectPolicy } from "./project";
-export type { ProjectTelemetryPolicy } from "./project";
+import { TelemetryEvent, TelemetryEventName } from "./payload.js";
+export { TELEMETRY_SCHEMA_VERSION, bucket, durationBucket, errorClass, buildEvent, sanitize } from "./payload.js";
+export type { TelemetryEvent, TelemetryEventName, TelemetryValue } from "./payload.js";
+export { configPath, readConfig, writeConfig } from "./identity.js";
+export type { TelemetryConfig } from "./identity.js";
+export { readProjectPolicy } from "./project.js";
+export type { ProjectTelemetryPolicy } from "./project.js";
 /**
  * Where events go. Overridable so a fork can point at its own collector, and so
  * the tests never touch the network.

package/dist/utils/dev-preflight.d.ts

@@ -0,0 +1,73 @@
+/** Where the preflight stopped, and why. Returned so tests can assert it. */
+export type PreflightOutcome = {
+    action: "disabled";
+} | {
+    action: "no-dsn";
+} | {
+    action: "remote-dsn";
+    host: string;
+} | {
+    action: "already-running";
+    host: string;
+    port: number;
+} | {
+    action: "no-compose";
+} | {
+    action: "no-docker";
+    hint: string;
+} | {
+    action: "start-failed";
+    hint: string;
+} | {
+    action: "started";
+    port: number;
+    pushed: boolean;
+};
+/**
+ * The host and port of a Postgres DSN, but only when it points at this machine.
+ *
+ * Returns null for anything else — a remote host, an unparseable string, a
+ * non-postgres scheme. Callers treat null as "do nothing", so every parse
+ * failure fails closed onto the safe behaviour rather than onto a guess.
+ */
+export declare function parseLoopbackDsn(dsn: string | undefined): {
+    host: string;
+    port: number;
+} | null;
+/**
+ * Whether a compose file declares a `db` service.
+ *
+ * Deliberately a text scan and not a YAML parse: the CLI has no YAML
+ * dependency, and the question is only ever asked of a file this tool wrote.
+ * A false negative costs the automation and nothing else — the reader gets the
+ * manual steps, which are correct.
+ */
+export declare function composeDeclaresDbService(yamlText: string): boolean;
+/** Is something accepting connections there right now? */
+export declare function probeTcp(host: string, port: number, timeoutMs?: number): Promise<boolean>;
+/**
+ * Poll until the port answers, or give up.
+ *
+ * Postgres publishes its port before it is ready to accept queries, so the
+ * caller still has to tolerate a first connection that is refused at the
+ * protocol level. This only answers "has the container got as far as listening",
+ * which is the part that takes the seconds.
+ */
+export declare function waitForPort(host: string, port: number, timeoutMs?: number, intervalMs?: number): Promise<boolean>;
+export interface EnsureDevDatabaseOptions {
+    projectRoot: string;
+    /** The DSN from the project's env file, if it has one. */
+    databaseUrl: string | undefined;
+    /** Set by `--no-db` or REBASE_DEV_NO_DB. */
+    disabled: boolean;
+    /** Whether the project has collections worth pushing. */
+    hasCollections: boolean;
+    /** Runs `rebase db push` for this project. Injected so tests need no database. */
+    pushSchema: () => Promise<void>;
+    log?: (message: string) => void;
+}
+/**
+ * Start the project's development database if it is not running, and give it a
+ * schema if this call is what started it.
+ */
+export declare function ensureDevDatabase(options: EnsureDevDatabaseOptions): Promise<PreflightOutcome>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rebasepro/cli",
-  "version": "0.16.0",
+  "version": "0.16.1-canary.g0d7af95",
   "description": "Developer tools for Rebase projects",
   "main": "./dist/index.es.js",
   "module": "./dist/index.es.js",
@@ -31,17 +31,17 @@
     "execa": "^9.6.1",
     "inquirer": "14.0.2",
     "jiti": "^2.7.0",
+    "pg": "^8.22.0",
     "@rebasepro/agent-skills": "0.16.0",
-    "@rebasepro/client": "0.16.0",
-    "@rebasepro/codegen": "0.16.0",
-    "@rebasepro/server": "0.16.0",
-    "@rebasepro/server-postgres": "0.16.0",
-    "@rebasepro/types": "0.16.0"
+    "@rebasepro/codegen": "0.16.1-canary.g0d7af95",
+    "@rebasepro/client": "0.16.1-canary.g0d7af95",
+    "@rebasepro/server": "0.16.1-canary.g0d7af95",
+    "@rebasepro/server-postgres": "0.16.1-canary.g0d7af95",
+    "@rebasepro/types": "0.16.1-canary.g0d7af95"
   },
   "devDependencies": {
     "@types/node": "^26.1.2",
     "@types/pg": "^8.20.0",
-    "pg": "^8.22.0",
     "typescript": "^6.0.3",
     "vite": "^8.1.5",
     "vitest": "4.1.10"
@@ -63,10 +63,15 @@
     "url": "https://github.com/rebasepro/rebase.git",
     "directory": "packages/cli"
   },
+  "optionalDependencies": {
+    "@electric-sql/pglite": "^0.5.6",
+    "@electric-sql/pglite-socket": "^0.2.9"
+  },
   "scripts": {
     "test": "vitest run",
+    "test:integration": "vitest run --config vitest.integration.config.ts",
     "test:e2e": "vitest run --config vitest.e2e.config.ts",
-    "build": "vite build && tsc --emitDeclarationOnly -p tsconfig.json && node ../../scripts/assert-build-output.mjs",
+    "build": "vite build && tsc --emitDeclarationOnly -p tsconfig.json && node ../../tooling/scripts/add-dts-extensions.mjs dist && node ../../tooling/scripts/assert-build-output.mjs",
     "clean": "rm -rf dist && find ./src -name '*.js' -type f | xargs rm -f",
     "typecheck:test": "tsc --noEmit -p tsconfig.test.json"
   }