single-file-cli 2.6.4 → 2.7.1

package/build.sh

@@ -2,7 +2,7 @@
 
 set -e
 
-CORE_PACKAGE="npm:single-file-core@1.5.119"
+CORE_PACKAGE="npm:single-file-core@1.5.120"
 ESBUILD_PACKAGE="npm:esbuild@0.27.7"
 
 project_dir=$(pwd)

package/deno.json

@@ -1,6 +1,6 @@
 {
   "name": "@single-file/single-file-cli",
-  "version": "2.6.4",
+  "version": "2.7.1",
   "description": "SingleFile CLI",
   "exports": {
     ".": "./single-file-cli-api.js"

package/lib/browser.js

@@ -59,7 +59,23 @@ const PROFILE_INCOMPATIBLE_ARGS = [
 	"--deny-permission-prompts"
 ];
 
-const { build, makeTempDir, readDir, copyFile, mkdir, Command, errors, remove } = Deno;
+const { build, makeTempDir, 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",
+	"profile=$1",
+	"shift",
+	"\"$0\" \"$@\" &",
+	"browser=$!",
+	"parent=$PPID",
+	"while kill -0 $parent 2>/dev/null && kill -0 $browser 2>/dev/null; do sleep 0.25; done",
+	"if ! kill -0 $parent 2>/dev/null; then",
+	"kill -TERM $browser 2>/dev/null",
+	"wait $browser 2>/dev/null",
+	"if [ -n \"$profile\" ]; then rm -rf \"$profile\"; fi",
+	"fi",
+	"wait $browser 2>/dev/null"
+].join("\n");
 const { join } = path;
 let child, profilePath, childExited, keepProfilePath, browserDebugPort;
 export { launchBrowser, createBrowserProfile, getBrowserOptions, copyProfile, pruneProfile, closeBrowser, browserExited };
@@ -139,9 +155,8 @@ async function launchBrowser(options = {}, indexPath = 0) {
 	if (options.startUrl) {
 		args.push(options.startUrl);
 	}
-	const command = new Command(executablePath, { args, stdout: NULL_STD_CONFIG, stderr: NULL_STD_CONFIG });
 	try {
-		child = await command.spawn();
+		child = await spawnBrowser(executablePath, args, keepProfilePath ? "" : profilePath);
 	} catch (error) {
 		if (!keepProfilePath) {
 			await remove(profilePath, { recursive: true }).catch(() => { });
@@ -173,6 +188,18 @@ async function launchBrowser(options = {}, indexPath = 0) {
 	return debugPort;
 }
 
+async function spawnBrowser(executablePath, args, temporaryProfilePath) {
+	if (build.os == "windows") {
+		return new Command(executablePath, { args, stdout: NULL_STD_CONFIG, stderr: NULL_STD_CONFIG }).spawn();
+	}
+	try {
+		await stat(executablePath);
+	} catch {
+		throw new errors.NotFound(executablePath);
+	}
+	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) {

package/lib/cdp-client.js

@@ -122,9 +122,6 @@ async function getPageData(options) {
 		await disableCdpDomains(cdp, pageContext);
 		return await finalizePageData(pageDataPromise, pageContext);
 	} catch (error) {
-		if (shouldRetryWithFallback(error)) {
-			return await retryWithFallback();
-		}
 		if (await shouldRelaunchBrowser()) {
 			return await relaunchBrowserAndRetry();
 		}
@@ -137,21 +134,6 @@ async function getPageData(options) {
 		logData(["Finishing"], pageContext);
 	}
 
-	function shouldRetryWithFallback(error) {
-		return error.code === LOAD_TIMEOUT_ERROR &&
-			options.browserWaitUntilFallback &&
-			options.browserWaitUntil &&
-			NETWORK_STATES.indexOf(options.browserWaitUntil) < NETWORK_STATES.length - 1;
-	}
-
-	async function retryWithFallback() {
-		const browserWaitUntil = NETWORK_STATES[(NETWORK_STATES.indexOf(options.browserWaitUntil) + 1)];
-		logData(["Retrying with waitUntil", browserWaitUntil], pageContext);
-		options.browserWaitUntil = browserWaitUntil;
-		await closeTarget();
-		return await getPageData(options);
-	}
-
 	async function shouldRelaunchBrowser() {
 		return Boolean(browserOptions && browserOptions.singleProcess) && await browserExited(BROWSER_EXITED_MAX_DELAY);
 	}
@@ -570,16 +552,28 @@ async function loadPage({ Page, Runtime }, { options, debugMessages }) {
 	// the ID of the top frame is stable, and it is read before the navigation is
 	// triggered so that no event is missed while the browser answers
 	const { frameTree } = await Page.getFrameTree();
+	const state = { topFrameId: frameTree.frame.id, reachedStateIndex: -1 };
 	const loadTimeoutAbortController = new AbortController();
 	const loadTimeoutAbortSignal = loadTimeoutAbortController.signal;
 	try {
 		logData(["Loading page", options.url], { options, debugMessages });
+		const contextIdPromise = getTopFrameContextId({ Page, Runtime }, state, { options, debugMessages });
 		const [contextId] = await Promise.race([
 			Promise.all([
-				getTopFrameContextId({ Page, Runtime }, frameTree.frame.id, { options, debugMessages }),
+				contextIdPromise,
 				Page.navigate({ url: options.url })
 			]),
-			waitForTimeout(loadTimeoutAbortSignal, options.browserLoadMaxTime, LOAD_TIMEOUT_ERROR_MESSAGE, LOAD_TIMEOUT_ERROR)
+			waitForTimeout(loadTimeoutAbortSignal, options.browserLoadMaxTime, LOAD_TIMEOUT_ERROR_MESSAGE, LOAD_TIMEOUT_ERROR).catch(async error => {
+				if (options.browserWaitUntilFallback && state.reachedStateIndex >= 0) {
+					const reachedState = NETWORK_STATES[state.reachedStateIndex];
+					logData(["Stopping the page loading, reached state", reachedState], { options, debugMessages });
+					console.warn(`Warning: ${options.url} did not reach ${options.browserWaitUntil} within ${options.browserLoadMaxTime} ms, captured as it was at ${reachedState}`); // eslint-disable-line no-console
+					await Page.stopLoading();
+					state.settle();
+					return [await contextIdPromise];
+				}
+				throw error;
+			})
 		]);
 		// only called when the page loaded, these calls can hang forever on an
 		// unresponsive page and would mask the load timeout error
@@ -596,9 +590,9 @@ async function loadPage({ Page, Runtime }, { options, debugMessages }) {
 
 // the listeners are registered synchronously, before the navigation triggered
 // in parallel by the caller can produce any event
-async function getTopFrameContextId({ Page, Runtime }, topFrameId, { options, debugMessages }) {
-	await waitForPageReadyState({ Page }, { topFrameId }, { options, debugMessages });
-	return await getSingleFileContext({ Page, Runtime }, topFrameId, { options, debugMessages });
+async function getTopFrameContextId({ Page, Runtime }, state, { options, debugMessages }) {
+	await waitForPageReadyState({ Page }, state, { options, debugMessages });
+	return await getSingleFileContext({ Page, Runtime }, state.topFrameId, { options, debugMessages });
 }
 
 async function waitForPageReadyState({ Page }, state, { options, debugMessages }) {
@@ -611,7 +605,12 @@ async function waitForPageReadyState({ Page }, state, { options, debugMessages }
 			Page.removeEventListener(FRAME_NAVIGATED_EVENT_TYPE, onFrameNavigated);
 		};
 		const onLifecycleEvent = createLifecycleEventHandler(state, timeoutState, resolve, cleanup, { options, debugMessages });
-		const onFrameNavigated = createFrameNavigatedHandler(timeoutState, reject, cleanup, { options, debugMessages });
+		const onFrameNavigated = createFrameNavigatedHandler(state, timeoutState, reject, cleanup, { options, debugMessages });
+		state.settle = () => {
+			clearTimeout(timeoutState.timeoutId);
+			cleanup();
+			resolve();
+		};
 		Page.addEventListener(LIFE_CYCLE_EVENT_TYPE, onLifecycleEvent);
 		Page.addEventListener(FRAME_NAVIGATED_EVENT_TYPE, onFrameNavigated);
 	});
@@ -622,6 +621,10 @@ function createLifecycleEventHandler(state, timeoutState, resolve, cleanup, { op
 		const { frameId, name } = params;
 		if (frameId === state.topFrameId) {
 			logData(["Detecting lifecycle event", name], { options, debugMessages });
+			const stateIndex = NETWORK_STATES.indexOf(name);
+			if (stateIndex != -1 && (state.reachedStateIndex == -1 || stateIndex < state.reachedStateIndex)) {
+				state.reachedStateIndex = stateIndex;
+			}
 		}
 		const shouldResolve = frameId === state.topFrameId &&
 			(name === options.browserWaitUntil ||
@@ -640,15 +643,24 @@ function createLifecycleEventHandler(state, timeoutState, resolve, cleanup, { op
 	};
 };
 
-function createFrameNavigatedHandler(timeoutState, reject, cleanup, { options, debugMessages }) {
+function createFrameNavigatedHandler(state, timeoutState, reject, cleanup, { options, debugMessages }) {
 	const UNREACHABLE_URL_ERROR_MESSAGE = "Unreachable URL";
 	return ({ params }) => {
 		const { frame } = params;
-		if (!frame.parentId && frame.unreachableUrl) {
-			logData(["Detecting unreachable URL", frame.unreachableUrl], { options, debugMessages });
-			clearTimeout(timeoutState.timeoutId);
-			cleanup();
-			reject(new Error(UNREACHABLE_URL_ERROR_MESSAGE + ": " + frame.unreachableUrl));
+		if (!frame.parentId) {
+			if (frame.unreachableUrl) {
+				logData(["Detecting unreachable URL", frame.unreachableUrl], { options, debugMessages });
+				clearTimeout(timeoutState.timeoutId);
+				cleanup();
+				reject(new Error(UNREACHABLE_URL_ERROR_MESSAGE + ": " + frame.unreachableUrl));
+			} else {
+				// a new document starts the wait over: the states the previous one
+				// reached and the delay it started say nothing about this one
+				logData(["Detecting navigation", frame.url], { options, debugMessages });
+				clearTimeout(timeoutState.timeoutId);
+				timeoutState.timeoutId = undefined;
+				state.reachedStateIndex = -1;
+			}
 		}
 	};
 }