@wolfstar/cli 2.1.0 → 2.3.0-next-20261004131917

package/dist/{dev-4wpEQC7l.js → dev-oPPVR7d_.js}

@@ -1,39 +1,94 @@
 import { i as shouldUseColor, n as prefersReducedMotion, r as resolveOutputMode } from "./output-mode-Bp7Da8vJ.js";
-import { i as renderCrashReport, t as ExitCode } from "./errors-Crt4hu0b.js";
-import { t as cliDiagnostics } from "./diagnostics-CZBVxlpj.js";
-import { a as readSavedTheme, c as saveTheme, i as isThemeSetting, n as THEME_SETTINGS, s as resolveThemeSetting } from "./theme-3Fc_LI-2.js";
-import { i as resolveFromProject, r as resolveBinary } from "./project-MD4dIo2X.js";
-import { i as createLineSplitter, n as resolveTscBinary, r as ProcessSupervisor } from "./tsc-DO7D_uCl.js";
-import { n as createBuilder, t as Locales } from "./locales-C7X8VNmK.js";
-import { a as projectArgs, n as loadProject, o as resolveCwd, r as withProjectEnv, t as applyEnvOptions } from "./hooks-H9kjLCMk.js";
-import { n as reportWarnings, t as prepareProject } from "./_shared-B-hRZDRS.js";
-import { t as Tunnel } from "./tunnel-DT1FH6oA.js";
-import { n as classifyAppLine, t as LogBuffer } from "./log-buffer-CY82aqnb.js";
+import { i as renderCrashReport, t as ExitCode } from "./errors-COFWKKKw.js";
+import { t as cliDiagnostics } from "./diagnostics-BysbNnPD.js";
+import { a as readSavedTheme, c as saveTheme, i as isThemeSetting, n as THEME_SETTINGS, s as resolveThemeSetting } from "./theme-yS2h5dd_.js";
+import { r as resolveBinary } from "./project-zlQStwsf.js";
+import { i as createLineSplitter, n as resolveTscBinary, r as ProcessSupervisor } from "./tsc-puVAcwmo.js";
+import { n as createBuilder, t as Locales } from "./locales-BJAP4HYf.js";
+import { c as moduleImportArgs, d as resolveCwd, l as collectFlag, n as loadProject, r as withProjectEnv, s as envImportArgs, t as applyEnvOptions, u as projectArgs } from "./hooks-Cy6F2bhH.js";
+import { n as reportWarnings, t as prepareProject } from "./_shared-BIQK0Bhm.js";
+import { r as diffSnapshots, t as describeCommand } from "./command-diff-BK912Hjc.js";
+import { i as bridgeImportArgs, n as CLI_SOURCE, o as parseBridgeMessage, s as Tunnel } from "./bridge-BvkmlAOZ.js";
+import { a as initialLogView, s as isLogLevel, x as classifyAppLine, y as LogBuffer } from "./log-view-B7uJEnMR.js";
 import { defineCommand } from "citty";
-import { createWriteStream, mkdirSync } from "node:fs";
-import { dirname } from "node:path";
-import { pathToFileURL } from "node:url";
+import { createWriteStream, mkdirSync, readFileSync, readdirSync, rmSync, statSync } from "node:fs";
+import { basename, dirname, extname, join, sep } from "node:path";
 import { displayPath } from "@wolfstar/schema";
 import { EventEmitter } from "node:events";
-import { envModuleSource } from "@wolfstar/vite-server/internal";
 import { spawn } from "node:child_process";
+import { stripVTControlCharacters } from "node:util";
+import { createHash } from "node:crypto";
 import { lookup } from "node:dns/promises";
 
-//#region src/utils/env-import.ts
-/** Build tools whose output never passes through the entry transform that registers `env`. */
-const UNTRANSFORMED_TOOLS = /* @__PURE__ */ new Set(["none", "tsc"]);
+//#region src/dev/changed-files.ts
+const SKIPPED_DIRECTORIES = /* @__PURE__ */ new Set(["node_modules", ".git"]);
 /**
-* `node` arguments that register `env` before the entry runs, for the build tools the entry transform cannot reach.
-* The preload is a `data:` URL, so `.stars/` gets no generated runtime file; a `data:` URL cannot resolve bare
-* specifiers, so `@wolfstar/env-utilities` is resolved from the project first. When it cannot be resolved nothing is
-* preloaded, and the bot's own import of it reports the missing install.
+* `tsc -b` rewrites its build info on every build, whatever changed; a source map only ever changes with the file it
+* maps, and is most of what there would be to read.
 */
-function envImportArgs(config) {
-	if (!config.env.enabled || !UNTRANSFORMED_TOOLS.has(config.build.tool)) return [];
-	const resolved = resolveFromProject(config.root, "@wolfstar/env-utilities");
-	if (resolved === null) return [];
-	const source = envModuleSource(config.env.options, pathToFileURL(resolved).href);
-	return ["--import", `data:text/javascript,${encodeURIComponent(source)}`];
+const SKIPPED_FILES = /\.(?:tsbuildinfo|map)$/;
+/**
+* Hashes every file under `roots`, skipping `node_modules`, `.git` and everything under `exclude`.
+*
+* The builders only report that a build finished, and a bundler rewrites files it did not change (`tsdown` writes
+* its whole output on every rebuild), so neither an event nor a modification time says what a build changed: two
+* snapshots do (see {@link changedFiles}).
+*/
+function snapshotFiles(roots, exclude = [], cache = /* @__PURE__ */ new Map()) {
+	const snapshot = /* @__PURE__ */ new Map();
+	const visit = (directory) => {
+		let entries;
+		try {
+			entries = readdirSync(directory, { withFileTypes: true });
+		} catch {
+			return;
+		}
+		for (const entry of entries) {
+			const path = join(directory, entry.name);
+			if (exclude.some((excluded) => isInside(path, excluded))) continue;
+			if (entry.isDirectory()) {
+				if (!SKIPPED_DIRECTORIES.has(entry.name)) visit(path);
+			} else if (entry.isFile() && !SKIPPED_FILES.test(entry.name)) try {
+				const { size, mtimeMs } = statSync(path);
+				const known = cache.get(path);
+				const hash = known?.size === size && known.mtimeMs === mtimeMs ? known.hash : createHash("sha1").update(readFileSync(path)).digest("base64");
+				cache.set(path, {
+					size,
+					mtimeMs,
+					hash
+				});
+				snapshot.set(path, hash);
+			} catch {}
+		}
+	};
+	for (const root of new Set(roots)) visit(root);
+	return snapshot;
+}
+/** The files that were added, removed, or whose content differs between two snapshots. */
+function changedFiles(previous, next) {
+	const changed = [...next].filter(([path, hash]) => previous.get(path) !== hash).map(([path]) => path);
+	for (const path of previous.keys()) if (!next.has(path)) changed.push(path);
+	return changed;
+}
+const PIECE_EXTENSIONS = /* @__PURE__ */ new Set([
+	".js",
+	".mjs",
+	".cjs",
+	".ts",
+	".mts",
+	".cts"
+]);
+/**
+* Whether a file a store has not loaded yet could be a piece, by the rule the stores filter files with: a script
+* that is not a declaration file and whose name does not start with `_`.
+*/
+function couldBePiece(path) {
+	const extension = extname(path);
+	return PIECE_EXTENSIONS.has(extension) && !path.endsWith(".d.ts") && !basename(path, extension).startsWith("_");
+}
+/** Whether `path` is `directory` itself or lies under it. */
+function isInside(path, directory) {
+	return path === directory || path.startsWith(directory.endsWith(sep) ? directory : `${directory}${sep}`);
 }
 
 //#endregion
@@ -252,6 +307,8 @@ var DevService = class extends EventEmitter {
 	typechecker;
 	tunnel;
 	locales;
+	/** Whether something can answer a {@link DevPrompt}: the interactive UI sets it, the plain renderer cannot. */
+	promptable = false;
 	#hooks;
 	/** Runs hooks one at a time, so an async `build:done` settles before the next build's hooks or a restart. */
 	#hookChain = Promise.resolve();
@@ -272,6 +329,23 @@ var DevService = class extends EventEmitter {
 		startedAt: Date.now(),
 		readyMs: null
 	};
+	#ready = false;
+	#port = null;
+	/** The store paths the running bot watches for hot reloads, empty when it does not. */
+	#hmrPaths = [];
+	#paused = false;
+	#prompt = null;
+	/** The commands the bot last reported, kept across restarts: a restart is how most changes arrive. */
+	#commands = null;
+	/** What the build output held after the previous build, `null` before the first one. */
+	#files = null;
+	#hashes = /* @__PURE__ */ new Map();
+	/** The files the running bot loaded pieces from: what its hot reload can replace. */
+	#pieces = /* @__PURE__ */ new Set();
+	/** The commands Discord is assumed to have: the first report of the session, then whatever was last deployed. */
+	#deployed = null;
+	/** A refresh of the commands asked for while the bot was not listening; sent once it is. */
+	#refreshPending = false;
 	constructor(config, options) {
 		super();
 		this.config = config;
@@ -312,6 +386,15 @@ var DevService = class extends EventEmitter {
 		});
 		this.supervisor.on("stdout", (line) => this.log("app", classifyAppLine(line, "info"), line));
 		this.supervisor.on("stderr", (line) => this.log("app", classifyAppLine(line, "error"), line));
+		this.supervisor.on("message", (message) => {
+			const parsed = parseBridgeMessage(message);
+			if (parsed === null) return;
+			try {
+				this.#onBridge(parsed);
+			} catch (error) {
+				this.log("stars", "warn", `Ignored a ${parsed.type} message from the bot: ${error instanceof Error ? error.message : String(error)}`);
+			}
+		});
 		this.supervisor.on("error", (error) => this.log("stars", "error", `Failed to start the bot: ${error.message}`));
 		this.supervisor.on("exit", (exit) => this.#onExit(exit));
 		this.typechecker.on("log", (level, text) => this.log("tsc", level, text));
@@ -344,14 +427,20 @@ var DevService = class extends EventEmitter {
 			typecheck: this.typechecker.state,
 			typeErrors: this.typechecker.errors,
 			tunnel: this.tunnel.state,
-			tunnelUrl: this.tunnel.url
+			tunnelUrl: this.tunnel.url,
+			ready: this.#ready,
+			port: this.#port,
+			hmr: this.#hmrPaths.length > 0,
+			paused: this.#paused,
+			prompt: this.#prompt
 		};
 	}
-	log(source, level, text) {
+	log(source, level, text, extra = {}) {
 		this.logs.push({
 			source,
 			level,
-			text
+			text,
+			...extra
 		});
 	}
 	/**
@@ -394,10 +483,51 @@ var DevService = class extends EventEmitter {
 				message: "starting the bot"
 			};
 			this.#health = "unknown";
+			this.#paused = false;
 			this.supervisor.start();
 			this.#emitStatus();
 		});
 	}
+	/**
+	* Stops the bot and leaves it stopped (the `d` key): builds keep running, but nothing starts the bot again until
+	* {@link restart}. For when the bot must be off without ending the session.
+	*/
+	disconnect() {
+		this.#clearRestartTimer();
+		return this.#enqueue(async () => {
+			if (this.#stopped || this.#paused) return;
+			this.#paused = true;
+			this.log("stars", "info", "Stopped the bot, press r to start it again");
+			await this.supervisor.stop();
+			this.#emitStatus();
+		});
+	}
+	/** Settles the pending {@link DevPrompt}: `true` does what it asks, `false` dismisses it. */
+	answerPrompt(accept) {
+		if (this.#prompt === null) return;
+		this.#prompt = null;
+		if (accept) this.refreshCommands();
+		else this.log("stars", "info", "Kept the deployed commands as they are", { channel: "commands" });
+		this.#emitStatus();
+	}
+	/** Asks the bot to register its commands with Discord again. The bot answers on the `commands` channel. */
+	refreshCommands() {
+		if (!this.#ready) {
+			this.#refreshPending = true;
+			const when = this.supervisor.running ? "once the bot is ready" : "when the bot starts again";
+			this.log("stars", "info", `Refreshing commands ${when}…`, { channel: "commands" });
+			return;
+		}
+		this.#refreshPending = false;
+		const current = this.#commands?.guilds ?? {};
+		const request = {
+			source: CLI_SOURCE,
+			type: "commands:refresh",
+			clearGuilds: Object.keys(this.#deployed?.guilds ?? {}).filter((guild) => !Object.hasOwn(current, guild))
+		};
+		if (this.supervisor.send(request)) this.log("stars", "info", "Refreshing commands…", { channel: "commands" });
+		else this.log("stars", "warn", "Could not reach the bot to refresh its commands", { channel: "commands" });
+	}
 	/** Opens or closes the public tunnel (used by the `t` key). */
 	toggleTunnel() {
 		return this.tunnel.toggle();
@@ -434,6 +564,7 @@ var DevService = class extends EventEmitter {
 		this.logs.clear();
 	}
 	#onBuildSuccess(outcome) {
+		const hot = this.#hotReloadable();
 		try {
 			this.locales.copy();
 		} catch (error) {
@@ -455,8 +586,35 @@ var DevService = class extends EventEmitter {
 		if (this.#stopped) return;
 		this.typechecker.check();
 		this.log("stars", "success", this.builder.tool === "none" ? "Sources changed" : `Build succeeded in ${outcome.durationMs}ms`);
+		if (this.#paused) return;
+		if (hot !== null) {
+			for (const file of hot) this.log("stars", "trace", `UPDATE ${displayPath(this.config.root, file)}`, { channel: "hmr" });
+			this.#settleProgress();
+			this.#emitStatus();
+			return;
+		}
 		this.#scheduleRestart(this.supervisor.state === "idle" ? "initial" : "build");
 	}
+	/**
+	* The files the build rewrote when all of them are pieces the running bot hot reloads, `null` when the bot has to
+	* be restarted instead: it is not running, it does not hot reload, `dev.hmr` is off, nothing changed (a rebuild for
+	* a reason that cannot be seen from the output), or a file changed that the bot cannot replace. What a build changed
+	* is the difference in content with the previous output, since a bundler rewrites files it did not change.
+	*
+	* The bot replaces the files it loaded pieces from, and loads a new file that could be one. A helper module next to
+	* the pieces (`_shared.js`, or any file no piece came from) is imported once and stays as it was: changing it
+	* needs a restart, even though it lies in a store path.
+	*/
+	#hotReloadable() {
+		if (this.config.dev.hmr === false) return null;
+		const roots = this.config.build.tool === "none" ? this.config.dev.watch : [this.config.build.outDir];
+		const previous = this.#files;
+		this.#files = snapshotFiles(roots, [this.locales.destination], this.#hashes);
+		if (previous === null || this.#hmrPaths.length === 0 || this.supervisor.state !== "running") return null;
+		const changed = changedFiles(previous, this.#files);
+		const replaceable = (file) => this.#hmrPaths.some((path) => isInside(file, path)) && (this.#pieces.has(file) || !previous.has(file) && couldBePiece(file));
+		return changed.length > 0 && changed.every(replaceable) ? changed : null;
+	}
 	#onBuildFailure(outcome) {
 		this.#lastBuild = outcome;
 		this.#queueHook("build:done", outcome, this.config);
@@ -467,6 +625,10 @@ var DevService = class extends EventEmitter {
 	#onExit(exit) {
 		this.#lastExit = exit;
 		this.#health = "unknown";
+		this.#ready = false;
+		this.#port = null;
+		this.#hmrPaths = [];
+		this.#pieces.clear();
 		if (!exit.requested) {
 			const how = exit.signal ? `signal ${exit.signal}` : `code ${exit.code}`;
 			this.log("stars", exit.code === 0 ? "warn" : "error", `The bot exited with ${how}, waiting for changes (press r to restart)`);
@@ -474,6 +636,7 @@ var DevService = class extends EventEmitter {
 		this.#emitStatus();
 	}
 	#scheduleRestart(reason) {
+		if (this.#paused) return;
 		this.#pendingReason = reason;
 		this.#clearRestartTimer();
 		this.#restartTimer = setTimeout(() => {
@@ -522,6 +685,141 @@ var DevService = class extends EventEmitter {
 			readyMs: this.#progress.readyMs ?? Date.now() - this.#progress.startedAt
 		};
 	}
+	/** Turns what the bot reports over the bridge into log entries and status. */
+	#onBridge(message) {
+		const relative = (path) => displayPath(this.config.root, path);
+		switch (message.type) {
+			case "ready":
+				this.#ready = true;
+				this.#port = message.port;
+				this.log("stars", "success", message.port === null ? "The bot is ready" : `Listening on port ${message.port}`, { channel: "lifecycle" });
+				if (this.#refreshPending) this.refreshCommands();
+				this.#emitStatus();
+				return;
+			case "pieces":
+				for (const piece of message.pieces) this.#pieces.add(piece.path);
+				if (message.pieces.length === 0) return;
+				this.log("stars", "debug", `Loaded ${message.store}: ${message.pieces.length} ${message.pieces.length === 1 ? "piece" : "pieces"}`, {
+					channel: message.store === "commands" ? "commands" : "lifecycle",
+					detail: message.pieces.map((piece) => `${piece.name} ${relative(piece.path)}`)
+				});
+				return;
+			case "hmr":
+				this.#onHmr(message);
+				return;
+			case "commands":
+				this.#onCommands({
+					global: message.global,
+					guilds: message.guilds
+				});
+				return;
+			case "dispatch":
+				if (message.phase === "run") this.log("stars", "debug", `Processing ${message.route} with ${message.piece}`, { channel: "interactions" });
+				else if (message.phase === "success") this.log("stars", "trace", `${message.route} handled${formatMs(message.ms)}`, { channel: "interactions" });
+				else this.log("stars", "error", `${message.route} failed${formatMs(message.ms)}: ${message.error.message}`, {
+					channel: "interactions",
+					detail: message.error.stack
+				});
+				return;
+			case "request":
+				this.log("stars", message.status >= 500 ? "error" : message.status >= 400 ? "warn" : "trace", formatRequest(message), { channel: "http" });
+				return;
+			case "refreshed":
+				if (message.ok) {
+					this.#deployed = this.#commands;
+					const guilds = (message.guilds > 0 ? `, ${message.guilds} guild ${message.guilds === 1 ? "group" : "groups"}` : "") + (message.cleared > 0 ? `, cleared ${message.cleared} ${message.cleared === 1 ? "guild" : "guilds"}` : "");
+					this.log("stars", "success", `Deployed ${message.global} global ${message.global === 1 ? "command" : "commands"}${guilds}`, { channel: "commands" });
+				} else this.log("stars", "error", `Could not refresh the commands: ${message.message}`, {
+					channel: "commands",
+					detail: message.stack
+				});
+				return;
+			case "log":
+				this.log("app", toLogLevel(message.level), message.text, {
+					channel: message.channel,
+					detail: message.detail
+				});
+				return;
+		}
+	}
+	#onHmr(message) {
+		const relative = (path) => displayPath(this.config.root, path);
+		if (message.event === "start") {
+			this.#hmrPaths = message.paths;
+			this.log("stars", "debug", `Hot reload on, watching ${message.paths.length} ${message.paths.length === 1 ? "path" : "paths"}`, {
+				channel: "hmr",
+				detail: message.paths.map(relative)
+			});
+			this.#emitStatus();
+			return;
+		}
+		if (message.event === "stop") {
+			this.#hmrPaths = [];
+			this.log("stars", "debug", "Hot reload off", { channel: "hmr" });
+			this.#emitStatus();
+			return;
+		}
+		if (message.event === "error") {
+			this.log("stars", "error", `Could not reload ${relative(message.path)}: ${message.message}`, {
+				channel: "hmr",
+				detail: message.stack
+			});
+			return;
+		}
+		if (message.event === "unloaded") this.#pieces.delete(message.path);
+		else this.#pieces.add(message.path);
+		const verb = message.event === "reloaded" ? "Reloaded" : message.event === "loaded" ? "Loaded" : "Unloaded";
+		this.log("stars", "debug", `${verb} ${message.names.join(", ")} from ${relative(message.path)}`, { channel: "hmr" });
+	}
+	/**
+	* Compares the commands the bot registers with the ones it reported before. The first report of a session is the
+	* baseline; a later one that differs is acted on as `dev.commands.refresh` says.
+	*/
+	#onCommands(snapshot) {
+		const previous = this.#commands;
+		this.#commands = snapshot;
+		if (previous === null) {
+			this.#deployed = snapshot;
+			const guilds = Object.keys(snapshot.guilds).length;
+			this.log("stars", "debug", `Loaded commands: ${snapshot.global.length} global, ${guilds} guild ${guilds === 1 ? "group" : "groups"}`, {
+				channel: "commands",
+				detail: snapshot.global.map((command) => describeCommand({
+					name: command.name,
+					type: command.type ?? 1,
+					guild: null
+				}))
+			});
+			return;
+		}
+		const changes = diffSnapshots(previous, snapshot);
+		if (changes.length === 0) return;
+		const detail = changes.map((change) => `${change.kind} ${describeCommand(change)}`);
+		const mode = this.config.dev.commands?.refresh ?? "prompt";
+		if (mode === "auto") {
+			this.log("stars", "info", "Commands updated", {
+				channel: "commands",
+				detail
+			});
+			this.refreshCommands();
+			return;
+		}
+		if (mode === "off" || !this.promptable) {
+			this.log("stars", "warn", "Commands updated, Discord still has the previous ones", {
+				channel: "commands",
+				detail: [...detail, mode === "off" ? "dev.commands.refresh is off" : "Set dev.commands.refresh to \"auto\" to redeploy without asking"]
+			});
+			return;
+		}
+		this.#prompt = {
+			kind: "commands",
+			changes: mergeChanges(this.#prompt?.changes ?? [], changes)
+		};
+		this.log("stars", "info", "Commands updated", {
+			channel: "commands",
+			detail
+		});
+		this.#emitStatus();
+	}
 	/**
 	* Runs a hook behind the ones already running (see {@link DevService.#hookChain}), e.g. `dev:close` so shutdown
 	* waits for an unfinished `build:done`.
@@ -565,6 +863,8 @@ function createSupervisor(config) {
 		command: process.execPath,
 		args: [
 			...envImportArgs(config),
+			...moduleImportArgs(config),
+			...bridgeImportArgs(config),
 			...config.dev.nodeArgs,
 			config.build.output,
 			...config.dev.args
@@ -577,9 +877,34 @@ function createSupervisor(config) {
 			NODE_ENV: "development",
 			FORCE_COLOR: process.env.NO_COLOR !== void 0 ? void 0 : process.env.FORCE_COLOR ?? (process.stdout.isTTY ? "1" : void 0)
 		},
-		killTimeout: config.dev.killTimeout
+		killTimeout: config.dev.killTimeout,
+		ipc: true
 	});
 }
+function formatMs(ms) {
+	return ms === null ? "" : ` in ${ms}ms`;
+}
+function formatRequest(message) {
+	return `${message.method} ${message.path} ${message.status} in ${message.ms}ms`;
+}
+const BRIDGE_LEVELS = /* @__PURE__ */ new Set([
+	"trace",
+	"debug",
+	"info",
+	"success",
+	"warn",
+	"error"
+]);
+function toLogLevel(level) {
+	return BRIDGE_LEVELS.has(level) ? level : "info";
+}
+/** The latest change of each command wins: `added` then `changed` is still one line of the prompt. */
+function mergeChanges(previous, next) {
+	const key = (change) => `${change.guild ?? ""}:${change.type}:${change.name}`;
+	const merged = new Map(previous.map((change) => [key(change), change]));
+	for (const change of next) merged.set(key(change), change);
+	return [...merged.values()];
+}
 function describeReason(reason) {
 	switch (reason) {
 		case "initial": return "first build";
@@ -622,8 +947,8 @@ async function withResolvedLocalhost(url) {
 //#region src/dev/log-file.ts
 /**
 * Mirrors a dev session's logs into a file, so a run can be read back after the terminal UI is gone (the TUI takes
-* over the alternate screen and its scrollback disappears on exit). Seedcord keeps a `logs/` directory for the same
-* reason; this writes a single, truncated-per-run file instead.
+* over the alternate screen and its scrollback disappears on exit). `dev.logFile` is a single file truncated on every
+* run; `dev.logs.dir` adds one file per run (see {@link runLogFile}).
 */
 var LogFileWriter = class {
 	file;
@@ -649,20 +974,57 @@ var LogFileWriter = class {
 		stream.end();
 	}
 	#write = (entry) => {
-		this.#stream?.write(`${format(entry)}\n`);
+		this.#stream?.write(`${formatLogLine(entry)}\n`);
 	};
 };
-function format(entry) {
-	return `${new Date(entry.time).toISOString()} ${entry.level.padEnd(7)} ${entry.source.padEnd(6)} ${entry.text}`;
+/** One line per entry, then its detail lines indented under it. Never filtered: the file is the whole session. */
+function formatLogLine(entry) {
+	return [`${new Date(entry.time).toISOString()} ${entry.level.padEnd(7)} ${entry.channel.padEnd(12)} ${stripVTControlCharacters(entry.text)}`, ...(entry.detail ?? []).map((line) => `  ${stripVTControlCharacters(line)}`)].join("\n");
+}
+const RUN_FILE = /^dev-.+\.log$/;
+/**
+* The file of this run inside `dev.logs.dir` (`dev-<timestamp>.log`), after deleting the oldest ones so the directory
+* holds at most `keep` files with the new one. The names sort by time, so no file needs to be opened to order them.
+*/
+function runLogFile(directory, keep, now = /* @__PURE__ */ new Date()) {
+	let existing = [];
+	try {
+		existing = readdirSync(directory).filter((name) => RUN_FILE.test(name)).sort();
+	} catch {}
+	for (const name of existing.slice(0, Math.max(0, existing.length - Math.max(0, keep - 1)))) rmSync(join(directory, name), { force: true });
+	return join(directory, `dev-${now.toISOString().replaceAll(":", "-")}.log`);
 }
 
 //#endregion
 //#region src/commands/dev.ts
+const LAYOUTS = [
+	"auto",
+	"dashboard",
+	"panel"
+];
+const LEVELS = [
+	"trace",
+	"debug",
+	"info",
+	"warn",
+	"error"
+];
 async function runDev(options) {
 	if (options.theme !== void 0 && !isThemeSetting(options.theme)) throw cliDiagnostics.INVALID_THEME({
 		theme: options.theme,
 		themes: THEME_SETTINGS.join(", ")
 	});
+	const layout = options.layout;
+	if (layout !== void 0 && !LAYOUTS.includes(layout)) throw cliDiagnostics.INVALID_OPTION({
+		option: "--layout",
+		value: options.layout,
+		allowed: LAYOUTS.join(", ")
+	});
+	if (options.level !== void 0 && !isLogLevel(options.level)) throw cliDiagnostics.INVALID_OPTION({
+		option: "--level",
+		value: options.level,
+		allowed: LEVELS.join(", ")
+	});
 	process.env.NODE_ENV = "development";
 	const project = await loadProject({
 		cwd: resolveCwd(options),
@@ -686,24 +1048,33 @@ async function runDev(options) {
 		builder,
 		hooks
 	});
-	await reportWarnings(config, (text) => service.log("stars", "warn", text));
-	const logFile = config.dev.logFile ? new LogFileWriter(config.dev.logFile, service.logs) : null;
-	logFile?.open();
-	const renderer = mode === "tui" ? (await import("./tui-BRddrLQP.js")).createTuiRenderer(service, {
+	await reportWarnings(config, (text) => service.log("stars", "warn", text), { production: false });
+	const logFiles = [...config.dev.logFile ? [config.dev.logFile] : [], ...config.dev.logs?.dir ? [runLogFile(config.dev.logs.dir, config.dev.logs.keep)] : []].map((file) => new LogFileWriter(file, service.logs));
+	for (const file of logFiles) file.open();
+	const filter = initialLogView(config, {
+		channels: options.channel,
+		level: options.level
+	});
+	const renderer = mode === "tui" ? (await import("./tui-nldGSD4c.js")).createTuiRenderer(service, {
 		color,
 		theme,
+		layout,
+		filter,
 		reducedMotion: prefersReducedMotion(),
 		onThemeSave: (setting) => {
 			if (!saveTheme(setting)) service.log("stars", "warn", "Could not save the theme preference.");
 		}
-	}) : (await import("./plain-B6z85uQP.js")).createPlainRenderer(service, { color });
+	}) : (await import("./plain-DG7cy0Kk.js")).createPlainRenderer(service, {
+		color,
+		filter
+	});
 	let exiting = null;
 	const shutdown = (code) => {
 		exiting ??= (async () => {
 			renderer.stop();
 			await service.runHook("dev:close", config);
 			await service.stop();
-			logFile?.close();
+			for (const file of logFiles) file.close();
 			process.exit(code);
 		})();
 		return exiting;
@@ -765,18 +1136,34 @@ var dev_default = defineCommand({
 		theme: {
 			type: "string",
 			description: `Colour theme of the interactive UI: ${THEME_SETTINGS.join(", ")} (or STARS_THEME; press T in the UI to pick one)`
+		},
+		layout: {
+			type: "string",
+			description: `Layout of the interactive UI: ${LAYOUTS.join(", ")} (defaults to dev.layout; press v in the UI to switch)`
+		},
+		channel: {
+			type: "string",
+			description: "Only show these log channels at start (repeatable, or comma-separated; defaults to dev.logs.channels)"
+		},
+		level: {
+			type: "string",
+			description: `Only show this log level and the more severe ones at start: ${LEVELS.join(", ")} (defaults to dev.logs.levels)`
 		}
 	},
-	async run({ args }) {
+	async run({ args, rawArgs }) {
+		const channel = collectFlag(rawArgs, "channel");
 		await runDev({
 			config: args.config,
 			cwd: args.cwd,
 			tui: args.tui ? void 0 : false,
-			theme: args.theme
+			theme: args.theme,
+			layout: args.layout,
+			channel: channel.length > 0 ? channel : void 0,
+			level: args.level
 		});
 	}
 });
 
 //#endregion
 export { dev_default as default };
-//# sourceMappingURL=dev-4wpEQC7l.js.map
+//# sourceMappingURL=dev-oPPVR7d_.js.map