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 <noreply@anthropic.com>

* fix(cli): keep the page-network change inside the package's comment share

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
James Russo
2026-11-16 09:21:04 +00:00
committed by GitHub
co-authored by Claude Opus 5.5
parent ead110aab9
commit 49e9424baa
7 changed files with 296 additions and 26 deletions
@@ -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);
});
});
+40
View File
@@ -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<Browser>,
): Promise<Browser> {
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;
}
}
@@ -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 `<!doctype html><html><body>
<div id="root" data-composition-id="main" data-width="320" data-height="180" data-duration="1"></div>
<script>
const read = (url) => fetch(url).then((response) => response.text(), () => "refused");
const load = (url) => new Promise((done) => {
const image = new Image();
image.onload = () => done("loaded");
image.onerror = () => done("refused");
image.src = url;
});
window.__probe = Promise.all([
read("/own.txt"),
...${JSON.stringify(hosts)}.flatMap((host) => [
read("http://" + host + ":${hostPort}/fetch"),
load("http://" + host + ":${hostPort}/img"),
]),
]);
window.__renderReady = true;
</script></body></html>`;
}
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<void>((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<void>((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<string[]> }).__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);
@@ -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<LaunchedBrowser> {
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 }),
});
});
};
+15 -8
View File
@@ -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);
+12 -5
View File
@@ -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);
+12 -5
View File
@@ -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();