Files
hyperframes/packages/aws-lambda/scripts/build-zip.test.ts
T
James RussoandClaude Opus 5.5 ed3f05a05b fix(aws-lambda): pin the shell ZIP route, gate ZIP headroom, match arm64 fonts to x86 (#8170)
- build-zip --source=chrome-headless-shell stages only the repo's pinned
  build (managedChromeVersion) and only when its folder matches the pinned
  digest (isPinnedHeadlessShell), instead of the newest folder in the cache.
  The folder cannot fit a ZIP function, so lambda deploy refuses
  --chrome-source chrome-headless-shell up front on either arch, and the
  docs say the arm64 video image is where the shell runs.
- build-zip prints the headroom under the unzipped gate, and a new
  "Lambda handler ZIP" workflow builds the ZIP on PRs that touch the code
  it bundles, so growth fails before merge rather than in the release job.
- The arm64 image keeps @sparticuz/chromium's fonts and fonts.conf from the
  handler ZIP (FONTCONFIG_PATH=/var/task/fonts) instead of liberation-fonts,
  so text falls back to the same fonts as on x86. The image workflow renders
  a mixed-script page on both arches and fails when any line resolves to
  different platform fonts.

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-18 10:21:01 +00:00

175 lines
7.0 KiB
TypeScript

import { describe, expect, it } from "bun:test";
import { spawnSync } from "node:child_process";
import {
existsSync,
mkdirSync,
mkdtempSync,
readFileSync,
rmSync,
statSync,
writeFileSync,
} from "node:fs";
import { tmpdir } from "node:os";
import { dirname, join } from "node:path";
import { pathToFileURL } from "node:url";
import { managedChromeVersion } from "@hyperframes/engine/chrome-host-ceiling";
import * as esbuild from "esbuild";
import { BUNDLED_SHELL_DIR, BUNDLED_SHELL_PATH } from "../src/chromium.js";
import { stageChromeHeadlessShell } from "./_chromeHeadlessShell.js";
import { HANDLER_BANNER } from "./_handlerBanner.js";
// The handler ships as ESM (.mjs) but inlines CJS deps that assume Node's CJS
// globals exist at module scope: postcss et al. call top-level `require(...)`,
// and wawoff2's emscripten build reads `__dirname`. A freshly deployed stack
// crashed on every render (#1932) with "__dirname is not defined in ES module
// scope"; the fix is the require/__filename/__dirname shim in HANDLER_BANNER.
//
// This bundles a fixture touching all three globals with the REAL banner and
// imports the output, so it catches a dropped/renamed shim behaviourally
// rather than by grepping for literals (which survives a broken refactor).
//
// The import MUST run under Node, not the `bun test` runtime: Bun defines
// `__dirname`/`__filename` even in ESM, which would mask a missing shim and
// green-light a broken bundle. Lambda runs Node, so we spawn `node` (guaranteed
// present in CI alongside bun) to reproduce the deploy target faithfully.
describe("build-zip handler banner", () => {
it("shims require/__filename/__dirname so inlined CJS deps import under Node", () => {
const dir = mkdtempSync(join(tmpdir(), "hf-banner-test-"));
try {
const entry = join(dir, "fixture.ts");
const outfile = join(dir, "out.mjs");
// Reference each CJS global at module top level, the way inlined deps do.
// If any shim is missing, importing `out.mjs` throws at eval time.
writeFileSync(
entry,
[
"const cjsDir = __dirname;",
"const cjsFile = __filename;",
"const path = require('node:path');",
"if (typeof cjsDir !== 'string') throw new Error('__dirname missing');",
"if (typeof cjsFile !== 'string') throw new Error('__filename missing');",
"if (typeof path.join !== 'function') throw new Error('require missing');",
"console.log('BANNER_OK');",
].join("\n"),
);
esbuild.buildSync({
bundle: true,
platform: "node",
target: "node22",
format: "esm",
entryPoints: [entry],
outfile,
banner: { js: HANDLER_BANNER },
});
// Import under real Node — Lambda's runtime — not the bun test runtime.
const res = spawnSync(
"node",
[
"--input-type=module",
"-e",
`await import(${JSON.stringify(pathToFileURL(outfile).href)});`,
],
{ encoding: "utf8" },
);
// A missing shim surfaces as a non-zero exit + ReferenceError on stderr.
// Guard against a silent skip if `node` isn't on PATH (it is in CI).
expect(res.error).toBeUndefined();
expect(res.stderr).not.toContain("is not defined in ES module scope");
expect(res.stderr).not.toContain("Dynamic require");
expect(res.status).toBe(0);
expect(res.stdout).toContain("BANNER_OK");
} finally {
rmSync(dir, { recursive: true, force: true });
}
});
});
describe("build-zip chrome-headless-shell staging", () => {
// @puppeteer/browsers' layout: chrome-headless-shell/linux-<version>/chrome-headless-shell-linux64/.
function puppeteerCache(versions: Record<string, Record<string, string>>): string {
const home = mkdtempSync(join(tmpdir(), "hf-shell-cache-"));
for (const [version, files] of Object.entries(versions)) {
const folder = join(home, ".cache/puppeteer/chrome-headless-shell", `linux-${version}`);
for (const [path, body] of Object.entries(files)) {
const file = join(folder, "chrome-headless-shell-linux64", path);
mkdirSync(dirname(file), { recursive: true });
writeFileSync(file, body, { mode: path === "chrome-headless-shell" ? 0o755 : 0o644 });
}
}
return home;
}
const pinned = managedChromeVersion("linux");
it("stages the whole pinned shell folder where the template and the CDK stack point", () => {
const home = puppeteerCache({
"999.0.0.1": { "chrome-headless-shell": "newer" },
[pinned]: {
"chrome-headless-shell": "exe",
"icudtl.dat": "icu",
"headless_lib_data.pak": "pak",
"locales/en-US.pak": "locale",
},
});
const staging = mkdtempSync(join(tmpdir(), "hf-shell-staging-"));
const checked: string[] = [];
try {
const isPinned = (exe: string) => checked.push(exe) > 0;
expect(stageChromeHeadlessShell(staging, home, isPinned)).toBe(pinned);
expect(checked).toEqual([
join(
home,
".cache/puppeteer/chrome-headless-shell",
`linux-${pinned}`,
"chrome-headless-shell-linux64",
"chrome-headless-shell",
),
]);
const shell = join(staging, BUNDLED_SHELL_DIR);
// Without icudtl.dat beside it the shell exits at launch, so the folder ships whole.
expect(readFileSync(join(shell, "icudtl.dat"), "utf-8")).toBe("icu");
expect(readFileSync(join(shell, "headless_lib_data.pak"), "utf-8")).toBe("pak");
expect(readFileSync(join(shell, "locales/en-US.pak"), "utf-8")).toBe("locale");
expect(readFileSync(join(shell, "chrome-headless-shell"), "utf-8")).toBe("exe");
expect(statSync(join(shell, "chrome-headless-shell")).mode & 0o111).not.toBe(0);
expect(join("/var/task", BUNDLED_SHELL_DIR, "chrome-headless-shell")).toBe(
BUNDLED_SHELL_PATH,
);
} finally {
rmSync(home, { recursive: true, force: true });
rmSync(staging, { recursive: true, force: true });
}
});
it("refuses a cached folder that does not match the pinned digest", () => {
const home = puppeteerCache({
[pinned]: { "chrome-headless-shell": "tampered" },
});
const staging = mkdtempSync(join(tmpdir(), "hf-shell-staging-"));
try {
expect(() => stageChromeHeadlessShell(staging, home)).toThrow(/does not match the pinned/);
expect(existsSync(join(staging, BUNDLED_SHELL_DIR))).toBe(false);
} finally {
rmSync(home, { recursive: true, force: true });
rmSync(staging, { recursive: true, force: true });
}
});
it("names the pinned install command when only another version is cached", () => {
const home = puppeteerCache({
"999.0.0.1": { "chrome-headless-shell": "newer" },
});
try {
expect(() => stageChromeHeadlessShell(home, home)).toThrow(
new RegExp(
`@puppeteer/browsers install chrome-headless-shell@${pinned.replaceAll(".", "\\.")} `,
),
);
} finally {
rmSync(home, { recursive: true, force: true });
}
});
});