@rebasepro/cli 0.19.2-canary.g98b88fd → 0.19.2-canary.gef769df

package/dist/index.es.js

@@ -1474,12 +1474,33 @@ async function recordEvent(event, properties = {}, options = {}) {
 }
 //#endregion
 //#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";
+/**
+* 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);
 }
 function renderPreview(event, properties) {
 	const preview = buildEvent(event, properties, {
@@ -1495,9 +1516,8 @@ function renderPreview(event, properties) {
 * CI must behave exactly as it does today, which means not asking and not
 * sending.
 */
-async function promptForConsent(event, properties, options = {}) {
-	if (!shouldPrompt(process.env, options)) return false;
-	const askedBefore = suppressionReason(process.env) === "declined";
+async function promptForConsent(event, properties) {
+	if (!shouldPrompt()) return false;
 	try {
 		console.log("");
 		console.log(chalk.bold("Help improve Rebase?"));
@@ -1511,11 +1531,6 @@ async function promptForConsent(event, properties, options = {}) {
 		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",
@@ -1524,7 +1539,7 @@ async function promptForConsent(event, properties, options = {}) {
 			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(accepted ? chalk.green("  Thank you — sharing enabled.") : chalk.gray("  Nothing will be sent. You will not be asked again."));
 		console.log("");
 		return Boolean(accepted);
 	} catch {
@@ -1638,7 +1653,7 @@ function buildInitQuestions(params) {
 		type: "input",
 		name: "projectName",
 		message: "Project name:",
-		default: "my-app",
+		default: "my-rebase-app",
 		validate: (input) => validateProjectName(input) ?? true
 	});
 	if (headlessArg === void 0) questions.push({
@@ -1706,7 +1721,7 @@ ${chalk.bold("Usage")}
   rebase init ${chalk.blue("[name]")} [options]
 
   ${chalk.gray("The name may be a nested path (apps/my-app) or \".\" for the current directory.")}
-  ${chalk.gray("Asks when omitted; defaults to \"my-app\", and takes it without asking under --yes.")}
+  ${chalk.gray("Defaults to \"my-rebase-app\" when omitted with --yes.")}
 
 ${chalk.bold("Options")}
   ${chalk.blue("-t, --template")} ${chalk.gray("<preset>")}   blog | ecommerce | blank ${chalk.gray("(default: blog)")}
@@ -1788,7 +1803,7 @@ async function promptForOptions(rawArgs, pm) {
 	const installFlag = noInstall ? false : args["--install"] ?? false;
 	const hasInstallFlag = noInstall || args["--install"] === true;
 	if (isNonInteractive) {
-		const projectName = nameArg || "my-app";
+		const projectName = nameArg || "my-rebase-app";
 		const targetDirectory = path.resolve(process.cwd(), projectName);
 		const templateDirectory = path.resolve(cliRoot, "templates", "template");
 		const pmCommands = getPMCommands(pm);
@@ -2124,7 +2139,7 @@ async function createProject$1(options) {
 		git: Boolean(options.git),
 		duration: durationBucket(Date.now() - startedAt)
 	};
-	if (await promptForConsent("cli.init", initProperties, { reAskDeclined: true })) await recordEvent("cli.init", initProperties, { projectRoot: options.targetDirectory });
+	if (await promptForConsent("cli.init", initProperties)) await recordEvent("cli.init", initProperties, { projectRoot: options.targetDirectory });
 }
 /**
 * Apply a template preset by replacing the default collection files.
@@ -15159,31 +15174,7 @@ 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);
@@ -15267,13 +15258,6 @@ async function deployCommand(rawArgs, projectRef) {
 			following: false,
 			...warningPayload(warnings)
 		});
-		await recordDeploy({
-			followed: false,
-			status: "not_followed",
-			deduplicated,
-			frameworkVersion,
-			startedAt
-		});
 		return;
 	}
 	if (!isJsonMode()) {
@@ -15286,13 +15270,6 @@ async function deployCommand(rawArgs, projectRef) {
 		projectId,
 		url
 	});
-	await recordDeploy({
-		followed: true,
-		status,
-		deduplicated,
-		frameworkVersion,
-		startedAt
-	});
 	emit(() => {}, {
 		deploymentId,
 		deduplicated,
@@ -19102,24 +19079,6 @@ 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");