@rebasepro/cli 0.23.0 → 0.24.1-canary.g19596ef

package/dist/commands/skills.d.ts

@@ -18,14 +18,32 @@
  * A subdirectory layout has no such problem: the rule file already sits beside
  * its own assets, so `references/x.md` resolves as written and nothing is
  * loaded until it is opened.
+ *
+ * `homeMarkers` are the directories under `~` that say the assistant is
+ * installed on this machine. They answer a different question from
+ * `detectDir`: a fresh scaffold has no `.claude/` of its own, so `rebase init`
+ * asks the machine which assistants the developer has and pre-selects those.
+ *
+ * `mcp` is where the assistant reads a *project-level* MCP server list, and in
+ * which shape — see `agent-setup.ts`. `projectDir` is what `REBASE_PROJECT_DIR`
+ * is set to: `"."` where the server is spawned in the project, the editor's own
+ * workspace variable where it may not be. `null` means there is no project
+ * file to write: Windsurf reads only a user-level config, and one entry there
+ * cannot name every project on the machine.
  */
-declare const AGENTS: {
+export declare const AGENTS: {
     readonly cursor: {
         readonly label: "Cursor";
         readonly detectDir: ".cursor";
+        readonly homeMarkers: readonly [".cursor"];
         readonly targetDir: ".cursor/rules";
         readonly flatLayout: true;
         readonly indexFile: "rebase.mdc";
+        readonly mcp: {
+            readonly file: ".cursor/mcp.json";
+            readonly format: "mcpServers";
+            readonly projectDir: "${workspaceFolder}";
+        };
         /** The body is not a rule file here — `indexFile` is. */
         readonly transformFile: (skillName: string, content: string) => {
             fileName: string;
@@ -35,8 +53,14 @@ declare const AGENTS: {
     readonly claude: {
         readonly label: "Claude Code";
         readonly detectDir: ".claude";
+        readonly homeMarkers: readonly [".claude"];
         readonly targetDir: ".claude/skills";
         readonly flatLayout: false;
+        readonly mcp: {
+            readonly file: ".mcp.json";
+            readonly format: "mcpServers";
+            readonly projectDir: ".";
+        };
         /** Claude Code uses the standard SKILL.md format in subdirectories. */
         readonly transformFile: (skillName: string, content: string) => {
             fileName: string;
@@ -46,9 +70,11 @@ declare const AGENTS: {
     readonly windsurf: {
         readonly label: "Windsurf";
         readonly detectDir: ".windsurf";
+        readonly homeMarkers: readonly [".codeium/windsurf", ".windsurf"];
         readonly targetDir: ".windsurf/rules";
         readonly flatLayout: true;
         readonly indexFile: "rebase.md";
+        readonly mcp: null;
         /** The body is not a rule file here — `indexFile` is. */
         readonly transformFile: (skillName: string, content: string) => {
             fileName: string;
@@ -58,8 +84,14 @@ declare const AGENTS: {
     readonly gemini: {
         readonly label: "Gemini CLI / Antigravity";
         readonly detectDir: ".agents";
+        readonly homeMarkers: readonly [".gemini"];
         readonly targetDir: ".agents/skills";
         readonly flatLayout: false;
+        readonly mcp: {
+            readonly file: ".gemini/settings.json";
+            readonly format: "mcpServers";
+            readonly projectDir: ".";
+        };
         /** Gemini uses the standard SKILL.md format in subdirectories. */
         readonly transformFile: (skillName: string, content: string) => {
             fileName: string;
@@ -69,9 +101,15 @@ declare const AGENTS: {
     readonly codex: {
         readonly label: "Codex CLI";
         readonly detectDir: ".codex";
-        readonly targetDir: ".codex/skills";
+        readonly homeMarkers: readonly [".codex"];
+        readonly targetDir: ".agents/skills";
         readonly flatLayout: false;
-        /** Codex reads AGENTS.md; the skills sit beside its own config. */
+        readonly mcp: {
+            readonly file: ".codex/config.toml";
+            readonly format: "codexToml";
+            readonly projectDir: ".";
+        };
+        /** Codex uses the standard SKILL.md format in subdirectories. */
         readonly transformFile: (skillName: string, content: string) => {
             fileName: string;
             content: string;
@@ -80,9 +118,15 @@ declare const AGENTS: {
     readonly kiro: {
         readonly label: "Kiro";
         readonly detectDir: ".kiro";
+        readonly homeMarkers: readonly [".kiro"];
         readonly targetDir: ".kiro/steering";
         readonly flatLayout: true;
         readonly indexFile: "rebase.md";
+        readonly mcp: {
+            readonly file: ".kiro/settings/mcp.json";
+            readonly format: "mcpServers";
+            readonly projectDir: ".";
+        };
         /** The body is not a rule file here — `indexFile` is. */
         readonly transformFile: (skillName: string, content: string) => {
             fileName: string;
@@ -92,9 +136,15 @@ declare const AGENTS: {
     readonly copilot: {
         readonly label: "GitHub Copilot";
         readonly detectDir: null;
+        readonly homeMarkers: readonly [];
         readonly targetDir: ".github/instructions";
         readonly flatLayout: true;
         readonly indexFile: "rebase.instructions.md";
+        readonly mcp: {
+            readonly file: ".vscode/mcp.json";
+            readonly format: "vscode";
+            readonly projectDir: "${workspaceFolder}";
+        };
         /** The body is not a rule file here — `indexFile` is. */
         readonly transformFile: (skillName: string, content: string) => {
             fileName: string;
@@ -102,7 +152,11 @@ declare const AGENTS: {
         };
     };
 };
-type AgentKey = keyof typeof AGENTS;
+export type AgentKey = keyof typeof AGENTS;
+/** Narrows a string to an agent name, by the table's own keys. */
+export declare function isAgentKey(value: string): value is AgentKey;
+/** Every agent, in table order. */
+export declare const AGENT_KEYS: AgentKey[];
 export interface LoadedSkill {
     name: string;
     /** Absolute path of the skill's source directory. */
@@ -113,6 +167,13 @@ export interface LoadedSkill {
 }
 /** Read all skill directories and return their names, content and assets. */
 export declare function loadSkills(skillsDir: string): LoadedSkill[];
+/**
+ * The skills this CLI ships, from its own `@rebasepro/agent-skills`.
+ *
+ * Throws rather than exiting, so `rebase init` can report a missing bundle as a
+ * warning and still finish the scaffold.
+ */
+export declare function loadBundledSkills(): LoadedSkill[];
 /**
  * The one always-on rule a flat-layout agent gets, in place of every skill.
  *
@@ -136,11 +197,57 @@ export declare function renderSkillIndex(skills: LoadedSkill[], agentKey: AgentK
  * guessing, because the wrong guess installs 21 files and reports success.
  */
 export declare function detectAgents(projectDir: string): AgentKey[];
+/** What `detectInstalledAgents` found for one assistant. */
+export interface InstalledAgent {
+    key: AgentKey;
+    label: string;
+    /** The home directory checked, as `~/…` — the one found, else the first. */
+    marker: string | null;
+    found: boolean;
+}
+/**
+ * Which assistants are installed on this machine, from their home directories.
+ *
+ * The question `rebase init` needs answered, and one `detectAgents` cannot: a
+ * project that does not exist yet has no `.claude/` in it. What the machine has
+ * is only a default — the developer confirms it — so a false positive costs an
+ * unticked box, not 21 files nobody asked for.
+ */
+export declare function detectInstalledAgents(home?: string): InstalledAgent[];
 /** Install skills for a specific agent into the project directory. */
-export declare function installForAgent(agentKey: AgentKey, skills: LoadedSkill[], projectDir: string): {
+/**
+ * The file in each target directory that records what the installer wrote:
+ * relative path → sha256 of the bytes written. A dotfile, so no agent loads it
+ * as a rule.
+ */
+export declare const SKILLS_MANIFEST = ".rebase-skills.json";
+/** What one agent's install did. */
+export interface AgentInstallResult {
     skills: number;
     assets: number;
-};
+    /** Files left as they are because they were edited since the last install (relative to the target dir). */
+    kept: string[];
+    /** Files of skills the bundle no longer ships, removed because nobody edited them. */
+    removed: string[];
+}
+export declare function installForAgent(agentKey: AgentKey, skills: LoadedSkill[], projectDir: string, options?: {
+    force?: boolean;
+}): AgentInstallResult;
+/** What `installSkills` did for one agent. */
+export interface SkillsInstallResult extends AgentInstallResult {
+    agent: AgentKey;
+    /** An earlier agent in the same run that already wrote this directory. */
+    sharedWith?: AgentKey;
+}
+/**
+ * Install for several agents, writing each target directory once.
+ *
+ * Gemini and Codex both read `.agents/skills`; installing twice would write the
+ * same 21 files twice and report two installs of one directory.
+ */
+export declare function installSkills(agents: readonly AgentKey[], skills: LoadedSkill[], projectDir: string, options?: {
+    force?: boolean;
+}): SkillsInstallResult[];
 /** Everything the switch below dispatches, for the did-you-mean. */
 export declare const SKILLS_SUBCOMMANDS: readonly ["install"];
 export declare function skillsCommand(subcommand: string | undefined, rawArgs: string[]): Promise<void>;
@@ -150,4 +257,16 @@ export declare function skillsCommand(subcommand: string | undefined, rawArgs: s
  * given.
  */
 export declare function parseAgentFlags(rawArgs: string[]): AgentKey[] | null;
-export {};
+/** `rebase skills install`'s whole line: the agents it names, `--mcp` and `--force`. */
+export declare function parseSkillsInstallLine(rawArgs: string[]): {
+    agents: AgentKey[] | null;
+    mcp: boolean;
+    force: boolean;
+};
+/**
+ * The agents a list of `--agent` values names, or null when it names none.
+ *
+ * Shared by `rebase skills install` and `rebase init`, so both accept the same
+ * spellings. Throws a UsageError on a name that is not an agent.
+ */
+export declare function resolveAgentNames(values: readonly string[]): AgentKey[] | null;

package/dist/commands/start.d.ts

@@ -1 +1,45 @@
+import type { RebaseBundleStatic } from "@rebasepro/types";
+import type { DevDatabase } from "../dev-db/resolve.js";
+/** The NODE_ENV the runtime will see, and where it comes from. */
+export interface StartNodeEnv {
+    value: string | undefined;
+    source: "shell" | ".env" | "unset";
+}
+/**
+ * What NODE_ENV the server will boot in. The shell wins — dotenv never
+ * overrides a variable that is already set — then `.env`.
+ */
+export declare function startNodeEnv(projectRoot: string): StartNodeEnv;
+/**
+ * The banner for a `rebase start` that is not a production server, or `null`.
+ *
+ * Not forced to production: the scaffold's `.env` points at a loopback
+ * database, which a production boot refuses, so forcing it would break the
+ * documented local run. What must not happen is the silence — a command the
+ * help called "(production)" booting with the first-registration window open.
+ */
+export declare function nonProductionWarning(nodeEnv: StartNodeEnv): string[] | null;
+/**
+ * What to say about the apps a bundle serves only on their own hostname.
+ *
+ * The runtime prints "Server running at http://localhost:<port>", and an app
+ * whose `path` names a hostname answers only requests carrying that `Host` —
+ * so opening the printed URL showed a 404 for an app that was running fine,
+ * and nothing said why. One line per such app, with a command that reaches it.
+ */
+export declare function hostRoutedNotice(staticApps: readonly RebaseBundleStatic[], port: string | undefined): string[];
+/**
+ * What to say when there is no DATABASE_URL for the runtime, or `null`.
+ *
+ * The runtime requires one, and its refusal — `DATABASE_URL: is required`, and
+ * a link to the self-hosting docs — is right for a deployment and says nothing
+ * to the reader most likely to see it: someone running the scaffold's own
+ * `.env`, which leaves DATABASE_URL commented out because `rebase dev` brings a
+ * database of its own. That database is one command away, so this names it.
+ *
+ * `kind` is what `rebase dev` runs this project on, so the line can say which
+ * database `rebase db url` will print. A blank value is unset, as the runtime
+ * reads it.
+ */
+export declare function missingDatabaseUrl(env: Record<string, string | undefined>, kind: DevDatabase["kind"] | null): string[] | null;
 export declare function startCommand(rawArgs?: string[]): Promise<void>;

package/dist/commands/storage.d.ts

@@ -0,0 +1,46 @@
+/** Everything the switch below dispatches, for the did-you-mean. */
+export declare const STORAGE_SUBCOMMANDS: readonly ["orphans", "move"];
+/** The flags `rebase storage orphans` takes. */
+export declare const ORPHANS_FLAGS: {
+    readonly "--source": StringConstructor;
+    readonly "--older-than": NumberConstructor;
+    readonly "--delete": BooleanConstructor;
+    readonly "--yes": BooleanConstructor;
+    readonly "-y": "--yes";
+    readonly "--json": BooleanConstructor;
+};
+/** The flags `rebase storage move` takes. */
+export declare const MOVE_FLAGS: {
+    readonly "--from": StringConstructor;
+    readonly "--to": StringConstructor;
+    readonly "--prefix": StringConstructor;
+    readonly "--delete-source": BooleanConstructor;
+    readonly "--json": BooleanConstructor;
+};
+/** One stored object, as the backend lists it. */
+interface StoredObjectEntry {
+    key: string;
+    size?: number;
+    updated?: string;
+}
+/** What `GET /admin/storage/orphans` answers. */
+export interface OrphanReport {
+    storageId: string;
+    objects: number;
+    orphans: StoredObjectEntry[];
+    recent: number;
+    scanned: string[];
+    unscanned: {
+        collection: string;
+        reason: string;
+    }[];
+}
+/** Bytes, as a person reads them. */
+export declare function formatBytes(bytes: number): string;
+/**
+ * The lines that describe an orphan scan. Exported so its tests can read them
+ * without a server.
+ */
+export declare function describeOrphanReport(report: OrphanReport, olderThanHours: number): string[];
+export declare function storageCommand(subcommand: string | undefined, rawArgs: string[]): Promise<void>;
+export {};

package/dist/commands/upgrade.d.ts

@@ -2,6 +2,7 @@ import { type ChangedPin, type OverrideFinding, type SkippedSpec, type Unreadabl
 /** Every flag `rebase upgrade` accepts. Its help page and the docs verifier read this. */
 export declare const UPGRADE_FLAGS: {
     readonly "--to": StringConstructor;
+    readonly "--allow-downgrade": BooleanConstructor;
     readonly "--drop-local-overrides": BooleanConstructor;
     readonly "--no-install": BooleanConstructor;
     readonly "--dry-run": BooleanConstructor;

package/dist/consent-ClRHmcxf.js

@@ -0,0 +1,76 @@
+import { a as setConsent, c as buildEvent, f as readConfig, o as suppressionReason } from "./telemetry-EMFRVRQi.js";
+import chalk from "chalk";
+import inquirer from "inquirer";
+//#region src/telemetry/consent.ts
+/** True when we may ask: nothing forbids it, and there is a question to ask. */
+function shouldPrompt(env = process.env, { reAskDeclined = false } = {}) {
+	if (!process.stdin.isTTY) return false;
+	const reason = suppressionReason(env);
+	if (reason === "not_asked") return true;
+	return reAskDeclined && reason === "declined";
+}
+function renderPreview(event, properties) {
+	const preview = buildEvent(event, properties, {
+		machineId: "<random uuid, generated only if you say yes>",
+		projectId: "<random uuid, per checkout>"
+	});
+	return JSON.stringify(preview, null, 2);
+}
+/**
+* Ask, record the answer, and report it.
+*
+* Never throws and never blocks a non-interactive run: `rebase init --yes` in
+* CI must behave exactly as it does today, which means not asking and not
+* sending.
+*/
+async function promptForConsent(options = {}) {
+	if (!shouldPrompt(process.env, options)) return false;
+	const askedBefore = suppressionReason(process.env) === "declined";
+	try {
+		console.log("");
+		console.log(chalk.bold("Help improve Rebase?"));
+		console.log("");
+		console.log(chalk.gray("  Rebase is self-hosted, so we only learn what works if you tell us."));
+		console.log(chalk.gray("  Anonymous: random ids, the CLI version, your OS, and which template and"));
+		console.log(chalk.gray("  package manager you used. Never project names, paths, schemas, URLs or"));
+		console.log(chalk.gray("  error messages."));
+		console.log("");
+		console.log(chalk.gray(`  Print the exact payload with ${chalk.cyan("rebase telemetry show")}; change your mind`));
+		console.log(chalk.gray(`  any time with ${chalk.cyan("rebase telemetry disable")}.`));
+		if (askedBefore) {
+			console.log("");
+			console.log(chalk.gray("  You declined before; that stands unless you change it here."));
+		}
+		console.log("");
+		const { accepted } = await inquirer.prompt([{
+			type: "confirm",
+			name: "accepted",
+			message: "Share anonymous usage data?",
+			default: false
+		}]);
+		setConsent(Boolean(accepted));
+		console.log(accepted ? chalk.green("  Thank you — sharing enabled.") : chalk.gray("  Nothing will be sent." + (options.reAskDeclined ? " You will be asked again the next time you scaffold a project." : " You will not be asked again.")));
+		console.log("");
+		return Boolean(accepted);
+	} catch {
+		return false;
+	}
+}
+/** Human-readable current state, for `rebase telemetry status`. */
+function describeState(env = process.env) {
+	const reason = suppressionReason(env);
+	const config = readConfig();
+	switch (reason) {
+		case null: return `${chalk.green("enabled")} — schema v1, machine id ${chalk.gray(config.machineId ?? "unset")}`;
+		case "not_asked": return `${chalk.yellow("not configured")} — nothing has been sent, and you have not been asked yet`;
+		case "declined": return `${chalk.gray("disabled")} — you declined${config.decidedAt ? ` on ${config.decidedAt.slice(0, 10)}` : ""}`;
+		case "do_not_track": return `${chalk.gray("disabled")} — the ${chalk.cyan("DO_NOT_TRACK")} environment variable is set`;
+		case "rebase_telemetry_disabled": return `${chalk.gray("disabled")} — the ${chalk.cyan("REBASE_TELEMETRY_DISABLED")} environment variable is set`;
+		case "ci": return `${chalk.gray("disabled")} — this looks like CI (${chalk.cyan("CI")} is set), which is never counted`;
+		case "project_opt_out": return `${chalk.gray("disabled")} — this project's ${chalk.cyan("rebase.json")} sets ${chalk.cyan("\"telemetry\": false")}`;
+	}
+}
+//#endregion
+export { promptForConsent as n, renderPreview as r, describeState as t };
+
+//# sourceMappingURL=consent-ClRHmcxf.js.map

package/dist/consent-ClRHmcxf.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"consent-ClRHmcxf.js","names":[],"sources":["../src/telemetry/consent.ts"],"sourcesContent":["import chalk from \"chalk\";\nimport inquirer from \"inquirer\";\n\nimport { buildEvent, TELEMETRY_SCHEMA_VERSION, TelemetryEventName } from \"./payload\";\nimport { readConfig } from \"./identity\";\nimport { setConsent, suppressionReason } from \"./index\";\n\n/**\n * Asking, and what the question looks like.\n *\n * ## Why the prompt comes *after* the work\n *\n * The first `rebase init` on a machine is the event most worth having, and it\n * is the one where no consent exists yet. Asking before scaffolding puts a\n * privacy negotiation in front of someone who has not yet seen the tool do\n * anything — the worst possible moment, and a reliable way to get a reflexive\n * no.\n *\n * So the question is asked once the project exists and the user has seen it\n * work. The event's data is still in memory at that point, so nothing is lost\n * by waiting, and — this is the part that matters — **nothing has been\n * transmitted or written**. Declining leaves no id, no file, no record.\n *\n * ## Why the payload is shown rather than described\n *\n * \"Anonymous usage data\" is a phrase that has been used to mean almost\n * anything. Printing the exact JSON costs four lines of output and replaces a\n * claim the user has to take on faith with something they can read. It is also\n * the same builder the sender uses, so it cannot drift into a comfortable\n * fiction.\n */\n\n/** Where the question is being asked from, which decides how often it may be. */\nexport interface PromptOptions {\n    /**\n     * Ask again even though this machine already declined.\n     *\n     * Set by `rebase init`, and only there. Scaffolding a project is a\n     * deliberate, occasional act with a natural pause in it — not something\n     * anyone does in a loop — so asking each time is an offer rather than\n     * nagging, and it reaches the person whose first answer was a reflex before\n     * they had seen the tool do anything.\n     *\n     * It does **not** re-ask someone who accepted: they are already sharing, so\n     * the only thing another prompt could do is talk them out of it.\n     *\n     * Nothing else changes. `DO_NOT_TRACK`, `REBASE_TELEMETRY_DISABLED`, `CI`\n     * and a project's `\"telemetry\": false` are answers, not questions, and they\n     * still suppress the prompt entirely — a re-ask that could override a\n     * committed repository policy would be exactly the consent-by-proxy the\n     * policy exists to prevent.\n     */\n    reAskDeclined?: boolean;\n}\n\n/** True when we may ask: nothing forbids it, and there is a question to ask. */\nexport function shouldPrompt(\n    env: NodeJS.ProcessEnv = process.env,\n    { reAskDeclined = false }: PromptOptions = {}\n): boolean {\n    if (!process.stdin.isTTY) return false;\n\n    const reason = suppressionReason(env);\n    // `not_asked` is the only reason that is a question rather than an answer.\n    // A user who set DO_NOT_TRACK, or is on CI, has already told us — and so\n    // has one who is already sharing (`null`), whom we never re-ask.\n    if (reason === \"not_asked\") return true;\n    return reAskDeclined && reason === \"declined\";\n}\n\nexport function renderPreview(event: TelemetryEventName, properties: Record<string, unknown>): string {\n    const preview = buildEvent(event, properties, {\n        machineId: \"<random uuid, generated only if you say yes>\",\n        projectId: \"<random uuid, per checkout>\"\n    });\n    return JSON.stringify(preview, null, 2);\n}\n\n/**\n * Ask, record the answer, and report it.\n *\n * Never throws and never blocks a non-interactive run: `rebase init --yes` in\n * CI must behave exactly as it does today, which means not asking and not\n * sending.\n */\nexport async function promptForConsent(options: PromptOptions = {}): Promise<boolean> {\n    if (!shouldPrompt(process.env, options)) return false;\n\n    // Only true when this is a second (or later) asking, which the closing line\n    // needs to know: \"you will not be asked again\" is false at `init`.\n    const askedBefore = suppressionReason(process.env) === \"declined\";\n\n    try {\n        console.log(\"\");\n        console.log(chalk.bold(\"Help improve Rebase?\"));\n        console.log(\"\");\n        console.log(chalk.gray(\"  Rebase is self-hosted, so we only learn what works if you tell us.\"));\n        console.log(chalk.gray(\"  Anonymous: random ids, the CLI version, your OS, and which template and\"));\n        console.log(chalk.gray(\"  package manager you used. Never project names, paths, schemas, URLs or\"));\n        console.log(chalk.gray(\"  error messages.\"));\n        console.log(\"\");\n        console.log(chalk.gray(`  Print the exact payload with ${chalk.cyan(\"rebase telemetry show\")}; change your mind`));\n        console.log(chalk.gray(`  any time with ${chalk.cyan(\"rebase telemetry disable\")}.`));\n        if (askedBefore) {\n            console.log(\"\");\n            console.log(chalk.gray(\"  You declined before; that stands unless you change it here.\"));\n        }\n        console.log(\"\");\n\n        const { accepted } = await inquirer.prompt([\n            {\n                type: \"confirm\",\n                name: \"accepted\",\n                message: \"Share anonymous usage data?\",\n                // Defaults to no. Telemetry is off until somebody says yes, and\n                // a bare Enter is the commonest answer to any prompt — so a\n                // pre-selected yes would make pressing through `init` the\n                // consent. `y` is one keystroke, and `rebase telemetry enable`\n                // is the same answer later.\n                default: false\n            }\n        ] as Parameters<typeof inquirer.prompt>[0]) as { accepted: boolean };\n\n        setConsent(Boolean(accepted));\n\n        console.log(\n            accepted\n                ? chalk.green(\"  Thank you — sharing enabled.\")\n                : chalk.gray(\n                    \"  Nothing will be sent.\"\n                    + (options.reAskDeclined\n                        ? \" You will be asked again the next time you scaffold a project.\"\n                        : \" You will not be asked again.\")\n                )\n        );\n        console.log(\"\");\n        return Boolean(accepted);\n    } catch {\n        // A prompt that fails (piped stdin, a terminal that went away) is a\n        // decline, and specifically a decline we do not persist — the user\n        // never actually saw the question, so they should still get to answer\n        // it another day.\n        return false;\n    }\n}\n\n/** Human-readable current state, for `rebase telemetry status`. */\nexport function describeState(env: NodeJS.ProcessEnv = process.env): string {\n    const reason = suppressionReason(env);\n    const config = readConfig();\n    switch (reason) {\n        case null:\n            return `${chalk.green(\"enabled\")} — schema v${TELEMETRY_SCHEMA_VERSION}, machine id ${chalk.gray(config.machineId ?? \"unset\")}`;\n        case \"not_asked\":\n            return `${chalk.yellow(\"not configured\")} — nothing has been sent, and you have not been asked yet`;\n        case \"declined\":\n            return `${chalk.gray(\"disabled\")} — you declined${config.decidedAt ? ` on ${config.decidedAt.slice(0, 10)}` : \"\"}`;\n        case \"do_not_track\":\n            return `${chalk.gray(\"disabled\")} — the ${chalk.cyan(\"DO_NOT_TRACK\")} environment variable is set`;\n        case \"rebase_telemetry_disabled\":\n            return `${chalk.gray(\"disabled\")} — the ${chalk.cyan(\"REBASE_TELEMETRY_DISABLED\")} environment variable is set`;\n        case \"ci\":\n            return `${chalk.gray(\"disabled\")} — this looks like CI (${chalk.cyan(\"CI\")} is set), which is never counted`;\n        case \"project_opt_out\":\n            return `${chalk.gray(\"disabled\")} — this project's ${chalk.cyan(\"rebase.json\")} sets ${chalk.cyan('\"telemetry\": false')}`;\n    }\n}\n"],"mappings":";;;;;AAwDA,SAAgB,aACZ,MAAyB,QAAQ,KACjC,EAAE,gBAAgB,UAAyB,CAAC,GACrC;CACP,IAAI,CAAC,QAAQ,MAAM,OAAO,OAAO;CAEjC,MAAM,SAAS,kBAAkB,GAAG;CAIpC,IAAI,WAAW,aAAa,OAAO;CACnC,OAAO,iBAAiB,WAAW;AACvC;AAEA,SAAgB,cAAc,OAA2B,YAA6C;CAClG,MAAM,UAAU,WAAW,OAAO,YAAY;EAC1C,WAAW;EACX,WAAW;CACf,CAAC;CACD,OAAO,KAAK,UAAU,SAAS,MAAM,CAAC;AAC1C;;;;;;;;AASA,eAAsB,iBAAiB,UAAyB,CAAC,GAAqB;CAClF,IAAI,CAAC,aAAa,QAAQ,KAAK,OAAO,GAAG,OAAO;CAIhD,MAAM,cAAc,kBAAkB,QAAQ,GAAG,MAAM;CAEvD,IAAI;EACA,QAAQ,IAAI,EAAE;EACd,QAAQ,IAAI,MAAM,KAAK,sBAAsB,CAAC;EAC9C,QAAQ,IAAI,EAAE;EACd,QAAQ,IAAI,MAAM,KAAK,sEAAsE,CAAC;EAC9F,QAAQ,IAAI,MAAM,KAAK,2EAA2E,CAAC;EACnG,QAAQ,IAAI,MAAM,KAAK,0EAA0E,CAAC;EAClG,QAAQ,IAAI,MAAM,KAAK,mBAAmB,CAAC;EAC3C,QAAQ,IAAI,EAAE;EACd,QAAQ,IAAI,MAAM,KAAK,kCAAkC,MAAM,KAAK,uBAAuB,EAAE,mBAAmB,CAAC;EACjH,QAAQ,IAAI,MAAM,KAAK,mBAAmB,MAAM,KAAK,0BAA0B,EAAE,EAAE,CAAC;EACpF,IAAI,aAAa;GACb,QAAQ,IAAI,EAAE;GACd,QAAQ,IAAI,MAAM,KAAK,+DAA+D,CAAC;EAC3F;EACA,QAAQ,IAAI,EAAE;EAEd,MAAM,EAAE,aAAa,MAAM,SAAS,OAAO,CACvC;GACI,MAAM;GACN,MAAM;GACN,SAAS;GAMT,SAAS;EACb,CACJ,CAA0C;EAE1C,WAAW,QAAQ,QAAQ,CAAC;EAE5B,QAAQ,IACJ,WACM,MAAM,MAAM,gCAAgC,IAC5C,MAAM,KACJ,6BACG,QAAQ,gBACL,mEACA,gCACV,CACR;EACA,QAAQ,IAAI,EAAE;EACd,OAAO,QAAQ,QAAQ;CAC3B,QAAQ;EAKJ,OAAO;CACX;AACJ;;AAGA,SAAgB,cAAc,MAAyB,QAAQ,KAAa;CACxE,MAAM,SAAS,kBAAkB,GAAG;CACpC,MAAM,SAAS,WAAW;CAC1B,QAAQ,QAAR;EACI,KAAK,MACD,OAAO,GAAG,MAAM,MAAM,SAAS,EAAE,2BAAqD,MAAM,KAAK,OAAO,aAAa,OAAO;EAChI,KAAK,aACD,OAAO,GAAG,MAAM,OAAO,gBAAgB,EAAE;EAC7C,KAAK,YACD,OAAO,GAAG,MAAM,KAAK,UAAU,EAAE,iBAAiB,OAAO,YAAY,OAAO,OAAO,UAAU,MAAM,GAAG,EAAE,MAAM;EAClH,KAAK,gBACD,OAAO,GAAG,MAAM,KAAK,UAAU,EAAE,SAAS,MAAM,KAAK,cAAc,EAAE;EACzE,KAAK,6BACD,OAAO,GAAG,MAAM,KAAK,UAAU,EAAE,SAAS,MAAM,KAAK,2BAA2B,EAAE;EACtF,KAAK,MACD,OAAO,GAAG,MAAM,KAAK,UAAU,EAAE,yBAAyB,MAAM,KAAK,IAAI,EAAE;EAC/E,KAAK,mBACD,OAAO,GAAG,MAAM,KAAK,UAAU,EAAE,oBAAoB,MAAM,KAAK,aAAa,EAAE,QAAQ,MAAM,KAAK,sBAAoB;CAC9H;AACJ"}

package/dist/console-D6SJf8k_.js

@@ -0,0 +1,102 @@
+import { n as parseCommandArgs, r as wantsHelp } from "./args-BnmsEXvu.js";
+import { r as refuseMissingCollectionsPath, t as COLLECTIONS_FLAG_HELP } from "./path-flags-BFgG9V6y.js";
+import { managedNotices, prepareDatabaseEnv } from "./prepare-CDN6lSpz.js";
+import { absolutizeLocalPathArgs, ensureDockerDatabase, n as argsFromCommand, resolveDriverCli, spawnDriverCli, t as reportSpawnFailure } from "./db-B7RuNuaQ.js";
+import chalk from "chalk";
+import path from "path";
+//#region src/commands/console.ts
+/**
+* CLI command: rebase console
+*
+* A Node REPL with the project open — `rebase` (what `openRebase` from
+* `@rebasepro/server-postgres` returns: `dataAsAdmin`, `sql`, `withAuth`) and
+* `collections` in scope — or, with `--eval`, one piece of code run and its
+* result printed as JSON.
+*
+* Resolved like `rebase db push`: the same project and `.env`, the same
+* database (the managed one started if that is what the project uses), the
+* same `--collections` loader — the driver's, spawned in `backend/`. Opening
+* the database changes nothing in it.
+*/
+var CONSOLE_FLAGS = {
+	"--eval": String,
+	"-e": "--eval",
+	"--collections": String,
+	"-c": "--collections",
+	"--database-url": String,
+	"--docker": Boolean
+};
+/** What each long flag above does, for the Options block. */
+var CONSOLE_FLAG_HELP = {
+	"--eval": "Run this code instead of the REPL, print its awaited result as JSON, and exit 1 if it throws",
+	"--collections": COLLECTIONS_FLAG_HELP,
+	"--database-url": "Open this database instead of the project's",
+	"--docker": "Use the database from docker compose, starting it if needed"
+};
+/** Where the REPL keeps its history: the project's own `.rebase/`, which the scaffold ignores. */
+function consoleHistoryPath(projectRoot) {
+	return path.join(projectRoot, ".rebase", "console_history");
+}
+function flagLabel(flag) {
+	return [flag, ...Object.entries(CONSOLE_FLAGS).filter(([, target]) => target === flag).map(([alias]) => alias)].join(", ");
+}
+function printConsoleHelp() {
+	console.log(`
+${chalk.bold("rebase console")} — Explore the project's data from a REPL
+
+${chalk.green.bold("Usage")}
+  rebase console [options]
+
+${chalk.green.bold("Options")}
+${Object.keys(CONSOLE_FLAG_HELP).map((flag) => `  ${chalk.blue(flagLabel(flag).padEnd(22))} ${CONSOLE_FLAG_HELP[flag]}`).join("\n")}
+
+In scope:
+  rebase        dataAsAdmin, sql(query, { params }), withAuth(user) → { data }, close()
+  collections   the project's collections
+
+Top-level await works. Opening the database changes nothing in it: no table,
+role or trigger is created. withAuth runs as the user under row-level security.
+
+${chalk.green.bold("Examples")}
+  rebase console
+  rebase console -e "rebase.dataAsAdmin.posts.find({ limit: 5 })"
+  rebase console -e "(await rebase.withAuth({ uid: 'u1', roles: ['user'] })).data.posts.find()"
+  rebase console -e "rebase.sql('select count(*) from posts')"
+`);
+}
+async function consoleCommand(rawArgs) {
+	if (wantsHelp(rawArgs)) {
+		printConsoleHelp();
+		return;
+	}
+	const { flags } = parseCommandArgs({
+		spec: CONSOLE_FLAGS,
+		rawArgs,
+		commandWords: 1,
+		command: "console",
+		maxPositionals: 0
+	});
+	const resolved = await resolveDriverCli();
+	const { projectRoot, backendDir } = resolved;
+	refuseMissingCollectionsPath(rawArgs, process.cwd(), backendDir, "console");
+	await ensureDockerDatabase(projectRoot, rawArgs);
+	const say = flags["--eval"] === void 0 ? (line) => console.log(chalk.gray(`  ${line}`)) : (line) => console.error(chalk.gray(`  ${line}`));
+	const prepared = await prepareDatabaseEnv(projectRoot, {
+		flagUrl: flags["--database-url"] ?? null,
+		flagDocker: flags["--docker"] === true,
+		onProgress: say
+	});
+	Object.assign(resolved.env, prepared.env);
+	for (const line of managedNotices(prepared)) say(line);
+	const childArgs = [...absolutizeLocalPathArgs(argsFromCommand(rawArgs, "console"), process.cwd()), `--history=${consoleHistoryPath(projectRoot)}`];
+	try {
+		await spawnDriverCli(resolved, childArgs);
+	} catch (error) {
+		reportSpawnFailure(error);
+		process.exit(1);
+	}
+}
+//#endregion
+export { consoleCommand };
+
+//# sourceMappingURL=console-D6SJf8k_.js.map

package/dist/console-D6SJf8k_.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"console-D6SJf8k_.js","names":[],"sources":["../src/commands/console.ts"],"sourcesContent":["/**\n * CLI command: rebase console\n *\n * A Node REPL with the project open — `rebase` (what `openRebase` from\n * `@rebasepro/server-postgres` returns: `dataAsAdmin`, `sql`, `withAuth`) and\n * `collections` in scope — or, with `--eval`, one piece of code run and its\n * result printed as JSON.\n *\n * Resolved like `rebase db push`: the same project and `.env`, the same\n * database (the managed one started if that is what the project uses), the\n * same `--collections` loader — the driver's, spawned in `backend/`. Opening\n * the database changes nothing in it.\n */\nimport chalk from \"chalk\";\nimport path from \"path\";\nimport { parseCommandArgs, wantsHelp } from \"../utils/args\";\nimport { argsFromCommand } from \"../utils/command-words\";\nimport { COLLECTIONS_FLAG_HELP, refuseMissingCollectionsPath } from \"../utils/path-flags\";\nimport { reportSpawnFailure } from \"../utils/spawn-error\";\nimport { managedNotices, prepareDatabaseEnv } from \"../dev-db/prepare\";\nimport { absolutizeLocalPathArgs, ensureDockerDatabase, resolveDriverCli, spawnDriverCli } from \"./db\";\n\nexport const CONSOLE_FLAGS = {\n    \"--eval\": String,\n    \"-e\": \"--eval\",\n    \"--collections\": String,\n    \"-c\": \"--collections\",\n    \"--database-url\": String,\n    \"--docker\": Boolean\n} as const;\n\n/** What each long flag above does, for the Options block. */\nconst CONSOLE_FLAG_HELP: Record<string, string> = {\n    \"--eval\": \"Run this code instead of the REPL, print its awaited result as JSON, and exit 1 if it throws\",\n    \"--collections\": COLLECTIONS_FLAG_HELP,\n    \"--database-url\": \"Open this database instead of the project's\",\n    \"--docker\": \"Use the database from docker compose, starting it if needed\"\n};\n\n/** Where the REPL keeps its history: the project's own `.rebase/`, which the scaffold ignores. */\nexport function consoleHistoryPath(projectRoot: string): string {\n    return path.join(projectRoot, \".rebase\", \"console_history\");\n}\n\nfunction flagLabel(flag: string): string {\n    const aliases = Object.entries(CONSOLE_FLAGS)\n        .filter(([, target]) => target === flag)\n        .map(([alias]) => alias);\n    return [flag, ...aliases].join(\", \");\n}\n\nexport function printConsoleHelp(): void {\n    console.log(`\n${chalk.bold(\"rebase console\")} — Explore the project's data from a REPL\n\n${chalk.green.bold(\"Usage\")}\n  rebase console [options]\n\n${chalk.green.bold(\"Options\")}\n${Object.keys(CONSOLE_FLAG_HELP)\n        .map(flag => `  ${chalk.blue(flagLabel(flag).padEnd(22))} ${CONSOLE_FLAG_HELP[flag]}`)\n        .join(\"\\n\")}\n\nIn scope:\n  rebase        dataAsAdmin, sql(query, { params }), withAuth(user) → { data }, close()\n  collections   the project's collections\n\nTop-level await works. Opening the database changes nothing in it: no table,\nrole or trigger is created. withAuth runs as the user under row-level security.\n\n${chalk.green.bold(\"Examples\")}\n  rebase console\n  rebase console -e \"rebase.dataAsAdmin.posts.find({ limit: 5 })\"\n  rebase console -e \"(await rebase.withAuth({ uid: 'u1', roles: ['user'] })).data.posts.find()\"\n  rebase console -e \"rebase.sql('select count(*) from posts')\"\n`);\n}\n\nexport async function consoleCommand(rawArgs: string[]): Promise<void> {\n    if (wantsHelp(rawArgs)) {\n        printConsoleHelp();\n        return;\n    }\n\n    // Strictly, before the line is relayed: the driver would otherwise be the\n    // first to see a mistyped flag, after a database had been started for it.\n    const { flags } = parseCommandArgs({\n        spec: CONSOLE_FLAGS,\n        rawArgs,\n        commandWords: 1,\n        command: \"console\",\n        maxPositionals: 0\n    });\n\n    const resolved = await resolveDriverCli();\n    const { projectRoot, backendDir } = resolved;\n    refuseMissingCollectionsPath(rawArgs, process.cwd(), backendDir, \"console\");\n    await ensureDockerDatabase(projectRoot, rawArgs);\n\n    // With --eval, stdout is the result and nothing else, so it can be piped\n    // into `jq`; what the database resolution has to say goes to stderr.\n    const say = flags[\"--eval\"] === undefined\n        ? (line: string) => console.log(chalk.gray(`  ${line}`))\n        : (line: string) => console.error(chalk.gray(`  ${line}`));\n    const prepared = await prepareDatabaseEnv(projectRoot, {\n        flagUrl: flags[\"--database-url\"] ?? null,\n        flagDocker: flags[\"--docker\"] === true,\n        onProgress: say\n    });\n    Object.assign(resolved.env, prepared.env);\n    for (const line of managedNotices(prepared)) say(line);\n\n    const childArgs = [\n        ...absolutizeLocalPathArgs(argsFromCommand(rawArgs, \"console\"), process.cwd()),\n        `--history=${consoleHistoryPath(projectRoot)}`\n    ];\n\n    try {\n        await spawnDriverCli(resolved, childArgs);\n    } catch (error) {\n        // A child that exited non-zero has already said why, on the terminal it\n        // shares — an `--eval` that threw, a database that refused.\n        reportSpawnFailure(error);\n        process.exit(1);\n    }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAsBA,IAAa,gBAAgB;CACzB,UAAU;CACV,MAAM;CACN,iBAAiB;CACjB,MAAM;CACN,kBAAkB;CAClB,YAAY;AAChB;;AAGA,IAAM,oBAA4C;CAC9C,UAAU;CACV,iBAAiB;CACjB,kBAAkB;CAClB,YAAY;AAChB;;AAGA,SAAgB,mBAAmB,aAA6B;CAC5D,OAAO,KAAK,KAAK,aAAa,WAAW,iBAAiB;AAC9D;AAEA,SAAS,UAAU,MAAsB;CAIrC,OAAO,CAAC,MAAM,GAHE,OAAO,QAAQ,aAAa,CAAC,CACxC,QAAQ,GAAG,YAAY,WAAW,IAAI,CAAC,CACvC,KAAK,CAAC,WAAW,KACL,CAAO,CAAC,CAAC,KAAK,IAAI;AACvC;AAEA,SAAgB,mBAAyB;CACrC,QAAQ,IAAI;EACd,MAAM,KAAK,gBAAgB,EAAE;;EAE7B,MAAM,MAAM,KAAK,OAAO,EAAE;;;EAG1B,MAAM,MAAM,KAAK,SAAS,EAAE;EAC5B,OAAO,KAAK,iBAAiB,CAAC,CACvB,KAAI,SAAQ,KAAK,MAAM,KAAK,UAAU,IAAI,CAAC,CAAC,OAAO,EAAE,CAAC,EAAE,GAAG,kBAAkB,OAAO,CAAC,CACrF,KAAK,IAAI,EAAE;;;;;;;;;EASlB,MAAM,MAAM,KAAK,UAAU,EAAE;;;;;CAK9B;AACD;AAEA,eAAsB,eAAe,SAAkC;CACnE,IAAI,UAAU,OAAO,GAAG;EACpB,iBAAiB;EACjB;CACJ;CAIA,MAAM,EAAE,UAAU,iBAAiB;EAC/B,MAAM;EACN;EACA,cAAc;EACd,SAAS;EACT,gBAAgB;CACpB,CAAC;CAED,MAAM,WAAW,MAAM,iBAAiB;CACxC,MAAM,EAAE,aAAa,eAAe;CACpC,6BAA6B,SAAS,QAAQ,IAAI,GAAG,YAAY,SAAS;CAC1E,MAAM,qBAAqB,aAAa,OAAO;CAI/C,MAAM,MAAM,MAAM,cAAc,KAAA,KACzB,SAAiB,QAAQ,IAAI,MAAM,KAAK,KAAK,MAAM,CAAC,KACpD,SAAiB,QAAQ,MAAM,MAAM,KAAK,KAAK,MAAM,CAAC;CAC7D,MAAM,WAAW,MAAM,mBAAmB,aAAa;EACnD,SAAS,MAAM,qBAAqB;EACpC,YAAY,MAAM,gBAAgB;EAClC,YAAY;CAChB,CAAC;CACD,OAAO,OAAO,SAAS,KAAK,SAAS,GAAG;CACxC,KAAK,MAAM,QAAQ,eAAe,QAAQ,GAAG,IAAI,IAAI;CAErD,MAAM,YAAY,CACd,GAAG,wBAAwB,gBAAgB,SAAS,SAAS,GAAG,QAAQ,IAAI,CAAC,GAC7E,aAAa,mBAAmB,WAAW,GAC/C;CAEA,IAAI;EACA,MAAM,eAAe,UAAU,SAAS;CAC5C,SAAS,OAAO;EAGZ,mBAAmB,KAAK;EACxB,QAAQ,KAAK,CAAC;CAClB;AACJ"}