seedcord 0.22.0-next.0 → 0.22.0

package/bin/seedcord.mjs

@@ -3,6 +3,8 @@ import { existsSync, readFileSync } from 'node:fs';
 import { dirname, resolve } from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 
+import { isValid, isValidRange, satisfies } from 'verkit';
+
 const here = dirname(fileURLToPath(import.meta.url));
 
 function declaredEngines() {
@@ -14,24 +16,6 @@ function declaredEngines() {
     }
 }
 
-function parseVersion(text) {
-    const [withoutBuild = ''] = text.replace(/^v/, '').split('+');
-    const [release = '', ...prerelease] = withoutBuild.split('-');
-    const parts = release.split('.').map(Number);
-    return parts.every(Number.isInteger) ? { parts, prerelease: prerelease.length > 0 } : undefined;
-}
-
-// semver ranks 1.4.2-canary.1 below 1.4.2
-function meetsMinimum(required, running) {
-    const length = Math.max(required.parts.length, running.parts.length);
-    for (let index = 0; index < length; index++) {
-        const wanted = required.parts[index] ?? 0;
-        const got = running.parts[index] ?? 0;
-        if (got !== wanted) return got > wanted;
-    }
-    return !running.prerelease;
-}
-
 // importing core's assertDeclaredRuntime here would load the code this guards
 function unsupportedRuntime() {
     const engines = declaredEngines();
@@ -41,12 +25,13 @@ function unsupportedRuntime() {
             ? { name: 'Node', range: engines.node ?? '', running: node }
             : { name: 'Bun', range: engines.bun ?? '', running: bun };
 
-    const range = runtime.range.replaceAll(/\s/g, '');
-    if (!range.startsWith('>=')) return undefined;
-
-    const required = parseVersion(range.slice('>='.length));
-    const running = parseVersion(runtime.running);
-    if (!required || !running || meetsMinimum(required, running)) return undefined;
+    if (
+        !runtime.range ||
+        !isValidRange(runtime.range) ||
+        !isValid(runtime.running) ||
+        satisfies(runtime.running, runtime.range, { includePrerelease: true })
+    )
+        return undefined;
     return runtime;
 }
 

package/dist/cli.mjs

@@ -1,4 +1,4 @@
-import { n as SEEDCORD_CONFIG_FILENAMES, t as version } from "./src-BrsznVXh.mjs";
+import { n as SEEDCORD_CONFIG_FILENAMES, t as version } from "./src-rYAuhl0h.mjs";
 import { createRequire } from "node:module";
 import { Command, Option } from "@commander-js/extra-typings";
 import { SeedcordErrorCode, isSeedcordError, paint } from "@seedcord/errors";
@@ -14,14 +14,15 @@ import chalk from "chalk";
 import { basename, delimiter, dirname, join, posix, relative, resolve, win32 } from "node:path";
 import { existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, statSync, watch, writeFileSync } from "node:fs";
 import { CONSOLE_LEVEL, CONSOLE_METHODS, consoleRecord, logsFolderIn, routeConsole, traceError } from "@seedcord/logger/internal";
-import { BOT_FILES_KEY, BUILT_FILES_READY_KEY, BotLayout, asError, encodeFile, hasErrorCode, importFailed, isInside, isPlainObject, isPortInUse, isStringArray, pluralize, posixRelative, recordThrownBy, routeLeavesOf, setDevFiles, toPosixPath, unlessAborted, vitePluginThrew, withoutQuery, workerdPath } from "@seedcord/utils/internal";
+import { BOT_FILES_KEY, BUILT_FILES_READY_KEY, BotLayout, asError, encodeFile, hasErrorCode, importFailed, isInside, isInteractive, isPlainObject, isPortInUse, isStringArray, pluralize, posixRelative, recordThrownBy, routeLeavesOf, setDevFiles, toPosixPath, unlessAborted, vitePluginThrew, withoutQuery, workerdPath } from "@seedcord/utils/internal";
 import { spawn } from "node:child_process";
 import { HostAugmentTarget, HostListenHost, HostPluginKeys, HostShutdown, HostStartup, HostVersion, SeedcordBrand } from "@seedcord/types/internal";
 import { Visitor, createBuilder, createLogger, createServer, createServerModuleRunner, loadEnv, mergeConfig, preview } from "vite";
+import { fileURLToPath } from "node:url";
 import { format, parseEnv, stripVTControlCharacters } from "node:util";
+import { BAKED_IDS_KEY, CommandMetadataKey, GLOBAL_ID, bindEnv, commandKey, commandRefOf, commandsRoute, currentApplication, fromDevLogLine, fromWireError, globalFirst, guildSummaries, isCommandClass, linkCommands, planDeploy, putCommands, readBotToken, readCommands, readCommandsAt, resolveDeployTarget, resolveEmojis, scopeIdsOf, skippedNote, warnLinks, wrapHot } from "@seedcord/core/internal";
+import { Converters, ENVIRONMENT_KEYS, Envapter, Environment, PortableSource, merge } from "envapt";
 import { randomUUID } from "node:crypto";
-import { Converters, ENVIRONMENT_KEYS, Envapter, Environment, FileSource, PortableSource, merge } from "envapt";
-import { BAKED_IDS_KEY, CommandMetadataKey, GLOBAL_ID, commandKey, commandRefOf, commandsRoute, currentApplication, fromDevLogLine, fromWireError, globalFirst, guildSummaries, isCommandClass, linkCommands, planDeploy, putCommands, readBotToken, readCommands, readCommandsAt, resolveDeployTarget, resolveEmojis, scopeIdsOf, skippedNote, warnLinks, wrapHot } from "@seedcord/core/internal";
 import { DiscordAPIError, REST } from "@discordjs/rest";
 import "reflect-metadata";
 import { ApplicationCommandOptionType, ApplicationCommandType, InteractionContextType, RESTJSONErrorCodes, Routes } from "discord-api-types/v10";
@@ -1474,12 +1475,12 @@ var ProjectLoader = class {
 	}
 	async readConfig(projectDir = process.cwd(), check) {
 		try {
-			var _usingCtx$7 = _usingCtx();
+			var _usingCtx$8 = _usingCtx();
 			const configPath = realPath(locateConfig(projectDir));
 			const configDir = realPath(dirname(configPath));
 			const mode = this.shell.applyMode(this.defaultMode, configDir);
 			const target = detectTarget(configDir);
-			const stack = _usingCtx$7.a(new AsyncDisposableStack());
+			const stack = _usingCtx$8.a(new AsyncDisposableStack());
 			const configModules = stack.use(await this.openModules(configDir, target, mode, "config"));
 			const config = await this.resolveConfig(configModules, configPath, target, mode);
 			const project = new Project(config, new ProjectFiles(config), configModules);
@@ -1490,9 +1491,9 @@ var ProjectLoader = class {
 			const loaded = new LoadedConfig(config, project.files);
 			return loaded.hasVitePlugins ? new LoadedConfig(config, project.files, stack.move()) : loaded;
 		} catch (_) {
-			_usingCtx$7.e = _;
+			_usingCtx$8.e = _;
 		} finally {
-			await _usingCtx$7.d();
+			await _usingCtx$8.d();
 		}
 	}
 	async openProject(loaded) {
@@ -1577,12 +1578,7 @@ function botEnvironment(environments) {
 
 //#endregion
 //#region src/core/modules/edgeStandIns.ts
-const BIND_ENV_ID$1 = "seedcord:bind-env";
-const RESOLVED_BIND_ENV_ID = `\0${BIND_ENV_ID$1}`;
 const CLOUDFLARE_WORKERS_ID = "\0seedcord:cloudflare-workers";
-const bindEnv = (env) => `import { Envapter, PortableSource } from 'envapt';
-Envapter.useSource(new PortableSource(${env}));
-`;
 const cloudflareWorkers = (env) => `export const env = ${env};
 export const exports = {};
 export const cache = {};
@@ -1602,18 +1598,40 @@ function edgeStandIns(loadEnv) {
 	return {
 		name: "seedcord:edge-stand-ins",
 		resolveId(id) {
-			if (id === "seedcord:bind-env") return RESOLVED_BIND_ENV_ID;
 			if (id === "cloudflare:workers") return CLOUDFLARE_WORKERS_ID;
 		},
 		async load(id) {
-			if (id !== RESOLVED_BIND_ENV_ID && id !== CLOUDFLARE_WORKERS_ID) return void 0;
+			if (id !== CLOUDFLARE_WORKERS_ID) return void 0;
 			const workerEnv = await loadEnv();
 			const values = JSON.stringify(workerEnv.values());
-			return id === RESOLVED_BIND_ENV_ID ? bindEnv(values) : cloudflareWorkers(values);
+			return cloudflareWorkers(values);
 		}
 	};
 }
 
+//#endregion
+//#region src/core/modules/envBootstrap.ts
+const ENV_BOOTSTRAP_ID = "seedcord:env";
+const RESOLVED_ENV_BOOTSTRAP_ID = `\0${ENV_BOOTSTRAP_ID}`;
+function envBootstrapSource(options) {
+	const helperPath = fileURLToPath(import.meta.resolve("@seedcord/core/internal/env"));
+	const imports = `import { Envapter } from 'envapt';
+import { bindViteEnv } from ${JSON.stringify(helperPath)};\n`;
+	if (options.runtime === "worker") return `${imports}import { env } from 'cloudflare:workers';
+export const binding = bindViteEnv(Envapter, import.meta.env, { bindings: env });\n`;
+	if (options.directory !== void 0) return `${imports}export const binding = bindViteEnv(Envapter, import.meta.env, { directory: ${JSON.stringify(options.directory)} });\n`;
+	const utilsPath = fileURLToPath(import.meta.resolve("@seedcord/utils/internal"));
+	return `${imports}import { botConfigDir } from ${JSON.stringify(utilsPath)};
+export const binding = bindViteEnv(Envapter, import.meta.env, { directory: botConfigDir() });\n`;
+}
+function envBootstrap(options) {
+	return {
+		name: "seedcord:env",
+		resolveId: (id) => id === "seedcord:env" ? RESOLVED_ENV_BOOTSTRAP_ID : void 0,
+		load: (id) => id === RESOLVED_ENV_BOOTSTRAP_ID ? envBootstrapSource(options) : void 0
+	};
+}
+
 //#endregion
 //#region src/core/modules/openViteServer.ts
 function closesOn(stack) {
@@ -1651,6 +1669,7 @@ const IMPORT_DEADLINE_MS = 3e4;
 var RunnerModuleLoader = class {
 	runner;
 	deadlineMs;
+	binding;
 	constructor(runner, deadlineMs = IMPORT_DEADLINE_MS) {
 		this.runner = runner;
 		this.deadlineMs = deadlineMs;
@@ -1660,8 +1679,16 @@ var RunnerModuleLoader = class {
 		if (!existsSync(path)) throw new SeedcordError(SeedcordErrorCode.CoreImportFailed, [path, "The file does not exist."]);
 		return this.load(path, path);
 	}
-	async bindEdgeEnv() {
-		await this.load(BIND_ENV_ID$1, "envapt");
+	async bindEnv() {
+		const { binding } = await this.load(ENV_BOOTSTRAP_ID, "envapt");
+		this.binding = binding;
+	}
+	async [Symbol.asyncDispose]() {
+		try {
+			await this.runner.close();
+		} finally {
+			this.binding?.[Symbol.dispose]();
+		}
 	}
 	async load(id, shownAs) {
 		let timer;
@@ -1877,6 +1904,9 @@ var WorkerEnv = class WorkerEnv {
 	static async load(cloudflareConfig, mode) {
 		return new WorkerEnv(await loadWorker(cloudflareConfig, mode), cloudflareConfig, mode);
 	}
+	bindToCli(stack) {
+		stack.use(bindEnv(Envapter, merge(Envapter.source, new PortableSource(this.values())), this.envDir));
+	}
 	values() {
 		const local = this.localVars();
 		const values = {};
@@ -1896,27 +1926,16 @@ var WorkerEnv = class WorkerEnv {
 
 //#endregion
 //#region src/core/modules/openModuleLoader.ts
-var ViteModuleLoader = class extends RunnerModuleLoader {
-	server;
-	constructor(server, runner) {
-		super(runner);
-		this.server = server;
-	}
-	async [Symbol.asyncDispose]() {
-		await this.runner.close();
-		await this.server.close();
-	}
-};
 function lazyWorkerEnv(cloudflareConfig, mode, loaded) {
 	let loading = loaded && Promise.resolve(loaded);
 	return () => loading ??= WorkerEnv.load(cloudflareConfig, mode);
 }
 async function openModuleLoader(projectDir, target, mode, use, devCopy) {
 	try {
-		var _usingCtx$6 = _usingCtx();
+		var _usingCtx$7 = _usingCtx();
 		const runsWorkerCode = target.kind === "edge" && use !== "config";
-		const workerEnv = target.kind === "edge" ? lazyWorkerEnv(target.cloudflareConfig, mode, devCopy?.workerEnv) : void 0;
-		if (runsWorkerCode) await workerEnv?.();
+		const loadWorkerEnv = target.kind === "edge" ? lazyWorkerEnv(target.cloudflareConfig, mode, devCopy?.workerEnv) : void 0;
+		const workerEnv = runsWorkerCode && loadWorkerEnv ? await loadWorkerEnv() : void 0;
 		const conditions = runsWorkerCode ? WORKERD_CONDITIONS : NODE_CONDITIONS;
 		const userPlugins = use === "config" ? [] : use.vitePlugins.create();
 		const config = mergeViteConfig(userCodeConfig(conditions, projectDir), {
@@ -1935,20 +1954,30 @@ async function openModuleLoader(projectDir, target, mode, use, devCopy) {
 				noDiscovery: true,
 				include: []
 			},
-			plugins: [...workerEnv ? [edgeStandIns(workerEnv)] : [], userPlugins]
+			plugins: [
+				envBootstrap(runsWorkerCode ? { runtime: "worker" } : {
+					runtime: "node",
+					directory: projectDir
+				}),
+				...loadWorkerEnv ? [edgeStandIns(loadWorkerEnv)] : [],
+				userPlugins
+			]
 		});
-		const onFailure = _usingCtx$6.a(new AsyncDisposableStack());
+		const onFailure = _usingCtx$7.a(new AsyncDisposableStack());
+		workerEnv?.bindToCli(onFailure);
 		const server = await openViteServer(onFailure, config);
 		const runner = createServerModuleRunner(botEnvironment(server.environments), { hmr: false });
-		onFailure.defer(() => runner.close());
-		const loader = new ViteModuleLoader(server, runner);
-		if (runsWorkerCode) await loader.bindEdgeEnv();
-		onFailure.move();
-		return loader;
+		const loader = onFailure.use(new RunnerModuleLoader(runner));
+		await loader.bindEnv();
+		const resources = onFailure.move();
+		return {
+			importModule: loader.importModule.bind(loader),
+			[Symbol.asyncDispose]: () => resources.disposeAsync()
+		};
 	} catch (_) {
-		_usingCtx$6.e = _;
+		_usingCtx$7.e = _;
 	} finally {
-		await _usingCtx$6.d();
+		await _usingCtx$7.d();
 	}
 }
 
@@ -1977,6 +2006,8 @@ function envFilesSetDevNodeEnv(mode, configDir) {
 }
 var ShellMode = class ShellMode {
 	variable;
+	nodeEnv = process.env.NODE_ENV;
+	viteNodeEnv = process.env.VITE_USER_NODE_ENV;
 	constructor(variable) {
 		this.variable = variable;
 	}
@@ -1993,7 +2024,12 @@ var ShellMode = class ShellMode {
 	applyMode(defaultMode, configDir) {
 		const mode = this.viteMode(defaultMode);
 		Envapter.environment = mode;
-		process.env.NODE_ENV ||= envFilesSetDevNodeEnv(mode, configDir) ? "development" : defaultMode;
+		if (this.nodeEnv) process.env.NODE_ENV = this.nodeEnv;
+		else {
+			if (this.viteNodeEnv === void 0) delete process.env.VITE_USER_NODE_ENV;
+			else process.env.VITE_USER_NODE_ENV = this.viteNodeEnv;
+			process.env.NODE_ENV = envFilesSetDevNodeEnv(mode, configDir) ? "development" : defaultMode;
+		}
 		return mode;
 	}
 	viteMode(defaultMode) {
@@ -2335,10 +2371,6 @@ const workerEntryConfig = () => ({ entrypoint: WORKER_ENTRY_ID });
 const BIND_ENV_ID = "virtual:seedcord/bind-env";
 const BUILT_FILES_ID = "virtual:seedcord/built-files";
 const BAKED_IDS_ID = "virtual:seedcord/baked-ids";
-const BIND_ENV = `import { env } from 'cloudflare:workers';
-import { Envapter, PortableSource } from 'envapt';
-Envapter.useSource(new PortableSource(env));
-`;
 const CWD_ID = "virtual:seedcord/cwd";
 function cwdSource(cwd) {
 	return `process.cwd = () => ${JSON.stringify(cwd)};\n`;
@@ -2370,7 +2402,7 @@ function setupSources({ layout, folders, rootKey, mode }) {
 	return new Map([
 		[CWD_ID, cwdSource(cwd)],
 		...modules,
-		[BIND_ENV_ID, BIND_ENV],
+		[BIND_ENV_ID, envBootstrapSource({ runtime: "worker" })],
 		[BUILT_FILES_ID, builtFilesSource({
 			layout,
 			folders,
@@ -2542,13 +2574,13 @@ function scopesInCode(found, configuredGuilds) {
 }
 async function loadInstance({ projectLoader }, projectDir) {
 	try {
-		var _usingCtx$5 = _usingCtx();
-		const project = _usingCtx$5.a(await openProjectWithSteps(quietSteps, projectLoader, { projectDir }));
+		var _usingCtx$6 = _usingCtx();
+		const project = _usingCtx$6.a(await openProjectWithSteps(quietSteps, projectLoader, { projectDir }));
 		return await importInstance(project.modules, project.config.instance);
 	} catch (_) {
-		_usingCtx$5.e = _;
+		_usingCtx$6.e = _;
 	} finally {
-		await _usingCtx$5.d();
+		await _usingCtx$6.d();
 	}
 }
 async function loadCodeScopes(steps, { projectLoader }, projectDir) {
@@ -2809,6 +2841,7 @@ function serverEntry(builtFiles, importBot) {
 			rootExpression: ROOT_EXPRESSION,
 			sourcePaths: false
 		}),
+		`await import('${ENV_BOOTSTRAP_ID}');`,
 		...importBot,
 		""
 	].join("\n");
@@ -2828,7 +2861,8 @@ function outputChunks(result) {
 function outputName(moduleId, layout) {
 	if (isServerEntry(moduleId)) return ENTRY_FILE_NAME;
 	if (moduleId && isListedFileId(moduleId)) return `_virtual/files${layout.listedKeyOf(listedFileOf(moduleId))}.js`;
-	return `[name]${BotLayout.builtExtension(withoutQuery(moduleId ?? ""))}`;
+	if (moduleId && layout.holds(moduleId)) return BotLayout.builtPath(layout.keyOf(withoutQuery(moduleId))).slice(1);
+	return "_virtual/[name]-[hash].js";
 }
 var ServerBuild = class extends TargetBuild {
 	target;
@@ -2851,19 +2885,24 @@ var ServerBuild = class extends TargetBuild {
 			rootKey: BotLayout.keyUnder(configDir, root),
 			configFile: BotLayout.keyUnder(outDir, config.configFile)
 		};
-		const result = await this.buildBot([serverEntry(builtFiles, importBot), pinModulePaths(layout)], {
+		const fileName = (chunk) => outputName(chunk.facadeModuleId, layout);
+		const result = await this.buildBot([
+			envBootstrap({ runtime: "node" }),
+			serverEntry(builtFiles, importBot),
+			pinModulePaths(layout)
+		], {
 			outDir,
 			emptyOutDir: true,
 			sourcemap: true,
 			minify: false,
 			target: NODE_TARGET,
 			rolldownOptions: {
-				input: ENTRY_ID,
+				input: [ENTRY_ID, ...await files.modulePaths()],
+				preserveEntrySignatures: "strict",
 				output: {
 					format: "esm",
-					preserveModules: true,
-					preserveModulesRoot: root,
-					entryFileNames: (chunk) => outputName(chunk.facadeModuleId, layout)
+					entryFileNames: fileName,
+					chunkFileNames: fileName
 				}
 			}
 		});
@@ -3054,13 +3093,13 @@ var BuildRunner = class BuildRunner {
 	}
 	async run(projectDir = process.cwd()) {
 		try {
-			var _usingCtx$4 = _usingCtx();
+			var _usingCtx$5 = _usingCtx();
 			const { steps, typeChecker } = this.deps;
 			const opened = await openProjectWithSteps(steps, this.deps.projectLoader, {
 				projectDir,
 				check: checkBuildTarget
 			});
-			const build = _usingCtx$4.a(this.deps.buildFor(opened));
+			const build = _usingCtx$5.a(this.deps.buildFor(opened));
 			const { project } = build;
 			const { config, modules } = project;
 			printResolvedConfig(steps, config);
@@ -3080,9 +3119,9 @@ var BuildRunner = class BuildRunner {
 				nextCommands: build.nextCommands(bundle)
 			};
 		} catch (_) {
-			_usingCtx$4.e = _;
+			_usingCtx$5.e = _;
 		} finally {
-			await _usingCtx$4.d();
+			await _usingCtx$5.d();
 		}
 	}
 	async bundle(build, instance) {
@@ -3357,9 +3396,9 @@ var CodegenRunner = class CodegenRunner {
 	}
 	async run(check) {
 		try {
-			var _usingCtx$3 = _usingCtx();
+			var _usingCtx$4 = _usingCtx();
 			const { steps, projectLoader } = this.deps;
-			const { config, files, modules } = _usingCtx$3.a(await openProjectWithSteps(steps, projectLoader));
+			const { config, files, modules } = _usingCtx$4.a(await openProjectWithSteps(steps, projectLoader));
 			printResolvedConfig(steps, config);
 			const instance = await steps.step("load bot", () => importInstance(modules, config.instance));
 			return await this.generate({
@@ -3369,9 +3408,9 @@ var CodegenRunner = class CodegenRunner {
 				modules
 			}, check);
 		} catch (_) {
-			_usingCtx$3.e = _;
+			_usingCtx$4.e = _;
 		} finally {
-			await _usingCtx$3.d();
+			await _usingCtx$4.d();
 		}
 	}
 	async writeFrom(bot) {
@@ -3433,12 +3472,6 @@ var CodegenCommand = class extends BaseCommand {
 	}
 };
 
-//#endregion
-//#region src/core/interactive.ts
-function isInteractive() {
-	return process.stdin.isTTY === true && process.stdout.isTTY === true && !process.env.CI;
-}
-
 //#endregion
 //#region src/core/output/stderrSteps.ts
 function stderrSteps(stdout = process.stdout, stderr = process.stderr) {
@@ -7159,10 +7192,6 @@ function installCliLogSinks(stack) {
 	installNodeDefaults();
 	stack.defer(() => LoggerChannelRegistry.instance.configure({}));
 }
-function bindWorkerEnvToCli(workerEnv, stack) {
-	Envapter.useSource(merge(new FileSource(), new PortableSource(workerEnv.values())));
-	stack.defer(() => Envapter.useSource(new FileSource()));
-}
 var EdgeDevRuntime = class extends BaseDevRuntime {
 	target;
 	settleStart;
@@ -7185,7 +7214,6 @@ var EdgeDevRuntime = class extends BaseDevRuntime {
 			CloudflareWorker.load(this.target),
 			WorkerEnv.load(this.target.cloudflareConfig, config.viteMode)
 		]);
-		bindWorkerEnvToCli(workerEnv, resources);
 		const nodeCopy = await openModuleLoader(dirname(config.configFile), this.target, config.viteMode, config, {
 			watch: devWatchOptions(files.layout),
 			workerEnv
@@ -7295,11 +7323,20 @@ var ServerDevRuntime = class extends BaseDevRuntime {
 		const hmr = this.openHmr(context, BOT_ENVIRONMENT, resources);
 		const server = await openViteServer(resources, mergeViteConfig(serverViteConfig(context.config, context.files.layout), {
 			mode: context.config.viteMode,
-			plugins: [hmr.plugin, context.config.vitePlugins.create()]
+			plugins: [
+				envBootstrap({
+					runtime: "node",
+					directory: dirname(context.config.configFile)
+				}),
+				hmr.plugin,
+				context.config.vitePlugins.create()
+			]
 		})).catch(rethrowVitePluginError);
+		const modules = resources.use(new RunnerModuleLoader(createServerModuleRunner(botEnvironment(server.environments))));
+		await modules.bindEnv();
 		return {
 			context,
-			modules: new RunnerModuleLoader(createServerModuleRunner(botEnvironment(server.environments))),
+			modules,
 			hmr,
 			resources
 		};
@@ -7749,13 +7786,13 @@ var DevRunner = class DevRunner {
 	}
 	async runSession() {
 		try {
-			var _usingCtx$2 = _usingCtx();
+			var _usingCtx$3 = _usingCtx();
 			const { store, tunnel } = this.deps;
 			resetChannelColors();
 			store.setPhase("starting");
 			store.setBusy(true);
 			const restarts = this.restarts;
-			const { config, files } = _usingCtx$2.a(await this.deps.projectLoader.readConfig());
+			const { config, files } = _usingCtx$3.a(await this.deps.projectLoader.readConfig());
 			if (this.next !== "session" || this.restarts !== restarts) return;
 			profileMark("config");
 			store.setIdleAnimation(config.idleAnimation);
@@ -7771,9 +7808,9 @@ var DevRunner = class DevRunner {
 				this.currentSession = null;
 			}
 		} catch (_) {
-			_usingCtx$2.e = _;
+			_usingCtx$3.e = _;
 		} finally {
-			await _usingCtx$2.d();
+			await _usingCtx$3.d();
 		}
 	}
 	async quit() {
@@ -7816,26 +7853,56 @@ var DevRunner = class DevRunner {
 //#endregion
 //#region src/commands/dev/runPlain.ts
 const logger = cliLogger("Dev");
-async function runPlain(store, runner) {
-	let failure;
-	const answer = () => {
-		const { phase, commandUpdatePrompt, error } = store.getState();
-		if (commandUpdatePrompt !== null) runner.refreshCommands(true);
-		if (phase === "restart-required") {
-			logger.info("Restarting to pick up the change");
-			runner.restart();
-		} else if (phase === "error" && error !== null) {
-			failure ??= error;
-			runner.quit();
-		}
-	};
-	store.on("change", answer);
+const COMMANDS = /* @__PURE__ */ new Map([
+	["restart", (runner) => runner.restart()],
+	["disconnect", (runner) => runner.disconnect()],
+	["quit", (runner) => runner.quit()]
+]);
+function commandOn(line) {
 	try {
-		await runner.run();
+		return COMMANDS.get(JSON.parse(line)?.do);
+	} catch {
+		return;
+	}
+}
+function leaveToRun(command) {
+	command.catch(() => void 0);
+}
+async function runPlain(store, runner, input) {
+	try {
+		var _usingCtx$2 = _usingCtx();
+		let failure;
+		const answer = () => {
+			const { phase, commandUpdatePrompt, error } = store.getState();
+			if (commandUpdatePrompt !== null) runner.refreshCommands(true);
+			if (phase === "restart-required") {
+				logger.info("Restarting to pick up the change");
+				leaveToRun(runner.restart());
+			} else if (phase === "error" && error !== null) {
+				failure ??= error;
+				leaveToRun(runner.quit());
+			}
+		};
+		_usingCtx$2.u(createInterface({
+			input,
+			terminal: false
+		})).on("line", (line) => {
+			const command = commandOn(line);
+			if (command) leaveToRun(command(runner));
+			else logger.warn(`Ignoring stdin line: ${line}`);
+		});
+		store.on("change", answer);
+		try {
+			await runner.run();
+		} finally {
+			store.off("change", answer);
+		}
+		if (failure) throw failure;
+	} catch (_) {
+		_usingCtx$2.e = _;
 	} finally {
-		store.off("change", answer);
+		_usingCtx$2.d();
 	}
-	if (failure) throw failure;
 }
 
 //#endregion
@@ -7855,7 +7922,7 @@ var DevCommand = class extends BaseCommand {
 				try {
 					var _usingCtx$1 = _usingCtx();
 					_usingCtx$1.u(DevSignals.own(() => void runner.quit()));
-					await (isInteractive() ? this.runDevApp(store, runner, stateFolder) : runPlain(store, runner));
+					await (isInteractive() ? this.runDevApp(store, runner, stateFolder) : runPlain(store, runner, process.stdin));
 				} catch (_) {
 					_usingCtx$1.e = _;
 				} finally {