@posthog/wizard 2.78.0 → 2.79.1

package/dist/runners-ov3EXF1n.js

@@ -0,0 +1,834 @@
+import { m as isGrantRevoked } from "./agent-interface-FkbaBJwz.js";
+import { n as ErrorCodes, t as emitWizardError } from "./emit-BSetXzDV.js";
+import { a as getLogFilePath, s as logToFile, v as runtimeEnv } from "./debug-kAHwWGg7.js";
+import { t as VERSION } from "./version-CHhJjz_H.js";
+import { a as getLocalDev, i as checkLocalServices, r as POSTHOG_LOCAL_URL } from "./local-dev-McsurOC-.js";
+import "./constants-DHCBSfnx.js";
+import "./wizard-session-2w4Ru-Wz.js";
+import { n as analytics } from "./analytics-DXK1gc12.js";
+import { t as classifyRunFailure } from "./errors-C2domSkK.js";
+import { t as LoggingUI } from "./logging-ui-Dza4D0MK.js";
+import { n as setUI, t as getUI } from "./ui-Q6-RvERF.js";
+import { n as registerShutdown, r as runCleanups } from "./wizard-abort-BPdv07np.js";
+import { r as currentCredentials } from "./oauth-session-DYM2Hrl2.js";
+import { d as authenticate, t as runProgramAgent, u as getAuditChecks } from "./run-agent-legacy-DOlM6DQu.js";
+import { at as maybeStampAiSdkDetected, i as isRunFailure, u as getProgramConfig } from "./mint-failure-u8xQKNOn.js";
+import { n as parseRetryAfter } from "./posthog-Bt0Aplb8.js";
+import { valid } from "semver";
+import { validate } from "uuid";
+import { basename, join, resolve } from "node:path";
+import { randomUUID } from "node:crypto";
+//#region src/lib/runners/resolve-no-telemetry.ts
+/**
+* `--no-telemetry` flips `telemetry: false` via yargs negation;
+* `POSTHOG_WIZARD_NO_TELEMETRY` is honoured separately so the env-var
+* form documented in the README keeps working.
+*/
+function resolveNoTelemetry(options) {
+	if (options.telemetry === false) return true;
+	const env = process.env.POSTHOG_WIZARD_NO_TELEMETRY;
+	if (env == null || env === "") return false;
+	const norm = env.toLowerCase();
+	return norm !== "0" && norm !== "false";
+}
+//#endregion
+//#region src/programs/task-stream/wizard-run-sync.ts
+const STATUS = {
+	pending: "created",
+	in_progress: "running",
+	completed: "completed",
+	failed: "failed",
+	skipped: "completed"
+};
+var RunTaskNames = class {
+	names = /* @__PURE__ */ new Map();
+	used = /* @__PURE__ */ new Set();
+	snapshot(items) {
+		if (items.length > 100) throw new Error("task limit exceeded (100)");
+		const occurrences = /* @__PURE__ */ new Map();
+		const ids = /* @__PURE__ */ new Set();
+		return items.map((item) => {
+			const subject = item.label.trim();
+			if (!subject) throw new Error("blank task name");
+			const rawStatus = item.sourceStatus ?? item.status;
+			const status = STATUS[rawStatus];
+			if (!Object.hasOwn(STATUS, rawStatus)) throw new Error("invalid task status");
+			const occurrence = (occurrences.get(subject) ?? 0) + 1;
+			occurrences.set(subject, occurrence);
+			const id = item.id ? JSON.stringify([item.source, item.id]) : JSON.stringify([subject, occurrence]);
+			if (ids.has(id)) throw new Error("duplicate task identity");
+			ids.add(id);
+			let name = this.names.get(id);
+			if (!name) {
+				name = subject.slice(0, 255);
+				for (let n = 2; this.used.has(name); n++) {
+					const suffix = ` (${n})`;
+					name = subject.slice(0, 255 - suffix.length) + suffix;
+				}
+				this.names.set(id, name);
+				this.used.add(name);
+			}
+			return {
+				name,
+				status
+			};
+		});
+	}
+};
+function createWizardRunSync(options) {
+	if (options.noTelemetry || options.mode === "ci") return;
+	if (options.mode === "headless" && options.assignedId === void 0) return;
+	return new WizardRunSync({
+		...options,
+		mode: options.assignedId !== void 0 ? "cloud" : "local"
+	});
+}
+var WizardRunSync = class {
+	names = new RunTaskNames();
+	tasksAbort = new AbortController();
+	reported = /* @__PURE__ */ new Set();
+	context;
+	queue = Promise.resolve();
+	lastBody;
+	stopped = false;
+	tasksDisabled = false;
+	authDisabled = false;
+	closing;
+	constructor(options) {
+		this.options = options;
+	}
+	capture(items) {
+		if (this.stopped || this.tasksDisabled || !items) return;
+		if (this.options.mode === "cloud" && !validate(this.options.assignedId ?? "")) {
+			this.tasksDisabled = true;
+			this.report("invalid cloud run assignment");
+			return;
+		}
+		const session = this.options.getSession();
+		if (session.runPhase === "idle") return;
+		if (!this.context) {
+			if (session.runPhase !== "running" || !session.credentials) return;
+			const { host, projectId } = session.credentials;
+			this.context = {
+				apiHost: host.appHost.replace(/\/$/, ""),
+				projectId,
+				programId: this.options.programId,
+				mode: this.options.mode,
+				id: this.options.assignedId
+			};
+			this.queue = this.initialize(session);
+		}
+		try {
+			const body = JSON.stringify({ tasks: this.names.snapshot(items) });
+			if (body === this.lastBody) return;
+			this.lastBody = body;
+			this.queue = this.queue.then(async () => {
+				if (this.tasksDisabled || this.tasksAbort.signal.aborted || !this.context?.id) return;
+				if (!await this.request("PUT", `${this.context.id}/tasks/`, body, this.tasksAbort.signal)) this.tasksDisabled = true;
+			});
+		} catch {
+			this.report("invalid task snapshot (names, statuses, identities or 100-task limit)");
+		}
+	}
+	shutdown(outcome, timeoutMs) {
+		if (this.closing) return this.closing;
+		this.stopped = true;
+		this.closing = this.finish(outcome, Math.max(0, timeoutMs));
+		return this.closing;
+	}
+	async initialize(session) {
+		const context = this.context;
+		if (!context || context.mode === "cloud") return;
+		const projectName = basename(resolve(session.installDir)).trim().slice(0, 255);
+		if (!projectName) {
+			this.tasksDisabled = true;
+			this.report("unsupported program or workspace configuration");
+			return;
+		}
+		const body = JSON.stringify({
+			program_id: context.programId,
+			environment: "local",
+			workspace: {
+				type: "local_folder",
+				project_name: projectName
+			},
+			...valid("2.79.1") ? { wizard_version: VERSION } : {},
+			idempotency_key: randomUUID()
+		});
+		const result = await this.request("POST", "", body, this.tasksAbort.signal);
+		if (result && typeof result === "object" && "id" in result && typeof result.id === "string" && validate(result.id)) context.id = result.id;
+		else {
+			this.tasksDisabled = true;
+			this.report("local creation failed or returned an invalid ID; creation was not retried");
+		}
+	}
+	credentials(creds = this.options.getSession().credentials) {
+		const context = this.context;
+		if (!context) return;
+		if (!creds || creds.host.appHost.replace(/\/$/, "") !== context.apiHost || creds.projectId !== context.projectId) {
+			this.report("execution credentials changed host or project");
+			return;
+		}
+		if (creds.missingScopes?.includes("wizard_run:write") || !creds.accessToken.startsWith("pha_")) {
+			this.authDisabled = true;
+			this.report("wizard_run:write OAuth grant required; authorize again");
+			return;
+		}
+		return creds;
+	}
+	async request(method, suffix, body, signal) {
+		const context = this.context;
+		if (!context || this.authDisabled || signal.aborted) return;
+		let refreshed = false;
+		let rateLimited = false;
+		const attempts = method === "POST" ? 1 : 3;
+		for (let attempt = 0; attempt < attempts && !signal.aborted; attempt++) {
+			let retryMs = 500 * 2 ** attempt;
+			try {
+				const creds = this.credentials();
+				if (!creds) return;
+				const { res, data, current } = await this.bounded(async (requestSignal) => {
+					const current = this.credentials(await currentCredentials(creds));
+					if (!current) throw new Error("credentials unavailable");
+					const res = await (this.options.fetchImpl ?? fetch)(`${context.apiHost}/api/projects/${context.projectId}/wizard/runs/${suffix}`, {
+						method,
+						body,
+						signal: requestSignal,
+						headers: {
+							Authorization: `Bearer ${current.accessToken}`,
+							"Content-Type": "application/json"
+						}
+					});
+					return {
+						res,
+						data: method === "POST" && (res.status === 200 || res.status === 201) ? await res.json() : void 0,
+						current
+					};
+				}, signal, 5e3);
+				if (method === "POST" && [200, 201].includes(res.status) || method === "PUT" && res.status === 204 || method === "PATCH" && res.status === 200) return data ?? true;
+				if (res.status === 401 && current.refreshToken && !isGrantRevoked() && !refreshed && method !== "POST") {
+					refreshed = true;
+					if ((await this.bounded(() => currentCredentials(current, true), signal, 5e3)).accessToken === current.accessToken) {
+						this.authDisabled = true;
+						this.report("OAuth refresh could not recover the grant; authorize again");
+						return;
+					}
+					continue;
+				}
+				if (res.status === 401 || res.status === 403) this.authDisabled = true;
+				if (res.status === 429 && !rateLimited) {
+					rateLimited = true;
+					retryMs = parseRetryAfter(res.headers.get("Retry-After"));
+				} else if (res.status < 500 || res.status >= 600) {
+					this.report(`${method} rejected (${res.status}); check assignment, grant and program configuration`);
+					return;
+				}
+			} catch {
+				if (signal.aborted) return;
+			}
+			if (attempt + 1 < attempts) try {
+				await this.sleep(retryMs, signal);
+			} catch {
+				return;
+			}
+		}
+		this.report(`${method} delivery exhausted`);
+	}
+	async finish(outcome, timeoutMs) {
+		const deadline = Date.now() + timeoutMs;
+		try {
+			await this.bounded(() => this.queue, new AbortController().signal, Math.floor(timeoutMs * .75));
+		} catch {
+			this.report("task drain timed out");
+		}
+		this.tasksAbort.abort();
+		if (this.context?.mode !== "local" || !this.context.id || this.authDisabled) return;
+		if (Date.now() >= deadline) {
+			this.report("terminal update budget exhausted");
+			return;
+		}
+		const finalAbort = new AbortController();
+		const timer = setTimeout(() => finalAbort.abort(), Math.max(0, deadline - Date.now()));
+		try {
+			await this.request("PATCH", `${this.context.id}/`, JSON.stringify({ status: outcome }), finalAbort.signal);
+		} finally {
+			clearTimeout(timer);
+			finalAbort.abort();
+		}
+	}
+	async bounded(operation, parent, ms) {
+		const controller = new AbortController();
+		const abort = () => controller.abort();
+		parent.addEventListener("abort", abort, { once: true });
+		if (parent.aborted) controller.abort();
+		const timer = setTimeout(abort, ms);
+		let onAbort = () => void 0;
+		const cancelled = new Promise((_, reject) => {
+			onAbort = () => reject(/* @__PURE__ */ new Error("request cancelled"));
+			controller.signal.addEventListener("abort", onAbort, { once: true });
+			if (controller.signal.aborted) onAbort();
+		});
+		try {
+			return await Promise.race([operation(controller.signal), cancelled]);
+		} finally {
+			clearTimeout(timer);
+			parent.removeEventListener("abort", abort);
+			controller.signal.removeEventListener("abort", onAbort);
+			controller.abort();
+		}
+	}
+	sleep(ms, signal) {
+		return new Promise((resolve) => {
+			const finish = () => {
+				clearTimeout(timer);
+				signal.removeEventListener("abort", finish);
+				resolve();
+			};
+			const timer = setTimeout(finish, ms);
+			signal.addEventListener("abort", finish, { once: true });
+			if (signal.aborted) finish();
+		});
+	}
+	report(message) {
+		if (this.reported.has(message)) return;
+		this.reported.add(message);
+		(this.options.onError ?? ((m) => logToFile(`[wizard-run-sync] ${m}`)))(message);
+	}
+};
+//#endregion
+//#region src/lib/runners/run-wizard.ts
+const WIZARD_VERSION = VERSION;
+/** The session a run step's agent runs in: scoped to the step's target dir
+* (e.g. a monorepo sub-app) with its own framework context, after any prep.
+* A step without `targetDir` runs in the live session, unchanged.
+* The frameworkContext copy is shallow and unfiltered — name keys per owning program. */
+async function prepareRunSession(step, live) {
+	const session = step.targetDir ? {
+		...live,
+		installDir: step.targetDir(live),
+		frameworkContext: { ...live.frameworkContext }
+	} : live;
+	if (step.onRunPrep) await step.onRunPrep(session);
+	return session;
+}
+/** Advance one step of a composed run to completion: the auth screen
+* authenticates (every later run reuses it); a step carrying its own `run`
+* thunk runs that agent in its dir and is recorded in `completedRuns`; the
+* host program's own run screen runs `config.run`; any other screen waits for
+* the user to satisfy `isComplete`. */
+async function advanceStep(step, store, config) {
+	if (step.screenId === "auth") {
+		await authenticate(store.session, config.id);
+		maybeStampAiSdkDetected(store.session);
+	} else if (step.run) {
+		await step.run(await prepareRunSession(step, store.session));
+		store.completeRunStep(step.id);
+	} else if (step.screenId === "run") await runProgramAgent(config, await prepareRunSession(step, store.session));
+	else if (step.isComplete) await store.waitUntil(step.isComplete);
+}
+/**
+* Run a full wizard program in the TUI. Handles the full lifecycle: start TUI,
+* build session, run detection, wait for intro gate, execute the
+* agent pipeline, wait for outro dismissal, then exit.
+*/
+function runWizard(config, options) {
+	let tui = null;
+	let taskStream = null;
+	let onSignal = null;
+	let exitInProgress = false;
+	let signalled = false;
+	let unregisterShutdown;
+	(async () => {
+		try {
+			const installDir = options.installDir || process.cwd();
+			const { startTUI } = await import("./start-tui-Bo2L0bar.js");
+			const { buildSession, RunPhase } = await import("./wizard-session-DGaUHOF3.js");
+			const { TaskStreamPush } = await import("./task-stream-Bw6JaLCX.js");
+			const { PostHogDestination } = await import("./posthog-CUgCEhH0.js");
+			const { createFileDestination } = await import("./file-C5JMsyR1.js");
+			const local = getLocalDev();
+			const localServicesError = await checkLocalServices({
+				...local,
+				localPosthog: local.localPosthog && !options.baseUrl
+			});
+			if (localServicesError) {
+				const { wizardAbort } = await import("./wizard-abort-Br1qMDNa.js");
+				await wizardAbort({ message: localServicesError });
+				return;
+			}
+			tui = startTUI(WIZARD_VERSION, config.id, () => onSignal?.());
+			const activeTui = tui;
+			const session = buildSession({
+				debug: options.debug,
+				localDev: options.localDev,
+				localMcp: options.localMcp,
+				localPosthog: options.localPosthog,
+				installDir,
+				ci: false,
+				signup: options.signup,
+				apiKey: options.apiKey,
+				projectId: options.projectId,
+				email: options.email,
+				baseUrl: options.baseUrl,
+				benchmark: options.benchmark,
+				yaraReport: options.yaraReport,
+				noTelemetry: resolveNoTelemetry(options),
+				harness: options.harness,
+				sequence: options.sequence,
+				model: options.model,
+				integrate: options.integrate,
+				captureAio: options.captureAio
+			});
+			session.programLabel = config.id;
+			if (options.skillId) session.skillId = options.skillId;
+			else if (config.skillId) session.skillId = config.skillId;
+			activeTui.store.session = session;
+			onSignal = () => {
+				if (signalled || exitInProgress) return;
+				signalled = true;
+				logToFile("[run-wizard] signal received, flushing task stream");
+				runCleanups();
+				if (activeTui.store.session.runPhase === RunPhase.Running) activeTui.store.setRunPhase(RunPhase.Error);
+				const teardown = () => {
+					unregisterShutdown?.();
+					if (onSignal) {
+						process.off("SIGINT", onSignal);
+						process.off("SIGTERM", onSignal);
+					}
+					try {
+						activeTui.unmount();
+					} catch {}
+					process.exit(130);
+				};
+				Promise.all([taskStream?.shutdown(2e3, "cancelled"), analytics.shutdown("cancelled")]).catch(() => logToFile("[run-wizard] cancellation shutdown failed")).finally(teardown);
+			};
+			process.on("SIGINT", onSignal);
+			process.on("SIGTERM", onSignal);
+			for (;;) {
+				await activeTui.store.runReadyHooks();
+				await activeTui.store.getGate("intro");
+				const active = activeTui.store.router.activeProgram;
+				if (active === config.id) break;
+				config = getProgramConfig(active);
+			}
+			const fileDestination = createFileDestination(options.taskStreamLog);
+			const destinations = [...session.noTelemetry ? [] : [new PostHogDestination({
+				getCredentials: () => activeTui.store.session.credentials,
+				onError: (err) => logToFile("[task-stream-push]", err.message)
+			})], ...fileDestination ? [fileDestination] : []];
+			const taskStreamEnabled = destinations.length > 0;
+			const activeStream = new TaskStreamPush({
+				store: activeTui.store,
+				getFlags: () => analytics.getCachedWizardFlags(),
+				programId: config.streamWorkflowId ?? config.id,
+				runSync: createWizardRunSync({
+					mode: "local",
+					programId: config.id,
+					assignedId: options.runId ?? runtimeEnv("POSTHOG_WIZARD_RUN_ID"),
+					noTelemetry: session.noTelemetry,
+					getSession: () => activeTui.store.session
+				}),
+				destinations,
+				eventPlanPath: config.eventPlanFile ? join(session.installDir, config.eventPlanFile) : void 0,
+				auditChecks: config.auditLedgerFile ? () => getAuditChecks(activeTui.store.session) : void 0,
+				enabled: taskStreamEnabled
+			});
+			taskStream = activeStream;
+			activeStream.attach();
+			unregisterShutdown = registerShutdown((outcome) => {
+				if (activeTui.store.session.runPhase === RunPhase.Running) activeTui.store.setRunPhase(RunPhase.Error);
+				return activeStream.shutdown(2e3, outcome);
+			});
+			await activeTui.store.getGate("integration-check");
+			await activeTui.store.getGate("health-check");
+			const skipAgent = config.run == null;
+			const shown = (s) => !s.show || s.show(activeTui.store.session);
+			if (config.steps.some((s) => s.run || s.targetDir)) for (const step of config.steps) {
+				if (step.screenId === "outro") break;
+				if (shown(step)) await advanceStep(step, activeTui.store, config);
+			}
+			else if (skipAgent) {
+				const { getOrAskForProjectData } = await import("./setup-utils-CVS86NYR.js");
+				const { projectApiKey, host, accessToken, projectId } = await getOrAskForProjectData({
+					signup: session.signup,
+					ci: session.ci,
+					apiKey: session.apiKey,
+					projectId: session.projectId,
+					baseUrl: session.baseUrl,
+					programId: config.id
+				});
+				activeTui.store.setCredentials({
+					accessToken,
+					projectApiKey,
+					host,
+					projectId
+				});
+			} else try {
+				await runProgramAgent(config, activeTui.store.session);
+			} catch (error) {
+				const failure = classifyRunFailure(error);
+				logToFile("[run-wizard] run failed, handing off:", error);
+				runCleanups();
+				analytics.captureException(error instanceof Error ? error : new Error(String(error)), { error_code: failure.code });
+				getUI().outroError({
+					kind: "error",
+					errorCode: failure.code,
+					message: failure.message
+				});
+			}
+			if (signalled) return;
+			const runFailed = isRunFailure(activeTui.store.session);
+			await activeStream.finishRun(runFailed ? "failed" : "completed");
+			await activeTui.store.waitUntil((s) => {
+				if (s.mintHandoff === "exit") return true;
+				if (skipAgent && !runFailed) return s.outroDismissed;
+				return s.skillsComplete;
+			});
+			exitInProgress = true;
+			await activeStream.shutdown(2e3);
+			unregisterShutdown?.();
+			process.off("SIGINT", onSignal);
+			process.off("SIGTERM", onSignal);
+			if (runFailed) await analytics.shutdown("error");
+			activeTui.unmount();
+			process.exit(runFailed ? 1 : 0);
+		} catch (err) {
+			if (signalled) return;
+			logToFile("[run-wizard] FATAL:", err);
+			runCleanups();
+			exitInProgress = true;
+			if (onSignal) {
+				process.off("SIGINT", onSignal);
+				process.off("SIGTERM", onSignal);
+			}
+			if (taskStream) try {
+				await taskStream.shutdown(2e3, "failed");
+			} catch {}
+			unregisterShutdown?.();
+			if (tui) try {
+				tui.unmount();
+			} catch {}
+			const failure = classifyRunFailure(err);
+			if (failure.coded) console.error(failure.message);
+			else console.error("Wizard run failed:", err);
+			console.error(`Full logs: ${getLogFilePath()}`);
+			emitWizardError({
+				code: failure.code,
+				message: failure.message
+			});
+			process.exit(1);
+		}
+	})();
+}
+//#endregion
+//#region src/programs/detect-map.ts
+const DETECT_CODES = {
+	"bad-directory": ErrorCodes.DetectBadDirectory,
+	"unsupported-platform": ErrorCodes.DetectUnsupportedPlatform,
+	"no-project-files": ErrorCodes.DetectNoProjectFiles,
+	"no-sources": ErrorCodes.DetectNoSources,
+	"no-package-json": ErrorCodes.DetectNoPackageJson,
+	"no-sdks": ErrorCodes.DetectNoSdks,
+	"missing-stripe": ErrorCodes.DetectMissingStripe,
+	"no-posthog-sdk": ErrorCodes.DetectNoPosthogSdk,
+	"no-posthog": ErrorCodes.DetectNoPosthogSdk,
+	"missing-posthog": ErrorCodes.DetectNoPosthogSdk
+};
+/**
+* `kind` arrives as a bare string — `frameworkContext.detectError` is untyped
+* storage — so the lookup can still miss. It falls back to a detect-group code
+* with `retry: 'no'`, never to `InternalUnhandled`: an unrecognized precondition
+* failure is still a precondition failure, and telling a sandbox to retry one
+* costs it the whole budget.
+*/
+function detectErrorCode(kind) {
+	return DETECT_CODES[kind] ?? ErrorCodes.DetectUnclassified;
+}
+//#endregion
+//#region src/lib/runners/run-non-interactive.ts
+/** User-facing label for a non-interactive mode. */
+function modeLabel(mode) {
+	return mode === "headless" ? "Headless" : "CI";
+}
+/** The credentials every non-interactive mode accepts, for error messages. */
+const API_KEY_HINT = "personal API key phx_xxx or wizard-app OAuth access token pha_xxx";
+/**
+* The single non-interactive validation layer: requires api-key and
+* install-dir. Every non-interactive entry point routes through
+* `runNonInteractive`, so this is the one place these checks live. UI must be
+* initialized before calling.
+*/
+function validateNonInteractiveOptions(options, mode) {
+	const label = modeLabel(mode);
+	if (!options.apiKey) {
+		getUI().intro("PostHog Wizard");
+		getUI().log.error(`${label} mode requires --api-key (${API_KEY_HINT})`);
+		emitWizardError({
+			code: ErrorCodes.ArgsMissingApiKey,
+			message: `${label} mode requires --api-key (${API_KEY_HINT})`
+		});
+		process.exit(1);
+	}
+	if (!options.installDir) {
+		getUI().intro("PostHog Wizard");
+		getUI().log.error(`${label} mode requires --install-dir (directory to install in)`);
+		emitWizardError({
+			code: ErrorCodes.ArgsMissingInstallDir,
+			message: `${label} mode requires --install-dir`
+		});
+		process.exit(1);
+	}
+}
+/**
+* Non-interactive pipeline shared by CI (`runWizardCI`) and headless
+* (`runWizardHeadless`) runs.
+*
+* Validates flags, builds a `ci:true` session, runs `config.ciPreRun` (or the
+* program's `onReady` hooks by default), executes `runProgramAgent`, and routes any
+* failure through `wizardAbort`. `wizardAbort` owns all exits — never add a
+* raw `process.exit` here.
+*
+* `mode` is the only difference between the two callers today (it sets the
+* analytics build tag and the user-facing label). Keeping it a parameter is
+* what lets CI and headless share this body now and diverge later — branch on
+* `mode` here, or stop sharing this function entirely.
+*/
+function runNonInteractive(config, options, mode) {
+	setUI(new LoggingUI());
+	validateNonInteractiveOptions(options, mode);
+	analytics.setTag("build", mode);
+	(async () => {
+		const path = await import("path");
+		const { buildSession, RunPhase, OutroKind } = await import("./wizard-session-DGaUHOF3.js");
+		const { readEnvironment } = await import("./environment-CwD8OPYj.js");
+		const { readApiKeyFromEnv } = await import("./env-api-key-CaWEDj_9.js");
+		const { configureLogFileFromEnvironment, logToFile } = await import("./debug-BuYHGr6_.js");
+		const { wizardAbort, WizardError } = await import("./wizard-abort-Br1qMDNa.js");
+		configureLogFileFromEnvironment();
+		const env = readEnvironment();
+		const apiKey = options.apiKey ?? readApiKeyFromEnv() ?? void 0;
+		const installDir = path.isAbsolute(options.installDir) ? options.installDir : path.join(process.cwd(), options.installDir);
+		const session = buildSession({
+			debug: options.debug,
+			installDir,
+			ci: true,
+			signup: options.signup,
+			localDev: options.localDev,
+			localMcp: options.localMcp,
+			localPosthog: options.localPosthog,
+			apiKey,
+			email: options.email,
+			projectId: options.projectId,
+			baseUrl: options.baseUrl,
+			benchmark: options.benchmark,
+			yaraReport: options.yaraReport,
+			noTelemetry: resolveNoTelemetry(options),
+			harness: options.harness,
+			sequence: options.sequence,
+			model: options.model,
+			captureAio: options.captureAio,
+			...env,
+			region: options.region ?? env.region
+		});
+		session.programLabel = config.id;
+		if (config.skillId) session.skillId = config.skillId;
+		const runDef = typeof config.run === "object" ? config.run : null;
+		getUI().intro("Welcome to the PostHog setup wizard");
+		getUI().log.info(`Running ${config.id} in ${modeLabel(mode)} mode`);
+		const localServicesError = await checkLocalServices({
+			...getLocalDev(),
+			localMcp: session.localMcp,
+			localPosthog: session.baseUrl === POSTHOG_LOCAL_URL
+		});
+		if (localServicesError) {
+			await wizardAbort({
+				code: ErrorCodes.EnvLocalServicesDown,
+				message: localServicesError
+			});
+			return;
+		}
+		let store = null;
+		let taskStream = null;
+		{
+			const { WizardStore } = await import("./store-BpqySPXm.js");
+			const { HeadlessUI } = await import("./headless-ui-CqI2gXlD.js");
+			const { TaskStreamPush, PostHogDestination, createFileDestination } = await import("./task-stream-Bw6JaLCX.js");
+			const fileDestination = createFileDestination(mode === "ci" ? options.taskStreamLog ?? "" : options.taskStreamLog);
+			const posthogDestination = mode === "headless" && !session.noTelemetry ? new PostHogDestination({
+				getCredentials: () => store?.session.credentials ?? session.credentials,
+				onError: (e) => logToFile("[headless task-stream]", e.message)
+			}) : null;
+			const destinations = [...posthogDestination ? [posthogDestination] : [], ...fileDestination ? [fileDestination] : []];
+			const headlessStore = new WizardStore(config.id);
+			store = headlessStore;
+			headlessStore.session = session;
+			setUI(new HeadlessUI(headlessStore));
+			taskStream = new TaskStreamPush({
+				store: headlessStore,
+				getFlags: () => analytics.getCachedWizardFlags(),
+				programId: config.streamWorkflowId ?? config.id,
+				runSync: createWizardRunSync({
+					mode,
+					programId: config.id,
+					assignedId: options.runId ?? runtimeEnv("POSTHOG_WIZARD_RUN_ID"),
+					noTelemetry: session.noTelemetry,
+					getSession: () => headlessStore.session
+				}),
+				destinations,
+				eventPlanPath: config.eventPlanFile ? join(session.installDir, config.eventPlanFile) : void 0,
+				auditChecks: config.auditLedgerFile ? () => getAuditChecks(headlessStore.session) : void 0,
+				enabled: destinations.length > 0
+			});
+			taskStream.attach();
+			if (fileDestination) logToFile(`[task-stream] ${mode} dump: ${fileDestination.path}`);
+		}
+		const settleStream = async (phase, outroData, outcome = phase === RunPhase.Completed ? "completed" : "failed") => {
+			if (!store || !taskStream) return;
+			if (outroData) store.setOutroData(outroData);
+			store.setRunPhase(phase);
+			await taskStream.shutdown(2e3, outcome);
+			process.off("SIGINT", onSignal);
+			process.off("SIGTERM", onSignal);
+			unregisterShutdown();
+		};
+		const unregisterShutdown = registerShutdown((outcome) => settleStream(RunPhase.Error, void 0, outcome));
+		let signalled = false;
+		const onSignal = () => {
+			if (signalled) return;
+			signalled = true;
+			runCleanups();
+			settleStream(RunPhase.Error, void 0, "cancelled").then(() => wizardAbort({ exitCode: 130 }));
+		};
+		process.on("SIGINT", onSignal);
+		process.on("SIGTERM", onSignal);
+		try {
+			if (mode === "ci") {
+				const { configureGatewayFromCIEnvironment } = await import("./agent-BEjARD2a.js");
+				configureGatewayFromCIEnvironment(Number(session.projectId), session.region ?? "us");
+			}
+			if (config.ciPreRun) await config.ciPreRun(session, { log: {
+				info: (message) => getUI().log.info(message),
+				warn: (message) => getUI().log.warn(message)
+			} });
+			else {
+				const readyCtx = {
+					session,
+					setFrameworkContext: (key, value) => {
+						session.frameworkContext[key] = value;
+					},
+					setFrameworkConfig: () => void 0,
+					setDetectedFramework: () => void 0,
+					setSkillId: (skillId) => {
+						session.skillId = skillId;
+					},
+					setUnsupportedVersion: (info) => {
+						session.unsupportedVersion = info;
+					},
+					addDiscoveredFeature: () => void 0,
+					setDetectionComplete: () => void 0,
+					setPosthogSdkDetected: (detected) => {
+						session.posthogSdkDetected = detected;
+					}
+				};
+				for (const step of config.steps) if (step.onReady) await step.onReady(readyCtx);
+				const detectError = session.frameworkContext.detectError;
+				if (session.unsupportedVersion) {
+					const { current, minimum, docsUrl } = session.unsupportedVersion;
+					const message = `Detected framework version ${current} is not supported. Minimum supported version is ${minimum}.`;
+					await settleStream(RunPhase.Error, {
+						kind: OutroKind.Error,
+						message,
+						errorCode: ErrorCodes.DetectUnsupportedVersion
+					});
+					await wizardAbort({
+						code: ErrorCodes.DetectUnsupportedVersion,
+						message: `${message}\n\nSee ${docsUrl}`,
+						error: new WizardError(`${config.id} unsupported framework version`, {
+							integration: config.id,
+							current,
+							minimum
+						}, ErrorCodes.DetectUnsupportedVersion)
+					});
+				}
+				if (detectError) {
+					const code = detectErrorCode(detectError.kind);
+					const detectKind = detectError.kind;
+					const detail = { ...detectError };
+					await settleStream(RunPhase.Error, {
+						kind: OutroKind.Error,
+						message: `Prerequisites not met: ${detectKind}`,
+						errorCode: code,
+						errorDetail: detail
+					});
+					await wizardAbort({
+						code,
+						detail,
+						message: `Prerequisites not met: ${detectKind}\n\nSee ${runDef?.docsUrl ?? "https://posthog.com/docs"}`,
+						error: new WizardError(`${config.id} prerequisites failed`, {
+							integration: config.id,
+							detect_error_kind: detectKind
+						}, code)
+					});
+				}
+			}
+			const { runProgramAgent } = await import("./run-agent-legacy-ChacZImU.js");
+			await runProgramAgent(config, session);
+			if (signalled) return;
+			await settleStream(RunPhase.Completed);
+		} catch (error) {
+			if (signalled) return;
+			const errorMessage = error instanceof Error ? error.message : String(error);
+			const errorStack = error instanceof Error && error.stack ? error.stack : void 0;
+			logToFile(`[${mode}] ERROR: ${errorMessage}`);
+			if (errorStack) logToFile(`[${mode}] STACK: ${errorStack}`);
+			const debugInfo = session.debug && errorStack ? `\n\n${errorStack}` : "";
+			const docsUrl = session.frameworkConfig?.metadata.docsUrl ?? runDef?.docsUrl ?? "https://posthog.com/docs";
+			const failure = classifyRunFailure(error);
+			await settleStream(RunPhase.Error, {
+				kind: OutroKind.Error,
+				message: errorMessage,
+				errorCode: failure.code
+			});
+			await wizardAbort({
+				code: failure.code,
+				message: failure.coded ? `${errorMessage}${debugInfo}` : `Something went wrong: ${errorMessage}\n\nYou can read the documentation at ${docsUrl} to set up manually.${debugInfo}`,
+				error
+			});
+		}
+	})().catch((error) => {
+		emitWizardError({
+			code: ErrorCodes.InternalUnhandled,
+			message: error instanceof Error ? error.message : String(error)
+		});
+		process.exit(1);
+	});
+}
+//#endregion
+//#region src/lib/runners/run-wizard-ci.ts
+/**
+* CI-mode entry point (`--ci`, dev/test builds). A thin shell over the shared
+* non-interactive pipeline — see `runNonInteractive`. Kept as its own function
+* so CI and headless (`runWizardHeadless`) can diverge without re-threading the
+* many callers that route here.
+*/
+function runWizardCI(config, options) {
+	runNonInteractive(config, options, "ci");
+}
+//#endregion
+//#region src/lib/runners/run-wizard-headless.ts
+/**
+* Headless entry point (the experimental published-build, non-interactive run
+* path; see @lib/headless-mode). A thin shell over the shared non-interactive
+* pipeline — see `runNonInteractive`. Today it behaves exactly like
+* `runWizardCI`; it exists as a separate function so headless can diverge later
+* (its own auth handling, telemetry, prompts, …) without touching CI or its
+* callers. Diverge by branching on the mode inside `runNonInteractive`, or by
+* giving this function its own body.
+*/
+function runWizardHeadless(config, options) {
+	runNonInteractive(config, options, "headless");
+}
+//#endregion
+export { runWizard as i, runWizardCI as n, API_KEY_HINT as r, runWizardHeadless as t };
+
+//# sourceMappingURL=runners-ov3EXF1n.js.map