create-opentray 0.19.0 → 0.20.0

package/dist/bin-sZB5nWq0.mjs

@@ -0,0 +1,2142 @@
+import { createRequire } from "node:module";
+import { createHash, randomBytes } from "node:crypto";
+import { access, mkdtemp, readFile, readdir, stat, writeFile } from "node:fs/promises";
+import { homedir, tmpdir } from "node:os";
+import { basename, dirname, extname, join, resolve, sep } from "node:path";
+import { autoBackground, buildExportPlan, buildScriptExport, collectProcessTreePids, composeAppIcon, compositionCacheKey, createPortDiscovery, deriveDefaultAppId, deriveDefaultAppName, detectImageFormat, detectPackageManager, ensureLoopbackNoProxy, findCreateEntry, foregroundStats, formatPosixCommandLine, listCreateEntries, listListeningPorts, materialize, openMaterializedApp, pinningHint, readResourceBytes, readWizardProjectIcon, resolveLaunchVector, scrapeService, startCommandRun, stopRunningApp, toProjectDirectoryName, tokenizeCommandLine, uninstallApp, uninstallWizardProject } from "@create-opentray/core";
+import { createServer } from "node:http";
+import { fileURLToPath } from "node:url";
+import { spawn } from "node:child_process";
+import { realpathSync } from "node:fs";
+import { consoleStreams, dispatchCli } from "@create-opentray/cli";
+//#region src/wizard.ts
+const DEFAULT_ICON_SCALE = .8;
+const DEFAULT_COMMAND_OPTIONS = {
+	cwd: "",
+	env: [],
+	argsMode: "string"
+};
+const createWizardSession = (options) => {
+	let state = "idle";
+	let services = [];
+	let selectedPort;
+	let run;
+	let discovery = createPortDiscovery({
+		baseline: /* @__PURE__ */ new Set(),
+		...options.listListeners === void 0 ? {} : { listListeners: () => options.listListeners() },
+		...options.verifyHttp === void 0 ? {} : { verifyHttp: options.verifyHttp }
+	});
+	let discoveryTimer;
+	let scrapeTimer;
+	let scraping = false;
+	let tempIconDir;
+	let currentIconPath;
+	let currentIconUrl;
+	let currentTrayIconPath;
+	let currentTrayIconUrl;
+	let trayIconIsSolid = false;
+	let iconCandidates = [];
+	let iconPort;
+	let currentTokens = [];
+	let currentCommand = "";
+	let scrapedTitle;
+	let interactive = true;
+	let resolvedVector;
+	let frozenForm;
+	let resolvedServicePort;
+	let resolvedTargetDir;
+	let frozenIconPath;
+	let frozenIconUrl;
+	let submitting = false;
+	let runAlive = false;
+	let commandOptions = { ...DEFAULT_COMMAND_OPTIONS };
+	let composeIconDir;
+	const iconCompositions = /* @__PURE__ */ new Map();
+	let iconBackground;
+	let iconScale;
+	const touched = {
+		appId: false,
+		appName: false,
+		iconPath: false,
+		iconBackground: false,
+		iconScale: false,
+		trayIconPath: false,
+		pm: false,
+		force: false,
+		showStartupTerminal: false,
+		showAddressBar: false,
+		imageSmoothingEnabled: false,
+		developerMode: false
+	};
+	let form = {
+		appId: "",
+		appName: "",
+		iconPath: "",
+		iconBackground: "transparent",
+		iconScale: DEFAULT_ICON_SCALE,
+		trayIconPath: "",
+		force: options.force === true,
+		showStartupTerminal: false,
+		showAddressBar: false,
+		imageSmoothingEnabled: true,
+		developerMode: false,
+		pm: options.packageManager ?? detectPackageManager([], process.env.npm_config_user_agent)
+	};
+	let result;
+	const emit = options.emit;
+	const setState = (next, reason) => {
+		state = next;
+		emit({
+			type: "state",
+			state: next,
+			...reason === void 0 ? {} : { reason }
+		});
+	};
+	const stopTimers = () => {
+		if (discoveryTimer !== void 0) {
+			clearInterval(discoveryTimer);
+			discoveryTimer = void 0;
+		}
+		if (scrapeTimer !== void 0) {
+			clearInterval(scrapeTimer);
+			scrapeTimer = void 0;
+		}
+	};
+	const publishServices = () => {
+		emit({
+			type: "services",
+			services: [...services],
+			selectedPort
+		});
+	};
+	/**
+	* Placeholder defaults: scrapes and derivations update the *suggestions*,
+	* never the user's values. Empty values mean "use the default".
+	*/
+	const currentDefaults = () => {
+		const effectiveAppId = form.appId.trim().length > 0 ? form.appId : deriveDefaultAppId(currentTokens);
+		return {
+			appId: deriveDefaultAppId(currentTokens),
+			appName: scrapedTitle ?? deriveDefaultAppName(currentTokens),
+			iconPath: currentIconPath ?? "",
+			targetDir: options.targetDir ?? join(homeDir, ".opentray", "create", toProjectDirectoryName(effectiveAppId))
+		};
+	};
+	const publishForm = () => {
+		emit({
+			type: "form",
+			values: form,
+			defaults: currentDefaults(),
+			targetDirExists
+		});
+	};
+	/** Track whether the resolved target directory is already occupied so the
+	*  UI can warn and offer the force toggle. */
+	let targetDirExists = false;
+	let targetDirProbe = 0;
+	const refreshTargetDirExists = () => {
+		const probe = ++targetDirProbe;
+		const target = currentDefaults().targetDir;
+		(async () => {
+			let occupied = false;
+			try {
+				occupied = (await stat(target)).isDirectory();
+			} catch {
+				occupied = false;
+			}
+			if (probe !== targetDirProbe) return;
+			if (occupied !== targetDirExists) {
+				targetDirExists = occupied;
+				publishForm();
+			}
+		})();
+	};
+	const scrapeOnce = async () => {
+		if (scraping || selectedPort === void 0 || state === "frozen" || state === "materializing") return;
+		scraping = true;
+		try {
+			const port = selectedPort;
+			const scraped = await (options.scrape ?? scrapeService)(port, tempIconDir === void 0 ? {} : { tempDir: tempIconDir });
+			if (selectedPort !== port) return;
+			const stateNow = state;
+			if (stateNow === "frozen" || stateNow === "materializing" || stateNow === "success") return;
+			iconCandidates = scraped.icons;
+			iconPort = port;
+			currentIconPath = scraped.icons[0]?.path;
+			currentIconUrl = scraped.icons[0]?.url;
+			if (scraped.title !== void 0) scrapedTitle = scraped.title;
+			emit({
+				type: "icons",
+				port,
+				icons: scraped.icons
+			});
+			emit({
+				type: "scrape",
+				port,
+				...scraped.title === void 0 ? {} : { title: scraped.title },
+				hasIcon: scraped.icons.length > 0
+			});
+			publishForm();
+		} finally {
+			scraping = false;
+		}
+	};
+	const startScrapePolling = () => {
+		if (scrapeTimer !== void 0) clearInterval(scrapeTimer);
+		scrapeOnce();
+		scrapeTimer = setInterval(() => {
+			scrapeOnce();
+		}, options.scrapeIntervalMs ?? 1500);
+	};
+	const selectDefaultService = () => {
+		if (selectedPort === void 0 && services.length > 0) selectedPort = services[0]?.port;
+		if (selectedPort !== void 0 && state === "running") {
+			setState("discovered");
+			startScrapePolling();
+		}
+	};
+	const startDiscoveryPolling = () => {
+		if (discoveryTimer !== void 0) clearInterval(discoveryTimer);
+		(async () => {
+			const found = await discovery.poll();
+			if (found.length > 0) {
+				const known = new Set(services.map((service) => service.port));
+				services = [...services, ...found.filter((s) => !known.has(s.port))];
+				selectDefaultService();
+				publishServices();
+			}
+		})();
+		discoveryTimer = setInterval(() => {
+			(async () => {
+				const found = await discovery.poll();
+				if (found.length > 0) {
+					const known = new Set(services.map((service) => service.port));
+					services = [...services, ...found.filter((s) => !known.has(s.port))];
+					selectDefaultService();
+					publishServices();
+				}
+			})();
+		}, options.pollIntervalMs ?? 1e3);
+	};
+	/** Default command cwd is the USER_HOME directory (owner round-10 law):
+	*  empty input means home, and relative paths resolve against home. */
+	const homeDir = options.homeDir ?? homedir();
+	const effectiveCwd = () => {
+		const custom = commandOptions.cwd.trim();
+		return custom.length > 0 ? resolve(homeDir, custom) : homeDir;
+	};
+	/** Build the env overlay from configured entries (empty keys skipped). */
+	const commandEnv = () => {
+		const env = {};
+		for (const entry of commandOptions.env) if (entry.key.trim().length > 0) env[entry.key.trim()] = entry.value;
+		return env;
+	};
+	const publishCommandOptions = () => {
+		emit({
+			type: "command-options",
+			options: commandOptions,
+			defaultCwd: homeDir
+		});
+	};
+	/** Stable dir for composed preview assets, created on demand. */
+	const ensureIconComposeDir = async () => {
+		if (composeIconDir === void 0) composeIconDir = await mkdtemp(join(tmpdir(), "create-opentray-compose-"));
+		return composeIconDir;
+	};
+	const session = {
+		get state() {
+			return state;
+		},
+		snapshot() {
+			return {
+				type: "snapshot",
+				state,
+				runAlive,
+				command: currentCommand,
+				commandOptions: {
+					...commandOptions,
+					env: [...commandOptions.env]
+				},
+				form: { ...form },
+				defaults: currentDefaults(),
+				targetDirExists,
+				services: [...services],
+				...selectedPort === void 0 ? {} : { selectedPort },
+				iconCandidates: [...iconCandidates],
+				...iconPort === void 0 ? {} : { iconsPort: iconPort },
+				interactive
+			};
+		},
+		get services() {
+			return services;
+		},
+		get selectedPort() {
+			return selectedPort;
+		},
+		get runAlive() {
+			return runAlive;
+		},
+		get iconCandidates() {
+			return iconCandidates;
+		},
+		iconCandidate(port, index) {
+			if (iconPort !== port) return;
+			return iconCandidates.find((icon) => icon.index === index);
+		},
+		replaceIconCandidates(port, icons) {
+			iconPort = port;
+			iconCandidates = icons;
+		},
+		selectTrayIconCandidate(port, index) {
+			if (state === "frozen" || state === "materializing" || state === "success") return false;
+			const candidate = session.iconCandidate(port, index);
+			if (candidate === void 0) return false;
+			touched.trayIconPath = true;
+			currentTrayIconPath = candidate.path;
+			currentTrayIconUrl = candidate.url;
+			trayIconIsSolid = candidate.variant !== "original";
+			form = {
+				...form,
+				trayIconPath: candidate.path
+			};
+			publishForm();
+			return true;
+		},
+		selectIconCandidate(port, index) {
+			if (state === "frozen" || state === "materializing" || state === "success") return false;
+			const candidate = session.iconCandidate(port, index);
+			if (candidate === void 0) return false;
+			touched.iconPath = true;
+			currentIconPath = candidate.path;
+			currentIconUrl = candidate.url;
+			if (!touched.trayIconPath) {
+				currentTrayIconPath = candidate.path;
+				currentTrayIconUrl = candidate.url;
+				trayIconIsSolid = candidate.variant !== "original";
+				form = {
+					...form,
+					iconPath: candidate.path,
+					trayIconPath: candidate.path
+				};
+			} else form = {
+				...form,
+				iconPath: candidate.path
+			};
+			publishForm();
+			return true;
+		},
+		get form() {
+			return form;
+		},
+		get result() {
+			return result;
+		},
+		async submitCommand(command) {
+			if (state !== "idle" && state !== "failed" && state !== "running" && state !== "discovered") throw new Error(`cannot submit a command while ${state}`);
+			if (submitting) throw new Error("a command submission is already in flight");
+			submitting = true;
+			const tokens = typeof command === "string" ? void 0 : command;
+			let tokenized;
+			if (tokens === void 0) {
+				tokenized = tokenizeCommandLine(command);
+				if (!tokenized.ok) {
+					submitting = false;
+					setState("failed", tokenized.error);
+					return;
+				}
+			} else if (tokens.length === 0 || tokens[0].trim().length === 0) {
+				submitting = false;
+				setState("failed", "数组模式至少需要程序元素（第一个参数）");
+				return;
+			}
+			await session.stop();
+			runAlive = false;
+			services = [];
+			selectedPort = void 0;
+			currentTokens = tokens ?? tokenized.tokens;
+			refreshTargetDirExists();
+			currentIconPath = void 0;
+			currentIconUrl = void 0;
+			currentTrayIconPath = void 0;
+			currentTrayIconUrl = void 0;
+			trayIconIsSolid = false;
+			iconCandidates = [];
+			touched.appId = false;
+			touched.appName = false;
+			touched.pm = false;
+			touched.trayIconPath = false;
+			form = {
+				appId: "",
+				appName: "",
+				iconPath: "",
+				iconBackground: iconBackground ?? "transparent",
+				iconScale: iconScale ?? .8,
+				...touched.force ? { force: form.force } : { force: options.force === true },
+				...touched.trayIconPath ? { trayIconPath: form.trayIconPath } : { trayIconPath: "" },
+				...touched.showStartupTerminal ? { showStartupTerminal: form.showStartupTerminal } : { showStartupTerminal: false },
+				...touched.showAddressBar ? { showAddressBar: form.showAddressBar } : { showAddressBar: false },
+				...touched.imageSmoothingEnabled ? { imageSmoothingEnabled: form.imageSmoothingEnabled } : { imageSmoothingEnabled: true },
+				...touched.developerMode ? { developerMode: form.developerMode } : { developerMode: false },
+				pm: options.packageManager ?? detectPackageManager([], process.env.npm_config_user_agent)
+			};
+			currentCommand = typeof command === "string" ? command : command.join(" ");
+			scrapedTitle = void 0;
+			emit({
+				type: "command-display",
+				command: currentCommand
+			});
+			tempIconDir = await mkdtemp(join(tmpdir(), "create-opentray-"));
+			const baseline = await (options.listListeners ?? (() => listListeningPorts(process.platform)))().catch(() => /* @__PURE__ */ new Set());
+			setState("running");
+			publishForm();
+			const spawnRun = options.spawnRun ?? startCommandRun;
+			const envOverlay = commandEnv();
+			run = await spawnRun({
+				tokens: currentTokens,
+				cwd: effectiveCwd(),
+				...Object.keys(envOverlay).length === 0 ? {} : { env: envOverlay },
+				onEvent: (event) => {
+					if (event.type === "stdout" || event.type === "stderr") {
+						emit({
+							type: "log",
+							stream: event.type,
+							chunk: event.chunk ?? ""
+						});
+						return;
+					}
+					if (event.type === "pty-ready") {
+						interactive = true;
+						emit({
+							type: "term-mode",
+							interactive: true
+						});
+						return;
+					}
+					if (event.type === "pty-unavailable") {
+						interactive = false;
+						emit({
+							type: "term-mode",
+							interactive: false,
+							...event.message === void 0 ? {} : { message: event.message }
+						});
+						return;
+					}
+					if (event.type === "spawn-error") {
+						stopTimers();
+						setState("failed", event.message ?? "spawn failed");
+						return;
+					}
+					if (event.type === "exit") {
+						runAlive = false;
+						stopTimers();
+						emit({
+							type: "run-status",
+							running: false,
+							...event.code === void 0 ? {} : { code: event.code }
+						});
+						if (state === "running" && services.length === 0) setState("failed", `command exited with ${event.code ?? "signal"} before any service appeared`);
+					}
+				}
+			});
+			submitting = false;
+			run.exited.then(async ({ code, spawnError }) => {
+				if (state === "running" && services.length === 0 && spawnError !== void 0) {
+					stopTimers();
+					setState("failed", spawnError);
+				}
+			});
+			discovery = createPortDiscovery({
+				baseline,
+				...options.listListeners === void 0 ? {} : { listListeners: () => options.listListeners() },
+				...options.verifyHttp === void 0 ? {} : { verifyHttp: options.verifyHttp },
+				...options.listPortOwners === void 0 ? {} : { listOwners: options.listPortOwners },
+				...run.pid === void 0 ? {} : { resolveOwnerPids: () => collectProcessTreePids(run?.pid ?? 0, options.platform ?? process.platform) }
+			});
+			runAlive = true;
+			emit({
+				type: "run-status",
+				running: true
+			});
+			startDiscoveryPolling();
+		},
+		prime(command) {
+			if (state === "frozen" || state === "materializing" || state === "success") return;
+			if (typeof command !== "string") {
+				if (command.length === 0 || command[0].trim().length === 0) return;
+				currentTokens = command;
+				currentCommand = command.join(" ");
+				emit({
+					type: "command-display",
+					command: currentCommand
+				});
+				refreshTargetDirExists();
+				publishForm();
+				return;
+			}
+			const tokenized = tokenizeCommandLine(command);
+			if (!tokenized.ok) return;
+			currentTokens = tokenized.tokens;
+			currentCommand = command;
+			emit({
+				type: "command-display",
+				command
+			});
+			refreshTargetDirExists();
+			publishForm();
+		},
+		get commandOptions() {
+			return commandOptions;
+		},
+		updateCommandOptions(patch) {
+			if (state === "frozen" || state === "materializing" || state === "success") return;
+			commandOptions = {
+				...commandOptions,
+				...patch
+			};
+			publishCommandOptions();
+		},
+		async analyzeIconForeground(foregroundPath) {
+			const stats = await foregroundStats(foregroundPath).catch(() => ({
+				luminance: void 0,
+				coverage: 0
+			}));
+			return {
+				...stats,
+				suggested: autoBackground(stats)
+			};
+		},
+		async composeIcon(options) {
+			if (state === "frozen" || state === "materializing" || state === "success") throw new Error("cannot compose while frozen");
+			const background = options.background ?? iconBackground ?? "transparent";
+			const scale = options.scale ?? iconScale ?? .8;
+			const composed = await composeAppIcon({
+				foregroundPath: options.foregroundPath,
+				background,
+				scale,
+				outputDir: await ensureIconComposeDir()
+			});
+			const composition = {
+				key: compositionCacheKey({
+					foregroundPath: options.foregroundPath,
+					background,
+					scale
+				}),
+				...composed
+			};
+			iconCompositions.set(composition.key, composition);
+			return composition;
+		},
+		trackIconComposition(composition) {
+			iconCompositions.set(composition.key, composition);
+		},
+		iconSourceRoots() {
+			return [...tempIconDir !== void 0 ? [tempIconDir] : [], ...composeIconDir !== void 0 ? [composeIconDir] : []];
+		},
+		iconComposition(key) {
+			return iconCompositions.get(key);
+		},
+		async saveIconUpload(bytes) {
+			const path = join(tempIconDir ?? (tempIconDir = await mkdtemp(join(tmpdir(), "create-opentray-"))), `upload-${createHash("sha256").update(bytes).digest("hex").slice(0, 16)}.bin`);
+			await writeFile(path, bytes);
+			return path;
+		},
+		selectService(port) {
+			if (state !== "discovered" && state !== "running") return;
+			if (!services.some((service) => service.port === port)) return;
+			selectedPort = port;
+			currentIconPath = void 0;
+			currentIconUrl = void 0;
+			publishServices();
+			if (state === "discovered") startScrapePolling();
+		},
+		updateForm(patch) {
+			if (state !== "idle" && state !== "running" && state !== "discovered" && state !== "failed") return;
+			if (patch.iconBackground !== void 0) iconBackground = patch.iconBackground;
+			if (patch.iconScale !== void 0) iconScale = patch.iconScale;
+			for (const key of Object.keys(patch)) if (patch[key] !== void 0 && patch[key] !== form[key]) {
+				touched[key] = true;
+				if (key === "trayIconPath") trayIconIsSolid = false;
+			}
+			form = {
+				...form,
+				...patch
+			};
+			publishForm();
+		},
+		/** Forward base64-encoded terminal keystroke bytes to the preview command. */
+		terminalInput(data) {
+			if (state !== "running" && state !== "discovered") return;
+			run?.write(data);
+		},
+		/** Forward terminal dimensions to the pseudo-terminal. */
+		terminalResize(size) {
+			if (state !== "running" && state !== "discovered") return;
+			run?.resize(size);
+		},
+		confirm() {
+			if (state !== "idle" && state !== "running" && state !== "discovered" && state !== "failed") throw new Error(`cannot confirm while ${state}`);
+			resolvedServicePort = selectedPort ?? 0;
+			resolvedTargetDir = currentDefaults().targetDir;
+			const defaults = currentDefaults();
+			let resolvedForm = {
+				...form,
+				appId: form.appId.trim().length > 0 ? form.appId : defaults.appId,
+				appName: form.appName.trim().length > 0 ? form.appName : defaults.appName
+			};
+			if (resolvedForm.iconPath.trim().length > 0) {
+				currentIconPath = resolvedForm.iconPath.trim();
+				currentIconUrl = void 0;
+			}
+			frozenIconPath = currentIconPath;
+			frozenIconUrl = currentIconUrl;
+			const resolvedTrayIconPath = resolvedForm.trayIconPath.trim().length > 0 ? resolvedForm.trayIconPath.trim() : resolvedForm.iconPath.trim().length > 0 ? resolvedForm.iconPath.trim() : currentIconPath ?? "";
+			resolvedForm = {
+				...resolvedForm,
+				trayIconPath: resolvedTrayIconPath
+			};
+			currentTrayIconPath = resolvedTrayIconPath;
+			form = resolvedForm;
+			stopTimers();
+			frozenForm = { ...form };
+			setState("frozen");
+			publishForm();
+		},
+		cancel() {
+			if (state !== "frozen") throw new Error(`cannot cancel while ${state}`);
+			frozenForm = void 0;
+			frozenIconPath = void 0;
+			frozenIconUrl = void 0;
+			resolvedServicePort = void 0;
+			resolvedTargetDir = void 0;
+			setState(selectedPort === void 0 ? "running" : "discovered");
+			publishForm();
+			if (runAlive && discovery !== void 0) startDiscoveryPolling();
+		},
+		async exportFrozen(exportOptions) {
+			const frozen = frozenForm;
+			if (frozen === void 0) return {
+				ok: false,
+				code: "state_error",
+				message: "share requires a confirmed (frozen) parameter set"
+			};
+			if (currentTokens.length === 0) return {
+				ok: false,
+				code: "state_error",
+				message: "no command recorded"
+			};
+			let vector;
+			try {
+				vector = await (options.resolveVector ?? resolveLaunchVector)({
+					tokens: currentTokens,
+					cwd: effectiveCwd()
+				});
+			} catch (error) {
+				return {
+					ok: false,
+					code: "resolve_failed",
+					message: `failed to resolve the launch vector: ${error instanceof Error ? error.message : String(error)}`
+				};
+			}
+			const envOverlay = commandEnv();
+			const env = Object.keys(envOverlay).length > 0 ? envOverlay : vector.env;
+			const embedded = [];
+			const iconRef = async (path, url, flag) => {
+				if (path === void 0 || path.trim().length === 0) return { mode: "none" };
+				const hasUrl = url !== void 0 && /^https?:\/\//u.test(url);
+				if (!(exportOptions.inlineIcon ?? !hasUrl)) {
+					if (hasUrl) return {
+						ref: {
+							path: "icon.png",
+							format: "png",
+							sha256: "",
+							source: {
+								kind: "http",
+								ref: url
+							}
+						},
+						mode: "url"
+					};
+					return {
+						ref: {
+							path: basename(path),
+							format: "png",
+							sha256: "",
+							source: {
+								kind: "file",
+								ref: path
+							}
+						},
+						mode: "local"
+					};
+				}
+				try {
+					const bytes = new Uint8Array(await readFile(path));
+					const format = detectImageFormat(bytes);
+					if (format === void 0) return { mode: "none" };
+					embedded.push({
+						flag,
+						filename: basename(path),
+						bytes
+					});
+					return {
+						ref: {
+							path: basename(path),
+							format,
+							sha256: createHash("sha256").update(bytes).digest("hex"),
+							source: {
+								kind: "file",
+								ref: path
+							}
+						},
+						mode: "embedded"
+					};
+				} catch {
+					return { mode: "none" };
+				}
+			};
+			const appIconSource = frozenIconPath ?? currentIconPath;
+			const appIconUrl = frozenIconUrl ?? currentIconUrl;
+			const trayIconSource = currentTrayIconPath;
+			const trayIconUrl = currentTrayIconUrl;
+			const appIconRef = await iconRef(appIconSource, appIconUrl, "app-icon");
+			const appIcon = appIconRef.ref;
+			const trayIcon = (trayIconSource !== void 0 && trayIconSource !== appIconSource ? await iconRef(trayIconSource, trayIconUrl, "tray-icon") : {
+				ref: void 0,
+				mode: "none"
+			}).ref;
+			const config = {
+				schemaVersion: 1,
+				appId: frozen.appId,
+				appName: frozen.appName,
+				command: {
+					executable: vector.command,
+					args: [...vector.args],
+					cwd: vector.cwd,
+					...env === void 0 ? {} : { env }
+				},
+				packageManager: frozen.pm,
+				icons: {
+					imageSmoothingEnabled: frozen.imageSmoothingEnabled !== false,
+					background: frozen.iconBackground ?? "transparent",
+					scale: frozen.iconScale ?? .8,
+					...trayIconIsSolid === true ? { trayTemplate: true } : {},
+					...appIcon === void 0 ? {} : { appIcon },
+					...trayIcon === void 0 ? {} : { trayIcon }
+				},
+				window: {
+					width: 1200,
+					height: 800
+				},
+				developerMode: frozen.developerMode === true
+			};
+			if (Object.keys(config.command.env ?? {}).length > 0 && exportOptions.acknowledgeEnv !== true) return {
+				ok: false,
+				code: "env_ack_required",
+				message: "environment entries present; acknowledgement required"
+			};
+			if (exportOptions.format === "command") {
+				const plan = buildExportPlan({
+					config,
+					embeddedResources: embedded,
+					forceCopy: exportOptions.forceCopy === true
+				});
+				if (!plan.ok) return {
+					ok: false,
+					code: "export_unsafe",
+					message: plan.error.message
+				};
+				if (plan.value.directCommand === null) return {
+					ok: false,
+					code: "export_unsafe",
+					message: plan.value.directCommandBlockedReason ?? "direct copy requires force-copy"
+				};
+				return {
+					ok: true,
+					kind: "command",
+					command: formatPosixCommandLine(plan.value.directCommand.command)
+				};
+			}
+			const script = buildScriptExport({
+				config,
+				embeddedResources: embedded
+			}, exportOptions.format === "sh" ? "sh" : "powershell");
+			if (!script.ok) return {
+				ok: false,
+				code: "export_unsafe",
+				message: script.error.message
+			};
+			const iconReference = appIconUrl !== void 0 && /^https?:\/\//u.test(appIconUrl) ? "url" : appIconSource !== void 0 && appIconSource.trim().length > 0 ? "local" : "none";
+			return {
+				ok: true,
+				kind: "script",
+				filename: script.value.filename,
+				content: script.value.content,
+				commandLine: script.value.commandLine,
+				requiresEnvAcknowledgement: script.value.requiresEnvAcknowledgement,
+				iconSharedAs: appIconRef.mode,
+				iconReference
+			};
+		},
+		async create() {
+			if (state !== "frozen") throw new Error(`cannot create while ${state}`);
+			const frozen = frozenForm ?? form;
+			if (currentTokens.length === 0) throw new Error("no command recorded");
+			setState("materializing");
+			if (run !== void 0) {
+				await run.kill();
+				run = void 0;
+			}
+			try {
+				resolvedVector = await (options.resolveVector ?? resolveLaunchVector)({
+					tokens: currentTokens,
+					cwd: effectiveCwd()
+				});
+				const envOverlay = commandEnv();
+				if (Object.keys(envOverlay).length > 0) resolvedVector = {
+					...resolvedVector,
+					env: envOverlay
+				};
+			} catch (error) {
+				setState("failed", error instanceof Error ? error.message : String(error));
+				return;
+			}
+			try {
+				result = await materialize({
+					config: {
+						schemaVersion: 1,
+						appId: frozen.appId,
+						appName: frozen.appName,
+						command: resolvedVector,
+						service: { port: resolvedServicePort ?? 0 },
+						window: {
+							width: 1200,
+							height: 800
+						},
+						...frozen.developerMode === true ? { developerMode: true } : {}
+					},
+					targetDir: resolvedTargetDir ?? currentDefaults().targetDir,
+					dependencyRange: options.dependencyRange,
+					iconSourcePath: frozenIconPath ?? currentIconPath,
+					...frozen.iconBackground === void 0 ? {} : { iconBackground: frozen.iconBackground },
+					...frozen.iconScale === void 0 ? {} : { iconScale: frozen.iconScale },
+					...currentTrayIconPath === void 0 ? {} : { trayIconSourcePath: currentTrayIconPath },
+					...trayIconIsSolid ? { trayIconIsSolid: true } : {},
+					shell: {
+						showTerminal: frozen.showStartupTerminal,
+						showAddressBar: frozen.showAddressBar
+					},
+					...frozen.imageSmoothingEnabled === false ? { imageSmoothingEnabled: false } : {},
+					...frozen.developerMode === true ? { developerMode: true } : {},
+					packageManager: frozen.pm,
+					skipInstall: options.skipInstall,
+					force: frozen.force
+				}, {
+					log: (event) => {
+						if (event.type === "step") {
+							emit({
+								type: "materialize-step",
+								step: event.step,
+								message: event.message
+							});
+							return;
+						}
+						emit({
+							type: "materialize-log",
+							message: event.message
+						});
+					},
+					...options.platform === void 0 ? {} : { platform: options.platform },
+					...options.materializeContext ?? {}
+				});
+				setState("success");
+				emit({
+					type: "success",
+					projectDir: result.projectDir,
+					pinHint: pinningHint()
+				});
+			} catch (error) {
+				const message = error instanceof Error ? error.message : String(error);
+				const occupied = message.includes("target directory is not empty");
+				setState("failed", occupied ? `${message}；可在「高级选项」中开启 强制覆盖 后重试` : message);
+			}
+		},
+		async stop() {
+			stopTimers();
+			discovery.stop();
+			if (run !== void 0) {
+				await run.kill();
+				run = void 0;
+			}
+		}
+	};
+	publishCommandOptions();
+	return session;
+};
+//#endregion
+//#region src/workbench-api.ts
+const exists = async (path) => {
+	try {
+		await access(path);
+		return true;
+	} catch {
+		return false;
+	}
+};
+const moduleDirectory = dirname(fileURLToPath(import.meta.url));
+/** Resolve the packaged skill root served to the WebUI help center. */
+const resolveSkillRoot = async () => {
+	const candidates = [
+		join(moduleDirectory, "skill"),
+		join(moduleDirectory, "..", "..", "skill"),
+		join(moduleDirectory, "..", "skill")
+	];
+	for (const candidate of candidates) try {
+		await readdir(candidate);
+		return resolve(candidate);
+	} catch {}
+};
+const SKILL_PATH_PATTERN = /^(?!-_)[A-Za-z0-9._-]+(?:\/(?!_)[A-Za-z0-9._-]+)*$/u;
+const containedSkillPath = (logical) => {
+	if (!SKILL_PATH_PATTERN.test(logical) || logical.includes("..") || logical.includes("\0")) return;
+	return logical;
+};
+/**
+* Handle one workbench API request. Returns undefined when the pathname is
+* not a workbench route (the caller falls through to its own handling).
+*/
+const handleWorkbenchApi = async (request) => {
+	const { pathname } = request;
+	if (pathname === "/api/apps" && request.method === "GET") {
+		const entries = await listCreateEntries();
+		return {
+			status: 200,
+			body: await Promise.all(entries.map(async (entry) => {
+				if (entry.source === "wizard") {
+					const projectDir = entry.dir;
+					return {
+						key: entry.key,
+						source: "wizard",
+						appId: entry.config?.appId,
+						appName: entry.config?.appName,
+						status: "healthy",
+						registrationDir: entry.dir,
+						payloadPath: entry.dir,
+						projectDir,
+						isLink: false,
+						hasEnv: entry.config !== void 0 && Object.keys(entry.config.command.env ?? {}).length > 0,
+						hasIcon: await exists(join(projectDir, "app-icon", "app-icon.png")),
+						...entry.config === void 0 ? { error: {
+							code: "invalid_config",
+							message: "unreadable wizard project config"
+						} } : {}
+					};
+				}
+				const projectDir = entry.record.payloadPath ?? entry.record.appDir;
+				return {
+					key: entry.key,
+					source: "registered",
+					appId: entry.record.config?.appId,
+					appName: entry.record.config?.appName,
+					status: entry.record.status,
+					registrationDir: entry.record.dir,
+					payloadPath: entry.record.payloadPath,
+					projectDir,
+					isLink: entry.record.isLink,
+					hasEnv: entry.record.config !== void 0 && Object.keys(entry.record.config.command.env ?? {}).length > 0,
+					hasIcon: await exists(join(projectDir, "app-icon", "app-icon.png")),
+					...entry.record.error === void 0 ? {} : { error: {
+						code: entry.record.error.code,
+						message: entry.record.error.message
+					} }
+				};
+			}))
+		};
+	}
+	const iconMatch = /^\/api\/apps\/([^/]+)\/icon$/.exec(pathname);
+	if (iconMatch !== null && request.method === "GET") {
+		const key = decodeURIComponent(iconMatch[1]);
+		const entry = await findCreateEntry(key);
+		if (entry === void 0) return {
+			status: 404,
+			body: {
+				code: "not_found",
+				message: `no application at key ${key}`
+			}
+		};
+		const projectDir = entry.source === "wizard" ? entry.dir : entry.record.payloadPath;
+		if (projectDir === void 0) return {
+			status: 404,
+			body: {
+				code: "missing_payload",
+				message: "application payload is unavailable"
+			}
+		};
+		try {
+			const bytes = new Uint8Array(await readFile(join(projectDir, "app-icon", "app-icon.png")));
+			return {
+				status: 200,
+				body: { dataUrl: `data:image/png;base64,${Buffer.from(bytes).toString("base64")}` }
+			};
+		} catch {
+			return {
+				status: 404,
+				body: {
+					code: "not_found",
+					message: "no app icon asset"
+				}
+			};
+		}
+	}
+	const readMatch = /^\/api\/apps\/([^/]+)\/config$/.exec(pathname);
+	if (readMatch !== null && request.method === "GET") {
+		const key = decodeURIComponent(readMatch[1]);
+		const entry = await findCreateEntry(key);
+		if (entry === void 0) return {
+			status: 404,
+			body: {
+				code: "not_found",
+				message: `no application at key ${key}`
+			}
+		};
+		if (entry.source === "wizard") {
+			if (entry.config === void 0) return {
+				status: 500,
+				body: {
+					code: "invalid_config",
+					message: "unreadable wizard project config"
+				}
+			};
+			return {
+				status: 200,
+				body: {
+					schemaVersion: 1,
+					appId: entry.config.appId,
+					appName: entry.config.appName,
+					command: {
+						executable: entry.config.command.executable,
+						args: [...entry.config.command.args],
+						cwd: entry.config.command.cwd,
+						...entry.config.command.env === void 0 ? {} : { env: { ...entry.config.command.env } }
+					},
+					packageManager: entry.config.packageManager,
+					icons: {
+						imageSmoothingEnabled: true,
+						background: "transparent",
+						scale: .8
+					},
+					window: entry.config.window,
+					developerMode: entry.config.developerMode
+				}
+			};
+		}
+		if (entry.record.config === void 0) return {
+			status: 500,
+			body: {
+				code: "invalid_config",
+				message: "unreadable registration"
+			}
+		};
+		return {
+			status: 200,
+			body: entry.record.config
+		};
+	}
+	const openMatch = /^\/api\/apps\/([^/]+)\/open$/.exec(pathname);
+	if (openMatch !== null && request.method === "POST") {
+		const key = decodeURIComponent(openMatch[1]);
+		const entry = await findCreateEntry(key);
+		if (entry === void 0) return {
+			status: 404,
+			body: {
+				code: "not_found",
+				message: `no application at key ${key}`
+			}
+		};
+		const projectDir = entry.source === "wizard" ? entry.dir : entry.record.payloadPath;
+		if (projectDir === void 0) return {
+			status: 409,
+			body: {
+				code: "missing_payload",
+				message: "application payload is unavailable"
+			}
+		};
+		const opened = await openMaterializedApp({
+			projectDir,
+			bundlePath: void 0
+		});
+		return {
+			status: opened.ok ? 200 : 500,
+			body: opened
+		};
+	}
+	const uninstallMatch = /^\/api\/apps\/([^/]+)\/uninstall$/.exec(pathname);
+	if (uninstallMatch !== null && request.method === "POST") {
+		const key = decodeURIComponent(uninstallMatch[1]);
+		const entry = await findCreateEntry(key);
+		if (entry === void 0) return {
+			status: 404,
+			body: {
+				code: "not_found",
+				message: `no application at key ${key}`
+			}
+		};
+		if (entry.source === "wizard") {
+			const result = await uninstallWizardProject({
+				key,
+				stopRunning: request.body.stopRunning === true
+			});
+			if (!result.ok) return {
+				status: result.error.code === "not_found" ? 404 : result.error.code === "app_running" ? 409 : 500,
+				body: result.error
+			};
+			return {
+				status: 200,
+				body: result.value
+			};
+		}
+		const appId = entry?.source === "registered" && entry.record.config !== void 0 ? entry.record.config.appId : typeof request.body.appId === "string" ? request.body.appId : void 0;
+		if (appId === void 0) return {
+			status: 400,
+			body: {
+				code: "invalid_config",
+				message: "appId is required"
+			}
+		};
+		const result = await uninstallApp({
+			appId,
+			stopRunning: request.body.stopRunning === true,
+			purgeTarget: request.body.purgeTarget === true
+		});
+		if (!result.ok) return {
+			status: result.error.code === "not_found" ? 404 : result.error.code === "app_running" ? 409 : 500,
+			body: result.error
+		};
+		return {
+			status: 200,
+			body: result.value
+		};
+	}
+	if (/^\/api\/apps\/([^/]+)\/stop$/.exec(pathname) !== null && request.method === "POST") {
+		const appId = typeof request.body.appId === "string" ? request.body.appId : void 0;
+		if (appId === void 0) return {
+			status: 400,
+			body: {
+				code: "invalid_config",
+				message: "appId is required"
+			}
+		};
+		const result = await stopRunningApp({ appId });
+		if (!result.ok) return {
+			status: 500,
+			body: result.error
+		};
+		return {
+			status: 200,
+			body: result.value
+		};
+	}
+	const exportMatch = /^\/api\/apps\/([^/]+)\/export$/.exec(pathname);
+	if (exportMatch !== null && request.method === "POST") {
+		const key = decodeURIComponent(exportMatch[1]);
+		const entry = await findCreateEntry(key);
+		if (entry === void 0) return {
+			status: 404,
+			body: {
+				code: "not_found",
+				message: `no application at key ${key}`
+			}
+		};
+		let config;
+		const embedded = [];
+		let iconSharedAs = "none";
+		let iconReference = "none";
+		const inlineIcon = request.body.inlineIcon;
+		if (entry.source === "wizard") {
+			if (entry.config === void 0) return {
+				status: 500,
+				body: {
+					code: "invalid_config",
+					message: "unreadable wizard project config"
+				}
+			};
+			const icon = await readWizardProjectIcon(entry.dir);
+			config = {
+				schemaVersion: 1,
+				appId: entry.config.appId,
+				appName: entry.config.appName,
+				command: {
+					executable: entry.config.command.executable,
+					args: [...entry.config.command.args],
+					cwd: entry.config.command.cwd,
+					...entry.config.command.env === void 0 ? {} : { env: { ...entry.config.command.env } }
+				},
+				packageManager: entry.config.packageManager,
+				icons: {
+					imageSmoothingEnabled: true,
+					background: "transparent",
+					scale: .8,
+					...icon === void 0 ? {} : { appIcon: {
+						path: "app-icon.png",
+						format: "png",
+						sha256: icon.sha256,
+						source: {
+							kind: "file",
+							ref: icon.path
+						}
+					} }
+				},
+				window: entry.config.window,
+				developerMode: entry.config.developerMode
+			};
+			if (icon !== void 0) {
+				iconReference = "local";
+				if (inlineIcon === false) {
+					config = {
+						...config,
+						icons: {
+							...config.icons,
+							appIcon: {
+								path: "app-icon.png",
+								format: "png",
+								sha256: "",
+								source: {
+									kind: "file",
+									ref: icon.path
+								}
+							}
+						}
+					};
+					iconSharedAs = "local";
+				} else {
+					embedded.push({
+						flag: "app-icon",
+						filename: "app-icon.png",
+						bytes: icon.bytes
+					});
+					iconSharedAs = "embedded";
+				}
+			}
+		} else {
+			if (entry.record.config === void 0) return {
+				status: 500,
+				body: {
+					code: "invalid_config",
+					message: "unreadable registration"
+				}
+			};
+			config = entry.record.config;
+			for (const ref of [config.icons.appIcon, config.icons.trayIcon]) {
+				if (ref === void 0) continue;
+				const isHttp = ref.source.kind === "http";
+				const isApp = ref === config.icons.appIcon;
+				if (isApp) iconReference = isHttp ? "url" : "local";
+				if (!(inlineIcon ?? !isHttp)) {
+					if (isApp) iconSharedAs = isHttp ? "url" : "local";
+					continue;
+				}
+				const bytes = await readResourceBytes(entry.record.dir, ref);
+				if (bytes.ok) {
+					embedded.push({
+						flag: isApp ? "app-icon" : "tray-icon",
+						filename: ref.path.split("/").pop() ?? "icon.png",
+						bytes: bytes.value
+					});
+					if (isApp) iconSharedAs = "embedded";
+				}
+			}
+		}
+		const envCount = Object.keys(config.command.env ?? {}).length;
+		if (envCount > 0 && request.body.acknowledgeEnv !== true) return {
+			status: 409,
+			body: {
+				code: "env_ack_required",
+				message: "environment entries present; acknowledgement required",
+				envCount
+			}
+		};
+		const format = request.body.format === "sh" || request.body.format === "ps1" || request.body.format === "command" ? request.body.format : "command";
+		if (format === "command") {
+			const plan = buildExportPlan({
+				config,
+				embeddedResources: embedded,
+				forceCopy: request.body.forceCopy === true
+			});
+			if (!plan.ok) return {
+				status: 500,
+				body: plan.error
+			};
+			if (plan.value.directCommand === null) return {
+				status: 409,
+				body: {
+					code: "export_unsafe",
+					message: plan.value.directCommandBlockedReason ?? "direct copy requires force-copy"
+				}
+			};
+			return {
+				status: 200,
+				body: { command: formatPosixCommandLine(plan.value.directCommand.command) }
+			};
+		}
+		const script = buildScriptExport({
+			config,
+			embeddedResources: embedded
+		}, format === "sh" ? "sh" : "powershell");
+		if (!script.ok) return {
+			status: 500,
+			body: script.error
+		};
+		return {
+			status: 200,
+			body: {
+				filename: script.value.filename,
+				content: script.value.content,
+				commandLine: script.value.commandLine,
+				requiresEnvAcknowledgement: script.value.requiresEnvAcknowledgement,
+				iconSharedAs,
+				iconReference
+			}
+		};
+	}
+	if (pathname === "/api/skill" && request.method === "GET") {
+		const root = await resolveSkillRoot();
+		if (root === void 0) return {
+			status: 404,
+			body: {
+				code: "not_found",
+				message: "packaged skill not found"
+			}
+		};
+		const requested = request.query.get("path");
+		const logical = containedSkillPath(requested !== null && requested.length > 0 ? requested : "SKILL.md");
+		if (logical === void 0) return {
+			status: 400,
+			body: {
+				code: "path_escape",
+				message: "invalid skill path"
+			}
+		};
+		try {
+			return {
+				status: 200,
+				body: {
+					path: logical,
+					content: await readFile(join(root, logical), "utf8")
+				}
+			};
+		} catch {
+			return {
+				status: 404,
+				body: {
+					code: "not_found",
+					message: `skill file not found: ${logical}`
+				}
+			};
+		}
+	}
+	if (pathname === "/api/skill/list" && request.method === "GET") {
+		const root = await resolveSkillRoot();
+		if (root === void 0) return {
+			status: 404,
+			body: {
+				code: "not_found",
+				message: "packaged skill not found"
+			}
+		};
+		const walk = async (prefix) => {
+			const entries = await readdir(join(root, prefix), { withFileTypes: true });
+			entries.sort((a, b) => a.name.localeCompare(b.name));
+			const out = [];
+			for (const entry of entries) {
+				const logical = prefix.length === 0 ? entry.name : `${prefix}/${entry.name}`;
+				if (entry.isDirectory()) {
+					out.push({
+						path: logical,
+						type: "directory"
+					});
+					out.push(...await walk(logical));
+				} else if (entry.isFile()) out.push({
+					path: logical,
+					type: "file"
+				});
+			}
+			return out;
+		};
+		return {
+			status: 200,
+			body: await walk("")
+		};
+	}
+};
+//#endregion
+//#region src/server.ts
+const LOOPBACK_HOSTS = /* @__PURE__ */ new Set([
+	"127.0.0.1",
+	"localhost",
+	"[::1]",
+	"::1"
+]);
+const createWizardServer = async (createSession, options = {}) => {
+	const token = randomBytes(16).toString("hex");
+	const clients = /* @__PURE__ */ new Set();
+	const eventLog = [];
+	const EVENT_LOG_LIMIT = 200;
+	const draftPath = join(tmpdir(), `create-opentray-draft-${options.port ?? 0}.json`);
+	const writeDraft = (event) => {
+		if (event.type !== "form" && event.type !== "command-display" && event.type !== "command-options") return;
+		(async () => {
+			try {
+				const next = {
+					...await readFile(draftPath, "utf8").then((raw) => JSON.parse(raw)).catch(() => ({})),
+					...event.type === "form" ? {
+						form: event.values,
+						defaults: event.defaults
+					} : {},
+					...event.type === "command-display" ? { command: event.command } : {},
+					...event.type === "command-options" ? { commandOptions: event.options } : {},
+					savedAt: Date.now()
+				};
+				await writeFile(draftPath, JSON.stringify(next), "utf8");
+			} catch {}
+		})();
+	};
+	const emit = (event) => {
+		if (event.type !== "log") {
+			eventLog.push(event);
+			if (eventLog.length > EVENT_LOG_LIMIT) eventLog.splice(0, eventLog.length - EVENT_LOG_LIMIT);
+		}
+		writeDraft(event);
+		const frame = `data: ${JSON.stringify(event)}\n\n`;
+		for (const client of clients) client.write(frame);
+	};
+	const session = createSession(emit);
+	const indexHtml = await readWebUiIndex();
+	const server = createServer((request, response) => {
+		handle(request, response).catch((error) => {
+			respond(response, 500, "application/json", `${JSON.stringify({ error: error instanceof Error ? error.message : String(error) })}\n`);
+		});
+	});
+	const handle = async (request, response) => {
+		const url = new URL(request.url ?? "/", "http://127.0.0.1");
+		if (url.pathname === "/" || url.pathname === "/index.html") {
+			if (!isAuthorized(request, url, token)) {
+				respond(response, 401, "text/plain", "invalid wizard token\n");
+				return;
+			}
+			if (indexHtml === void 0) {
+				respond(response, 500, "text/plain", "wizard page is missing from this installation\n");
+				return;
+			}
+			respond(response, 200, "text/html; charset=utf-8", indexHtml);
+			return;
+		}
+		if (url.pathname === "/api/events") {
+			if (!isAuthorized(request, url, token)) {
+				respond(response, 401, "text/plain", "unauthorized\n");
+				return;
+			}
+			response.writeHead(200, {
+				"content-type": "text/event-stream",
+				"cache-control": "no-cache",
+				connection: "keep-alive"
+			});
+			response.write(": connected\n\n");
+			response.write(`data: ${JSON.stringify(session.snapshot())}\n\n`);
+			for (const event of eventLog) response.write(`data: ${JSON.stringify(event)}\n\n`);
+			clients.add(response);
+			request.once("close", () => {
+				clients.delete(response);
+			});
+			return;
+		}
+		if (url.pathname.startsWith("/assets/")) {
+			await handleAssetFile(url.pathname, response);
+			return;
+		}
+		if (url.pathname === "/logo.png" || FAVICON_PATHS.has(url.pathname)) {
+			await handleAssetFile(url.pathname, response);
+			return;
+		}
+		if (url.pathname === "/ghostty-vt.wasm") {
+			await handleAssetFile("/ghostty-vt.wasm", response);
+			return;
+		}
+		if (url.pathname.startsWith("/vendor/")) {
+			await handleVendorAsset(url.pathname, response);
+			return;
+		}
+		const composedMatch = /^\/api\/icon-composed\/([a-f0-9]+)$/.exec(url.pathname);
+		if (composedMatch !== null) {
+			if (!isAuthorized(request, url, token)) {
+				respond(response, 401, "text/plain", "unauthorized\n");
+				return;
+			}
+			const key = composedMatch[1];
+			const composed = session.iconComposition(key);
+			if (composed === void 0) {
+				respond(response, 404, "text/plain", "not found\n");
+				return;
+			}
+			try {
+				const bytes = await readFile(composed.compositePath);
+				response.writeHead(200, {
+					"content-type": "image/png",
+					"cache-control": "no-store",
+					"content-length": bytes.byteLength
+				});
+				response.end(bytes);
+				return;
+			} catch {
+				respond(response, 404, "text/plain", "not found\n");
+				return;
+			}
+		}
+		const iconDataMatch = /^\/api\/icon-data\/(\d+)\/(\d+)$/.exec(url.pathname);
+		if (iconDataMatch !== null) {
+			if (!isAuthorized(request, url, token)) {
+				respond(response, 401, "text/plain", "unauthorized\n");
+				return;
+			}
+			const port = Number.parseInt(iconDataMatch[1], 10);
+			const index = Number.parseInt(iconDataMatch[2], 10);
+			const candidate = session.iconCandidate(port, index);
+			if (candidate === void 0) {
+				respond(response, 404, "text/plain", "not found\n");
+				return;
+			}
+			const bytes = await readFile(candidate.path).catch(() => void 0);
+			if (bytes === void 0) {
+				respond(response, 404, "text/plain", "not found\n");
+				return;
+			}
+			response.writeHead(200, {
+				"content-type": ICON_CONTENT_TYPES[candidate.format] ?? "application/octet-stream",
+				"content-length": bytes.length,
+				"cache-control": "no-store"
+			});
+			response.end(bytes);
+			return;
+		}
+		if (url.pathname.startsWith("/api/")) {
+			if (!isAuthorized(request, url, token)) {
+				respond(response, 401, "application/json", "{\"error\":\"unauthorized\"}\n");
+				return;
+			}
+			if (!isLoopbackHost(request)) {
+				respond(response, 403, "application/json", "{\"error\":\"forbidden host\"}\n");
+				return;
+			}
+			if (url.pathname === "/api/apps" || url.pathname.startsWith("/api/apps/") || url.pathname === "/api/skill" || url.pathname === "/api/skill/list") {
+				let body = {};
+				if (request.method === "POST") body = await readJsonBody(request);
+				const workbench = await handleWorkbenchApi({
+					method: request.method ?? "GET",
+					pathname: url.pathname,
+					query: url.searchParams,
+					body
+				});
+				if (workbench !== void 0) {
+					respond(response, workbench.status, "application/json", `${JSON.stringify(workbench.body)}\n`);
+					return;
+				}
+			}
+			await handleApi(url.pathname, request, response, session);
+			return;
+		}
+		respond(response, 404, "text/plain", "not found\n");
+	};
+	await listen(server, options.port);
+	const address = server.address();
+	if (address === null || typeof address === "string") {
+		server.close();
+		throw new Error("wizard server did not bind a loopback port");
+	}
+	return {
+		url: `http://127.0.0.1:${address.port}/?token=${token}`,
+		port: address.port,
+		token,
+		session,
+		close: () => new Promise((resolve) => {
+			for (const client of clients) client.end();
+			clients.clear();
+			server.close(() => resolve());
+		})
+	};
+};
+/** Whitelisted static terminal-renderer assets; exact names only, no traversal. */
+const VENDOR_ASSETS = {
+	"/vendor/ghostty-web.js": {
+		contentType: "text/javascript; charset=utf-8",
+		candidates: () => [join(moduleDir(), "webui", "vendor", "ghostty-web.js"), ghosttyPackageFile("dist/ghostty-web.js")]
+	},
+	"/vendor/ghostty-vt.wasm": {
+		contentType: "application/wasm",
+		candidates: () => [
+			join(moduleDir(), "webui", "vendor", "ghostty-vt.wasm"),
+			ghosttyPackageFile("ghostty-vt.wasm"),
+			ghosttyPackageFile("dist/ghostty-vt.wasm")
+		]
+	}
+};
+const moduleDir = () => dirname(fileURLToPath(import.meta.url));
+/**
+* Resolve a file inside the installed ghostty-web package. Deep paths are
+* blocked by the package `exports` map, so resolve the exported main module
+* and walk from the package root instead.
+*/
+const ghosttyPackageFile = (relative) => {
+	try {
+		return join(dirname(dirname(createRequire(import.meta.url).resolve("ghostty-web"))), relative);
+	} catch {
+		return "";
+	}
+};
+const ICON_CONTENT_TYPES = {
+	png: "image/png",
+	svg: "image/svg+xml",
+	jpeg: "image/jpeg",
+	webp: "image/webp",
+	gif: "image/gif",
+	ico: "image/x-icon"
+};
+const ASSET_CONTENT_TYPES = {
+	".js": "text/javascript; charset=utf-8",
+	".css": "text/css; charset=utf-8",
+	".wasm": "application/wasm",
+	".html": "text/html; charset=utf-8",
+	".svg": "image/svg+xml",
+	".png": "image/png",
+	".json": "application/json"
+};
+/**
+* Serve one file from the built webui directory (dist/webui). Only simple
+* relative names are accepted: resolve first, then require the resolved path
+* to stay inside the webui root, so traversal cannot escape.
+*/
+const handleAssetFile = async (pathname, response) => {
+	const relative = pathname.replace(/^\/+/, "");
+	if (relative.length === 0 || relative.includes("\0")) {
+		respond(response, 404, "text/plain", "not found\n");
+		return;
+	}
+	const roots = [join(moduleDir(), "webui"), join(moduleDir(), "..", "..", "create-webui", "dist")];
+	for (const root of roots) {
+		const resolved = resolve(root, relative);
+		if (!(resolved === root || resolved.startsWith(`${root}${sep}`))) continue;
+		const bytes = await readFile(resolved).catch(() => void 0);
+		if (bytes === void 0) continue;
+		const extension = extname(resolved).toLowerCase();
+		response.writeHead(200, {
+			"content-type": ASSET_CONTENT_TYPES[extension] ?? "application/octet-stream",
+			"content-length": bytes.length,
+			"cache-control": "no-store"
+		});
+		response.end(bytes);
+		return;
+	}
+	respond(response, 404, "text/plain", "not found\n");
+};
+const handleVendorAsset = async (pathname, response) => {
+	const asset = VENDOR_ASSETS[pathname];
+	if (asset === void 0) {
+		respond(response, 404, "text/plain", "not found\n");
+		return;
+	}
+	for (const candidate of asset.candidates()) {
+		if (candidate.length === 0) continue;
+		const bytes = await readFile(candidate).catch(() => void 0);
+		if (bytes !== void 0) {
+			response.writeHead(200, {
+				"content-type": asset.contentType,
+				"content-length": bytes.length,
+				"cache-control": "no-store"
+			});
+			response.end(bytes);
+			return;
+		}
+	}
+	respond(response, 404, "text/plain", "terminal renderer asset is missing\n");
+};
+/** Containment: icon routes must only read sources the wizard itself
+*  produced (its temp dirs / saved uploads), never arbitrary paths. */
+const isWizardOwnedIconPath = (session, target) => {
+	for (const root of session.iconSourceRoots()) if (root.length > 0 && target.startsWith(root + sep)) return true;
+	return false;
+};
+const handleApi = async (pathname, request, response, session, preReadBody) => {
+	if (request.method !== "POST") {
+		respond(response, 405, "application/json", "{\"error\":\"method not allowed\"}\n");
+		return;
+	}
+	if (pathname === "/api/icon-upload") {
+		const chunks = [];
+		for await (const chunk of request) {
+			const piece = typeof chunk === "string" ? Buffer.from(chunk) : chunk;
+			chunks.push(piece);
+		}
+		const bytes = Buffer.concat(chunks);
+		if (bytes.length < 64) {
+			respond(response, 400, "application/json", "{\"error\":\"image bytes are required\"}\n");
+			return;
+		}
+		const path = await session.saveIconUpload(bytes);
+		respond(response, 200, "application/json", JSON.stringify({ path }) + "\n");
+		return;
+	}
+	const body = preReadBody ?? await readJsonBody(request);
+	switch (pathname) {
+		case "/api/command": {
+			if (Array.isArray(body.argv)) {
+				const argv = body.argv.filter((element) => typeof element === "string");
+				if (argv.length === 0 || (argv[0] ?? "").trim().length === 0) {
+					respond(response, 400, "application/json", "{\"error\":\"argv requires the program element\"}\n");
+					return;
+				}
+				await session.submitCommand(argv);
+				respond(response, 200, "application/json", "{\"ok\":true}\n");
+				return;
+			}
+			const command = typeof body.command === "string" ? body.command : "";
+			if (command.trim().length === 0) {
+				respond(response, 400, "application/json", "{\"error\":\"command is required\"}\n");
+				return;
+			}
+			await session.submitCommand(command);
+			respond(response, 200, "application/json", "{\"ok\":true}\n");
+			return;
+		}
+		case "/api/command-options": {
+			const patch = {};
+			if (typeof body.cwd === "string") patch.cwd = body.cwd;
+			if (body.argsMode === "string" || body.argsMode === "array") patch.argsMode = body.argsMode;
+			if (Array.isArray(body.env)) {
+				const entries = [];
+				for (const entry of body.env) if (typeof entry === "object" && entry !== null && typeof entry.key === "string" && typeof entry.value === "string") entries.push({
+					key: entry.key,
+					value: entry.value
+				});
+				patch.env = entries;
+			}
+			session.updateCommandOptions(patch);
+			respond(response, 200, "application/json", "{\"ok\":true}\n");
+			return;
+		}
+		case "/api/prime": {
+			const command = typeof body.command === "string" ? body.command : "";
+			if (command.trim().length === 0) {
+				respond(response, 400, "application/json", "{\"error\":\"command is required\"}\n");
+				return;
+			}
+			session.prime(command);
+			respond(response, 200, "application/json", "{\"ok\":true}\n");
+			return;
+		}
+		case "/api/select-service": {
+			const port = Number(body.port);
+			if (!Number.isInteger(port) || port <= 0) {
+				respond(response, 400, "application/json", "{\"error\":\"port is required\"}\n");
+				return;
+			}
+			session.selectService(port);
+			respond(response, 200, "application/json", "{\"ok\":true}\n");
+			return;
+		}
+		case "/api/form": {
+			const patch = {};
+			for (const key of [
+				"appId",
+				"appName",
+				"iconPath",
+				"trayIconPath"
+			]) {
+				const value = body[key];
+				if (typeof value === "string") patch[key] = value;
+			}
+			if (body.pm === "npm" || body.pm === "pnpm" || body.pm === "bun") patch.pm = body.pm;
+			if (body.iconBackground === "black" || body.iconBackground === "white" || body.iconBackground === "transparent") patch.iconBackground = body.iconBackground;
+			if (typeof body.iconScale === "number" && body.iconScale >= .5 && body.iconScale <= .95) patch.iconScale = body.iconScale;
+			for (const key of [
+				"showStartupTerminal",
+				"showAddressBar",
+				"imageSmoothingEnabled",
+				"developerMode",
+				"force"
+			]) {
+				const value = body[key];
+				if (typeof value === "boolean") patch[key] = value;
+			}
+			session.updateForm(patch);
+			respond(response, 200, "application/json", "{\"ok\":true}\n");
+			return;
+		}
+		case "/api/cancel":
+			try {
+				session.cancel();
+				respond(response, 200, "application/json", "{\"ok\":true}\n");
+			} catch (error) {
+				respond(response, 409, "application/json", `${JSON.stringify({ error: error instanceof Error ? error.message : String(error) })}\n`);
+			}
+			return;
+		case "/api/confirm":
+			try {
+				session.confirm();
+				respond(response, 200, "application/json", "{\"ok\":true}\n");
+			} catch (error) {
+				respond(response, 409, "application/json", `${JSON.stringify({ error: error instanceof Error ? error.message : String(error) })}\n`);
+			}
+			return;
+		case "/api/export": {
+			const format = body.format === "sh" || body.format === "ps1" || body.format === "command" ? body.format : void 0;
+			if (format === void 0) {
+				respond(response, 400, "application/json", "{\"error\":\"format must be command, sh, or ps1\"}\n");
+				return;
+			}
+			const result = await session.exportFrozen({
+				format,
+				acknowledgeEnv: body.acknowledgeEnv === true,
+				forceCopy: body.forceCopy === true,
+				inlineIcon: body.inlineIcon === true
+			});
+			if (!result.ok) {
+				const status = result.code === "env_ack_required" || result.code === "export_unsafe" ? 409 : 400;
+				respond(response, status, "application/json", `${JSON.stringify({
+					code: result.code,
+					message: result.message
+				})}\n`);
+				return;
+			}
+			respond(response, 200, "application/json", `${JSON.stringify(result)}\n`);
+			return;
+		}
+		case "/api/create":
+			try {
+				await session.create();
+				respond(response, 200, "application/json", "{\"ok\":true}\n");
+			} catch (error) {
+				respond(response, 409, "application/json", `${JSON.stringify({ error: error instanceof Error ? error.message : String(error) })}\n`);
+			}
+			return;
+		case "/api/terminal-input": {
+			const data = typeof body.data === "string" ? body.data : void 0;
+			if (data === void 0) {
+				respond(response, 400, "application/json", "{\"error\":\"data is required\"}\n");
+				return;
+			}
+			session.terminalInput(data);
+			respond(response, 200, "application/json", "{\"ok\":true}\n");
+			return;
+		}
+		case "/api/icon-analyze": {
+			const path = typeof body.path === "string" ? body.path.trim() : "";
+			if (path.length === 0) {
+				respond(response, 400, "application/json", "{\"error\":\"path is required\"}\n");
+				return;
+			}
+			if (!isWizardOwnedIconPath(session, path)) {
+				respond(response, 403, "application/json", "{\"error\":\"path is not a wizard icon source\"}\n");
+				return;
+			}
+			try {
+				const analysis = await session.analyzeIconForeground(path);
+				respond(response, 200, "application/json", JSON.stringify(analysis) + "\n");
+			} catch (error) {
+				respond(response, 500, "application/json", JSON.stringify({ error: String(error) }) + "\n");
+			}
+			return;
+		}
+		case "/api/icon-compose": {
+			const foregroundPath = typeof body.foregroundPath === "string" ? body.foregroundPath.trim() : "";
+			if (foregroundPath.length === 0) {
+				respond(response, 400, "application/json", "{\"error\":\"foregroundPath is required\"}\n");
+				return;
+			}
+			if (!isWizardOwnedIconPath(session, foregroundPath)) {
+				respond(response, 403, "application/json", "{\"error\":\"foregroundPath is not a wizard icon source\"}\n");
+				return;
+			}
+			const background = body.background === "black" || body.background === "white" || body.background === "transparent" ? body.background : void 0;
+			const scale = typeof body.scale === "number" && body.scale >= .5 && body.scale <= .95 ? body.scale : void 0;
+			try {
+				const composed = await session.composeIcon({
+					foregroundPath,
+					...background === void 0 ? {} : { background },
+					...scale === void 0 ? {} : { scale }
+				});
+				respond(response, 200, "application/json", JSON.stringify(composed) + "\n");
+			} catch (error) {
+				respond(response, 500, "application/json", JSON.stringify({ error: String(error) }) + "\n");
+			}
+			return;
+		}
+		case "/api/tray-icon-select": {
+			const port = typeof body.port === "number" ? body.port : NaN;
+			const index = typeof body.index === "number" ? body.index : NaN;
+			if (!Number.isInteger(port) || !Number.isInteger(index)) {
+				respond(response, 400, "application/json", "{\"error\":\"port and index are required\"}\n");
+				return;
+			}
+			const ok = session.selectTrayIconCandidate(port, index);
+			respond(response, 200, "application/json", JSON.stringify({ ok }) + "\n");
+			return;
+		}
+		case "/api/icon-select": {
+			const port = typeof body.port === "number" ? body.port : NaN;
+			const index = typeof body.index === "number" ? body.index : NaN;
+			if (!Number.isInteger(port) || !Number.isInteger(index)) {
+				respond(response, 400, "application/json", "{\"error\":\"port and index are required\"}\n");
+				return;
+			}
+			const ok = session.selectIconCandidate(port, index);
+			respond(response, 200, "application/json", JSON.stringify({ ok }) + "\n");
+			return;
+		}
+		case "/api/icon-source": {
+			const path = typeof body.path === "string" ? body.path.trim() : "";
+			if (path.length === 0) {
+				respond(response, 400, "application/json", "{\"error\":\"path is required\"}\n");
+				return;
+			}
+			session.updateForm({ iconPath: path });
+			respond(response, 200, "application/json", "{\"ok\":true}\n");
+			return;
+		}
+		case "/api/terminal-resize": {
+			const cols = Number(body.cols);
+			const rows = Number(body.rows);
+			if (!Number.isInteger(cols) || !Number.isInteger(rows) || cols <= 0 || rows <= 0) {
+				respond(response, 400, "application/json", "{\"error\":\"cols and rows are required\"}\n");
+				return;
+			}
+			session.terminalResize({
+				cols,
+				rows
+			});
+			respond(response, 200, "application/json", "{\"ok\":true}\n");
+			return;
+		}
+		case "/api/stop":
+			await session.stop();
+			respond(response, 200, "application/json", "{\"ok\":true}\n");
+			return;
+		case "/api/open-app": {
+			const result = session.result;
+			if (result === void 0) {
+				respond(response, 409, "application/json", "{\"error\":\"no materialized app\"}\n");
+				return;
+			}
+			const opened = await openMaterializedApp({
+				projectDir: result.projectDir,
+				bundlePath: void 0
+			});
+			respond(response, opened.ok ? 200 : 500, "application/json", `${JSON.stringify({
+				ok: opened.ok,
+				detail: opened.detail
+			})}\n`);
+			return;
+		}
+		default: respond(response, 404, "application/json", "{\"error\":\"unknown endpoint\"}\n");
+	}
+};
+const listen = (server, port) => new Promise((resolve, reject) => {
+	server.once("error", reject);
+	server.listen(port ?? 0, "127.0.0.1", () => {
+		server.off("error", reject);
+		resolve();
+	});
+});
+const isAuthorized = (request, url, token) => {
+	if (request.headers.authorization === `Bearer ${token}`) return true;
+	return url.searchParams.get("token") === token;
+};
+const isLoopbackHost = (request) => {
+	const hostname = (request.headers.host ?? "").replace(/:\d+$/u, "").toLowerCase();
+	return LOOPBACK_HOSTS.has(hostname);
+};
+const readJsonBody = async (request) => {
+	const chunks = [];
+	let size = 0;
+	for await (const chunk of request) {
+		const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk));
+		size += buffer.length;
+		if (size > 1 << 20) throw new Error("request body too large");
+		chunks.push(buffer);
+	}
+	if (chunks.length === 0) return {};
+	const parsed = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+	if (typeof parsed !== "object" || parsed === null) return {};
+	return parsed;
+};
+const respond = (response, status, contentType, body) => {
+	response.writeHead(status, {
+		"content-type": contentType,
+		"content-length": Buffer.byteLength(body),
+		"cache-control": "no-store"
+	});
+	response.end(body);
+};
+/** Built package: dist/webui/index.html; source checkout falls back to the create-webui vite output. */
+const webUiIndexPaths = () => [join(moduleDir(), "webui", "index.html"), join(moduleDir(), "..", "..", "create-webui", "dist", "index.html")];
+const readWebUiIndex = async () => {
+	for (const candidate of webUiIndexPaths()) {
+		const html = await readFile(candidate, "utf8").catch(() => void 0);
+		if (html !== void 0) return html;
+	}
+};
+/** Favicon variants served from the webui root (see create-webui/public). */
+const FAVICON_PATHS = /* @__PURE__ */ new Set([
+	"/favicon-64.png",
+	"/favicon-32.png",
+	"/favicon-16.png"
+]);
+//#endregion
+//#region src/bin.ts
+const parseWizardCli = (argv) => {
+	const options = {
+		open: true,
+		skipInstall: false,
+		force: false
+	};
+	const positional = [];
+	for (let index = 0; index < argv.length; index += 1) {
+		const arg = argv[index];
+		if (arg === void 0) continue;
+		if (arg === "--no-open") options.open = false;
+		else if (arg === "--skip-install") options.skipInstall = true;
+		else if (arg === "--force") options.force = true;
+		else if (arg === "--port") {
+			const value = argv[index + 1];
+			const port = Number.parseInt(value ?? "", 10);
+			if (Number.isInteger(port) && port > 0 && port < 65536) {
+				options.port = port;
+				index += 1;
+			}
+		} else if (arg === "--pm") {
+			const value = argv[index + 1];
+			if (value === "npm" || value === "pnpm" || value === "bun") {
+				options.pm = value;
+				index += 1;
+			}
+		} else if (arg === "--help" || arg === "-h") {
+			options.open = false;
+			positional.length = 0;
+			break;
+		} else if (!arg.startsWith("--")) positional.push(arg);
+	}
+	const [target] = positional;
+	return {
+		open: options.open,
+		port: options.port,
+		pm: options.pm,
+		skipInstall: options.skipInstall,
+		force: options.force,
+		targetDir: target
+	};
+};
+const readDependencyRange = async () => {
+	const packageJsonUrl = new URL("../package.json", import.meta.url);
+	try {
+		const parsed = JSON.parse(await readFile(packageJsonUrl, "utf8"));
+		if (typeof parsed.version === "string" && /^\d/u.test(parsed.version)) return `^${parsed.version}`;
+	} catch {}
+	return "latest";
+};
+const openBrowser = async (url) => {
+	const platform = process.platform;
+	spawn(platform === "darwin" ? "open" : platform === "win32" ? "cmd" : "xdg-open", platform === "win32" ? [
+		"/c",
+		"start",
+		"",
+		url
+	] : platform === "darwin" ? [url] : [url], {
+		stdio: "ignore",
+		detached: true,
+		windowsHide: true
+	}).unref();
+};
+const runWebAdapter = async (options) => {
+	ensureLoopbackNoProxy();
+	const invocationDir = process.env.INIT_CWD || process.cwd();
+	/** Read a persisted wizard draft for a port (best-effort). */
+	const readDraft = async (port) => {
+		try {
+			const raw = await readFile(join(tmpdir(), `create-opentray-draft-${port ?? 0}.json`), "utf8");
+			const parsed = JSON.parse(raw);
+			if (parsed.form === void 0) return void 0;
+			return {
+				form: parsed.form,
+				command: parsed.command
+			};
+		} catch {
+			return;
+		}
+	};
+	const dependencyRange = await readDependencyRange();
+	const draftSeed = await readDraft(options.port);
+	const server = await createWizardServer((emit) => {
+		const session = createWizardSession({
+			cwd: invocationDir,
+			skipInstall: false,
+			force: false,
+			dependencyRange,
+			emit
+		});
+		if (draftSeed !== void 0) {
+			session.updateForm(draftSeed.form);
+			if (draftSeed.command !== void 0 && draftSeed.command.length > 0) session.prime(draftSeed.command);
+		}
+		return session;
+	}, options.port === void 0 ? {} : { port: options.port });
+	console.log(`create-opentray wizard: ${server.url}`);
+	console.log(`working directory: ${invocationDir}`);
+	if (options.open) await openBrowser(server.url);
+	const shutdown = () => {
+		(async () => {
+			await server.session.stop();
+			await server.close();
+			process.exit(0);
+		})();
+	};
+	process.once("SIGINT", shutdown);
+	process.once("SIGTERM", shutdown);
+	await new Promise(() => {});
+	return 0;
+};
+const main = async (argv) => {
+	const legacy = parseWizardCli(argv.filter((arg) => !arg.startsWith("--") || [
+		"--no-open",
+		"--port",
+		"--pm",
+		"--skip-install",
+		"--force",
+		"--help",
+		"-h"
+	].includes(arg)));
+	return dispatchCli(argv, {
+		streams: consoleStreams,
+		runWeb: async (webOptions) => runWebAdapter({
+			...webOptions,
+			...webOptions.port === void 0 && legacy.port !== void 0 ? { port: legacy.port } : {},
+			open: webOptions.open && legacy.open
+		})
+	});
+};
+const isMainModule = () => {
+	const entryPath = process.argv[1];
+	if (entryPath === void 0) return false;
+	const sameFile = (a, b) => {
+		try {
+			return realpathSync(resolve(a)) === realpathSync(resolve(b));
+		} catch {
+			return resolve(a) === resolve(b);
+		}
+	};
+	const modulePath = fileURLToPath(import.meta.url);
+	if (sameFile(entryPath, modulePath)) return true;
+	return sameFile(entryPath, modulePath.replace(/bin-[^/]*\.mjs$/u, "bin.mjs"));
+};
+if (isMainModule()) main(process.argv.slice(2)).then((code) => {
+	process.exitCode = code;
+});
+//#endregion
+export { isAuthorized as a, createWizardServer as i, openBrowser as n, isLoopbackHost as o, parseWizardCli as r, createWizardSession as s, main as t };
+
+//# sourceMappingURL=bin-sZB5nWq0.mjs.map