@wolfstar/cli 0.2.0 → 0.4.0

package/dist/tui-BCGQrMQo.js

@@ -0,0 +1,947 @@
+import { t as readOwnPackageJson } from "./version-DN6Uho-Y.js";
+import { n as classifyAppLine, r as isErrorDetail } from "./log-buffer-D-nj2ZEU.js";
+import { execFile } from "node:child_process";
+import { stripVTControlCharacters } from "node:util";
+import { Box, Text, render, useInput, useWindowSize } from "ink";
+import { createContext, useContext, useEffect, useMemo, useState } from "react";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { StringDecoder } from "node:string_decoder";
+
+//#region src/renderers/ink/theme.tsx
+/**
+* Whether the UI may use colour. `stars dev` decides this once (`NO_COLOR`, `FORCE_COLOR`, TTY detection) and every
+* component reads it from here instead of re-deriving it.
+*/
+const ColorContext = createContext(true);
+function ColorProvider({ color, children }) {
+	return /* @__PURE__ */ jsx(ColorContext, {
+		value: color,
+		children
+	});
+}
+/**
+* Returns a colour name only when colour is enabled, so `<Text color={useColor()('green')}>` degrades to plain text.
+*/
+function useColor() {
+	const enabled = useContext(ColorContext);
+	return (name) => enabled ? name : void 0;
+}
+
+//#endregion
+//#region src/renderers/ink/components/HelpOverlay.tsx
+const KEYS = [
+	["r", "restart the bot now"],
+	["o", "open the local URL in a browser"],
+	["t", "toggle the public tunnel"],
+	["i", "show versions, URLs and session info"],
+	["l", "open the logs (scroll, filter by source or level)"],
+	["e", "jump to the last error, keeping its context"],
+	["c / Ctrl+L", "clear the log history"],
+	["q / Ctrl+C", "stop the bot and quit"],
+	["?", "toggle this help"]
+];
+/** The static keys reference, opened with `?` from the pinned panel. */
+function HelpOverlay({ height, width, onClose }) {
+	const paint = useColor();
+	useInput((input, key) => {
+		if (!key.ctrl && (key.escape || [
+			"q",
+			"h",
+			"?"
+		].includes(input))) onClose();
+	});
+	return /* @__PURE__ */ jsxs(Box, {
+		flexDirection: "column",
+		height,
+		children: [
+			/* @__PURE__ */ jsx(Text, {
+				bold: true,
+				children: " keyboard shortcuts"
+			}),
+			/* @__PURE__ */ jsx(Text, {
+				dimColor: true,
+				children: "─".repeat(width)
+			}),
+			KEYS.slice(0, Math.max(0, height - 3)).map(([key, description]) => /* @__PURE__ */ jsxs(Text, {
+				wrap: "truncate-end",
+				children: [
+					"  ",
+					/* @__PURE__ */ jsx(Text, {
+						bold: true,
+						color: paint("white"),
+						children: key.padEnd(14)
+					}),
+					/* @__PURE__ */ jsx(Text, {
+						dimColor: true,
+						children: description
+					})
+				]
+			}, key)),
+			/* @__PURE__ */ jsx(Box, { flexGrow: 1 }),
+			/* @__PURE__ */ jsx(Text, {
+				dimColor: true,
+				children: " q close"
+			})
+		]
+	});
+}
+
+//#endregion
+//#region src/renderers/ink/hooks/useLogVersion.ts
+/** Bumps whenever the buffer changes, so a consumer can re-derive a filtered view without re-filtering on every render. */
+function useLogVersion(logs) {
+	const [version, setVersion] = useState(0);
+	useEffect(() => {
+		const bump = () => setVersion((current) => current + 1);
+		logs.on("entry", bump);
+		logs.on("clear", bump);
+		bump();
+		return () => {
+			logs.off("entry", bump);
+			logs.off("clear", bump);
+		};
+	}, [logs]);
+	return version;
+}
+
+//#endregion
+//#region src/renderers/ink/components/Hints.tsx
+const PANEL_HINTS = [
+	{
+		key: "r",
+		label: "restart",
+		priority: 80
+	},
+	{
+		key: "o",
+		label: "open",
+		priority: 40
+	},
+	{
+		key: "t",
+		label: "tunnel",
+		priority: 60
+	},
+	{
+		key: "i",
+		label: "info",
+		priority: 50
+	},
+	{
+		key: "l",
+		label: "logs",
+		priority: 70
+	},
+	{
+		key: "?",
+		label: "help",
+		priority: 100
+	},
+	{
+		key: "q",
+		label: "quit",
+		priority: 90
+	}
+];
+/** Drop the lowest-priority shortcuts first; help and the last error survive narrow panes. */
+function Hints({ hints, width }) {
+	const shown = [...hints];
+	const length = () => shown.reduce((size, hint) => size + hint.key.length + hint.label.length + 4, -2);
+	while (shown.length > 1 && length() > width) {
+		const weakest = shown.reduce((a, b) => a.priority <= b.priority ? a : b);
+		shown.splice(shown.indexOf(weakest), 1);
+	}
+	return /* @__PURE__ */ jsxs(Text, {
+		wrap: "truncate-end",
+		children: [" ", shown.map(({ key, label }, i) => /* @__PURE__ */ jsxs(Text, { children: [
+			i > 0 && /* @__PURE__ */ jsx(Text, {
+				dimColor: true,
+				children: " · "
+			}),
+			/* @__PURE__ */ jsx(Text, {
+				bold: true,
+				children: key
+			}),
+			/* @__PURE__ */ jsx(Text, {
+				dimColor: true,
+				children: ` ${label}`
+			})
+		] }, key))]
+	});
+}
+
+//#endregion
+//#region src/renderers/ink/components/LogBrowser.tsx
+const group = (entry) => entry.source === "app" ? "runtime" : entry.source === "build" || entry.source === "tsc" ? "build" : "cli";
+/** Filterable history, using Nuxt's keys and selecting the last error without discarding its context. */
+function LogBrowser({ service, height, width, lastError = false, onClose, onCopy }) {
+	const paint = useColor();
+	const [sources, setSources] = useState({
+		cli: true,
+		build: true,
+		runtime: true
+	});
+	const [level, setLevel] = useState(null);
+	const [query, setQuery] = useState("");
+	const [searching, setSearching] = useState(false);
+	const [selected, setSelected] = useState(() => lastError ? service.logs.entries().findLast((entry) => entry.level === "error" && !isErrorDetail(entry))?.id ?? null : null);
+	const version = useLogVersion(service.logs);
+	const entries = useMemo(() => service.logs.filter({ level }).filter((entry) => sources[group(entry)] && stripVTControlCharacters(entry.text).toLowerCase().includes(query.toLowerCase())), [
+		service,
+		sources,
+		level,
+		query,
+		version
+	]);
+	const bodyHeight = Math.max(0, height - 3);
+	const index = entries.findIndex((entry) => entry.id === selected);
+	const rows = entries.flatMap((entry) => stripVTControlCharacters(entry.text).split("\n").map((line, i) => ({
+		entry,
+		text: i === 0 ? `${new Date(entry.time).toLocaleTimeString()}  ${entry.source.padEnd(6)} ${line}` : `          ${line}`
+	})));
+	const selectedStart = rows.findIndex((row) => row.entry.id === selected);
+	const selectedEnd = rows.findLastIndex((row) => row.entry.id === selected) + 1;
+	const end = index < 0 ? rows.length : Math.min(rows.length, selectedStart + Math.max(bodyHeight, Math.min(selectedEnd - selectedStart, bodyHeight)));
+	const visible = rows.slice(Math.max(0, end - bodyHeight), end);
+	const move = (delta) => {
+		if (!entries.length) return;
+		const next = index < 0 ? delta < 0 ? entries.length - 1 : 0 : Math.max(0, Math.min(entries.length - 1, index + delta));
+		setSelected(entries[next].id);
+	};
+	useInput((input, key) => {
+		if (key.ctrl) return;
+		if (searching) {
+			if (key.escape) {
+				setSearching(false);
+				setQuery("");
+			} else if (key.return) setSearching(false);
+			else if (key.backspace || key.delete) setQuery((value) => [...value].slice(0, -1).join(""));
+			else if (input && !key.upArrow && !key.downArrow) setQuery((value) => value + input);
+			setSelected(null);
+			return;
+		}
+		if (key.escape || input === "l" || input === "q") return onClose();
+		if (input === "/") return setSearching(true);
+		if (input === "e" || input === "w" || input === "a") {
+			const next = input === "e" ? "error" : input === "w" ? "warn" : null;
+			setLevel((current) => current === next ? null : next);
+			return setSelected(null);
+		}
+		if (input === "c" || input === "b" || input === "r") {
+			const source = input === "c" ? "cli" : input === "b" ? "build" : "runtime";
+			setSources((current) => {
+				const next = {
+					...current,
+					[source]: !current[source]
+				};
+				return Object.values(next).some(Boolean) ? next : current;
+			});
+			return setSelected(null);
+		}
+		if (input === "x") {
+			service.clearLogs();
+			return setSelected(null);
+		}
+		if (key.upArrow || input === "k") return move(-1);
+		if (key.downArrow || input === "j") return move(1);
+		if (key.pageUp) return move(-Math.max(1, bodyHeight));
+		if (key.pageDown) return move(Math.max(1, bodyHeight));
+		if (key.home || input === "g") return setSelected(entries[0]?.id ?? null);
+		if (key.end || input === "G") return setSelected(null);
+		if ((key.return || input === "y") && index >= 0) onCopy?.(stripVTControlCharacters(entries[index].text));
+	});
+	const hints = searching ? [["enter", "apply"], ["esc", "cancel"]] : [
+		["↑/↓", "select"],
+		["g/G", "top/bottom"],
+		["e", "errors"],
+		["w", "warnings"],
+		["a", "all"],
+		["c/b/r", "sources"],
+		["/", "search"],
+		["x", "clear"],
+		["enter", "copy"],
+		["q", "close"]
+	];
+	return /* @__PURE__ */ jsxs(Box, {
+		flexDirection: "column",
+		height,
+		children: [
+			/* @__PURE__ */ jsxs(Text, {
+				wrap: "truncate-end",
+				children: [
+					" ",
+					/* @__PURE__ */ jsx(Text, {
+						bold: true,
+						children: "logs"
+					}),
+					/* @__PURE__ */ jsx(Text, {
+						dimColor: true,
+						children: ` · ${Object.entries(sources).filter(([, shown]) => shown).map(([source]) => source).join("+")} · ${level ? `${level}+ only` : "all levels"}${query || searching ? ` · search ${query}${searching ? "▏" : ""}` : ""}`
+					})
+				]
+			}),
+			/* @__PURE__ */ jsx(Text, {
+				dimColor: true,
+				children: "─".repeat(width)
+			}),
+			/* @__PURE__ */ jsxs(Box, {
+				flexDirection: "column",
+				height: bodyHeight,
+				overflow: "hidden",
+				children: [visible.length === 0 && /* @__PURE__ */ jsx(Text, {
+					dimColor: true,
+					children: " no matching logs"
+				}), visible.map(({ entry, text }, i) => /* @__PURE__ */ jsxs(Text, {
+					wrap: "truncate-end",
+					children: [/* @__PURE__ */ jsx(Text, {
+						color: paint("green"),
+						children: entry.id === selected ? "▎ " : "  "
+					}), /* @__PURE__ */ jsx(Text, {
+						color: paint(entry.level === "error" ? "red" : entry.level === "warn" ? "yellow" : entry.level === "success" ? "green" : "white"),
+						dimColor: isErrorDetail(entry),
+						children: text
+					})]
+				}, `${entry.id}-${i}`))]
+			}),
+			/* @__PURE__ */ jsx(Hints, {
+				width,
+				hints: hints.map(([key, label], i) => ({
+					key,
+					label,
+					priority: i === hints.length - 1 ? 100 : hints.length - i
+				}))
+			})
+		]
+	});
+}
+
+//#endregion
+//#region src/renderers/ink/hooks/useDevStatus.ts
+/**
+* Mirrors the service's status into React state. The service stays the single source of truth: the UI only
+* subscribes to it, exactly like the plain renderer does.
+*/
+function useDevStatus(service) {
+	const [status, setStatus] = useState(() => service.status);
+	useEffect(() => {
+		const onStatus = (next) => setStatus(next);
+		service.on("status", onStatus);
+		setStatus(service.status);
+		return () => {
+			service.off("status", onStatus);
+		};
+	}, [service]);
+	return status;
+}
+
+//#endregion
+//#region src/renderers/ink/hooks/useUptime.ts
+/**
+* Re-renders once a second while the bot is up, so the uptime in the header keeps counting.
+*/
+function useUptime(startedAt) {
+	const [now, setNow] = useState(() => Date.now());
+	useEffect(() => {
+		if (startedAt === null) return;
+		setNow(Date.now());
+		const timer = setInterval(() => setNow(Date.now()), 1e3);
+		return () => clearInterval(timer);
+	}, [startedAt]);
+	return startedAt === null ? null : now - startedAt;
+}
+
+//#endregion
+//#region src/renderers/panel-logic.ts
+/**
+* The badge and standing description for the panel's status row, mirroring the states Nuxt CLI v4's own dev panel
+* cycles through (`STARTING`/`BUILDING`/`RESTART`/`READY`/`ERROR`).
+*/
+function describeBadge(status) {
+	if (status.build === "building") return {
+		badge: status.startedAt === null ? "starting" : "building",
+		note: status.progress.message
+	};
+	if (status.process === "starting") return {
+		badge: "starting",
+		note: "starting the bot"
+	};
+	if (status.process === "stopping") return {
+		badge: "restarting",
+		note: "restarting the bot"
+	};
+	if (status.build === "failed") return {
+		badge: "error",
+		note: "build failed, waiting for changes"
+	};
+	if (status.process === "crashed") return {
+		badge: "error",
+		note: "the bot crashed, press r to restart"
+	};
+	if (status.health === "down") return {
+		badge: "error",
+		note: "health check failed"
+	};
+	if (status.typecheck === "failed") return {
+		badge: "error",
+		note: "type check failed, press e to view it"
+	};
+	if (status.process === "stopped") return {
+		badge: "error",
+		note: "the bot stopped, press r to restart"
+	};
+	if (status.progress.fraction < 1) return {
+		badge: "starting",
+		note: status.progress.message
+	};
+	if (status.process === "running") return {
+		badge: "ready",
+		note: "watching for changes"
+	};
+	return {
+		badge: "starting",
+		note: "waiting for the first build"
+	};
+}
+/** Formats a duration the way a dev session reads it: `mm:ss` under an hour, `h:mm:ss` above. */
+function formatDuration(milliseconds) {
+	const total = Math.max(0, Math.floor(milliseconds / 1e3));
+	const seconds = total % 60;
+	const minutes = Math.floor(total / 60) % 60;
+	const hours = Math.floor(total / 3600);
+	const pad = (value) => value.toString().padStart(2, "0");
+	return hours > 0 ? `${hours}:${pad(minutes)}:${pad(seconds)}` : `${pad(minutes)}:${pad(seconds)}`;
+}
+
+//#endregion
+//#region src/renderers/ink/components/InfoOverlay.tsx
+function InfoOverlay({ service, height, width, onClose }) {
+	const status = useDevStatus(service);
+	const uptime = useUptime(status.startedAt);
+	useInput((input, key) => {
+		if (!key.ctrl && (key.escape || ["q", "i"].includes(input))) onClose();
+	});
+	const lines = [
+		["Project", service.config.packageJson?.name ?? "stars project"],
+		["Root", service.config.root],
+		["Node", process.version],
+		["Builder", service.builder.tool],
+		["Local", status.url ?? "—"],
+		["Tunnel", status.tunnelUrl ?? status.tunnel],
+		["Process", `${status.process}${status.pid ? ` (${status.pid})` : ""}`],
+		["Uptime", uptime === null ? "—" : formatDuration(uptime)],
+		["Restarts", String(status.restarts)],
+		["Health", service.config.dev.health ? status.health : "not configured (READY reports process state)"],
+		["Types", `${status.typecheck}${status.typeErrors ? ` (${status.typeErrors} errors)` : ""}`],
+		["Log file", service.config.dev.logFile ?? "disabled"]
+	];
+	return /* @__PURE__ */ jsxs(Box, {
+		flexDirection: "column",
+		height,
+		children: [
+			/* @__PURE__ */ jsxs(Text, {
+				bold: true,
+				wrap: "truncate-end",
+				children: [" ", "session info"]
+			}),
+			/* @__PURE__ */ jsx(Text, {
+				dimColor: true,
+				children: "─".repeat(width)
+			}),
+			lines.slice(0, Math.max(0, height - 3)).map(([label, value]) => /* @__PURE__ */ jsxs(Text, {
+				wrap: "truncate-end",
+				children: [
+					"  ",
+					/* @__PURE__ */ jsx(Text, {
+						bold: true,
+						children: label.padEnd(10)
+					}),
+					/* @__PURE__ */ jsx(Text, {
+						dimColor: true,
+						children: value
+					})
+				]
+			}, label)),
+			/* @__PURE__ */ jsx(Box, { flexGrow: 1 }),
+			/* @__PURE__ */ jsx(Text, {
+				dimColor: true,
+				children: " q close"
+			})
+		]
+	});
+}
+
+//#endregion
+//#region src/renderers/ink/components/Panel.tsx
+/** Nuxt's wordmark / URLs / progress / status / hints layout, with Stars branding. */
+function Panel({ status, config, counters, frame, elapsedMs, width, height, confirmQuit }) {
+	const paint = useColor();
+	const state = describeBadge(status);
+	const busy = state.badge !== "ready" && state.badge !== "error";
+	const badge = !busy && counters.errors > 0 ? "error" : state.badge;
+	const note = badge === "error" && state.badge === "ready" ? "an error was logged · press e to view it" : state.note;
+	const filled = Math.round(Math.min(1, Math.max(0, status.progress.fraction)) * 20);
+	let shown = [
+		...(config.dev.banner === false ? [] : config.dev.banner?.flatMap((line) => line.split("\n")) ?? [null]).slice(0, 4).map((line, index) => ({
+			name: "wordmark",
+			content: /* @__PURE__ */ jsxs(Box, {
+				justifyContent: "space-between",
+				children: [/* @__PURE__ */ jsxs(Text, {
+					wrap: "truncate-end",
+					children: [" ", line === null ? /* @__PURE__ */ jsxs(Fragment, { children: [
+						/* @__PURE__ */ jsx(Text, {
+							color: paint("green"),
+							children: [..."·✦★✦"].map((cell, i) => /* @__PURE__ */ jsx(Text, {
+								dimColor: busy && i !== frame % 4,
+								children: cell
+							}, i))
+						}),
+						"  ",
+						/* @__PURE__ */ jsx(Text, {
+							bold: true,
+							color: paint("green"),
+							children: "Stars"
+						}),
+						/* @__PURE__ */ jsx(Text, {
+							dimColor: true,
+							children: ` ${readOwnPackageJson().version}`
+						})
+					] }) : /* @__PURE__ */ jsx(Text, {
+						color: paint("green"),
+						children: line
+					})]
+				}), index === 0 && width >= 60 && badge === "ready" && status.progress.readyMs !== null && /* @__PURE__ */ jsx(Text, {
+					dimColor: true,
+					children: `ready in ${(status.progress.readyMs / 1e3).toFixed(2)}s `
+				})]
+			}, index)
+		})),
+		{
+			name: "space",
+			content: /* @__PURE__ */ jsx(Text, { children: " " })
+		},
+		...status.url ? [{
+			name: "urls",
+			content: /* @__PURE__ */ jsxs(Text, {
+				wrap: "truncate-end",
+				children: [
+					"   ",
+					/* @__PURE__ */ jsx(Text, {
+						dimColor: true,
+						children: "Local    "
+					}),
+					/* @__PURE__ */ jsx(Text, {
+						color: paint("cyan"),
+						dimColor: busy,
+						children: status.url
+					}),
+					busy && /* @__PURE__ */ jsx(Text, {
+						color: paint("yellow"),
+						children: ` ${[
+							"⠋",
+							"⠙",
+							"⠹",
+							"⠸",
+							"⠼",
+							"⠴",
+							"⠦",
+							"⠧",
+							"⠇",
+							"⠏"
+						][frame % 10]}`
+					})
+				]
+			})
+		}] : [],
+		...status.tunnelUrl ? [{
+			name: "urls",
+			content: /* @__PURE__ */ jsxs(Text, {
+				wrap: "truncate-end",
+				children: [
+					"   ",
+					/* @__PURE__ */ jsx(Text, {
+						dimColor: true,
+						children: "Tunnel   "
+					}),
+					/* @__PURE__ */ jsx(Text, {
+						color: paint("magenta"),
+						children: status.tunnelUrl
+					})
+				]
+			})
+		}] : [],
+		{
+			name: "space",
+			content: /* @__PURE__ */ jsx(Text, { children: " " })
+		},
+		{
+			name: "summary",
+			content: busy ? /* @__PURE__ */ jsxs(Text, {
+				wrap: "truncate-end",
+				children: [
+					"   ",
+					/* @__PURE__ */ jsx(Text, {
+						color: paint("green"),
+						children: "━".repeat(filled)
+					}),
+					/* @__PURE__ */ jsxs(Text, {
+						dimColor: true,
+						children: ["━".repeat(20 - filled), ` ${Math.round(status.progress.fraction * 100)}% · ${(elapsedMs / 1e3).toFixed(1)}s`]
+					})
+				]
+			}) : /* @__PURE__ */ jsxs(Text, {
+				wrap: "truncate-end",
+				children: [
+					"   ",
+					counters.warnings > 0 && /* @__PURE__ */ jsx(Text, {
+						color: paint("yellow"),
+						children: `⚠ ${counters.warnings} ${plural(counters.warnings, "warning")}   `
+					}),
+					counters.errors > 0 && /* @__PURE__ */ jsx(Text, {
+						bold: true,
+						color: paint("red"),
+						children: `✖ ${counters.errors} ${plural(counters.errors, "error")}   `
+					}),
+					counters.errors === 0 && counters.warnings === 0 && /* @__PURE__ */ jsx(Text, {
+						dimColor: true,
+						children: status.typecheck === "checking" ? "checking types" : status.tunnel === "failed" ? "tunnel failed · press l to view logs" : "logs folded away · press l to view"
+					})
+				]
+			})
+		},
+		{
+			name: "space",
+			content: /* @__PURE__ */ jsx(Text, { children: " " })
+		},
+		{
+			name: "status",
+			content: /* @__PURE__ */ jsxs(Text, {
+				wrap: "truncate-end",
+				children: [
+					" ",
+					/* @__PURE__ */ jsx(Text, {
+						bold: true,
+						backgroundColor: paint(confirmQuit || busy ? "yellow" : badge === "error" ? "red" : "green"),
+						color: paint(badge === "error" && !confirmQuit ? "white" : "black"),
+						children: ` ${confirmQuit ? "QUIT?" : badge === "restarting" ? "RESTART" : badge.toUpperCase()} `
+					}),
+					"  ",
+					/* @__PURE__ */ jsx(Text, {
+						dimColor: true,
+						children: confirmQuit ? "press y to confirm, esc to stay" : note
+					})
+				]
+			})
+		},
+		{
+			name: "hints",
+			content: confirmQuit ? /* @__PURE__ */ jsx(Text, { children: " " }) : /* @__PURE__ */ jsx(Hints, {
+				width,
+				hints: [...counters.errors ? [{
+					key: "e",
+					label: "last error",
+					priority: Infinity
+				}] : [], ...PANEL_HINTS]
+			})
+		}
+	];
+	const budget = Math.max(2, Math.min(height, 14));
+	for (const name of [
+		"space",
+		"summary",
+		"urls",
+		"wordmark"
+	]) {
+		if (shown.length <= budget) break;
+		shown = shown.filter((block) => block.name !== name);
+	}
+	shown = shown.filter((block, i, all) => block.name !== "space" || i > 0 && i < all.length - 1 && all[i - 1]?.name !== "space");
+	return /* @__PURE__ */ jsx(Box, {
+		flexDirection: "column",
+		children: shown.map((block, index) => /* @__PURE__ */ jsx(Box, {
+			flexDirection: "column",
+			height: 1,
+			children: block.content
+		}, index))
+	});
+}
+function plural(count, word) {
+	return count === 1 ? word : `${word}s`;
+}
+
+//#endregion
+//#region src/renderers/ink/hooks/useLogCounters.ts
+/**
+* Warnings and errors logged since the last successful build, the way Nuxt CLI v4's own panel counts them: the
+* badge's job is the current state, this line is what happened getting there.
+*/
+function useLogCounters(service) {
+	const count = () => service.logs.entries().reduce((total, entry) => ({
+		warnings: total.warnings + Number(entry.level === "warn"),
+		errors: total.errors + Number(entry.level === "error" && !isErrorDetail(entry))
+	}), {
+		warnings: 0,
+		errors: 0
+	});
+	const [counters, setCounters] = useState(count);
+	useEffect(() => {
+		let previousBuild = service.status.build;
+		let previousStart = service.status.startedAt;
+		const onEntry = (entry) => {
+			if (entry.level === "warn") setCounters((current) => ({
+				...current,
+				warnings: current.warnings + 1
+			}));
+			else if (entry.level === "error" && !isErrorDetail(entry)) setCounters((current) => ({
+				...current,
+				errors: current.errors + 1
+			}));
+		};
+		const onStatus = (status) => {
+			if (status.build === "building" && previousBuild !== "building" && previousBuild !== "idle" || status.lastRestartReason === "manual" && status.startedAt !== null && status.startedAt !== previousStart) setCounters({
+				warnings: 0,
+				errors: 0
+			});
+			previousBuild = status.build;
+			previousStart = status.startedAt;
+		};
+		service.logs.on("entry", onEntry);
+		const onClear = () => setCounters({
+			warnings: 0,
+			errors: 0
+		});
+		service.logs.on("clear", onClear);
+		service.on("status", onStatus);
+		setCounters(count());
+		return () => {
+			service.logs.off("entry", onEntry);
+			service.logs.off("clear", onClear);
+			service.off("status", onStatus);
+		};
+	}, [service]);
+	return counters;
+}
+
+//#endregion
+//#region src/renderers/ink/hooks/useBuildClock.ts
+/** The clock moves during a long compiler phase; the percentage only moves on real build events. */
+function useBuildClock(startedAt, active, reducedMotion) {
+	const [now, setNow] = useState(Date.now);
+	useEffect(() => {
+		if (!active) return;
+		setNow(Date.now());
+		const timer = setInterval(() => setNow(Date.now()), reducedMotion ? 1e3 : 120);
+		return () => clearInterval(timer);
+	}, [
+		startedAt,
+		active,
+		reducedMotion
+	]);
+	const elapsedMs = Math.max(0, now - startedAt);
+	return {
+		elapsedMs,
+		frame: reducedMotion ? 0 : Math.floor(elapsedMs / 120)
+	};
+}
+
+//#endregion
+//#region src/lib/open-url.ts
+/** Called only on an explicit `o` keypress, with no shell interpolation. */
+function openDevUrl(value) {
+	if (!value) return Promise.resolve();
+	const url = new URL(value);
+	if (url.protocol !== "http:" && url.protocol !== "https:") return Promise.reject(/* @__PURE__ */ new Error("Only HTTP(S) URLs can be opened."));
+	const [command, args] = process.platform === "win32" ? ["rundll32", ["url.dll,FileProtocolHandler", url.href]] : process.platform === "darwin" ? ["open", [url.href]] : ["xdg-open", [url.href]];
+	return new Promise((resolve, reject) => execFile(command, [...args], (error) => error ? reject(/* @__PURE__ */ new Error(`Could not open the browser: ${error.message}`)) : resolve()));
+}
+
+//#endregion
+//#region src/renderers/ink/DevApp.tsx
+/**
+* A bottom-aligned panel in the normal buffer, with logs folded away. Only the browsable overlays use the
+* alternate screen, preserving the terminal's history and the panel when they close.
+*/
+function DevApp({ service, color, reducedMotion, onQuit, onViewChange, onCopy }) {
+	const { columns, rows } = useWindowSize();
+	const [view, setView] = useState("panel");
+	const [confirmQuit, setConfirmQuit] = useState(false);
+	const status = useDevStatus(service);
+	const counters = useLogCounters(service);
+	const badge = describeBadge(status).badge;
+	const busy = badge !== "ready" && badge !== "error";
+	const clock = useBuildClock(status.progress.startedAt, busy && view === "panel", reducedMotion);
+	const width = Math.max(1, columns);
+	const height = Math.max(2, rows - 1);
+	const changeView = (next) => {
+		onViewChange(next !== "panel");
+		setView(next);
+	};
+	useInput((input, key) => {
+		if (key.ctrl && input === "c") return onQuit();
+		if (key.ctrl && input === "l") return service.clearLogs();
+		if (view !== "panel") return;
+		if (confirmQuit) {
+			if (input === "y") return onQuit();
+			return setConfirmQuit(false);
+		}
+		if (key.ctrl && input === "r") return void service.restart("manual");
+		if (key.ctrl && input === "d") return busy ? setConfirmQuit(true) : onQuit();
+		switch (input) {
+			case "q": return busy ? setConfirmQuit(true) : onQuit();
+			case "r":
+				service.restart("manual");
+				return;
+			case "l": return changeView("logs");
+			case "e": return changeView("errors");
+			case "c": return service.clearLogs();
+			case "o":
+				openDevUrl(status.url).catch((error) => service.log("stars", "warn", error.message));
+				return;
+			case "t":
+				service.toggleTunnel();
+				return;
+			case "i": return changeView("info");
+			case "h":
+			case "?": return changeView("help");
+		}
+	});
+	return /* @__PURE__ */ jsx(ColorProvider, {
+		color,
+		children: /* @__PURE__ */ jsxs(Box, {
+			width,
+			height,
+			flexDirection: "column",
+			justifyContent: view === "panel" ? "flex-end" : "flex-start",
+			children: [
+				(view === "logs" || view === "errors") && /* @__PURE__ */ jsx(LogBrowser, {
+					service,
+					height,
+					width,
+					lastError: view === "errors",
+					onCopy,
+					onClose: () => changeView("panel")
+				}),
+				view === "help" && /* @__PURE__ */ jsx(HelpOverlay, {
+					height,
+					width,
+					onClose: () => changeView("panel")
+				}),
+				view === "info" && /* @__PURE__ */ jsx(InfoOverlay, {
+					service,
+					height,
+					width,
+					onClose: () => changeView("panel")
+				}),
+				view === "panel" && /* @__PURE__ */ jsx(Panel, {
+					status,
+					config: service.config,
+					counters,
+					...clock,
+					width,
+					height,
+					confirmQuit
+				})
+			]
+		})
+	});
+}
+
+//#endregion
+//#region src/renderers/capture-output.ts
+/** Capture third-party writes before build plugins run. Ink writes through a separate, unpatched sink. */
+function captureOutput(service, stream, fallback) {
+	const original = stream.write;
+	const decoder = new StringDecoder("utf8");
+	let pending = "";
+	const emit = (text) => {
+		if (text.trim()) service.log("build", classifyAppLine(text, fallback), text);
+	};
+	const write = (chunk, encoding, callback) => {
+		pending += typeof chunk === "string" ? chunk : chunk instanceof Uint8Array ? decoder.write(Buffer.from(chunk)) : String(chunk);
+		const lines = pending.split(/\r?\n/);
+		pending = lines.pop() ?? "";
+		for (const line of lines) emit(line);
+		if (pending.length > 65536) {
+			emit(pending);
+			pending = "";
+		}
+		const done = typeof encoding === "function" ? encoding : callback;
+		if (typeof done === "function") queueMicrotask(() => done());
+		return true;
+	};
+	stream.write = write;
+	return () => {
+		if (stream.write === write) stream.write = original;
+		emit(pending + decoder.end());
+		pending = "";
+	};
+}
+
+//#endregion
+//#region src/renderers/tui.tsx
+/**
+* A normal-buffer, bottom-aligned panel and alternate-buffer overlays. External output is captured for the log
+* browser; the renderer alone writes to the terminal. Switching views and teardown restore the original buffer.
+*
+* `start()` resolves when the user quits, which is what `stars dev` waits on before shutting the bot down.
+*/
+function createTuiRenderer(service, options = {}) {
+	const stdout = options.stdout ?? process.stdout;
+	const stdin = options.stdin ?? process.stdin;
+	const write = stdout.write.bind(stdout);
+	const sink = new Proxy(stdout, { get(target, property) {
+		if (property === "write") return write;
+		const value = Reflect.get(target, property, target);
+		return typeof value === "function" ? value.bind(target) : value;
+	} });
+	const restoreOutput = stdout === process.stdout ? [captureOutput(service, process.stdout, "info"), captureOutput(service, process.stderr, "warn")] : [];
+	let alternate = false;
+	let stopped = false;
+	const switchView = (overlay) => {
+		if (overlay === alternate || stopped) return;
+		instance.clear();
+		write(overlay ? "\x1B[?1049h\x1B[H" : "\x1B[?1049l");
+		alternate = overlay;
+	};
+	let quit;
+	const quitting = new Promise((resolve) => {
+		quit = resolve;
+	});
+	const instance = render(/* @__PURE__ */ jsx(DevApp, {
+		service,
+		color: options.color ?? false,
+		reducedMotion: options.reducedMotion ?? false,
+		onQuit: quit,
+		onViewChange: switchView,
+		onCopy: (text) => write(`\u001B]52;c;${Buffer.from(text.slice(0, 65536)).toString("base64")}\u0007`)
+	}), {
+		stdout: sink,
+		stdin,
+		exitOnCtrlC: false,
+		patchConsole: false,
+		interactive: true,
+		...options.fps === void 0 ? {} : { maxFps: options.fps }
+	});
+	return {
+		async start() {
+			await Promise.race([quitting, instance.waitUntilExit()]);
+		},
+		stop() {
+			if (stopped) return;
+			stopped = true;
+			if (alternate) instance.clear();
+			instance.unmount();
+			if (alternate) write("\x1B[?1049l");
+			write("\x1B[?25h");
+			for (const restore of restoreOutput) restore();
+			if (service.status.progress.readyMs === null) {
+				const error = service.logs.entries().findLast((entry) => entry.level === "error" && !isErrorDetail(entry));
+				if (error) write(`\n${error.text}\n`);
+			}
+			quit();
+		}
+	};
+}
+
+//#endregion
+export { createTuiRenderer };
+//# sourceMappingURL=tui-BCGQrMQo.js.map