@posthog/wizard 2.79.1 → 2.80.1

package/dist/runners-ov3EXF1n.js

@@ -1,834 +0,0 @@
-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