react-doctor 0.9.7 → 0.9.8-dev.7f028ea

package/dist/report-error-Wat6_MDs.js

@@ -0,0 +1,158 @@
+
+!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]="98355477-37ef-5b82-8b69-b28370c58639")}catch(e){}}();
+import { D as SENTRY_FLUSH_TIMEOUT_MS, H as CANONICAL_DISCORD_URL, Hn as gen, Ht as formatErrorChain, In as error, U as CANONICAL_GITHUB_URL, Ut as formatReactDoctorError, Yn as runSync, cn as isReactDoctorError, en as highlighter, i as buildSentryScope, m as VERSION, nn as isErrnoException, t as recordCount, y as METRIC } from "./record-metric-BGxpNcR0.js";
+import { c as isEnvironmentError, i as recordRunTraceId, n as getActiveRunTrace, o as isExpectedUserError, s as formatEnvironmentError } from "./unref-stdin-noiOzC5n.js";
+import * as Sentry from "@sentry/node";
+//#region src/cli/utils/handle-error.ts
+const OTLP_ENDPOINT_ENVIRONMENT_VARIABLE = "REACT_DOCTOR_OTLP_ENDPOINT";
+const OTLP_AUTH_HEADER_ENVIRONMENT_VARIABLE = "REACT_DOCTOR_OTLP_AUTH_HEADER";
+const formatErrorForReport = (error) => isReactDoctorError(error) ? formatReactDoctorError(error) : formatErrorChain(error);
+const formatSingleLine = (text) => text.replaceAll(/\s+/g, " ").trim();
+const getErrorReportContext = () => ({
+	cwd: process.cwd(),
+	command: process.argv.join(" "),
+	nodeVersion: process.version,
+	platform: process.platform,
+	architecture: process.arch,
+	isOtlpEndpointConfigured: Boolean(process.env[OTLP_ENDPOINT_ENVIRONMENT_VARIABLE]),
+	isOtlpAuthHeaderConfigured: Boolean(process.env[OTLP_AUTH_HEADER_ENVIRONMENT_VARIABLE])
+});
+const formatConfiguredState = (isConfigured) => isConfigured ? "yes" : "no";
+const buildErrorIssueBody = (error, context, sentryEventId) => {
+	const formattedError = formatErrorForReport(error) || "(empty error)";
+	const isOtlpExporterEnabled = context.isOtlpEndpointConfigured && context.isOtlpAuthHeaderConfigured;
+	return [
+		"## Error",
+		"",
+		"```text",
+		formattedError,
+		"```",
+		"",
+		"## Runtime",
+		"",
+		`- react-doctor version: ${VERSION}`,
+		`- node: ${context.nodeVersion}`,
+		`- platform: ${context.platform} ${context.architecture}`,
+		`- cwd: ${context.cwd}`,
+		`- command: ${context.command}`,
+		...sentryEventId ? [`- Sentry reference: ${sentryEventId}`] : [],
+		"",
+		"## OpenTelemetry",
+		"",
+		`- ${OTLP_ENDPOINT_ENVIRONMENT_VARIABLE} configured: ${formatConfiguredState(context.isOtlpEndpointConfigured)}`,
+		`- ${OTLP_AUTH_HEADER_ENVIRONMENT_VARIABLE} configured: ${formatConfiguredState(context.isOtlpAuthHeaderConfigured)} (value redacted)`,
+		`- OTLP exporter enabled: ${formatConfiguredState(isOtlpExporterEnabled)}`,
+		"- trace/span link, if exported: ",
+		"",
+		"## Notes",
+		"",
+		"Please add reproduction steps and any relevant repository details."
+	].join("\n");
+};
+const buildErrorIssueUrl = (error, sentryEventId) => {
+	const formattedError = formatSingleLine(formatErrorForReport(error));
+	const issueUrl = new URL(`${CANONICAL_GITHUB_URL}/issues/new`);
+	issueUrl.searchParams.set("title", formattedError ? `CLI error: ${formattedError}` : "CLI error");
+	issueUrl.searchParams.set("labels", "bug");
+	issueUrl.searchParams.set("body", buildErrorIssueBody(error, getErrorReportContext(), sentryEventId));
+	return issueUrl.toString();
+};
+/**
+* Effect-typed renderer: every message routes through `Console.error`
+* so test runs can swap `Console` to a capture sink and the output
+* appears in the right stream (stderr) in production. Lines stay
+* red-highlighted (matches the historical `consoleLogger.error`
+* contract) so the user sees a clearly distinguished error block.
+*/
+const handleErrorEffect = (error$2, sentryEventId) => gen(function* () {
+	yield* error("");
+	yield* error(highlighter.error("Something went wrong. Please check the error below for more details."));
+	yield* error(highlighter.error(`If the problem persists, please open this prefilled issue: ${buildErrorIssueUrl(error$2, sentryEventId)}`));
+	yield* error(highlighter.error(`You can also ask for help in Discord: ${CANONICAL_DISCORD_URL}`));
+	if (sentryEventId) yield* error(highlighter.error(`Reference (mention this when reporting): ${sentryEventId}`));
+	yield* error("");
+	yield* error(highlighter.error(formatErrorForReport(error$2)));
+	yield* error("");
+});
+/**
+* Sync façade for legacy callers (top-level CLI command bodies that
+* aren't yet Effect-typed). Bridges via `Effect.runSync` so the
+* underlying Console writes happen exactly like the Effect path.
+*/
+const handleError = (error, options = {}) => {
+	runSync(handleErrorEffect(error, options.sentryEventId));
+	if (options.shouldExit !== false) process.exit(1);
+	process.exitCode = 1;
+};
+/**
+* Renderer for expected, user-actionable failures — a bad `--diff` value,
+* a base branch that isn't fetched, or environment errors like disk-full or
+* permission-denied. Prints just the (already human-readable) message — no
+* "Something went wrong", prefilled issue, Discord link, or Sentry reference
+* — because there is no bug to report.
+*/
+const handleUserError = (error$1, options = {}) => {
+	const isEnvError = isEnvironmentError(error$1);
+	if (isEnvError) recordCount(METRIC.cliEnvironmentError, 1, { code: (isErrnoException(error$1) ? error$1.code : void 0) ?? "unknown" });
+	const message = isEnvError ? formatEnvironmentError(error$1) : formatErrorForReport(error$1);
+	runSync(gen(function* () {
+		yield* error("");
+		yield* error(highlighter.error(message));
+		yield* error("");
+	}));
+	if (options.shouldExit !== false) process.exit(1);
+	process.exitCode = 1;
+};
+//#endregion
+//#region src/cli/utils/report-error.ts
+/**
+* Sends an error to Sentry — enriched with a fresh snapshot of the current run
+* (version, platform, CI/agent, invocation, scanned project) and, when a run
+* transaction is in flight, linked to its trace via the scope's propagation
+* context so the crash and its transaction share a `trace_id` — then waits for
+* delivery before the caller exits. The CLI tears down synchronously after
+* rendering an error, so the awaited `flush` is what actually gets the event
+* (and any in-flight transaction) off the machine.
+*
+* Returns the Sentry event id so the caller can surface it as a reference the
+* user can quote when reporting the bug; returns `undefined` when Sentry was
+* never initialized (`--no-score`, tests, or a missing DSN) or delivery failed.
+* Swallows any transport failure so telemetry can never mask the user's
+* original error.
+*/
+const reportErrorToSentry = async (error) => {
+	if (!Sentry.isInitialized()) return void 0;
+	if (isExpectedUserError(error)) return void 0;
+	try {
+		const { tags, contexts } = buildSentryScope();
+		let reason = "unknown";
+		if (isReactDoctorError(error)) reason = error.reason._tag;
+		else if (error instanceof Error) reason = error.name;
+		recordCount(METRIC.cliError, 1, {
+			command: typeof tags.command === "string" ? tags.command : void 0,
+			reason
+		});
+		const runTrace = getActiveRunTrace();
+		const eventId = Sentry.withScope((scope) => {
+			for (const [name, context] of Object.entries(contexts)) scope.setContext(name, context);
+			scope.setTags(tags);
+			if (runTrace) scope.setPropagationContext({
+				traceId: runTrace.traceId,
+				parentSpanId: runTrace.spanId,
+				sampled: runTrace.sampled,
+				sampleRand: Math.random()
+			});
+			recordRunTraceId(scope.getPropagationContext().traceId);
+			return Sentry.captureException(error);
+		});
+		await Sentry.flush(SENTRY_FLUSH_TIMEOUT_MS);
+		return eventId;
+	} catch {
+		return;
+	}
+};
+//#endregion
+export { handleError as n, handleUserError as r, reportErrorToSentry as t };
+
+//# sourceMappingURL=report-error-Wat6_MDs.js.map
+//# debugId=98355477-37ef-5b82-8b69-b28370c58639

package/dist/report-workflow-result-CULZXneJ.js

@@ -0,0 +1,279 @@
+
+!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]="2c4a070e-23f8-5a31-a4af-18688e5c19c0")}catch(e){}}();
+import { S as REACT_DOCTOR_CONFIG_PROJECT_NAME, t as recordCount, y as METRIC } from "./record-metric-BGxpNcR0.js";
+import { u as isCommandAvailable } from "./install-github-workflow-CAo3dNh1.js";
+import { spawn } from "node:child_process";
+import * as path$1 from "node:path";
+import process$1 from "node:process";
+import { createHash } from "node:crypto";
+import { detectInstalledSkillAgents, getSkillAgentTypes } from "agent-install";
+import Conf from "conf";
+//#region src/cli/utils/detect-agents.ts
+const PATH_BINARIES = {
+	"claude-code": ["claude"],
+	codex: ["codex"],
+	cursor: ["cursor", "agent"],
+	droid: ["droid"],
+	"gemini-cli": ["gemini"],
+	"github-copilot": ["copilot"],
+	opencode: ["opencode"],
+	pi: ["pi", "omegon"]
+};
+const detectPathAvailableAgents = () => {
+	const detected = [];
+	for (const [agent, binaries] of Object.entries(PATH_BINARIES)) if (binaries.some(isCommandAvailable)) detected.push(agent);
+	return detected;
+};
+const detectAvailableAgents = async () => {
+	const detected = new Set([...detectPathAvailableAgents(), ...await detectInstalledSkillAgents()]);
+	return getSkillAgentTypes().filter((agent) => agent !== "universal" && detected.has(agent));
+};
+const DEFAULT_INSTALL_AGENTS = [
+	"claude-code",
+	"cursor",
+	"codex",
+	"opencode"
+];
+const computeDefaultSelectedAgents = (detectedAgents, rememberedAgents) => {
+	const detected = new Set(detectedAgents);
+	const remembered = rememberedAgents.filter((agent) => detected.has(agent));
+	if (remembered.length > 0) return remembered;
+	const defaults = DEFAULT_INSTALL_AGENTS.filter((agent) => detected.has(agent));
+	if (defaults.length > 0) return defaults;
+	return detectedAgents.length === 1 ? [...detectedAgents] : [];
+};
+//#endregion
+//#region src/cli/utils/now-iso.ts
+const nowIso = () => (/* @__PURE__ */ new Date()).toISOString();
+const ONBOARDING_EVENT = "onboarding";
+const CI_PITCH_EVENT = "ci-pitch";
+const ACTION_UPGRADE_EVENT = "action-upgrade-v2";
+const SETUP_HINT_EVENT = "setup-hint";
+const HANDOFF_TARGET_PREFERENCE_ID = "handoff-target";
+const INSTALL_AGENTS_PREFERENCE_ID = "install-agents";
+const foldLegacyDecisions = (projects, legacy, eventId) => {
+	for (const [hash, record] of Object.entries(legacy ?? {})) {
+		const existing = projects[hash] ?? { rootDirectory: record.rootDirectory ?? "" };
+		projects[hash] = {
+			...existing,
+			events: {
+				...existing.events,
+				[eventId]: {
+					firedAt: record.at ?? nowIso(),
+					version: 1,
+					...record.outcome ? { outcome: record.outcome } : {}
+				}
+			}
+		};
+	}
+};
+const migrateCliState = (state) => {
+	if (typeof state.schemaVersion === "number" && state.schemaVersion >= 2) return state;
+	const projects = {};
+	for (const [hash, record] of Object.entries(state.projects ?? {})) {
+		const carried = {
+			rootDirectory: record.rootDirectory,
+			...record.events ? { events: record.events } : {},
+			...record.migrations ? { migrations: record.migrations } : {}
+		};
+		projects[hash] = record.setupPrompt === false ? {
+			...carried,
+			events: {
+				...carried.events,
+				[SETUP_HINT_EVENT]: {
+					firedAt: nowIso(),
+					version: 1,
+					outcome: "declined"
+				}
+			}
+		} : carried;
+	}
+	foldLegacyDecisions(projects, state.ciPrompts, CI_PITCH_EVENT);
+	foldLegacyDecisions(projects, state.actionUpgrades, ACTION_UPGRADE_EVENT);
+	return {
+		schemaVersion: 2,
+		global: typeof state.onboardedAt === "string" ? { events: { [ONBOARDING_EVENT]: {
+			firedAt: state.onboardedAt,
+			version: 1
+		} } } : {},
+		projects
+	};
+};
+const resolveConfigDir = (options) => options.cwd ?? (process.env["REACT_DOCTOR_CONFIG_DIR"] || void 0);
+const openStore = (options = {}) => new Conf({
+	projectName: REACT_DOCTOR_CONFIG_PROJECT_NAME,
+	cwd: resolveConfigDir(options)
+});
+const openMigratedStore = (options) => {
+	const store = openStore(options);
+	const state = store.store;
+	const migrated = migrateCliState(state);
+	if (migrated !== state) store.store = migrated;
+	return store;
+};
+const readCliState = (select, fallback, options = {}) => {
+	try {
+		return select(openMigratedStore(options).store);
+	} catch {
+		return fallback;
+	}
+};
+const updateCliState = (update, options = {}) => {
+	try {
+		const store = openMigratedStore(options);
+		store.store = update(store.store);
+		return true;
+	} catch {
+		return false;
+	}
+};
+//#endregion
+//#region src/cli/utils/hash-project-root.ts
+const hashProjectRoot = (projectRoot) => createHash("sha256").update(path$1.resolve(projectRoot)).digest("hex");
+//#endregion
+//#region src/cli/utils/cli-lifecycle.ts
+const versionOf = (item) => item.version ?? 1;
+const selectScope = (state, scoped, projectRoot) => scoped.scope === "global" ? state.global : projectRoot === void 0 ? void 0 : state.projects?.[hashProjectRoot(projectRoot)];
+const updateScope = (state, scoped, projectRoot, updateScopeState) => {
+	if (scoped.scope === "global") return {
+		...state,
+		global: updateScopeState(state.global ?? {})
+	};
+	if (projectRoot === void 0) return state;
+	const projectKey = hashProjectRoot(projectRoot);
+	const base = state.projects?.[projectKey] ?? { rootDirectory: path$1.resolve(projectRoot) };
+	return {
+		...state,
+		projects: {
+			...state.projects,
+			[projectKey]: {
+				...base,
+				...updateScopeState(base)
+			}
+		}
+	};
+};
+const isGatePending = (gate, target = {}, options = {}) => {
+	if (gate.scope === "project" && target.projectRoot === void 0) return false;
+	return readCliState((state) => {
+		const record = selectScope(state, gate, target.projectRoot)?.events?.[gate.id];
+		return !record || record.version < versionOf(gate);
+	}, gate.fireWhenUnknown ?? false, options);
+};
+const recordGate = (gate, target = {}, options = {}) => updateCliState((state) => updateScope(state, gate, target.projectRoot, (scope) => ({
+	...scope,
+	events: {
+		...scope.events,
+		[gate.id]: {
+			firedAt: nowIso(),
+			version: versionOf(gate),
+			...target.outcome ? { outcome: target.outcome } : {}
+		}
+	}
+})), options);
+const readPreference = (preference, target = {}, options = {}) => readCliState((state) => selectScope(state, preference, target.projectRoot)?.preferences?.[preference.id] ?? null, null, options);
+const writePreference = (preference, value, target = {}, options = {}) => updateCliState((state) => updateScope(state, preference, target.projectRoot, (scope) => ({
+	...scope,
+	preferences: {
+		...scope.preferences,
+		[preference.id]: value
+	}
+})), options);
+const isMigrationPending = (migration, target = {}, options = {}) => {
+	if (migration.scope === "project" && target.projectRoot === void 0) return false;
+	return readCliState((state) => {
+		const record = selectScope(state, migration, target.projectRoot)?.migrations?.[migration.id];
+		return !record || record.version < versionOf(migration);
+	}, false, options);
+};
+const recordMigration = (migration, projectRoot, record, options) => updateCliState((state) => updateScope(state, migration, projectRoot, (scope) => ({
+	...scope,
+	migrations: {
+		...scope.migrations,
+		[migration.id]: record
+	}
+})), options);
+const runMigrations = async (migrations, target = {}, options = {}) => {
+	const results = [];
+	for (const migration of migrations) {
+		if (!isMigrationPending(migration, target, options)) {
+			results.push({
+				id: migration.id,
+				ran: false,
+				applied: true
+			});
+			continue;
+		}
+		let applied = false;
+		try {
+			applied = await migration.run({ projectRoot: target.projectRoot });
+		} catch {
+			applied = false;
+		}
+		if (applied) recordMigration(migration, target.projectRoot, {
+			ranAt: nowIso(),
+			version: versionOf(migration)
+		}, options);
+		results.push({
+			id: migration.id,
+			ran: true,
+			applied
+		});
+	}
+	return results;
+};
+//#endregion
+//#region src/cli/utils/open-url.ts
+const resolveOpenCommand = (url) => {
+	if (process$1.platform === "darwin") return {
+		command: "open",
+		args: [url]
+	};
+	if (process$1.platform === "win32") return {
+		command: "cmd",
+		args: [
+			"/c",
+			"start",
+			"",
+			url
+		]
+	};
+	return {
+		command: "xdg-open",
+		args: [url]
+	};
+};
+const openUrl = (url) => new Promise((resolve) => {
+	try {
+		const { command, args } = resolveOpenCommand(url);
+		const child = spawn(command, args, {
+			detached: true,
+			stdio: "ignore"
+		});
+		child.once("spawn", () => resolve(true));
+		child.once("error", () => resolve(false));
+		child.unref();
+	} catch {
+		resolve(false);
+	}
+});
+//#endregion
+//#region src/cli/utils/report-workflow-result.ts
+const reportWorkflowResult = (workflowSpinner, result, projectRoot) => {
+	if (result.status === "failed") {
+		workflowSpinner.fail("Couldn't write the GitHub Actions workflow.");
+		return false;
+	}
+	if (result.status === "exists") {
+		workflowSpinner.succeed("GitHub Actions workflow already configured.");
+		return false;
+	}
+	workflowSpinner.succeed(`GitHub Actions workflow added at ${path$1.relative(projectRoot, result.workflowPath)}.`);
+	recordCount(METRIC.installWorkflow, 1);
+	return true;
+};
+//#endregion
+export { recordGate as a, ACTION_UPGRADE_EVENT as c, INSTALL_AGENTS_PREFERENCE_ID as d, ONBOARDING_EVENT as f, detectAvailableAgents as h, readPreference as i, CI_PITCH_EVENT as l, computeDefaultSelectedAgents as m, openUrl as n, runMigrations as o, SETUP_HINT_EVENT as p, isGatePending as r, writePreference as s, reportWorkflowResult as t, HANDOFF_TARGET_PREFERENCE_ID as u };
+
+//# sourceMappingURL=report-workflow-result-CULZXneJ.js.map
+//# debugId=2c4a070e-23f8-5a31-a4af-18688e5c19c0