@nuxt/cli-nightly 3.30.0-20251029-210522-3a92d84 → 3.30.0-20251030-113745-b8ea409

package/dist/{dev-DsH3xiyp.mjs → dev-BYEMtZLe.mjs}

@@ -1,74 +1,22 @@
-import { t as clearBuildDir } from "./fs-ewAp6tjM.mjs";
-import { t as loadKit } from "./kit-xFxVGu6d.mjs";
-import { a as writeNuxtManifest, i as resolveNuxtManifest, n as loadNuxtManifest } from "./nuxt-Cc9ZTk7m.mjs";
+import { t as loadKit } from "./kit-f7zsnm10.mjs";
+import { n as showVersionsFromConfig } from "./banner-CWBLwDiB.mjs";
+import { t as clearBuildDir } from "./fs--ofMleGo.mjs";
+import { a as writeNuxtManifest, i as resolveNuxtManifest, n as loadNuxtManifest } from "./nuxt-CfBR40hD.mjs";
 import process from "node:process";
 import { provider } from "std-env";
 import { pathToFileURL } from "node:url";
 import defu, { defu as defu$1 } from "defu";
-import { listen } from "listhen";
-import { Server } from "node:http";
-import { cleanSocket, getSocketAddress } from "get-port-please";
 import EventEmitter from "node:events";
 import { existsSync, statSync, watch } from "node:fs";
 import { mkdir } from "node:fs/promises";
 import { resolveModulePath } from "exsolve";
 import { joinURL } from "ufo";
+import { listen } from "listhen";
 import { resolve } from "pathe";
 import { debounce } from "perfect-debounce";
 import { toNodeHandler } from "srvx/node";
 import { Youch } from "youch";
 
-//#region ../nuxi/src/dev/socket.ts
-function formatSocketURL(socketPath, ssl = false) {
-	return `${ssl ? "https" : "http"}+unix://${process.platform === "win32" ? encodeURIComponent(socketPath) : socketPath.replace(/\//g, "%2F")}`;
-}
-function isSocketURL(url) {
-	return url.startsWith("http+unix://") || url.startsWith("https+unix://");
-}
-function parseSocketURL(url) {
-	if (!isSocketURL(url)) throw new Error(`Invalid socket URL: ${url}`);
-	const ssl = url.startsWith("https+unix://");
-	const path = url.slice(ssl ? 13 : 12);
-	return {
-		socketPath: decodeURIComponent(path.replace(/%2F/g, "/")),
-		protocol: ssl ? "https" : "http"
-	};
-}
-async function createSocketListener(handler, proxyAddress) {
-	const socketPath = getSocketAddress({
-		name: "nuxt-dev",
-		random: true
-	});
-	const server = new Server(handler);
-	await cleanSocket(socketPath);
-	await new Promise((resolve$1) => server.listen({ path: socketPath }, resolve$1));
-	const url = formatSocketURL(socketPath);
-	return {
-		url,
-		address: {
-			address: "localhost",
-			port: 3e3,
-			...proxyAddress,
-			socketPath
-		},
-		async close() {
-			try {
-				server.removeAllListeners();
-				await new Promise((resolve$1, reject) => server.close((err) => err ? reject(err) : resolve$1()));
-			} finally {
-				await cleanSocket(socketPath);
-			}
-		},
-		getURLs: async () => [{
-			url,
-			type: "network"
-		}],
-		https: false,
-		server
-	};
-}
-
-//#endregion
 //#region ../../node_modules/.pnpm/h3@1.15.4/node_modules/h3/dist/index.mjs
 function hasProp(obj, prop) {
 	try {
@@ -337,6 +285,8 @@ async function renderError(req, res, error) {
 	const youch = new Youch();
 	res.statusCode = 500;
 	res.setHeader("Content-Type", "text/html");
+	res.setHeader("Cache-Control", "no-store");
+	res.setHeader("Refresh", "3");
 	const html = await youch.toHTML(error, { request: {
 		url: req.url,
 		method: req.method,
@@ -363,14 +313,15 @@ var FileChangeTracker = class {
 	}
 };
 var NuxtDevServer = class extends EventEmitter {
-	_handler;
-	_distWatcher;
-	_configWatcher;
-	_currentNuxt;
-	_loadingMessage;
-	_loadingError;
-	_fileChangeTracker = new FileChangeTracker();
-	cwd;
+	#handler;
+	#distWatcher;
+	#configWatcher;
+	#currentNuxt;
+	#loadingMessage;
+	#loadingError;
+	#fileChangeTracker = new FileChangeTracker();
+	#cwd;
+	#websocketConnections = /* @__PURE__ */ new Set();
 	loadDebounced;
 	handler;
 	listener;
@@ -385,66 +336,58 @@ var NuxtDevServer = class extends EventEmitter {
 		this.once("ready", () => {
 			_initResolve();
 		});
-		this.cwd = options.cwd;
+		this.#cwd = options.cwd;
 		this.handler = async (req, res) => {
-			if (this._loadingError) {
-				this._renderError(req, res);
+			if (this.#loadingError) {
+				renderError(req, res, this.#loadingError);
 				return;
 			}
 			await _initPromise;
-			if (this._handler) this._handler(req, res);
-			else this._renderLoadingScreen(req, res);
+			if (this.#handler) this.#handler(req, res);
+			else this.#renderLoadingScreen(req, res);
 		};
-		this.listener = void 0;
 	}
-	_renderError(req, res) {
-		renderError(req, res, this._loadingError);
-	}
-	async _renderLoadingScreen(req, res) {
+	async #renderLoadingScreen(req, res) {
 		if (res.headersSent) {
 			if (!res.writableEnded) res.end();
 			return;
 		}
 		res.statusCode = 503;
 		res.setHeader("Content-Type", "text/html");
-		const loadingTemplate = this.options.loadingTemplate || this._currentNuxt?.options.devServer.loadingTemplate || await resolveLoadingTemplate(this.cwd);
-		res.end(loadingTemplate({ loading: this._loadingMessage || "Loading..." }));
+		const loadingTemplate = this.options.loadingTemplate || this.#currentNuxt?.options.devServer.loadingTemplate || await resolveLoadingTemplate(this.#cwd);
+		res.end(loadingTemplate({ loading: this.#loadingMessage || "Loading..." }));
 	}
 	async init() {
-		await this.load();
-		this._watchConfig();
+		this.#loadingMessage = `Starting Nuxt...`;
+		this.#handler = void 0;
+		this.emit("loading", this.#loadingMessage);
+		await this.#loadNuxtInstance();
+		if (this.options.showBanner) showVersionsFromConfig(this.options.cwd, this.#currentNuxt.options);
+		await this.#createListener();
+		await this.#initializeNuxt(false);
+		this.#watchConfig();
 	}
 	closeWatchers() {
-		this._distWatcher?.close();
-		this._configWatcher?.();
+		this.#distWatcher?.close();
+		this.#configWatcher?.();
 	}
 	async load(reload, reason) {
 		try {
 			this.closeWatchers();
-			await this._load(reload, reason);
-			this._watchConfig();
-			this._loadingError = void 0;
+			await this.#load(reload, reason);
+			this.#loadingError = void 0;
 		} catch (error) {
 			console.error(`Cannot ${reload ? "restart" : "start"} nuxt: `, error);
-			this._handler = void 0;
-			this._loadingError = error;
-			this._loadingMessage = "Error while loading Nuxt. Please check console and fix errors.";
+			this.#handler = void 0;
+			this.#loadingError = error;
+			this.#loadingMessage = "Error while loading Nuxt. Please check console and fix errors.";
 			this.emit("loading:error", error);
 		}
+		this.#watchConfig();
 	}
-	async close() {
-		if (this._currentNuxt) await this._currentNuxt.close();
-	}
-	async _load(reload, reason) {
-		const action = reload ? "Restarting" : "Starting";
-		this._loadingMessage = `${reason ? `${reason}. ` : ""}${action} Nuxt...`;
-		this._handler = void 0;
-		this.emit("loading", this._loadingMessage);
-		if (reload) console.info(this._loadingMessage);
-		await this.close();
+	async #loadNuxtInstance(urls) {
 		const kit = await loadKit(this.options.cwd);
-		const devServerDefaults = resolveDevServerDefaults({}, await this.listener.getURLs().then((r) => r.map((r$1) => r$1.url)));
-		this._currentNuxt = await kit.loadNuxt({
+		const loadOptions = {
 			cwd: this.options.cwd,
 			dev: true,
 			ready: false,
@@ -453,7 +396,6 @@ var NuxtDevServer = class extends EventEmitter {
 				cwd: this.options.cwd,
 				fileName: this.options.dotenv.fileName
 			},
-			defaults: defu(this.options.defaults, devServerDefaults),
 			overrides: {
 				logLevel: this.options.logLevel,
 				...this.options.overrides,
@@ -462,8 +404,55 @@ var NuxtDevServer = class extends EventEmitter {
 					...this.options.overrides.vite
 				}
 			}
-		});
-		if (!process.env.NUXI_DISABLE_VITE_HMR) this._currentNuxt.hooks.hook("vite:extend", ({ config }) => {
+		};
+		if (urls) {
+			const overrides = this.options.listenOverrides || {};
+			const hostname = overrides.hostname ?? overrides.host;
+			const https = overrides.https;
+			loadOptions.defaults = resolveDevServerDefaults({
+				hostname,
+				https
+			}, urls);
+		}
+		this.#currentNuxt = await kit.loadNuxt(loadOptions);
+	}
+	async #createListener() {
+		if (!this.#currentNuxt) throw new Error("Nuxt must be loaded before creating listener");
+		const listenOptions = this.#resolveListenOptions();
+		this.listener = await listen(this.handler, listenOptions);
+		if (listenOptions.public) {
+			this.#currentNuxt.options.devServer.cors = { origin: "*" };
+			if (this.#currentNuxt.options.vite?.server) this.#currentNuxt.options.vite.server.allowedHosts = true;
+			return;
+		}
+		const urls = await this.listener.getURLs().then((r) => r.map((r$1) => r$1.url));
+		if (urls && urls.length > 0) this.#currentNuxt.options.vite = defu(this.#currentNuxt.options.vite, { server: { allowedHosts: urls.map((u) => new URL(u).hostname) } });
+	}
+	#resolveListenOptions() {
+		if (!this.#currentNuxt) throw new Error("Nuxt must be loaded before resolving listen options");
+		const nuxtConfig = this.#currentNuxt.options;
+		const overrides = this.options.listenOverrides || {};
+		const port = overrides.port ?? nuxtConfig.devServer?.port;
+		const hostname = overrides.hostname ?? overrides.host ?? nuxtConfig.devServer?.host;
+		const isPublic = provider === "codesandbox" || (overrides.public ?? (isPublicHostname(hostname) ? true : void 0));
+		const httpsFromConfig = typeof nuxtConfig.devServer?.https !== "boolean" && nuxtConfig.devServer?.https ? nuxtConfig.devServer.https : {};
+		const httpsOptions = !!(overrides.https ?? nuxtConfig.devServer?.https) && {
+			...httpsFromConfig,
+			...typeof overrides.https === "object" ? overrides.https : {}
+		};
+		const baseURL = nuxtConfig.app?.baseURL?.startsWith?.("./") ? nuxtConfig.app.baseURL.slice(1) : nuxtConfig.app?.baseURL;
+		return {
+			...overrides,
+			port,
+			hostname,
+			public: isPublic,
+			https: httpsOptions || void 0,
+			baseURL
+		};
+	}
+	async #initializeNuxt(reload) {
+		if (!this.#currentNuxt) throw new Error("Nuxt must be loaded before configuration");
+		if (!process.env.NUXI_DISABLE_VITE_HMR) this.#currentNuxt.hooks.hook("vite:extend", ({ config }) => {
 			if (config.server) config.server.hmr = {
 				protocol: void 0,
 				...config.server.hmr,
@@ -472,20 +461,21 @@ var NuxtDevServer = class extends EventEmitter {
 				server: this.listener.server
 			};
 		});
-		this._currentNuxt.hooks.hookOnce("close", () => {
+		this.#currentNuxt.hooks.hookOnce("close", () => {
+			this.#closeWebSocketConnections();
 			this.listener.server.removeAllListeners("upgrade");
 		});
 		if (!reload) {
-			const previousManifest = await loadNuxtManifest(this._currentNuxt.options.buildDir);
-			const newManifest = resolveNuxtManifest(this._currentNuxt);
-			const promise = writeNuxtManifest(this._currentNuxt, newManifest);
-			this._currentNuxt.hooks.hookOnce("ready", async () => {
+			const previousManifest = await loadNuxtManifest(this.#currentNuxt.options.buildDir);
+			const newManifest = resolveNuxtManifest(this.#currentNuxt);
+			const promise = writeNuxtManifest(this.#currentNuxt, newManifest);
+			this.#currentNuxt.hooks.hookOnce("ready", async () => {
 				await promise;
 			});
-			if (previousManifest && newManifest && previousManifest._hash !== newManifest._hash) await clearBuildDir(this._currentNuxt.options.buildDir);
+			if (previousManifest && newManifest && previousManifest._hash !== newManifest._hash) await clearBuildDir(this.#currentNuxt.options.buildDir);
 		}
-		await this._currentNuxt.ready();
-		const unsub = this._currentNuxt.hooks.hook("restart", async (options) => {
+		await this.#currentNuxt.ready();
+		const unsub = this.#currentNuxt.hooks.hook("restart", async (options) => {
 			unsub();
 			if (options?.hard) {
 				this.emit("restart");
@@ -493,35 +483,59 @@ var NuxtDevServer = class extends EventEmitter {
 			}
 			await this.load(true);
 		});
-		if (this._currentNuxt.server && "upgrade" in this._currentNuxt.server) this.listener.server.on("upgrade", (req, socket, head) => {
-			const nuxt = this._currentNuxt;
+		if (this.#currentNuxt.server && "upgrade" in this.#currentNuxt.server) this.listener.server.on("upgrade", (req, socket, head) => {
+			const nuxt = this.#currentNuxt;
 			if (!nuxt || !nuxt.server) return;
 			const viteHmrPath = joinURL(nuxt.options.app.baseURL.startsWith("./") ? nuxt.options.app.baseURL.slice(1) : nuxt.options.app.baseURL, nuxt.options.app.buildAssetsDir);
 			if (req.url?.startsWith(viteHmrPath)) return;
 			nuxt.server.upgrade(req, socket, head);
+			this.#websocketConnections.add(socket);
+			socket.on("close", () => {
+				this.#websocketConnections.delete(socket);
+			});
 		});
-		await this._currentNuxt.hooks.callHook("listen", this.listener.server, this.listener);
+		await this.#currentNuxt.hooks.callHook("listen", this.listener.server, this.listener);
 		const addr = this.listener.address;
-		this._currentNuxt.options.devServer.host = addr.address;
-		this._currentNuxt.options.devServer.port = addr.port;
-		this._currentNuxt.options.devServer.url = getAddressURL(addr, !!this.listener.https);
-		this._currentNuxt.options.devServer.https = this.options.devContext.proxy?.https;
+		this.#currentNuxt.options.devServer.host = addr.address;
+		this.#currentNuxt.options.devServer.port = addr.port;
+		this.#currentNuxt.options.devServer.url = getAddressURL(addr, !!this.listener.https);
+		this.#currentNuxt.options.devServer.https = this.listener.https;
 		if (this.listener.https && !process.env.NODE_TLS_REJECT_UNAUTHORIZED) console.warn("You might need `NODE_TLS_REJECT_UNAUTHORIZED=0` environment variable to make https work.");
-		await Promise.all([kit.writeTypes(this._currentNuxt).catch(console.error), kit.buildNuxt(this._currentNuxt)]);
-		if (!this._currentNuxt.server) throw new Error("Nitro server has not been initialized.");
-		const distDir = resolve(this._currentNuxt.options.buildDir, "dist");
+		const kit = await loadKit(this.options.cwd);
+		await Promise.all([kit.writeTypes(this.#currentNuxt).catch(console.error), kit.buildNuxt(this.#currentNuxt)]);
+		if (!this.#currentNuxt.server) throw new Error("Nitro server has not been initialized.");
+		const distDir = resolve(this.#currentNuxt.options.buildDir, "dist");
 		await mkdir(distDir, { recursive: true });
-		this._distWatcher = watch(distDir);
-		this._distWatcher.on("change", (_event, file) => {
-			if (!this._fileChangeTracker.shouldEmitChange(resolve(distDir, file || ""))) return;
+		this.#distWatcher = watch(distDir);
+		this.#distWatcher.on("change", (_event, file) => {
+			if (!this.#fileChangeTracker.shouldEmitChange(resolve(distDir, file || ""))) return;
 			this.loadDebounced(true, ".nuxt/dist directory has been removed");
 		});
-		if ("fetch" in this._currentNuxt.server) this._handler = toNodeHandler(this._currentNuxt.server.fetch);
-		else this._handler = toNodeListener(this._currentNuxt.server.app);
-		this.emit("ready", "socketPath" in addr ? formatSocketURL(addr.socketPath, !!this.listener.https) : `http://127.0.0.1:${addr.port}`);
+		if ("fetch" in this.#currentNuxt.server) this.#handler = toNodeHandler(this.#currentNuxt.server.fetch);
+		else this.#handler = toNodeListener(this.#currentNuxt.server.app);
+		const proto = this.listener.https ? "https" : "http";
+		this.emit("ready", `${proto}://127.0.0.1:${addr.port}`);
 	}
-	_watchConfig() {
-		this._configWatcher = createConfigWatcher(this.cwd, this.options.dotenv.fileName, () => this.emit("restart"), (file) => this.loadDebounced(true, `${file} updated`));
+	async close() {
+		if (this.#currentNuxt) await this.#currentNuxt.close();
+	}
+	#closeWebSocketConnections() {
+		for (const socket of this.#websocketConnections) socket.destroy();
+		this.#websocketConnections.clear();
+	}
+	async #load(reload, reason) {
+		const action = reload ? "Restarting" : "Starting";
+		this.#loadingMessage = `${reason ? `${reason}. ` : ""}${action} Nuxt...`;
+		this.#handler = void 0;
+		this.emit("loading", this.#loadingMessage);
+		if (reload) console.info(this.#loadingMessage);
+		await this.close();
+		const urls = await this.listener.getURLs().then((r) => r.map((r$1) => r$1.url));
+		await this.#loadNuxtInstance(urls);
+		await this.#initializeNuxt(!!reload);
+	}
+	#watchConfig() {
+		this.#configWatcher = createConfigWatcher(this.#cwd, this.options.dotenv.fileName, () => this.emit("restart"), (file) => this.loadDebounced(true, `${file} updated`));
 	}
 };
 function getAddressURL(addr, https) {
@@ -531,16 +545,9 @@ function getAddressURL(addr, https) {
 	const port = addr.port || 3e3;
 	return `${proto}://${host}:${port}/`;
 }
-function resolveDevServerOverrides(listenOptions) {
-	if (listenOptions.public || provider === "codesandbox") return {
-		devServer: { cors: { origin: "*" } },
-		vite: { server: { allowedHosts: true } }
-	};
-	return {};
-}
 function resolveDevServerDefaults(listenOptions, urls = []) {
 	const defaultConfig = {};
-	if (urls) defaultConfig.vite = { server: { allowedHosts: urls.filter((u) => !isSocketURL(u)).map((u) => new URL(u).hostname) } };
+	if (urls && urls.length > 0) defaultConfig.vite = { server: { allowedHosts: urls.map((u) => new URL(u).hostname) } };
 	if (listenOptions.hostname) {
 		defaultConfig.devServer = { cors: { origin: [`${listenOptions.https ? "https" : "http"}://${listenOptions.hostname}`, ...urls] } };
 		defaultConfig.vite = defu(defaultConfig.vite, { server: { allowedHosts: [listenOptions.hostname] } });
@@ -579,6 +586,13 @@ async function resolveLoadingTemplate(cwd) {
 		try: true
 	}) || cwd })).href)).loading || ((params) => `<h2>${params.loading}</h2>`);
 }
+function isPublicHostname(hostname) {
+	return !!hostname && ![
+		"localhost",
+		"127.0.0.1",
+		"::1"
+	].includes(hostname);
+}
 
 //#endregion
 //#region ../nuxi/src/dev/index.ts
@@ -595,7 +609,7 @@ var IPC = class {
 			process.exit();
 		});
 		process.on("message", (message) => {
-			if (message.type === "nuxt:internal:dev:context") initialize(message.context, {}, message.socket ? void 0 : true);
+			if (message.type === "nuxt:internal:dev:context") initialize(message.context, { listenOverrides: message.listenOverrides });
 		});
 		this.send({ type: "nuxt:internal:dev:fork-ready" });
 	}
@@ -604,16 +618,10 @@ var IPC = class {
 	}
 };
 const ipc = new IPC();
-async function initialize(devContext, ctx = {}, _listenOptions) {
-	const devServerOverrides = resolveDevServerOverrides({ public: devContext.public });
-	const devServerDefaults = resolveDevServerDefaults({
-		hostname: devContext.hostname,
-		https: devContext.proxy?.https
-	}, devContext.publicURLs);
+async function initialize(devContext, ctx = {}) {
 	const devServer = new NuxtDevServer({
 		cwd: devContext.cwd,
-		overrides: defu(ctx.data?.overrides, { extends: devContext.args.extends }, devServerOverrides),
-		defaults: devServerDefaults,
+		overrides: defu(ctx.data?.overrides, { extends: devContext.args.extends }),
 		logLevel: devContext.args.logLevel,
 		clear: devContext.args.clear,
 		dotenv: {
@@ -621,21 +629,9 @@ async function initialize(devContext, ctx = {}, _listenOptions) {
 			fileName: devContext.args.dotenv
 		},
 		envName: devContext.args.envName,
-		devContext: { proxy: devContext.proxy }
+		showBanner: ctx.showBanner !== false && !ipc.enabled,
+		listenOverrides: ctx.listenOverrides
 	});
-	const listenOptions = _listenOptions === true || process.env._PORT ? {
-		port: process.env._PORT ?? 0,
-		hostname: "127.0.0.1",
-		showURL: false
-	} : _listenOptions;
-	devServer.listener = listenOptions ? await listen(devServer.handler, listenOptions) : await createSocketListener(devServer.handler, devContext.proxy?.addr);
-	if (process.env.DEBUG) console.debug(`Using ${listenOptions ? "network" : "socket"} listener for Nuxt dev server.`);
-	devServer.listener._url = devServer.listener.url;
-	if (devContext.proxy?.url) devServer.listener.url = devContext.proxy.url;
-	if (devContext.proxy?.urls) {
-		const _getURLs = devServer.listener.getURLs.bind(devServer.listener);
-		devServer.listener.getURLs = async () => Array.from(new Set([...devContext.proxy?.urls || [], ...await _getURLs()]));
-	}
 	let address;
 	if (ipc.enabled) {
 		devServer.on("loading:error", (_error) => {
@@ -673,7 +669,7 @@ async function initialize(devContext, ctx = {}, _listenOptions) {
 		listener: devServer.listener,
 		close: async () => {
 			devServer.closeWatchers();
-			await devServer.close();
+			await Promise.all([devServer.listener.close(), devServer.close()]);
 		},
 		onReady: (callback) => {
 			if (address) callback(address);
@@ -695,4 +691,4 @@ async function initialize(devContext, ctx = {}, _listenOptions) {
 }
 
 //#endregion
-export { parseSocketURL as a, isSocketURL as i, resolveLoadingTemplate as n, renderError as r, initialize as t };
+export { initialize as t };

package/dist/dev-CD5a8ssT.mjs

@@ -0,0 +1,8 @@
+import "./logger-Dk0gkCkX.mjs";
+import { t as initialize } from "./dev-BYEMtZLe.mjs";
+import "./kit-f7zsnm10.mjs";
+import "./banner-CWBLwDiB.mjs";
+import "./fs--ofMleGo.mjs";
+import "./nuxt-CfBR40hD.mjs";
+
+export { initialize };

package/dist/{dev-child-CJxOnht6.mjs → dev-child-Dcs4VQnN.mjs}

@@ -25,7 +25,7 @@ var dev_child_default = defineCommand({
 	async run(ctx) {
 		if (!process.send && !isTest) console.warn("`nuxi _dev` is an internal command and should not be used directly. Please use `nuxi dev` instead.");
 		const cwd = resolve(ctx.args.cwd || ctx.args.rootDir);
-		const { initialize } = await import("./dev-Bv3ZMKhd.mjs");
+		const { initialize } = await import("./dev-CD5a8ssT.mjs");
 		await initialize({
 			cwd,
 			args: ctx.args