react-doctor 0.9.7 → 0.9.8-dev.7f028ea

package/dist/build-section-divider-DKzi1sn2.js

@@ -0,0 +1,312 @@
+
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="bd01af5d-c94c-56b0-8823-3601ceecd3b3")}catch(e){}}();
+import { D as SENTRY_FLUSH_TIMEOUT_MS, I as isDebugFlagEnabled, On as scrubSensitivePaths, U as CANONICAL_GITHUB_URL, X as DOCS_URL, en as highlighter, i as buildSentryScope, on as isPlainObject, yn as redactSensitiveText } from "./record-metric-BGxpNcR0.js";
+import { o as isExpectedUserError } from "./unref-stdin-noiOzC5n.js";
+import * as Sentry from "@sentry/node";
+//#region src/cli/utils/is-env-flag-enabled.ts
+const isEnvFlagEnabled = (value) => value === "1" || value?.toLowerCase() === "true";
+//#endregion
+//#region src/cli/utils/anonymize-text.ts
+/**
+* Free-text fields can carry both a home-directory path (the OS username) and a
+* secret/email echoed from user code, so run both scrubbers: strip the username
+* from paths, then mask any known credential/PII shape. Shared by the Sentry
+* event scrubber ({@link scrubSentryEvent}) and metric scrubber
+* ({@link scrubSentryMetric}).
+*/
+const anonymizeText = (text) => redactSensitiveText(scrubSensitivePaths(text));
+/**
+* Recursively rewrites every string within an arbitrary value (object / array /
+* primitive) through {@link anonymizeText}, mutating in place. Used to sweep the
+* unstructured corners of a Sentry payload (event contexts/extra/tags, breadcrumb
+* data, span attributes, metric attributes) where a path or secret could hide.
+*/
+const anonymizeInPlace = (value) => {
+	if (Array.isArray(value)) {
+		for (let index = 0; index < value.length; index += 1) {
+			const item = value[index];
+			if (typeof item === "string") value[index] = anonymizeText(item);
+			else anonymizeInPlace(item);
+		}
+		return;
+	}
+	if (!isPlainObject(value)) return;
+	for (const key of Object.keys(value)) {
+		const inner = value[key];
+		if (typeof inner === "string") value[key] = anonymizeText(inner);
+		else anonymizeInPlace(inner);
+	}
+};
+//#endregion
+//#region src/cli/utils/scrub-sentry-event.ts
+/**
+* Anonymizes a Sentry event (error or transaction) before it leaves the
+* machine. Strips identity the SDK attaches automatically — the IP-bearing
+* `user`, the `server_name`, and the device `name` (all hostnames) — drops
+* captured local variables (unbounded, un-anonymizable user data), and scrubs
+* home-directory paths + known secrets/emails from every remaining string:
+* messages, stack frames, breadcrumbs, contexts/extra/tags, and span
+* attributes (e.g. the `inspect.directory` path on the bridged `runInspect`
+* span).
+*
+* Wired into both `beforeSend` and `beforeSendTransaction`. If scrubbing ever
+* throws, the event is dropped (`null`) rather than risk sending un-anonymized
+* data — telemetry is best-effort, privacy is not.
+*/
+const scrubSentryEvent = (event) => {
+	try {
+		delete event.server_name;
+		delete event.user;
+		const device = event.contexts?.device;
+		if (device) delete device.name;
+		if (event.contexts) anonymizeInPlace(event.contexts);
+		if (event.extra) anonymizeInPlace(event.extra);
+		if (event.tags) anonymizeInPlace(event.tags);
+		if (typeof event.message === "string") event.message = anonymizeText(event.message);
+		for (const breadcrumb of event.breadcrumbs ?? []) {
+			if (typeof breadcrumb.message === "string") breadcrumb.message = anonymizeText(breadcrumb.message);
+			if (breadcrumb.data) anonymizeInPlace(breadcrumb.data);
+		}
+		for (const exception of event.exception?.values ?? []) {
+			if (typeof exception.value === "string") exception.value = anonymizeText(exception.value);
+			for (const frame of exception.stacktrace?.frames ?? []) {
+				delete frame.vars;
+				if (typeof frame.filename === "string") frame.filename = scrubSensitivePaths(frame.filename);
+				if (typeof frame.abs_path === "string") frame.abs_path = scrubSensitivePaths(frame.abs_path);
+				if (typeof frame.module === "string") frame.module = scrubSensitivePaths(frame.module);
+			}
+		}
+		for (const span of event.spans ?? []) {
+			if (typeof span.description === "string") span.description = anonymizeText(span.description);
+			if (span.data) anonymizeInPlace(span.data);
+		}
+		return event;
+	} catch {
+		return null;
+	}
+};
+//#endregion
+//#region src/cli/utils/scrub-sentry-metric.ts
+/**
+* Anonymizes a Sentry metric before it leaves the machine, mirroring
+* {@link scrubSentryEvent}. Drops the `server.address` default attribute (the
+* hostname) and scrubs home-directory paths + known secrets/emails from every
+* remaining attribute value (metric names are our own constants, so they're
+* left intact to avoid splitting a series). Returns `null` on any failure so an
+* un-anonymized metric is never sent. Wired into `beforeSendMetric`.
+*/
+const scrubSentryMetric = (metric) => {
+	try {
+		if (metric.attributes) {
+			delete metric.attributes["server.address"];
+			anonymizeInPlace(metric.attributes);
+		}
+		return metric;
+	} catch {
+		return null;
+	}
+};
+//#endregion
+//#region src/cli/utils/sentry-config.ts
+/**
+* Shared Sentry configuration resolution — release, environment, and tracing
+* sample rate — derived from `VERSION` and the standard `SENTRY_*` env
+* overrides. Lives apart from `instrument.ts` (the CLI's run-context-aware
+* init) so both the CLI and the editor language server can resolve identical
+* release/environment values without the LSP pulling in CLI run-context code.
+*/
+/**
+* A version is a "dev" build when it's the unbuilt placeholder (`0.0.0`) or
+* carries a prerelease suffix (e.g. the `-dev.<sha>` snapshots published from
+* CI). Everything else is a real, tagged release.
+*/
+const isDevVersion = (version) => version === "0.0.0" || version.includes("-");
+/**
+* Sentry release identifier. `react-doctor@<version>` keeps it unique within
+* the org and — crucially — matches the value `scripts/sentry-sourcemaps.mjs`
+* uploads source-map artifacts under, so stack frames symbolicate. Honors the
+* standard `SENTRY_RELEASE` override.
+*/
+const resolveSentryRelease = () => process.env.SENTRY_RELEASE || `react-doctor@0.9.8-dev.7f028ea`;
+/**
+* Deployment environment shown in Sentry's environment filter. Defaults to
+* `production` for tagged releases and `development` for dev/unbuilt versions,
+* overridable via the standard `SENTRY_ENVIRONMENT` env var.
+*/
+const resolveSentryEnvironment = () => process.env.SENTRY_ENVIRONMENT || (isDevVersion("0.9.8-dev.7f028ea") ? "development" : "production");
+/**
+* Performance-tracing sample rate in `[0, 1]`. Reads `SENTRY_TRACES_SAMPLE_RATE`
+* (set to `0` to disable tracing) and falls back to
+* {@link SENTRY_DEFAULT_TRACES_SAMPLE_RATE}. Invalid / out-of-range values fall
+* back to the default rather than silently disabling tracing.
+*/
+const resolveTracesSampleRate = () => {
+	const raw = process.env.SENTRY_TRACES_SAMPLE_RATE;
+	if (raw === void 0 || raw.trim() === "") return 1;
+	const parsed = Number(raw);
+	if (Number.isNaN(parsed) || parsed < 0 || parsed > 1) return 1;
+	return parsed;
+};
+//#endregion
+//#region src/instrument.ts
+let isInitialized = false;
+let resolvedTracesSampleRate = 0;
+const shouldEnableSentry = () => {
+	if (process.argv.includes("--no-score") || process.argv.includes("--no-telemetry")) return false;
+	if (process.env.VITEST || process.env.NODE_ENV === "test") return false;
+	return true;
+};
+/**
+* Whether performance traces will actually be recorded — Sentry is live and the
+* resolved sample rate is above zero. Used to gate the per-run root span and
+* the Effect→Sentry tracer bridge so they're true no-ops when tracing is off.
+*/
+const isSentryTracingEnabled = () => Sentry.isInitialized() && resolvedTracesSampleRate > 0;
+/**
+* Flushes queued Sentry events (errors + transactions) before the CLI exits, so
+* the success-path transaction is delivered. A no-op when Sentry was never
+* initialized, and it swallows transport failures so telemetry can never mask
+* the user's result.
+*/
+const flushSentry = async () => {
+	if (!Sentry.isInitialized()) return;
+	try {
+		await Sentry.flush(SENTRY_FLUSH_TIMEOUT_MS);
+	} catch {}
+};
+/**
+* Initializes the Sentry Node SDK for CLI crash reporting and performance
+* tracing. Invoked as the first statement of the CLI entry (`cli/index.ts`) so
+* the SDK's global `uncaughtException` / `unhandledRejection` handlers and OTel
+* auto-instrumentation are armed before any command runs.
+*
+* Exported as a function rather than a bare side-effecting import because the
+* package declares `"sideEffects": false`, which lets the bundler tree-shake
+* side-effect-only modules. An explicit call keeps the initialization in the
+* published `dist/cli.js`.
+*
+* Scoped to the CLI application only — the programmatic `@react-doctor/api`
+* library never initializes Sentry, so importing `diagnose()` into a consumer
+* app can't hijack their telemetry.
+*
+* Configuration is environment-overridable for self-hosting and tuning:
+* `SENTRY_DSN`, `SENTRY_ENVIRONMENT`, `SENTRY_RELEASE`,
+* `SENTRY_TRACES_SAMPLE_RATE` (`0` disables tracing), and `SENTRY_DEBUG`.
+*/
+const initializeSentry = () => {
+	if (isInitialized || !shouldEnableSentry()) return;
+	isInitialized = true;
+	resolvedTracesSampleRate = isDebugFlagEnabled() ? 1 : resolveTracesSampleRate();
+	const { tags, contexts } = buildSentryScope();
+	try {
+		Sentry.init({
+			dsn: process.env.SENTRY_DSN || "https://f253d570240a59b8dbd77b7a548ef133@o4510226365743104.ingest.us.sentry.io/4511487817809920",
+			release: resolveSentryRelease(),
+			environment: resolveSentryEnvironment(),
+			sendDefaultPii: false,
+			tracesSampleRate: resolvedTracesSampleRate,
+			debug: isEnvFlagEnabled(process.env.SENTRY_DEBUG),
+			initialScope: {
+				tags,
+				contexts
+			},
+			beforeSend: (event, hint) => isExpectedUserError(hint.originalException) ? null : scrubSentryEvent(event),
+			beforeSendTransaction: (event) => scrubSentryEvent(event),
+			beforeSendMetric: (metric) => scrubSentryMetric(metric)
+		});
+	} catch {
+		resolvedTracesSampleRate = 0;
+	}
+};
+//#endregion
+//#region src/cli/utils/active-scan-abort-registry.ts
+const activeScanAbortControllers = /* @__PURE__ */ new Set();
+const activeScanAbortRegistry = {
+	register: (controller) => {
+		activeScanAbortControllers.add(controller);
+		return () => activeScanAbortControllers.delete(controller);
+	},
+	abortAll: () => {
+		const controllers = [...activeScanAbortControllers];
+		activeScanAbortControllers.clear();
+		for (const controller of controllers) controller.abort();
+	}
+};
+//#endregion
+//#region src/cli/utils/resolve-measure-width.ts
+const resolveClampedWidth = (input) => {
+	const terminalColumns = process.stdout.columns;
+	if (!terminalColumns || terminalColumns <= 0) return input.fullWidth;
+	const availableColumns = terminalColumns - input.reservedColumns;
+	return Math.max(input.minWidth, Math.min(input.fullWidth, availableColumns));
+};
+const resolveMeasureWidth = (reservedColumns = 0) => resolveClampedWidth({
+	reservedColumns,
+	fullWidth: 60,
+	minWidth: 24
+});
+//#endregion
+//#region src/cli/utils/wrap-indented-text.ts
+const wrapLine = (lineText, width, breakLongWords) => {
+	if (lineText.length <= width) return [lineText];
+	const wrappedLines = [];
+	let remainingText = lineText.trim();
+	while (remainingText.length > width) {
+		const candidateText = remainingText.slice(0, width);
+		const breakIndex = candidateText.lastIndexOf(" ");
+		if (breakIndex <= 0) {
+			if (breakLongWords) {
+				wrappedLines.push(candidateText);
+				remainingText = remainingText.slice(width).trimStart();
+				continue;
+			}
+			const nextSpace = remainingText.indexOf(" ");
+			if (nextSpace === -1) break;
+			wrappedLines.push(remainingText.slice(0, nextSpace));
+			remainingText = remainingText.slice(nextSpace + 1).trimStart();
+			continue;
+		}
+		wrappedLines.push(remainingText.slice(0, breakIndex));
+		remainingText = remainingText.slice(breakIndex + 1).trimStart();
+	}
+	if (remainingText.length > 0) wrappedLines.push(remainingText);
+	return wrappedLines;
+};
+/**
+* Greedy word-wrap to a character width, returning one string per line
+* (no indentation applied). Preserves existing `\n` boundaries.
+*/
+const wrapTextToWidth = (text, width, options = {}) => {
+	if (width <= 0) return text.split("\n");
+	const breakLongWords = options.breakLongWords ?? true;
+	return text.split("\n").flatMap((lineText) => wrapLine(lineText, width, breakLongWords));
+};
+//#endregion
+//#region src/cli/utils/build-footer-description-lines.ts
+const FOOTER_DESCRIPTION_INDENT = "  ";
+const buildFooterDescriptionLines = (description) => {
+	return wrapTextToWidth(description, resolveMeasureWidth(2)).map((line) => highlighter.dim(`${FOOTER_DESCRIPTION_INDENT}${line}`));
+};
+//#endregion
+//#region src/cli/utils/build-footer-link-lines.ts
+const buildFooterLinkLines = ({ shareUrl }) => [
+	...shareUrl === null ? [] : [
+		`  ${highlighter.bold("Share:")} ${highlighter.info(shareUrl)}`,
+		...buildFooterDescriptionLines("Tell others how you did on socials"),
+		""
+	],
+	`  ${highlighter.bold("Docs:")} ${highlighter.info(DOCS_URL)}`,
+	...buildFooterDescriptionLines("Learn more about fixing issues, setting up CI/CD, and configuring rules with a config file"),
+	"",
+	`  ${highlighter.bold("GitHub:")} ${highlighter.info(CANONICAL_GITHUB_URL)}`,
+	...buildFooterDescriptionLines("Report issues and star the repository!")
+];
+//#endregion
+//#region src/cli/utils/build-section-divider.ts
+const DIVIDER_INDENT = "  ";
+const buildSectionDivider = () => highlighter.dim(`${DIVIDER_INDENT}${"─".repeat(resolveMeasureWidth(2))}`);
+//#endregion
+export { initializeSentry as a, flushSentry as i, buildFooterLinkLines as n, isSentryTracingEnabled as o, activeScanAbortRegistry as r, buildSectionDivider as t };
+
+//# sourceMappingURL=build-section-divider-DKzi1sn2.js.map
+//# debugId=bd01af5d-c94c-56b0-8823-3601ceecd3b3