Add Playwright CDN support for arm64 Linux in chrome-for-testing

Author: cderv

src/tools/impl/chrome-for-testing.ts

@@ -18,6 +18,7 @@ import { InstallContext } from "../types.ts";
 /** CfT platform identifiers matching the Google Chrome for Testing API. */
 export type CftPlatform =
   | "linux64"
+  | "linux-arm64"
   | "mac-arm64"
   | "mac-x64"
   | "win32"
@@ -37,6 +38,7 @@ export interface PlatformInfo {
 export function detectCftPlatform(): PlatformInfo {
   const platformMap: Record<string, CftPlatform> = {
     "linux-x86_64": "linux64",
+    "linux-aarch64": "linux-arm64",
     "darwin-aarch64": "mac-arm64",
     "darwin-x86_64": "mac-x64",
     "windows-x86_64": "win64",
@@ -47,14 +49,8 @@ export function detectCftPlatform(): PlatformInfo {
   const platform = platformMap[key];
 
   if (!platform) {
-    if (os === "linux" && arch === "aarch64") {
-      throw new Error(
-        "linux-arm64 is not supported by Chrome for Testing. " +
-          "Use 'quarto install chromium' for arm64 support.",
-      );
-    }
     throw new Error(
-      `Unsupported platform for Chrome for Testing: ${os} ${arch}`,
+      `Unsupported platform for chrome-headless-shell: ${os} ${arch}`,
     );
   }
 
@@ -122,6 +118,79 @@ export async function fetchLatestCftRelease(): Promise<CftStableRelease> {
   };
 }
 
+/** Parsed entry from Playwright's browsers.json for chromium-headless-shell. */
+export interface PlaywrightBrowserEntry {
+  revision: string;
+  browserVersion: string;
+}
+
+const kPlaywrightBrowsersJsonUrl =
+  "https://raw.githubusercontent.com/microsoft/playwright/main/packages/playwright-core/browsers.json";
+
+/** Check if the current platform requires Playwright CDN (arm64 Linux). */
+export function isPlaywrightCdnPlatform(info?: PlatformInfo): boolean {
+  const p = info ?? detectCftPlatform();
+  return p.platform === "linux-arm64";
+}
+
+/**
+ * Fetch Playwright's browsers.json and extract the chromium-headless-shell entry.
+ * Used as the version/revision source for arm64 Linux where CfT has no builds.
+ */
+export async function fetchPlaywrightBrowsersJson(): Promise<PlaywrightBrowserEntry> {
+  let response: Response;
+  const fallbackHint = "\nIf this persists, install a system Chrome/Chromium instead " +
+    "(Quarto will detect it automatically).";
+  try {
+    response = await fetch(kPlaywrightBrowsersJsonUrl);
+  } catch (e) {
+    throw new Error(
+      `Failed to fetch Playwright browsers.json: ${
+        e instanceof Error ? e.message : String(e)
+      }${fallbackHint}`,
+    );
+  }
+
+  if (!response.ok) {
+    throw new Error(
+      `Playwright browsers.json returned ${response.status}: ${response.statusText}${fallbackHint}`,
+    );
+  }
+
+  // deno-lint-ignore no-explicit-any
+  let data: any;
+  try {
+    data = await response.json();
+  } catch {
+    throw new Error("Playwright browsers.json returned invalid JSON");
+  }
+
+  const browsers = data?.browsers;
+  if (!Array.isArray(browsers)) {
+    throw new Error("Playwright browsers.json missing 'browsers' array");
+  }
+
+  // deno-lint-ignore no-explicit-any
+  const entry = browsers.find((b: any) => b.name === "chromium-headless-shell");
+  if (!entry || !entry.revision || !entry.browserVersion) {
+    throw new Error(
+      "Playwright browsers.json has no 'chromium-headless-shell' entry with revision and browserVersion",
+    );
+  }
+
+  return {
+    revision: entry.revision,
+    browserVersion: entry.browserVersion,
+  };
+}
+
+/**
+ * Construct the Playwright CDN download URL for chrome-headless-shell on linux arm64.
+ */
+export function playwrightCdnDownloadUrl(revision: string): string {
+  return `https://cdn.playwright.dev/builds/chromium/${revision}/chromium-headless-shell-linux-arm64.zip`;
+}
+
 /**
  * Find a named executable inside an extracted CfT directory.
  * Handles platform-specific naming (.exe on Windows) and nested directory structures.

tests/unit/tools/chrome-for-testing.test.ts

@@ -22,7 +22,7 @@ import {
 // Step 1: detectCftPlatform()
 unitTest("detectCftPlatform - returns valid CftPlatform for current system", async () => {
   const result = detectCftPlatform();
-  const validPlatforms = ["linux64", "mac-arm64", "mac-x64", "win32", "win64"];
+  const validPlatforms = ["linux64", "linux-arm64", "mac-arm64", "mac-x64", "win32", "win64"];
   assert(
     validPlatforms.includes(result.platform),
     `Expected one of ${validPlatforms.join(", ")}, got: ${result.platform}`,
@@ -172,3 +172,67 @@ unitTest(
     ignore: runningInCI(),
   },
 );
+
+// -- Playwright CDN tests (arm64 Linux support) --
+
+import {
+  isPlaywrightCdnPlatform,
+  playwrightCdnDownloadUrl,
+  fetchPlaywrightBrowsersJson,
+} from "../../../src/tools/impl/chrome-for-testing.ts";
+
+// isPlaywrightCdnPlatform — pure logic, runs everywhere
+unitTest("isPlaywrightCdnPlatform - returns false on non-arm64 platform", async () => {
+  if (os === "linux" && arch === "aarch64") return; // Skip on actual arm64
+  const result = isPlaywrightCdnPlatform();
+  assertEquals(result, false);
+});
+
+// playwrightCdnDownloadUrl — pure function, no HTTP
+unitTest("playwrightCdnDownloadUrl - constructs correct arm64 URL", async () => {
+  const url = playwrightCdnDownloadUrl("1219");
+  assert(
+    url.startsWith("https://cdn.playwright.dev/"),
+    `URL should start with cdn.playwright.dev, got: ${url}`,
+  );
+  assert(
+    url.includes("/builds/chromium/1219/"),
+    `URL should contain revision path, got: ${url}`,
+  );
+  assert(
+    url.endsWith("chromium-headless-shell-linux-arm64.zip"),
+    `URL should end with arm64 zip name, got: ${url}`,
+  );
+});
+
+// fetchPlaywrightBrowsersJson — external HTTP, skip on CI
+unitTest("fetchPlaywrightBrowsersJson - returns chromium-headless-shell entry", async () => {
+  const entry = await fetchPlaywrightBrowsersJson();
+  assert(entry.revision, "revision should be non-empty");
+  assert(
+    /^\d+$/.test(entry.revision),
+    `revision should be numeric, got: ${entry.revision}`,
+  );
+  assert(entry.browserVersion, "browserVersion should be non-empty");
+  assert(
+    /^\d+\.\d+\.\d+\.\d+$/.test(entry.browserVersion),
+    `browserVersion format wrong: ${entry.browserVersion}`,
+  );
+}, { ignore: runningInCI() });
+
+// findCftExecutable with Playwright arm64 layout (chrome-linux/headless_shell)
+unitTest("findCftExecutable - finds binary in Playwright arm64 layout", async () => {
+  if (isWindows) return; // arm64 layout is Linux-only, no .exe
+  const tempDir = Deno.makeTempDirSync();
+  try {
+    const subdir = join(tempDir, "chrome-linux");
+    Deno.mkdirSync(subdir);
+    Deno.writeTextFileSync(join(subdir, "headless_shell"), "fake binary");
+
+    const found = findCftExecutable(tempDir, "headless_shell");
+    assert(found !== undefined, "should find headless_shell in chrome-linux/");
+    assert(found!.endsWith("headless_shell"), `should end with headless_shell, got: ${found}`);
+  } finally {
+    safeRemoveSync(tempDir, { recursive: true });
+  }
+});