@spicemod/creator 0.0.1

package/dist/bin.mjs

@@ -0,0 +1,1739 @@
+#!/usr/bin/env node
+import { Command, Option } from "commander";
+import * as v from "valibot";
+import path, { basename, dirname, extname, join, relative, resolve } from "node:path";
+import { context, transform } from "esbuild";
+import { createReadStream, existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { watchConfig } from "c12";
+import { globSync } from "tinyglobby";
+import { URL as URL$1, fileURLToPath } from "node:url";
+import { execSync, spawn, spawnSync } from "node:child_process";
+import readline, { createInterface } from "node:readline";
+import * as p from "@clack/prompts";
+import { cancel, log } from "@clack/prompts";
+import pc from "picocolors";
+import "dotenv/config";
+import { gzipSync } from "node:zlib";
+import postcssMinify from "@csstools/postcss-minify";
+import autoprefixer from "autoprefixer";
+import { postcssModules, sassPlugin } from "esbuild-sass-plugin";
+import postcss from "postcss";
+import postcssImport from "postcss-import";
+import postcssPresetEnv from "postcss-preset-env";
+import { readFile, writeFile } from "node:fs/promises";
+import { parse } from "ini";
+import { chdir } from "node:process";
+import { lookup } from "node:dns/promises";
+import { createServer } from "node:http";
+import { WebSocket, WebSocketServer } from "ws";
+
+//#region src/utils/replace.ts
+function replace(contents, kv) {
+	const keys = Object.keys(kv);
+	if (keys.length === 0) return contents;
+	const pattern = new RegExp(keys.map((k) => k.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|"), "g");
+	return contents.replace(pattern, (matched) => kv[matched] ?? matched);
+}
+
+//#endregion
+//#region src/utils/fs.ts
+function mkdirp(dir) {
+	try {
+		mkdirSync(dir, { recursive: true });
+	} catch (e) {
+		if (e?.code === "EEXIST") return;
+		throw e;
+	}
+}
+function dist(path, url = import.meta.url) {
+	const insideDistFolder = url.includes("dist");
+	return fileURLToPath(new URL(`./${!insideDistFolder ? "dist/" : ""}${path}`, url).href);
+}
+
+//#endregion
+//#region src/metadata.ts
+const toOptions = (metadata) => metadata.map((m) => ({
+	value: m.name,
+	label: m.title,
+	hint: m.description
+}));
+const templateTypes = ["extension", "theme"];
+const templates = templateTypes.map((dir) => {
+	const meta_file = dist(`templates/${dir}/meta.json`, import.meta.url);
+	const { title, description } = JSON.parse(readFileSync(meta_file, "utf8"));
+	return {
+		name: dir,
+		title,
+		description
+	};
+});
+const templateOptions = toOptions(templates);
+const linterTypes = [
+	"biome",
+	"eslint",
+	"oxlint",
+	"none"
+];
+const linterMeta = {
+	oxlint: {
+		title: "Oxlint",
+		description: "high-performance linter - http://oxc.rs"
+	},
+	biome: {
+		title: "Biome",
+		description: "Fast formatter and linter - https://biomejs.dev"
+	},
+	eslint: {
+		title: "ESLint",
+		description: "Industry standard, highly extensible - https://eslint.org"
+	},
+	none: {
+		title: "None",
+		description: "Skip linting for this project"
+	}
+};
+const linters = linterTypes.map((name) => ({
+	name,
+	...linterMeta[name]
+}));
+const linterOptions = toOptions(linters);
+const languageTypes = ["ts", "js"];
+const languageMeta = {
+	ts: {
+		title: "Typescript",
+		description: "with types (Recommended)"
+	},
+	js: {
+		title: "Javascript",
+		description: "with JSDOC"
+	}
+};
+const languages = languageTypes.map((name) => ({
+	name,
+	...languageMeta[name]
+}));
+const languageOptions = toOptions(languages);
+const frameworkTypes = ["react", "vanilla"];
+const frameworkMeta = {
+	react: {
+		title: "ReactJS",
+		description: "js framework - https://react.dev"
+	},
+	vanilla: {
+		title: "Vanilla",
+		description: "ya know it"
+	}
+};
+const frameworks = frameworkTypes.map((name) => ({
+	name,
+	...frameworkMeta[name]
+}));
+const frameworkOptions = toOptions(frameworks);
+const liveReloadFilePath = dist(`templates/liveReload.js`, import.meta.url);
+const templateFilePath = dist("templates/wrapper.js", import.meta.url);
+
+//#endregion
+//#region package.json
+var name = "@spicemod/creator";
+var version = "0.0.1";
+
+//#endregion
+//#region src/utils/common.ts
+const runCommand = async (action, options = {
+	outro: false,
+	message: void 0
+}) => {
+	try {
+		p.intro(options.message === void 0 || typeof options.message !== "function" ? `${name} ${pc.gray(`(v${version})`)}` : options.message({
+			name,
+			version
+		}));
+		await action();
+		if (options.outro) p.outro("You're all set!");
+	} catch (e) {
+		if (e instanceof Error) {
+			p.log.error(e.stack ?? String(e));
+			p.log.message();
+		}
+		p.cancel("Operation failed.");
+	}
+};
+const normalizePosix = (dir) => path.posix.normalize(dir.replace(/\\/g, "/"));
+function urlSlugify(text) {
+	return text.toString().normalize("NFD").replace(/[\u0300-\u036f]/g, "").toLowerCase().trim().replace(/\s+/g, "-").replace(/[^\w-]+/g, "").replace(/--+/g, "-");
+}
+function varSlugify(text) {
+	return text.toString().normalize("NFD").replace(/[\u0300-\u036f]/g, "").toLowerCase().trim().replace(/\s+/g, "_").replace(/[^\w]/g, "").replace(/__+/g, "_").replace(/^[0-9]/, (val) => `_${val}`);
+}
+
+//#endregion
+//#region src/utils/package-manager.ts
+const packageManagers = [
+	"npm",
+	"pnpm",
+	"yarn",
+	"bun"
+];
+function getPackageManager() {
+	const userAgent = process.env.npm_config_user_agent ?? "";
+	if (userAgent.startsWith("yarn")) return "yarn";
+	if (userAgent.startsWith("pnpm")) return "pnpm";
+	if (userAgent.startsWith("bun")) return "bun";
+	return "npm";
+}
+/**
+* Spawn a package manager installation based on user preference.
+*
+* @returns A Promise that resolves once the installation is finished.
+*/
+async function installPackages(packageManager, isOnline) {
+	const args = ["install"];
+	if (!isOnline) {
+		log.warn(pc.yellow("You appear to be offline.\nFalling back to the local cache."));
+		args.push("--offline");
+	}
+	/**
+	* Return a Promise that resolves once the installation is finished.
+	*/
+	return new Promise((resolve, reject) => {
+		/**
+		* Spawn the installation process.
+		*/
+		const child = spawn(packageManager, args, {
+			stdio: [
+				"inherit",
+				"pipe",
+				"pipe"
+			],
+			env: {
+				...process.env,
+				ADBLOCK: "1",
+				NODE_ENV: "development",
+				DISABLE_OPENCOLLECTIVE: "1"
+			}
+		});
+		createInterface({ input: child.stdout }).on("line", (line) => {
+			log.message(line);
+		});
+		createInterface({ input: child.stderr }).on("line", (line) => {
+			log.error(line);
+		});
+		child.on("close", (code) => {
+			log.message();
+			if (code !== 0) {
+				reject({ command: `${packageManager} ${args.join(" ")}` });
+				return;
+			}
+			resolve();
+		});
+	});
+}
+
+//#endregion
+//#region src/config/schema.ts
+const ServerConfigSchema = v.object({
+	port: v.optional(v.number()),
+	serveDir: v.string(),
+	hmrPath: v.optional(v.string())
+});
+const EntryFileSchema = v.string();
+const ThemeEntrySchema = v.object({
+	js: EntryFileSchema,
+	css: EntryFileSchema
+});
+const TemplateSpecificOptionalSchema = v.variant("template", [v.partial(v.object({
+	template: v.literal("extension"),
+	entry: EntryFileSchema
+})), v.partial(v.object({
+	template: v.literal("theme"),
+	entry: ThemeEntrySchema
+}))]);
+const TemplateSpecificSchema = v.variant("template", [v.object({
+	template: v.literal("extension"),
+	entry: EntryFileSchema
+}), v.object({
+	template: v.literal("theme"),
+	entry: ThemeEntrySchema
+})]);
+const CommonSchema = v.object({
+	name: v.string(),
+	outDir: v.string(),
+	linter: v.picklist(linterTypes),
+	framework: v.picklist(frameworkTypes),
+	packageManager: v.picklist(packageManagers),
+	esbuildOptions: v.record(v.string(), v.any()),
+	serverConfig: v.partial(ServerConfigSchema),
+	version: v.string()
+});
+const FileOptionsSchema = v.intersect([v.partial(CommonSchema), TemplateSpecificOptionalSchema]);
+const OptionsSchema$1 = v.pipe(v.intersect([v.required(CommonSchema), TemplateSpecificSchema]), v.check((input) => !!input.name, "Name is required"));
+
+//#endregion
+//#region src/env.ts
+const isInternal = process.env.SPICE_INTERNAL === "true";
+const isDev = process.env.IS_DEV === "true";
+const spicetifyBin = process.env.SPICETIFY_BIN || process.env.SPICE_BIN || "spicetify";
+const env = {
+	isInternal,
+	isDev,
+	spicetifyBin
+};
+
+//#endregion
+//#region src/constants.ts
+const GITHUB_LINK = "https://github.com/sanoojes/spicetify-creator";
+const DISCORD_LINK = "https://discord.gg/YGkktjdYV8";
+const DOCS_LINK = "https://github.com/sanoojes/spicetify-creator";
+const CONFIG_REF_LINK = "https://github.com/sanoojes/spicetify-creator";
+const SPICETIFY_LINK = "https://spicetify.app/docs/getting-started";
+const CHECK = pc.bold(pc.green("✔"));
+const CROSS = pc.bold(pc.red("✖"));
+const WARN = pc.bold(pc.yellow("⚠"));
+const VALID_PROJECT_FILES = new Set([
+	".DS_Store",
+	".git",
+	".gitattributes",
+	".gitignore",
+	".gitlab-ci.yml",
+	".hg",
+	".hgcheck",
+	".hgignore",
+	".idea",
+	".npmignore",
+	".travis.yml",
+	"LICENSE",
+	"Thumbs.db",
+	"docs",
+	"mkdocs.yml",
+	"npm-debug.log",
+	"yarn-debug.log",
+	"yarn-error.log",
+	"yarnrc.yml",
+	".yarn"
+]);
+
+//#endregion
+//#region src/utils/logger.ts
+var Logger = class {
+	constructor(prefix = "", mode = env.isDev ? "dev" : "prod") {
+		this.prefix = prefix;
+		this.mode = mode;
+	}
+	get isDev() {
+		return this.mode === "dev";
+	}
+	getPrefix() {
+		if (!this.prefix || !env.isDev) return null;
+		return pc.dim(`[${this.prefix.toLowerCase()}]`);
+	}
+	add(fn, args) {
+		const p = this.getPrefix();
+		if (p) fn(p, ...args);
+		else fn(...args);
+	}
+	greeting(msg = "") {
+		const label = pc.bgBlue(pc.black(` ${name.toUpperCase()} `));
+		console.log(`${label} ${pc.dim(`v${version}`)} ${msg}`);
+	}
+	info(...args) {
+		this.add(console.info, args);
+	}
+	success(m) {
+		console.log(`${CHECK} ${pc.green(m)}`);
+	}
+	warn(m) {
+		console.log(`${WARN} ${pc.yellow(m)}`);
+	}
+	cwarn(...args) {
+		this.add(console.warn, args);
+	}
+	error(...errors) {
+		this.add(console.error, errors);
+		for (const err of errors) if (err instanceof Error && this.isDev && err.stack) console.error(pc.dim(err.stack.split("\n").slice(1).join("\n")));
+	}
+	log(...args) {
+		if (!this.isDev) return;
+		this.add(console.log, args);
+	}
+	debug(...args) {
+		if (!this.isDev) return;
+		this.add((...a) => console.log(pc.magenta("[debug]"), ...a), args);
+	}
+	clear() {
+		if (!process.stdout.isTTY || process.env.CI) return;
+		readline.cursorTo(process.stdout, 0, 0);
+		readline.clearScreenDown(process.stdout);
+	}
+};
+const createLogger = (prefix = "", mode) => new Logger(prefix, mode);
+const logger$2 = createLogger("common");
+
+//#endregion
+//#region src/utils/schema.ts
+function safeParse(schema, data, type = "CLI") {
+	const result = v.safeParse(schema, data);
+	if (result.success) return result.output;
+	logger$2.error(`\n${pc.bgRed(pc.black(" ERROR "))} ${pc.red(`Invalid ${type} options:`)}`);
+	result.issues.forEach((issue) => {
+		const path = issue.path?.map((p) => p.key).join(".") || "input";
+		logger$2.error(`${pc.dim(" └─")} ${pc.yellow(path)}: ${pc.white(issue.message)}`);
+	});
+	logger$2.error(`\n${pc.dim("Check your command flags and try again.")}\n`);
+	process.exit(1);
+}
+
+//#endregion
+//#region src/config/index.ts
+const logger$1 = createLogger("config");
+const JS_ENTRY_GLOBS = [
+	"app.{ts,tsx,js,jsx,mts,mjs,cts,cjs}",
+	"extension/app.{ts,tsx,js,jsx,mts,mjs,cts,cjs}",
+	"src/app.{ts,tsx,js,jsx,mts,mjs,cts,cjs}",
+	"src/extension/app.{ts,tsx,js,jsx,mts,mjs,cts,cjs}"
+];
+const CSS_ENTRY_GLOBS = [
+	"app.{css,scss,sass,less,styl,stylus,pcss,postcss}",
+	"styles/app.{css,scss,sass,less,styl,stylus,pcss,postcss}",
+	"src/app.{css,scss,sass,less,styl,stylus,pcss,postcss}",
+	"src/styles/app.{css,scss,sass,less,styl,stylus,pcss,postcss}"
+];
+const CONFIG_DEFAULTS = {
+	outDir: "./dist",
+	linter: "biome",
+	framework: "react",
+	template: "extension",
+	packageManager: getPackageManager()
+};
+async function loadConfig(cb) {
+	let cleanup;
+	const runCb = async (config, isUpdate) => {
+		if (typeof cleanup === "function") await cleanup();
+		cleanup = await cb(config, isUpdate);
+	};
+	const watcher = await watchConfig({
+		name: "spice",
+		defaults: CONFIG_DEFAULTS,
+		configFileRequired: false,
+		packageJson: true,
+		async onUpdate({ newConfig }) {
+			await runCb(await getResolvedConfig(newConfig.config), true);
+		}
+	});
+	await runCb(await getResolvedConfig(watcher.config), false);
+	return watcher;
+}
+async function getResolvedConfig(config) {
+	try {
+		return safeParse(OptionsSchema$1, await resolveContext(config), "Config");
+	} catch (e) {
+		const message = e instanceof Error ? e.message : String(e);
+		logger$1.error(pc.red(`Failed to load configuration: ${message}`));
+		process.exit(1);
+	}
+}
+async function resolveContext(config) {
+	const cwd = process.cwd();
+	const getPkg = () => {
+		try {
+			return JSON.parse(readFileSync(resolve(cwd, "package.json"), "utf-8"));
+		} catch {
+			return {};
+		}
+	};
+	const pkg = config.name && config.version ? {} : getPkg();
+	if (!config.name) config.name = pkg.name || basename(cwd);
+	const DEFAULT_VERSION = "0.0.1";
+	if (!config.version) config.version = pkg.version ?? DEFAULT_VERSION;
+	if (!config.entry) if (config.template === "theme") {
+		config.entry = {
+			js: resolveDefaultEntries(cwd, "js"),
+			css: resolveDefaultEntries(cwd, "css")
+		};
+		if (!config.entry.js || config.entry.js.length === 0) config.entry.js = resolveDefaultEntries(cwd, "js");
+		if (!config.entry.css || config.entry.css.length === 0) config.entry.css = resolveDefaultEntries(cwd, "css");
+	} else config.entry = resolveDefaultEntries(cwd, "js");
+	config.outDir = resolve(cwd, config.outDir || "./dist");
+	config.esbuildOptions ??= {};
+	config.serverConfig ??= {};
+	return config;
+}
+function resolveDefaultEntries(cwd, type) {
+	const resolveFile = (globs) => {
+		for (const glob of globs) {
+			const matches = globSync(glob, {
+				cwd,
+				absolute: true
+			});
+			if (matches.length > 0) return matches;
+		}
+		return [];
+	};
+	const firstEntry = resolveFile(type === "js" ? JS_ENTRY_GLOBS : CSS_ENTRY_GLOBS)[0];
+	if (!firstEntry) throw new Error(type === "js" ? "No JavaScript entry found (src/app or src/index)." : "No CSS entry found (src/app, src/index, or src/styles).");
+	return firstEntry;
+}
+
+//#endregion
+//#region src/esbuild/format.ts
+function formatBuildSummary(files) {
+	try {
+		const tableData = [];
+		let totalSize = 0;
+		for (const [filePath, file] of files) {
+			let gzipKB = 0;
+			if (file.contents) gzipKB = gzipSync(file.contents).length / 1024;
+			const sizeKB = file.contents.length / 1024;
+			totalSize += file.contents.length;
+			tableData.push({
+				fullPath: relative(process.cwd(), filePath),
+				sizeKB,
+				gzipKB
+			});
+		}
+		const maxPathWidth = Math.max(...tableData.map((d) => d.fullPath.length), 10);
+		const lines = [];
+		for (const file of tableData) {
+			const sizeColor = file.sizeKB > 500 ? pc.magenta : file.sizeKB > 100 ? pc.yellow : pc.cyan;
+			const pathPart = pc.dim(file.fullPath);
+			const padding = " ".repeat(maxPathWidth - file.fullPath.length + 2);
+			const sizeStr = `${file.sizeKB.toFixed(2)} kB`.padStart(9);
+			const gzipStr = pc.dim(`│ gzip: ${file.gzipKB.toFixed(2).padStart(5)} kB`);
+			lines.push(`${pc.blue("i")} ${pathPart}${padding}${sizeColor(sizeStr)} ${gzipStr}`);
+		}
+		const totalSizeKB = totalSize / 1024;
+		const fileCount = tableData.length;
+		lines.push(`${pc.blue("ℹ")} ${pc.bold(pc.gray(`${fileCount} files, total: ${totalSizeKB.toFixed(2)} kB`))}`);
+		return lines.join("\n");
+	} catch (e) {
+		logger$2.debug(e);
+		return pc.red("Failed to generate build summary");
+	}
+}
+
+//#endregion
+//#region src/esbuild/plugins/buildLogger.ts
+const buildLogger = ({ cache }) => ({
+	name: "spice_internal__build-logger",
+	setup(build) {
+		let isFirstBuild = true;
+		let buildStartTime;
+		build.onStart(() => {
+			buildStartTime = performance.now();
+			if (!isFirstBuild) {
+				logger$2.clear();
+				logger$2.info(pc.dim("Rebuilding..."));
+			} else logger$2.info(pc.dim("Build started..."));
+		});
+		build.onEnd((result) => {
+			if (result.errors.length > 0) {
+				logger$2.info(pc.red("build failed."));
+				return;
+			}
+			const moduleCount = result.metafile ? Object.keys(result.metafile.inputs).length : 0;
+			logger$2.info(`${CHECK} ${moduleCount} modules transformed.`);
+			if (result.metafile) {
+				const details = formatBuildSummary(cache.files);
+				logger$2.info(details);
+			}
+			logger$2.info(pc.green(`${CHECK} built in ${getTime(buildStartTime)}.`));
+			isFirstBuild = false;
+		});
+	}
+});
+function getTime(start) {
+	const ms = performance.now() - start;
+	return ms > 1e3 ? `${(ms / 1e3).toFixed(2)}s` : `${Math.round(ms)}ms`;
+}
+
+//#endregion
+//#region src/esbuild/plugins/cleanDist.ts
+const cleanDist = (outDir) => ({
+	name: "spice_internal__clean-dist",
+	setup(build) {
+		build.onStart(() => {
+			if (existsSync(outDir)) rmSync(outDir, {
+				recursive: true,
+				force: true
+			});
+		});
+	}
+});
+
+//#endregion
+//#region src/esbuild/plugins/css.ts
+function css({ minify = false, inline = false, logger = createLogger("plugin:css") } = {}) {
+	const postCssPlugins = [
+		postcssImport({ path: [resolve(process.cwd(), "src")] }),
+		autoprefixer,
+		postcssPresetEnv({ stage: 0 }),
+		...minify ? [postcssMinify()] : []
+	];
+	const type = inline ? "style" : "css";
+	return [sassPlugin({
+		filter: /\.module\.(s[ac]ss|css)$/,
+		type,
+		transform: postcssModules({
+			getJSON: () => {},
+			generateScopedName: "[name]__[local]___[hash:base64:5]",
+			localsConvention: "camelCaseOnly"
+		}, postCssPlugins)
+	}), sassPlugin({
+		filter: /\.(s[ac]ss|css)$/,
+		type,
+		async transform(css, _resolveDir, filePath) {
+			const start = performance.now();
+			const result = await postcss(postCssPlugins).process(css, { from: filePath });
+			logger.debug("Global CSS processed", {
+				filePath,
+				ms: Math.round(performance.now() - start)
+			});
+			return result.css;
+		}
+	})];
+}
+
+//#endregion
+//#region src/esbuild/plugins/externalGlobal.ts
+const externalGlobal = (externals, namespace = "spicetify-global") => {
+	return {
+		name: "spice_internal__external-global",
+		setup(build) {
+			build.onResolve({ filter: new RegExp(`^(${Object.keys(externals).join("|")})$`) }, (args) => ({
+				path: args.path,
+				namespace
+			}));
+			build.onLoad({
+				filter: /.*/,
+				namespace
+			}, (args) => {
+				return { contents: `module.exports = ${externals[args.path]}` };
+			});
+		}
+	};
+};
+
+//#endregion
+//#region src/utils/spicetify/schema.ts
+const SpicetifyConfigSchema = v.object({
+	Setting: v.object({
+		spotify_path: v.string(),
+		prefs_path: v.string(),
+		inject_theme_js: v.string(),
+		inject_css: v.string(),
+		current_theme: v.string(),
+		color_scheme: v.string(),
+		always_enable_devtools: v.string()
+	}),
+	AdditionalOptions: v.object({
+		experimental_features: v.string(),
+		extensions: v.pipe(v.string(), v.transform((input) => input.split("|").filter(Boolean))),
+		custom_apps: v.string()
+	}),
+	Backup: v.object({
+		version: v.string(),
+		with: v.string()
+	})
+});
+
+//#endregion
+//#region src/utils/spicetify/index.ts
+function runSpice(args) {
+	validateSpicetify(env.spicetifyBin);
+	return spawnSync(env.spicetifyBin, args, { encoding: "utf-8" });
+}
+const getExtensionDir = () => join(getSpiceDataPath(), "Extensions");
+const getThemesDir = () => join(getSpiceDataPath(), "Themes");
+async function getSpicetifyConfig() {
+	const { stdout, stderr, error } = runSpice(["path", "-c"]);
+	if (error || stderr) throw new Error(`Failed to locate Spicetify config: ${stderr || error?.message}`);
+	const rawConfig = parse(await readFile(stdout.trim(), "utf-8"));
+	const result = v.safeParse(SpicetifyConfigSchema, rawConfig);
+	if (result.success) return result.output;
+	else throw new Error("Spicetify Config Validation Failed:", v.flatten(result.issues).nested);
+}
+function getSpiceDataPath() {
+	const { stdout, stderr, error } = runSpice(["path", "userdata"]);
+	if (error || stderr) throw new Error(`Failed to locate Spicetify config: ${stderr || error?.message}`);
+	return stdout.trim();
+}
+function validateSpicetify(bin) {
+	const result = spawnSync(bin, ["--version"], { encoding: "utf-8" });
+	if (result.error) throw result.error;
+	if (result.status !== 0) throw new Error(`Invalid spicetify binary "${bin}": ${result.stderr || "unknown error"}`);
+}
+
+//#endregion
+//#region src/esbuild/plugins/spicetifyHandlers.ts
+const spicetifyHandler = ({ config, options, cache, logger = createLogger("plugin:spicetifyHandler") }) => ({
+	name: "spice_internal__spicetify-build-handler",
+	async setup(build) {
+		const { apply = true, copy = true, applyOnce = true, remove, outDir = "./dist" } = options;
+		let hasAppliedOnce = false;
+		const isExtension = config.template === "extension";
+		const identifier = isExtension ? `${urlSlugify(config.name)}.js` : urlSlugify(config.name);
+		const spiceConfig = await getSpicetifyConfig();
+		logger.debug(pc.green("Spicetify Config: "), spiceConfig);
+		if (apply) {
+			const defaultTheme = spiceConfig.Setting.current_theme;
+			build.onStart(() => {
+				const spiceIdentifier = remove ? `${identifier}-` : identifier;
+				if (isExtension) runSpice([
+					"config",
+					"extensions",
+					spiceIdentifier
+				]);
+				else runSpice([
+					"config",
+					"current_theme",
+					spiceIdentifier
+				]);
+			});
+			if (!isExtension && !remove) {
+				const resetTheme = () => {
+					runSpice([
+						"config",
+						"current_theme",
+						defaultTheme
+					]);
+					process.exit();
+				};
+				process.once("SIGINT", resetTheme);
+				process.once("SIGTERM", resetTheme);
+			}
+		}
+		build.onEnd(async (result) => {
+			if (result.errors.length > 0) return;
+			if (!cache.hasChanges || cache.changed.size === 0) return;
+			const destDirs = [resolve(outDir)];
+			if (copy) destDirs.push(isExtension ? getExtensionDir() : resolve(getThemesDir(), identifier));
+			const tasks = [];
+			for (const filePath of cache.changed) {
+				const fileData = cache.files.get(filePath);
+				if (!fileData) continue;
+				for (const destDir of destDirs) {
+					const targetPath = resolve(destDir, basename(filePath));
+					tasks.push((async () => {
+						await mkdirp(destDir);
+						await writeFile(targetPath, fileData.contents);
+					})());
+				}
+			}
+			try {
+				await Promise.all(tasks);
+				logger.debug(pc.green(`${CHECK} Changed files copied.`));
+			} catch (err) {
+				logger.error(pc.red(`${CROSS} Failed to copy files: ${err instanceof Error ? err.message : String(err)}`));
+				return;
+			}
+			if (apply && cache.hasChanges && (!applyOnce || !hasAppliedOnce)) {
+				const { stderr, status } = runSpice(["apply"]);
+				if (status !== 0) logger.error(pc.red(`${CROSS} Spicetify apply failed: ${stderr}`));
+				else hasAppliedOnce = true;
+			}
+		});
+	}
+});
+
+//#endregion
+//#region src/esbuild/plugins/wrapWithLoader.ts
+function wrapWithLoader({ name, type, version, cache, outFiles, server, dev = false, logger = createLogger("plugin:wrapWithLoader") }) {
+	const namespace = "spice_internal__wrap-with-loader";
+	return {
+		name: namespace,
+		setup(build) {
+			if (build.initialOptions.write !== false) throw new Error(`[${namespace}] This plugin requires "write: false" in build options.`);
+			build.onEnd(async (res) => {
+				try {
+					if (res.errors.length > 0 || !res.outputFiles) return;
+					cache.changed.clear();
+					cache.hasChanges = false;
+					const filesChanged = [];
+					let bundledCss = "";
+					if (!dev && type === "extension") bundledCss = res.outputFiles.filter((f) => f.path.endsWith(".css")).map((f) => f.text).join("");
+					const transformPromises = res.outputFiles.map(async (file) => {
+						const isJs = file.path.endsWith(".js");
+						const isCss = file.path.endsWith(".css");
+						if (!dev && isCss && type === "extension") return;
+						const targetName = isJs ? outFiles.js : isCss ? outFiles.css ?? basename(file.path) : basename(file.path);
+						const renamedPath = join(build.initialOptions.outdir || "./dist/", targetName);
+						if (!isJs) {
+							cache.files.set(renamedPath, {
+								name: targetName,
+								contents: file.contents
+							});
+							cache.changed.add(renamedPath);
+							cache.hasChanges = true;
+							filesChanged.push(renamedPath);
+							return;
+						}
+						const slug = varSlugify(`${name}_${version}`);
+						const templateRaw = readFileSync(templateFilePath, "utf-8");
+						const minify = build.initialOptions.minify;
+						const { code: transformedTemp } = await transform(templateRaw, {
+							minify,
+							target: build.initialOptions.target || "es2020",
+							loader: "jsx",
+							define: {
+								__ESBUILD__HAS_CSS: JSON.stringify(type === "extension"),
+								__ESBUILD__APP_SLUG: JSON.stringify(slug),
+								__ESBUILD__APP_TYPE: JSON.stringify(type),
+								__ESBUILD__APP_ID: JSON.stringify(varSlugify(name)),
+								__ESBUILD__APP_VERSION: JSON.stringify(version),
+								__ESBUILD__APP_HASH: JSON.stringify("")
+							}
+						});
+						const template = replace(transformedTemp, {
+							"\"{{INJECT_START_COMMENT}}\"": minify ? "" : "/* --- START --- */",
+							"\"{{INJECT_END_COMMENT}}\"": minify ? "" : "/* --- END --- */",
+							"{{INJECTED_CSS_HERE}}": bundledCss,
+							"\"{{INJECTED_JS_HERE}}\"": file.text
+						});
+						const nextBuffer = Buffer.from(template);
+						const previous = cache.files.get(renamedPath);
+						if (previous?.contents && Buffer.compare(previous.contents, nextBuffer) === 0) return;
+						cache.files.set(renamedPath, {
+							name: targetName,
+							contents: nextBuffer
+						});
+						cache.changed.add(renamedPath);
+						cache.hasChanges = true;
+						filesChanged.push(renamedPath);
+					});
+					await Promise.all(transformPromises);
+					if (filesChanged.length > 0) server?.broadcast(filesChanged);
+				} catch (e) {
+					logger.error(`Error: ${e instanceof Error ? e.message : String(e)}`);
+				}
+			});
+		}
+	};
+}
+
+//#endregion
+//#region src/esbuild/plugins/index.ts
+const plugins = {
+	css,
+	cleanDist,
+	buildLogger,
+	externalGlobal,
+	wrapWithLoader,
+	spicetifyHandler
+};
+
+//#endregion
+//#region src/esbuild/index.ts
+const defaultBuildOptions = {
+	bundle: true,
+	write: false,
+	metafile: true,
+	treeShaking: true,
+	jsx: "transform",
+	format: "esm",
+	platform: "browser",
+	target: ["es2022", "chrome120"]
+};
+const getCommonPlugins = (opts) => {
+	const { template, minify, cache, name, version, buildOptions, outFiles, server, dev } = opts;
+	return [
+		...plugins.css({
+			minify,
+			inline: !dev && template === "extension"
+		}),
+		plugins.externalGlobal({
+			react: "Spicetify.React",
+			"react-dom": "Spicetify.ReactDOM",
+			"react-dom/client": "Spicetify.ReactDOM",
+			"react-dom/server": "Spicetify.ReactDOMServer",
+			"react/jsx-runtime": "Spicetify.ReactJSX"
+		}),
+		plugins.wrapWithLoader({
+			name,
+			version,
+			type: template,
+			cache,
+			outFiles,
+			server,
+			dev
+		}),
+		plugins.spicetifyHandler({
+			config: opts,
+			cache,
+			options: buildOptions
+		}),
+		plugins.buildLogger({ cache })
+	];
+};
+
+//#endregion
+//#region src/build/index.ts
+const logger = createLogger("build");
+async function build$1(options) {
+	logger.clear();
+	logger.greeting(pc.green("Building for production..."));
+	let ctx;
+	await loadConfig(async (config, isNewUpdate) => {
+		if (isNewUpdate) {
+			logger.clear();
+			logger.info(pc.green("Config updated, reloading..."));
+		}
+		if (ctx) await ctx.dispose();
+		ctx = await context(getJSBuildOptions(config, options));
+		if (options.watch) {
+			logger.info(pc.blue("Watching for changes..."));
+			await ctx.watch();
+		} else try {
+			await ctx.rebuild();
+		} catch {} finally {
+			await ctx.dispose();
+			process.exit(0);
+		}
+		return async () => {
+			await ctx?.dispose();
+			ctx = void 0;
+		};
+	});
+}
+function getJSBuildOptions(config, options) {
+	const entryPoints = (() => {
+		if (config.template === "theme") return [config.entry.js, config.entry.css];
+		return [config.entry];
+	})();
+	const minify = options.watch ? false : options.minify;
+	const outDir = resolve(config.outDir);
+	const cache = {
+		files: /* @__PURE__ */ new Map(),
+		changed: /* @__PURE__ */ new Set(),
+		hasChanges: true
+	};
+	const outFiles = {
+		js: config.template === "extension" ? `${urlSlugify(config.name)}.js` : "theme.js",
+		css: config.template === "theme" ? "user.css" : null
+	};
+	const overrides = {
+		...defaultBuildOptions,
+		outdir: outDir,
+		minify,
+		sourcemap: false,
+		external: [
+			...config.esbuildOptions?.external ? config.esbuildOptions.external : [],
+			"react",
+			"react-dom"
+		],
+		plugins: [...config.esbuildOptions?.plugins ? config.esbuildOptions.plugins : [], ...getCommonPlugins({
+			...config,
+			minify,
+			cache,
+			buildOptions: {
+				apply: options.apply,
+				copy: options.copy,
+				outDir,
+				applyOnce: false,
+				remove: false
+			},
+			outFiles
+		})]
+	};
+	return {
+		entryPoints,
+		...config.esbuildOptions,
+		...overrides
+	};
+}
+
+//#endregion
+//#region src/commands/build.ts
+const CLIOptionsSchema$1 = v.strictObject({
+	watch: v.boolean(),
+	minify: v.boolean(),
+	apply: v.boolean(),
+	copy: v.boolean()
+});
+const build = new Command("build").description("Build your spicetify project").option("-a, --apply", "Apply to spicetify", false).option("-w, --watch", "Watch mode", false).option("--no-copy", "Do not copy files to spicetify").option("--no-minify", "Disable code minification").action(async (opts) => {
+	await build$1(safeParse(CLIOptionsSchema$1, opts));
+});
+
+//#endregion
+//#region src/create/package.ts
+const FRAMEWORKS$1 = {
+	react: {
+		dependencies: {
+			react: "^18.3.1",
+			"react-dom": "^18.3.1"
+		},
+		devDependencies: {
+			"@types/react": "^18.3.27",
+			"@types/react-dom": "^18.3.7"
+		}
+	},
+	vanilla: {}
+};
+const LINTERS$1 = {
+	eslint: {
+		scripts: { lint: "eslint ." },
+		devDependencies: {
+			eslint: "^9.39.2",
+			"@eslint/js": "^9.39.2",
+			"@eslint/css": "^0.14.1",
+			globals: "^17.2.0",
+			jiti: "^2.6.1"
+		}
+	},
+	biome: {
+		scripts: { lint: "biome check --apply ." },
+		devDependencies: { "@biomejs/biome": "latest" }
+	},
+	oxlint: {
+		scripts: {
+			lint: "oxlint",
+			"lint:fix": "oxlint --fix"
+		},
+		devDependencies: { oxlint: "^1.43.0" }
+	}
+};
+const INTERSECTIONS = { reactEslint: {
+	condition: (options) => options.framework === "react" && options.linter === "eslint",
+	devDependencies: {
+		"eslint-plugin-react": "^7.37.5",
+		"typescript-eslint": "^8.54.0"
+	}
+} };
+function createPackageJSON(options) {
+	const result = {
+		name: options.name,
+		description: `A Spicetify ${options.template} created with @spicetify/creator`,
+		version: "0.0.1",
+		type: "module",
+		private: true,
+		scripts: {
+			sc: "spicetify-creator",
+			dev: "spicetify-creator dev",
+			build: "spicetify-creator build"
+		},
+		dependencies: {},
+		devDependencies: { "@spicetify/creator": env.isInternal ? "link:@spicetify/creator" : "latest" }
+	};
+	if (options.language === "ts") result.peerDependencies = {
+		...result.peerDependencies,
+		typescript: "^5"
+	};
+	const slices = [FRAMEWORKS$1[options.framework], LINTERS$1[options.linter]];
+	Object.values(INTERSECTIONS).forEach((intersection) => {
+		if (intersection.condition(options)) slices.push(intersection);
+	});
+	slices.forEach((slice) => {
+		if (!slice) return;
+		for (const key of [
+			"scripts",
+			"dependencies",
+			"devDependencies"
+		]) if (slice[key]) result[key] = {
+			...result[key],
+			...slice[key]
+		};
+	});
+	return result;
+}
+function writePackageJSON(packageJSON, targetDir) {
+	try {
+		mkdirp(targetDir);
+		const data = `${JSON.stringify(packageJSON, null, 2)}\n`;
+		writeFileSync(join(targetDir, "package.json"), data, "utf8");
+	} catch (e) {
+		const message = e instanceof Error ? e.message : "Unknown error";
+		log.error(`Failed to write package.json: ${message}`);
+		cancel("Exiting...");
+		process.exit(1);
+	}
+}
+function validateProjectName(name) {
+	if (!name.length) return "Project name is required";
+	if (!/^(?:@[a-z0-9-*~][a-z0-9-*._~]*\/)?[a-z0-9-~][a-z0-9-._~]*$/.test(name)) return "Invalid project name (must be lowercase and URL-friendly)";
+}
+
+//#endregion
+//#region src/create/template.ts
+const ext = (lang) => lang === "ts" ? "ts" : "js";
+const kv = ({ name, language, framework, linter, packageManager, template }) => ({
+	"{{project-name}}": name,
+	"{{framework}}": framework,
+	"{{linter}}": linter,
+	"{{package-manager}}": packageManager,
+	"{{template}}": template,
+	"{{language}}": ext(language),
+	"{{entry-ext}}": `${ext(language)}${framework === "react" ? "x" : ""}`,
+	"{{docs-link}}": DOCS_LINK,
+	"{{get-started-link}}": DOCS_LINK,
+	"{{discord-link}}": DISCORD_LINK,
+	"{{github-link}}": GITHUB_LINK,
+	"{{spicetify-link}}": SPICETIFY_LINK,
+	"{{config-reference-link}}": CONFIG_REF_LINK
+});
+const action = { modify(c, opts) {
+	return replace(c, kv(opts));
+} };
+const COMMON_FILES = (opts) => [
+	{
+		from: "README.template.md",
+		to: "README.md",
+		action,
+		isShared: true
+	},
+	{
+		from: ".gitignore",
+		to: ".gitignore",
+		isShared: true
+	},
+	{
+		from: `spice.config.${ext(opts.language)}`,
+		to: `spice.config.${ext(opts.language)}`,
+		action,
+		isShared: true
+	},
+	{
+		from: "app.css",
+		to: "src/app.css",
+		action,
+		isShared: true
+	},
+	...opts.language === "ts" ? [{
+		from: "css.d.ts",
+		to: "src/types/css.d.ts",
+		isShared: true
+	}] : []
+];
+const LANGUAGE_FILES = {
+	js: [{
+		from: "jsconfig.json",
+		to: "jsconfig.json",
+		isShared: true
+	}],
+	ts: [{
+		from: "tsconfig.json",
+		to: "tsconfig.json",
+		isShared: true
+	}]
+};
+const FRAMEWORKS = {
+	react: ({ language }) => [{
+		from: `src/app.${ext(language)}x`,
+		to: `src/app.${ext(language)}x`,
+		action
+	}, {
+		from: `src/components/Onboarding.${ext(language)}x`,
+		to: `src/components/Onboarding.${ext(language)}x`,
+		action
+	}],
+	vanilla: ({ language }) => [{
+		from: `src/app.${ext(language)}`,
+		to: `src/app.${ext(language)}`,
+		action
+	}, {
+		from: `src/components/Onboarding.${ext(language)}`,
+		to: `src/components/Onboarding.${ext(language)}`,
+		action
+	}]
+};
+const LINTERS = {
+	biome: [{
+		from: "biome.json",
+		to: "biome.json",
+		isShared: true
+	}],
+	eslint: ({ language }) => [{
+		from: `eslint.config.${ext(language)}`,
+		to: `eslint.config.${ext(language)}`
+	}],
+	oxlint: [{
+		from: ".oxlintrc.json",
+		to: ".oxlintrc.json",
+		isShared: true
+	}]
+};
+function setupTemplateFiles(options, targetDir) {
+	const { template, language, framework, linter } = options;
+	const templateRoot = dist(`templates/${template}`, import.meta.url);
+	const fromDir = join(templateRoot, language, framework);
+	const resolve = (slice) => typeof slice === "function" ? slice(options) : slice ?? [];
+	const files = [
+		...resolve(COMMON_FILES),
+		...resolve(LANGUAGE_FILES[language]),
+		...resolve(FRAMEWORKS[framework]),
+		...resolve(LINTERS[linter])
+	];
+	for (const file of files) {
+		const src = (() => {
+			if (file.isGlobal) return join(templateRoot, file.from);
+			if (file.isShared) return join(templateRoot, "shared", file.from);
+			return join(fromDir, file.from);
+		})();
+		const dest = join(targetDir, file.to);
+		if (!existsSync(src)) {
+			log.warn(`[Template] Source missing: ${src}`);
+			continue;
+		}
+		mkdirp(dirname(dest));
+		let content = readFileSync(src, "utf8");
+		if (file.action?.modify) content = file.action.modify(content, options);
+		writeFileSync(dest, content, "utf8");
+	}
+}
+
+//#endregion
+//#region src/utils/is-online.ts
+function getProxy() {
+	if (process.env.https_proxy) return process.env.https_proxy;
+	try {
+		const httpsProxy = execSync("npm config get https-proxy").toString().trim();
+		return httpsProxy !== "null" ? httpsProxy : void 0;
+	} catch {
+		return;
+	}
+}
+async function getOnline() {
+	try {
+		await lookup("registry.yarnpkg.com");
+		return true;
+	} catch {
+		const proxy = getProxy();
+		if (!proxy) return false;
+		let url;
+		try {
+			url = new URL$1(proxy);
+		} catch {
+			return false;
+		}
+		const { hostname } = url;
+		if (!hostname) return false;
+		try {
+			await lookup(hostname);
+			return true;
+		} catch {
+			return false;
+		}
+	}
+}
+
+//#endregion
+//#region src/utils/git.ts
+function isInGitRepository() {
+	try {
+		execSync("git rev-parse --is-inside-work-tree", { stdio: "ignore" });
+		return true;
+	} catch {}
+	return false;
+}
+function isInMercurialRepository() {
+	try {
+		execSync("hg --cwd . root", { stdio: "ignore" });
+		return true;
+	} catch {}
+	return false;
+}
+function isDefaultBranchSet() {
+	try {
+		execSync("git config init.defaultBranch", { stdio: "ignore" });
+		return true;
+	} catch {}
+	return false;
+}
+function tryGitInit(root) {
+	let didInit = false;
+	try {
+		execSync("git --version", { stdio: "ignore" });
+		if (isInGitRepository() || isInMercurialRepository()) return false;
+		execSync("git init", { stdio: "ignore" });
+		didInit = true;
+		if (!isDefaultBranchSet()) execSync("git checkout -b main", { stdio: "ignore" });
+		execSync("git add -A", { stdio: "ignore" });
+		execSync("git commit -m \"Initial commit from @spicetify/creator create\"", { stdio: "ignore" });
+		return true;
+	} catch {
+		if (didInit) try {
+			rmSync(join(root, ".git"), {
+				recursive: true,
+				force: true
+			});
+		} catch {}
+		return false;
+	}
+}
+
+//#endregion
+//#region src/create/index.ts
+const isOnline = await getOnline();
+async function createProject(cwd, options) {
+	const { directory, template, language, linter, framework, packageManager, disableGit } = await p.group({
+		directory: async () => {
+			if (cwd) return normalizePosix(cwd);
+			const defaultPath = "./";
+			return await p.text({
+				message: "Where would you like your project to be created?",
+				placeholder: `  (hit Enter to use '${defaultPath}')`,
+				defaultValue: defaultPath
+			});
+		},
+		force: async ({ results: { directory } }) => {
+			if (!options.dirCheck || !directory) return;
+			if (!existsSync(directory)) return;
+			const root = resolve(directory);
+			const name = basename(root);
+			const conflicts = readdirSync(root).filter((file) => !VALID_PROJECT_FILES.has(file) && !file.endsWith(".iml"));
+			if (conflicts.length === 0) return;
+			p.log.warn(`The directory ${pc.green(name)} contains files that could conflict:`);
+			const conflictList = conflicts.map((file) => {
+				try {
+					return lstatSync(join(root, file)).isDirectory() ? ` ${pc.blue(file)}/` : ` ${file}`;
+				} catch {
+					return `${file}`;
+				}
+			}).join("\n");
+			p.note(conflictList, "Potential Conflicts");
+			const force = await p.confirm({
+				message: `Directory is not empty. ${pc.yellow("Overwrite and continue?")}`,
+				initialValue: false
+			});
+			if (p.isCancel(force) || !force) {
+				p.cancel("Operation cancelled.");
+				process.exit(0);
+			}
+		},
+		template: async () => {
+			if (options.template) return options.template;
+			return await p.select({
+				message: "Select which template you want to chose",
+				options: templateOptions
+			});
+		},
+		framework: async () => {
+			if (options.framework) return options.framework;
+			return await p.select({
+				message: "Select which framework you want to chose",
+				options: frameworkOptions
+			});
+		},
+		language: async () => {
+			if (options.language) return options.language;
+			return await p.select({
+				message: "Select which language you want to chose",
+				initialValue: "ts",
+				options: languageOptions
+			});
+		},
+		linter: async () => {
+			if (options.linter) return options.linter;
+			return await p.select({
+				message: "Select which linter you want to chose",
+				options: linterOptions
+			});
+		},
+		packageManager: async () => {
+			if (options.packageManager) return options.packageManager;
+			return await p.select({
+				message: "Select which package manager you want to choose to install packages",
+				options: packageManagers.map((value) => ({
+					value,
+					title: value
+				})),
+				initialValue: getPackageManager()
+			});
+		},
+		disableGit: async () => {
+			if (!options.git) return options.git;
+			return !await p.confirm({
+				message: "Initialize a Git repository?",
+				initialValue: true
+			});
+		}
+	}, { onCancel: () => {
+		p.cancel("Operation cancelled.");
+		process.exit(0);
+	} });
+	const projectPath = resolve(directory);
+	const projectName = await p.text({
+		message: "Confirm or enter the package name:",
+		initialValue: basename(projectPath).toLowerCase(),
+		validate: validateProjectName
+	});
+	if (p.isCancel(projectName)) {
+		p.cancel("Operation cancelled.");
+		process.exit(0);
+	}
+	await create$1(projectPath, {
+		name: projectName,
+		template,
+		language,
+		linter,
+		framework,
+		packageManager,
+		disableGit,
+		install: options.install
+	});
+	p.log.success("Project created");
+}
+async function create$1(cwd, options) {
+	try {
+		mkdirp(cwd);
+		setupTemplateFiles(options, cwd);
+		const pkgJSON = createPackageJSON(options);
+		writePackageJSON(pkgJSON, cwd);
+		chdir(cwd);
+		await promptPackageInstallation(options, pkgJSON);
+		if (!options.disableGit) if (tryGitInit(cwd)) p.log.success("Initialized a git repository");
+		else p.log.error("Failed to initialize git repository");
+		else p.log.info("Skipping git initialization");
+	} catch (e) {
+		const message = e instanceof Error ? e.message : "Unexpected Error";
+		p.log.error(`Failed to scaffold ${options.template}: ${message}\n`);
+		p.cancel("Exiting...");
+		process.exit(1);
+	}
+}
+async function promptPackageInstallation(options, pkg) {
+	if (!options.install) return;
+	const shouldInstall = await p.confirm({
+		message: `Install dependencies using ${options.packageManager}?`,
+		initialValue: true
+	});
+	if (p.isCancel(shouldInstall)) {
+		p.cancel("Operation cancelled.");
+		process.exit(0);
+	}
+	try {
+		if (shouldInstall) {
+			p.log.info(`Installing dependencies with ${options.packageManager}...`);
+			await installPackages(options.packageManager, isOnline);
+			const formatDeps = (deps) => {
+				return Object.entries(deps).map(([name, version]) => `${pc.bold(name)}@${pc.blue(version)}`).join("\n");
+			};
+			if (pkg.dependencies) p.note(formatDeps(pkg.dependencies), "Dependencies");
+			if (pkg.devDependencies) p.note(formatDeps(pkg.devDependencies), "Dev Dependencies");
+			p.log.info("Dependencies installed successfully.");
+		} else p.log.info(`Skipping install. You can run '${options.packageManager} install' later.`);
+	} catch {
+		p.log.info(`Failed to install dependencies, check the errors above.`);
+	}
+}
+
+//#endregion
+//#region src/commands/create.ts
+const PathSchema = v.optional(v.string());
+const OptionsSchema = v.strictObject({
+	install: v.boolean(),
+	git: v.boolean(),
+	dirCheck: v.boolean(),
+	language: v.optional(v.picklist(languageTypes)),
+	template: v.optional(v.picklist(templateTypes)),
+	framework: v.optional(v.picklist(frameworkTypes)),
+	linter: v.optional(v.picklist(linterTypes)),
+	packageManager: v.optional(v.picklist(packageManagers))
+});
+const templateOption = new Option("-t, --template <name>", "Template to use").choices(templateTypes);
+const linterOption = new Option("--linter <name>", "Linter to use").choices(linterTypes);
+const langOption = new Option("--language <lang>", "Language to use").choices(languageTypes);
+const frameworkOption = new Option("--framework <name>", "Framework to use").choices(frameworkTypes);
+const packageManagerOption = new Option("--pm, --package-manager <name>", "Package manager to use").choices(packageManagers);
+const create = new Command("create").description("Scaffolds a new spicetify project").argument("[path]", "Where the project will be created").addOption(templateOption).addOption(langOption).addOption(frameworkOption).addOption(linterOption).addOption(packageManagerOption).option("--disable-git, --no-git", "Skip initializing a git repository.").option("--skip-install, --no-install", "Skip installing packages").option("--skip-dir-check, --no-dir-check", "Even if the folder is not empty, no prompt will be shown").action((path, opts) => {
+	try {
+		const cwd = safeParse(PathSchema, path);
+		const options = safeParse(OptionsSchema, opts);
+		runCommand(async () => {
+			await createProject(cwd, options);
+		}, {
+			outro: true,
+			message: (opts) => `Welcome to ${opts.name} CLI ${pc.gray(`(v${opts.version})`)}`
+		});
+	} catch (error) {
+		if (v.isValiError(error)) {
+			logger$2.error("\nInvalid configuration:");
+			error.issues.forEach((issue) => {
+				const path = issue.path?.map((p) => p.key).join(".") || "input";
+				logger$2.error(`${pc.yellow(`  - ${path}:`)} ${issue.message}`);
+			});
+		} else logger$2.error(`\nAn unexpected error occurred: ${error instanceof Error ? error.message : String(error)}`);
+		process.exit(1);
+	}
+});
+
+//#endregion
+//#region src/dev/server/templates/root.ts
+const root = () => `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Spicetify Creator | Dev Server</title>
+</head>
+<body>
+  <h1>Spicetify Creator Server up and running.</h1>
+</body>
+</html>
+`;
+
+//#endregion
+//#region src/dev/server/index.ts
+const WS_PATH = "/spicetify-creator";
+async function createHmrServer(config, logger = createLogger("hmrServer")) {
+	const { port = DEFAULT_PORT, serveDir = outDir } = config;
+	let isRunning = false;
+	const mimeTypes = {
+		".html": "text/html",
+		".js": "text/javascript",
+		".css": "text/css",
+		".json": "application/json",
+		".png": "image/png",
+		".jpg": "image/jpeg",
+		".jpeg": "image/jpeg",
+		".gif": "image/gif",
+		".svg": "image/svg+xml",
+		".ico": "image/x-icon"
+	};
+	const httpServer = createServer((req, res) => {
+		const corsHeaders = {
+			"Access-Control-Allow-Origin": "*",
+			"Access-Control-Allow-Methods": "GET, POST, OPTIONS, PUT, PATCH, DELETE",
+			"Access-Control-Allow-Headers": "X-Requested-With, Content-Type, Authorization",
+			"Access-Control-Max-Age": "86400"
+		};
+		if (req.method === "OPTIONS") {
+			res.writeHead(204, corsHeaders);
+			res.end();
+			return;
+		}
+		const wrapResponse = (statusCode, headers) => {
+			res.writeHead(statusCode, {
+				...headers,
+				...corsHeaders
+			});
+		};
+		const cleanUrl = (req.url ?? "/").split("?")[0] ?? "/";
+		if (cleanUrl === "/" || cleanUrl === "/index.html") {
+			wrapResponse(200, { "Content-Type": "text/html" });
+			res.end(root());
+			return;
+		}
+		const filePath = resolve(join(serveDir, cleanUrl.startsWith("/files/") ? cleanUrl.slice(6) : cleanUrl));
+		try {
+			if (existsSync(filePath) && statSync(filePath).isFile()) {
+				const contentType = mimeTypes[extname(filePath).toLowerCase()] || "application/octet-stream";
+				wrapResponse(200, { "Content-Type": contentType });
+				createReadStream(filePath).pipe(res);
+				return;
+			}
+		} catch {}
+		wrapResponse(404, { "Content-Type": "text/html" });
+		res.end("<h1>404 - Not Found</h1>");
+	});
+	const wss = new WebSocketServer({ noServer: true });
+	const clients = /* @__PURE__ */ new Set();
+	httpServer.on("upgrade", (req, socket, head) => {
+		const { url } = req;
+		if (!url?.startsWith(WS_PATH)) {
+			socket.destroy();
+			return;
+		}
+		wss.handleUpgrade(req, socket, head, (ws) => {
+			clients.add(ws);
+			ws.on("close", () => {
+				clients.delete(ws);
+			});
+			ws.on("error", () => {
+				clients.delete(ws);
+			});
+			wss.emit("connection", ws, req);
+		});
+	});
+	function broadcast(data) {
+		const message = typeof data === "string" ? data : JSON.stringify(data);
+		for (const client of clients) if (client.readyState === WebSocket.OPEN) client.send(message);
+	}
+	return {
+		start: async () => new Promise((resolve) => {
+			httpServer.listen(port, () => {
+				logger.debug(`${pc.bold("HTTP Server Started at")}: ${pc.cyan(`http://localhost:${port}/`)}`);
+				isRunning = true;
+				resolve();
+			});
+		}),
+		stop: () => new Promise((resolve, reject) => {
+			httpServer.close((err) => {
+				if (err) return reject(err);
+				isRunning = false;
+				logger.debug(`${pc.yellow("! ")} ${pc.gray("HTTP server stopped")}`);
+				resolve();
+			});
+		}),
+		broadcast,
+		get port() {
+			return port;
+		},
+		get isRunning() {
+			return isRunning;
+		},
+		get link() {
+			return `http://localhost:${port}`;
+		},
+		get wsLink() {
+			return `ws://localhost:${port}${WS_PATH}`;
+		}
+	};
+}
+
+//#endregion
+//#region src/utils/hmr.ts
+const injectHMRExtension = async (rootLink, wsLink, outFiles) => {
+	const extName = `sc-live-reload-helper.js`;
+	const spiceConfig = await getSpicetifyConfig();
+	const cleanup = () => {
+		if (env.isDev) logger$2.log(`[Spicetify] Removing Live reload extension...`);
+		try {
+			runSpice([
+				"config",
+				"extensions",
+				`${extName}-`
+			]);
+			runSpice(["apply"]);
+			logger$2.debug(pc.green(`${CHECK} Cleanup successful.`));
+		} catch (e) {
+			if (env.isDev) logger$2.error(pc.red(`${CROSS} Cleanup failed: `), e);
+		}
+		process.exit();
+	};
+	if (env.isDev) {
+		process.on("SIGINT", cleanup);
+		process.on("SIGTERM", cleanup);
+	}
+	try {
+		logger$2.debug(`[Spicetify] Preparing Live reload extension...`);
+		const destDir = getExtensionDir();
+		mkdirp(destDir);
+		const outDir = resolve(destDir, extName);
+		const { code } = await transform(readFileSync(liveReloadFilePath, "utf8"), {
+			loader: "js",
+			define: {
+				_SERVER_URL: JSON.stringify(rootLink),
+				_HOT_RELOAD_LINK: JSON.stringify(wsLink),
+				_JS_PATH: JSON.stringify(`/files/${outFiles.js}`),
+				_CSS_PATH: JSON.stringify(outFiles.css ? `/files/${outFiles.css}` : `/files/app.css`)
+			}
+		});
+		writeFileSync(outDir, code);
+		if (spiceConfig) {
+			runSpice([
+				"config",
+				"extensions",
+				extName
+			]);
+			runSpice(["apply"]);
+		}
+		logger$2.debug(pc.green(`${CHECK} Live reload extension injected successfully.`));
+	} catch (err) {
+		logger$2.error(pc.red(`${CROSS} Failed to inject HMR helper: ${err instanceof Error ? err.message : String(err)}`));
+	}
+};
+
+//#endregion
+//#region src/dev/index.ts
+const DEFAULT_PORT = 54321;
+const outDir = resolve(`./.spicetify/build/`);
+async function dev$1(options) {
+	logger$2.clear();
+	logger$2.greeting(pc.green("Starting development environment"));
+	let ctx;
+	let server = void 0;
+	loadConfig(async (config, isNewUpdate) => {
+		if (isNewUpdate) {
+			logger$2.clear();
+			logger$2.info(pc.green("Config updated, reloading..."));
+		}
+		try {
+			server = await createHmrServer({
+				...config.serverConfig,
+				serveDir: config.serverConfig.serveDir ?? outDir,
+				port: options.port ?? config.serverConfig.port
+			});
+			await server.start();
+			const outFiles = {
+				js: config.template === "extension" ? `${urlSlugify(config.name)}.js` : "theme.js",
+				css: config.template === "theme" ? "user.css" : null
+			};
+			await injectHMRExtension(server.link, server.wsLink, outFiles);
+			ctx = await context(getJSDevOptions(config, {
+				...options,
+				outFiles,
+				server
+			}));
+			await ctx.watch();
+			logger$2.info(pc.blue("Watching for changes..."));
+		} catch (err) {
+			logger$2.error("Failed to start dev server: ", err);
+		}
+		return async () => {
+			try {
+				await ctx?.dispose();
+				ctx = void 0;
+				await server?.stop();
+			} finally {
+				process.exit();
+			}
+		};
+	});
+}
+function getJSDevOptions(config, options) {
+	const entryPoints = (() => {
+		if (config.template === "theme") return [config.entry.js, config.entry.css];
+		return [config.entry];
+	})();
+	const minify = false;
+	const cache = {
+		files: /* @__PURE__ */ new Map(),
+		changed: /* @__PURE__ */ new Set(),
+		hasChanges: true
+	};
+	const overrides = {
+		...defaultBuildOptions,
+		outdir: outDir,
+		minify,
+		sourcemap: "inline",
+		external: [
+			...config.esbuildOptions?.external ? config.esbuildOptions.external : [],
+			"react",
+			"react-dom"
+		],
+		plugins: [...config.esbuildOptions?.plugins ? config.esbuildOptions.plugins : [], ...getCommonPlugins({
+			...config,
+			minify,
+			cache,
+			buildOptions: {
+				copy: true,
+				remove: true,
+				outDir
+			},
+			dev: true,
+			server: options.server,
+			outFiles: options.outFiles
+		})]
+	};
+	return {
+		entryPoints,
+		...config.esbuildOptions,
+		...overrides
+	};
+}
+
+//#endregion
+//#region src/commands/dev.ts
+const CLIOptionsSchema = v.strictObject({ port: v.optional(v.pipe(v.union([v.string(), v.number()]), v.transform((val) => Number(val)), v.number("Port must be a valid number"), v.minValue(1, "Port must be greater than 0"), v.maxValue(65535, "Port must be less than 65536"))) });
+const dev = new Command("dev").description("Develop your spicetify project").option("-p, --port <number>", "Port for the development server").action(async (opts) => {
+	await dev$1(safeParse(CLIOptionsSchema, opts));
+});
+
+//#endregion
+//#region src/bin.ts
+logger$2.debug(`Env: ${JSON.stringify(env, null, 2)}\n`);
+const command = new Command();
+create.alias("init");
+command.addCommand(create).addCommand(build).addCommand(dev);
+command.parse();
+
+//#endregion
+export {  };