single-file-cli 2.3.0 → 2.4.0

package/lib/version.js

@@ -1 +1 @@
-export const version = "2.3.0";
+export const version = "2.4.0";

package/options.js

@@ -56,6 +56,7 @@ const OPTIONS_INFO = [{
 	"browser-server": { description: "Server to connect to", type: "string", alias: "browser-remote-debugging-url" },
 	"browser-headless": { description: "Run the browser in headless mode", type: "boolean", defaultValue: true },
 	"browser-executable-path": { description: "Path to chrome/chromium executable", type: "string" },
+	"browser-profile": { description: "Path of the browser profile directory to use, e.g. to save pages requiring a logged-in session (see --create-browser-profile). The directory is copied before starting the browser and is left unmodified.", type: "string" },
 	"browser-width": { description: "Width of the browser viewport in pixels", type: "number", defaultValue: 1280 },
 	"browser-height": { description: "Height of the browser viewport in pixels", type: "number", defaultValue: 720 },
 	"browser-debug": { description: "Enable debug mode", type: "boolean" },
@@ -203,6 +204,7 @@ const OPTIONS_INFO = [{
 
 	"save-raw-page": { description: "Save the original page without interpreting it into the browser", type: "boolean" },
 	"output-json": { description: "Output the result as a JSON string containing the page and network info", type: "boolean" },
+	"create-browser-profile": { description: "Path of the browser profile directory to create or update instead of saving a page. The browser is started with a visible window on the URL passed as argument, log in to the website and quit the browser to save the profile, then pass it to --browser-profile when saving pages", type: "string" },
 
 }, {
 	"help": { description: "Show help", type: "boolean" },
@@ -303,12 +305,22 @@ function getOptions() {
 	invalidOptions.forEach(({ name, value }) => errorMessages.push(value === undefined ?
 		`Missing value for --${name}` :
 		`Invalid value for --${name}: ${JSON.stringify(value)}`));
-	if (!urls.length && !options.urlsFile) {
+	if (!urls.length && !options.urlsFile && !options.createBrowserProfile) {
 		errorMessages.push("The URL or path of the page to save is required");
 	}
 	if (urls.length > 2) {
 		errorMessages.push(`Unexpected arguments: ${urls.slice(2).join(", ")}`);
 	}
+	if (options.createBrowserProfile) {
+		if (options.browserProfile) {
+			errorMessages.push("--create-browser-profile cannot be used with --browser-profile, it already takes the path of the profile directory");
+		}
+		if (options.browserServer) {
+			errorMessages.push("--create-browser-profile cannot be used with --browser-server");
+		}
+	} else if (options.browserProfile && options.browserServer) {
+		errorMessages.push("--browser-profile cannot be used with --browser-server");
+	}
 	if (!options.crawlLinks) {
 		const explicitOptions = parseArgs(Array.from(args), false).options;
 		Object.keys(CRAWL_LINKS_DEPENDENT_OPTIONS)
@@ -336,7 +348,7 @@ function printUsage() {
 				optionType = optionType.replace("[]", "*");
 			}
 			const optionDescription = optionInfo.description;
-			const optionDefaultValue = optionInfo.defaultValue === undefined ? "" : `(default: ${JSON.stringify(optionInfo.defaultValue)})`;
+			const optionDefaultValue = optionInfo.defaultValue === undefined ? "" : `(default: ${JSON.stringify(optionInfo.defaultValue).replace(/[\u007f-\u009f]/g, character => "\\u" + character.charCodeAt(0).toString(16).padStart(4, "0"))})`;
 			console.log(`    --${optionName}: ${optionDescription} <${optionType}> ${optionDefaultValue}`); // eslint-disable-line no-console
 		});
 		console.log(""); // eslint-disable-line no-console

package/package.json

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

package/single-file-cli-api.js

@@ -26,7 +26,7 @@
 import { Buffer } from "node:buffer";
 import * as backend from "./lib/cdp-client.js";
 import { getZipScriptSource } from "./lib/single-file-script.js";
-import { createPagesArchive } from "./lib/archive-packager.js";
+import { createPagesArchive } from "./lib/single-file-archive.js";
 import { Deno, path } from "./lib/deno-polyfill.js";
 
 const VALID_URL_TEST = /^(https?|file):\/\//;
@@ -250,6 +250,12 @@ async function runNextTask() {
 		task.promise = capturePage(taskOptions);
 		const pageData = await task.promise;
 		task.status = STATE_PROCESSED;
+		if (options.crawlLinks || tasks.length > 1) {
+			const processedCount = tasks.filter(task => task.status == STATE_PROCESSED).length;
+			const filenameInfo = pageData && pageData.filename && !options.crawlSaveArchive && !options.dumpContent ? " (" + pageData.filename + ")" : "";
+			// written to stderr so that stdout stays parseable when using --dump-content
+			console.error(`[${processedCount}/${tasks.length}] ${pageData ? "saved" : "failed"} ${task.url}${filenameInfo}`); // eslint-disable-line no-console
+		}
 		if (pageData) {
 			task.filename = pageData.filename;
 			task.title = pageData.title;

package/single-file-launcher.js

@@ -22,11 +22,12 @@
  */
 
 import { initialize } from "./single-file-cli-api.js";
-import { closeBrowser } from "./lib/browser.js";
+import { closeBrowser, createBrowserProfile, getBrowserOptions } from "./lib/browser.js";
 import { Deno } from "./lib/deno-polyfill.js";
 import { getOptions, applySettings, parseUrlsFile } from "./options.js";
 
-const { readTextFile, readFile, exit, addSignalListener } = Deno;
+const { readTextFile, readFile, exit, addSignalListener, build } = Deno;
+const QUIT_BROWSER_HINT = build.os == "darwin" ? " (Cmd+Q)" : "";
 
 try {
 	addSignalListener("SIGTERM", closeBrowserAndExit);
@@ -49,6 +50,10 @@ async function run() {
 			const settings = JSON.parse(await readTextFile(options.settingsFile));
 			applySettings(options, settings);
 		}
+		if (options.createBrowserProfile) {
+			await saveBrowserProfile(options);
+			exit(0);
+		}
 		if (options.urlsFile) {
 			urls = await getUrlsFile(options.urlsFile);
 		} else {
@@ -81,6 +86,13 @@ async function run() {
 	}
 }
 
+async function saveBrowserProfile(options) {
+	const profileDirectory = options.createBrowserProfile;
+	console.error(`Log in to the website in the browser window, then quit the browser${QUIT_BROWSER_HINT} to save the profile.`); // eslint-disable-line no-console
+	await createBrowserProfile(Object.assign(getBrowserOptions(options), { profile: profileDirectory, startUrl: options.url }));
+	console.error(`Profile saved, use it with --browser-profile ${JSON.stringify(profileDirectory)}.`); // eslint-disable-line no-console
+}
+
 function parseCookies(textValue) {
 	const httpOnlyRegExp = /^#HttpOnly_(.*)/;
 	return textValue.split(/\r\n|\n/)

package/test/e2e/automation-detection.test.js

@@ -0,0 +1,103 @@
+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, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import process from "node:process";
+
+const execFileAsync = promisify(execFile);
+const cliDirectory = join(dirname(fileURLToPath(import.meta.url)), "..", "..");
+
+test("pages are not captured as controlled by automation", { timeout: 120000 }, async () => {
+	const server = createServer((_, response) => response
+		.writeHead(200, { "content-type": "text/html" })
+		.end("<html><head><title>Automation</title></head><body><p id=result></p>" +
+			"<script>document.getElementById(\"result\").textContent = \"webdriver=\" + navigator.webdriver;</script>" +
+			"</body></html>"));
+	await new Promise(resolve => server.listen(0, "localhost", resolve));
+	const directory = await mkdtemp(join(tmpdir(), "single-file-test-"));
+	try {
+		const outputPath = join(directory, "page.html");
+		const url = "http://localhost:" + server.address().port + "/";
+		const { stderr } = await execFileAsync(process.execPath, [
+			"single-file-node.js", url, outputPath
+		], { cwd: cliDirectory });
+		let content;
+		try {
+			content = await readFile(outputPath, "utf8");
+		} catch (error) {
+			throw new Error("missing output file, stderr: " + stderr, { cause: error });
+		}
+		assert.ok(content.includes("webdriver=false"), "expected navigator.webdriver to be false, got: " + content.match(/webdriver=\w+/));
+	} finally {
+		await rm(directory, { recursive: true });
+		server.close();
+	}
+});
+
+test("pages are not captured with a headless user agent", { timeout: 120000 }, async () => {
+	const server = createServer((request, response) => response
+		.writeHead(200, { "content-type": "text/html" })
+		.end("<html><head><title>User agent</title></head><body>" +
+			"<p id=header-agent>header-agent=" + request.headers["user-agent"] + "</p>" +
+			"<p id=script-agent></p>" +
+			"<script>document.getElementById(\"script-agent\").textContent = \"script-agent=\" + navigator.userAgent;</script>" +
+			"</body></html>"));
+	await new Promise(resolve => server.listen(0, "localhost", resolve));
+	const directory = await mkdtemp(join(tmpdir(), "single-file-test-"));
+	try {
+		const outputPath = join(directory, "page.html");
+		const url = "http://localhost:" + server.address().port + "/";
+		const { stderr } = await execFileAsync(process.execPath, [
+			"single-file-node.js", url, outputPath
+		], { cwd: cliDirectory });
+		let content;
+		try {
+			content = await readFile(outputPath, "utf8");
+		} catch (error) {
+			throw new Error("missing output file, stderr: " + stderr, { cause: error });
+		}
+		const headerAgent = content.match(/header-agent=([^<]*)/);
+		const scriptAgent = content.match(/script-agent=([^<]*)/);
+		assert.ok(headerAgent, "missing the user agent sent to the server");
+		assert.ok(scriptAgent, "missing the user agent read in the page");
+		assert.ok(!headerAgent[1].includes("Headless"), "unexpected headless token in the user agent sent to the server: " + headerAgent[1]);
+		assert.ok(!scriptAgent[1].includes("Headless"), "unexpected headless token in the user agent read in the page: " + scriptAgent[1]);
+		assert.ok(scriptAgent[1].includes("Chrome/"), "expected a Chrome user agent, got: " + scriptAgent[1]);
+	} finally {
+		await rm(directory, { recursive: true });
+		server.close();
+	}
+});
+
+test("the user agent option overrides the browser user agent", { timeout: 120000 }, async () => {
+	const userAgent = "Mozilla/5.0 (SingleFile test) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/151.0.0.0 Safari/537.36";
+	const server = createServer((request, response) => response
+		.writeHead(200, { "content-type": "text/html" })
+		.end("<html><head><title>User agent</title></head><body>" +
+			"<p id=header-agent>header-agent=" + request.headers["user-agent"] + "</p>" +
+			"</body></html>"));
+	await new Promise(resolve => server.listen(0, "localhost", resolve));
+	const directory = await mkdtemp(join(tmpdir(), "single-file-test-"));
+	try {
+		const outputPath = join(directory, "page.html");
+		const url = "http://localhost:" + server.address().port + "/";
+		const { stderr } = await execFileAsync(process.execPath, [
+			"single-file-node.js", url, outputPath, "--user-agent=" + userAgent
+		], { cwd: cliDirectory });
+		let content;
+		try {
+			content = await readFile(outputPath, "utf8");
+		} catch (error) {
+			throw new Error("missing output file, stderr: " + stderr, { cause: error });
+		}
+		assert.ok(content.includes("header-agent=" + userAgent), "expected the user agent option to be sent, got: " + content.match(/header-agent=[^<]*/));
+	} finally {
+		await rm(directory, { recursive: true });
+		server.close();
+	}
+});

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

@@ -0,0 +1,67 @@
+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, mkdir, readdir, readFile, writeFile, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import process from "node:process";
+
+const execFileAsync = promisify(execFile);
+const cliDirectory = join(dirname(fileURLToPath(import.meta.url)), "..", "..");
+
+test("a browser profile is copied and left unmodified by a capture", { timeout: 120000 }, async () => {
+	const server = createServer((_, response) => response
+		.writeHead(200, { "content-type": "text/html" })
+		.end("<html><head><title>Profile</title></head><body>content</body></html>"));
+	await new Promise(resolve => server.listen(0, "localhost", resolve));
+	const directory = await mkdtemp(join(tmpdir(), "single-file-test-"));
+	try {
+		const profilePath = join(directory, "profile");
+		await mkdir(join(profilePath, "Default"), { recursive: true });
+		await writeFile(join(profilePath, "Default", "Preferences"), "{}");
+		const outputPath = join(directory, "page.html");
+		const url = "http://localhost:" + server.address().port + "/";
+		const { stderr } = await execFileAsync(process.execPath, [
+			"single-file-node.js", url, outputPath,
+			"--browser-profile", profilePath
+		], { cwd: cliDirectory });
+		let content;
+		try {
+			content = await readFile(outputPath, "utf8");
+		} catch (error) {
+			throw new Error("missing output file, stderr: " + stderr, { cause: error });
+		}
+		assert.ok(content.includes("<title>Profile</title>"));
+		assert.deepEqual(await readdir(profilePath), ["Default"]);
+		assert.deepEqual(await readdir(join(profilePath, "Default")), ["Preferences"]);
+		assert.equal(await readFile(join(profilePath, "Default", "Preferences"), "utf8"), "{}");
+	} finally {
+		await rm(directory, { recursive: true });
+		server.close();
+	}
+});
+
+test("a missing browser profile is reported with its path", { timeout: 120000 }, async () => {
+	const directory = await mkdtemp(join(tmpdir(), "single-file-test-"));
+	try {
+		const profilePath = join(directory, "missing");
+		let exitCode = 0;
+		let stderr = "";
+		try {
+			await execFileAsync(process.execPath, [
+				"single-file-node.js", "https://example.com", join(directory, "page.html"),
+				"--browser-profile", profilePath
+			], { cwd: cliDirectory });
+		} catch (error) {
+			exitCode = error.code;
+			stderr = error.stderr;
+		}
+		assert.notEqual(exitCode, 0);
+		assert.ok(stderr.includes(`The browser profile directory was not found at ${JSON.stringify(profilePath)}`));
+	} finally {
+		await rm(directory, { recursive: true });
+	}
+});

package/test/e2e/oopif.test.js

@@ -0,0 +1,86 @@
+/* global URL */
+
+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, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import process from "node:process";
+
+const execFileAsync = promisify(execFile);
+const cliDirectory = join(dirname(fileURLToPath(import.meta.url)), "..", "..");
+const FRAME_MARKER = "OUT_OF_PROCESS_FRAME_CONTENT";
+
+test("blocked URL patterns and extra HTTP headers apply in cross-origin frames", { timeout: 120000 }, async () => {
+	const BLOCKED_STYLE = "rgb(123,45,67)";
+	const GATED_STYLE = "rgb(89,89,89)";
+	const frameServer = createServer((request, response) => {
+		const { pathname } = new URL(request.url, "http://127.0.0.1");
+		if (pathname === "/tracker.css") {
+			response.writeHead(200, { "content-type": "text/css" }).end("h2 { color: " + BLOCKED_STYLE + "; }");
+		} else if (pathname === "/gated.css") {
+			if (request.headers["x-test-header"] === "yes") {
+				response.writeHead(200, { "content-type": "text/css" }).end("h3 { color: " + GATED_STYLE + "; }");
+			} else {
+				response.writeHead(404).end();
+			}
+		} else {
+			response.writeHead(200, { "content-type": "text/html" }).end(
+				"<html><head><link rel=\"stylesheet\" href=\"/tracker.css\"><link rel=\"stylesheet\" href=\"/gated.css\"></head>" +
+				"<body><h2>blocked</h2><h3>gated</h3></body></html>");
+		}
+	});
+	await new Promise(resolve => frameServer.listen(0, "127.0.0.1", resolve));
+	const frameUrl = "http://127.0.0.1:" + frameServer.address().port + "/frame.html";
+	const server = createServer((request, response) => {
+		response.writeHead(200, { "content-type": "text/html" }).end("<html><body><iframe src=\"" + frameUrl + "\"></iframe></body></html>");
+	});
+	await new Promise(resolve => server.listen(0, "localhost", resolve));
+	const directory = await mkdtemp(join(tmpdir(), "single-file-test-"));
+	try {
+		const outputPath = join(directory, "out.html");
+		const url = "http://localhost:" + server.address().port + "/top.html";
+		await execFileAsync(process.execPath, [
+			"single-file-node.js", url, outputPath,
+			"--blocked-URL-pattern", "tracker",
+			"--http-header", "x-test-header=yes"
+		], { cwd: cliDirectory });
+		const content = await readFile(outputPath, "utf8");
+		assert.ok(!content.includes(BLOCKED_STYLE), "a blocked stylesheet leaked into the frame");
+		assert.ok(content.includes(GATED_STYLE), "the extra HTTP header was not sent for a frame resource");
+	} finally {
+		await rm(directory, { recursive: true });
+		server.close();
+		frameServer.close();
+	}
+});
+
+test("cross-origin frames are captured in the saved page", { timeout: 120000 }, async () => {
+	// localhost and 127.0.0.1 are different sites, so site isolation renders
+	// the frame out of process, in a separate CDP target
+	const frameServer = createServer((request, response) => {
+		response.writeHead(200, { "content-type": "text/html" }).end("<html><body><p>" + FRAME_MARKER + "</p></body></html>");
+	});
+	await new Promise(resolve => frameServer.listen(0, "127.0.0.1", resolve));
+	const frameUrl = "http://127.0.0.1:" + frameServer.address().port + "/frame.html";
+	const server = createServer((request, response) => {
+		response.writeHead(200, { "content-type": "text/html" }).end("<html><body><iframe src=\"" + frameUrl + "\"></iframe></body></html>");
+	});
+	await new Promise(resolve => server.listen(0, "localhost", resolve));
+	const directory = await mkdtemp(join(tmpdir(), "single-file-test-"));
+	try {
+		const outputPath = join(directory, "out.html");
+		const url = "http://localhost:" + server.address().port + "/top.html";
+		await execFileAsync(process.execPath, ["single-file-node.js", url, outputPath], { cwd: cliDirectory });
+		const content = await readFile(outputPath, "utf8");
+		assert.ok(content.includes(FRAME_MARKER), "the out-of-process frame was saved empty");
+	} finally {
+		await rm(directory, { recursive: true });
+		server.close();
+		frameServer.close();
+	}
+});

package/test/unit/archive-packager.test.js

@@ -1,7 +1,6 @@
 import { test } from "node:test";
 import assert from "node:assert/strict";
-import { createPagesArchive } from "../../lib/archive-packager.js";
-import { configure, ZipWriter, ZipReader, Uint8ArrayReader, Uint8ArrayWriter, TextReader, TextWriter } from "../../lib/single-file-archive.js";
+import { createPagesArchive, configure, ZipWriter, ZipReader, Uint8ArrayReader, Uint8ArrayWriter, TextReader, TextWriter } from "../../lib/single-file-archive.js";
 
 configure({ useWebWorkers: false });
 

package/test/unit/browser-profile.test.js

@@ -0,0 +1,70 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtemp, mkdir, readdir, readFile, symlink, writeFile, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { copyProfile } from "../../lib/browser.js";
+
+async function createProfileDirectory() {
+	const directory = await mkdtemp(join(tmpdir(), "single-file-test-"));
+	const sourcePath = join(directory, "profile");
+	await mkdir(join(sourcePath, "Default", "Cache"), { recursive: true });
+	await mkdir(join(sourcePath, "Default", "Local Storage"), { recursive: true });
+	await mkdir(join(sourcePath, "GPUCache"), { recursive: true });
+	await writeFile(join(sourcePath, "Local State"), "state");
+	await writeFile(join(sourcePath, "Default", "Cookies"), "cookies");
+	await writeFile(join(sourcePath, "Default", "Cache", "data_0"), "cached");
+	await writeFile(join(sourcePath, "Default", "Local Storage", "leveldb"), "storage");
+	await writeFile(join(sourcePath, "GPUCache", "index"), "cached");
+	await symlink("hostname-1234", join(sourcePath, "SingletonLock"));
+	return { directory, sourcePath, destinationPath: join(directory, "copy") };
+}
+
+test("copying a profile keeps the session data", async () => {
+	const { directory, sourcePath, destinationPath } = await createProfileDirectory();
+	try {
+		await mkdir(destinationPath);
+		await copyProfile(sourcePath, destinationPath);
+		assert.equal(await readFile(join(destinationPath, "Local State"), "utf8"), "state");
+		assert.equal(await readFile(join(destinationPath, "Default", "Cookies"), "utf8"), "cookies");
+		assert.equal(await readFile(join(destinationPath, "Default", "Local Storage", "leveldb"), "utf8"), "storage");
+	} finally {
+		await rm(directory, { recursive: true });
+	}
+});
+
+test("copying a profile skips caches and lock files", async () => {
+	const { directory, sourcePath, destinationPath } = await createProfileDirectory();
+	try {
+		await mkdir(destinationPath);
+		await copyProfile(sourcePath, destinationPath);
+		assert.deepEqual((await readdir(destinationPath)).sort(), ["Default", "Local State"]);
+		assert.deepEqual((await readdir(join(destinationPath, "Default"))).sort(), ["Cookies", "Local Storage"]);
+	} finally {
+		await rm(directory, { recursive: true });
+	}
+});
+
+test("copying a profile leaves the source directory unmodified", async () => {
+	const { directory, sourcePath, destinationPath } = await createProfileDirectory();
+	try {
+		await mkdir(destinationPath);
+		await copyProfile(sourcePath, destinationPath);
+		assert.deepEqual((await readdir(sourcePath)).sort(), ["Default", "GPUCache", "Local State", "SingletonLock"]);
+		assert.deepEqual((await readdir(join(sourcePath, "Default"))).sort(), ["Cache", "Cookies", "Local Storage"]);
+	} finally {
+		await rm(directory, { recursive: true });
+	}
+});
+
+test("copying a missing profile is reported with its path", async () => {
+	const directory = await mkdtemp(join(tmpdir(), "single-file-test-"));
+	try {
+		const missingPath = join(directory, "missing");
+		await assert.rejects(
+			() => copyProfile(missingPath, directory),
+			error => error.message == `The browser profile directory was not found at ${JSON.stringify(missingPath)}`);
+	} finally {
+		await rm(directory, { recursive: true });
+	}
+});

package/test/unit/cli-usage.test.js

@@ -49,6 +49,21 @@ test("a wrong browser executable path is reported with the path", async () => {
 	assert.ok(stderr.includes("The browser executable was not found at \"/nonexistent/chrome\""));
 });
 
+test("creating a browser profile does not require a url", async () => {
+	const { code, stderr } = await runCli(["--create-browser-profile", "/path/to/profile", "--browser-executable-path", "/nonexistent/chrome"]);
+	assert.notEqual(code, 0);
+	assert.equal(stderr.includes("The URL or path of the page to save is required"), false);
+});
+
+test("conflicting browser profile options are reported as errors", async () => {
+	const { code, stderr } = await runCli(["--create-browser-profile", "/path/to/profile", "--browser-profile", "/path/to/other"]);
+	assert.equal(code, 1);
+	assert.ok(stderr.includes("--create-browser-profile cannot be used with --browser-profile"));
+	const remoteResult = await runCli(["https://example.com", "--browser-profile", "/path/to/profile", "--browser-server", "http://localhost:9222"]);
+	assert.equal(remoteResult.code, 1);
+	assert.ok(remoteResult.stderr.includes("--browser-profile cannot be used with --browser-server"));
+});
+
 test("unexpected extra arguments are reported as errors", async () => {
 	const { code, stderr } = await runCli(["https://example.com", "out.html", "extra.html"]);
 	assert.equal(code, 1);