single-file-cli 2.7.2 → 2.9.0

package/lib/bidi.js

@@ -0,0 +1,141 @@
+/*
+ * Copyright 2010-2026 Gildas Lormeau
+ * contact : gildas.lormeau <at> gmail.com
+ *
+ * This file is part of SingleFile.
+ *
+ *   The code in this file is free software: you can redistribute it and/or
+ *   modify it under the terms of the GNU Affero General Public License
+ *   (GNU AGPL) as published by the Free Software Foundation, either version 3
+ *   of the License, or (at your option) any later version.
+ *
+ *   The code in this file is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero
+ *   General Public License for more details.
+ *
+ *   As additional permission under GNU AGPL version 3 section 7, you may
+ *   distribute UNMODIFIED VERSIONS OF THIS file without the copy of the GNU
+ *   AGPL normally required by section 4, provided you include this license
+ *   notice and a URL through which recipients can access the Corresponding
+ *   Source.
+ */
+
+/* global WebSocket, setTimeout, clearTimeout */
+
+const SUCCESS_TYPE = "success";
+const EVENT_TYPE = "event";
+const OPEN_ATTEMPT_TIMEOUT = 500;
+const OPEN_RETRY_DELAY = 200;
+const DEFAULT_COMMAND_TIMEOUT = 30000;
+
+export { connect };
+
+async function connect(url, { timeout, commandTimeout = DEFAULT_COMMAND_TIMEOUT, isClosed = () => false } = {}) {
+	const socket = await openSocket(url, timeout, isClosed);
+	const pendingCommands = new Map();
+	const listeners = new Map();
+	let nextId = 1, closeError;
+	socket.addEventListener("close", () => {
+		closeError = new Error("The BiDi connection was closed");
+		pendingCommands.forEach(({ reject }) => reject(closeError));
+		pendingCommands.clear();
+	});
+	socket.addEventListener("message", event => {
+		const message = JSON.parse(event.data);
+		if (message.id !== undefined && pendingCommands.has(message.id)) {
+			const { resolve, reject } = pendingCommands.get(message.id);
+			pendingCommands.delete(message.id);
+			if (message.type == SUCCESS_TYPE) {
+				resolve(message.result);
+			} else {
+				const error = new Error(message.message);
+				error.code = message.error;
+				reject(error);
+			}
+		} else if (message.type == EVENT_TYPE) {
+			const eventListeners = listeners.get(message.method);
+			if (eventListeners) {
+				Array.from(eventListeners).forEach(listener => listener(message.params));
+			}
+		}
+	});
+	return { send, addEventListener, removeEventListener, close };
+
+	function send(method, params = {}, { timeout = commandTimeout } = {}) {
+		if (closeError) {
+			return Promise.reject(closeError);
+		}
+		const id = nextId++;
+		socket.send(JSON.stringify({ id, method, params }));
+		return new Promise((resolve, reject) => {
+			let timeoutId;
+			if (timeout) {
+				timeoutId = setTimeout(() => {
+					pendingCommands.delete(id);
+					reject(new Error(method + " timed out after " + timeout + " ms"));
+				}, timeout);
+			}
+			pendingCommands.set(id, {
+				resolve: value => {
+					clearTimeout(timeoutId);
+					resolve(value);
+				},
+				reject: error => {
+					clearTimeout(timeoutId);
+					reject(error);
+				}
+			});
+		});
+	}
+
+	function addEventListener(eventName, listener) {
+		if (!listeners.has(eventName)) {
+			listeners.set(eventName, new Set());
+		}
+		listeners.get(eventName).add(listener);
+	}
+
+	function removeEventListener(eventName, listener) {
+		const eventListeners = listeners.get(eventName);
+		if (eventListeners) {
+			eventListeners.delete(listener);
+		}
+	}
+
+	function close() {
+		try {
+			socket.close();
+		} catch {
+			// ignored
+		}
+	}
+}
+
+async function openSocket(url, timeout, isClosed) {
+	const timeoutTime = Date.now() + timeout;
+	while (Date.now() < timeoutTime && !isClosed()) {
+		const socket = new WebSocket(url);
+		const opened = await new Promise(resolve => {
+			const timeoutId = setTimeout(() => resolve(false), OPEN_ATTEMPT_TIMEOUT);
+			socket.addEventListener("open", () => {
+				clearTimeout(timeoutId);
+				resolve(true);
+			});
+			socket.addEventListener("error", () => {
+				clearTimeout(timeoutId);
+				resolve(false);
+			});
+		});
+		if (opened) {
+			return socket;
+		}
+		try {
+			socket.close();
+		} catch {
+			// ignored
+		}
+		await new Promise(resolve => setTimeout(resolve, OPEN_RETRY_DELAY));
+	}
+	throw new Error(isClosed() ? "The browser exited unexpectedly" : "The browser is not responding");
+}

package/lib/browser.js

@@ -1,38 +1,33 @@
 /*
  * Copyright 2010-2024 Gildas Lormeau
  * contact : gildas.lormeau <at> gmail.com
- * 
+ *
  * This file is part of SingleFile.
  *
- *   The code in this file is free software: you can redistribute it and/or 
- *   modify it under the terms of the GNU Affero General Public License 
+ *   The code in this file is free software: you can redistribute it and/or
+ *   modify it under the terms of the GNU Affero General Public License
  *   (GNU AGPL) as published by the Free Software Foundation, either version 3
  *   of the License, or (at your option) any later version.
- * 
- *   The code in this file is distributed in the hope that it will be useful, 
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of 
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero 
+ *
+ *   The code in this file is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero
  *   General Public License for more details.
  *
- *   As additional permission under GNU AGPL version 3 section 7, you may 
- *   distribute UNMODIFIED VERSIONS OF THIS file without the copy of the GNU 
- *   AGPL normally required by section 4, provided you include this license 
- *   notice and a URL through which recipients can access the Corresponding 
+ *   As additional permission under GNU AGPL version 3 section 7, you may
+ *   distribute UNMODIFIED VERSIONS OF THIS file without the copy of the GNU
+ *   AGPL normally required by section 4, provided you include this license
+ *   notice and a URL through which recipients can access the Corresponding
  *   Source.
  */
 
-/* global fetch, setTimeout, WebSocket */
+/* global fetch */
 
-import { BROWSER_PATHS, BROWSER_ARGS } from "./constants.js";
 import { Deno, path } from "./deno-polyfill.js";
 
 const NULL_STD_CONFIG = "null";
 const DEBUG_PORT_MIN = 9222;
 const DEBUG_PORT_RANGE = 256;
-const READY_TIMEOUT = 30000;
-const READY_RETRY_DELAY = 250;
-const CLOSE_TIMEOUT = 15000;
-const LOCALHOST = "http://localhost:";
 const PROFILE_LOCK_ENTRY_PREFIX = "Singleton";
 const PROFILE_IGNORED_ENTRY_NAMES = [
 	"AutofillAiModelCache",
@@ -53,13 +48,8 @@ const PROFILE_IGNORED_ENTRY_NAMES = [
 	"optimization_guide_hint_cache_store",
 	"optimization_guide_model_store"
 ];
-const PROFILE_INCOMPATIBLE_ARGS = [
-	"--no-startup-window",
-	"--bwsi",
-	"--deny-permission-prompts"
-];
 
-const { build, makeTempDir, readDir, copyFile, mkdir, Command, errors, remove, stat } = Deno;
+const { build, readDir, copyFile, mkdir, Command, errors, remove, stat } = Deno;
 const WATCHDOG_SHELL = "/bin/sh";
 const WATCHDOG_SCRIPT = [
 	"trap 'kill -TERM $browser 2>/dev/null' TERM INT",
@@ -77,116 +67,7 @@ const WATCHDOG_SCRIPT = [
 	"wait $browser 2>/dev/null"
 ].join("\n");
 const { join } = path;
-let child, profilePath, childExited, keepProfilePath, browserDebugPort;
-export { launchBrowser, createBrowserProfile, getBrowserOptions, copyProfile, pruneProfile, closeBrowser, browserExited };
-
-function getBrowserOptions(options) {
-	return {
-		args: options.browserArgs,
-		headless: options.browserHeadless,
-		executablePath: options.browserExecutablePath,
-		debug: options.browserDebug,
-		singleProcess: options.browserSingleProcess,
-		width: options.browserWidth,
-		height: options.browserHeight,
-		userAgent: options.userAgent,
-		httpProxyServer: options.httpProxyServer,
-		profile: options.browserProfile
-	};
-}
-
-async function createBrowserProfile(options = {}) {
-	await mkdir(options.profile, { recursive: true });
-	await launchBrowser(Object.assign({}, options, { headless: false, persistProfile: true }));
-	if (child !== undefined) {
-		await child.status;
-	}
-	await closeBrowser();
-}
-
-async function launchBrowser(options = {}, indexPath = 0) {
-	const executablePath = options.executablePath || BROWSER_PATHS[build.os][indexPath];
-	let args = Array.from(BROWSER_ARGS);
-	const debugPort = await getDebugPort();
-	browserDebugPort = debugPort;
-	args.push("--remote-debugging-port=" + debugPort);
-	keepProfilePath = Boolean(options.persistProfile);
-	if (keepProfilePath) {
-		profilePath = options.profile;
-		args = args.filter(arg => !PROFILE_INCOMPATIBLE_ARGS.includes(arg));
-	} else {
-		profilePath = await makeTempDir();
-		if (options.profile) {
-			await copyProfile(options.profile, profilePath);
-		}
-	}
-	if (options.headless && !options.debug) {
-		args.push("--headless");
-	} else {
-		args.push("--start-maximized");
-	}
-	if (options.debug) {
-		args.push("--auto-open-devtools-for-tabs");
-	}
-	if (options.width && options.height) {
-		args.push("--window-size=" + options.width + "," + options.height);
-	}
-	if (options.userAgent) {
-		args.push("--user-agent=" + options.userAgent);
-	}
-	if (options.httpProxyServer) {
-		args.push("--proxy-server=" + options.httpProxyServer);
-	}
-	args.push("--user-data-dir=" + profilePath);
-	if (options.singleProcess) {
-		args.push("--single-process");
-	}
-	if (options.args) {
-		const argNames = options.args.map(arg => arg.split("=")[0]);
-		args = args.filter(arg => !argNames.includes(arg.split("=")[0]));
-		args.push(...options.args);
-	}
-	if (args.includes("--headless=new") ||
-		args.includes("--auto-open-devtools-for-tabs") ||
-		args.includes("--start-maximized") ||
-		!args.includes("--headless")) {
-		args.push("--disable-site-isolation-trials");
-	}
-	if (options.startUrl) {
-		args.push(options.startUrl);
-	}
-	try {
-		child = await spawnBrowser(executablePath, args, keepProfilePath ? "" : profilePath);
-	} catch (error) {
-		if (!keepProfilePath) {
-			await remove(profilePath, { recursive: true }).catch(() => { });
-		}
-		profilePath = undefined;
-		if (error instanceof errors.NotFound) {
-			if (!options.executablePath && indexPath + 1 < BROWSER_PATHS[build.os].length) {
-				return launchBrowser(options, indexPath + 1);
-			}
-			throw new Error(options.executablePath ?
-				`The browser executable was not found at ${JSON.stringify(executablePath)}` :
-				"The browser executable was not found, use --browser-executable-path to set its location");
-		}
-		throw error;
-	}
-	child.ref();
-	childExited = false;
-	child.status.then(() => childExited = true);
-	try {
-		await waitUntilReady(debugPort);
-	} catch (error) {
-		await closeBrowser();
-		if (options.singleProcess) {
-			console.warn("Warning: the browser exited when using --browser-single-process, retrying without it"); // eslint-disable-line no-console
-			return launchBrowser(Object.assign({}, options, { singleProcess: false }), indexPath);
-		}
-		throw error;
-	}
-	return debugPort;
-}
+export { spawnBrowser, getDebugPort, copyProfile, pruneProfile, removeProfileLockEntries };
 
 async function spawnBrowser(executablePath, args, temporaryProfilePath) {
 	if (build.os == "windows") {
@@ -200,32 +81,6 @@ async function spawnBrowser(executablePath, args, temporaryProfilePath) {
 	return new Command(WATCHDOG_SHELL, { args: ["-c", WATCHDOG_SCRIPT, executablePath, temporaryProfilePath, ...args], stdout: NULL_STD_CONFIG, stderr: NULL_STD_CONFIG }).spawn();
 }
 
-async function waitUntilReady(debugPort) {
-	const timeoutTime = Date.now() + READY_TIMEOUT;
-	while (!childExited && Date.now() < timeoutTime) {
-		try {
-			await fetch("http://localhost:" + debugPort + "/json/version");
-			return;
-		} catch {
-			await new Promise(resolve => setTimeout(resolve, READY_RETRY_DELAY));
-		}
-	}
-	throw new Error(childExited ? "The browser exited unexpectedly" : "The browser is not responding");
-}
-
-async function browserExited(maxDelay = 0) {
-	if (child === undefined) {
-		return false;
-	}
-	if (childExited || !maxDelay) {
-		return childExited;
-	}
-	return Promise.race([
-		child.status.then(() => true),
-		new Promise(resolve => setTimeout(() => resolve(childExited), maxDelay))
-	]);
-}
-
 async function getDebugPort(port = getRandomDebugPort(), usedPorts = []) {
 	try {
 		await fetch("http://localhost:" + port + "/json/version");
@@ -243,60 +98,10 @@ async function getDebugPort(port = getRandomDebugPort(), usedPorts = []) {
 	}
 }
 
-
 function getRandomDebugPort() {
 	return Math.floor(Math.random() * DEBUG_PORT_RANGE) + DEBUG_PORT_MIN;
 }
 
-async function closeBrowser() {
-	const closedChild = child;
-	const closedProfilePath = profilePath;
-	child = undefined;
-	profilePath = undefined;
-	if (closedChild !== undefined) {
-		if (keepProfilePath && !childExited) {
-			await closeBrowserGracefully(closedChild);
-		}
-		try {
-			closedChild.kill();
-		} catch {
-			// ignored
-		}
-		await closedChild.status;
-	}
-	if (closedProfilePath !== undefined) {
-		if (keepProfilePath) {
-			await removeProfileLockEntries(closedProfilePath).catch(() => { });
-			await pruneProfile(closedProfilePath).catch(() => { });
-		} else {
-			try {
-				await remove(closedProfilePath, { recursive: true });
-			} catch {
-				console.log("Warning: failed to remove profile directory: " + closedProfilePath); // eslint-disable-line no-console
-			}
-		}
-	}
-}
-
-async function closeBrowserGracefully(closedChild) {
-	try {
-		const response = await fetch(LOCALHOST + browserDebugPort + "/json/version");
-		const { webSocketDebuggerUrl } = await response.json();
-		const socket = new WebSocket(webSocketDebuggerUrl);
-		await new Promise((resolve, reject) => {
-			socket.addEventListener("open", resolve);
-			socket.addEventListener("error", reject);
-		});
-		socket.send(JSON.stringify({ id: 0, method: "Browser.close" }));
-		await Promise.race([
-			closedChild.status,
-			new Promise(resolve => setTimeout(resolve, CLOSE_TIMEOUT))
-		]);
-	} catch {
-		// ignored
-	}
-}
-
 async function copyProfile(sourcePath, destinationPath) {
 	let entries;
 	try {

package/lib/cdp-client.js

@@ -24,11 +24,11 @@
 /* global setTimeout, clearTimeout, URL, AbortController */
 
 import {
-	launchBrowser,
-	getBrowserOptions,
-	closeBrowser,
-	browserExited
-} from "./browser.js";
+	launchChromium,
+	getChromiumOptions,
+	closeChromium,
+	chromiumExited
+} from "./chromium.js";
 import {
 	CDP,
 	options as cdpOptions
@@ -73,15 +73,15 @@ let browserOptions, relaunchBrowserPromise;
 export {
 	initialize,
 	getPageData,
-	closeBrowser
+	closeChromium as closeBrowser
 };
 
 async function initialize(singleFileOptions) {
 	if (singleFileOptions.browserServer) {
 		cdpOptions.apiUrl = singleFileOptions.browserServer;
 	} else {
-		browserOptions = getBrowserOptions(singleFileOptions);
-		cdpOptions.apiUrl = LOCALHOST + (await launchBrowser(browserOptions));
+		browserOptions = getChromiumOptions(singleFileOptions);
+		cdpOptions.apiUrl = LOCALHOST + (await launchChromium(browserOptions));
 	}
 }
 
@@ -89,9 +89,9 @@ function relaunchBrowser() {
 	if (!relaunchBrowserPromise) {
 		console.warn("Warning: the browser exited when using --browser-single-process, retrying without it"); // eslint-disable-line no-console
 		relaunchBrowserPromise = (async () => {
-			await closeBrowser();
+			await closeChromium();
 			browserOptions.singleProcess = false;
-			cdpOptions.apiUrl = LOCALHOST + (await launchBrowser(browserOptions));
+			cdpOptions.apiUrl = LOCALHOST + (await launchChromium(browserOptions));
 		})();
 	}
 	return relaunchBrowserPromise;
@@ -135,7 +135,7 @@ async function getPageData(options) {
 	}
 
 	async function shouldRelaunchBrowser() {
-		return Boolean(browserOptions && browserOptions.singleProcess) && await browserExited(BROWSER_EXITED_MAX_DELAY);
+		return Boolean(browserOptions && browserOptions.singleProcess) && await chromiumExited(BROWSER_EXITED_MAX_DELAY);
 	}
 
 	async function relaunchBrowserAndRetry() {

package/lib/chromium.js

@@ -0,0 +1,225 @@
+/*
+ * Copyright 2010-2024 Gildas Lormeau
+ * contact : gildas.lormeau <at> gmail.com
+ *
+ * This file is part of SingleFile.
+ *
+ *   The code in this file is free software: you can redistribute it and/or
+ *   modify it under the terms of the GNU Affero General Public License
+ *   (GNU AGPL) as published by the Free Software Foundation, either version 3
+ *   of the License, or (at your option) any later version.
+ *
+ *   The code in this file is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero
+ *   General Public License for more details.
+ *
+ *   As additional permission under GNU AGPL version 3 section 7, you may
+ *   distribute UNMODIFIED VERSIONS OF THIS file without the copy of the GNU
+ *   AGPL normally required by section 4, provided you include this license
+ *   notice and a URL through which recipients can access the Corresponding
+ *   Source.
+ */
+
+/* global fetch, setTimeout, WebSocket */
+
+import { CHROMIUM_PATHS, CHROMIUM_ARGS } from "./constants.js";
+import { spawnBrowser, getDebugPort, copyProfile, pruneProfile, removeProfileLockEntries } from "./browser.js";
+import { Deno } from "./deno-polyfill.js";
+
+const READY_TIMEOUT = 30000;
+const READY_RETRY_DELAY = 250;
+const CLOSE_TIMEOUT = 15000;
+const LOCALHOST = "http://localhost:";
+const PROFILE_INCOMPATIBLE_ARGS = [
+	"--no-startup-window",
+	"--bwsi",
+	"--deny-permission-prompts"
+];
+
+const { build, makeTempDir, mkdir, errors, remove } = Deno;
+let child, profilePath, childExited, keepProfilePath, browserDebugPort;
+export { launchChromium, createBrowserProfile, getChromiumOptions, closeChromium, chromiumExited };
+
+function getChromiumOptions(options) {
+	return {
+		args: options.browserArgs,
+		headless: options.browserHeadless,
+		executablePath: options.browserExecutablePath,
+		debug: options.browserDebug,
+		singleProcess: options.browserSingleProcess,
+		width: options.browserWidth,
+		height: options.browserHeight,
+		userAgent: options.userAgent,
+		httpProxyServer: options.httpProxyServer,
+		profile: options.browserProfile
+	};
+}
+
+async function createBrowserProfile(options = {}) {
+	await mkdir(options.profile, { recursive: true });
+	await launchChromium(Object.assign({}, options, { headless: false, persistProfile: true }));
+	if (child !== undefined) {
+		await child.status;
+	}
+	await closeChromium();
+}
+
+async function launchChromium(options = {}, indexPath = 0) {
+	const executablePath = options.executablePath || CHROMIUM_PATHS[build.os][indexPath];
+	let args = Array.from(CHROMIUM_ARGS);
+	const debugPort = await getDebugPort();
+	browserDebugPort = debugPort;
+	args.push("--remote-debugging-port=" + debugPort);
+	keepProfilePath = Boolean(options.persistProfile);
+	if (keepProfilePath) {
+		profilePath = options.profile;
+		args = args.filter(arg => !PROFILE_INCOMPATIBLE_ARGS.includes(arg));
+	} else {
+		profilePath = await makeTempDir();
+		if (options.profile) {
+			await copyProfile(options.profile, profilePath);
+		}
+	}
+	if (options.headless && !options.debug) {
+		args.push("--headless");
+	} else {
+		args.push("--start-maximized");
+	}
+	if (options.debug) {
+		args.push("--auto-open-devtools-for-tabs");
+	}
+	if (options.width && options.height) {
+		args.push("--window-size=" + options.width + "," + options.height);
+	}
+	if (options.userAgent) {
+		args.push("--user-agent=" + options.userAgent);
+	}
+	if (options.httpProxyServer) {
+		args.push("--proxy-server=" + options.httpProxyServer);
+	}
+	args.push("--user-data-dir=" + profilePath);
+	if (options.singleProcess) {
+		args.push("--single-process");
+	}
+	if (options.args) {
+		const argNames = options.args.map(arg => arg.split("=")[0]);
+		args = args.filter(arg => !argNames.includes(arg.split("=")[0]));
+		args.push(...options.args);
+	}
+	if (args.includes("--headless=new") ||
+		args.includes("--auto-open-devtools-for-tabs") ||
+		args.includes("--start-maximized") ||
+		!args.includes("--headless")) {
+		args.push("--disable-site-isolation-trials");
+	}
+	if (options.startUrl) {
+		args.push(options.startUrl);
+	}
+	try {
+		child = await spawnBrowser(executablePath, args, keepProfilePath ? "" : profilePath);
+	} catch (error) {
+		if (!keepProfilePath) {
+			await remove(profilePath, { recursive: true }).catch(() => { });
+		}
+		profilePath = undefined;
+		if (error instanceof errors.NotFound) {
+			if (!options.executablePath && indexPath + 1 < CHROMIUM_PATHS[build.os].length) {
+				return launchChromium(options, indexPath + 1);
+			}
+			throw new Error(options.executablePath ?
+				`The browser executable was not found at ${JSON.stringify(executablePath)}` :
+				"The browser executable was not found, use --browser-executable-path to set its location");
+		}
+		throw error;
+	}
+	child.ref();
+	childExited = false;
+	child.status.then(() => childExited = true);
+	try {
+		await waitUntilReady(debugPort);
+	} catch (error) {
+		await closeChromium();
+		if (options.singleProcess) {
+			console.warn("Warning: the browser exited when using --browser-single-process, retrying without it"); // eslint-disable-line no-console
+			return launchChromium(Object.assign({}, options, { singleProcess: false }), indexPath);
+		}
+		throw error;
+	}
+	return debugPort;
+}
+
+async function waitUntilReady(debugPort) {
+	const timeoutTime = Date.now() + READY_TIMEOUT;
+	while (!childExited && Date.now() < timeoutTime) {
+		try {
+			await fetch("http://localhost:" + debugPort + "/json/version");
+			return;
+		} catch {
+			await new Promise(resolve => setTimeout(resolve, READY_RETRY_DELAY));
+		}
+	}
+	throw new Error(childExited ? "The browser exited unexpectedly" : "The browser is not responding");
+}
+
+async function chromiumExited(maxDelay = 0) {
+	if (child === undefined) {
+		return false;
+	}
+	if (childExited || !maxDelay) {
+		return childExited;
+	}
+	return Promise.race([
+		child.status.then(() => true),
+		new Promise(resolve => setTimeout(() => resolve(childExited), maxDelay))
+	]);
+}
+
+async function closeChromium() {
+	const closedChild = child;
+	const closedProfilePath = profilePath;
+	child = undefined;
+	profilePath = undefined;
+	if (closedChild !== undefined) {
+		if (keepProfilePath && !childExited) {
+			await closeBrowserGracefully(closedChild);
+		}
+		try {
+			closedChild.kill();
+		} catch {
+			// ignored
+		}
+		await closedChild.status;
+	}
+	if (closedProfilePath !== undefined) {
+		if (keepProfilePath) {
+			await removeProfileLockEntries(closedProfilePath).catch(() => { });
+			await pruneProfile(closedProfilePath).catch(() => { });
+		} else {
+			try {
+				await remove(closedProfilePath, { recursive: true });
+			} catch {
+				console.log("Warning: failed to remove profile directory: " + closedProfilePath); // eslint-disable-line no-console
+			}
+		}
+	}
+}
+
+async function closeBrowserGracefully(closedChild) {
+	try {
+		const response = await fetch(LOCALHOST + browserDebugPort + "/json/version");
+		const { webSocketDebuggerUrl } = await response.json();
+		const socket = new WebSocket(webSocketDebuggerUrl);
+		await new Promise((resolve, reject) => {
+			socket.addEventListener("open", resolve);
+			socket.addEventListener("error", reject);
+		});
+		socket.send(JSON.stringify({ id: 0, method: "Browser.close" }));
+		await Promise.race([
+			closedChild.status,
+			new Promise(resolve => setTimeout(resolve, CLOSE_TIMEOUT))
+		]);
+	} catch {
+		// ignored
+	}
+}