single-file-cli 2.9.1 → 2.9.2

package/deno.json

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

package/lib/bidi-client.js

@@ -34,6 +34,8 @@ import {
 	FETCH_FUNCTION_NAME,
 	RESOLVE_FETCH_FUNCTION_NAME,
 	REJECT_FETCH_FUNCTION_NAME,
+	SCRIPT_READY_PROPERTY_NAME,
+	SCRIPT_ERROR_PROPERTY_NAME,
 	getScriptSource,
 	getHookScriptSource,
 	getPageDataScriptSource
@@ -1100,7 +1102,7 @@ function waitForPageReadyState(state, waitUntil, pageContext) {
 }
 
 async function checkSingleFileContext(pageContext) {
-	const SINGLE_FILE_DETECTION_TEST = "typeof singlefile !== 'undefined'";
+	const SINGLE_FILE_DETECTION_TEST = "typeof singlefile !== 'undefined' && globalThis." + SCRIPT_READY_PROPERTY_NAME + " === true";
 	const NO_VALID_CONTEXT_ERROR_MESSAGE = "No valid SingleFile execution context found";
 	const { context } = pageContext;
 	logData(["Getting execution context"], pageContext);
@@ -1110,10 +1112,19 @@ async function checkSingleFileContext(pageContext) {
 		awaitPromise: false
 	});
 	if (!result || result.value !== true) {
-		throw new Error(NO_VALID_CONTEXT_ERROR_MESSAGE);
+		throw new Error(NO_VALID_CONTEXT_ERROR_MESSAGE + await getInjectionErrorSuffix(context));
 	}
 }
 
+async function getInjectionErrorSuffix(context) {
+	const { result } = await session.send("script.evaluate", {
+		expression: "globalThis." + SCRIPT_ERROR_PROPERTY_NAME,
+		target: getSingleFileTarget(context),
+		awaitPromise: false
+	}).catch(() => ({}));
+	return result && result.value ? ": " + result.value : "";
+}
+
 async function capturePageData(pageContext) {
 	const CAPTURE_TIMEOUT_ERROR_MESSAGE = "Capture timeout";
 	const EXCEPTION_TYPE = "exception";

package/lib/cdp-client.js

@@ -37,6 +37,8 @@ import {
 	FETCH_FUNCTION_NAME,
 	RESOLVE_FETCH_FUNCTION_NAME,
 	REJECT_FETCH_FUNCTION_NAME,
+	SCRIPT_READY_PROPERTY_NAME,
+	SCRIPT_ERROR_PROPERTY_NAME,
 	getScriptSource,
 	getHookScriptSource,
 	getPageDataScriptSource
@@ -670,7 +672,7 @@ function createFrameNavigatedHandler(state, timeoutState, reject, cleanup, { opt
 }
 
 async function getSingleFileContext({ Page, Runtime }, topFrameId, { options, debugMessages }) {
-	const SINGLE_FILE_DETECTION_TEST = "typeof singlefile !== 'undefined'";
+	const SINGLE_FILE_DETECTION_TEST = "typeof singlefile !== 'undefined' && globalThis." + SCRIPT_READY_PROPERTY_NAME + " === true";
 	const NO_VALID_CONTEXT_ERROR_MESSAGE = "No valid SingleFile execution context found";
 	logData(["Getting execution context"], { options, debugMessages });
 	// the world already exists, so asking for it by name returns the context the
@@ -687,11 +689,19 @@ async function getSingleFileContext({ Page, Runtime }, topFrameId, { options, de
 		contextId: executionContextId
 	});
 	if (result.value !== true) {
-		throw new Error(NO_VALID_CONTEXT_ERROR_MESSAGE);
+		throw new Error(NO_VALID_CONTEXT_ERROR_MESSAGE + await getInjectionErrorSuffix(Runtime, executionContextId));
 	}
 	return executionContextId;
 }
 
+async function getInjectionErrorSuffix(Runtime, executionContextId) {
+	const { result } = await Runtime.evaluate({
+		expression: "globalThis." + SCRIPT_ERROR_PROPERTY_NAME,
+		contextId: executionContextId
+	}).catch(() => ({}));
+	return result && result.value ? ": " + result.value : "";
+}
+
 function setupPageDataCapture({ Runtime }, { options, debugMessages }) {
 	return new Promise((resolve, reject) => {
 		let pageDataResponse = "";

package/lib/single-file-script.js

@@ -29,6 +29,8 @@ import { Deno } from "./deno-polyfill.js";
 const FETCH_FUNCTION_NAME = "__singleFileFetch";
 const RESOLVE_FETCH_FUNCTION_NAME = "__singleFileResolveFetch";
 const REJECT_FETCH_FUNCTION_NAME = "__singleFileRejectFetch";
+const SCRIPT_READY_PROPERTY_NAME = "__singleFileScriptReady";
+const SCRIPT_ERROR_PROPERTY_NAME = "__singleFileScriptError";
 
 const { readTextFile } = Deno;
 
@@ -36,6 +38,8 @@ export {
 	FETCH_FUNCTION_NAME,
 	RESOLVE_FETCH_FUNCTION_NAME,
 	REJECT_FETCH_FUNCTION_NAME,
+	SCRIPT_READY_PROPERTY_NAME,
+	SCRIPT_ERROR_PROPERTY_NAME,
 	getScriptSource,
 	getHookScriptSource,
 	getZipScriptSource,
@@ -101,7 +105,8 @@ async function getScriptSource(options) {
 		RESOLVE_FETCH_FUNCTION_NAME,
 		REJECT_FETCH_FUNCTION_NAME
 	}) + ");";
-	return source;
+	return "try{" + source + "\nglobalThis." + SCRIPT_READY_PROPERTY_NAME + "=true;}" +
+		"catch(error){globalThis." + SCRIPT_ERROR_PROPERTY_NAME + "=String(error);throw error;}";
 }
 
 function getHookScriptSource() {

package/lib/version.js

@@ -1 +1 @@
-export const version = "2.9.1";
+export const version = "2.9.2";

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "single-file-cli",
-	"version": "2.9.1",
+	"version": "2.9.2",
 	"description": "SingleFile CLI",
 	"author": "Gildas Lormeau",
 	"license": "AGPL-3.0-or-later",

package/test/e2e/browser-script.test.js

@@ -0,0 +1,72 @@
+// The injected script is one concatenation: the SingleFile bundle, then the scripts named by
+// --browser-script, then the call that hands SingleFile its options and its fetch fallback. A
+// throw anywhere in it stops the rest, and nothing reported it — the browser does not surface an
+// exception raised by a preload script, and the only guard was "is `singlefile` defined", which is
+// already true by then. So a script that threw produced a save that looked ordinary and was
+// missing the fetch fallback the CLI installs for the resources the page itself cannot get.
+
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { createServer } from "node:http";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { mkdtemp, readFile, writeFile, rm } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import process from "node:process";
+import { cliDirectory } from "../target.js";
+
+const execFileAsync = promisify(execFile);
+const TEST_TIMEOUT = 120000;
+
+test("a browser script runs in the page it saves", { timeout: TEST_TIMEOUT }, async () => {
+	const MARKER = "browser-script-marker";
+	await withPage(async ({ url, directory }) => {
+		const scriptPath = join(directory, "marker.js");
+		await writeFile(scriptPath, "addEventListener(\"DOMContentLoaded\",()=>{" +
+			"const marker=document.createElement(\"p\");marker.id=\"" + MARKER + "\";document.body.appendChild(marker);});");
+		const outputPath = join(directory, "out.html");
+		await execFileAsync(process.execPath, [
+			"single-file-node.js", url, outputPath,
+			"--browser-script", scriptPath
+		], { cwd: cliDirectory });
+		assert.match(await readFile(outputPath, "utf8"), new RegExp(MARKER));
+	});
+});
+
+test("a browser script that throws fails the save instead of degrading it", { timeout: TEST_TIMEOUT }, async () => {
+	const SCRIPT_ERROR_MESSAGE = "browser script boom";
+	await withPage(async ({ url, directory }) => {
+		const scriptPath = join(directory, "throwing.js");
+		await writeFile(scriptPath, "throw new Error(\"" + SCRIPT_ERROR_MESSAGE + "\");");
+		const outputPath = join(directory, "out.html");
+		let exitCode = 0, stderr = "";
+		try {
+			await execFileAsync(process.execPath, [
+				"single-file-node.js", url, outputPath,
+				"--browser-script", scriptPath
+			], { cwd: cliDirectory });
+		} catch (error) {
+			({ code: exitCode, stderr } = error);
+		}
+		assert.notEqual(exitCode, 0, "a save whose injected script threw was reported as a success");
+		// the message the script threw is what says which script to look at: without it the
+		// failure names the execution context and leaves the cause to be guessed
+		assert.match(stderr, new RegExp(SCRIPT_ERROR_MESSAGE), "the failure does not name the error the script threw");
+		assert.ok(!existsSync(outputPath), "a page was written for a save that failed");
+	});
+});
+
+async function withPage(run) {
+	const server = createServer((request, response) =>
+		response.writeHead(200, { "content-type": "text/html" }).end("<html><body><h1>page</h1></body></html>"));
+	await new Promise(resolve => server.listen(0, "localhost", resolve));
+	const directory = await mkdtemp(join(tmpdir(), "single-file-test-"));
+	try {
+		await run({ url: "http://localhost:" + server.address().port + "/", directory });
+	} finally {
+		await rm(directory, { recursive: true, force: true });
+		server.close();
+	}
+}