Skip to content

Formerly KrillinAI, VideoTranslation and Dubbing Tool for 120+ Languages. Open-source AI workspace for creators, powered by Codex. Video downloader, video translation, create videos, images, audios, and edits with Agents in one place. For your Social Media like YouTube, TikTok, Instagram, etc.

fix(e2e): await detached runtime shutdown before cleanup

Leggett0b99989f8068
diff --git a/apps/web/e2e/fixtures/process-cleanup.ts b/apps/web/e2e/fixtures/process-cleanup.ts
new file mode 100644
index 00000000..3701a71c
--- /dev/null
+++ b/apps/web/e2e/fixtures/process-cleanup.ts
@@ -0,0 +1,84 @@
+import { execFileSync } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { setTimeout as delay } from 'node:timers/promises';
+
+export function readRuntimePid(dataDir: string): number | undefined {
+ let value: string;
+ try {
+ value = readFileSync(join(dataDir, 'opencreator-runtime.lock'), 'utf8').trim();
+ } catch (error) {
+ if ((error as NodeJS.ErrnoException).code === 'ENOENT') return undefined;
+ throw error;
+ }
+ const pid = /^\d+$/.test(value) ? Number(value) : NaN;
+ assertSafePid(pid);
+ return pid;
+}
+
+export async function stopRecordedProcess(
+ pid: number,
+ options: { processGroup?: boolean; force?: boolean } = {}
+): Promise<void> {
+ assertSafePid(pid);
+ const processGroup = options.processGroup === true && process.platform !== 'win32';
+ if (!isRunning(pid, processGroup)) return;
+ signalProcess(pid, processGroup, options.force === true ? 'SIGKILL' : 'SIGTERM');
+ if (await waitForExit(pid, processGroup)) return;
+ signalProcess(pid, processGroup, 'SIGKILL');
+ if (!await waitForExit(pid, processGroup)) {
+ throw new Error(`E2E process ${pid} did not stop; refusing to remove its data directory`);
+ }
+}
+
+function assertSafePid(pid: number): void {
+ if (!Number.isSafeInteger(pid) || pid <= 1 || pid === process.pid) {
+ throw new Error(`Invalid E2E process PID: ${pid}`);
+ }
+}
+
+function signalProcess(pid: number, processGroup: boolean, signal: NodeJS.Signals): void {
+ if (process.platform === 'win32') {
+ try {
+ execFileSync('taskkill.exe', ['/PID', String(pid), '/T', '/F'], {
+ stdio: 'ignore',
+ windowsHide: true
+ });
+ } catch (error) {
+ if (isRunning(pid, false)) throw error;
+ }
+ return;
+ }
+ try {
+ process.kill(processGroup ? -pid : pid, signal);
+ } catch (error) {
+ if ((error as NodeJS.ErrnoException).code !== 'ESRCH') throw error;
+ }
+}
+
+function isRunning(pid: number, processGroup: boolean): boolean {
+ if (process.platform === 'win32') {
+ try {
+ process.kill(pid, 0);
+ return true;
+ } catch (error) {
+ if ((error as NodeJS.ErrnoException).code === 'ESRCH') return false;
+ throw error;
+ }
+ }
+ // Orphaned zombies cannot write files and may await reaping by the CI host.
+ const processes = execFileSync('ps', ['-eo', 'pid=,pgid=,stat='], { encoding: 'utf8' });
+ return processes.split('\n').some(line => {
+ const [processId, groupId, status = ''] = line.trim().split(/\s+/);
+ return Number(processGroup ? groupId : processId) === pid && !status.startsWith('Z');
+ });
+}
+
+async function waitForExit(pid: number, processGroup: boolean): Promise<boolean> {
+ const deadline = Date.now() + 3_000;
+ while (isRunning(pid, processGroup)) {
+ if (Date.now() >= deadline) return false;
+ await delay(100);
+ }
+ return true;
+}
diff --git a/apps/web/e2e/fixtures/runtime.ts b/apps/web/e2e/fixtures/runtime.ts
index 7ece5273..f9406350 100644
--- a/apps/web/e2e/fixtures/runtime.ts
+++ b/apps/web/e2e/fixtures/runtime.ts
@@ -16,6 +16,7 @@ import { tmpdir } from 'node:os';
import { join, resolve } from 'node:path';
import { setTimeout as delay } from 'node:timers/promises';
import { fileURLToPath } from 'node:url';
+import { readRuntimePid, stopRecordedProcess } from './process-cleanup.js';
export type FakeCodexInvocation = {
threadId?: string;
@@ -260,8 +261,7 @@ export const test = base.extend<TestFixtures>({
projectId: project.project.id,
ordinaryThreadId: ordinary.thread.id,
async restart(options = {}) {
- await stopProcessTree(child);
- terminateRecordedFakeCodexProcesses(stateDir);
+ await stopFixtureRuntime(child, dataDir, stateDir);
presetCatalogRoot = options.presetCatalogRoot ?? presetCatalogRoot;
serverLog += '\n[opencreator-e2e] restarting Vite and Daemon\n';
child = startRuntime();
@@ -410,8 +410,7 @@ export const test = base.extend<TestFixtures>({
contentType: 'text/plain'
});
}
- await stopProcessTree(child);
- terminateRecordedFakeCodexProcesses(stateDir);
+ await stopFixtureRuntime(child, dataDir, stateDir);
if (process.env.OPENCREATOR_E2E_KEEP_TEMP !== '1') {
rmSync(rootDir, {
recursive: true,
@@ -542,26 +541,31 @@ function prepareDaemonDevelopment(packageManagerScript: string | undefined): voi
daemonDevelopmentPrepared = true;
}
-function terminateRecordedFakeCodexProcesses(stateDir: string): void {
+async function stopFixtureRuntime(
+ child: ChildProcess,
+ dataDir: string,
+ stateDir: string
+): Promise<void> {
+ // Capture the detached Daemon before Vite shutdown can remove its lock.
+ const daemonPid = readRuntimePid(dataDir);
+ if (child.pid !== undefined) {
+ await stopRecordedProcess(child.pid, { processGroup: true });
+ }
+ if (daemonPid !== undefined) {
+ await stopRecordedProcess(daemonPid, { processGroup: true });
+ }
+ await terminateRecordedFakeCodexProcesses(stateDir);
+}
+
+async function terminateRecordedFakeCodexProcesses(stateDir: string): Promise<void> {
const path = join(stateDir, 'app-server-pids.txt');
if (!existsSync(path)) return;
const pids = [...new Set(readFileSync(path, 'utf8')
.split(/\r?\n/)
.map(value => Number(value))
- .filter(value => Number.isInteger(value) && value > 0))].reverse();
+ .filter(value => Number.isSafeInteger(value) && value > 1 && value !== process.pid))].reverse();
for (const pid of pids) {
- try {
- if (process.platform === 'win32') {
- execFileSync('taskkill.exe', ['/PID', String(pid), '/T', '/F'], {
- stdio: 'ignore',
- windowsHide: true
- });
- } else {
- process.kill(pid, 'SIGKILL');
- }
- } catch {
- // The process may already have exited with the Daemon tree.
- }
+ await stopRecordedProcess(pid, { force: true });
}
}
@@ -587,30 +591,3 @@ async function waitForRuntime(
}
throw new Error(`Runtime did not become ready: ${latestError}\n${readLog()}`);
}
-
-async function stopProcessTree(child: ChildProcess): Promise<void> {
- if (child.exitCode !== null || child.pid === undefined) return;
- const exited = new Promise<void>(resolveExit => {
- child.once('exit', () => resolveExit());
- });
- try {
- if (process.platform === 'win32') {
- execFileSync('taskkill.exe', ['/PID', String(child.pid), '/T', '/F'], {
- stdio: 'ignore',
- windowsHide: true
- });
- } else {
- process.kill(-child.pid, 'SIGTERM');
- }
- } catch {
- child.kill('SIGTERM');
- }
- await Promise.race([exited, delay(3_000)]);
- if (child.exitCode !== null) return;
- try {
- process.kill(-child.pid, 'SIGKILL');
- } catch {
- child.kill('SIGKILL');
- }
- await Promise.race([exited, delay(3_000)]);
-}
diff --git a/apps/web/src/test/process-cleanup.test.ts b/apps/web/src/test/process-cleanup.test.ts
new file mode 100644
index 00000000..dd3f984f
--- /dev/null
+++ b/apps/web/src/test/process-cleanup.test.ts
@@ -0,0 +1,91 @@
+import { spawn, type ChildProcess } from 'node:child_process';
+import { once } from 'node:events';
+import { existsSync, mkdtempSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterEach, describe, expect, it } from 'vitest';
+import { readRuntimePid, stopRecordedProcess } from '../../e2e/fixtures/process-cleanup.js';
+
+const directories: string[] = [];
+const children: ChildProcess[] = [];
+
+afterEach(async () => {
+ for (const child of children.splice(0)) {
+ if (child.pid !== undefined) {
+ await stopRecordedProcess(child.pid, { processGroup: true, force: true });
+ }
+ }
+ for (const path of directories.splice(0)) rmSync(path, { recursive: true, force: true });
+});
+
+function createDataDir(): string {
+ const path = mkdtempSync(join(tmpdir(), 'opencreator-cleanup-test-'));
+ directories.push(path);
+ return path;
+}
+
+describe('E2E runtime process cleanup', () => {
+ it('stops a detached writer before removing its runtime directory', async () => {
+ const rootDir = createDataDir();
+ const dataDir = join(rootDir, 'runtime');
+ mkdirSync(dataDir);
+ const child = spawn(process.execPath, ['--input-type=module', '-e', `
+ import { writeFileSync } from 'node:fs';
+ import { join } from 'node:path';
+ const dataDir = process.argv[1];
+ writeFileSync(join(dataDir, 'opencreator-runtime.lock'), String(process.pid));
+ process.on('SIGTERM', () => {});
+ setInterval(() => writeFileSync(join(dataDir, 'state.json'), String(Date.now())), 5);
+ console.log('ready');
+ `, dataDir], { detached: process.platform !== 'win32', stdio: ['ignore', 'pipe', 'pipe'] });
+ children.push(child);
+ await once(child.stdout!, 'data');
+
+ const daemonPid = readRuntimePid(dataDir);
+ expect(daemonPid).toBe(child.pid);
+ const exited = once(child, 'exit');
+ await stopRecordedProcess(daemonPid!, { processGroup: true });
+ await exited;
+ rmSync(rootDir, { recursive: true, force: true });
+ expect(existsSync(rootDir)).toBe(false);
+ }, 10_000);
+
+ it('stops remaining group members after their parent exits', async () => {
+ if (process.platform === 'win32') return;
+ const dataDir = createDataDir();
+ const writer = `
+ const fs = require('node:fs');
+ setInterval(() => fs.writeFileSync(process.argv[1] + '/state.json', String(Date.now())), 5);
+ console.log('ready');
+ `;
+ const child = spawn(process.execPath, ['-e', `
+ const { spawn } = require('node:child_process');
+ const child = spawn(process.execPath, ['-e', process.argv[1], process.argv[2]], {
+ stdio: ['ignore', 'pipe', 'ignore']
+ });
+ child.stdout.once('data', () => {
+ console.log('ready');
+ child.unref();
+ process.exit(0);
+ });
+ `, writer, dataDir], { detached: true, stdio: ['ignore', 'pipe', 'pipe'] });
+ children.push(child);
+ const exited = once(child, 'exit');
+ await once(child.stdout!, 'data');
+ await exited;
+
+ await stopRecordedProcess(child.pid!, { processGroup: true });
+ rmSync(dataDir, { recursive: true, force: true });
+ expect(existsSync(dataDir)).toBe(false);
+ });
+
+ it('allows a missing runtime lock and rejects unsafe lock PIDs', async () => {
+ const dataDir = createDataDir();
+ expect(readRuntimePid(dataDir)).toBeUndefined();
+ for (const value of ['0', '1', '-2', String(process.pid), '123junk', '9007199254740992']) {
+ writeFileSync(join(dataDir, 'opencreator-runtime.lock'), value);
+ expect(() => readRuntimePid(dataDir)).toThrow('Invalid E2E process PID');
+ }
+ await expect(stopRecordedProcess(process.pid)).rejects.toThrow('Invalid E2E process PID');
+ });
+});