From 49e9424baa74cf27aa91981ed0da3349e6371ab4 Mon Sep 17 00:00:00 2001 From: James Russo Date: Mon, 16 Nov 2026 09:21:04 +0000 Subject: [PATCH] fix(cli): commands that open a composition honor PRODUCER_RESTRICT_PAGE_NETWORK (#7935) * fix(cli): commands that open a composition honor PRODUCER_RESTRICT_PAGE_NETWORK check, snapshot, compare, grade-compare, layout, validate and the motion shot launched Chrome with no page-network restriction, so a composition page could reach loopback, the LAN and link-local addresses even when the caller set PRODUCER_RESTRICT_PAGE_NETWORK=true, as a render honors it. Every composition browser now launches through launchWithPageNetwork. When the flag is on, it starts the engine's public-only capture proxy and profile, the same ones a render uses. The page server is the only direct host, and the proxy and profile live as long as the browser. The prelaunch path, which starts Chrome before the page server exists, is skipped when the network is restricted. A restricted launch without a page URL throws instead of running unrestricted. Co-Authored-By: Claude Opus 5.5 * fix(cli): keep the page-network change inside the package's comment share Co-Authored-By: Claude Opus 5.5 --------- Co-authored-by: Claude Opus 5.5 --- packages/cli/src/browser/pageNetwork.test.ts | 108 ++++++++++++++++++ packages/cli/src/browser/pageNetwork.ts | 40 +++++++ ...mpositionFrame.pageNetwork.browser.test.ts | 92 +++++++++++++++ .../src/capture/captureCompositionFrame.ts | 25 ++-- packages/cli/src/commands/layout.ts | 23 ++-- packages/cli/src/commands/motionShot.ts | 17 ++- packages/cli/src/commands/validate.ts | 17 ++- 7 files changed, 296 insertions(+), 26 deletions(-) create mode 100644 packages/cli/src/browser/pageNetwork.test.ts create mode 100644 packages/cli/src/browser/pageNetwork.ts create mode 100644 packages/cli/src/capture/captureCompositionFrame.pageNetwork.browser.test.ts diff --git a/packages/cli/src/browser/pageNetwork.test.ts b/packages/cli/src/browser/pageNetwork.test.ts new file mode 100644 index 0000000000..2139e3440a --- /dev/null +++ b/packages/cli/src/browser/pageNetwork.test.ts @@ -0,0 +1,108 @@ +import { EventEmitter } from "node:events"; +import { existsSync } from "node:fs"; +import type { Browser } from "puppeteer-core"; +import { afterEach, describe, expect, it } from "vitest"; +import { launchWithPageNetwork, type PageNetworkLaunch } from "./pageNetwork.js"; + +const previous = process.env.PRODUCER_RESTRICT_PAGE_NETWORK; + +afterEach(() => { + if (previous === undefined) delete process.env.PRODUCER_RESTRICT_PAGE_NETWORK; + else process.env.PRODUCER_RESTRICT_PAGE_NETWORK = previous; +}); + +/** A browser double: connected until `disconnect()`, which fires puppeteer's "disconnected" event. */ +function fakeBrowser() { + const events = new EventEmitter(); + const browser = { + connected: true, + once: (event: string, listener: () => void) => events.once(event, listener), + }; + return { + browser: browser as unknown as Browser, + disconnect() { + browser.connected = false; + events.emit("disconnected"); + }, + }; +} + +describe("launchWithPageNetwork", () => { + it("adds nothing when the page network isn't restricted", async () => { + delete process.env.PRODUCER_RESTRICT_PAGE_NETWORK; + let seen: PageNetworkLaunch | undefined; + const { browser } = fakeBrowser(); + await launchWithPageNetwork("http://127.0.0.1:4000/", async (network) => { + seen = network; + return browser; + }); + expect(seen).toEqual({ args: [] }); + }); + + // fails without the fix: layout, validate and the motion shot launched Chrome with no proxy when the page + // network was restricted. + it("routes everything but the page server through a public-only proxy for the browser's life", async () => { + process.env.PRODUCER_RESTRICT_PAGE_NETWORK = "true"; + let seen: PageNetworkLaunch | undefined; + const fake = fakeBrowser(); + await launchWithPageNetwork("http://127.0.0.1:4000/index.html", async (network) => { + seen = network; + return fake.browser; + }); + const proxyArg = seen?.args.find((arg) => arg.startsWith("--proxy-server=")); + expect(proxyArg).toMatch(/^--proxy-server=http:\/\/127\.0\.0\.1:\d+$/); + expect(seen?.args).toContain("--proxy-bypass-list=<-loopback>;127.0.0.1:4000"); + expect(seen?.args).toContain("--force-webrtc-ip-handling-policy=disable_non_proxied_udp"); + expect(seen?.userDataDir && existsSync(seen.userDataDir)).toBe(true); + + const proxyUrl = proxyArg!.slice("--proxy-server=".length); + expect( + await fetch(proxyUrl).then( + () => "open", + () => "closed", + ), + ).toBe("open"); + + fake.disconnect(); + await expect + .poll(() => + fetch(proxyUrl).then( + () => "open", + () => "closed", + ), + ) + .toBe("closed"); + await expect.poll(() => existsSync(seen!.userDataDir!)).toBe(false); + }); + + it("refuses to launch a restricted browser before the page has a URL", async () => { + process.env.PRODUCER_RESTRICT_PAGE_NETWORK = "true"; + let launched = false; + await expect( + launchWithPageNetwork(undefined, async () => { + launched = true; + return fakeBrowser().browser; + }), + ).rejects.toThrow(/needs the page's URL/); + expect(launched).toBe(false); + }); + + it("closes the proxy when the launch fails", async () => { + process.env.PRODUCER_RESTRICT_PAGE_NETWORK = "true"; + let seen: PageNetworkLaunch | undefined; + await expect( + launchWithPageNetwork("http://127.0.0.1:4000/", async (network) => { + seen = network; + throw new Error("chrome failed"); + }), + ).rejects.toThrow("chrome failed"); + const proxyUrl = seen!.args.find((arg) => arg.startsWith("--proxy-server="))!.slice(15); + expect( + await fetch(proxyUrl).then( + () => "open", + () => "closed", + ), + ).toBe("closed"); + expect(existsSync(seen!.userDataDir!)).toBe(false); + }); +}); diff --git a/packages/cli/src/browser/pageNetwork.ts b/packages/cli/src/browser/pageNetwork.ts new file mode 100644 index 0000000000..532582968b --- /dev/null +++ b/packages/cli/src/browser/pageNetwork.ts @@ -0,0 +1,40 @@ +import type { Browser } from "puppeteer-core"; + +export interface PageNetworkLaunch { + args: string[]; + userDataDir?: string; +} + +// With PRODUCER_RESTRICT_PAGE_NETWORK on, a composition page reaches its own server directly and everything else +// only through the engine's public-only proxy, as in a render. If the proxy can't start, the launch fails. +export async function launchWithPageNetwork( + pageUrl: string | undefined, + launch: (network: PageNetworkLaunch) => Promise, +): Promise { + const { resolveRestrictPageNetwork } = await import("@hyperframes/engine"); + if (!resolveRestrictPageNetwork()) return launch({ args: [] }); + if (!pageUrl) + throw new Error("A restricted page network needs the page's URL before Chrome launches."); + const { browserProxyArgs, createPublicOnlyProfile, logRefusal, startCaptureProxy } = + await import("@hyperframes/engine/public-network"); + const { rm } = await import("node:fs/promises"); + const proxy = await startCaptureProxy(null, logRefusal); + let userDataDir: string | undefined; + const release = async () => { + await proxy.close(); + if (userDataDir) await rm(userDataDir, { recursive: true, force: true }).catch(() => {}); + }; + try { + userDataDir = await createPublicOnlyProfile("hf-cli-profile-"); + const browser = await launch({ + args: browserProxyArgs(proxy.url, new URL(pageUrl).host), + userDataDir, + }); + if (browser.connected) browser.once("disconnected", () => void release()); + else await release(); + return browser; + } catch (error) { + await release(); + throw error; + } +} diff --git a/packages/cli/src/capture/captureCompositionFrame.pageNetwork.browser.test.ts b/packages/cli/src/capture/captureCompositionFrame.pageNetwork.browser.test.ts new file mode 100644 index 0000000000..ddb10a134e --- /dev/null +++ b/packages/cli/src/capture/captureCompositionFrame.pageNetwork.browser.test.ts @@ -0,0 +1,92 @@ +import { createServer, type Server } from "node:http"; +import type { AddressInfo } from "node:net"; +import { networkInterfaces } from "node:os"; +import { afterAll, afterEach, beforeAll, expect, it } from "vitest"; +import { openSettledCompositionPage } from "./captureCompositionFrame.js"; + +// A host service the composition page must not reach when the caller restricts the page network. +const hostHits: string[] = []; +let hostService: Server; +let hostPort: number; +let pageServer: Server; +let pageUrl: string; +const previous = process.env.PRODUCER_RESTRICT_PAGE_NETWORK; + +function privateIpv4(): string | undefined { + return Object.values(networkInterfaces()) + .flat() + .find((entry) => entry?.family === "IPv4" && !entry.internal)?.address; +} + +function html(hosts: string[]): string { + return ` +
+`; +} + +beforeAll(async () => { + hostService = createServer((req, res) => { + hostHits.push(`${req.socket.localAddress} ${req.url}`); + res.writeHead(200, { "Access-Control-Allow-Origin": "*" }).end("host service"); + }); + await new Promise((resolve) => hostService.listen(0, "0.0.0.0", resolve)); + hostPort = (hostService.address() as AddressInfo).port; + pageServer = createServer((req, res) => { + if (req.url === "/own.txt") return void res.end("own asset"); + const hosts = ["127.0.0.1", privateIpv4()].filter((host): host is string => Boolean(host)); + res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" }).end(html(hosts)); + }); + await new Promise((resolve) => pageServer.listen(0, "127.0.0.1", resolve)); + pageUrl = `http://127.0.0.1:${(pageServer.address() as AddressInfo).port}/`; +}); + +afterEach(() => { + if (previous === undefined) delete process.env.PRODUCER_RESTRICT_PAGE_NETWORK; + else process.env.PRODUCER_RESTRICT_PAGE_NETWORK = previous; +}); + +afterAll(() => { + for (const server of [hostService, pageServer]) { + server.closeAllConnections(); + server.close(); + } +}); + +// fails without the fix: with PRODUCER_RESTRICT_PAGE_NETWORK=true, the page check, snapshot and compare open +// still fetched and loaded images from loopback and the private IP, and the host service saw every request. +it("keeps a composition page off loopback and private hosts when the page network is restricted", async () => { + process.env.PRODUCER_RESTRICT_PAGE_NETWORK = "true"; + hostHits.length = 0; + const { browser, page } = await openSettledCompositionPage( + await (await fetch(pageUrl)).text(), + pageUrl, + { renderReadyTimeoutMs: 5_000, renderReadyWarningSuffix: "test", browserGpuMode: "software" }, + ); + try { + const [own, ...others] = await page.evaluate( + () => (window as unknown as { __probe: Promise }).__probe, + ); + expect(own).toBe("own asset"); + expect(others.length).toBeGreaterThanOrEqual(2); + expect(others).toEqual(others.map(() => "refused")); + expect(hostHits).toEqual([]); + } finally { + await browser.close(); + } +}, 90_000); diff --git a/packages/cli/src/capture/captureCompositionFrame.ts b/packages/cli/src/capture/captureCompositionFrame.ts index 048bfa6da8..4ca69dc254 100644 --- a/packages/cli/src/capture/captureCompositionFrame.ts +++ b/packages/cli/src/capture/captureCompositionFrame.ts @@ -1,4 +1,4 @@ -import { oneProcessOverPipe } from "@hyperframes/engine"; +import { oneProcessOverPipe, resolveRestrictPageNetwork } from "@hyperframes/engine"; import { SEEK_SETTLES_BEFORE_PROTOCOL_TIMEOUT_MS } from "./captureTimeout.js"; import { rethrowAfterBrowserCleanup, @@ -16,6 +16,7 @@ import { resolveLocalWebGpu, type BrowserGpuMode, } from "../browser/gpuPolicy.js"; +import { launchWithPageNetwork } from "../browser/pageNetwork.js"; import { windowsChromeCrashRemediation } from "../browser/windowsCrash.js"; import { resolveCompositionViewportFromHtml } from "../utils/compositionViewport.js"; import { normalizeErrorMessage } from "../utils/errorMessage.js"; @@ -161,7 +162,10 @@ export function prelaunchCompositionBrowser( const abort = new AbortController(); const options = { browserGpuMode, signal: abort.signal }; const key = launchKey(html, false, options); - const launched = launchCompositionBrowser(html, false, options).catch(() => undefined); + const launchNeedsPageUrl = resolveRestrictPageNetwork(); + const launched = launchNeedsPageUrl + ? Promise.resolve(undefined) + : launchCompositionBrowser(html, false, options).catch(() => undefined); let taken = false; const discard = async () => { if (taken) return; @@ -332,7 +336,7 @@ export async function openSettledCompositionPage( try { const launched = (await options.prelaunched?.take(launchKey(html, noListen, options))) ?? - (await launchCompositionBrowser(html, noListen, options)); + (await launchCompositionBrowser(html, noListen, options, url)); chromeBrowser = launched.browser; const softwareWebGpu = launched.softwareWebGpu; options.onBrowser?.(chromeBrowser); @@ -361,6 +365,7 @@ async function launchCompositionBrowser( html: string, noListen: boolean, options: LaunchOptions, + pageUrl?: string, ): Promise { const viewport = resolveCompositionViewportFromHtml(html); const { ensureBrowser, findSystemBrowser } = await import("../browser/manager.js"); @@ -384,11 +389,15 @@ async function launchCompositionBrowser( { ...viewport, captureMode: "screenshot", requiresWebGpu }, webGpu.gpuConfig, ); - return launchManagedBrowser(puppeteer.default, { - headless: true, - signal: options.signal, - executablePath, - ...(noListen ? oneProcessOverPipe({ args }) : { args }), + return launchWithPageNetwork(pageUrl, (network) => { + const allArgs = [...args, ...network.args]; + return launchManagedBrowser(puppeteer.default, { + headless: true, + signal: options.signal, + executablePath, + userDataDir: network.userDataDir, + ...(noListen ? oneProcessOverPipe({ args: allArgs }) : { args: allArgs }), + }); }); }; diff --git a/packages/cli/src/commands/layout.ts b/packages/cli/src/commands/layout.ts index fbfb63b2fc..de47b2c99d 100644 --- a/packages/cli/src/commands/layout.ts +++ b/packages/cli/src/commands/layout.ts @@ -1,4 +1,5 @@ import { launchManagedBrowser, resolveManagedGpuMode } from "../browser/launch.js"; +import { launchWithPageNetwork } from "../browser/pageNetwork.js"; import { failCommand, setCommandExitCode } from "../utils/commandResult.js"; import { defineCommand } from "../utils/defineCommand.js"; import { existsSync, readFileSync } from "node:fs"; @@ -223,14 +224,20 @@ async function runLayoutAudit( const resolvedGpuMode = await resolveManagedGpuMode(requestedGpuMode, browser.executablePath); const requiresWebGpu = compositionRequiresWebGpu(html); const { gpuConfig, softwareWebGpu } = resolveLocalWebGpu(resolvedGpuMode, requiresWebGpu); - chromeBrowser = await launchManagedBrowser(puppeteer.default, { - headless: true, - executablePath: browser.executablePath, - args: buildChromeArgs( - { width: 1920, height: 1080, captureMode: "screenshot", requiresWebGpu }, - gpuConfig, - ), - }); + chromeBrowser = await launchWithPageNetwork(server.url, (network) => + launchManagedBrowser(puppeteer.default, { + headless: true, + executablePath: browser.executablePath, + userDataDir: network.userDataDir, + args: [ + ...buildChromeArgs( + { width: 1920, height: 1080, captureMode: "screenshot", requiresWebGpu }, + gpuConfig, + ), + ...network.args, + ], + }), + ); const page = await chromeBrowser.newPage(); await installPageFunctionGuard(page); diff --git a/packages/cli/src/commands/motionShot.ts b/packages/cli/src/commands/motionShot.ts index 5ffb7d3c79..7107969ca8 100644 --- a/packages/cli/src/commands/motionShot.ts +++ b/packages/cli/src/commands/motionShot.ts @@ -1,4 +1,5 @@ import { launchManagedBrowser, resolveManagedGpuMode } from "../browser/launch.js"; +import { launchWithPageNetwork } from "../browser/pageNetwork.js"; // Onion-skin motion screenshot: seek the LIVE timeline at N equal-time steps and // project the REAL element at each step, so an agent can SELF-VERIFY motion (the // rendered result — every channel: position, rotation, scale, opacity, colour), @@ -420,11 +421,17 @@ async function openCompositionPage( const resolvedGpuMode = await resolveManagedGpuMode(requestedGpuMode, executablePath); const requiresWebGpu = compositionRequiresWebGpu(html); const { gpuConfig, softwareWebGpu } = resolveLocalWebGpu(resolvedGpuMode, requiresWebGpu); - const browser = await launchManagedBrowser(puppeteer.default, { - headless: true, - executablePath, - args: buildChromeArgs({ ...size, captureMode: "screenshot", requiresWebGpu }, gpuConfig), - }); + const browser = await launchWithPageNetwork(url, (network) => + launchManagedBrowser(puppeteer.default, { + headless: true, + executablePath, + userDataDir: network.userDataDir, + args: [ + ...buildChromeArgs({ ...size, captureMode: "screenshot", requiresWebGpu }, gpuConfig), + ...network.args, + ], + }), + ); try { const page = await browser.newPage(); await page.setViewport(size); diff --git a/packages/cli/src/commands/validate.ts b/packages/cli/src/commands/validate.ts index 21afa80b3b..98ff0fc0c7 100644 --- a/packages/cli/src/commands/validate.ts +++ b/packages/cli/src/commands/validate.ts @@ -1,4 +1,5 @@ import { launchManagedBrowser, resolveManagedGpuMode } from "../browser/launch.js"; +import { launchWithPageNetwork } from "../browser/pageNetwork.js"; // The media-metadata wait exists twice on purpose: once Node-side and once // inside a page.evaluate() body, which is serialized into the browser and // cannot import the Node helper. Line-level markers don't survive the clone @@ -456,11 +457,17 @@ async function validateInBrowser( const resolvedGpuMode = await resolveManagedGpuMode(requestedGpuMode, browser.executablePath); const requiresWebGpu = compositionRequiresWebGpu(html); const { gpuConfig, softwareWebGpu } = resolveLocalWebGpu(resolvedGpuMode, requiresWebGpu); - const chromeBrowser = await launchManagedBrowser(puppeteer.default, { - headless: true, - executablePath: browser.executablePath, - args: buildChromeArgs({ ...viewport, captureMode: "screenshot", requiresWebGpu }, gpuConfig), - }); + const chromeBrowser = await launchWithPageNetwork(server.url, (network) => + launchManagedBrowser(puppeteer.default, { + headless: true, + executablePath: browser.executablePath, + userDataDir: network.userDataDir, + args: [ + ...buildChromeArgs({ ...viewport, captureMode: "screenshot", requiresWebGpu }, gpuConfig), + ...network.args, + ], + }), + ); try { const page = await chromeBrowser.newPage();