@posthog/wizard 2.9.0 → 2.10.0

package/dist/setup-utils-CdDnllRW.js

@@ -0,0 +1,928 @@
+import { c as getUI, s as logToFile } from "./debug-CyJ_3dTP.js";
+import { _ as POSTHOG_US_CLIENT_ID, a as DEFAULT_HOST_URL, c as ISSUES_URL, d as OAUTH_TIMEOUT_MS, g as POSTHOG_PROXY_CLIENT_ID, m as POSTHOG_OAUTH_URL, n as analytics, s as DUMMY_PROJECT_API_KEY, u as OAUTH_PORTS, x as WIZARD_USER_AGENT } from "./analytics-C4jO5Qda.js";
+import { t as traceStep } from "./telemetry-Ct_GGkSO.js";
+import { r as wizardAbort } from "./wizard-abort-7HUIsqv1.js";
+import { major, minVersion } from "semver";
+import * as childProcess from "node:child_process";
+import { execSync } from "node:child_process";
+import * as fs$1 from "node:fs";
+import { basename, join } from "node:path";
+import * as fs$2 from "fs";
+import * as path$1 from "path";
+import axios from "axios";
+import * as crypto from "node:crypto";
+import * as http from "node:http";
+import opn from "opn";
+import { z } from "zod";
+const packageManagers = [
+	{
+		name: "bun",
+		label: "Bun",
+		installCommand: "bun add",
+		buildCommand: "bun run build",
+		runScriptCommand: "bun run",
+		flags: "",
+		forceInstallFlag: "--force",
+		detect: ({ installDir }) => ["bun.lockb", "bun.lock"].some((lockFile) => fs$2.existsSync(path$1.join(installDir, lockFile))),
+		addOverride: async (pkgName, pkgVersion, { installDir }) => {
+			const packageDotJson = await getPackageDotJson({ installDir });
+			const overrides = packageDotJson.overrides || {};
+			await updatePackageDotJson({
+				...packageDotJson,
+				overrides: {
+					...overrides,
+					[pkgName]: pkgVersion
+				}
+			}, { installDir });
+		}
+	},
+	{
+		name: "yarn",
+		label: "Yarn V1",
+		installCommand: "yarn add",
+		buildCommand: "yarn build",
+		runScriptCommand: "yarn",
+		flags: "--ignore-workspace-root-check",
+		forceInstallFlag: "--force",
+		detect: ({ installDir }) => {
+			try {
+				return fs$2.readFileSync(path$1.join(installDir, "yarn.lock"), "utf-8").slice(0, 500).includes("yarn lockfile v1");
+			} catch (e) {
+				return false;
+			}
+		},
+		addOverride: async (pkgName, pkgVersion, { installDir }) => {
+			const packageDotJson = await getPackageDotJson({ installDir });
+			const resolutions = packageDotJson.resolutions || {};
+			await updatePackageDotJson({
+				...packageDotJson,
+				resolutions: {
+					...resolutions,
+					[pkgName]: pkgVersion
+				}
+			}, { installDir });
+		}
+	},
+	{
+		name: "yarn",
+		label: "Yarn V2/3/4",
+		installCommand: "yarn add",
+		buildCommand: "yarn build",
+		runScriptCommand: "yarn",
+		flags: "",
+		forceInstallFlag: "--force",
+		detect: ({ installDir }) => {
+			try {
+				return fs$2.readFileSync(path$1.join(installDir, "yarn.lock"), "utf-8").slice(0, 500).includes("__metadata");
+			} catch (e) {
+				return false;
+			}
+		},
+		addOverride: async (pkgName, pkgVersion, { installDir }) => {
+			const packageDotJson = await getPackageDotJson({ installDir });
+			const resolutions = packageDotJson.resolutions || {};
+			await updatePackageDotJson({
+				...packageDotJson,
+				resolutions: {
+					...resolutions,
+					[pkgName]: pkgVersion
+				}
+			}, { installDir });
+		}
+	},
+	{
+		name: "pnpm",
+		label: "pnpm",
+		installCommand: "pnpm add",
+		buildCommand: "pnpm build",
+		runScriptCommand: "pnpm",
+		flags: "--ignore-workspace-root-check",
+		forceInstallFlag: "--force",
+		detect: ({ installDir }) => fs$2.existsSync(path$1.join(installDir, "pnpm-lock.yaml")),
+		addOverride: async (pkgName, pkgVersion, { installDir }) => {
+			const packageDotJson = await getPackageDotJson({ installDir });
+			const pnpm = packageDotJson.pnpm || {};
+			const overrides = pnpm.overrides || {};
+			await updatePackageDotJson({
+				...packageDotJson,
+				pnpm: {
+					...pnpm,
+					overrides: {
+						...overrides,
+						[pkgName]: pkgVersion
+					}
+				}
+			}, { installDir });
+		}
+	},
+	{
+		name: "npm",
+		label: "npm",
+		installCommand: "npm add",
+		buildCommand: "npm run build",
+		runScriptCommand: "npm run",
+		flags: "",
+		forceInstallFlag: "--force",
+		detect: ({ installDir }) => fs$2.existsSync(path$1.join(installDir, "package-lock.json")),
+		addOverride: async (pkgName, pkgVersion, { installDir }) => {
+			const packageDotJson = await getPackageDotJson({ installDir });
+			const overrides = packageDotJson.overrides || {};
+			await updatePackageDotJson({
+				...packageDotJson,
+				overrides: {
+					...overrides,
+					[pkgName]: pkgVersion
+				}
+			}, { installDir });
+		}
+	},
+	{
+		name: "expo",
+		label: "Expo",
+		installCommand: "npx expo install",
+		buildCommand: "npx expo build",
+		runScriptCommand: "npx expo run",
+		flags: "",
+		forceInstallFlag: "--force",
+		detect: () => false,
+		addOverride: async (pkgName, pkgVersion, { installDir }) => {
+			const packageDotJson = await getPackageDotJson({ installDir });
+			const overrides = packageDotJson.overrides || {};
+			await updatePackageDotJson({
+				...packageDotJson,
+				overrides: {
+					...overrides,
+					[pkgName]: pkgVersion
+				}
+			}, { installDir });
+		}
+	}
+];
+function detectAllPackageManagers({ installDir }) {
+	return traceStep("detect-package-manager", () => {
+		const detectedManagers = [];
+		for (const packageManager of packageManagers) if (packageManager.detect({ installDir })) detectedManagers.push(packageManager);
+		if (detectedManagers.length === 0) analytics.setTag("package-manager", "not-detected");
+		return detectedManagers;
+	});
+}
+//#endregion
+//#region src/utils/urls.ts
+const getHostFromRegion = (region) => {
+	if (region === "eu") return "https://eu.i.posthog.com";
+	return "https://us.i.posthog.com";
+};
+const getCloudUrlFromRegion = (region) => {
+	if (region === "eu") return "https://eu.posthog.com";
+	return "https://us.posthog.com";
+};
+async function detectRegionFromToken(accessToken) {
+	const headers = {
+		Authorization: `Bearer ${accessToken}`,
+		"User-Agent": WIZARD_USER_AGENT
+	};
+	const [usResult, euResult] = await Promise.allSettled([axios.get("https://us.posthog.com/api/users/@me/", { headers }), axios.get("https://eu.posthog.com/api/users/@me/", { headers })]);
+	if (usResult.status === "fulfilled") return "us";
+	if (euResult.status === "fulfilled") return "eu";
+	throw new Error("Could not determine cloud region from access token. Please check your PostHog account.");
+}
+const getLlmGatewayUrlFromHost = (host) => {
+	if (host.includes("localhost")) return "http://localhost:3308/wizard";
+	if (host.includes("eu.posthog.com") || host.includes("eu.i.posthog.com")) return "https://gateway.eu.posthog.com/wizard";
+	return "https://gateway.us.posthog.com/wizard";
+};
+//#endregion
+//#region src/utils/oauth.ts
+const OAUTH_CALLBACK_STYLES = `
+  <style>
+    * {
+      font-family: monospace;
+      background-color: #1b0a00;
+      color: #F7A502;
+      font-weight: medium;
+      font-size: 24px;
+      margin: .25rem;
+    }
+
+    .blink {
+      animation: blink-animation 1s steps(2, start) infinite;
+    }
+
+    @keyframes blink-animation {
+      to {
+        opacity: 0;
+      }
+    }
+  </style>
+`;
+const OAuthTokenResponseSchema = z.object({
+	access_token: z.string(),
+	expires_in: z.number(),
+	token_type: z.string(),
+	scope: z.string(),
+	refresh_token: z.string(),
+	scoped_teams: z.array(z.number()).optional(),
+	scoped_organizations: z.array(z.string()).optional()
+});
+function getLocalOAuthOrigin(port) {
+	return `http://localhost:${port}`;
+}
+function getCallbackUrl(port) {
+	return `${getLocalOAuthOrigin(port)}/callback`;
+}
+function getLocalLoginUrl(port) {
+	return `${getLocalOAuthOrigin(port)}/authorize`;
+}
+function getLocalSignupUrl(port) {
+	return `${getLocalLoginUrl(port)}?signup=true`;
+}
+function generateCodeVerifier$1() {
+	return crypto.randomBytes(32).toString("base64url");
+}
+function generateCodeChallenge$1(verifier) {
+	return crypto.createHash("sha256").update(verifier).digest("base64url");
+}
+async function startCallbackServer(authUrl, signupUrl, port) {
+	return new Promise((resolve, reject) => {
+		let callbackResolve;
+		let callbackReject;
+		const waitForCallback = () => new Promise((res, rej) => {
+			callbackResolve = res;
+			callbackReject = rej;
+		});
+		const server = http.createServer((req, res) => {
+			if (!req.url) {
+				res.writeHead(400);
+				res.end();
+				return;
+			}
+			const url = new URL(req.url, getLocalOAuthOrigin(port));
+			if (url.pathname === "/authorize") {
+				const redirectUrl = url.searchParams.get("signup") === "true" ? signupUrl : authUrl;
+				res.writeHead(302, { Location: redirectUrl });
+				res.end();
+				return;
+			}
+			const code = url.searchParams.get("code");
+			const error = url.searchParams.get("error");
+			if (error) {
+				const isAccessDenied = error === "access_denied";
+				res.writeHead(isAccessDenied ? 200 : 400, { "Content-Type": "text/html; charset=utf-8" });
+				res.end(`
+          <html>
+            <head>
+              <meta charset="UTF-8">
+              <title>PostHog wizard - Authorization ${isAccessDenied ? "cancelled" : "failed"}</title>
+              ${OAUTH_CALLBACK_STYLES}
+            </head>
+            <body>
+              <p>${isAccessDenied ? "Authorization cancelled." : `Authorization failed.`}</p>
+              <p>Return to your terminal. This window will close automatically.</p>
+              <script>window.close();<\/script>
+            </body>
+          </html>
+        `);
+				callbackReject(/* @__PURE__ */ new Error(`OAuth error: ${error}`));
+				return;
+			}
+			if (code) {
+				res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+				res.end(`
+          <html>
+            <head>
+              <meta charset="UTF-8">
+              <title>PostHog wizard is ready</title>
+              ${OAUTH_CALLBACK_STYLES}
+            </head>
+            <body>
+              <p>PostHog login complete!</p>
+              <p>Return to your terminal: the wizard is hard at work on your project<span class="blink">█</span></p>
+              <script>window.close();<\/script>
+            </body>
+          </html>
+        `);
+				callbackResolve(code);
+			} else {
+				res.writeHead(400, { "Content-Type": "text/html; charset=utf-8" });
+				res.end(`
+          <html>
+            <head>
+              <meta charset="UTF-8">
+              <title>PostHog wizard - Invalid request</title>
+              ${OAUTH_CALLBACK_STYLES}
+            </head>
+            <body>
+              <p>Invalid request - no authorization code received.</p>
+              <p>You can close this window.</p>
+            </body>
+          </html>
+        `);
+			}
+		});
+		server.listen(port, () => {
+			resolve({
+				port,
+				server,
+				waitForCallback
+			});
+		});
+		server.on("error", reject);
+	});
+}
+function getPortProcessInfo(port) {
+	try {
+		const lines = execSync(`lsof -i :${port} -sTCP:LISTEN 2>/dev/null`, {
+			encoding: "utf-8",
+			timeout: 3e3
+		}).trim().split("\n");
+		if (lines.length < 2) return {
+			command: "unknown",
+			pid: "unknown",
+			port,
+			user: "unknown"
+		};
+		const fields = lines[1].split(/\s+/);
+		return {
+			command: fields[0] ?? "unknown",
+			pid: fields[1] ?? "unknown",
+			port,
+			user: fields[2] ?? "unknown"
+		};
+	} catch {
+		return {
+			command: "unknown",
+			pid: "unknown",
+			port,
+			user: "unknown"
+		};
+	}
+}
+function isPortInUseError(error) {
+	return error instanceof Error && "code" in error && error.code === "EADDRINUSE";
+}
+async function exchangeCodeForToken(code, codeVerifier, callbackUrl) {
+	const clientId = POSTHOG_PROXY_CLIENT_ID;
+	const response = await axios.post(`${POSTHOG_OAUTH_URL}/oauth/token`, {
+		grant_type: "authorization_code",
+		code,
+		redirect_uri: callbackUrl,
+		client_id: clientId,
+		code_verifier: codeVerifier
+	}, { headers: {
+		"Content-Type": "application/json",
+		"User-Agent": WIZARD_USER_AGENT
+	} });
+	return OAuthTokenResponseSchema.parse(response.data);
+}
+async function performOAuthFlow(config) {
+	const clientId = POSTHOG_PROXY_CLIENT_ID;
+	const codeVerifier = generateCodeVerifier$1();
+	const codeChallenge = generateCodeChallenge$1(codeVerifier);
+	let shouldRetry = false;
+	do {
+		shouldRetry = false;
+		let lastProcessInfo = null;
+		for (const port of OAUTH_PORTS) {
+			const callbackUrl = getCallbackUrl(port);
+			const authUrl = new URL(`${POSTHOG_OAUTH_URL}/oauth/authorize`);
+			authUrl.searchParams.set("client_id", clientId);
+			authUrl.searchParams.set("redirect_uri", callbackUrl);
+			authUrl.searchParams.set("response_type", "code");
+			authUrl.searchParams.set("code_challenge", codeChallenge);
+			authUrl.searchParams.set("code_challenge_method", "S256");
+			authUrl.searchParams.set("scope", config.scopes.join(" "));
+			authUrl.searchParams.set("required_access_level", "project");
+			const signupUrl = new URL(`${POSTHOG_OAUTH_URL}/signup?next=${encodeURIComponent(authUrl.toString())}`);
+			const localSignupUrl = getLocalSignupUrl(port);
+			const localLoginUrl = getLocalLoginUrl(port);
+			const urlToOpen = config.signup ? localSignupUrl : localLoginUrl;
+			logToFile(`[oauth] attempting callback server on port ${port}`);
+			let server;
+			let waitForCallback;
+			try {
+				({server, waitForCallback} = await startCallbackServer(authUrl.toString(), signupUrl.toString(), port));
+			} catch (e) {
+				if (!isPortInUseError(e)) throw e;
+				lastProcessInfo = getPortProcessInfo(port);
+				continue;
+			}
+			logToFile("[oauth] callback server ready, showing login URL");
+			getUI().setLoginUrl(urlToOpen);
+			opn(urlToOpen, { wait: false }).catch(() => {});
+			const loginSpinner = getUI().spinner();
+			loginSpinner.start("Waiting for authorization...");
+			try {
+				const token = await exchangeCodeForToken(await Promise.race([waitForCallback(), new Promise((_, reject) => setTimeout(() => reject(/* @__PURE__ */ new Error("Authorization timed out")), OAUTH_TIMEOUT_MS))]), codeVerifier, callbackUrl);
+				server.close();
+				getUI().setLoginUrl(null);
+				loginSpinner.stop("Authorization complete!");
+				return token;
+			} catch (e) {
+				loginSpinner.stop("Authorization failed.");
+				server.close();
+				const error = e instanceof Error ? e : /* @__PURE__ */ new Error("Unknown error");
+				if (error.message.includes("timeout")) getUI().log.error("Authorization timed out. Please try again.");
+				else if (error.message.includes("access_denied")) getUI().log.info(`Authorization was cancelled.\n\nYou denied access to PostHog. To use the wizard, you need to authorize access to your PostHog account.\n\nYou can try again by re-running the wizard.`);
+				else getUI().log.error(`Authorization failed:\n\n${error.message}\n\nIf you think this is a bug in the PostHog wizard, please create an issue:\n${ISSUES_URL}`);
+				analytics.captureException(error, { step: "oauth_flow" });
+				await abort();
+				throw error;
+			}
+		}
+		if (!lastProcessInfo) throw new Error("No OAuth callback ports configured");
+		await getUI().showPortConflict(lastProcessInfo);
+		shouldRetry = true;
+	} while (shouldRetry);
+	throw new Error("OAuth port retry loop exited unexpectedly");
+}
+//#endregion
+//#region src/utils/provisioning.ts
+/**
+* Provisioning API client for creating new PostHog accounts.
+*
+* Uses the agentic provisioning API with PKCE auth:
+*   1. POST /account_requests  - create account, get auth code
+*   2. POST /oauth/token       - exchange code for tokens (with PKCE)
+*   3. POST /resources         - provision project, get API key
+*/
+const WIZARD_CLIENT_ID = POSTHOG_US_CLIENT_ID;
+const API_VERSION = "0.1d";
+const PROVISIONING_BASE_URL = "https://us.posthog.com";
+function generateCodeVerifier() {
+	return crypto.randomBytes(32).toString("base64url");
+}
+function generateCodeChallenge(verifier) {
+	return crypto.createHash("sha256").update(verifier).digest("base64url");
+}
+const AccountRequestResponseSchema = z.object({
+	id: z.string(),
+	type: z.enum([
+		"oauth",
+		"requires_auth",
+		"error"
+	]),
+	oauth: z.object({ code: z.string() }).optional(),
+	error: z.object({
+		code: z.string(),
+		message: z.string()
+	}).optional()
+});
+const TokenResponseSchema = z.object({
+	token_type: z.string(),
+	access_token: z.string(),
+	refresh_token: z.string(),
+	expires_in: z.number(),
+	account: z.object({ id: z.string() }).optional()
+});
+const ResourceResponseSchema = z.object({
+	status: z.string(),
+	id: z.string(),
+	service_id: z.string(),
+	complete: z.object({ access_configuration: z.object({
+		api_key: z.string(),
+		host: z.string(),
+		personal_api_key: z.string().optional()
+	}) }).optional()
+});
+/**
+* Create a new PostHog account and provision a project via the provisioning API.
+*
+* This is the "no browser" signup path: the wizard collects the email,
+* calls the provisioning API to create the account, and gets back
+* credentials without opening a browser.
+*/
+async function provisionNewAccount(email, name, region = "US", opts) {
+	const codeVerifier = generateCodeVerifier();
+	const codeChallenge = generateCodeChallenge(codeVerifier);
+	logToFile("[provisioning] starting account creation");
+	const accountRes = await axios.post(`${PROVISIONING_BASE_URL}/api/agentic/provisioning/account_requests`, {
+		id: crypto.randomUUID(),
+		email,
+		name,
+		client_id: WIZARD_CLIENT_ID,
+		code_challenge: codeChallenge,
+		code_challenge_method: "S256",
+		configuration: {
+			region,
+			...opts?.orgName ? { organization_name: opts.orgName } : {}
+		}
+	}, {
+		headers: {
+			"Content-Type": "application/json",
+			"API-Version": API_VERSION,
+			"User-Agent": WIZARD_USER_AGENT
+		},
+		timeout: 3e4
+	});
+	const accountData = AccountRequestResponseSchema.parse(accountRes.data);
+	if (accountData.type === "error") {
+		const msg = accountData.error?.message ?? "Account creation failed";
+		analytics.captureException(new Error(msg), {
+			step: "provisioning_account_request",
+			error_code: accountData.error?.code
+		});
+		throw new Error(msg);
+	}
+	if (accountData.type === "requires_auth") throw new Error("This email is already associated with a PostHog account. Please use the login flow instead.");
+	const code = accountData.oauth?.code;
+	if (!code) throw new Error("No authorization code received from account creation");
+	logToFile("[provisioning] account created, exchanging code for tokens");
+	const tokenRes = await axios.post(`${PROVISIONING_BASE_URL}/api/agentic/oauth/token`, new URLSearchParams({
+		grant_type: "authorization_code",
+		code,
+		code_verifier: codeVerifier
+	}).toString(), {
+		headers: {
+			"Content-Type": "application/x-www-form-urlencoded",
+			"API-Version": API_VERSION,
+			"User-Agent": WIZARD_USER_AGENT
+		},
+		timeout: 3e4
+	});
+	const tokenData = TokenResponseSchema.parse(tokenRes.data);
+	logToFile("[provisioning] tokens received, provisioning resources");
+	const resourceRes = await axios.post(`${PROVISIONING_BASE_URL}/api/agentic/provisioning/resources`, {
+		service_id: "analytics",
+		...opts?.projectName ? { configuration: { project_name: opts.projectName } } : {}
+	}, {
+		headers: {
+			"Content-Type": "application/json",
+			Authorization: `Bearer ${tokenData.access_token}`,
+			"API-Version": API_VERSION,
+			"User-Agent": WIZARD_USER_AGENT
+		},
+		timeout: 3e4
+	});
+	const resourceData = ResourceResponseSchema.parse(resourceRes.data);
+	if (resourceData.status !== "complete" || !resourceData.complete) throw new Error("Resource provisioning did not complete");
+	logToFile("[provisioning] resources provisioned successfully");
+	return {
+		accessToken: tokenData.access_token,
+		refreshToken: tokenData.refresh_token,
+		projectApiKey: resourceData.complete.access_configuration.api_key,
+		host: resourceData.complete.access_configuration.host,
+		personalApiKey: resourceData.complete.access_configuration.personal_api_key,
+		projectId: resourceData.id,
+		accountId: tokenData.account?.id ?? ""
+	};
+}
+//#endregion
+//#region src/lib/api.ts
+const ApiUserSchema = z.object({
+	distinct_id: z.string(),
+	organizations: z.array(z.object({ id: z.string().uuid() })),
+	team: z.object({
+		id: z.number(),
+		organization: z.string().uuid()
+	}),
+	organization: z.object({ id: z.string().uuid() })
+});
+const ApiProjectSchema = z.object({
+	id: z.number(),
+	uuid: z.string().uuid(),
+	organization: z.string().uuid(),
+	api_token: z.string(),
+	name: z.string()
+});
+var ApiError = class extends Error {
+	constructor(message, statusCode, endpoint) {
+		super(message);
+		this.statusCode = statusCode;
+		this.endpoint = endpoint;
+		this.name = "ApiError";
+	}
+};
+async function fetchUserData(accessToken, baseUrl) {
+	try {
+		const response = await axios.get(`${baseUrl}/api/users/@me/`, { headers: {
+			Authorization: `Bearer ${accessToken}`,
+			"User-Agent": WIZARD_USER_AGENT
+		} });
+		return ApiUserSchema.parse(response.data);
+	} catch (error) {
+		const apiError = handleApiError(error, "fetch user data");
+		analytics.captureException(apiError, {
+			endpoint: "/api/users/@me/",
+			baseUrl
+		});
+		throw apiError;
+	}
+}
+async function fetchProjectData(accessToken, projectId, baseUrl) {
+	try {
+		const response = await axios.get(`${baseUrl}/api/projects/${projectId}/`, { headers: {
+			Authorization: `Bearer ${accessToken}`,
+			"User-Agent": WIZARD_USER_AGENT
+		} });
+		return ApiProjectSchema.parse(response.data);
+	} catch (error) {
+		const apiError = handleApiError(error, "fetch project data");
+		analytics.captureException(apiError, {
+			endpoint: `/api/projects/${projectId}/`,
+			baseUrl,
+			projectId
+		});
+		throw apiError;
+	}
+}
+function handleApiError(error, operation) {
+	if (axios.isAxiosError(error)) {
+		const axiosError = error;
+		const status = axiosError.response?.status;
+		const detail = axiosError.response?.data?.detail;
+		const endpoint = axiosError.config?.url;
+		if (status === 401) return new ApiError(`Authentication failed while trying to ${operation}`, status, endpoint);
+		if (status === 403) return new ApiError(`Access denied while trying to ${operation}`, status, endpoint);
+		if (status === 404) return new ApiError(`Resource not found while trying to ${operation}`, status, endpoint);
+		return new ApiError(detail || `Failed to ${operation}`, status, endpoint);
+	}
+	if (error instanceof z.ZodError) return new ApiError(`Invalid response format while trying to ${operation}`);
+	return new ApiError(`Unexpected error while trying to ${operation}: ${error instanceof Error ? error.message : "Unknown error"}`);
+}
+//#endregion
+//#region src/utils/semver.ts
+/**
+* Version strings from package.json that are not semver ranges.
+* URLs, git refs, dist-tags, local paths, workspace protocol, npm aliases, etc.
+* These should be rejected early — we can't determine a clear version from them.
+*/
+function isNonSemverVersion(version) {
+	const v = version.trim();
+	return v === "" || v.startsWith("http://") || v.startsWith("https://") || v.startsWith("git+") || v.startsWith("git://") || v.startsWith("file:") || v.startsWith("npm:") || v.startsWith("workspace:") || v.startsWith("/") || v.includes("/");
+}
+/**
+* Creates a version bucket function for analytics.
+* Converts versions like "1.2.3" to "1.x" for grouping in analytics.
+*
+* @param minMajorVersion - Optional minimum major version threshold.
+*   Versions below this will be bucketed as "<{min}.0.0"
+*
+* @example
+* const getVersionBucket = createVersionBucket(); // no minimum
+* getVersionBucket("1.2.3") // "1.x"
+*
+* const getVersionBucket = createVersionBucket(11);
+* getVersionBucket("15.3.0") // "15.x"
+* getVersionBucket("10.0.0") // "<11.0.0"
+*/
+function createVersionBucket(minMajorVersion) {
+	return (version) => {
+		if (!version) return "none";
+		if (isNonSemverVersion(version)) return "unknown";
+		try {
+			const minVer = minVersion(version);
+			if (!minVer) return "invalid";
+			const majorVersion = major(minVer);
+			if (minMajorVersion !== void 0 && majorVersion < minMajorVersion) return `<${minMajorVersion}.0.0`;
+			return `${majorVersion}.x`;
+		} catch {
+			return "unknown";
+		}
+	};
+}
+//#endregion
+//#region src/utils/setup-utils.ts
+/** @deprecated Use wizardAbort() directly for new code. */
+async function abort(message, status) {
+	return wizardAbort({
+		message,
+		exitCode: status
+	});
+}
+const FREEMAIL_DOMAINS = new Set([
+	"gmail.com",
+	"googlemail.com",
+	"hotmail.com",
+	"outlook.com",
+	"yahoo.com",
+	"icloud.com",
+	"me.com",
+	"mail.com",
+	"protonmail.com",
+	"proton.me",
+	"live.com",
+	"aol.com",
+	"yandex.com",
+	"zoho.com",
+	"gmx.com",
+	"fastmail.com"
+]);
+function parseGitRemote() {
+	try {
+		const match = childProcess.execSync("git remote get-url origin", { stdio: [
+			"ignore",
+			"pipe",
+			"ignore"
+		] }).toString().trim().match(/[/:]([\w.-]+)\/([\w.-]+?)(?:\.git)?$/);
+		if (match) return {
+			org: match[1],
+			repo: match[2]
+		};
+	} catch {}
+	return null;
+}
+function detectOrgAndProject(email) {
+	const remote = parseGitRemote();
+	const projectName = remote?.repo || basename(process.cwd()) || void 0;
+	let orgName;
+	if (remote?.org) orgName = remote.org;
+	else {
+		const domain = email.split("@")[1]?.toLowerCase();
+		if (domain && !FREEMAIL_DOMAINS.has(domain)) orgName = domain.split(".")[0];
+	}
+	return {
+		orgName,
+		projectName
+	};
+}
+/**
+* Get package.json or abort the wizard if not found.
+* Only use where package.json is required (e.g., package install, overrides).
+* For detection/version-checks, use tryGetPackageJson() instead.
+*/
+async function getPackageDotJson({ installDir }) {
+	const packageJsonFileContents = await fs$1.promises.readFile(join(installDir, "package.json"), "utf8").catch(() => {
+		getUI().log.error("Could not find package.json. Make sure to run the wizard in the root of your app!");
+		return abort();
+	});
+	let packageJson = void 0;
+	try {
+		packageJson = JSON.parse(packageJsonFileContents);
+	} catch {
+		getUI().log.error(`Unable to parse your package.json. Make sure it has a valid format!`);
+		await abort();
+	}
+	return packageJson || {};
+}
+/**
+* Try to get package.json, returning null if it doesn't exist.
+* Use this for detection purposes where missing package.json is expected (e.g., Python projects).
+*/
+async function tryGetPackageJson({ installDir }) {
+	try {
+		const packageJsonFileContents = await fs$1.promises.readFile(join(installDir, "package.json"), "utf8");
+		return JSON.parse(packageJsonFileContents);
+	} catch {
+		return null;
+	}
+}
+async function updatePackageDotJson(packageDotJson, { installDir }) {
+	try {
+		await fs$1.promises.writeFile(join(installDir, "package.json"), JSON.stringify(packageDotJson, null, 2), {
+			encoding: "utf8",
+			flag: "w"
+		});
+	} catch {
+		getUI().log.error(`Unable to update your package.json.`);
+		await abort();
+	}
+}
+function isUsingTypeScript({ installDir }) {
+	try {
+		return fs$1.existsSync(join(installDir, "tsconfig.json"));
+	} catch {
+		return false;
+	}
+}
+/**
+* Get project data for the wizard via OAuth or CI API key.
+*/
+async function getOrAskForProjectData(_options) {
+	if (_options.ci && _options.apiKey) {
+		getUI().log.info("Using provided API key (CI mode - OAuth bypassed)");
+		const cloudRegion = await detectRegionFromToken(_options.apiKey);
+		const host = getHostFromRegion(cloudRegion);
+		const cloudUrl = getCloudUrlFromRegion(cloudRegion);
+		const projectData = _options.projectId != null ? await fetchProjectDataById(_options.apiKey, _options.projectId, cloudUrl) : await fetchProjectDataWithApiKey(_options.apiKey, cloudUrl);
+		return {
+			host,
+			projectApiKey: projectData.api_token,
+			accessToken: _options.apiKey,
+			projectId: projectData.id,
+			cloudRegion
+		};
+	}
+	const { host, projectApiKey, accessToken, projectId, cloudRegion } = await traceStep("login", () => askForWizardLogin({
+		signup: _options.signup,
+		email: _options.email,
+		region: _options.region
+	}));
+	if (!projectApiKey) {
+		const cloudUrl = getCloudUrlFromRegion(cloudRegion);
+		getUI().log.error(`Didn't receive a project token. This shouldn't happen :(
+
+Please let us know if you think this is a bug in the wizard:
+${ISSUES_URL}`);
+		getUI().log.info(`In the meantime, we'll add a dummy project token ("${DUMMY_PROJECT_API_KEY}") for you to replace later.
+You can find your project token here:
+${cloudUrl}/settings/project#variables`);
+	}
+	return {
+		accessToken,
+		host: host || DEFAULT_HOST_URL,
+		projectApiKey: projectApiKey || "_YOUR_POSTHOG_PROJECT_TOKEN_",
+		projectId,
+		cloudRegion
+	};
+}
+async function fetchProjectDataWithApiKey(apiKey, cloudUrl) {
+	const projectId = (await fetchUserData(apiKey, cloudUrl)).team?.id;
+	if (!projectId) throw new Error("Could not determine project ID from API key. Please ensure your API key has access to a project in this cloud region.");
+	return {
+		api_token: (await fetchProjectData(apiKey, projectId, cloudUrl)).api_token,
+		id: projectId
+	};
+}
+async function fetchProjectDataById(apiKey, projectId, cloudUrl) {
+	return {
+		api_token: (await fetchProjectData(apiKey, projectId, cloudUrl)).api_token,
+		id: projectId
+	};
+}
+async function askForWizardLogin(options) {
+	if (options.signup) return askForProvisioningSignup(options.email, options.region);
+	const tokenResponse = await performOAuthFlow({
+		scopes: [
+			"user:read",
+			"project:read",
+			"introspection",
+			"llm_gateway:read",
+			"dashboard:write",
+			"insight:write",
+			"query:read"
+		],
+		signup: false
+	});
+	const projectId = tokenResponse.scoped_teams?.[0];
+	if (projectId === void 0) {
+		const error = /* @__PURE__ */ new Error("No project access granted. Please authorize with project-level access.");
+		analytics.captureException(error, {
+			step: "wizard_login",
+			has_scoped_teams: !!tokenResponse.scoped_teams
+		});
+		getUI().log.error(error.message);
+		await abort();
+	}
+	const cloudRegion = await detectRegionFromToken(tokenResponse.access_token);
+	const cloudUrl = getCloudUrlFromRegion(cloudRegion);
+	const host = getHostFromRegion(cloudRegion);
+	const projectData = await fetchProjectData(tokenResponse.access_token, projectId, cloudUrl);
+	const userData = await fetchUserData(tokenResponse.access_token, cloudUrl);
+	const data = {
+		accessToken: tokenResponse.access_token,
+		projectApiKey: projectData.api_token,
+		host,
+		distinctId: userData.distinct_id,
+		projectId,
+		cloudRegion
+	};
+	getUI().log.success("Login complete.");
+	analytics.setTag("opened-wizard-link", true);
+	analytics.setDistinctId(data.distinctId);
+	return data;
+}
+async function askForProvisioningSignup(email, region) {
+	if (!email || !email.includes("@")) {
+		getUI().log.error("Email is required for signup. Use --email your@email.com with --signup.");
+		await abort();
+		throw new Error("unreachable");
+	}
+	const spinner = getUI().spinner();
+	spinner.start("Creating your PostHog account...");
+	try {
+		const provisionRegion = (region ?? "us").toUpperCase();
+		const { orgName, projectName } = detectOrgAndProject(email);
+		const result = await provisionNewAccount(email, "", provisionRegion, {
+			orgName,
+			projectName
+		});
+		spinner.stop("Account created!");
+		getUI().log.success("Welcome to PostHog!");
+		const host = result.host;
+		const cloudRegion = host.includes("eu.") ? "eu" : "us";
+		analytics.setTag("provisioning-signup", true);
+		return {
+			accessToken: result.accessToken,
+			projectApiKey: result.projectApiKey,
+			host,
+			distinctId: email,
+			projectId: parseInt(result.projectId, 10) || 0,
+			cloudRegion
+		};
+	} catch (error) {
+		spinner.stop("Account creation failed.");
+		const message = error instanceof Error ? error.message : "Unknown error";
+		if (message.includes("already associated")) {
+			getUI().log.info("This email already has a PostHog account. Switching to login flow...");
+			return askForWizardLogin({ signup: false });
+		}
+		getUI().log.error(`Failed to create account: ${message}`);
+		analytics.captureException(error instanceof Error ? error : new Error(message), { step: "provisioning_signup" });
+		await abort();
+		throw error;
+	}
+}
+//#endregion
+export { getCloudUrlFromRegion as a, createVersionBucket as i, isUsingTypeScript as n, getLlmGatewayUrlFromHost as o, tryGetPackageJson as r, detectAllPackageManagers as s, getOrAskForProjectData as t };
+
+//# sourceMappingURL=setup-utils-CdDnllRW.js.map