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();