@devdogsuga/backstage 0.1.0

package/dist/telemetry-Bjoz29Hl.js

@@ -0,0 +1,609 @@
+import { fileURLToPath } from "node:url";
+import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { homedir, platform, release } from "node:os";
+import * as Sentry from "@sentry/node";
+import { buildSentryOptions } from "@devdogsuga/telemetry";
+//#region ../cli-core/src/catalog.ts
+/**
+* How each scope reads, in the two places that draw it.
+*
+* `menu` sits inline in a hint, so it is one word. `help` heads a block of
+* commands, so it can be a phrase. Both live here rather than in the renderers
+* because they are labels, the same kind of data as a group title.
+*/
+const SCOPES = {
+	machine: {
+		menu: "This machine",
+		help: "Supabase on this machine"
+	},
+	repo: {
+		menu: "Repo",
+		help: "files in the repo"
+	},
+	endpoint: {
+		menu: "Database",
+		help: "the session's database (--tier)"
+	},
+	infra: {
+		menu: "Hosted",
+		help: "hosted infrastructure, each naming its own connection"
+	}
+};
+/** Print what would change; write nothing; exit 0. On every command that writes. */
+const DRY_RUN = {
+	flag: "--dry-run",
+	summary: "Print what would change, write nothing, exit 0."
+};
+/**
+* Machine-readable output to stdout.
+*
+* Promptless by design: the wizard is already interactive; a flag that switches
+* its output format has no meaning there. `commands.test.ts` pins the promptless
+* set with a "scripting-only" category for exactly this kind of flag.
+*/
+const JSON_FLAG = {
+	flag: "--json",
+	summary: "Print machine-readable JSON to stdout."
+};
+/** Skip every interactive confirmation prompt. On every destructive command. */
+const YES = {
+	flag: "--yes",
+	summary: "Skip the confirmations."
+};
+function walk(roots, path) {
+	let nodes = roots;
+	let found = null;
+	for (const name of path) {
+		const next = nodes.find((node) => node.name === name);
+		if (!next) return null;
+		found = next;
+		nodes = next.subcommands ?? [];
+	}
+	return found;
+}
+function createCatalog(trees) {
+	const groups = trees.groups;
+	const ciGroups = trees.ciGroups ?? [];
+	const topLevel = groups.flatMap((group) => group.commands);
+	const ciTopLevel = ciGroups.flatMap((group) => group.commands);
+	const subcommandNames = (path) => (walk(topLevel, path)?.subcommands ?? []).map((node) => node.name);
+	return {
+		usage: trees.usage,
+		commonTasks: trees.commonTasks ?? [],
+		groups,
+		ciGroups,
+		topLevel,
+		ciTopLevel,
+		findCommand: (path) => walk(topLevel, path),
+		findCiCommand: (path) => walk(ciTopLevel, path),
+		groupOf: (name) => groups.find((group) => group.commands.some((command) => command.name === name)),
+		subcommandNames,
+		subcommandCiNames: (path) => (walk(ciTopLevel, path)?.subcommands ?? []).map((node) => node.name),
+		subcommandList: (path) => {
+			const names = subcommandNames(path);
+			if (names.length <= 1) return names.join("");
+			return `${names.slice(0, -1).join(", ")} or ${names[names.length - 1]}`;
+		},
+		allPaths: () => {
+			const paths = [];
+			const visit = (nodes, prefix) => {
+				for (const node of nodes) {
+					const path = [...prefix, node.name];
+					paths.push(path);
+					visit(node.subcommands ?? [], path);
+				}
+			};
+			visit(topLevel, []);
+			return paths;
+		}
+	};
+}
+//#endregion
+//#region ../cli-core/src/cli-name.ts
+let current = "devtools";
+function setCliName(name) {
+	current = name;
+}
+function cliName() {
+	return current;
+}
+//#endregion
+//#region ../cli-core/src/repo/root.ts
+/**
+* Where devtools finds the DevDogsUGA checkout it is running against.
+*
+* devtools used to live inside `packages/devtools` of that repo, so its own
+* `import.meta.url` WAS a path into the repo (`PROJECT_ROOT` /
+* `REPO_ROOT` walked up a fixed number of `..` segments from this file).
+* Published as its own package and run through `pnpm dlx`, that assumption
+* breaks: this file's `import.meta.url` points into a dlx cache directory
+* or an isolated `node_modules` tree that has nothing to do with the repo
+* the contributor is standing in.
+*
+* So repo discovery walks up from `process.cwd()` instead, looking for the
+* marker validated in the `devtools-dlx` prototype
+* (`/home/sloan/scratchpad/devdogs/prototypes/devtools-dlx/FINDINGS.md`,
+* experiment 1): a directory containing `pnpm-workspace.yaml` AND whose
+* `package.json` has `"name": "devdogs-monorepo"`. The name check is not
+* redundant — a bare `pnpm-workspace.yaml` also matches a Backstage
+* checkout (a separate pnpm workspace), which devtools should refuse
+* rather than silently "find".
+*/
+/** The `package.json` name every real DevDogsUGA checkout carries at its root. */
+const REPO_MARKER_NAME = "devdogs-monorepo";
+var RepoNotFoundError = class extends Error {
+	constructor() {
+		super("run this from inside a DevDogsUGA clone");
+		this.name = "RepoNotFoundError";
+	}
+};
+function looksLikeRepoRoot(dir) {
+	if (!existsSync(join(dir, "pnpm-workspace.yaml"))) return false;
+	try {
+		return JSON.parse(readFileSync(join(dir, "package.json"), "utf8")).name === REPO_MARKER_NAME;
+	} catch {
+		return false;
+	}
+}
+/**
+* Walks up from `startDir` (default `process.cwd()`) looking for the repo
+* marker. Returns `null` rather than throwing — `findRepoRoot()` below is
+* the throwing convenience most callers want; this is exported for callers
+* (like `setup`) that need to know without failing.
+*/
+function discoverRepoRoot(startDir = process.cwd()) {
+	let dir = startDir;
+	for (;;) {
+		if (looksLikeRepoRoot(dir)) return dir;
+		const parent = dirname(dir);
+		if (parent === dir) return null;
+		dir = parent;
+	}
+}
+let cachedRoot;
+/**
+* The memoized, throwing repo-root lookup. Lazy on purpose: importing this
+* module must never fail just because nothing has called it yet (`setup`
+* and `completions` in `launch.ts` never need a repo at all, and must stay
+* that way — see that file's header comment on why).
+*
+* Resolved once per process: `process.cwd()` does not change mid-invocation
+* for this CLI, and re-walking the filesystem on every call would be pure
+* waste.
+*/
+function findRepoRoot() {
+	if (cachedRoot === void 0) cachedRoot = process.env.DEVTOOLS_TEST_REPO_ROOT ?? discoverRepoRoot();
+	if (cachedRoot === null) throw new RepoNotFoundError();
+	return cachedRoot;
+}
+//#endregion
+//#region ../cli-core/src/version.ts
+let cachedOwnDir;
+/** The published package's own root: the nearest directory above this
+* module's file that holds a `package.json`. A bundled CLI runs from a flat
+* `dist/`, so that is the CLI's root (`dist/launch.js` -> up one); the core
+* is inlined into it, so its own source location never matters at run time.
+* Memoized since it never changes within a process. */
+function ownPackageDir() {
+	if (cachedOwnDir !== void 0) return cachedOwnDir;
+	let dir = dirname(fileURLToPath(import.meta.url));
+	while (!existsSync(join(dir, "package.json")) && dirname(dir) !== dir) dir = dirname(dir);
+	cachedOwnDir = dir;
+	return dir;
+}
+/** Reads this build's own `package.json` version — used by `telemetry.ts`
+* (release tagging) and the CLI's `version` command. */
+function ownVersion() {
+	const pkg = JSON.parse(readFileSync(join(ownPackageDir(), "package.json"), "utf8"));
+	return typeof pkg.version === "string" ? pkg.version : "0.0.0";
+}
+//#endregion
+//#region ../cli-core/src/failure-log.ts
+/**
+* A local log for a failed run, so a contributor has something to attach to
+* #tech-support.
+*
+* When the process is about to exit non-zero, one file is written holding what
+* helps someone else diagnose it: the command line, the version and platform,
+* the tool commands that ran with their exit codes, devtools' own output, the
+* error, and the Sentry event id when telemetry sent one. The path is printed
+* last, on stderr. Output a tool wrote straight to the terminal is not
+* captured (tools keep the terminal so colours and prompts work), and the log
+* says so.
+*
+* Secrets are redacted before anything is stored: credentials inside URLs,
+* and the value of any environment variable named like a secret.
+*
+* Not a failure, so no log: a clean exit, Ctrl-C (130) or SIGTERM (143), the
+* drift code (2) that `--check` uses on purpose, and a cancelled prompt.
+*/
+function nonEmpty(value) {
+	if (value === void 0 || value === "") return void 0;
+	return value;
+}
+function describe(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+function versionOrUnknown() {
+	try {
+		return ownVersion();
+	} catch {
+		return "unknown";
+	}
+}
+const SECRET_NAME = /(SECRET|TOKEN|PASSWORD|PASSWD|KEY|DSN|DB_URL|CREDENTIAL)/i;
+const URL_CREDENTIALS = /\/\/[^/@\s:]+(:[^/@\s]*)?@/g;
+let state = null;
+/** Replaces credentials in `text` with a placeholder. */
+function redact(text, env = process.env) {
+	let out = text.replace(URL_CREDENTIALS, "//***@");
+	for (const [name, value] of Object.entries(env)) if (value && value.length >= 8 && SECRET_NAME.test(name)) out = out.split(value).join("<redacted>");
+	return out;
+}
+function failureLogDir(env = process.env) {
+	return nonEmpty(env.DEVTOOLS_LOG_DIR) ?? join(nonEmpty(env.XDG_STATE_HOME) ?? join(homedir(), ".local", "state"), "devdogs", "logs");
+}
+/** Whether an exit code means the run failed. */
+function isFailureCode(code) {
+	return code !== 0 && code !== 2 && code !== 130 && code !== 143;
+}
+/** The file's text. Pure, so it is testable without a process to fail. */
+function renderFailureLog(input) {
+	const env = input.env ?? process.env;
+	const lines = [
+		"devtools failure log",
+		"Attach this file to your #tech-support message.",
+		"",
+		`time:      ${input.now.toISOString()}`,
+		`version:   ${versionOrUnknown()}`,
+		`command:   devtools ${input.argv.join(" ")}`,
+		`exit code: ${input.code}`,
+		`tier:      ${nonEmpty(env.DEPLOY_ENV) ?? "development"}`,
+		`node:      ${process.version}`,
+		`platform:  ${platform()} ${release()}`,
+		`cwd:       ${process.cwd()}`,
+		`sentry:    ${input.eventId ?? "none (telemetry sent nothing)"}`,
+		"",
+		"== Tool commands that ran ==",
+		...input.ran.length > 0 ? input.ran : ["(none)"],
+		"",
+		"== Error =="
+	];
+	if (input.error === void 0) lines.push("(none thrown)");
+	else lines.push(input.error instanceof Error ? input.error.stack ?? input.error.message : describe(input.error));
+	lines.push("", "== devtools output (tool output that went straight to the terminal is not here) ==", input.output.length > 0 ? input.output : "(none)");
+	return redact(`${lines.join("\n")}\n`, env);
+}
+/** Records a command a tool ran, for the log. */
+function noteRan(line) {
+	state?.ran.push(line);
+}
+/** Records the error a failure came from, for the log. */
+function noteError(error) {
+	if (state) state.error ??= error;
+}
+/** A cancelled prompt is the user's choice, not a failure. */
+function suppressFailureLog() {
+	if (state) state.quiet = true;
+}
+function keepNewest(dir) {
+	try {
+		const old = readdirSync(dir).filter((name) => name.startsWith("devtools-") && name.endsWith(".log")).sort().slice(0, -10);
+		for (const name of old) rmSync(join(dir, name), { force: true });
+	} catch {}
+}
+/** Writes the log and returns its path, or `null` if it could not be written. */
+function writeLog(input) {
+	try {
+		const dir = failureLogDir(input.env);
+		mkdirSync(dir, { recursive: true });
+		const stamp = input.now.toISOString().replace(/[:.]/g, "-");
+		const path = join(dir, `devtools-${stamp}.log`);
+		writeFileSync(path, renderFailureLog(input), { mode: 384 });
+		keepNewest(dir);
+		return path;
+	} catch {
+		return null;
+	}
+}
+/**
+* Starts recording and writes the log if the process exits with a failure.
+* Call once, early. A second call is ignored.
+*/
+function installFailureLog(options) {
+	if (state) return;
+	state = {
+		argv: [...options.argv],
+		eventId: options.eventId,
+		ran: [],
+		output: "",
+		error: void 0,
+		quiet: false
+	};
+	const capture = (stream) => {
+		const original = stream.write.bind(stream);
+		stream.write = (chunk, ...rest) => {
+			if (state && typeof chunk === "string") state.output = (state.output + chunk).slice(-65536);
+			return original(chunk, ...rest);
+		};
+	};
+	capture(process.stdout);
+	capture(process.stderr);
+	process.once("exit", (exitCode) => {
+		const current = state;
+		if (!current || current.quiet) return;
+		const code = process.exitCode === void 0 ? exitCode : Number(process.exitCode);
+		if (!isFailureCode(code)) return;
+		const path = writeLog({
+			argv: current.argv,
+			code,
+			ran: current.ran,
+			output: current.output,
+			error: current.error,
+			eventId: current.eventId(),
+			now: /* @__PURE__ */ new Date()
+		});
+		const eventId = current.eventId();
+		process.stderr.write([
+			path ? `Log for #tech-support: ${path}` : "Could not write a failure log.",
+			...eventId ? [`Sentry event: ${eventId}`] : [],
+			""
+		].join("\n"));
+	});
+}
+//#endregion
+//#region ../cli-core/src/mode.ts
+/**
+* Non-interactive mode: the one definition both published CLIs share.
+*
+* A run is non-interactive when nobody can answer a prompt: no TTY on stdin,
+* or `CI=true`. In that mode there is no wizard and no banner, output is plain
+* lines (errors on stderr), every confirmation needs `--yes`, the tier must be
+* named (`--tier` or `DEPLOY_ENV`), and Sentry reports the environment `ci`.
+* `--no-env` is the companion switch: it skips loading env files, for a job
+* that supplies its own environment.
+*/
+/** Skip every confirmation. Also the only way past the hosted-tier gate with no terminal. */
+const YES_FLAG = "--yes";
+/** Do not load env files; the caller's environment is the environment. */
+const NO_ENV_FLAG = "--no-env";
+/** `CI=true` (or `1`), the value every CI runner sets. */
+function isCiEnv(env = process.env) {
+	return env.CI === "true" || env.CI === "1";
+}
+/**
+* Whether this run has nobody to ask.
+*
+* Both inputs are injectable for tests; the defaults read the live process.
+*/
+function isNonInteractive(env = process.env, isTTY = process.stdin.isTTY === true) {
+	return !isTTY || isCiEnv(env);
+}
+/** Whether `--yes` was typed anywhere in `argv`. */
+function hasYes(argv) {
+	return argv.includes(YES_FLAG);
+}
+/**
+* Pulls `--no-env` out of `argv`, wherever it sits, leaving everything else in
+* order. Like `--tier`, it is a global flag the launcher strips before any
+* command sees the rest.
+*/
+function stripNoEnvFlag(argv) {
+	const rest = argv.filter((arg) => arg !== NO_ENV_FLAG);
+	return {
+		noEnv: rest.length !== argv.length,
+		rest
+	};
+}
+/**
+* Pulls a global `--tier <t>` out of `argv`, wherever it sits, leaving every
+* other argument untouched and in its original order.
+*
+* A trailing `--tier` with nothing after it removes just the flag; the
+* missing value then reaches tier resolution as `explicit: undefined`, which
+* falls through to `DEPLOY_ENV`/the sole tier/the prompt exactly as if
+* `--tier` had never been typed, rather than this function guessing. A
+* following token that is itself a flag is treated the same way, NOT consumed
+* as the value (the guard every other flag-value reader keeps): without it,
+* `--tier --help` would swallow the flag as a bogus tier and refuse with
+* "unknown tier" instead of reaching the help bypass.
+*/
+function stripTierFlag(argv) {
+	const rest = [...argv];
+	const index = rest.indexOf("--tier");
+	if (index === -1) return {
+		explicit: void 0,
+		rest
+	};
+	const value = rest[index + 1];
+	const missing = value === void 0 || value.startsWith("-");
+	rest.splice(index, missing ? 1 : 2);
+	return {
+		explicit: missing ? void 0 : value,
+		rest
+	};
+}
+let noEnv = false;
+/** Records that `--no-env` was typed, for handlers that behave differently
+* when the caller supplies the environment (backstage's `planner status`). */
+function setNoEnv(value) {
+	noEnv = value;
+}
+/** Whether this run was started with `--no-env`. */
+function isNoEnv() {
+	return noEnv;
+}
+//#endregion
+//#region ../cli-core/src/telemetry.ts
+/**
+* devtools' own Sentry wiring — the CLI is a consumer of
+* `@devdogsuga/telemetry` like `apps/platform`, `apps/schedule-builder`, and
+* `apps/sandbox`, but on `@sentry/node` rather than a framework SDK: a CLI
+* process starts, runs one command, and exits, with none of a server's
+* request lifecycle for a framework integration to hook into.
+*
+* ## Reporting is on by default
+*
+* Every other `*_SENTRY_DSN` in this org is optional-and-empty until
+* configured (see `@devdogsuga/telemetry`'s no-op-without-DSN contract), and
+* so is this one — empty means `buildSentryOptions` returns `undefined` and
+* `Sentry.init` never runs — but the DEFAULT here is reporting ON once a DSN
+* exists, unlike a feature a contributor opts into. `DEVTOOLS_TELEMETRY=0` is
+* the one escape hatch, checked before `Sentry.init` and before every capture
+* call, so it also works as a kill switch after init already ran (a
+* long-lived `pnpm devtools` menu session, for instance).
+*
+* ## Where the DSN comes from
+*
+* Baked in at build time, not read from the consumer's environment: devtools
+* runs on contributors' machines, where no `.env` could be relied on to carry
+* it. `scripts/write-build-info.mjs` writes `dist/build-info.json` from the
+* build's `DEVTOOLS_SENTRY_DSN`, which Backstage's `publish.yaml` sets from
+* the repo's Actions variable of the same name. Every other build bakes ""
+* and reports nothing. `DEVTOOLS_SENTRY_DSN` in the run-time environment still
+* wins, for pointing a local build at a test project.
+*/
+/** The DSN baked into this build, or "" if there is none (a source run under
+* tsx, or a build made without `DEVTOOLS_SENTRY_DSN`). */
+function bakedSentryDsn() {
+	try {
+		const info = JSON.parse(readFileSync(new URL("./build-info.json", import.meta.url), "utf8"));
+		return typeof info.sentryDsn === "string" ? info.sentryDsn : "";
+	} catch {
+		return "";
+	}
+}
+/** The run-time `DEVTOOLS_SENTRY_DSN` if set, else the baked one. */
+function resolveDevtoolsDsn(env, baked) {
+	return (env.DEVTOOLS_SENTRY_DSN ?? "") || baked;
+}
+let initialized = false;
+/** The id of the last event this process sent to Sentry, if any. */
+let lastEventId;
+/**
+* The Sentry event id of the last error or failure this run reported, or
+* `undefined` when telemetry is off or sent nothing. Printed with the failure
+* log so a maintainer can find the event.
+*/
+function lastSentryEventId() {
+	return lastEventId;
+}
+/** Records the id only when a client exists: without one nothing was sent. */
+function sent(id) {
+	if (Sentry.getClient()) lastEventId = id;
+}
+/**
+* `'ci'` whenever the run is non-interactive (no TTY, or `CI=true`, which the
+* runner sets itself before any workflow-authored env), `'local'` on a
+* contributor's terminal.
+* One of `@devdogsuga/telemetry`'s `ENVIRONMENTS`.
+*/
+function devtoolsEnvironment() {
+	return isNonInteractive() ? "ci" : "local";
+}
+/**
+* `DEVTOOLS_TELEMETRY=0` (any other value, including unset, leaves reporting
+* on) is the only opt-out. Checked by both `initDevtoolsTelemetry` (skips
+* `Sentry.init` outright) and `captureDevtoolsError` (so setting it mid-run,
+* or between two invocations in the same process, still works).
+*/
+function devtoolsTelemetryEnabled() {
+	return process.env.DEVTOOLS_TELEMETRY !== "0";
+}
+/**
+* Whether anyone is actually using devtools in this process. Package-registry
+* scanners install every published version within minutes and run it in a
+* throwaway sandbox (random `DESKTOP-xxxxxx` hosts, Firecracker VMs, a fuzzer
+* that turns `process.exit` into a throw). Left unfiltered, each release filed
+* the same two issues from them. They run with no DevDogsUGA checkout and no
+* terminal. A person has at least one of the two (`setup` runs outside a
+* checkout, but in a terminal), and CI always has a checkout.
+*/
+function hasRealCaller(inRepo, isTTY) {
+	return inRepo || isTTY;
+}
+/**
+* Initializes `@sentry/node` for this CLI process. Safe to call more than
+* once (idempotent) and safe to call with no DSN configured (no-ops via
+* `buildSentryOptions`, see its header).
+*
+* `command` becomes a `command` tag on every event this process reports, so
+* an issue in Sentry names the subcommand it came from (`db reset`,
+* `deploy platform`, …) without anyone opening the job log first.
+*/
+function initDevtoolsTelemetry(command) {
+	if (initialized) return;
+	initialized = true;
+	if (!devtoolsTelemetryEnabled()) return;
+	if (!hasRealCaller(discoverRepoRoot() !== null, process.stdin.isTTY === true)) return;
+	const options = buildSentryOptions({
+		service: "devtools",
+		environment: devtoolsEnvironment(),
+		dsn: resolveDevtoolsDsn(process.env, bakedSentryDsn()),
+		release: `${cliName()}@${ownVersion()}`
+	});
+	if (!options) return;
+	Sentry.init(options);
+	Sentry.getCurrentScope().setTag("command", command);
+}
+/**
+* Reports an error nothing below the entry points caught — `launch.ts`'s
+* `dispatch`, `launch-ci.ts`, and the bins — then flushes before the process
+* exits. Node's event loop dies with `process.exit`, taking any in-flight
+* request to Sentry's ingest endpoint with it, so the flush must be awaited
+* BEFORE that call — never after.
+*
+* A short timeout: a CLI exiting on error should not hang perceptibly longer
+* because Sentry's ingest is slow or unreachable.
+*/
+async function captureDevtoolsError(err) {
+	noteError(err);
+	if (!devtoolsTelemetryEnabled()) return;
+	sent(Sentry.captureException(err));
+	await Sentry.flush(2e3);
+}
+/**
+* Reports an error a command caught and explained to the reader itself
+* (`explainError` in `ui.ts`, `backstage deploy`'s catch), then carried on
+* to a normal exit. Not flushed: the SDK's in-flight request keeps the event
+* loop alive until it lands, so a natural exit waits for it on its own. A
+* path that ends in `process.exit` instead must use `captureDevtoolsError`.
+*/
+function reportDevtoolsError(err) {
+	noteError(err);
+	if (!devtoolsTelemetryEnabled()) return;
+	sent(Sentry.captureException(err));
+}
+/**
+* Reports a failure that has no error object — a subprocess or deploy step
+* that exited non-zero. Same no-flush contract as `reportDevtoolsError`.
+*/
+function reportDevtoolsFailure(message, extra = {}) {
+	noteError(new Error(message));
+	if (!devtoolsTelemetryEnabled()) return;
+	sent(Sentry.captureMessage(message, {
+		level: "error",
+		extra
+	}));
+}
+/**
+* Reports a warning-level message under a FIXED fingerprint, then flushes.
+*
+* For the deprecated aliases: every use groups into one Sentry issue per
+* fingerprint, so the issue's last-seen time says when the alias stopped
+* being used and is safe to remove. Flushed because the callers go on to
+* `process.exit`, which would otherwise drop the request in flight. The
+* timeout is short: the command being run is what the person came for.
+*/
+async function captureDevtoolsDeprecation(message, fingerprint, tags) {
+	if (!devtoolsTelemetryEnabled()) return;
+	Sentry.captureMessage(message, {
+		level: "warning",
+		fingerprint: [fingerprint],
+		tags
+	});
+	await Sentry.flush(1e3);
+}
+//#endregion
+export { YES as A, discoverRepoRoot as C, DRY_RUN as D, setCliName as E, JSON_FLAG as O, RepoNotFoundError as S, cliName as T, installFailureLog as _, hasRealCaller as a, ownPackageDir as b, reportDevtoolsError as c, hasYes as d, isNoEnv as f, stripTierFlag as g, stripNoEnvFlag as h, devtoolsTelemetryEnabled as i, createCatalog as j, SCOPES as k, reportDevtoolsFailure as l, setNoEnv as m, captureDevtoolsError as n, initDevtoolsTelemetry as o, isNonInteractive as p, devtoolsEnvironment as r, lastSentryEventId as s, captureDevtoolsDeprecation as t, resolveDevtoolsDsn as u, noteRan as v, findRepoRoot as w, ownVersion as x, suppressFailureLog as y };

package/dist/telemetry.js

@@ -0,0 +1,2 @@
+import { a as hasRealCaller, c as reportDevtoolsError, i as devtoolsTelemetryEnabled, l as reportDevtoolsFailure, n as captureDevtoolsError, o as initDevtoolsTelemetry, r as devtoolsEnvironment, s as lastSentryEventId, t as captureDevtoolsDeprecation, u as resolveDevtoolsDsn } from "./telemetry-Bjoz29Hl.js";
+export { captureDevtoolsDeprecation, captureDevtoolsError, devtoolsEnvironment, devtoolsTelemetryEnabled, hasRealCaller, initDevtoolsTelemetry, lastSentryEventId, reportDevtoolsError, reportDevtoolsFailure, resolveDevtoolsDsn };

package/dist/ui-CdKo8mLw.js

@@ -0,0 +1,66 @@
+import { c as reportDevtoolsError, p as isNonInteractive, y as suppressFailureLog } from "./telemetry-Bjoz29Hl.js";
+import { cancel, isCancel, log, note } from "@clack/prompts";
+//#region ../cli-core/src/ui.ts
+/**
+* Shared prompt plumbing.
+*
+* The audience here is a contributor who may not be comfortable in a terminal
+* at all, so two rules apply throughout:
+*
+*   * Nothing requires knowing a command. Running `pnpm devtools` with no
+*     arguments opens a menu, and every prompt has a sensible default.
+*   * A failure says what to do next. `explain()` exists so no error path
+*     ends at a stack trace.
+*/
+function bail(message = "Cancelled.") {
+	if (message === "Cancelled.") suppressFailureLog();
+	if (isNonInteractive()) process.stderr.write(`${message}\n`);
+	else cancel(message);
+	process.exit(1);
+}
+/** Exits cleanly on Ctrl-C rather than letting a cancel symbol leak onward. */
+function unwrap(value) {
+	if (isCancel(value)) bail();
+	return value;
+}
+/**
+* Reports a failure with the next thing to try.
+*
+* `hints` is not decoration: for most of these failures the fix is one command,
+* and printing it is the difference between a contributor continuing and a
+* contributor asking in Discord.
+*/
+function explain(summary, detail, hints = []) {
+	if (isNonInteractive()) {
+		process.stderr.write(`${summary}\n`);
+		if (detail) process.stderr.write(`${detail}\n`);
+		for (const hint of hints) process.stderr.write(`  try: ${hint}\n`);
+		return;
+	}
+	log.error(summary);
+	if (detail) log.message(detail);
+	if (hints.length > 0) note(hints.join("\n"), "Try this");
+}
+/**
+* A refusal the reader can fix themselves — a name that matches nothing, a
+* flag missing where there is no terminal to ask. Thrown from deep enough
+* that the command's catch can't tell it from a real failure any other way;
+* `explainError` prints it like any other error but keeps it out of Sentry.
+*/
+var UsageError = class extends Error {
+	name = "UsageError";
+};
+/**
+* `explain()` for a caught error rather than a refusal: prints the same way,
+* with `err`'s message as the detail, and reports `err` to Sentry unless it
+* is a {@link UsageError}. Only failures nobody anticipated belong there.
+*/
+function explainError(summary, err, hints = []) {
+	if (!(err instanceof UsageError)) reportDevtoolsError(err);
+	explain(summary, errorMessage(err), hints);
+}
+function errorMessage(err) {
+	return err instanceof Error ? err.message : String(err);
+}
+//#endregion
+export { explainError as a, explain as i, bail as n, unwrap as o, errorMessage as r, UsageError as t };