@rebasepro/cli 0.19.2-canary.gef769df → 0.20.1-canary.g4d882ca

package/dist/bundle.d.ts

@@ -398,6 +398,8 @@ export declare function foldStaticIntoBundle(options: {
     path: string;
     /** Serve `index.html` for unmatched paths under `path`. */
     spa: boolean;
+    /** Where this app mounts the Rebase CMS, if it does. */
+    cms?: string;
 }): {
     fileCount: number;
     dir: string;
@@ -412,6 +414,8 @@ export declare function buildStaticBundle(options: {
     path?: string;
     /** Serve `index.html` for unmatched paths. Default `true`. */
     spa?: boolean;
+    /** Where this app mounts the Rebase CMS, if it does. */
+    cms?: string;
 }): {
     outDir: string;
     manifest: RebaseBundleManifest;

package/dist/fold-static.d.ts

@@ -6,6 +6,7 @@ export interface FoldableManifest {
         output?: string;
         path?: string;
         spa?: boolean;
+        cms?: string;
     }>;
 }
 export interface FoldOptions {
@@ -32,6 +33,8 @@ export interface FoldableApp {
     path: string;
     /** SPA fallback, defaulted to `true`. */
     spa: boolean;
+    /** Where this app mounts the Rebase CMS, if it does. */
+    cms?: string;
 }
 /**
  * Every static app in the manifest, in mount order.

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,30 +1495,33 @@ 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(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 have no idea what works and what does not"));
-		console.log(chalk.gray("  unless you tell us. Sharing is entirely optional and off by default."));
+		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("  This is exactly what would be sent — nothing more, ever:"));
-		console.log("");
-		console.log(renderPreview(event, properties).split("\n").map((line) => chalk.gray("    " + line)).join("\n"));
-		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")}.`));
+		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
+			default: true
 		}]);
 		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 {
@@ -1653,7 +1635,7 @@ function buildInitQuestions(params) {
 		type: "input",
 		name: "projectName",
 		message: "Project name:",
-		default: "my-rebase-app",
+		default: "my-app",
 		validate: (input) => validateProjectName(input) ?? true
 	});
 	if (headlessArg === void 0) questions.push({
@@ -1721,7 +1703,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("Defaults to \"my-rebase-app\" when omitted with --yes.")}
+  ${chalk.gray("Asks when omitted; defaults to \"my-app\", and takes it without asking under --yes.")}
 
 ${chalk.bold("Options")}
   ${chalk.blue("-t, --template")} ${chalk.gray("<preset>")}   blog | ecommerce | blank ${chalk.gray("(default: blog)")}
@@ -1803,7 +1785,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-rebase-app";
+		const projectName = nameArg || "my-app";
 		const targetDirectory = path.resolve(process.cwd(), projectName);
 		const templateDirectory = path.resolve(cliRoot, "templates", "template");
 		const pmCommands = getPMCommands(pm);
@@ -2139,7 +2121,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({ reAskDeclined: true })) await recordEvent("cli.init", initProperties, { projectRoot: options.targetDirectory });
 }
 /**
 * Apply a template preset by replacing the default collection files.
@@ -4418,6 +4400,38 @@ function checkAppPath(value, fieldPath, issues) {
 	}
 	return value;
 }
+/**
+* Is `candidate` the path `parent`, or something beneath it?
+*
+* Segment-aware for the same reason `isForbiddenStaticPath` is: a plain
+* `startsWith` reads `/admin` as living under `/adm`.
+*/
+function isUnderPath(candidate, parent) {
+	if (parent === "/") return true;
+	return candidate === parent || candidate.startsWith(`${parent}/`);
+}
+/**
+* Validate where an app says it mounts the Rebase CMS.
+*
+* The same shape as {@link checkAppPath} — it is a URL path and ends up in the
+* same places — plus one rule of its own: it has to be inside the app declaring
+* it. The app's SPA fallback is what answers that URL, so a `cms` outside its
+* `path` names an address this app will never serve. That is a link the console
+* would then offer to a 404, which is worse than the missing link it replaces.
+*/
+function checkCmsPath(value, appPath, fieldPath, issues) {
+	if (value === void 0) return void 0;
+	const cms = checkAppPath(value, fieldPath, issues);
+	if (cms === void 0) return void 0;
+	if (!isUnderPath(cms, appPath)) {
+		issues.push({
+			path: fieldPath,
+			message: `must be inside this app's path — it is at "${appPath}", so it cannot serve "${cms}". The CMS is a route of this app, not a separate deployment; if it really lives elsewhere, declare that app and put \`cms\` on it instead`
+		});
+		return;
+	}
+	return cms;
+}
 function isRecord(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -4480,7 +4494,8 @@ var KNOWN_APP_FIELDS = {
 		"build",
 		"output",
 		"path",
-		"spa"
+		"spa",
+		"cms"
 	]
 };
 /**
@@ -4592,7 +4607,7 @@ function validateApp(name, raw, issues) {
 			});
 			return raw;
 		}
-		case "static":
+		case "static": {
 			checkRelativePath(raw.root, `${base}.root`, issues, { required: true });
 			checkRelativePath(raw.output, `${base}.output`, issues, { required: true });
 			if (raw.build !== void 0 && typeof raw.build !== "string") issues.push({
@@ -4603,8 +4618,10 @@ function validateApp(name, raw, issues) {
 				path: `${base}.spa`,
 				message: "must be a boolean"
 			});
-			checkAppPath(raw.path, `${base}.path`, issues);
+			const appPath = checkAppPath(raw.path, `${base}.path`, issues);
+			checkCmsPath(raw.cms, appPath ?? "/", `${base}.cms`, issues);
 			return raw;
+		}
 		default: return;
 	}
 }
@@ -4671,6 +4688,11 @@ function validateManifest(raw) {
 		}
 		byPath.set(at, name);
 	}
+	const withCms = Object.entries(apps).filter(([, app]) => app.type === "static" && typeof app.cms === "string");
+	if (withCms.length > 1) for (const [name] of withCms.slice(1)) issues.push({
+		path: `apps.${name}.cms`,
+		message: `a project has one CMS — "${withCms[0][0]}" already declares one`
+	});
 	refuseStorageBlock(raw.storage, issues);
 	let telemetry;
 	if (raw.telemetry !== void 0) if (typeof raw.telemetry === "boolean") telemetry = raw.telemetry;
@@ -4853,6 +4875,30 @@ function findBackendApp(manifest) {
 	};
 }
 /**
+* Where this project mounts the Rebase CMS, if it says.
+*
+* The CMS is a component inside a developer's own app, so its address is a
+* client-side route: no build artifact, no running server and no control plane
+* can observe it. {@link RebaseStaticAppConfig.cms} is the only place that fact
+* is ever written down, and this is the one reader of it — so that "the
+* project's CMS" means the same thing to `rebase dev`, `rebase apps list`, the
+* bundle it builds and the console that shows it.
+*
+* Returns the *serving* app alongside the path, because a caller with a base URL
+* needs to know which app answers there — and because the path alone cannot say
+* whether the CMS is the whole of an app or one route of it.
+*/
+function cmsMountOf(manifest) {
+	for (const [name, app] of Object.entries(manifest.apps)) {
+		if (app.type !== "static" || typeof app.cms !== "string") continue;
+		return {
+			appName: name,
+			app,
+			path: app.cms
+		};
+	}
+}
+/**
 * The app a deploy targets: the one named, or the obvious one.
 *
 * A repository declares apps; a project owns them. So "which app" is a question
@@ -5649,14 +5695,21 @@ async function devCommand(rawArgs) {
 	* a shape that has no such directory reads as a broken scaffold on the
 	* very first run of the very command the headless quickstart names.
 	*/
-	const declaresStaticApp = (() => {
+	const staticShape = (() => {
 		try {
 			const { manifest } = loadManifest(projectRoot);
-			return Object.values(manifest.apps ?? {}).some((app) => app.type === "static");
+			return {
+				declaresStaticApp: Object.values(manifest.apps ?? {}).some((app) => app.type === "static"),
+				cmsPath: cmsMountOf(manifest)?.path
+			};
 		} catch {
-			return Boolean(frontendDir);
+			return {
+				declaresStaticApp: Boolean(frontendDir),
+				cmsPath: void 0
+			};
 		}
 	})();
+	const declaresStaticApp = staticShape.declaresStaticApp;
 	let frontendUrl = "";
 	let backendUrl = "";
 	let debounceSummary = null;
@@ -5696,6 +5749,7 @@ async function devCommand(rawArgs) {
 				["✦ Rebase API is ready!", ""],
 				["➜ API:      ", api]
 			];
+			if (declaresStaticApp && staticShape.cmsPath && staticShape.cmsPath !== "/") lines.push(["➜ CMS:   ", `${stripAnsi(frontendUrl).replace(/\/$/, "")}${staticShape.cmsPath}`]);
 			if (!declaresStaticApp) {
 				if (swaggerPath) lines.push(["➜ Swagger:  ", `${api}${swaggerPath}`]);
 				else lines.push(["  ", "(no tables served yet, so no data API and no docs)"]);
@@ -7812,7 +7866,7 @@ function vendorDependencies(options) {
 * in one image already, that is exactly what it had.
 */
 function foldStaticIntoBundle(options) {
-	const { bundleDir, assetsDir, appName, path: basePath, spa } = options;
+	const { bundleDir, assetsDir, appName, path: basePath, spa, cms } = options;
 	const manifestPath = path.join(bundleDir, "manifest.json");
 	if (!fs.existsSync(manifestPath)) throw new Error(`No manifest at ${manifestPath} — build the backend bundle first.`);
 	if (!fs.existsSync(assetsDir)) throw new Error(`No built assets at ${assetsDir}.`);
@@ -7837,7 +7891,9 @@ function foldStaticIntoBundle(options) {
 		static: [...existing, {
 			path: basePath,
 			dir,
-			spa
+			spa,
+			name: appName,
+			...cms ? { cms } : {}
 		}]
 	};
 	fs.writeFileSync(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`, "utf8");
@@ -7872,7 +7928,9 @@ function buildStaticBundle(options) {
 		entry: { static: [{
 			path: basePath,
 			dir: "static",
-			spa: options.spa ?? true
+			spa: options.spa ?? true,
+			name: appName,
+			...options.cms ? { cms: options.cms } : {}
 		}] },
 		hooks: { native: false },
 		deps: { declared: {} },
@@ -8004,7 +8062,8 @@ function foldableApps(manifest) {
 			build: app.build,
 			output: app.output,
 			path: app.path ?? "/",
-			spa: app.spa ?? true
+			spa: app.spa ?? true,
+			cms: app.cms
 		});
 	}
 	apps.sort((a, b) => b.path.length - a.path.length);
@@ -8124,7 +8183,8 @@ async function foldFrontendIntoBundle(options) {
 			assetsDir,
 			appName: app.name,
 			path: app.path,
-			spa: app.spa
+			spa: app.spa,
+			cms: app.cms
 		});
 		outcomes.push({
 			appName: app.name,
@@ -8836,7 +8896,8 @@ async function buildAssetApp(projectRoot, name, app, runtimeRange, outOverride)
 		outDir: outOverride ? path.resolve(process.cwd(), outOverride) : path.join(projectRoot, `dist-bundle-${name}`),
 		runtimeRange,
 		path: basePath,
-		spa: asset.spa ?? true
+		spa: asset.spa ?? true,
+		cms: asset.cms
 	});
 	const rel = path.relative(projectRoot, result.outDir);
 	console.log(chalk.green(`  ✓ static bundle → ${rel}/`) + chalk.dim(` (${result.fileCount} file(s) → served at ${basePath})`));
@@ -9019,13 +9080,6 @@ async function ejectCommand(rawArgs = []) {
 	const dryRun = Boolean(args["--dry-run"]);
 	const force = Boolean(args["--force"]);
 	const requested = positionals[0];
-	if (requested === "infra") {
-		console.error(chalk.red("  ✗ `rebase eject infra` has been removed."));
-		console.error(chalk.gray("    It wrote rebase.infra.json, which nothing ever read. Resources bind"));
-		console.error(chalk.gray("    from the environment on the <BASE>__<KEY> convention; declare them in"));
-		console.error(chalk.gray("    config/resources.ts and see `rebase resources` for the names."));
-		process.exit(1);
-	}
 	let loaded;
 	try {
 		loaded = loadManifest(projectRoot);
@@ -11750,8 +11804,11 @@ function printPayload() {
 		console.log("");
 		console.log(`  ${describeState()}`);
 		console.log("");
-		console.log(chalk.gray("  Nothing is being sent, so there is no payload to show."));
-		console.log(chalk.gray(`  Run ${chalk.cyan("rebase telemetry enable")} first if you want to inspect one.`));
+		console.log(chalk.gray("  Nothing is being sent. This is what WOULD be sent if you said yes:"));
+		console.log("");
+		console.log(renderPreview("cli.dev", { first_run: false }).split("\n").map((l) => "  " + l).join("\n"));
+		console.log("");
+		console.log(chalk.gray(`  Start sharing with ${chalk.cyan("rebase telemetry enable")}.`));
 		console.log("");
 		return;
 	}
@@ -11767,7 +11824,7 @@ function printPayload() {
 }
 function printHelp$2() {
 	console.log(`
-${chalk.bold("rebase telemetry")} — anonymous usage sharing (opt-in, off by default)
+${chalk.bold("rebase telemetry")} — anonymous usage sharing (asked once per project)
 
 ${chalk.bold("Commands")}
   ${chalk.blue("status")}     Whether anything is being shared, and why ${chalk.gray("(default)")}
@@ -15174,7 +15231,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 +15339,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 +15358,13 @@ async function deployCommand(rawArgs, projectRef) {
 		projectId,
 		url
 	});
+	await recordDeploy({
+		followed: true,
+		status,
+		deduplicated,
+		frameworkVersion,
+		startedAt
+	});
 	emit(() => {}, {
 		deploymentId,
 		deduplicated,
@@ -18871,7 +18966,7 @@ async function appsCommand(subcommand, rawArgs = []) {
 function describeApp(app) {
 	switch (app.type) {
 		case "backend": return app.runtime === "custom" ? `custom runtime — ${app.dockerfile ?? "Dockerfile"}` : `managed runtime, config: ${app.config ?? "config"}`;
-		case "static": return `${app.root} → ${app.output} @ ${app.path ?? "/"}`;
+		case "static": return `${app.root} → ${app.output} @ ${app.path ?? "/"}` + (app.cms ? `  ${chalk.magenta(`CMS at ${app.cms}`)}` : "");
 		default: return "";
 	}
 }
@@ -19079,6 +19174,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");
@@ -19256,6 +19369,6 @@ function telemetryNotice() {
 	return chalk.gray(`Usage sharing: ${sharing ? "on" : "off"} — ${chalk.cyan("rebase telemetry")} to inspect or change\n`);
 }
 //#endregion
-export { CURRENT_RUNTIME_RANGE, DEFAULT_BUNDLE_DIR, DEFAULT_CONFIG_DIR, DEFAULT_CRONS_DIR, DEFAULT_FUNCTIONS_DIR, DEFAULT_SCHEMA_FILE, ManifestError, VENDOR_SIZE_MAX_BYTES, VENDOR_SIZE_WARN_BYTES, VENDOR_TARGET_CPU, VENDOR_TARGET_OS, assessManagedCompatibility, buildBundle, buildStaticBundle, buildableApps, collectDeclaredDependencies, commentSpans, composeBundleManifest, detectDeclaredDepConflicts, detectFrameworkDepDrift, detectNativeDependencies, detectStorageAuthorize, entry, findBackendApp, findUnusedServerEntry, foldStaticIntoBundle, loadManifest, manifestExists, manifestPath, normalizeEsmSpecifiers, resolveBackendPaths, selectDeployApp, synthesizeManifest, validateManifest, vendorDependencies, writeManifest };
+export { CURRENT_RUNTIME_RANGE, DEFAULT_BUNDLE_DIR, DEFAULT_CONFIG_DIR, DEFAULT_CRONS_DIR, DEFAULT_FUNCTIONS_DIR, DEFAULT_SCHEMA_FILE, ManifestError, VENDOR_SIZE_MAX_BYTES, VENDOR_SIZE_WARN_BYTES, VENDOR_TARGET_CPU, VENDOR_TARGET_OS, assessManagedCompatibility, buildBundle, buildStaticBundle, buildableApps, cmsMountOf, collectDeclaredDependencies, commentSpans, composeBundleManifest, detectDeclaredDepConflicts, detectFrameworkDepDrift, detectNativeDependencies, detectStorageAuthorize, entry, findBackendApp, findUnusedServerEntry, foldStaticIntoBundle, loadManifest, manifestExists, manifestPath, normalizeEsmSpecifiers, resolveBackendPaths, selectDeployApp, synthesizeManifest, validateManifest, vendorDependencies, writeManifest };
 
 //# sourceMappingURL=index.es.js.map