Skip to content

Open source website builder and Webflow alternative. Webstudio is an advanced visual builder that connects to any headless CMS, supports all CSS properties, and can be hosted anywhere, including with us.

fix: Stop managed preview process groups (#6037)

Oleg Isonen6d2389ee5416
diff --git a/packages/cli/src/preview-server.test.ts b/packages/cli/src/preview-server.test.ts
index 9cc00092b0..d9c8ee1d02 100644
--- a/packages/cli/src/preview-server.test.ts
+++ b/packages/cli/src/preview-server.test.ts
@@ -35,6 +35,13 @@ const createDependencies = (
readFile: vi.fn(async () => "") as never,
writeFile: vi.fn(async () => undefined) as never,
sleep: vi.fn(async () => undefined),
+ killProcess: vi.fn(() => true),
+ parentProcess: {
+ pid: 456,
+ once: vi.fn(),
+ off: vi.fn(),
+ kill: vi.fn(() => true),
+ },
nodeExecPath: "/usr/bin/node",
npmExecPath: undefined,
platform: "linux",
@@ -302,6 +309,7 @@ test("preview controller builds once and reuses a running server", async () => {
expect(spawn).toHaveBeenCalledTimes(2);
expect(spawn).toHaveBeenLastCalledWith("npm", ["run", "start"], {
cwd: "/tmp/preview",
+ detached: true,
stdio: ["ignore", "pipe", "pipe"],
env: expect.objectContaining({
HOST: "127.0.0.1",
@@ -453,6 +461,7 @@ test("preview controller stops the running server", async () => {
const controller = createPreviewController(
{ host: "127.0.0.1", port: 5173, cwd: "/tmp/preview" },
createDependencies({
+ platform: "win32",
spawn: vi
.fn()
.mockReturnValueOnce(buildProcess)
@@ -491,6 +500,78 @@ test("preview controller stops the running server", async () => {
});
});
+test("preview controller stops the entire POSIX preview process group", async () => {
+ const process = createPreviewProcess();
+ const killProcess = vi.fn(() => true);
+ const controller = createPreviewController(
+ {
+ host: "127.0.0.1",
+ port: 5173,
+ cwd: "/tmp/preview",
+ mode: "iterative",
+ },
+ createDependencies({
+ spawn: vi.fn(() => process) as never,
+ killProcess,
+ })
+ );
+ let exitListener: (() => void) | undefined;
+ vi.mocked(
+ process.once as (event: string, callback: unknown) => unknown
+ ).mockImplementation((event, callback) => {
+ if (event === "exit" && typeof callback === "function") {
+ exitListener = callback as () => void;
+ }
+ return process;
+ });
+ killProcess.mockImplementation(() => {
+ exitListener?.();
+ return true;
+ });
+
+ await controller.start();
+ await controller.stop();
+
+ expect(killProcess).toHaveBeenCalledWith(-123, "SIGTERM");
+ expect(process.kill).not.toHaveBeenCalled();
+});
+
+test("preview controller stops its process group before propagating termination", async () => {
+ const process = createPreviewProcess();
+ const killProcess = vi.fn(() => true);
+ const parentProcess = {
+ pid: 456,
+ once: vi.fn(),
+ off: vi.fn(),
+ kill: vi.fn(() => true),
+ };
+ const controller = createPreviewController(
+ {
+ host: "127.0.0.1",
+ port: 5173,
+ cwd: "/tmp/preview",
+ mode: "iterative",
+ },
+ createDependencies({
+ spawn: vi.fn(() => process) as never,
+ killProcess,
+ parentProcess,
+ })
+ );
+
+ await controller.start();
+ const signalHandler = vi
+ .mocked(parentProcess.once)
+ .mock.calls.find(([signal]) => signal === "SIGTERM")?.[1] as
+ | (() => void)
+ | undefined;
+ signalHandler?.();
+
+ expect(killProcess).toHaveBeenCalledWith(-123, "SIGTERM");
+ expect(parentProcess.kill).toHaveBeenCalledWith(456, "SIGTERM");
+ expect(controller.status().running).toBe(false);
+});
+
test("preview controller reuses custom running options when start has no options", async () => {
const process = createPreviewProcess();
const buildProcess = createPreviewProcess();
@@ -530,12 +611,13 @@ test("preview controller can restart a running server after rebuilding", async (
.mockReturnValueOnce(firstProcess)
.mockReturnValueOnce(secondBuildProcess)
.mockReturnValueOnce(secondProcess);
+ const killProcess = vi.fn(() => true);
resolveProcessExit(firstBuildProcess);
resolveProcessExit(secondBuildProcess);
const controller = createPreviewController(
{ host: "127.0.0.1", port: 5173, cwd: "/tmp/preview" },
- createDependencies({ spawn: spawn as never })
+ createDependencies({ spawn: spawn as never, killProcess })
);
await expect(controller.start()).resolves.toEqual({
@@ -552,7 +634,7 @@ test("preview controller can restart a running server after rebuilding", async (
mode: "production",
});
- expect(firstProcess.kill).toHaveBeenCalledOnce();
+ expect(killProcess).toHaveBeenCalledWith(-123, "SIGTERM");
expect(spawn).toHaveBeenCalledTimes(4);
});
@@ -579,7 +661,10 @@ test("ignores a delayed exit from a previously owned preview server", async () =
cwd: "/tmp/preview",
mode: "iterative",
},
- createDependencies({ spawn: spawn as never })
+ createDependencies({
+ spawn: spawn as never,
+ killProcess: vi.fn(() => false),
+ })
);
await controller.start();
diff --git a/packages/cli/src/preview-server.ts b/packages/cli/src/preview-server.ts
index 55367caef2..28e7072176 100644
--- a/packages/cli/src/preview-server.ts
+++ b/packages/cli/src/preview-server.ts
@@ -26,6 +26,13 @@ export type PreviewServerResult = {
export type PreviewServerDependencies = {
spawn: typeof spawn;
+ killProcess: (pid: number, signal: NodeJS.Signals) => boolean;
+ parentProcess: {
+ pid: number;
+ once: (signal: NodeJS.Signals, handler: () => void) => unknown;
+ off: (signal: NodeJS.Signals, handler: () => void) => unknown;
+ kill: (pid: number, signal: NodeJS.Signals) => boolean;
+ };
fetch: typeof fetch;
cp: typeof cp;
mkdir: typeof mkdir;
@@ -40,6 +47,8 @@ export type PreviewServerDependencies = {
export const defaultPreviewServerDependencies: PreviewServerDependencies = {
spawn,
+ killProcess: process.kill,
+ parentProcess: process,
fetch,
cp,
mkdir,
@@ -218,7 +227,10 @@ export const materializePreviewAssets = async (
};
export const startPreviewServer = (
- options: PreviewServerOptions & { stdio?: StdioOptions },
+ options: PreviewServerOptions & {
+ stdio?: StdioOptions;
+ detached?: boolean;
+ },
dependencies = defaultPreviewServerDependencies
): PreviewServerResult => {
const invocation = getNpmInvocation(
@@ -230,6 +242,7 @@ export const startPreviewServer = (
invocation.args,
{
cwd: options.cwd,
+ ...(options.detached === undefined ? {} : { detached: options.detached }),
stdio: options.stdio ?? "inherit",
env: getPreviewEnv(options.cwd, {
...processEnv(),
@@ -251,6 +264,24 @@ export const startPreviewServer = (
};
};
+const killPreviewProcess = (
+ previewProcess: ChildProcess,
+ signal: NodeJS.Signals,
+ dependencies: PreviewServerDependencies
+) => {
+ if (dependencies.platform !== "win32" && previewProcess.pid !== undefined) {
+ try {
+ return dependencies.killProcess(-previewProcess.pid, signal);
+ } catch (error) {
+ if (error instanceof Error && "code" in error && error.code === "ESRCH") {
+ return false;
+ }
+ throw error;
+ }
+ }
+ return previewProcess.kill(signal);
+};
+
export const waitForPreviewExit = async (process: ChildProcess) => {
const code = await new Promise<number | null>((resolve, reject) => {
process.once("error", reject);
@@ -479,6 +510,43 @@ export const createPreviewController = (
let currentOptions = defaults;
let currentCwd = defaults.cwd;
let serverOutput = "";
+ const terminationSignals = ["SIGHUP", "SIGINT", "SIGTERM"] as const;
+ let isTerminating = false;
+ const terminationHandlers = new Map<NodeJS.Signals, () => void>();
+ const removeTerminationHandlers = () => {
+ for (const [signal, handler] of terminationHandlers) {
+ dependencies.parentProcess.off(signal, handler);
+ }
+ terminationHandlers.clear();
+ };
+ const installTerminationHandlers = () => {
+ if (terminationHandlers.size > 0) {
+ return;
+ }
+ for (const signal of terminationSignals) {
+ const handler = () => {
+ if (isTerminating) {
+ return;
+ }
+ isTerminating = true;
+ const activeServer = server;
+ server = undefined;
+ removeTerminationHandlers();
+ try {
+ if (activeServer !== undefined) {
+ killPreviewProcess(activeServer.process, "SIGTERM", dependencies);
+ }
+ } finally {
+ dependencies.parentProcess.kill(
+ dependencies.parentProcess.pid,
+ signal
+ );
+ }
+ };
+ terminationHandlers.set(signal, handler);
+ dependencies.parentProcess.once(signal, handler);
+ }
+ };
const appendServerOutput = (chunk: unknown) => {
serverOutput = `${serverOutput}${String(chunk)}`.slice(-4000);
};
@@ -532,6 +600,7 @@ export const createPreviewController = (
}
const process = server.process;
server = undefined;
+ removeTerminationHandlers();
if (
process.killed ||
process.exitCode !== null ||
@@ -542,7 +611,7 @@ export const createPreviewController = (
await new Promise<void>((resolve, reject) => {
process.once("error", reject);
process.once("exit", () => resolve());
- if (process.kill() === false) {
+ if (killPreviewProcess(process, "SIGTERM", dependencies) === false) {
resolve();
}
});
@@ -592,16 +661,19 @@ export const createPreviewController = (
const startedServer = startPreviewServer(
{
...nextOptions,
+ detached: dependencies.platform !== "win32",
stdio: ["ignore", "pipe", "pipe"],
},
dependencies
);
server = startedServer;
+ installTerminationHandlers();
startedServer.process.stdout?.on("data", appendServerOutput);
startedServer.process.stderr?.on("data", appendServerOutput);
startedServer.process.once("exit", () => {
if (server === startedServer) {
server = undefined;
+ removeTerminationHandlers();
}
});
return getStatus();