@rebasepro/cli 0.25.0 → 0.25.1

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

@@ -101,13 +101,33 @@ export declare function probeTcp(host: string, port: number, timeoutMs?: number)
  * forward. {@link waitForQueryable} is the check that a query will work.
  */
 export declare function waitForPort(host: string, port: number, timeoutMs?: number, intervalMs?: number): Promise<boolean>;
-/** Whether a database answered a query, and if not, the last reason it gave. */
+/**
+ * Whether a database answered a query, and if not, the last reason it gave —
+ * and, for a database closed to new connections, its name.
+ */
 export type QueryReadiness = {
     ready: true;
 } | {
     ready: false;
     error: string;
+    closedDatabase?: string;
 };
+/** What opening a closed database again did, and what to say about it. */
+export interface ClosedDatabaseHeal {
+    /** It accepts connections again. */
+    reopened: boolean;
+    /** The driver's own lines about it (`reopenedDatabasesNotice`). */
+    notice: string[];
+}
+/**
+ * The database a connection was refused by because it is closed to new
+ * connections (`ALLOW_CONNECTIONS false`), or null.
+ *
+ * The driver's `closedDatabaseName`, for the error a bare `pg` connect gives:
+ * the sentence is matched, not SQLSTATE 55000, which also covers failures that
+ * have nothing to do with connecting.
+ */
+export declare function closedDatabaseName(error: unknown): string | null;
 /**
  * Poll until `SELECT 1` succeeds on this connection string, or the bound runs out.
  *
@@ -118,10 +138,21 @@ export type QueryReadiness = {
  * three. Every error is retried: a reset, "the database system is starting up"
  * and a refused connection all mean "not yet", and the bound is what turns
  * "not yet" into an answer.
+ *
+ * Except one, which is not "not yet": a database closed to new connections
+ * (`closedDatabaseName`), which is what a `rebase db branch create --force`
+ * killed mid-copy leaves its source as. Waiting cannot open it, and it was
+ * waited on for the whole minute. It is opened again with the driver's
+ * `reopenClosedDatabases`, once, and then either answers or the wait ends at
+ * once, naming it.
  */
 export declare function waitForQueryable(databaseUrl: string, options?: {
     timeoutMs?: number;
     intervalMs?: number;
+    /** Opens a closed database again. The driver's `reopenClosedDatabases` by default; injected for tests. */
+    reopenClosed?: (databaseUrl: string) => Promise<ClosedDatabaseHeal>;
+    /** Where the driver's lines about a database it opened go. */
+    onNotice?: (line: string) => void;
 }): Promise<QueryReadiness>;
 /**
  * What a failed schema push printed, as lines to show.
@@ -204,6 +235,8 @@ export interface EnsureDevDatabaseOptions {
     startDatabase?: (projectRoot: string) => Promise<void>;
     /** How long a started database has to answer `SELECT 1`. Defaults to 60s. */
     readyTimeoutMs?: number;
+    /** Opens a database closed to new connections again; see `waitForQueryable`. Injected for tests. */
+    reopenClosed?: (databaseUrl: string) => Promise<ClosedDatabaseHeal>;
     /**
      * Who answers on the compose port. Asks Docker by default; injected for the
      * same reason `startDatabase` is.

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

@@ -1,3 +1,14 @@
+/**
+ * The address `rebase dev` is starting its backend on, handed to the
+ * `generate-sdk` child it runs.
+ *
+ * Dev regenerates the SDK at boot, beside the database start and before the
+ * backend binds — so before the backend writes `.rebase/state.json`, which is
+ * where `generate-sdk` otherwise reads the address for the README's example.
+ * Dev knows the port it hands the backend, and the child's environment is the
+ * only channel between them.
+ */
+export declare const DEV_BACKEND_URL_ENV = "REBASE_DEV_BACKEND_URL";
 /**
  * The port `rebase dev` derives from the project root path.
  * Range: 3001–3999 (avoids privileged ports and common services).

package/dist/utils/project.d.ts

@@ -158,7 +158,11 @@ export interface JsonFailureIssue {
  * failure mode of not doing it is an unparseable stream.
  */
 export declare function failAsJson(message: string, code: string, hint?: string, issues?: JsonFailureIssue[]): never;
-/** Did the command line ask for machine-readable output? */
+/**
+ * Did the command line ask for machine-readable output? Read as the parser
+ * reads a switch: `--json`, `--json=true` and `--json=1` ask for it,
+ * `--json=false` and `--json=0` do not.
+ */
 export declare function wantsJsonOutput(argv?: readonly string[]): boolean;
 /**
  * Require the project root or exit with a helpful error.

package/dist/utils/unknown-command.d.ts

@@ -17,6 +17,10 @@ export declare function suggestCommand(typed: string, known: readonly string[]):
  * `family` is empty for the top level: `rebase --help`, not `rebase  --help`.
  * `families` are the command families below this level, by name, whose
  * commands a word may be one of.
+ *
+ * The typed word is repeated with any connection-string password masked: a URL
+ * pasted where the command goes (`rebase db "postgres://u:pw@h/db"`) is a
+ * word like any other here, and this line lands in terminals and CI logs.
  */
 export declare function unknownCommandMessage(typed: string | undefined, known: readonly string[], family?: string, families?: Readonly<Record<string, readonly string[]>>): string;
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rebasepro/cli",
-  "version": "0.25.0",
+  "version": "0.25.1",
   "description": "Developer tools for Rebase projects",
   "keywords": [
     "cli",
@@ -43,12 +43,12 @@
     "inquirer": "14.0.2",
     "jiti": "^2.7.0",
     "pg": "^8.22.0",
-    "@rebasepro/codegen": "0.25.0",
-    "@rebasepro/client": "0.25.0",
-    "@rebasepro/agent-skills": "0.25.0",
-    "@rebasepro/server": "0.25.0",
-    "@rebasepro/types": "0.25.0",
-    "@rebasepro/server-postgres": "0.25.0"
+    "@rebasepro/client": "0.25.1",
+    "@rebasepro/codegen": "0.25.1",
+    "@rebasepro/server": "0.25.1",
+    "@rebasepro/types": "0.25.1",
+    "@rebasepro/agent-skills": "0.25.1",
+    "@rebasepro/server-postgres": "0.25.1"
   },
   "devDependencies": {
     "@types/node": "^26.1.2",

package/templates/resource-graphs/blank.json

@@ -0,0 +1,25 @@
+{
+    "$generated": "Generated from config by `rebase resources`. Edit the declarations, not this file.",
+    "version": 1,
+    "resources": [
+        {
+            "kind": "database",
+            "key": "(default)",
+            "engine": "postgres",
+            "transport": "server",
+            "usedBy": [
+                "collection:users"
+            ]
+        },
+        {
+            "kind": "function",
+            "key": "hello",
+            "engine": "http",
+            "transport": "server",
+            "options": {
+                "portable": true,
+                "file": "backend/functions/hello.ts"
+            }
+        }
+    ]
+}

package/templates/resource-graphs/blog.json

@@ -0,0 +1,28 @@
+{
+    "$generated": "Generated from config by `rebase resources`. Edit the declarations, not this file.",
+    "version": 1,
+    "resources": [
+        {
+            "kind": "database",
+            "key": "(default)",
+            "engine": "postgres",
+            "transport": "server",
+            "usedBy": [
+                "collection:authors",
+                "collection:posts",
+                "collection:tags",
+                "collection:users"
+            ]
+        },
+        {
+            "kind": "function",
+            "key": "hello",
+            "engine": "http",
+            "transport": "server",
+            "options": {
+                "portable": true,
+                "file": "backend/functions/hello.ts"
+            }
+        }
+    ]
+}

package/templates/resource-graphs/ecommerce.json

@@ -0,0 +1,28 @@
+{
+    "$generated": "Generated from config by `rebase resources`. Edit the declarations, not this file.",
+    "version": 1,
+    "resources": [
+        {
+            "kind": "database",
+            "key": "(default)",
+            "engine": "postgres",
+            "transport": "server",
+            "usedBy": [
+                "collection:categories",
+                "collection:orders",
+                "collection:products",
+                "collection:users"
+            ]
+        },
+        {
+            "kind": "function",
+            "key": "hello",
+            "engine": "http",
+            "transport": "server",
+            "options": {
+                "portable": true,
+                "file": "backend/functions/hello.ts"
+            }
+        }
+    ]
+}

package/templates/resource-graphs/headless.json

@@ -0,0 +1,22 @@
+{
+    "$generated": "Generated from config by `rebase resources`. Edit the declarations, not this file.",
+    "version": 1,
+    "resources": [
+        {
+            "kind": "database",
+            "key": "(default)",
+            "engine": "postgres",
+            "transport": "server"
+        },
+        {
+            "kind": "function",
+            "key": "hello",
+            "engine": "http",
+            "transport": "server",
+            "options": {
+                "portable": true,
+                "file": "backend/functions/hello.ts"
+            }
+        }
+    ]
+}

package/templates/template/.env.example

@@ -169,10 +169,11 @@ VITE_API_URL=
 # STORAGE_TYPE=local
 
 # --- Local filesystem (default — great for dev and single-server deployments) --
-# Unset, files land in <project>/uploads, under `rebase dev` and in the server
-# `rebase eject` writes alike. A relative path is read from the directory the
-# server runs in: the project root under `rebase dev`, backend/ after
-# `rebase eject`. So ./uploads names two places, and an absolute path one.
+# Unset, files land in <project>/uploads, under `rebase dev`, `rebase start`
+# and in the server `rebase eject` writes alike. A relative path is read from
+# the directory the server runs in: the project root under `rebase dev`,
+# backend/ after `rebase eject`. So ./uploads names two places, and an absolute
+# path one.
 # STORAGE_PATH=/absolute/path/to/uploads
 # FORCE_LOCAL_STORAGE=true      # Only with a durable volume holding STORAGE_PATH
 

package/templates/template/frontend/src/App.tsx

@@ -1,5 +1,3 @@
-import React from "react";
-
 import "@fontsource/jetbrains-mono";
 import "@fontsource-variable/inter";
 import "@fontsource-variable/instrument-sans";
@@ -19,14 +17,17 @@ import { collections } from "virtual:rebase-collections";
 const API_URL = import.meta.env.VITE_API_URL;
 const GOOGLE_CLIENT_ID = import.meta.env.VITE_GOOGLE_CLIENT_ID;
 
-export function App() {
-    const rebaseClient = React.useMemo(() => createRebaseClient({
-        baseUrl: API_URL,
-        // Store the refresh token in an httpOnly cookie (XSS-safe) rather than
-        // localStorage. The backend issues it via `auth.cookieAuth`.
-        auth: { authFlowMode: "cookie" }
-    }), []);
+// One client for the page, created when this module loads. Inside a component,
+// even in a `useMemo`, `<React.StrictMode>` builds a second one in development,
+// and both restore the session and open their own connections.
+const rebaseClient = createRebaseClient({
+    baseUrl: API_URL,
+    // Store the refresh token in an httpOnly cookie (XSS-safe) rather than
+    // localStorage. The backend issues it via `auth.cookieAuth`.
+    auth: { authFlowMode: "cookie" }
+});
 
+export function App() {
     const authController = useRebaseAuthController({
         client: rebaseClient,
         googleClientId: GOOGLE_CLIENT_ID

package/dist/args-BX0YD14a.js

@@ -1,266 +0,0 @@
-import chalk from "chalk";
-import arg from "arg";
-//#region src/utils/redact.ts
-/**
-* Connection-string passwords, replaced before a line is printed.
-*
-* A refusal that repeats what was typed repeats a password with it, and these
-* lines land in terminals, CI logs and issues. `user:***@` is the form every
-* other message uses: the driver's `redactConnectionPasswords` in
-* `@rebasepro/server-postgres`, which its entry does not export, and this
-* mirrors. Covers the user-info password and a `password=` parameter.
-*/
-function redactConnectionPasswords(text) {
-	return text.replace(/(\b[a-z][a-z0-9+.-]*:\/\/[^\s/?#@'"]*):[^\s/?#'"]*@/gi, "$1:***@").replace(/(\bpassword\s*=\s*)('[^']*'|[^\s&'"]+)/gi, "$1***");
-}
-//#endregion
-//#region src/utils/unknown-command.ts
-/**
-* What every command family says when it does not recognise a subcommand.
-*
-* Six families each did it differently, and the differences were not stylistic:
-*
-*   rebase statsu       "Unknown command: statsu" + the whole top-level help
-*   rebase auth foo     "Unknown auth command: foo" + the whole auth help
-*   rebase apps foo     "Unknown subcommand: foo"   — which command's?
-*   rebase skills foo   "Unknown skills subcommand: foo" + the whole help
-*   rebase telemetry x  the help, silently, with exit code 1 and no error line
-*   rebase cloud debug x both a JSON error *and* the human one, in JSON mode
-*
-* Dumping a screen of help after an error is the wrong shape: the one line that
-* says what happened scrolls off the top, and in a CI log it is buried in
-* forty. None of them offered the correction, which for a typo is the entire
-* answer — `statsu` is one transposition from `status`.
-*
-* So: one line, the near-miss when there is one, and where to read the rest.
-*/
-/**
-* Damerau–Levenshtein distance, capped by the caller.
-*
-* The transposition is the reason this is not plain Levenshtein: `statsu` for
-* `status` and `craete` for `create` are the two most common typing errors
-* there are, and both are distance 2 without it — the same as two unrelated
-* edits, which is too far to suggest anything at all.
-*/
-function editDistance(a, b) {
-	const rows = a.length + 1;
-	const cols = b.length + 1;
-	const d = Array.from({ length: rows }, () => new Array(cols).fill(0));
-	for (let i = 0; i < rows; i++) d[i][0] = i;
-	for (let j = 0; j < cols; j++) d[0][j] = j;
-	for (let i = 1; i < rows; i++) for (let j = 1; j < cols; j++) {
-		const cost = a[i - 1] === b[j - 1] ? 0 : 1;
-		d[i][j] = Math.min(d[i - 1][j] + 1, d[i][j - 1] + 1, d[i - 1][j - 1] + cost);
-		if (i > 1 && j > 1 && a[i - 1] === b[j - 2] && a[i - 2] === b[j - 1]) d[i][j] = Math.min(d[i][j], d[i - 2][j - 2] + 1);
-	}
-	return d[a.length][b.length];
-}
-/**
-* The one command the user probably meant, or nothing.
-*
-* Tight on purpose. A suggestion that is wrong is worse than none: it sends
-* someone to read the help for a command that was never the answer, and on a
-* family like `db` — where `push` and `pull` are one edit apart — a loose
-* threshold would confidently propose the destructive neighbour of what they
-* typed. So: one edit for a short word, two for a long one, and a prefix match
-* always counts (`rebase cloud dep` for `deploy`).
-*/
-function suggestCommand(typed, known) {
-	const word = typed.toLowerCase();
-	if (!word) return void 0;
-	if (word.length >= 3) {
-		const prefixed = known.filter((name) => name.toLowerCase().startsWith(word));
-		if (prefixed.length === 1) return prefixed[0];
-	}
-	const budget = word.length <= 4 ? 1 : 2;
-	let best;
-	for (const candidate of known) {
-		const distance = editDistance(word, candidate.toLowerCase());
-		if (distance > budget) continue;
-		if (!best || distance < best.distance) best = {
-			name: candidate,
-			distance
-		};
-	}
-	return best?.name;
-}
-/**
-* The family command a word names exactly, as `<family> <command>`, or nothing.
-*
-* `rebase deploy` is `rebase cloud deploy`: the word is a whole command one
-* level down. Exact only — a near miss there is a guess about both the family
-* and the command.
-*/
-function familyCommand(typed, families) {
-	const word = typed.toLowerCase();
-	for (const [family, commands] of Object.entries(families)) {
-		const match = commands.find((name) => name.toLowerCase() === word);
-		if (match) return `${family} ${match}`;
-	}
-}
-/**
-* The line itself, without printing it — so callers that must answer in JSON
-* (the cloud family, whose `fail()` writes a machine-readable envelope) use the
-* same words as the ones that print.
-*
-* `family` is empty for the top level: `rebase --help`, not `rebase  --help`.
-* `families` are the command families below this level, by name, whose
-* commands a word may be one of.
-*/
-function unknownCommandMessage(typed, known, family = "", families = {}) {
-	const what = family ? `${family} command` : "command";
-	const suggestion = typed ? suggestCommand(typed, known) ?? familyCommand(typed, families) : void 0;
-	const help = family ? `rebase ${family} --help` : "rebase --help";
-	return suggestion ? `Unknown ${what} "${typed}" — did you mean \`${suggestion}\`? Run \`${help}\` for the rest.` : `Unknown ${what} "${typed ?? ""}". Run \`${help}\` for the ones there are.`;
-}
-/**
-* Print the line to stderr and exit 1.
-*
-* stderr, not stdout: a mistyped command is a failure, and the families with a
-* `--json` mode guarantee that stdout holds only their envelope.
-*/
-function unknownCommand(typed, known, family = "", families = {}) {
-	console.error(chalk.red(`✗ ${unknownCommandMessage(typed, known, family, families)}`));
-	process.exit(1);
-}
-//#endregion
-//#region src/utils/args.ts
-/**
-* Argument parsing for the commands that take positional arguments.
-*
-* Every command in the small group used to parse its own line the same way:
-* `arg(spec, { argv: rawArgs.slice(4), permissive: true })`, then read `_[0]`
-* and `_[1]`. Both halves of that are wrong in a way that costs data.
-*
-*  - **`permissive: true` turns an unknown flag into a positional.** `arg`
-*    pushes an undeclared flag into `_` as a bare token, so `_[1]` is whatever
-*    came second on the line, flag or not. `rebase auth reset-password
-*    bob@example.com --debug` set Bob's password to the literal `--debug` — and
-*    `--debug` is what `bin/rebase.js` prints after *every* failure as the thing
-*    to re-run with, so the single most likely next keystroke after a failed
-*    reset was the one that reset the account to a two-word string.
-*  - **`slice(4)` assumes the command words are at fixed indices.** They are
-*    not: a flag before the command shifts everything, so `rebase --debug auth
-*    reset-password bob@example.com NewPass1!` read the email as
-*    `reset-password` and the password as `bob@example.com`.
-*
-* So: parse the *whole* line — `rawArgs` is `process.argv` — against a spec
-* strictly, with no permissive mode. `arg` then consumes every flag wherever it
-* appears and rejects the ones nobody declared, which leaves `_` holding the
-* command words followed by the real positionals, in order and at a known
-* offset. An unrecognised flag becomes an error naming the command's help,
-* which is the only safe answer: the alternative is guessing that it was meant
-* as a value.
-*
-* `commands/cloud/index.ts` resolves its positionals against its own spec for
-* the same reason; this is that idea for the commands whose positionals are
-* credentials rather than resource names.
-*/
-/**
-* Flags accepted on top of whatever a command declares.
-*
-* `--debug` is read by `bin/rebase.js` off `process.argv` and never by a
-* command, but it has to be *declared* somewhere or strict parsing rejects the
-* exact flag the CLI tells people to add. `--help`/`-h` are answered by each
-* command's dispatcher before any work happens.
-*/
-var GLOBAL_COMMAND_FLAGS = {
-	"--debug": Boolean,
-	"--help": Boolean,
-	"-h": "--help"
-};
-/**
-* The declared long flag an undeclared one was probably meant to be: one edit
-* or one swap away (`--form` → `--from`), or an abbreviation of exactly one
-* (`--anon` → `--anonymize`).
-*/
-function closestDeclaredFlag(typed, declared) {
-	if (!typed.startsWith("--")) return void 0;
-	const near = suggestCommand(typed.slice(2), declared.filter((flag) => flag.startsWith("--")).map((flag) => flag.slice(2)));
-	return near ? `--${near}` : void 0;
-}
-/** Past this many, a refusal names the help page rather than listing every flag. */
-var LISTED_FLAGS_MAX = 8;
-/**
-* The sentence an undeclared flag is refused with — the one `db backup`,
-* `db restore` and `db branch` say, so one CLI answers a typo one way:
-*
-*     `rebase db pull` has no option --anonymise — did you mean --anonymize?
-*     Nothing was run. See `rebase db pull --help`.
-*
-* With nothing close it lists what the command takes, when that list is short
-* enough to read.
-*
-* Exported for the commands that refuse a flag outside `parseCommandArgs`.
-*/
-function unknownOptionMessage(command, typed, spec) {
-	const near = closestDeclaredFlag(typed, Object.keys({
-		...GLOBAL_COMMAND_FLAGS,
-		...spec
-	}));
-	const own = Object.keys(spec).filter((flag) => flag.startsWith("--") && !(flag in GLOBAL_COMMAND_FLAGS));
-	return `\`rebase ${command}\` has no option ${typed}${near ? ` — did you mean ${near}?` : own.length === 0 ? " — it takes no options." : own.length <= LISTED_FLAGS_MAX ? ` — it takes ${own.join(", ")}.` : "."} Nothing was run. See \`rebase ${command} --help\`.`;
-}
-/** Did the line ask for help? Answered before dispatch, never by a handler. */
-function wantsHelp(rawArgs) {
-	return rawArgs.includes("--help") || rawArgs.includes("-h");
-}
-/**
-* The command line was wrong — nothing ran, and there is no stack to want.
-*
-* `bin/rebase.js` ends every failure with "Re-run with --debug for the stack
-* trace.", which is right when something broke inside a command and absurd for
-* a typo: the stack points at `arg` and this file, neither of which the person
-* who mistyped `--ouput` has any interest in. Worse, `--debug` is a flag, so
-* the suggested next command is *another* command line — and the one thing we
-* have just established is that the command line is what went wrong.
-*
-* Marked with a property rather than left to `instanceof`, because the reader
-* is `bin/rebase.js`: it imports the bundle, so the class object it would test
-* against is not the one this file compiled to.
-*/
-var UsageError = class extends Error {
-	isUsageError = true;
-	constructor(message) {
-		super(message);
-		this.name = "UsageError";
-	}
-};
-/**
-* Resolve a command's flags and positionals from the full `process.argv`.
-*
-* `commandWords` is how many words name the command itself — 2 for
-* `auth reset-password`, 1 for `start` — and is applied to the *parsed*
-* positionals rather than to `argv`, so a flag placed before the command no
-* longer shifts them.
-*
-* `command` names the command in error messages, e.g. `auth reset-password`.
-*
-* Throws on an unknown flag, on a positional that looks like a flag, and on
-* more positionals than the command takes. `bin/rebase.js` turns each into a
-* one-line `✗ …` and exit 1.
-*/
-function parseCommandArgs({ spec, rawArgs, commandWords, command, maxPositionals }) {
-	let parsed;
-	try {
-		parsed = arg({
-			...GLOBAL_COMMAND_FLAGS,
-			...spec
-		}, { argv: rawArgs.slice(2) });
-	} catch (err) {
-		if (err instanceof Error && err.code === "ARG_UNKNOWN_OPTION") throw new UsageError(unknownOptionMessage(command, (/option: (\S+)$/.exec(err.message)?.[1] ?? err.message).split("=")[0], spec));
-		throw err;
-	}
-	const positionals = parsed._.slice(commandWords);
-	for (const value of positionals) if (value.startsWith("-")) throw new UsageError(`\`${value}\` looks like an option, not a value — pass it with an explicit flag (\`rebase ${command} --help\`).`);
-	if (maxPositionals !== void 0 && positionals.length > maxPositionals) throw new UsageError(`rebase ${command} takes ${maxPositionals} argument${maxPositionals === 1 ? "" : "s"}, got ${positionals.length}: ${redactConnectionPasswords(positionals.join(" "))}`);
-	return {
-		flags: parsed,
-		positionals,
-		help: Boolean(parsed["--help"])
-	};
-}
-//#endregion
-export { unknownCommand as a, suggestCommand as i, parseCommandArgs as n, unknownCommandMessage as o, wantsHelp as r, redactConnectionPasswords as s, UsageError as t };
-
-//# sourceMappingURL=args-BX0YD14a.js.map

package/dist/args-BX0YD14a.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"args-BX0YD14a.js","names":[],"sources":["../src/utils/redact.ts","../src/utils/unknown-command.ts","../src/utils/args.ts"],"sourcesContent":["/**\n * Connection-string passwords, replaced before a line is printed.\n *\n * A refusal that repeats what was typed repeats a password with it, and these\n * lines land in terminals, CI logs and issues. `user:***@` is the form every\n * other message uses: the driver's `redactConnectionPasswords` in\n * `@rebasepro/server-postgres`, which its entry does not export, and this\n * mirrors. Covers the user-info password and a `password=` parameter.\n */\nexport function redactConnectionPasswords(text: string): string {\n    return text\n        .replace(/(\\b[a-z][a-z0-9+.-]*:\\/\\/[^\\s/?#@'\"]*):[^\\s/?#'\"]*@/gi, \"$1:***@\")\n        .replace(/(\\bpassword\\s*=\\s*)('[^']*'|[^\\s&'\"]+)/gi, \"$1***\");\n}\n","/**\n * What every command family says when it does not recognise a subcommand.\n *\n * Six families each did it differently, and the differences were not stylistic:\n *\n *   rebase statsu       \"Unknown command: statsu\" + the whole top-level help\n *   rebase auth foo     \"Unknown auth command: foo\" + the whole auth help\n *   rebase apps foo     \"Unknown subcommand: foo\"   — which command's?\n *   rebase skills foo   \"Unknown skills subcommand: foo\" + the whole help\n *   rebase telemetry x  the help, silently, with exit code 1 and no error line\n *   rebase cloud debug x both a JSON error *and* the human one, in JSON mode\n *\n * Dumping a screen of help after an error is the wrong shape: the one line that\n * says what happened scrolls off the top, and in a CI log it is buried in\n * forty. None of them offered the correction, which for a typo is the entire\n * answer — `statsu` is one transposition from `status`.\n *\n * So: one line, the near-miss when there is one, and where to read the rest.\n */\nimport chalk from \"chalk\";\n\n/**\n * Damerau–Levenshtein distance, capped by the caller.\n *\n * The transposition is the reason this is not plain Levenshtein: `statsu` for\n * `status` and `craete` for `create` are the two most common typing errors\n * there are, and both are distance 2 without it — the same as two unrelated\n * edits, which is too far to suggest anything at all.\n */\nfunction editDistance(a: string, b: string): number {\n    const rows = a.length + 1;\n    const cols = b.length + 1;\n    const d: number[][] = Array.from({ length: rows }, () => new Array<number>(cols).fill(0));\n\n    for (let i = 0; i < rows; i++) d[i][0] = i;\n    for (let j = 0; j < cols; j++) d[0][j] = j;\n\n    for (let i = 1; i < rows; i++) {\n        for (let j = 1; j < cols; j++) {\n            const cost = a[i - 1] === b[j - 1] ? 0 : 1;\n            d[i][j] = Math.min(\n                d[i - 1][j] + 1,\n                d[i][j - 1] + 1,\n                d[i - 1][j - 1] + cost\n            );\n            if (i > 1 && j > 1 && a[i - 1] === b[j - 2] && a[i - 2] === b[j - 1]) {\n                d[i][j] = Math.min(d[i][j], d[i - 2][j - 2] + 1);\n            }\n        }\n    }\n    return d[a.length][b.length];\n}\n\n/**\n * The one command the user probably meant, or nothing.\n *\n * Tight on purpose. A suggestion that is wrong is worse than none: it sends\n * someone to read the help for a command that was never the answer, and on a\n * family like `db` — where `push` and `pull` are one edit apart — a loose\n * threshold would confidently propose the destructive neighbour of what they\n * typed. So: one edit for a short word, two for a long one, and a prefix match\n * always counts (`rebase cloud dep` for `deploy`).\n */\nexport function suggestCommand(typed: string, known: readonly string[]): string | undefined {\n    const word = typed.toLowerCase();\n    if (!word) return undefined;\n\n    // An abbreviation, but only when it names exactly one command. \"res\" is a\n    // prefix of both `reset` and `restore`, and picking whichever comes first\n    // in the list would be a coin toss dressed up as an answer.\n    if (word.length >= 3) {\n        const prefixed = known.filter(name => name.toLowerCase().startsWith(word));\n        if (prefixed.length === 1) return prefixed[0];\n    }\n\n    const budget = word.length <= 4 ? 1 : 2;\n    let best: { name: string; distance: number } | undefined;\n\n    for (const candidate of known) {\n        const distance = editDistance(word, candidate.toLowerCase());\n        if (distance > budget) continue;\n        if (!best || distance < best.distance) best = { name: candidate, distance };\n    }\n\n    return best?.name;\n}\n\n/**\n * The family command a word names exactly, as `<family> <command>`, or nothing.\n *\n * `rebase deploy` is `rebase cloud deploy`: the word is a whole command one\n * level down. Exact only — a near miss there is a guess about both the family\n * and the command.\n */\nfunction familyCommand(typed: string, families: Readonly<Record<string, readonly string[]>>): string | undefined {\n    const word = typed.toLowerCase();\n    for (const [family, commands] of Object.entries(families)) {\n        const match = commands.find(name => name.toLowerCase() === word);\n        if (match) return `${family} ${match}`;\n    }\n    return undefined;\n}\n\n/**\n * The line itself, without printing it — so callers that must answer in JSON\n * (the cloud family, whose `fail()` writes a machine-readable envelope) use the\n * same words as the ones that print.\n *\n * `family` is empty for the top level: `rebase --help`, not `rebase  --help`.\n * `families` are the command families below this level, by name, whose\n * commands a word may be one of.\n */\nexport function unknownCommandMessage(\n    typed: string | undefined,\n    known: readonly string[],\n    family = \"\",\n    families: Readonly<Record<string, readonly string[]>> = {}\n): string {\n    const what = family ? `${family} command` : \"command\";\n    const suggestion = typed ? suggestCommand(typed, known) ?? familyCommand(typed, families) : undefined;\n    const help = family ? `rebase ${family} --help` : \"rebase --help\";\n\n    return suggestion\n        ? `Unknown ${what} \"${typed}\" — did you mean \\`${suggestion}\\`? Run \\`${help}\\` for the rest.`\n        : `Unknown ${what} \"${typed ?? \"\"}\". Run \\`${help}\\` for the ones there are.`;\n}\n\n/**\n * Print the line to stderr and exit 1.\n *\n * stderr, not stdout: a mistyped command is a failure, and the families with a\n * `--json` mode guarantee that stdout holds only their envelope.\n */\nexport function unknownCommand(\n    typed: string | undefined,\n    known: readonly string[],\n    family = \"\",\n    families: Readonly<Record<string, readonly string[]>> = {}\n): never {\n    console.error(chalk.red(`✗ ${unknownCommandMessage(typed, known, family, families)}`));\n    process.exit(1);\n}\n","/**\n * Argument parsing for the commands that take positional arguments.\n *\n * Every command in the small group used to parse its own line the same way:\n * `arg(spec, { argv: rawArgs.slice(4), permissive: true })`, then read `_[0]`\n * and `_[1]`. Both halves of that are wrong in a way that costs data.\n *\n *  - **`permissive: true` turns an unknown flag into a positional.** `arg`\n *    pushes an undeclared flag into `_` as a bare token, so `_[1]` is whatever\n *    came second on the line, flag or not. `rebase auth reset-password\n *    bob@example.com --debug` set Bob's password to the literal `--debug` — and\n *    `--debug` is what `bin/rebase.js` prints after *every* failure as the thing\n *    to re-run with, so the single most likely next keystroke after a failed\n *    reset was the one that reset the account to a two-word string.\n *  - **`slice(4)` assumes the command words are at fixed indices.** They are\n *    not: a flag before the command shifts everything, so `rebase --debug auth\n *    reset-password bob@example.com NewPass1!` read the email as\n *    `reset-password` and the password as `bob@example.com`.\n *\n * So: parse the *whole* line — `rawArgs` is `process.argv` — against a spec\n * strictly, with no permissive mode. `arg` then consumes every flag wherever it\n * appears and rejects the ones nobody declared, which leaves `_` holding the\n * command words followed by the real positionals, in order and at a known\n * offset. An unrecognised flag becomes an error naming the command's help,\n * which is the only safe answer: the alternative is guessing that it was meant\n * as a value.\n *\n * `commands/cloud/index.ts` resolves its positionals against its own spec for\n * the same reason; this is that idea for the commands whose positionals are\n * credentials rather than resource names.\n */\nimport arg from \"arg\";\n\nimport { redactConnectionPasswords } from \"./redact\";\nimport { suggestCommand } from \"./unknown-command\";\n\n/**\n * Flags accepted on top of whatever a command declares.\n *\n * `--debug` is read by `bin/rebase.js` off `process.argv` and never by a\n * command, but it has to be *declared* somewhere or strict parsing rejects the\n * exact flag the CLI tells people to add. `--help`/`-h` are answered by each\n * command's dispatcher before any work happens.\n */\nexport const GLOBAL_COMMAND_FLAGS = {\n    \"--debug\": Boolean,\n    \"--help\": Boolean,\n    \"-h\": \"--help\"\n} as const;\n\n/**\n * The declared long flag an undeclared one was probably meant to be: one edit\n * or one swap away (`--form` → `--from`), or an abbreviation of exactly one\n * (`--anon` → `--anonymize`).\n */\nfunction closestDeclaredFlag(typed: string, declared: readonly string[]): string | undefined {\n    if (!typed.startsWith(\"--\")) return undefined;\n    const near = suggestCommand(typed.slice(2), declared.filter(flag => flag.startsWith(\"--\")).map(flag => flag.slice(2)));\n    return near ? `--${near}` : undefined;\n}\n\n/** Past this many, a refusal names the help page rather than listing every flag. */\nconst LISTED_FLAGS_MAX = 8;\n\n/**\n * The sentence an undeclared flag is refused with — the one `db backup`,\n * `db restore` and `db branch` say, so one CLI answers a typo one way:\n *\n *     `rebase db pull` has no option --anonymise — did you mean --anonymize?\n *     Nothing was run. See `rebase db pull --help`.\n *\n * With nothing close it lists what the command takes, when that list is short\n * enough to read.\n *\n * Exported for the commands that refuse a flag outside `parseCommandArgs`.\n */\nexport function unknownOptionMessage(command: string, typed: string, spec: Readonly<Record<string, unknown>>): string {\n    const declared = Object.keys({ ...GLOBAL_COMMAND_FLAGS, ...spec });\n    const near = closestDeclaredFlag(typed, declared);\n    const own = Object.keys(spec).filter(flag => flag.startsWith(\"--\") && !(flag in GLOBAL_COMMAND_FLAGS));\n    const takes = near\n        ? ` — did you mean ${near}?`\n        : own.length === 0\n            ? \" — it takes no options.\"\n            : own.length <= LISTED_FLAGS_MAX ? ` — it takes ${own.join(\", \")}.` : \".\";\n\n    return `\\`rebase ${command}\\` has no option ${typed}${takes} Nothing was run. See \\`rebase ${command} --help\\`.`;\n}\n\nexport interface ParsedCommand<S extends arg.Spec> {\n    /** The declared flags, as `arg` resolved them. */\n    flags: arg.Result<S>;\n    /** What is left after the command words — never a flag. */\n    positionals: string[];\n    /** `--help` or `-h` appeared anywhere on the line. */\n    help: boolean;\n}\n\n/** Did the line ask for help? Answered before dispatch, never by a handler. */\nexport function wantsHelp(rawArgs: string[]): boolean {\n    return rawArgs.includes(\"--help\") || rawArgs.includes(\"-h\");\n}\n\n/**\n * The command line was wrong — nothing ran, and there is no stack to want.\n *\n * `bin/rebase.js` ends every failure with \"Re-run with --debug for the stack\n * trace.\", which is right when something broke inside a command and absurd for\n * a typo: the stack points at `arg` and this file, neither of which the person\n * who mistyped `--ouput` has any interest in. Worse, `--debug` is a flag, so\n * the suggested next command is *another* command line — and the one thing we\n * have just established is that the command line is what went wrong.\n *\n * Marked with a property rather than left to `instanceof`, because the reader\n * is `bin/rebase.js`: it imports the bundle, so the class object it would test\n * against is not the one this file compiled to.\n */\nexport class UsageError extends Error {\n    readonly isUsageError = true;\n\n    constructor(message: string) {\n        super(message);\n        this.name = \"UsageError\";\n    }\n}\n\n/**\n * Resolve a command's flags and positionals from the full `process.argv`.\n *\n * `commandWords` is how many words name the command itself — 2 for\n * `auth reset-password`, 1 for `start` — and is applied to the *parsed*\n * positionals rather than to `argv`, so a flag placed before the command no\n * longer shifts them.\n *\n * `command` names the command in error messages, e.g. `auth reset-password`.\n *\n * Throws on an unknown flag, on a positional that looks like a flag, and on\n * more positionals than the command takes. `bin/rebase.js` turns each into a\n * one-line `✗ …` and exit 1.\n */\nexport function parseCommandArgs<S extends arg.Spec>({\n    spec,\n    rawArgs,\n    commandWords,\n    command,\n    maxPositionals\n}: {\n    spec: S;\n    rawArgs: string[];\n    commandWords: number;\n    command: string;\n    maxPositionals?: number;\n}): ParsedCommand<S> {\n    let parsed: arg.Result<S> & { \"--help\"?: boolean };\n    try {\n        const merged = {\n            ...GLOBAL_COMMAND_FLAGS,\n            ...spec\n        };\n        parsed = arg(merged, { argv: rawArgs.slice(2) }) as arg.Result<S> & { \"--help\"?: boolean };\n    } catch (err) {\n        if (err instanceof Error && (err as arg.ArgError).code === \"ARG_UNKNOWN_OPTION\") {\n            // arg's wording: `unknown or unexpected option: --form`.\n            const typed = /option: (\\S+)$/.exec(err.message)?.[1] ?? err.message;\n            throw new UsageError(unknownOptionMessage(command, typed.split(\"=\")[0], spec));\n        }\n        throw err;\n    }\n\n    const positionals = parsed._.slice(commandWords);\n\n    for (const value of positionals) {\n        // Only reachable past a `--` separator or for a bare `-`, since anything\n        // else beginning with `-` was either declared or already rejected above.\n        // Still refused rather than accepted: a value that looks like a flag is\n        // as likely to be a typo as an argument, and one of these positions is a\n        // password.\n        if (value.startsWith(\"-\")) {\n            throw new UsageError(\n                `\\`${value}\\` looks like an option, not a value — pass it with an explicit flag ` +\n                `(\\`rebase ${command} --help\\`).`\n            );\n        }\n    }\n\n    if (maxPositionals !== undefined && positionals.length > maxPositionals) {\n        // Redacted: a connection string passed where a flag's value belongs\n        // (`rebase db pull \"$PROD\"`) is still a password.\n        throw new UsageError(\n            `rebase ${command} takes ${maxPositionals} argument${maxPositionals === 1 ? \"\" : \"s\"}, ` +\n            `got ${positionals.length}: ${redactConnectionPasswords(positionals.join(\" \"))}`\n        );\n    }\n\n    return {\n        flags: parsed,\n        positionals,\n        help: Boolean(parsed[\"--help\"])\n    };\n}\n"],"mappings":"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"}