@nuxt/cli4.0.329.8 kB
import { c as profileArgs, h as defineCommand, i as extendsArgs, l as rootDirArgs, n as dotEnvArgs, r as envNameArgs, s as logLevelArgs } from "./_shared-BmKJJNpF.mjs";
import { S as ActionableError, h as isInteractive, i as withUserAttention, s as debug, t as startupElapsedMs, u as logger, x as writeDirectTo } from "./startup-clock-Brvqy2C-.mjs";
import { t as tryResolveNuxt } from "./resolve-nuxt-l3Qmn2zH.mjs";
import { c as withDirectStdout, o as restoreRawMode } from "./console-CkLh6PBj.mjs";
import { t as replaceCwdArg } from "./args-CAT9qhaw.mjs";
import { c as openInspector, l as resolveInspectOptions, n as formatRestartReason, s as closeInspector } from "./reason-ZeAW2Y3R.mjs";
import { t as NUXT_PACKAGES } from "./nuxt-packages-DI1WwngW.mjs";
import { i as isReusePortSupported, s as parsePort } from "./listen-BU67IWQG.mjs";
import { i as resolveRootDir, n as relativeTo } from "./paths-BWaxgDBO.mjs";
import { t as createSpinner } from "./spinner-BSFu_Z9-.mjs";
import { t as CONFIG_EXTENSIONS } from "./nuxt-config-DvyFKfn_.mjs";
import { i as resolveLockDir } from "./dev-server-D_0p-Kc6.mjs";
import { n as FORCE_KILL_TIMEOUT_MS, r as handleShutdownSignals } from "./shutdown-16FH-C3A.mjs";
import { devShortcutContext } from "./shortcut-context-jl_XQvPi.mjs";
import { n as takeOverServer, t as formatTakeoverRefusal } from "./takeover-Cc9s0WhN.mjs";
import { beginDevUI, setupDevUI, teardownDevUI } from "./controller-DePnBcYz.mjs";
import process from "node:process";
import { styleText } from "node:util";
import { isBun, isTest } from "std-env";
import { confirm, isCancel } from "@clack/prompts";
import { dirname, join } from "pathe";
import { accessSync, constants, existsSync, readFileSync, readdirSync } from "node:fs";
import { fork } from "node:child_process";
import { satisfies } from "verkit";
// src/dev/pool.ts
var ForkPool = class {
forks = /* @__PURE__ */ new Set();
/** Forks that are starting or ready and not yet handed out. */
idle = [];
poolSize;
warming = false;
options;
constructor(options) {
this.options = options;
this.poolSize = options.poolSize ?? 1;
if (options.pipeOutput) process.stdout.on("resize", () => {
for (const fork of this.forks) if (fork.process.connected) fork.process.send({
type: "nuxt:internal:dev:resize",
columns: process.stdout.columns || 80
}, () => {});
});
process.once("exit", () => this.killAll("SIGTERM"));
process.once("SIGQUIT", () => this.killAll("SIGQUIT"));
}
startWarming() {
if (!this.warming) {
this.warming = true;
this.fill();
}
}
async getFork(context, options = {}) {
this.warming = true;
const fork = this.idle.find((f) => f.isReady) ?? this.idle[0] ?? this.createFork();
this.idle = this.idle.filter((f) => f !== fork);
await fork.ready;
const serving = trackServing(fork.process);
serving.catch(() => {});
const onMessage = options.onMessage;
if (onMessage) fork.process.on("message", (message) => {
if (message.type !== "nuxt:internal:dev:fork-ready") onMessage(message);
});
fork.process.send({
type: "nuxt:internal:dev:context",
listenOverrides: {
...this.options.listenOverrides,
...options.listenOverrides
},
inspect: this.options.inspect,
context
});
this.fill();
return {
pid: fork.process.pid,
serving,
promote: () => {
fork.serving = true;
},
close: () => this.closeFork(fork)
};
}
fill() {
while (this.idle.length < this.poolSize) this.idle.push(this.createFork());
}
/** `ready` rejects if the fork exits before it reports readiness. */
createFork() {
const pipeOutput = this.options.pipeOutput;
const childProc = fork(globalThis.__nuxt_cli__.devEntry, this.options.rawArgs, {
execArgv: ["--enable-source-maps"],
stdio: pipeOutput ? [
"ignore",
"pipe",
"pipe",
"ipc"
] : void 0,
env: {
...withoutDotenvVars(process.env),
__NUXT__FORK: "true",
...pipeOutput ? {
__NUXT_DEV_PIPED_TTY__: "1",
__NUXT_DEV_COLUMNS__: String(process.stdout.columns || 80),
...forcedColorEnv()
} : {}
}
});
if (pipeOutput) {
childProc.stdout?.on("data", (chunk) => writeDirectTo(process.stdout, chunk));
childProc.stderr?.on("data", (chunk) => writeDirectTo(process.stderr, chunk));
}
const pooledFork = {
process: childProc,
ready: new Promise((resolve, reject) => {
childProc.on("message", (message) => {
if (message.type === "nuxt:internal:dev:fork-ready") resolve();
});
childProc.on("error", reject);
childProc.on("close", () => reject(/* @__PURE__ */ new Error("Dev server fork exited before it finished starting.")));
}),
isReady: false,
closing: false,
serving: false
};
pooledFork.ready.then(() => {
pooledFork.isReady = true;
}, () => {});
this.forks.add(pooledFork);
childProc.on("error", () => this.forget(pooledFork));
childProc.on("close", (errorCode) => {
if (pooledFork.serving && errorCode) {
logger.error(`The dev server process (PID ${childProc.pid}) exited with code ${errorCode}.`);
process.exit(errorCode);
}
this.forget(pooledFork);
});
return pooledFork;
}
/** Ask a fork to run its `close` hooks and exit, signalling it if that fails or takes too long. */
async closeFork(fork) {
const alive = !fork.closing && fork.process.exitCode === null;
fork.closing = true;
fork.serving = false;
this.forget(fork);
if (!alive) return;
const exited = waitForExit(fork.process);
if (fork.process.connected) {
fork.process.send({ type: "nuxt:internal:dev:shutdown" }, (error) => {
if (error) fork.process.kill("SIGTERM");
});
if (await settlesWithin(exited, 1e4)) return;
debug(`Dev server fork ${fork.process.pid} did not shut down in time, terminating it`);
}
fork.process.kill("SIGTERM");
if (await settlesWithin(exited, 2e3)) return;
fork.process.kill("SIGKILL");
await settlesWithin(exited, FORCE_KILL_TIMEOUT_MS);
}
forget(fork) {
this.forks.delete(fork);
this.idle = this.idle.filter((f) => f !== fork);
}
killAll(signal) {
for (const fork of this.forks) {
fork.serving = false;
fork.process.kill(signal);
}
this.forks.clear();
this.idle = [];
}
};
/** Resolves when the fork is answering requests, including with an error page. */
function trackServing(child) {
return new Promise((resolve, reject) => {
function settle(finish) {
child.off("message", onMessage);
child.off("close", onExit);
child.off("error", onExit);
finish();
}
function onMessage(message) {
if (message.type === "nuxt:internal:dev:ready" || message.type === "nuxt:internal:dev:loading:error") settle(resolve);
}
function onExit() {
settle(() => reject(/* @__PURE__ */ new Error("Dev server fork exited before it was ready.")));
}
child.on("message", onMessage);
child.once("close", onExit);
child.once("error", onExit);
});
}
function withoutDotenvVars(env) {
const dotenvVars = globalThis.__c12_dotenv_vars__?.get(env);
if (!dotenvVars?.size) return env;
return Object.fromEntries(Object.entries(env).filter(([key]) => !dotenvVars.has(key)));
}
/** Colour settings for a piped fork, which cannot detect colour support itself. */
function forcedColorEnv() {
if (process.env.NO_COLOR || process.env.FORCE_COLOR) return {};
const depth = process.stdout.getColorDepth?.() ?? 1;
if (depth <= 1) return {};
return {
FORCE_COLOR: depth >= 24 ? "3" : depth >= 8 ? "2" : "1",
__NUXT_DEV_COLOR_DEPTH__: String(depth)
};
}
function waitForExit(child) {
return new Promise((resolve) => {
child.once("exit", () => resolve());
child.once("close", () => resolve());
});
}
/** Resolves `true` if the promise settles before the timeout, `false` otherwise. */
function settlesWithin(promise, timeout) {
return new Promise((resolve) => {
const timer = setTimeout(resolve, timeout, false);
timer.unref?.();
promise.then(() => {
clearTimeout(timer);
resolve(true);
});
});
}
// src/dev/preflight.ts
/**
* Extensions `c12` accepts for a config it parses rather than imports. Reporting
* a project as missing is worse than looking in a few more places, so the whole
* set is checked here even though only the importable ones can be loaded.
*/
const DATA_CONFIG_EXTENSIONS = [
".json",
".jsonc",
".json5",
".yaml",
".yml",
".toml"
];
const ALL_CONFIG_EXTENSIONS = [...CONFIG_EXTENSIONS, ...DATA_CONFIG_EXTENSIONS];
const CONFIG_FILENAMES = new Set(ALL_CONFIG_EXTENSIONS.map((extension) => `nuxt.config${extension}`));
/** The same configs, under both names `c12` accepts inside `.config/`. */
const CONFIG_DIR_FILENAMES = /* @__PURE__ */ new Set([...CONFIG_FILENAMES, ...ALL_CONFIG_EXTENSIONS.map((extension) => `nuxt${extension}`)]);
function containsAny(dir, filenames) {
try {
return readdirSync(dir).some((entry) => filenames.has(entry));
} catch {
return false;
}
}
/**
* Whether `dir` holds a Nuxt config in any of the places `c12` looks: alongside
* `package.json`, or in `.config/` as `nuxt.<ext>` or `nuxt.config.<ext>`.
*/
function isNuxtConfigPresent(dir) {
return containsAny(dir, CONFIG_FILENAMES) || containsAny(join(dir, ".config"), CONFIG_DIR_FILENAMES);
}
function readPackageJson(dir) {
try {
return JSON.parse(readFileSync(join(dir, "package.json"), "utf-8"));
} catch {
return;
}
}
function declaresNuxt(packageJson) {
if (!packageJson) return false;
const dependencies = {
...packageJson.dependencies,
...packageJson.devDependencies
};
return NUXT_PACKAGES.some((name) => name in dependencies);
}
/**
* Decide whether `dir` is a Nuxt project, and if not, whether one of its
* ancestors is: running `nuxt dev` one directory too deep otherwise silently
* boots an unrelated, empty app rooted at the subdirectory.
*
* An ancestor has to hold a config to count. A monorepo root commonly depends on
* `nuxt` for tooling without being an app, and offering to run it would be worse
* advice than none.
*/
function locateProject(dir) {
if (isNuxtConfigPresent(dir) || declaresNuxt(readPackageJson(dir))) return { isProject: true };
let current = dir;
let parent = dirname(current);
while (parent !== current) {
if (isNuxtConfigPresent(parent)) return {
isProject: false,
ancestor: parent
};
current = parent;
parent = dirname(parent);
}
return { isProject: false };
}
/**
* Check the things that stop `nuxt dev` from starting, before it starts.
*
* Problems that can be resolved without guessing are resolved (installing
* dependencies); the rest are reported as an error whose message contains the
* command to run. Everything interactive degrades to that error when there is
* no TTY.
*
* Returns the directory to start in, which is the one given unless the user
* asked to run in a project found above it.
*
* @throws {ActionableError} when the dev server cannot usefully be started.
*/
async function runDevPreflight(options) {
const interactive = options.interactive ?? isInteractive();
const cwd = await resolveProjectDirectory(options.cwd, interactive);
checkWritableBuildDir(cwd);
await checkDependencies(cwd, interactive);
return cwd;
}
/**
* The project directory to start in. Running one directory too deep is a typo
* rather than an intent, so the project above is offered instead of refused.
*/
async function resolveProjectDirectory(cwd, interactive) {
const location = locateProject(cwd);
if (location.isProject) return cwd;
if (location.ancestor) {
const relative = relativeTo(cwd, location.ancestor, { link: false });
if (interactive) {
logger.warn(`${styleText("cyan", cwd)} is not a Nuxt project, but ${styleText("cyan", location.ancestor)} is.`);
const answer = await withUserAttention(() => confirm({
message: `Run there instead?`,
initialValue: true
}));
restoreRawMode();
if (!isCancel(answer) && answer) return location.ancestor;
}
throw new ActionableError([
`${styleText("red", "No Nuxt project in")} ${styleText("cyan", cwd)}${styleText("red", ".")}`,
"",
`A Nuxt project was found in ${styleText("cyan", location.ancestor)}. Run it from there:`,
` ${styleText("cyan", `cd ${relative} && nuxt dev`)}`,
`or point the CLI at it: ${styleText("cyan", `nuxt dev --cwd ${relative}`)}`
].join("\n"));
}
throw new ActionableError([
`${styleText("red", "No Nuxt project in")} ${styleText("cyan", cwd)}${styleText("red", ".")}`,
"",
`There is no ${styleText("cyan", "nuxt.config")} here and no ${styleText("cyan", "nuxt")} dependency in ${styleText("cyan", "package.json")}.`,
`Create one with ${styleText("cyan", "nuxt init")}, or run ${styleText("cyan", "nuxt dev")} from an existing project.`
].join("\n"));
}
/**
* A read-only `.nuxt` otherwise surfaces as an unhandled `EACCES` rejection
* from whichever write happens to get there first, long after the banner.
*
* Only the default build directory is checked; a configured one is not known
* until the config has been read. Write access is not enough on its own: a
* directory also has to be searchable for anything inside it to be opened.
* Neither bit reflects Windows ACLs or the privileges of a root user, so on
* those the check passes and the write still fails, as it did before.
*/
function checkWritableBuildDir(cwd) {
const buildDir = join(cwd, ".nuxt");
const target = existsSync(buildDir) ? buildDir : cwd;
try {
accessSync(target, constants.W_OK | constants.X_OK);
} catch {
throw new ActionableError([
`${styleText("red", "Nuxt cannot write to")} ${styleText("cyan", target)}${styleText("red", ".")}`,
"",
`Grant write access with ${styleText("cyan", `chmod u+wx ${relativeTo(cwd, target, { link: false })}`)}, or remove the directory and try again.`
].join("\n"));
}
}
async function checkDependencies(cwd, interactive) {
if (tryResolveNuxt(cwd)) return;
const packageJson = readPackageJson(cwd);
if (!packageJson) throw new ActionableError([
`${styleText("red", "There is no readable")} ${styleText("cyan", "package.json")} ${styleText("red", "in")} ${styleText("cyan", cwd)}${styleText("red", ".")}`,
"",
`Create or repair it, then add ${styleText("cyan", "nuxt")} as a dependency.`
].join("\n"));
if (!declaresNuxt(packageJson)) {
const { name } = await detectInstaller(cwd);
throw new ActionableError([
`${styleText("red", "`nuxt` is not a dependency of this project.")}`,
"",
`Add it with ${styleText("cyan", `${name} add nuxt`)}, or run ${styleText("cyan", "nuxt init")} to start a new project.`
].join("\n"));
}
await withUserAttention(() => offerInstall(cwd, interactive));
}
async function detectInstaller(cwd) {
const { defaultPackageManager, detectPackageManager } = await import("./package-managers-oxm5w1ML.mjs").then((n) => n.s);
return await detectPackageManager(cwd) ?? defaultPackageManager;
}
async function offerInstall(cwd, interactive) {
const packageManager = await detectInstaller(cwd);
const command = `${packageManager.name} install`;
const reason = "Dependencies are not installed.";
if (!interactive) throw new ActionableError(`${reason}\nRun ${styleText("cyan", command)} first.`);
logger.warn(reason);
const answer = await confirm({
message: `Run ${styleText("cyan", command)} now?`,
initialValue: true
});
restoreRawMode();
if (isCancel(answer) || !answer) throw new ActionableError(`${styleText("red", "Cannot start the dev server without dependencies.")}\nRun ${styleText("cyan", command)} and try again.`);
const { createInstallLog, runInstall } = await import("./install-DY5MnLTf.mjs").then((n) => n.n);
const controller = new AbortController();
const installLog = createInstallLog();
const installSpinner = createSpinner({
indicator: "timer",
onCancel: () => controller.abort()
});
installSpinner.start(`Installing with ${styleText("cyan", packageManager.name)}`);
const result = await runInstall({
cwd,
packageManager,
onOutput: installLog.onOutput,
onStatus: (message) => installSpinner.message(message),
signal: controller.signal
});
if (!result.success) {
installSpinner.error(result.error ?? "Install failed");
installLog.finish(result);
throw new ActionableError(`${styleText("red", "Dependencies could not be installed.")}\nFix the error above, then run ${styleText("cyan", command)} and try again.`);
}
installSpinner.stop("Dependencies installed");
installLog.finish(result);
}
/**
* Run preflight, letting its advice reach the user and swallowing anything else,
* and return the directory the dev server should start in.
*
* A bug in a check must never be the reason `nuxt dev` refuses to start, so only
* an {@link ActionableError} propagates.
*/
async function preflight(options) {
try {
return await withDirectStdout(() => runDevPreflight(options));
} catch (error) {
if (error instanceof ActionableError) throw error;
debug("Preflight check failed:", error);
return options.cwd;
}
}
// src/commands/dev.ts
const startTime = Date.now();
const forkSupported = !isTest && (!isBun || isBunForkSupported());
const command = defineCommand({
meta: {
name: "dev",
description: "Run Nuxt development server"
},
args: {
...rootDirArgs,
...logLevelArgs,
...dotEnvArgs,
...envNameArgs,
...extendsArgs,
"inspect": {
type: "boolean",
description: "Enable the Node.js inspector for server code (`--inspect=[host:]port`), and for the CLI process on the next port"
},
"inspect-brk": {
type: "boolean",
description: "Like `--inspect`, and wait for a debugger to attach to the CLI process before loading Nuxt (`--inspect-brk=[host:]port`)"
},
"tui": {
type: "boolean",
description: "Interactive terminal UI (pinned status panel, folded logs and single-key shortcuts)",
negativeDescription: "Disable the interactive terminal UI and stream logs instead",
default: true
},
"clear": {
type: "boolean",
description: "Clear console on restart",
default: false
},
"fork": {
type: "boolean",
description: "Serve the app from a forked child process (on by default wherever the runtime supports it)",
negativeDescription: "Disable forked mode",
default: forkSupported,
alias: ["f"]
},
"port": {
type: "string",
description: "Port to listen on (default: `NUXT_PORT || NITRO_PORT || PORT || nuxtOptions.devServer.port`)",
valueHint: "port",
alias: ["p"]
},
"takeover": {
type: "boolean",
description: "Stop a dev server already running on this project and take its place",
negativeDescription: "Never stop a dev server already running on this project"
},
"strictPort": {
type: "boolean",
description: "Exit if the requested port is unavailable instead of using another one",
default: false
},
"host": {
type: "string",
description: "Host to listen on (default: `NUXT_HOST || NITRO_HOST || HOST || nuxtOptions.devServer?.host`)",
valueHint: "host",
alias: ["h"]
},
"open": {
type: "boolean",
description: "Open the URL in the browser",
alias: ["o"],
default: false
},
"open.url": {
type: "string",
description: "Path or URL to open instead of the dev server root",
valueHint: "url|path"
},
"clipboard": {
type: "boolean",
description: "Copy the URL to the clipboard",
default: false
},
"qr": {
type: "boolean",
description: "Print a QR code for the public URL (enabled by default when one is available)"
},
"tunnel": {
type: "boolean",
description: "Expose the server via a Cloudflare quick tunnel"
},
"public": {
type: "boolean",
description: "Listen on all network interfaces and allow any host to connect"
},
"publicURL": {
type: "string",
description: "Public URL to display (used for QR code and clipboard)",
valueHint: "url"
},
"https": {
type: "boolean",
description: "Enable HTTPS with a locally-trusted development certificate"
},
"https.cert": {
type: "string",
description: "Path to TLS certificate",
valueHint: "path"
},
"https.key": {
type: "string",
description: "Path to TLS key",
valueHint: "path"
},
"https.pfx": {
type: "string",
description: "Path to PKCS#12 (.p12/.pfx) keystore",
valueHint: "path"
},
"https.passphrase": {
type: "string",
description: "Passphrase for the TLS key or keystore",
valueHint: "passphrase"
},
"https.validityDays": {
type: "string",
description: "Validity in days for a generated self-signed certificate",
valueHint: "days"
},
"https.domains": {
type: "string",
description: "Domain for a generated certificate. Can be repeated, or given as a comma-separated list.",
valueHint: "domain",
multiple: true
},
...profileArgs,
"sslCert": {
type: "string",
description: "(DEPRECATED) Use `--https.cert` instead.",
hidden: true
},
"sslKey": {
type: "string",
description: "(DEPRECATED) Use `--https.key` instead.",
hidden: true
}
},
async run(ctx) {
const requestedCwd = resolveRootDir(ctx.args);
const cwd = await beforeServing(() => preflight({ cwd: requestedCwd }));
if (cwd !== requestedCwd) replaceCwdArg(ctx.rawArgs, cwd, requestedCwd);
const listenOverrides = resolveListenOverrides(ctx.args);
const buildDir = await beforeServing(() => resolveLockDir(cwd));
const takeover = await beforeServing(() => takeOverServer(buildDir, {
requestedPort: parsePort(listenOverrides.port),
takeover: ctx.args.takeover
}));
if (takeover.action === "refused") {
await teardownDevUI();
logger.error(formatTakeoverRefusal(takeover.existing, takeover.reason));
process.exit(1);
}
if (takeover.action === "start-anyway") process.env.NUXT_IGNORE_LOCK = "1";
if (takeover.action === "taken") listenOverrides.port = takeover.port;
const profiling = ctx.args.profile !== void 0;
const reusePort = ctx.args.fork && !profiling && await isReusePortSupported();
listenOverrides.reusePort = reusePort;
const inspect = resolveInspectOptions(ctx.rawArgs);
if (inspect) await openInspector(inspect);
const clearCaches = async () => {
const { clearDevCaches } = await import("./nuxt-CR-Eix_q.mjs").then((n) => n.i);
return clearDevCaches(cwd, buildDir);
};
const uiOptions = {
flag: ctx.args.tui,
inspect: !!inspect,
cwd,
startTime
};
const session = await beginDevUI(uiOptions);
const ui = !!session;
if (ui) listenOverrides.showURL = false;
const { context: shortcutContext, attach: attachServer, provide } = devShortcutContext();
provide({ clearCaches });
const startingUI = ui ? await setupDevUI(shortcutContext, {
...uiOptions,
enabled: true
}) : void 0;
handleShutdownSignals(() => shortcutContext.close());
await new Promise((resolve) => setImmediate(resolve));
const { initialize } = await import("./dev/index.mjs");
const { listener, close, reload, onRestart, onReady, onLoading, onEachReady, onLog, onRequests, onSpans, onRoutes, onBuilding, onReport, onReportClear, onFileChange } = await initialize({
cwd,
args: ctx.args,
handoverFrom: takeover.action === "taken" ? takeover.pid : void 0
}, {
data: ctx.data,
listenOverrides,
showBanner: !ui,
captureUIEvents: ui,
onProgress: session && ((snapshot) => session.reportProgress(snapshot)),
onListening: session && ((info) => session.reportListening(info))
}).catch((error) => {
session?.teardown();
throw error;
});
/** Feed the dev UI from the server running in this process. */
function attachDevUI(devUI) {
onLoading((message) => devUI.setStatus("building", message));
onEachReady(() => devUI.setStatus("ready"));
onBuilding((building) => devUI.setStatus(building ? "building" : "ready"));
onLog((log) => devUI.pushServerLog(log));
onRequests((requests) => devUI.pushRequests(requests));
onSpans((spans) => devUI.pushSpans(spans));
onReport((report) => devUI.pushReport(report));
onReportClear((id) => devUI.clearReport(id));
onRoutes((payload) => devUI.setRoutes(payload));
return devUI;
}
if (!ctx.args.fork || profiling) {
attachServer({
listener,
close,
onReady,
restart: () => reload({ type: "shortcut" })
});
attachDevUI(startingUI ?? await setupDevUI(shortcutContext, {
...uiOptions,
enabled: ui
}));
return {
listener,
close
};
}
const pool = new ForkPool({
rawArgs: ctx.rawArgs,
poolSize: resolveForkPoolSize(),
listenOverrides: {
...listenOverrides,
open: false,
openURL: void 0
},
inspect,
pipeOutput: ui
});
onReady((_address) => {
if (startTime) debug(`Dev server ready for connections in ${startupElapsedMs(startTime)}ms`);
});
onFileChange(() => {
pool.startWarming();
});
attachServer({
listener,
close: () => closeAll(),
onReady,
restart: () => restart({ type: "shortcut" })
});
const devUI = attachDevUI(startingUI ?? await setupDevUI(shortcutContext, {
...uiOptions,
enabled: ui
}));
let closeCurrent = close;
let currentPid = process.pid;
let inFlight;
let pendingReason;
function restartWithFork(reason) {
if (inFlight) {
pendingReason = { reason };
return inFlight;
}
inFlight = replaceWithFork(reason).finally(() => {
inFlight = void 0;
const pending = pendingReason;
pendingReason = void 0;
if (pending) restartWithFork(pending.reason);
});
return inFlight;
}
async function replaceWithFork(reason) {
const explanation = formatRestartReason(reason, {
rootDir: cwd,
hard: true
});
logger.info(explanation);
devUI.setStatus("restarting", explanation);
devUI.setRendering(void 0);
const handover = reusePort && !inspect;
const context = {
cwd,
args: ctx.args,
handoverFrom: handover ? currentPid : void 0
};
if (!handover) await Promise.all([closeCurrent(), inspect ? closeInspector() : void 0]);
let serving = false;
let fork;
try {
fork = await pool.getFork(context, {
listenOverrides: handover ? {
port: listener.address.port,
handover: true
} : void 0,
onMessage: (message) => {
if (message.type === "nuxt:internal:dev:log") devUI.pushServerLog(message);
else if (message.type === "nuxt:internal:dev:requests") devUI.pushRequests(message.requests);
else if (message.type === "nuxt:internal:dev:spans") devUI.pushSpans(message.spans);
else if (message.type === "nuxt:internal:dev:report") devUI.pushReport(message.report);
else if (message.type === "nuxt:internal:dev:report:clear") devUI.clearReport(message.id);
else if (message.type === "nuxt:internal:dev:routes") devUI.setRoutes(message.payload);
else if (message.type === "nuxt:internal:dev:building") devUI.setStatus(message.building ? "building" : "ready");
else if (message.type === "nuxt:internal:dev:rendering") devUI.setRendering(message.pending, message.awaiting);
else if (message.type === "nuxt:internal:dev:ready" || message.type === "nuxt:internal:dev:loading:error") {
serving = true;
if (message.type === "nuxt:internal:dev:ready" && startTime) debug(`Dev server ready for connections in ${startupElapsedMs(startTime)}ms`);
if (message.type === "nuxt:internal:dev:ready") devUI.setStatus("ready");
} else if (message.type === "nuxt:internal:dev:loading" && serving) devUI.setStatus("building");
else if (!serving) {} else if (message.type === "nuxt:internal:dev:restart") restartWithFork(message.reason);
else if (message.type === "nuxt:internal:dev:rejection") restartWithFork({
type: "error",
message: message.message
});
}
});
await fork.serving;
} catch (error) {
await fork?.close();
const detail = error instanceof Error ? error.message : String(error);
if (!handover) {
logger.error(`Could not restart the dev server: ${detail}`);
process.exit(1);
}
logger.error(`Could not restart the dev server, keeping the current one: ${detail}`);
devUI.settleRestart();
onRestart(restart);
return;
}
serving = true;
devUI.setStatus("ready");
fork.promote();
const closePrevious = handover ? closeCurrent : void 0;
closeCurrent = fork.close;
currentPid = fork.pid ?? currentPid;
await closePrevious?.();
}
async function restart(reason) {
await restartWithFork(reason);
}
onRestart(restart);
async function closeAll() {
if (closeCurrent !== close) await closeCurrent();
await close();
}
return { close: closeAll };
}
});
/** Run work that must succeed before there is a server, freeing the terminal if it does not. */
async function beforeServing(work) {
try {
return await work();
} catch (error) {
await teardownDevUI();
throw error;
}
}
function resolveForkPoolSize() {
const raw = process.env.NUXT_DEV_FORK_POOL_SIZE;
if (!raw) return;
const parsed = Number(raw);
if (!Number.isInteger(parsed) || parsed < 0) {
logger.warn(`Ignoring invalid \`NUXT_DEV_FORK_POOL_SIZE=${raw}\`; expected a non-negative integer.`);
return;
}
return parsed;
}
function parsePositiveInteger(value) {
const parsed = Number(value);
if (!value || !Number.isInteger(parsed) || parsed <= 0) {
if (value) logger.warn(`Ignoring invalid \`--https.validityDays=${value}\`; expected a positive number of days.`);
return;
}
return parsed;
}
function resolveListenOverrides(args) {
const httpsOptions = {
cert: args["https.cert"] || args.sslCert || process.env.NUXT_SSL_CERT || process.env.NITRO_SSL_CERT || void 0,
key: args["https.key"] || args.sslKey || process.env.NUXT_SSL_KEY || process.env.NITRO_SSL_KEY || void 0,
pfx: args["https.pfx"] || void 0,
passphrase: args["https.passphrase"] || void 0,
validityDays: parsePositiveInteger(args["https.validityDays"]),
domains: args["https.domains"]?.flatMap((value) => value.split(",")).map((domain) => domain.trim()).filter(Boolean)
};
const host = args.host ?? (process.env.NUXT_HOST || process.env.NITRO_HOST || process.env.HOST);
return {
port: args.port || process.env.NUXT_PORT || process.env.NITRO_PORT || process.env.PORT || void 0,
strictPort: args.strictPort,
hostname: host === true || host === "" ? "" : host || void 0,
open: args.open || !!args["open.url"],
openURL: args["open.url"] || void 0,
clipboard: args.clipboard,
qr: args.qr,
tunnel: args.tunnel,
public: args.public,
publicURL: args.publicURL,
httpsEnabled: args.https,
https: httpsOptions
};
}
function isBunForkSupported() {
const bunVersion = globalThis.Bun.version;
return satisfies(bunVersion, ">=1.2");
}
export { command as default, parsePositiveInteger, resolveListenOverrides };
Shown as plain text from the published tarball, after apm checked it against the version's checksum. Nothing in it runs on this page.