@posthog/wizard 2.11.0 → 2.13.0

package/dist/debug-Cqi6nVfX.js

@@ -0,0 +1,686 @@
+import "./wizard-ui-YdGFRyu_.js";
+import { n as WIZARD_LOG_FILE } from "./paths-DJS47p5x.js";
+import { appendFileSync } from "fs";
+import path from "path";
+//#region src/utils/logging.ts
+function prepareMessage(msg) {
+	if (typeof msg === "string") return msg;
+	if (msg instanceof Error) return `${msg.stack || ""}`;
+	return JSON.stringify(msg, null, "	");
+}
+function l(msg) {
+	console.log(msg);
+}
+function red(msg) {
+	return l(prepareMessage(msg));
+}
+//#endregion
+//#region src/lib/version.ts
+const VERSION = "2.13.0";
+//#endregion
+//#region src/env.ts
+/**
+* Central environment variable access for the PostHog wizard.
+*
+* ── Build-time constants ────────────────────────────────────────────
+* Inlined by tsdown's `env` option at compile time. After build, the
+* runtime value of these env vars has zero effect on the wizard.
+*
+* ── Runtime variables ───────────────────────────────────────────────
+* Read through `runtimeEnv()` with a typed allowlist. This makes every
+* runtime dependency on the environment explicit and grep-able.
+*
+* ── Direct process.env access ───────────────────────────────────────
+* Reserved for subprocess environment configuration (writes) and
+* vendored code. Production source outside those cases should use
+* this module instead.
+*/
+const NODE_ENV = "production";
+/** Read a runtime environment variable. Only allowlisted keys compile. */
+function runtimeEnv(key) {
+	return process.env[key];
+}
+//#endregion
+//#region src/lib/constants.ts
+/**
+* Shared constants for the PostHog wizard.
+*/
+/**
+* Detection order matters: put framework-specific integrations BEFORE basic language fallbacks.
+*/
+let Integration = /* @__PURE__ */ function(Integration) {
+	Integration["nextjs"] = "nextjs";
+	Integration["nuxt"] = "nuxt";
+	Integration["vue"] = "vue";
+	Integration["reactRouter"] = "react-router";
+	Integration["tanstackStart"] = "tanstack-start";
+	Integration["tanstackRouter"] = "tanstack-router";
+	Integration["reactNative"] = "react-native";
+	Integration["angular"] = "angular";
+	Integration["astro"] = "astro";
+	Integration["django"] = "django";
+	Integration["flask"] = "flask";
+	Integration["fastapi"] = "fastapi";
+	Integration["laravel"] = "laravel";
+	Integration["sveltekit"] = "sveltekit";
+	Integration["swift"] = "swift";
+	Integration["android"] = "android";
+	Integration["rails"] = "rails";
+	Integration["python"] = "python";
+	Integration["ruby"] = "ruby";
+	Integration["javascriptNode"] = "javascript_node";
+	Integration["javascript_web"] = "javascript_web";
+	return Integration;
+}({});
+const DEFAULT_HOST_URL = "https://us.i.posthog.com";
+const ISSUES_URL = "https://github.com/posthog/wizard/issues";
+const CONTEXT_MILL_URL = "https://github.com/PostHog/context-mill";
+const POSTHOG_DOCS_URL = "https://posthog.com/docs";
+/** Remote base URL for fetching the skill menu + downloading skills. */
+const REMOTE_SKILLS_BASE_URL = "https://github.com/PostHog/context-mill/releases/latest/download";
+/** Local base URL when `--local-mcp` is set (served by context-mill dev server). */
+const LOCAL_SKILLS_BASE_URL = "http://localhost:8765";
+/**
+* Pick the skills base URL based on the session's localMcp flag.
+* Single source of truth — do not inline this ternary anywhere.
+*/
+function getSkillsBaseUrl(localMcp) {
+	return localMcp ? LOCAL_SKILLS_BASE_URL : REMOTE_SKILLS_BASE_URL;
+}
+const ANALYTICS_POSTHOG_PUBLIC_PROJECT_WRITE_KEY = "sTMFPsFhdP1Ssg";
+const ANALYTICS_HOST_URL = "https://internal-j.posthog.com";
+const ANALYTICS_TEAM_TAG = "docs-and-wizard";
+const POSTHOG_OAUTH_URL = "https://oauth.posthog.com";
+const OAUTH_PORTS = [
+	8239,
+	8238,
+	8240,
+	8237,
+	8236,
+	8235
+];
+const POSTHOG_US_CLIENT_ID = "c4Rdw8DIxgtQfA80IiSnGKlNX8QN00cFWF00QQhM";
+const POSTHOG_DEV_CLIENT_ID = "DC5uRLVbGI02YQ82grxgnK6Qn12SXWpCqdPb60oZ";
+const POSTHOG_PROXY_CLIENT_ID = POSTHOG_US_CLIENT_ID;
+const DUMMY_PROJECT_API_KEY = "_YOUR_POSTHOG_PROJECT_TOKEN_";
+/**
+* Scopes the wizard requests during the agentic provisioning signup flow.
+*
+* Each entry is justified by what the wizard's agent step does after signup:
+* - user:read         identify the user for analytics + agent context
+* - project:read      look up the freshly-provisioned project
+* - llm_gateway:read  authenticate to gateway.{us,eu}.posthog.com/wizard
+*                     (the agent's LLM calls — without this scope, every
+*                     agent message returns 401)
+* - query:read        run HogQL queries when the agent needs data
+* - dashboard:write   create the onboarding dashboard during setup
+* - insight:write     create the onboarding insights during setup
+*
+* Must be a subset of `ALLOWED_PROVISIONING_SCOPES` in
+* `ee/api/agentic_provisioning/views.py` on the backend.
+*/
+const WIZARD_PROVISIONING_SCOPES = [
+	"user:read",
+	"project:read",
+	"llm_gateway:read",
+	"dashboard:write",
+	"insight:write",
+	"query:read"
+];
+/**
+* Scopes the wizard requests during the OAuth login flow. Superset of
+* `WIZARD_PROVISIONING_SCOPES` with two scopes that only apply to the login
+* path and are not in the provisioning allowlist:
+* - introspection      lets the wizard introspect its own token
+* - health_issue:read  used by `wizard doctor`
+*/
+const WIZARD_OAUTH_SCOPES = [
+	...WIZARD_PROVISIONING_SCOPES,
+	"introspection",
+	"health_issue:read"
+];
+const WIZARD_INTERACTION_EVENT_NAME = "wizard interaction";
+const WIZARD_REMARK_EVENT_NAME = "wizard remark";
+/** Feature flag key whose value selects a variant from WIZARD_VARIANTS. */
+const WIZARD_VARIANT_FLAG_KEY = "wizard-variant";
+/** Feature flag key that gates the intro-screen "Tools" menu. */
+const WIZARD_TOOLS_MENU_FLAG_KEY = "wizard-tools-menu";
+/** Variant key -> metadata for wizard run (VARIANT flag selects which entry to use). */
+const WIZARD_VARIANTS = {
+	base: { VARIANT: "base" },
+	subagents: { VARIANT: "subagents" }
+};
+/** User-Agent for wizard HTTP requests and MCP server identification. */
+const WIZARD_USER_AGENT = `posthog/wizard; version: ${VERSION}`;
+/** Header prefix for PostHog properties (e.g. X-POSTHOG-PROPERTY-VARIANT). */
+const POSTHOG_PROPERTY_HEADER_PREFIX = "X-POSTHOG-PROPERTY-";
+/** Header prefix for PostHog feature flags. */
+const POSTHOG_FLAG_HEADER_PREFIX = "X-POSTHOG-FLAG-";
+/** Timeout for framework / project detection probes (ms). */
+const DETECTION_TIMEOUT_MS = 1e4;
+/** Timeout for the OAuth authorization flow (ms). */
+const OAUTH_TIMEOUT_MS = 36e4;
+//#endregion
+//#region src/lib/health-checks/statuspage.ts
+function mapIndicator(v) {
+	switch (v) {
+		case "none": return "healthy";
+		case "minor": return "degraded";
+		case "major":
+		case "critical": return "down";
+		default: return "degraded";
+	}
+}
+function mapComponentRaw(v) {
+	switch (v) {
+		case "operational": return "healthy";
+		case "degraded_performance":
+		case "under_maintenance": return "degraded";
+		case "partial_outage":
+		case "major_outage": return "down";
+		default: return "degraded";
+	}
+}
+function errResult$1(error) {
+	return {
+		status: "degraded",
+		error
+	};
+}
+async function fetchStatuspageIndicator(url, timeoutMs = 5e3) {
+	try {
+		const controller = new AbortController();
+		const tid = setTimeout(() => controller.abort(), timeoutMs);
+		const res = await fetch(url, { signal: controller.signal });
+		clearTimeout(tid);
+		if (!res.ok) return errResult$1(`HTTP ${res.status}`);
+		const indicator = (await res.json()).status?.indicator ?? null;
+		return {
+			status: mapIndicator(indicator),
+			rawIndicator: indicator ?? void 0
+		};
+	} catch (e) {
+		if (e instanceof Error && e.name === "AbortError") return errResult$1("Request timed out");
+		return errResult$1(e instanceof Error ? e.message : "Unknown error");
+	}
+}
+async function fetchStatuspageSummary(url, timeoutMs = 5e3) {
+	try {
+		const controller = new AbortController();
+		const tid = setTimeout(() => controller.abort(), timeoutMs);
+		const res = await fetch(url, { signal: controller.signal });
+		clearTimeout(tid);
+		if (!res.ok) return errResult$1(`HTTP ${res.status}`);
+		const data = await res.json();
+		const indicator = data.status?.indicator ?? null;
+		const overall = mapIndicator(indicator);
+		const affected = (data.components ?? []).map((c) => ({
+			name: c.name,
+			status: mapComponentRaw(c.status),
+			rawStatus: c.status
+		})).filter((c) => c.status !== "healthy");
+		return {
+			status: affected.length > 0 ? "degraded" : overall,
+			rawIndicator: indicator ?? void 0,
+			degradedOrDownComponents: affected.length > 0 ? affected : void 0
+		};
+	} catch (e) {
+		if (e instanceof Error && e.name === "AbortError") return errResult$1("Request timed out");
+		return errResult$1(e instanceof Error ? e.message : "Unknown error");
+	}
+}
+const checkAnthropicHealth = () => fetchStatuspageIndicator("https://status.claude.com/api/v2/status.json");
+const checkGithubHealth = () => fetchStatuspageIndicator("https://www.githubstatus.com/api/v2/status.json");
+const checkNpmOverallHealth = () => fetchStatuspageIndicator("https://status.npmjs.org/api/v2/status.json");
+const checkNpmComponentHealth = () => fetchStatuspageSummary("https://status.npmjs.org/api/v2/summary.json");
+const checkCloudflareOverallHealth = () => fetchStatuspageIndicator("https://www.cloudflarestatus.com/api/v2/status.json");
+const checkCloudflareComponentHealth = () => fetchStatuspageSummary("https://www.cloudflarestatus.com/api/v2/summary.json");
+//#endregion
+//#region src/lib/health-checks/incidentio.ts
+function mapIncidentImpact(impact) {
+	switch (impact) {
+		case "full_outage": return "down";
+		case "partial_outage":
+		case "degraded_performance": return "degraded";
+		default: return "degraded";
+	}
+}
+function mapComponentStatus(status) {
+	switch (status) {
+		case "operational": return "healthy";
+		case "full_outage": return "down";
+		case "partial_outage":
+		case "degraded_performance": return "degraded";
+		default: return "degraded";
+	}
+}
+function errResult(error) {
+	return {
+		status: "degraded",
+		error
+	};
+}
+const POSTHOG_STATUS_URL = "https://www.posthogstatus.com/api/v1/summary";
+async function fetchPosthogStatus(timeoutMs = 5e3) {
+	try {
+		const controller = new AbortController();
+		const tid = setTimeout(() => controller.abort(), timeoutMs);
+		const res = await fetch(POSTHOG_STATUS_URL, { signal: controller.signal });
+		clearTimeout(tid);
+		if (!res.ok) {
+			const err = errResult(`HTTP ${res.status}`);
+			return {
+				overall: err,
+				components: err
+			};
+		}
+		const incidents = (await res.json()).ongoing_incidents ?? [];
+		if (incidents.length === 0) return {
+			overall: { status: "healthy" },
+			components: { status: "healthy" }
+		};
+		let worstOverall = "degraded";
+		const affected = [];
+		for (const incident of incidents) {
+			if (mapIncidentImpact(incident.current_worst_impact) === "down") worstOverall = "down";
+			for (const comp of incident.affected_components ?? []) {
+				const compStatus = mapComponentStatus(comp.current_status);
+				if (compStatus !== "healthy") affected.push({
+					name: comp.group_name ? `${comp.group_name} — ${comp.name}` : comp.name,
+					status: compStatus,
+					rawStatus: comp.current_status
+				});
+			}
+		}
+		return {
+			overall: { status: worstOverall },
+			components: {
+				status: affected.length > 0 ? "degraded" : worstOverall,
+				degradedOrDownComponents: affected.length > 0 ? affected : void 0
+			}
+		};
+	} catch (e) {
+		if (e instanceof Error && e.name === "AbortError") {
+			const err = errResult("Request timed out");
+			return {
+				overall: err,
+				components: err
+			};
+		}
+		const err = errResult(e instanceof Error ? e.message : "Unknown error");
+		return {
+			overall: err,
+			components: err
+		};
+	}
+}
+let _cache = null;
+function getPosthogHealth() {
+	if (!_cache) _cache = fetchPosthogStatus();
+	return _cache;
+}
+const checkPosthogOverallHealth = async () => (await getPosthogHealth()).overall;
+const checkPosthogComponentHealth = async () => (await getPosthogHealth()).components;
+//#endregion
+//#region src/lib/health-checks/endpoints.ts
+function downResult(error) {
+	return {
+		status: "down",
+		error
+	};
+}
+async function fetchEndpointHealth(url, timeoutMs = 5e3, expectedStatus = 200) {
+	try {
+		const controller = new AbortController();
+		const tid = setTimeout(() => controller.abort(), timeoutMs);
+		const res = await fetch(url, { signal: controller.signal });
+		clearTimeout(tid);
+		if (res.status === expectedStatus) return {
+			status: "healthy",
+			rawIndicator: `HTTP ${res.status}`
+		};
+		return downResult(`HTTP ${res.status}`);
+	} catch (e) {
+		if (e instanceof Error && e.name === "AbortError") return downResult("Request timed out");
+		return downResult(e instanceof Error ? e.message : "Unknown error");
+	}
+}
+const checkLlmGatewayHealth = () => fetchEndpointHealth("https://gateway.us.posthog.com/_liveness");
+const checkMcpHealth = () => fetchEndpointHealth("https://mcp.posthog.com/");
+const checkGithubReleasesHealth = () => fetchEndpointHealth(`${REMOTE_SKILLS_BASE_URL}/skill-menu.json`);
+//#endregion
+//#region src/lib/health-checks/readiness.ts
+const SERVICE_LABELS = {
+	anthropic: "Anthropic",
+	posthogOverall: "PostHog",
+	posthogComponents: "PostHog (components)",
+	github: "GitHub",
+	npmOverall: "npm",
+	npmComponents: "npm (components)",
+	cloudflareOverall: "Cloudflare",
+	cloudflareComponents: "Cloudflare (components)",
+	llmGateway: "LLM Gateway",
+	mcp: "MCP",
+	githubReleases: "GitHub Releases"
+};
+/**
+* See README section "Health checks" for the full rationale.
+* Adjust these arrays to change what blocks a wizard run.
+*/
+const DEFAULT_WIZARD_READINESS_CONFIG = {
+	downBlocksRun: [
+		"anthropic",
+		"npmOverall",
+		"llmGateway",
+		"mcp",
+		"githubReleases"
+	],
+	degradedBlocksRun: ["anthropic"]
+};
+/**
+* Reduced readiness config for --signup provisioning flows.
+*
+* Provisioning only needs PostHog and the LLM Gateway - it doesn't
+* use Anthropic directly, npm, GitHub Releases, or MCP.
+*/
+const SIGNUP_WIZARD_READINESS_CONFIG = { downBlocksRun: ["posthogOverall", "llmGateway"] };
+async function checkAllExternalServices() {
+	const [anthropic, posthogOverall, posthogComponents, github, npmOverall, npmComponents, cloudflareOverall, cloudflareComponents, llmGateway, mcp, githubReleases] = await Promise.all([
+		checkAnthropicHealth(),
+		checkPosthogOverallHealth(),
+		checkPosthogComponentHealth(),
+		checkGithubHealth(),
+		checkNpmOverallHealth(),
+		checkNpmComponentHealth(),
+		checkCloudflareOverallHealth(),
+		checkCloudflareComponentHealth(),
+		checkLlmGatewayHealth(),
+		checkMcpHealth(),
+		checkGithubReleasesHealth()
+	]);
+	return {
+		anthropic,
+		posthogOverall,
+		posthogComponents,
+		github,
+		npmOverall,
+		npmComponents,
+		cloudflareOverall,
+		cloudflareComponents,
+		llmGateway,
+		mcp,
+		githubReleases
+	};
+}
+function describeResult(label, h) {
+	const parts = [`${label}: ${h.status}`];
+	if (h.rawIndicator) parts.push(`indicator=${h.rawIndicator}`);
+	if (h.error) parts.push(h.error);
+	return parts.join(" — ");
+}
+const MAX_COMPONENT_NAMES = 8;
+function describeComponents(label, h) {
+	const affected = h.degradedOrDownComponents;
+	if (!affected || affected.length === 0) return `${label} components: all operational`;
+	const shown = affected.slice(0, MAX_COMPONENT_NAMES).map((c) => `${c.name} (${c.status})`);
+	const suffix = affected.length > MAX_COMPONENT_NAMES ? `, +${affected.length - MAX_COMPONENT_NAMES} more` : "";
+	return `${label} components impacted: ${shown.join(", ")}${suffix}`;
+}
+const READINESS_TIMEOUT_MS = 1e4;
+async function evaluateWizardReadiness(config = DEFAULT_WIZARD_READINESS_CONFIG) {
+	try {
+		const health = await Promise.race([checkAllExternalServices(), new Promise((resolve) => setTimeout(() => resolve(allUnknown("Health check timed out")), READINESS_TIMEOUT_MS))]);
+		const reasons = [];
+		for (const key of Object.keys(health)) {
+			const result = health[key];
+			const label = SERVICE_LABELS[key];
+			reasons.push(describeResult(label, result));
+			if ("degradedOrDownComponents" in result) reasons.push(describeComponents(label, result));
+		}
+		const blockingKeys = getBlockingServiceKeys(health, config);
+		if (blockingKeys.length > 0) {
+			logToFile(`[health-checks] blocked by: ${blockingKeys.join(", ")}`);
+			return {
+				decision: "no",
+				health,
+				reasons
+			};
+		}
+		if (Object.values(health).some((h) => h.status !== "healthy")) return {
+			decision: "yes_with_warnings",
+			health,
+			reasons
+		};
+		return {
+			decision: "yes",
+			health,
+			reasons
+		};
+	} catch (err) {
+		logToFile(`[health-checks] error: ${err instanceof Error ? err.message : err}`);
+		return {
+			decision: "yes",
+			health: allUnknown("Unexpected error"),
+			reasons: ["Health check failed unexpectedly — proceeding anyway"]
+		};
+	}
+}
+/** Keys that are component-level detail, not top-level services. */
+const COMPONENT_KEYS = [
+	"posthogComponents",
+	"npmComponents",
+	"cloudflareComponents"
+];
+/**
+* Get the keys of services that would block a wizard run per the given config.
+*/
+function getBlockingServiceKeys(health, config = DEFAULT_WIZARD_READINESS_CONFIG) {
+	return Object.keys(health).filter((key) => {
+		if (COMPONENT_KEYS.includes(key)) return false;
+		const result = health[key];
+		if (config.downBlocksRun.includes(key) && result.status === "down") return true;
+		if ((config.degradedBlocksRun ?? []).includes(key) && result.status !== "healthy") return true;
+		return false;
+	});
+}
+/** Build an AllServicesHealth where every service is Degraded with the given error. */
+function allUnknown(error) {
+	const base = {
+		status: "degraded",
+		error
+	};
+	return {
+		anthropic: base,
+		posthogOverall: base,
+		posthogComponents: { ...base },
+		github: base,
+		npmOverall: base,
+		npmComponents: { ...base },
+		cloudflareOverall: base,
+		cloudflareComponents: { ...base },
+		llmGateway: base,
+		mcp: base,
+		githubReleases: base
+	};
+}
+//#endregion
+//#region src/ui/logging-ui.ts
+var LoggingUI = class {
+	intro(message) {
+		console.log(`┌  ${message}`);
+	}
+	outro(message) {
+		console.log(`└  ${message}`);
+	}
+	outroError(data) {
+		console.log(`✖  ${data.message ?? "Wizard aborted"}`);
+		if (data.body) console.log(`│  ${data.body}`);
+		if (data.docsUrl) console.log(`│  Docs: ${data.docsUrl}`);
+	}
+	waitForOutroDismissed() {
+		return Promise.resolve();
+	}
+	cancel(message) {
+		console.log(`■  ${message}`);
+	}
+	log = {
+		info(message) {
+			console.log(`│  ${message}`);
+		},
+		warn(message) {
+			console.log(`▲  ${message}`);
+		},
+		error(message) {
+			console.log(`✖  ${message}`);
+		},
+		success(message) {
+			console.log(`✔  ${message}`);
+		},
+		step(message) {
+			console.log(`◇  ${message}`);
+		}
+	};
+	note(message) {
+		console.log(`│  ${message}`);
+	}
+	spinner() {
+		return {
+			start(message) {
+				if (message) console.log(`◌  ${message}`);
+			},
+			stop(message) {
+				if (message) console.log(`●  ${message}`);
+			},
+			message(msg) {
+				if (msg) console.log(`◌  ${msg}`);
+			}
+		};
+	}
+	pushStatus(message) {
+		console.log(`◇  ${message}`);
+	}
+	setDetectedFramework(label) {
+		console.log(`✔  Framework: ${label}`);
+	}
+	onEnterScreen(_screen, _fn) {}
+	setLoginUrl(url) {
+		if (url) {
+			console.log(`│  If the browser didn't open automatically, use this link:`);
+			console.log(`│  ${url}`);
+		}
+	}
+	showBlockingOutage(result) {
+		console.log(`▲  Service health issues detected — blocking outage.`);
+		const blockingKeys = getBlockingServiceKeys(result.health);
+		if (blockingKeys.length > 0) {
+			console.log(`│`);
+			console.log(`│  Blocking services:`);
+			for (const key of blockingKeys) {
+				const status = result.health[key].status;
+				const error = result.health[key].error;
+				const label = SERVICE_LABELS[key];
+				const detail = error ? ` — ${error}` : "";
+				console.log(`│    ✖ ${label}: ${status}${detail}`);
+			}
+			console.log(`│`);
+		}
+		for (const reason of result.reasons) console.log(`│  ${reason}`);
+		console.log(`│  The wizard cannot start while these services are down.`);
+		return Promise.resolve();
+	}
+	setReadinessWarnings(result) {
+		console.log(`▲  Service health warnings detected.`);
+		for (const reason of result.reasons) console.log(`│  ${reason}`);
+	}
+	showPortConflict(_processInfo) {
+		return Promise.resolve();
+	}
+	showSettingsOverride(_conflicts, _backupAndFix) {
+		return Promise.resolve();
+	}
+	showAuthError() {
+		console.log(`✖  Authentication failed (401)`);
+		console.log(`│  Claude Code auth is conflicting with the wizard. Please try again after logging out:`);
+		console.log(`│    claude auth logout`);
+	}
+	startRun() {}
+	setCredentials(_credentials) {}
+	syncTodos(todos) {
+		const completed = todos.filter((t) => t.status === "completed").length;
+		const inProgress = todos.find((t) => t.status === "in_progress");
+		if (inProgress) console.log(`◌  [${completed}/${todos.length}] ${inProgress.activeForm || inProgress.content}`);
+	}
+	setEventPlan(_events) {}
+	setFrameworkContext(_key, _value) {}
+};
+//#endregion
+//#region src/ui/index.ts
+let currentUI = new LoggingUI();
+function getUI() {
+	return currentUI;
+}
+function setUI(ui) {
+	currentUI = ui;
+}
+//#endregion
+//#region src/utils/debug.ts
+let debugEnabled = false;
+let logFilePath = WIZARD_LOG_FILE;
+let logEnabled = true;
+function getLogFilePath() {
+	return logFilePath;
+}
+/**
+* Configure the log file path and enable/disable state.
+* Call before initLogFile() to override defaults.
+*/
+function configureLogFile(opts) {
+	if (opts.path !== void 0) logFilePath = opts.path;
+	if (opts.enabled !== void 0) logEnabled = opts.enabled;
+}
+/**
+* Configure log path from environment variables.
+*
+* Uses POSTHOG_WIZARD_LOG_DIR when set, joined with posthog-wizard.log.
+*/
+function configureLogFileFromEnvironment() {
+	const envLogDir = runtimeEnv("POSTHOG_WIZARD_LOG_DIR");
+	if (envLogDir) configureLogFile({ path: path.join(envLogDir, "posthog-wizard.log") });
+}
+/**
+* Initialize the log file with a run header.
+* Call this at the start of each wizard run.
+* Fails silently to avoid crashing the wizard.
+*/
+function initLogFile() {
+	if (!logEnabled) return;
+	try {
+		const header = `\n${"=".repeat(60)}\nPostHog Wizard Run: ${(/* @__PURE__ */ new Date()).toISOString()}\n${"=".repeat(60)}\n`;
+		appendFileSync(logFilePath, header);
+	} catch {}
+}
+/**
+* Log a message to the log file.
+* Always writes regardless of debug flag (when logging is enabled).
+* Fails silently to avoid masking errors in catch blocks.
+*/
+function logToFile(...args) {
+	if (!logEnabled) return;
+	try {
+		const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+		const msg = args.map((a) => prepareMessage(a)).join(" ");
+		appendFileSync(logFilePath, `[${timestamp}] ${msg}\n`);
+	} catch {}
+}
+function debug(...args) {
+	if (!debugEnabled) return;
+	const msg = args.map((a) => prepareMessage(a)).join(" ");
+	getUI().log.info(msg);
+}
+function enableDebugLogs() {
+	debugEnabled = true;
+}
+//#endregion
+export { POSTHOG_PROPERTY_HEADER_PREFIX as A, WIZARD_VARIANTS as B, Integration as C, POSTHOG_DOCS_URL as D, POSTHOG_DEV_CLIENT_ID as E, WIZARD_OAUTH_SCOPES as F, VERSION as G, getSkillsBaseUrl as H, WIZARD_PROVISIONING_SCOPES as I, red as K, WIZARD_REMARK_EVENT_NAME as L, POSTHOG_US_CLIENT_ID as M, REMOTE_SKILLS_BASE_URL as N, POSTHOG_FLAG_HEADER_PREFIX as O, WIZARD_INTERACTION_EVENT_NAME as P, WIZARD_TOOLS_MENU_FLAG_KEY as R, ISSUES_URL as S, OAUTH_TIMEOUT_MS as T, NODE_ENV as U, WIZARD_VARIANT_FLAG_KEY as V, runtimeEnv as W, ANALYTICS_TEAM_TAG as _, getLogFilePath as a, DETECTION_TIMEOUT_MS as b, getUI as c, SERVICE_LABELS as d, SIGNUP_WIZARD_READINESS_CONFIG as f, ANALYTICS_POSTHOG_PUBLIC_PROJECT_WRITE_KEY as g, ANALYTICS_HOST_URL as h, enableDebugLogs as i, POSTHOG_PROXY_CLIENT_ID as j, POSTHOG_OAUTH_URL as k, setUI as l, getBlockingServiceKeys as m, configureLogFileFromEnvironment as n, initLogFile as o, evaluateWizardReadiness as p, debug as r, logToFile as s, configureLogFile as t, LoggingUI as u, CONTEXT_MILL_URL as v, OAUTH_PORTS as w, DUMMY_PROJECT_API_KEY as x, DEFAULT_HOST_URL as y, WIZARD_USER_AGENT as z };
+
+//# sourceMappingURL=debug-Cqi6nVfX.js.map