@rebasepro/cli 0.19.2-canary.g9b599d4 → 0.20.0

package/dist/index.es.js

@@ -1474,33 +1474,12 @@ async function recordEvent(event, properties = {}, options = {}) {
 }
 //#endregion
 //#region src/telemetry/consent.ts
-/**
-* Asking, and what the question looks like.
-*
-* ## Why the prompt comes *after* the work
-*
-* The first `rebase init` on a machine is the event most worth having, and it
-* is the one where no consent exists yet. Asking before scaffolding puts a
-* privacy negotiation in front of someone who has not yet seen the tool do
-* anything — the worst possible moment, and a reliable way to get a reflexive
-* no.
-*
-* So the question is asked once the project exists and the user has seen it
-* work. The event's data is still in memory at that point, so nothing is lost
-* by waiting, and — this is the part that matters — **nothing has been
-* transmitted or written**. Declining leaves no id, no file, no record.
-*
-* ## Why the payload is shown rather than described
-*
-* "Anonymous usage data" is a phrase that has been used to mean almost
-* anything. Printing the exact JSON costs four lines of output and replaces a
-* claim the user has to take on faith with something they can read. It is also
-* the same builder the sender uses, so it cannot drift into a comfortable
-* fiction.
-*/
-/** True when we may ask: no decision recorded, and nothing else forbids it. */
-function shouldPrompt(env = process.env) {
-	return suppressionReason(env) === "not_asked" && Boolean(process.stdin.isTTY);
+/** 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, {
@@ -1516,8 +1495,9 @@ function renderPreview(event, properties) {
 * CI must behave exactly as it does today, which means not asking and not
 * sending.
 */
-async function promptForConsent(event, properties) {
-	if (!shouldPrompt()) return false;
+async function promptForConsent(event, properties, options = {}) {
+	if (!shouldPrompt(process.env, options)) return false;
+	const askedBefore = suppressionReason(process.env) === "declined";
 	try {
 		console.log("");
 		console.log(chalk.bold("Help improve Rebase?"));
@@ -1531,6 +1511,11 @@ async function promptForConsent(event, properties) {
 		console.log("");
 		console.log(chalk.gray("  No project names, paths, schemas, URLs or error messages. Change your"));
 		console.log(chalk.gray(`  mind any time with ${chalk.cyan("rebase telemetry disable")}.`));
+		if (askedBefore) {
+			console.log("");
+			console.log(chalk.gray("  You declined before, and that is still the answer unless you change it"));
+			console.log(chalk.gray("  here. Asked once per new project; never during ordinary work."));
+		}
 		console.log("");
 		const { accepted } = await inquirer.prompt([{
 			type: "confirm",
@@ -1539,7 +1524,7 @@ async function promptForConsent(event, properties) {
 			default: false
 		}]);
 		setConsent(Boolean(accepted));
-		console.log(accepted ? chalk.green("  Thank you — sharing enabled.") : chalk.gray("  Nothing will be sent. You will not be asked again."));
+		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 {
@@ -2139,7 +2124,7 @@ async function createProject$1(options) {
 		git: Boolean(options.git),
 		duration: durationBucket(Date.now() - startedAt)
 	};
-	if (await promptForConsent("cli.init", initProperties)) await recordEvent("cli.init", initProperties, { projectRoot: options.targetDirectory });
+	if (await promptForConsent("cli.init", initProperties, { reAskDeclined: true })) await recordEvent("cli.init", initProperties, { projectRoot: options.targetDirectory });
 }
 /**
 * Apply a template preset by replacing the default collection files.
@@ -15174,7 +15159,31 @@ function resolveDeployArgs(rawArgs) {
 		appName: positionals[0]
 	};
 }
+/**
+* `cli.deploy` — the event that says whether anyone ever ships.
+*
+* Declared in `TelemetryEventName` from the start and recorded nowhere, so a
+* consenting user reported scaffolding, dev servers and schema pushes and never
+* the one act the product exists for.
+*
+* What it carries is deliberately thin. No project id, no app name, no
+* deployment id, no URL: those are the "project names" and "URLs" the consent
+* screen promises are never sent, and a deployment id is a durable handle on
+* somebody's infrastructure. `frameworkVersion` is *our* version, not the
+* user's data, and it is the one field that makes the rest legible — a failure
+* rate means nothing without knowing which release it is a rate for.
+*/
+async function recordDeploy(o) {
+	await recordEvent("cli.deploy", {
+		followed: o.followed,
+		status: o.status,
+		deduplicated: o.deduplicated,
+		framework_version: o.frameworkVersion ?? null,
+		duration: durationBucket(Date.now() - o.startedAt)
+	}, { projectRoot: process.cwd() });
+}
 async function deployCommand(rawArgs, projectRef) {
+	const startedAt = Date.now();
 	const { flags: args, appName } = resolveDeployArgs(rawArgs);
 	if (args["--wait"] && args["--no-follow"]) fail("--wait and --no-follow ask for opposite things.", "`deploy` follows by default — pass neither, or `--no-follow` to return as soon as the build is triggered.", "usage");
 	const { client, url } = await requireClient(rawArgs);
@@ -15258,6 +15267,13 @@ async function deployCommand(rawArgs, projectRef) {
 			following: false,
 			...warningPayload(warnings)
 		});
+		await recordDeploy({
+			followed: false,
+			status: "not_followed",
+			deduplicated,
+			frameworkVersion,
+			startedAt
+		});
 		return;
 	}
 	if (!isJsonMode()) {
@@ -15270,6 +15286,13 @@ async function deployCommand(rawArgs, projectRef) {
 		projectId,
 		url
 	});
+	await recordDeploy({
+		followed: true,
+		status,
+		deduplicated,
+		frameworkVersion,
+		startedAt
+	});
 	emit(() => {}, {
 		deploymentId,
 		deduplicated,
@@ -19079,6 +19102,24 @@ async function entry(args) {
 		return;
 	}
 	const effectiveSubcommand = parsedArgs["--help"] && !subcommand ? "--help" : subcommand;
+	try {
+		await dispatch(command, effectiveSubcommand, args, parsedArgs, namespacedCommands);
+	} catch (error) {
+		await recordEvent("cli.error", {
+			command: command ?? "none",
+			subcommand: effectiveSubcommand ?? "none",
+			error_type: error instanceof Error ? error.constructor.name : "unknown",
+			usage: Boolean(error && typeof error === "object" && error.isUsageError)
+		}, { projectRoot: process.cwd() });
+		throw error;
+	}
+}
+/**
+* The dispatch, lifted out of {@link entry} so the whole of it sits inside one
+* `try`. Inlining the switch there would have put the `catch` around the flag
+* parsing too, which throws its own usage errors before a command is even named.
+*/
+async function dispatch(command, effectiveSubcommand, args, parsedArgs, namespacedCommands) {
 	switch (command) {
 		case "__dev-db-daemon": {
 			const { parseDaemonArgs, runDaemon } = await import("./daemon-entry-LTFKtpHy.js");