From e84f4d3d01e3493b5726e5af7acd73f66b7a8409 Mon Sep 17 00:00:00 2001 From: Alexander Akait <4567934+alexander-akait@users.noreply.github.com> Date: Thu, 12 Nov 2026 11:53:45 +0000 Subject: [PATCH] fix: close the hot transport on plugin shutdown In plugin mode stop() skips middleware.close(), so the host's watching stays the host's, but that also left the middleware's hot transport open: a WebSocket endpoint on a port of its own kept accepting clients and sending heartbeats after compiler.close(). Close it in stop(). Closes #5781 Co-authored-by: Nirmal Siddh --- .changeset/plugin-close-hot-transport.md | 5 +++ lib/Server.js | 13 ++++++ test/e2e/api-plugin.test.js | 54 ++++++++++++++++++++++++ 3 files changed, 72 insertions(+) create mode 100644 .changeset/plugin-close-hot-transport.md diff --git a/.changeset/plugin-close-hot-transport.md b/.changeset/plugin-close-hot-transport.md new file mode 100644 index 0000000000..4b766bc0e2 --- /dev/null +++ b/.changeset/plugin-close-hot-transport.md @@ -0,0 +1,5 @@ +--- +"webpack-dev-server": patch +--- + +In plugin mode, `compiler.close()` now also closes the built-in hot transport, so a WebSocket endpoint on a port of its own no longer outlives the compiler and keeps the process running. diff --git a/lib/Server.js b/lib/Server.js index 3a8ab17bad..aee4df98a6 100644 --- a/lib/Server.js +++ b/lib/Server.js @@ -4491,6 +4491,19 @@ class Server { }); }) ); + } else { + // The middleware's hot transport is still its own to close, or its + // endpoint outlives `compiler.close()`. A custom one is closed above + // already, and closing it again is harmless, as `close()` does too. + // TODO once the webpack-dev-middleware dependency includes + // webpack/webpack-dev-middleware#2507, call `close()` in plugin mode + // too: it then closes only the hot transport, without a warning. + const { context } = this.middleware; + + if (context.hot) { + context.hot.close(); + context.hot = undefined; + } } this.middleware = undefined; diff --git a/test/e2e/api-plugin.test.js b/test/e2e/api-plugin.test.js index f0bd4f56e6..ca2527256f 100644 --- a/test/e2e/api-plugin.test.js +++ b/test/e2e/api-plugin.test.js @@ -1,5 +1,6 @@ import fs from "node:fs"; import http from "node:http"; +import net from "node:net"; import os from "node:os"; import path from "node:path"; import { afterEach, beforeEach, describe, it } from "node:test"; @@ -134,6 +135,59 @@ describe("API (plugin)", () => { stopSpy.mockRestore(); }); + it("should close a built-in WebSocket endpoint of its own port via compiler.close()", async () => { + const compiler = webpack(config); + const server = new Server({ + port: portA, + webSocketServer: { type: "ws", options: { port: portB } }, + }); + + server.apply(compiler); + + await compile(compiler, portA); + + const client = new WebSocket(`ws://127.0.0.1:${portB}/ws`, { + headers: { + host: `127.0.0.1:${portA}`, + origin: `http://127.0.0.1:${portA}`, + }, + }); + const clientClosed = new Promise((resolve) => { + client.once("close", () => resolve(true)); + }); + + await new Promise((resolve, reject) => { + client.once("open", resolve); + client.once("error", reject); + }); + + await new Promise((resolve) => { + compiler.close(resolve); + }); + + const closed = await Promise.race([ + clientClosed, + new Promise((resolve) => { + setTimeout(() => resolve(false), 2000); + }), + ]); + + client.terminate(); + expect(closed).toBe(true); + + const refused = await new Promise((resolve) => { + const socket = net.connect({ host: "127.0.0.1", port: portB }); + + socket.once("connect", () => { + socket.destroy(); + resolve(false); + }); + socket.once("error", (error) => resolve(error.code === "ECONNREFUSED")); + }); + + expect(refused).toBe(true); + }); + it("should tear down without error when the compiler is closed", async () => { // In plugin mode the host owns `watching`, so `stop()` must not call // `middleware.close()` — otherwise `compiler.close` surfaces a TypeError.