@seedcord/cli 0.2.1-next.0 → 0.3.0-next.0

package/dist/cli.mjs

@@ -1,10 +1,10 @@
-import { n as SEEDCORD_CONFIG_FILENAMES, t as version } from "./src-DdCl8vfD.mjs";
+import { n as SEEDCORD_CONFIG_FILENAMES, t as version } from "./src-DP3zjFwE.mjs";
 import { createRequire } from "node:module";
 import { Command } from "@commander-js/extra-typings";
 import { Logger, LoggerChannelRegistry, StrictEventEmitter } from "@seedcord/services";
 import { SeedcordErrorCode, isSeedcordError } from "@seedcord/errors";
 import { existsSync } from "node:fs";
-import { SeedcordError } from "@seedcord/errors/internal";
+import { SeedcordError, validateDiscordToken } from "@seedcord/errors/internal";
 import { dirname, extname, isAbsolute, join, relative, resolve } from "node:path";
 import { pathToFileURL } from "node:url";
 import { createJiti } from "jiti";
@@ -13,14 +13,18 @@ import { mkdir, readFile, readdir, writeFile } from "node:fs/promises";
 import { spawn } from "node:child_process";
 import { SeedcordBrand } from "@seedcord/types/internal";
 import { assertNever, formatFilePath, isTsOrJsFile } from "@seedcord/utils";
-import { ApplicationCommandOptionType, ApplicationCommandType } from "discord-api-types/v10";
+import { ApplicationCommandOptionType, ApplicationCommandType, Routes } from "discord-api-types/v10";
 import { routeLeavesOf } from "@seedcord/utils/internal";
+import { Envapter } from "envapt";
+import { REST } from "@discordjs/rest";
+import chalk from "chalk";
+import { autocompleteMultiselect, cancel, confirm, intro, isCancel, log, multiselect, note, outro, select, spinner } from "@clack/prompts";
+import { createInterface } from "node:readline";
 import { Box, Text, measureElement, render, useAnimation, useInput, useWindowSize } from "ink";
 import React, { useCallback, useEffect, useMemo, useRef, useState, useSyncExternalStore } from "react";
 import Spinner from "ink-spinner";
 import { createServer, createServerModuleRunner, defineConfig, mergeConfig } from "vite";
 import { EvaluatedModules } from "vite/module-runner";
-import chalk from "chalk";
 import { minimatch } from "minimatch";
 
 //#region src/core/BaseCommand.ts
@@ -469,7 +473,7 @@ var BuildCommand = class extends BaseCommand {
 };
 
 //#endregion
-//#region src/commands/codegen/RegistryGenerator.ts
+//#region src/commands/codegen/AugmentationBuilder.ts
 const KIND_BY_TYPE = {
 	[ApplicationCommandOptionType.String]: "string",
 	[ApplicationCommandOptionType.Integer]: "integer",
@@ -481,17 +485,23 @@ const KIND_BY_TYPE = {
 	[ApplicationCommandOptionType.Mentionable]: "mentionable",
 	[ApplicationCommandOptionType.Attachment]: "attachment"
 };
+function mapEmojis(emojiConfig) {
+	const emojis = {};
+	for (const [key, value] of Object.entries(emojiConfig)) emojis[key] = Array.isArray(value) ? "tuple" : "string";
+	return emojis;
+}
 /**
-* Builds the generated registry from each command's `toJSON()`. Chat-input commands become the slash-option
-* tables, context-menu commands contribute their name to the user or message set. Reads the builder back
-* because djs erases option names at the type level.
+* Builds the generated augmentations from each command's `toJSON()` plus the emoji config. Chat-input
+* commands become the slash-option tables, context-menu commands contribute their name to the user or
+* message set, and each emoji key becomes a kind tag. Reads the builder back because djs erases option
+* names at the type level.
 */
-var RegistryGenerator = class {
+var AugmentationBuilder = class {
 	logger;
 	constructor(logger) {
 		this.logger = logger;
 	}
-	generate(commands) {
+	generate(commands, emojiConfig) {
 		const slash = {};
 		const sourceByRoute = /* @__PURE__ */ new Map();
 		const sourceByUserName = /* @__PURE__ */ new Map();
@@ -504,11 +514,13 @@ var RegistryGenerator = class {
 		}
 		const userContextMenus = [...sourceByUserName.keys()];
 		const messageContextMenus = [...sourceByMessageName.keys()];
-		this.logger.debug(`Generated ${Object.keys(slash).length} slash route(s), ${userContextMenus.length} user and ${messageContextMenus.length} message context-menu command(s)`);
+		const emojis = mapEmojis(emojiConfig);
+		this.logger.debug(`Generated ${Object.keys(slash).length} slash route(s), ${userContextMenus.length} user and ${messageContextMenus.length} message context-menu command(s), ${Object.keys(emojis).length} emoji(s)`);
 		return {
 			slash,
 			userContextMenus,
-			messageContextMenus
+			messageContextMenus,
+			emojis
 		};
 	}
 	collectSlash(json, sourceFile, slash, sourceByRoute) {
@@ -555,24 +567,20 @@ var RegistryGenerator = class {
 };
 
 //#endregion
-//#region src/commands/codegen/renderRegistry.ts
+//#region src/commands/codegen/renderAugmentation.ts
 const BANNER = `// Generated by \`seedcord codegen\`. Do not edit by hand.
-// Run \`seedcord codegen\` after changing a command's options.`;
-const DISCLAIMER = `    /**
-     * These option types come from your command source. Redeploy your commands to Discord after regenerating,
-     * or an interaction from a stale command can return null for an option this file types as non-null.
-     */`;
+// Run \`seedcord codegen\` after changing your commands or emoji config.`;
 const IDENTIFIER = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
 const CONTROL_CHAR = 32;
 const HEX_RADIX = 16;
 /**
-* Renders the generated registry into the committed `declare module 'seedcord'` file, the slash option
-* tables plus the user and message context-menu name registries, all in one augmentation block. Keys are
+* Renders the built augmentations into the committed `declare module 'seedcord'` file, the slash option
+* tables, the user and message context-menu name registries, and the emoji map, all in one block. Keys are
 * sorted so the output is stable across filesystems. The result is byte-stable so `seedcord codegen --check`
 * can diff it directly.
 */
-function renderRegistry(registry) {
-	return `${BANNER}\n\ndeclare module 'seedcord' {\n${DISCLAIMER}\n    interface SlashOptionRegistry {\n${renderSlashRows(registry.slash)}\n    }\n    interface UserContextMenuRegistry {\n${renderContextMenuRows(registry.userContextMenus)}\n    }\n    interface MessageContextMenuRegistry {\n${renderContextMenuRows(registry.messageContextMenus)}\n    }\n}\n\nexport {};\n`;
+function renderAugmentation(registry) {
+	return `${BANNER}\n\ndeclare module 'seedcord' {\n    interface SlashOptionRegistry {\n${renderSlashRows(registry.slash)}\n    }\n    interface UserContextMenuRegistry {\n${renderContextMenuRows(registry.userContextMenus)}\n    }\n    interface MessageContextMenuRegistry {\n${renderContextMenuRows(registry.messageContextMenus)}\n    }\n    interface EmojiMap {\n${renderEmojiRows(registry.emojis)}\n    }\n}\n\nexport {};\n`;
 }
 function renderSlashRows(tables) {
 	return Object.entries(tables).sort(([first], [second]) => compare(first, second)).map(([route, options]) => `        ${renderKey(route)}: ${renderRow(options)};`).join("\n");
@@ -580,6 +588,9 @@ function renderSlashRows(tables) {
 function renderContextMenuRows(names) {
 	return [...names].sort(compare).map((name) => `        ${renderName(name)}: true;`).join("\n");
 }
+function renderEmojiRows(emojis) {
+	return Object.entries(emojis).sort(([first], [second]) => compare(first, second)).map(([key, kind]) => `        ${renderName(key)}: '${kind === "tuple" ? "guild" : "application"}';`).join("\n");
+}
 function renderRow(options) {
 	const entries = Object.entries(options);
 	if (entries.length === 0) return "{}";
@@ -622,11 +633,11 @@ function compare(first, second) {
 
 //#endregion
 //#region src/commands/codegen/CodegenRunner.ts
-const OUTPUT_FILENAME = "command-registry.gen.ts";
+const OUTPUT_FILENAME = "seedcord-gen.d.ts";
 /**
 * Orchestrates `seedcord codegen`. Locates and loads the CLI config, imports the user's Seedcord instance to
-* read its commands directory, scans and instantiates each command for its `toJSON()`, then renders the
-* registry and either writes it or, under `--check`, diffs it against the committed file.
+* read its commands directory and emoji config, scans and instantiates each command for its `toJSON()`, then
+* renders the augmentations and either writes them or, under `--check`, diffs against the committed file.
 */
 var CodegenRunner = class CodegenRunner {
 	locator;
@@ -643,11 +654,12 @@ var CodegenRunner = class CodegenRunner {
 	}
 	static create(logger) {
 		const moduleLoader = new RuntimeModuleLoader();
-		return new CodegenRunner(new ConfigLocator(logger), new ConfigLoader(moduleLoader, logger), moduleLoader, new RegistryGenerator(logger), logger);
+		return new CodegenRunner(new ConfigLocator(logger), new ConfigLoader(moduleLoader, logger), moduleLoader, new AugmentationBuilder(logger), logger);
 	}
 	async run(check) {
 		const config = await this.loadConfig();
-		const rendered = renderRegistry(this.generator.generate(await this.scan(config)));
+		const { commands, emojis } = await this.scan(config);
+		const rendered = renderAugmentation(this.generator.generate(commands, emojis));
 		const outputPath = resolve(config.root, OUTPUT_FILENAME);
 		if (check) {
 			await this.check(rendered, outputPath);
@@ -659,11 +671,13 @@ var CodegenRunner = class CodegenRunner {
 		return this.configLoader.load(this.locator.locate());
 	}
 	async scan(config) {
-		const commandsDir = await this.resolveCommandsDir(config);
-		if (!commandsDir) return [];
+		const { commandsDir, emojis } = await this.resolveInstance(config);
 		const commands = [];
-		await this.walk(commandsDir, commands, /* @__PURE__ */ new Set(), true);
-		return commands;
+		if (commandsDir) await this.walk(commandsDir, commands, /* @__PURE__ */ new Set(), true);
+		return {
+			commands,
+			emojis
+		};
 	}
 	async walk(dir, commands, seen, isRoot) {
 		let entries;
@@ -692,12 +706,15 @@ var CodegenRunner = class CodegenRunner {
 			}
 		}
 	}
-	async resolveCommandsDir(config) {
+	async resolveInstance(config) {
 		this.logger.info("Loading instance to resolve the commands directory");
 		const instance = resolveDefaultExport(await this.moduleLoader.importModule(config.instance));
 		if (!this.isSeedcordInstance(instance)) throw new SeedcordError(SeedcordErrorCode.CliInstanceInvalid);
 		const commandsPath = instance.config.bot.commands.path;
-		return commandsPath ? resolve(process.cwd(), commandsPath) : void 0;
+		return {
+			commandsDir: commandsPath ? resolve(process.cwd(), commandsPath) : void 0,
+			emojis: instance.config.bot.emojis ?? {}
+		};
 	}
 	commandJsonOf(exported) {
 		if (typeof exported !== "function") return void 0;
@@ -729,11 +746,11 @@ var CodegenRunner = class CodegenRunner {
 	async write(rendered, outputPath) {
 		await mkdir(dirname(outputPath), { recursive: true });
 		await writeFile(outputPath, rendered, "utf8");
-		this.logger.info(`Command registry written to ${outputPath}`);
+		this.logger.info(`Augmentations written to ${outputPath}`);
 	}
 	async check(rendered, outputPath) {
 		if ((existsSync(outputPath) ? await readFile(outputPath, "utf8") : "") === rendered) return;
-		this.logger.error(`Command registry is out of date. Run \`seedcord codegen\` and commit ${outputPath}.`);
+		this.logger.error(`Augmentations are out of date. Run \`seedcord codegen\` and commit ${outputPath}.`);
 		process.exitCode = 1;
 	}
 };
@@ -743,11 +760,11 @@ var CodegenRunner = class CodegenRunner {
 var CodegenCommand = class extends BaseCommand {
 	runner;
 	constructor() {
-		super("codegen", "Generate the typed command registry (slash options and context menus) from your commands", "CLI:Codegen");
+		super("codegen", "Generate typed augmentations (slash options, context menus, emojis) from your commands and config", "CLI:Codegen");
 		this.runner = CodegenRunner.create(this.logger);
 	}
 	register(program) {
-		program.command(this.name).description(this.description).option("--check", "Verify the committed registry is up to date instead of writing it").action(async (options) => {
+		program.command(this.name).description(this.description).option("--check", "Verify the committed augmentations are up to date instead of writing them").action(async (options) => {
 			try {
 				await this.runner.run(options.check ?? false);
 			} catch (error) {
@@ -759,6 +776,547 @@ var CodegenCommand = class extends BaseCommand {
 	}
 };
 
+//#endregion
+//#region src/core/interactive.ts
+function isInteractive(opts, hasActionFlags) {
+	return !hasActionFlags && process.stdin.isTTY === true && process.stdout.isTTY === true && !process.env.CI && !opts.yes;
+}
+
+//#endregion
+//#region src/commands/commands/classify.ts
+/**
+* Selects which deployed guild commands `commands --clean` would delete. An overlap is a guild command whose
+* name also exists globally, so it renders twice in the picker. Under `purge` every guild command is selected.
+* Global commands are never passed in here, so they are never deleted.
+*/
+function classifyGuildCommands(globalNames, guilds, purge) {
+	const flagged = [];
+	for (const { guildId, guildName, commands } of guilds) for (const command of commands) if (purge) flagged.push({
+		guildId,
+		guildName,
+		id: command.id,
+		name: command.name,
+		reason: "purge"
+	});
+	else if (globalNames.has(command.name)) flagged.push({
+		guildId,
+		guildName,
+		id: command.id,
+		name: command.name,
+		reason: "overlap"
+	});
+	return flagged;
+}
+
+//#endregion
+//#region src/commands/commands/CleanRunner.ts
+const GUILD_PAGE = 200;
+var CleanRunner = class CleanRunner {
+	makeRest;
+	constructor(makeRest) {
+		this.makeRest = makeRest;
+	}
+	static create() {
+		return new CleanRunner((token) => new REST({ version: "10" }).setToken(token));
+	}
+	async resolveTargets(scope, token) {
+		if (scope.purge && scope.allGuilds) throw new SeedcordError(SeedcordErrorCode.CliCleanPurgeAllGuilds);
+		if (!scope.allGuilds && scope.guildIds.length === 0) throw new SeedcordError(SeedcordErrorCode.CliCleanNoGuilds);
+		const rest = this.makeRest(token);
+		return {
+			appId: await this.resolveAppId(rest),
+			guilds: scope.allGuilds ? await this.fetchBotGuilds(rest) : scope.guildIds.map((id) => ({
+				id,
+				name: id
+			}))
+		};
+	}
+	async listBotGuilds(token) {
+		return this.fetchBotGuilds(this.makeRest(token));
+	}
+	async scanGuilds(token, appId, guilds, purge) {
+		const rest = this.makeRest(token);
+		const globalNames = await this.fetchGlobalNames(rest, appId);
+		const buckets = [];
+		const skipped = [];
+		let scannedCommandCount = 0;
+		for (const guild of guilds) try {
+			const commands = (await rest.get(Routes.applicationGuildCommands(appId, guild.id))).map((command) => ({
+				id: command.id,
+				name: command.name
+			}));
+			scannedCommandCount += commands.length;
+			buckets.push({
+				guildId: guild.id,
+				guildName: guild.name,
+				commands
+			});
+		} catch (error) {
+			skipped.push({
+				guildId: guild.id,
+				guildName: guild.name,
+				reason: error instanceof Error ? error.message : "Unknown error"
+			});
+		}
+		return {
+			flagged: classifyGuildCommands(globalNames, buckets, purge),
+			skipped,
+			scannedGuildCount: buckets.length,
+			scannedCommandCount,
+			globalCommandCount: globalNames.size
+		};
+	}
+	async applyDeletions(token, appId, flagged) {
+		const rest = this.makeRest(token);
+		let deleted = 0;
+		const failed = [];
+		for (const command of flagged) try {
+			await rest.delete(Routes.applicationGuildCommand(appId, command.guildId, command.id));
+			deleted++;
+		} catch (error) {
+			failed.push({
+				command,
+				reason: error instanceof Error ? error.message : "Unknown error"
+			});
+		}
+		return {
+			deleted,
+			failed
+		};
+	}
+	async resolveAppId(rest) {
+		try {
+			return (await rest.get(Routes.currentApplication())).id;
+		} catch (error) {
+			const reason = error instanceof Error ? error.message : "Unknown error";
+			throw new SeedcordError(SeedcordErrorCode.CliCleanAppFetchFailed, [reason]);
+		}
+	}
+	async fetchBotGuilds(rest) {
+		const guilds = [];
+		let after;
+		for (;;) {
+			const query = new URLSearchParams({ limit: String(GUILD_PAGE) });
+			if (after) query.set("after", after);
+			const page = await rest.get(Routes.userGuilds(), { query });
+			for (const guild of page) guilds.push({
+				id: guild.id,
+				name: guild.name
+			});
+			after = page.at(-1)?.id;
+			if (page.length < GUILD_PAGE || !after) break;
+		}
+		return guilds;
+	}
+	async fetchGlobalNames(rest, appId) {
+		const global = await rest.get(Routes.applicationCommands(appId));
+		return new Set(global.map((command) => command.name));
+	}
+};
+
+//#endregion
+//#region src/core/format.ts
+function plural(count, singular, pluralForm = `${singular}s`) {
+	return `${count} ${count === 1 ? singular : pluralForm}`;
+}
+function includesIgnoreCase(text, search) {
+	return text.toLowerCase().includes(search.trim().toLowerCase());
+}
+
+//#endregion
+//#region src/core/prompts/requireValue.ts
+function requireValue(value) {
+	if (isCancel(value)) {
+		cancel("Cancelled.");
+		throw new SeedcordError(SeedcordErrorCode.CliCancelled);
+	}
+	return value;
+}
+
+//#endregion
+//#region src/core/prompts/pickFromList.ts
+const DEFAULT_MAX_ITEMS = 10;
+const SEARCH_THRESHOLD = 12;
+/**
+* Multi-pick from a set, sized to the list: a plain checkbox multiselect for a short list, search-as-you-type
+* for a long one. Returns the selected ids, or throws CliCancelled if the prompt is cancelled.
+*/
+async function pickFromList(opts) {
+	const options = opts.items.map((item) => ({
+		value: item.id,
+		label: item.name
+	}));
+	const maxItems = opts.maxItems ?? DEFAULT_MAX_ITEMS;
+	if (opts.items.length <= SEARCH_THRESHOLD) return requireValue(await multiselect({
+		message: opts.message,
+		options,
+		maxItems,
+		required: false
+	}));
+	return requireValue(await autocompleteMultiselect({
+		message: opts.message,
+		options,
+		maxItems,
+		placeholder: "Type to search...",
+		filter: (search, option) => includesIgnoreCase(option.label ?? "", search) || includesIgnoreCase(String(option.value), search)
+	}));
+}
+
+//#endregion
+//#region src/core/prompts/index.ts
+async function select$1(opts) {
+	return requireValue(await select(opts));
+}
+async function confirm$1(opts) {
+	return requireValue(await confirm(opts));
+}
+
+//#endregion
+//#region src/commands/commands/confirm.ts
+async function readlineAsk(question) {
+	const rl = createInterface({
+		input: process.stdin,
+		output: process.stdout
+	});
+	try {
+		return await new Promise((resolve) => rl.question(question, resolve));
+	} finally {
+		rl.close();
+	}
+}
+/**
+* Gates a destructive delete behind typing the exact count, so a mistyped, empty, or non-numeric answer
+* aborts with nothing deleted.
+*/
+async function confirmCount(count, logger, ask = readlineAsk) {
+	logger.warn(`About to delete ${count} guild command(s). This cannot be undone.`);
+	return (await ask(`Type ${count} to confirm (anything else aborts) `)).trim() === String(count);
+}
+
+//#endregion
+//#region src/commands/commands/cleanPresenters.ts
+function groupByGuild(flagged) {
+	const groups = /* @__PURE__ */ new Map();
+	for (const command of flagged) {
+		const group = groups.get(command.guildId) ?? {
+			guildName: command.guildName,
+			commands: []
+		};
+		group.commands.push(command);
+		groups.set(command.guildId, group);
+	}
+	return [...groups.values()];
+}
+function skippedSummary(skipped) {
+	return `Could not read ${plural(skipped.length, "guild")} (${skipped.map((s) => s.guildName).join(", ")}).`;
+}
+function emptyLines(scan, outcome) {
+	return {
+		"all-skipped": {
+			info: [],
+			outro: `Could not read any of the ${plural(scan.skipped.length, "guild")}, nothing was scanned.`
+		},
+		"no-commands": {
+			info: [],
+			outro: `Scanned ${plural(scan.scannedGuildCount, "guild")} with no guild commands deployed. Nothing to clean.`
+		},
+		"no-globals": {
+			info: ["This app has no global commands, so nothing can duplicate one.", "Re-run and choose a full reset to remove guild commands."],
+			outro: "Nothing to clean."
+		},
+		"no-overlaps": {
+			info: [`Scanned ${plural(scan.scannedCommandCount, "guild command")} across ${plural(scan.scannedGuildCount, "guild")}. None duplicate a global command.`, "Re-run and choose a full reset to remove all of them."],
+			outro: "Nothing to clean."
+		}
+	}[outcome];
+}
+/** Renders the clean flow as clack framed output for an interactive terminal. */
+var InteractivePresenter = class {
+	async status(message, task, done) {
+		const status = spinner();
+		status.start(message);
+		try {
+			return await task();
+		} finally {
+			status.stop(done ?? message);
+		}
+	}
+	preview(scan) {
+		note(groupByGuild(scan.flagged).map((group) => `${chalk.bold(group.guildName)}\n${group.commands.map((c) => `  ${c.name}`).join("\n")}`).join("\n\n"), `Will delete ${plural(scan.flagged.length, "guild command")} (nothing deleted yet)`);
+		if (scan.skipped.length > 0) log.warn(skippedSummary(scan.skipped));
+	}
+	largeBotGuard(guildCount) {
+		return confirm$1({
+			message: `The bot is in ${guildCount} guilds. Scan all of them? This makes ${guildCount} requests.`,
+			initialValue: false
+		});
+	}
+	confirmDelete(count, skippedCount) {
+		const skips = skippedCount > 0 ? ` ${plural(skippedCount, "guild")} could not be read.` : "";
+		return confirm$1({
+			message: `Delete ${plural(count, "guild command")}? This cannot be undone.${skips}`,
+			initialValue: false
+		});
+	}
+	result(deletion, skipped) {
+		for (const failure of deletion.failed) log.warn(`Could not delete ${failure.command.name} in ${failure.command.guildName} (${failure.reason}).`);
+		if (skipped.length > 0) log.warn(skippedSummary(skipped));
+		outro(`Deleted ${plural(deletion.deleted, "guild command")}. Global commands untouched.`);
+	}
+	nothingToClean(scan, outcome) {
+		const lines = emptyLines(scan, outcome);
+		for (const line of lines.info) log.info(line);
+		outro(lines.outro);
+	}
+	dryRunHint() {
+		outro("Dry run, nothing was deleted.");
+	}
+};
+/** Renders the clean flow as plain logger lines for the flag, CI, and non-TTY path. */
+var FlagPresenter = class {
+	logger;
+	yes;
+	constructor(logger, yes) {
+		this.logger = logger;
+		this.yes = yes;
+	}
+	status(message, task) {
+		this.logger.info(message);
+		return task();
+	}
+	preview(scan) {
+		this.logger.info(chalk.bold(`${plural(scan.flagged.length, "guild command")} selected for deletion`));
+		for (const group of groupByGuild(scan.flagged)) {
+			this.logger.info(chalk.cyan(group.guildName));
+			for (const command of group.commands) this.logger.info(`  ${command.name}`);
+		}
+		for (const skip of scan.skipped) this.logger.warn(`Skipped ${skip.guildName} (${skip.reason}).`);
+	}
+	largeBotGuard(guildCount) {
+		if (this.yes) return Promise.resolve(true);
+		return Promise.reject(new SeedcordError(SeedcordErrorCode.CliCleanLargeBotUnconfirmed, [guildCount]));
+	}
+	confirmDelete(count, skippedCount) {
+		if (this.yes) return Promise.resolve(true);
+		if (!process.stdin.isTTY || !process.stdout.isTTY) return Promise.reject(new SeedcordError(SeedcordErrorCode.CliCleanApplyNeedsYes));
+		if (skippedCount > 0) this.logger.warn(`${plural(skippedCount, "guild")} could not be read and were not scanned.`);
+		return confirmCount(count, this.logger);
+	}
+	result(deletion, skipped) {
+		for (const failure of deletion.failed) this.logger.warn(`Could not delete ${failure.command.name} in ${failure.command.guildName} (${failure.reason}).`);
+		if (skipped.length > 0) this.logger.warn(skippedSummary(skipped));
+		this.logger.info(chalk.green(`Deleted ${plural(deletion.deleted, "guild command")}. Global commands untouched.`));
+	}
+	nothingToClean(scan, outcome) {
+		const lines = emptyLines(scan, outcome);
+		for (const line of lines.info) this.logger.info(line);
+		this.logger.info(chalk.green(lines.outro));
+	}
+	dryRunHint() {
+		this.logger.info(chalk.italic("Dry run. Re-run with --apply to delete the above."));
+	}
+};
+
+//#endregion
+//#region src/commands/commands/executeClean.ts
+const LARGE_BOT_THRESHOLD = 200;
+/** Why a scan found nothing to delete, so the caller can explain it instead of a bare "nothing to clean". */
+function emptyOutcome(scan, purge) {
+	if (scan.scannedGuildCount === 0 && scan.skipped.length > 0) return "all-skipped";
+	if (scan.scannedCommandCount === 0) return "no-commands";
+	if (!purge && scan.globalCommandCount === 0) return "no-globals";
+	return "no-overlaps";
+}
+/**
+* The dry-run-then-confirm flow for `commands --clean`. Resolves targets, scans, previews, and only deletes
+* once `apply` is set and the presenter confirms. The presenter owns all output and the two confirmations,
+* so the wizard and the flag path share this flow with different presenters.
+*/
+async function executeClean(request) {
+	const { runner, scope, apply, token, presenter, knownGuilds } = request;
+	const { appId, guilds } = await presenter.status("Connecting to Discord...", () => runner.resolveTargets(scope, token), "Connected to Discord.");
+	if (scope.allGuilds && guilds.length > 200) {
+		if (!await presenter.largeBotGuard(guilds.length)) return;
+	}
+	const scan = await presenter.status(`Scanning ${plural(guilds.length, "guild")} for commands...`, () => runner.scanGuilds(token, appId, overlayNames(guilds, knownGuilds), scope.purge), `Scanned ${plural(guilds.length, "guild")}.`);
+	if (scan.flagged.length === 0) {
+		presenter.nothingToClean(scan, emptyOutcome(scan, scope.purge));
+		return;
+	}
+	presenter.preview(scan);
+	if (!apply) {
+		presenter.dryRunHint();
+		return;
+	}
+	if (!await presenter.confirmDelete(scan.flagged.length, scan.skipped.length)) return;
+	const deletion = await presenter.status(`Deleting ${plural(scan.flagged.length, "guild command")}...`, () => runner.applyDeletions(token, appId, scan.flagged), "Deletion complete.");
+	presenter.result(deletion, scan.skipped);
+}
+function overlayNames(guilds, knownGuilds) {
+	if (!knownGuilds?.length) return guilds;
+	const known = new Map(knownGuilds.map((guild) => [guild.id, guild.name]));
+	return guilds.map((guild) => ({
+		id: guild.id,
+		name: known.get(guild.id) ?? guild.name
+	}));
+}
+
+//#endregion
+//#region src/commands/commands/flagClean.ts
+/** Runs `seedcord commands --clean ...` headlessly from parsed flags, reproducing any wizard run. */
+async function runCleanFromFlags(runner, flags, token, logger) {
+	await executeClean({
+		runner,
+		scope: {
+			guildIds: flags.guildIds,
+			allGuilds: flags.allGuilds,
+			purge: flags.purge
+		},
+		apply: flags.apply,
+		token,
+		presenter: new FlagPresenter(logger, flags.yes)
+	});
+}
+
+//#endregion
+//#region src/commands/commands/wizard.ts
+async function runCleanWizard(runner, token) {
+	intro("seedcord commands");
+	const plan = await buildScope(runner, token);
+	if (!plan) return;
+	await executeClean({
+		runner,
+		scope: plan.scope,
+		apply: true,
+		token,
+		presenter: new InteractivePresenter(),
+		knownGuilds: plan.knownGuilds
+	});
+}
+async function buildScope(runner, token) {
+	if (await select$1({
+		message: "Remove guild commands that duplicate a global command. Which guilds?",
+		options: [{
+			value: "pick",
+			label: "Pick specific guilds"
+		}, {
+			value: "all",
+			label: "All guilds the bot is in",
+			hint: "duplicates only, pick specific guilds for a full reset"
+		}]
+	}) === "all") return { scope: {
+		guildIds: [],
+		allGuilds: true,
+		purge: false
+	} };
+	const status = spinner();
+	status.start("Fetching the guilds the bot is in...");
+	let guilds;
+	try {
+		guilds = await runner.listBotGuilds(token);
+	} catch (error) {
+		status.stop("Could not fetch the guild list.");
+		throw error;
+	}
+	status.stop(`Found ${plural(guilds.length, "guild")}.`);
+	if (guilds.length === 0) {
+		outro("The bot is in no guilds.");
+		return;
+	}
+	let guildIds;
+	if (guilds.length > 1) {
+		guildIds = await pickFromList({
+			message: "Select guilds to clean",
+			items: guilds
+		});
+		if (guildIds.length === 0) {
+			outro("No guilds selected.");
+			return;
+		}
+	} else {
+		const only = guilds[0];
+		if (!only) return void 0;
+		guildIds = [only.id];
+		log.info(`Only one guild, using ${only.name}.`);
+	}
+	const mode = await select$1({
+		message: "What should I remove?",
+		options: [{
+			value: "overlap",
+			label: "Only duplicates of a global command (recommended)"
+		}, {
+			value: "purge",
+			label: "Every command in these guilds (full reset)"
+		}]
+	});
+	return {
+		scope: {
+			guildIds,
+			allGuilds: false,
+			purge: mode === "purge"
+		},
+		knownGuilds: guilds
+	};
+}
+
+//#endregion
+//#region src/commands/commands/CommandsCommand.ts
+function hasCleanFlags(options) {
+	return [
+		options.clean,
+		options.allGuilds,
+		options.apply,
+		options.purge
+	].some(Boolean) || options.guild.length > 0;
+}
+var CommandsCommand = class extends BaseCommand {
+	cleanRunner;
+	constructor() {
+		super("commands", "Inspect and clean deployed application commands", "CLI:Commands");
+		this.cleanRunner = CleanRunner.create();
+	}
+	register(program) {
+		program.command(this.name).description(this.description).option("--clean", "Report guild commands that duplicate a global command (deletes only with --apply)").option("--guild <ids...>", "Guild ids to inspect").option("--all-guilds", "Scan every guild the bot is in (overlaps only, cannot combine with --purge)").option("--apply", "Delete the reported commands instead of running a dry run").option("--purge", "Select every command in the named guilds, not only global overlaps").option("--yes", "Skip prompts and the typed-count confirm (for scripts and CI)").action(async (options) => this.run({
+			clean: options.clean ?? false,
+			guild: options.guild ?? [],
+			allGuilds: options.allGuilds ?? false,
+			apply: options.apply ?? false,
+			purge: options.purge ?? false,
+			yes: options.yes ?? false
+		}));
+	}
+	async run(options) {
+		try {
+			await this.dispatch(options);
+		} catch (error) {
+			if (isSeedcordError(error, "SeedcordError", SeedcordErrorCode.CliCancelled)) return;
+			this.logger.error("seedcord commands failed", error);
+			if (isSeedcordError(error)) process.exitCode = 1;
+			else process.exit(1);
+		}
+	}
+	async dispatch(options) {
+		const flags = hasCleanFlags(options);
+		const interactive = isInteractive(options, flags);
+		if (!interactive && !flags) {
+			this.logger.info("Nothing to do. Pass --clean to inspect deployed commands.");
+			return;
+		}
+		const token = validateDiscordToken(Envapter.get("DISCORD_BOT_TOKEN"));
+		if (interactive) {
+			await runCleanWizard(this.cleanRunner, token);
+			return;
+		}
+		await runCleanFromFlags(this.cleanRunner, {
+			guildIds: options.guild,
+			allGuilds: options.allGuilds,
+			apply: options.apply,
+			purge: options.purge,
+			yes: options.yes
+		}, token, this.logger);
+	}
+};
+
 //#endregion
 //#region src/ui/hooks/useDevState.ts
 function useDevState(store) {
@@ -1012,10 +1570,10 @@ function handlePrompt(ctx) {
 function handleToggleMode(ctx) {
 	if (!ctx.showToggles) return false;
 	const channels = LogStore.instance.getChannels();
-	if (ctx.key.escape || ctx.input === "c") ctx.setShowToggles(false);
+	if (ctx.key.escape || ctx.key.return || ctx.input === "c") ctx.setShowToggles(false);
 	else if (ctx.key.upArrow && channels.length > 0) ctx.setCursor((ctx.cursor + channels.length - 1) % channels.length);
 	else if (ctx.key.downArrow && channels.length > 0) ctx.setCursor((ctx.cursor + 1) % channels.length);
-	else if (ctx.input === " " || ctx.key.return) {
+	else if (ctx.input === " ") {
 		const channel = channels[ctx.cursor];
 		if (channel !== void 0) ctx.setEnabled(toggleChannel(ctx.enabled, channel, channels));
 	}
@@ -1344,7 +1902,7 @@ function HotkeyBar({ phase, interactive, mode, following }) {
 		keyLabel: "space",
 		action: "toggle"
 	}), /* @__PURE__ */ React.createElement(Hotkey, {
-		keyLabel: "esc",
+		keyLabel: "↵/esc",
 		action: "done"
 	})), mode === "default" && /* @__PURE__ */ React.createElement(DefaultKeys, {
 		phase,
@@ -2276,13 +2834,14 @@ var DevCommand = class extends BaseCommand {
 
 //#endregion
 //#region src/cli.ts
-const LOGGER_LABEL = "Seedcord CLI";
+const LOGGER_LABEL = "seedcord CLI";
 async function main() {
 	if (!process.env.ENV && !process.env.ENVIRONMENT && !process.env.NODE_ENV) process.env.NODE_ENV = "development";
-	const program = new Command().name("seedcord").description("Seedcord CLI").version(version);
+	const program = new Command().name("seedcord").description("seedcord CLI").version(version);
 	new DevCommand().register(program);
 	new BuildCommand().register(program);
 	new CodegenCommand().register(program);
+	new CommandsCommand().register(program);
 	await program.parseAsync(process.argv);
 }
 main().catch((error) => {