Skip to content

Commit 71595dd

Browse files
fix(cli): check and snapshot run where a sandbox refuses to listen on localhost (#5618)
1 parent b14a456 commit 71595dd

4 files changed

Lines changed: 266 additions & 7 deletions

File tree

‎packages/cli/src/capture/captureCompositionFrame.browserFallback.test.ts‎

Lines changed: 74 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -5,7 +5,7 @@ const mocks = vi.hoisted(() => ({
55
ensureBrowser: vi.fn(),
66
findSystemBrowser: vi.fn(),
77
launch: vi.fn(),
8-
buildChromeArgs: vi.fn(() => []),
8+
buildChromeArgs: vi.fn((): string[] => []),
99
resolveBrowserGpuMode: vi.fn(async () => "software" as const),
1010
compositionRequiresWebGpu: vi.fn(() => false),
1111
assertWebGpuAdapterAvailable: vi.fn(async () => undefined),
@@ -33,6 +33,11 @@ vi.mock("@hyperframes/engine", () => ({
3333
}));
3434

3535
import { openSettledCompositionPage } from "./captureCompositionFrame.js";
36+
import { Server } from "node:http";
37+
import { mkdtempSync, rmSync } from "node:fs";
38+
import { tmpdir } from "node:os";
39+
import { join } from "node:path";
40+
import { serveStaticProjectHtml } from "../utils/staticProjectServer.js";
3641

3742
const HTML = '<div data-composition-id="main" data-width="1920" data-height="1080"></div>';
3843
const OPTIONS = {
@@ -54,6 +59,8 @@ function fakeBrowser() {
5459
goto: vi.fn(async () => undefined),
5560
waitForFunction: vi.fn(async () => undefined),
5661
evaluate: vi.fn(async () => undefined),
62+
setRequestInterception: vi.fn(async (_on: boolean) => undefined),
63+
on: vi.fn((_event: string, _handler: (request: unknown) => void) => undefined),
5764
};
5865
return {
5966
browser: {
@@ -178,3 +185,69 @@ describe("openSettledCompositionPage Windows bundled-browser recovery", () => {
178185
expect(mocks.launch).toHaveBeenCalledOnce();
179186
});
180187
});
188+
189+
describe("openSettledCompositionPage when nothing may listen", () => {
190+
const launched = () =>
191+
mocks.launch.mock.calls.at(-1)?.[0] as unknown as { pipe?: boolean; args: string[] };
192+
193+
beforeEach(() => {
194+
vi.resetAllMocks();
195+
mocks.ensureBrowser.mockResolvedValue({ executablePath: BUNDLED, source: "cache" });
196+
mocks.buildChromeArgs.mockReturnValue(["--headless"]);
197+
mocks.resolveBrowserGpuMode.mockResolvedValue("software");
198+
mocks.resolveConfig.mockReturnValue({ allowSoftwareWebGpu: false });
199+
mocks.usesSoftwareWebGpu.mockReturnValue(false);
200+
});
201+
202+
afterEach(() => vi.restoreAllMocks());
203+
204+
it("drives Chrome over a pipe in one process and answers the page from the project", async () => {
205+
vi.spyOn(Server.prototype, "listen").mockImplementation(function (this: Server) {
206+
process.nextTick(() =>
207+
this.emit("error", Object.assign(new Error("listen EPERM"), { code: "EPERM" })),
208+
);
209+
return this;
210+
});
211+
const dir = mkdtempSync(join(tmpdir(), "hf-nolisten-"));
212+
const server = await serveStaticProjectHtml(dir, "<html><body>composition</body></html>");
213+
const opened = fakeBrowser();
214+
mocks.launch.mockResolvedValue(opened.browser);
215+
try {
216+
await openSettledCompositionPage(HTML, server.url, OPTIONS);
217+
218+
expect(launched().pipe).toBe(true);
219+
expect(launched().args).toEqual(["--headless", "--single-process"]);
220+
expect(opened.page.setRequestInterception).toHaveBeenCalledWith(true);
221+
const onRequest = opened.page.on.mock.calls.find(([event]) => event === "request")![1];
222+
const respond = vi.fn(async (_response: { status: number; body: Buffer }) => undefined);
223+
const proceed = vi.fn(async () => undefined);
224+
const request = (url: string) => ({
225+
url: () => url,
226+
method: () => "GET",
227+
headers: () => ({}),
228+
isInterceptResolutionHandled: () => false,
229+
respond,
230+
continue: proceed,
231+
abort: vi.fn(async () => undefined),
232+
});
233+
onRequest(request(`${server.url}index.html`));
234+
await vi.waitFor(() => expect(respond).toHaveBeenCalledOnce());
235+
expect(respond.mock.calls[0]![0]).toMatchObject({ status: 200 });
236+
expect(String(respond.mock.calls[0]![0].body)).toContain("composition");
237+
onRequest(request("https://cdn.example/gsap.js"));
238+
expect(proceed).toHaveBeenCalledOnce();
239+
} finally {
240+
await server.close();
241+
rmSync(dir, { recursive: true, force: true });
242+
}
243+
});
244+
245+
it("keeps the usual launch for a project served on a port", async () => {
246+
const opened = fakeBrowser();
247+
mocks.launch.mockResolvedValue(opened.browser);
248+
await openSettledCompositionPage(HTML, "http://127.0.0.1:3000", OPTIONS);
249+
expect(launched().pipe).toBeUndefined();
250+
expect(launched().args).toEqual(["--headless"]);
251+
expect(opened.page.setRequestInterception).not.toHaveBeenCalled();
252+
});
253+
});

‎packages/cli/src/capture/captureCompositionFrame.ts‎

Lines changed: 31 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -5,6 +5,7 @@ import {
55
} from "../browser/launch.js";
66
import { spawn } from "node:child_process";
77
import type { Browser, Page } from "puppeteer-core";
8+
import type { InProcessRequest, InProcessResponse } from "../utils/staticProjectServer.js";
89
import { c } from "../ui/colors.js";
910
import {
1011
assertWebGpuAdapterAvailable,
@@ -201,6 +202,8 @@ export async function openSettledCompositionPage(
201202
const puppeteer = await import("puppeteer-core");
202203
const { buildChromeArgs } = await import("@hyperframes/engine");
203204
const requestedGpuMode = options.browserGpuMode ?? resolveCliChromeGpuMode();
205+
// Nothing may listen (a sandbox refused it): DevTools over a pipe, one process, pages answered in-process.
206+
const answer = (await import("../utils/staticProjectServer.js")).inProcessAnswer(url);
204207
const requiresWebGpu = compositionRequiresWebGpu(html);
205208
let softwareWebGpu = false;
206209
const launch = async (executablePath: string): Promise<Browser> => {
@@ -212,14 +215,15 @@ export async function openSettledCompositionPage(
212215
options.signal?.throwIfAborted();
213216
const webGpu = resolveLocalWebGpu(resolvedGpuMode, requiresWebGpu);
214217
softwareWebGpu = webGpu.softwareWebGpu;
218+
const args = buildChromeArgs(
219+
{ ...viewport, captureMode: "screenshot", requiresWebGpu },
220+
webGpu.gpuConfig,
221+
);
215222
return launchManagedBrowser(puppeteer.default, {
216223
headless: true,
217224
signal: options.signal,
218225
executablePath,
219-
args: buildChromeArgs(
220-
{ ...viewport, captureMode: "screenshot", requiresWebGpu },
221-
webGpu.gpuConfig,
222-
),
226+
...(answer ? { pipe: true, args: [...args, "--single-process"] } : { args }),
223227
});
224228
};
225229

@@ -258,6 +262,7 @@ export async function openSettledCompositionPage(
258262
const page = await chromeBrowser.newPage();
259263
await installPageFunctionGuard(page);
260264
await page.setViewport(viewport);
265+
if (answer) await answerPageInProcess(page, url, answer);
261266
await options.beforeNavigate?.(page);
262267
await page.goto(url, {
263268
waitUntil: "domcontentloaded",
@@ -598,3 +603,25 @@ export async function runFfmpegOnce(
598603
});
599604
});
600605
}
606+
607+
/** Requests to the in-process origin are answered here; any other request goes on as usual. */
608+
async function answerPageInProcess(
609+
page: Page,
610+
url: string,
611+
answer: (request: InProcessRequest) => Promise<InProcessResponse>,
612+
): Promise<void> {
613+
const origin = new URL(url).origin;
614+
await page.setRequestInterception(true);
615+
page.on("request", (request) => {
616+
if (request.isInterceptResolutionHandled()) return;
617+
const target = new URL(request.url());
618+
if (target.origin !== origin) return void request.continue().catch(() => {});
619+
answer({
620+
method: request.method(),
621+
path: target.pathname + target.search,
622+
headers: request.headers(),
623+
})
624+
.then((response) => request.respond(response))
625+
.catch(() => request.abort("failed").catch(() => {}));
626+
});
627+
}

‎packages/cli/src/utils/staticProjectServer.test.ts‎

Lines changed: 56 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -2,7 +2,12 @@ import { afterEach, describe, expect, it, vi } from "vitest";
22
import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
33
import { tmpdir } from "node:os";
44
import { join } from "node:path";
5-
import { serveStaticProjectHtml, type StaticProjectServer } from "./staticProjectServer.js";
5+
import { Server } from "node:http";
6+
import {
7+
inProcessAnswer,
8+
serveStaticProjectHtml,
9+
type StaticProjectServer,
10+
} from "./staticProjectServer.js";
611

712
// `serveStaticProjectHtml` reaches these two studio-server helpers via a
813
// absolute module regardless of which file's relative specifier reaches it).
@@ -413,3 +418,53 @@ describe("serveStaticProjectHtml transparent media proxies", () => {
413418
expect(mocks.resolveProxy).not.toHaveBeenCalled();
414419
});
415420
});
421+
422+
describe("serveStaticProjectHtml when a sandbox refuses listen()", () => {
423+
const refuse = (code: string) =>
424+
vi.spyOn(Server.prototype, "listen").mockImplementation(function (this: Server) {
425+
process.nextTick(() =>
426+
this.emit("error", Object.assign(new Error(`listen ${code}`), { code })),
427+
);
428+
return this;
429+
});
430+
431+
afterEach(() => vi.restoreAllMocks());
432+
433+
it("answers the project in this process, Range included, with nothing listening", async () => {
434+
const listen = refuse("EPERM");
435+
dir = mkdtempSync(join(tmpdir(), "hf-static-"));
436+
writeFileSync(join(dir, "tone.wav"), Buffer.from("0123456789", "utf-8"));
437+
server = await serveStaticProjectHtml(dir, "<html><body>composition</body></html>");
438+
439+
expect(listen).toHaveBeenCalledOnce();
440+
expect(server.port).toBe(0);
441+
expect(inProcessAnswer(server.url)).toBe(server.answer);
442+
const page = await server.answer!({ method: "GET", path: "/", headers: {} });
443+
expect(page.status).toBe(200);
444+
expect(page.body.toString()).toContain("composition");
445+
const slice = await server.answer!({
446+
method: "GET",
447+
path: "/tone.wav",
448+
headers: { range: "bytes=2-5" },
449+
});
450+
expect(slice.status).toBe(206);
451+
expect(slice.headers["content-range"]).toBe("bytes 2-5/10");
452+
expect(slice.body.toString()).toBe("2345");
453+
expect(
454+
(await server.answer!({ method: "GET", path: "/missing.png", headers: {} })).status,
455+
).toBe(404);
456+
457+
const url = server.url;
458+
await server.close();
459+
server = undefined;
460+
expect(inProcessAnswer(url)).toBeUndefined();
461+
});
462+
463+
it("still fails on a bind error that is not a refusal", async () => {
464+
refuse("EADDRINUSE");
465+
dir = mkdtempSync(join(tmpdir(), "hf-static-"));
466+
await expect(serveStaticProjectHtml(dir, "<html></html>")).rejects.toMatchObject({
467+
code: "EADDRINUSE",
468+
});
469+
});
470+
});

‎packages/cli/src/utils/staticProjectServer.ts‎

Lines changed: 105 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,5 @@
1-
import { createServer, type ServerResponse } from "node:http";
1+
import { createServer, request as httpRequest, type Server, type ServerResponse } from "node:http";
2+
import { Duplex } from "node:stream";
23
import { createReadStream, existsSync, statSync } from "node:fs";
34
import { isAbsolute, relative, resolve } from "node:path";
45
import { getMimeType } from "@hyperframes/core/studio-api";
@@ -22,8 +23,92 @@ import {
2223

2324
export interface StaticProjectServer {
2425
url: string;
26+
/** 0 when nothing listens: the server answers in this process only (see `answer`). */
2527
port: number;
2628
close: () => Promise<void>;
29+
/** Set when a sandbox refused listen(): the browser's requests to `url` come here instead of a socket. */
30+
answer?: (request: InProcessRequest) => Promise<InProcessResponse>;
31+
}
32+
33+
export interface InProcessRequest {
34+
method: string;
35+
/** Path and query, e.g. `/assets/a.mp4?hf-proxy=alpha`. */
36+
path: string;
37+
headers: Record<string, string>;
38+
}
39+
40+
export interface InProcessResponse {
41+
status: number;
42+
headers: Record<string, string>;
43+
body: Buffer;
44+
}
45+
46+
/** A sandbox refuses a loopback listen() with one of these; any other bind error stays fatal. */
47+
const REFUSED_LISTEN = new Set(["EPERM", "EACCES"]);
48+
49+
/** Two connected in-memory sockets: what one side writes, the other reads. */
50+
function socketPair(): [Duplex, Duplex] {
51+
const sides: Duplex[] = [];
52+
const side = (other: () => Duplex) =>
53+
new Duplex({
54+
read() {},
55+
write(chunk, _encoding, done) {
56+
other().push(chunk);
57+
done();
58+
},
59+
final(done) {
60+
other().push(null);
61+
done();
62+
},
63+
});
64+
sides.push(
65+
side(() => sides[1]!),
66+
side(() => sides[0]!),
67+
);
68+
return [sides[0]!, sides[1]!];
69+
}
70+
71+
/** Hands one request to `server` over an in-memory socket, so its handler (Range, proxies) answers unchanged. */
72+
function answerInProcess(server: Server, request: InProcessRequest): Promise<InProcessResponse> {
73+
const [client, served] = socketPair();
74+
server.emit("connection", served);
75+
return new Promise((resolveAnswer, rejectAnswer) => {
76+
const req = httpRequest(
77+
{
78+
method: request.method,
79+
path: request.path,
80+
headers: { ...request.headers, connection: "close" },
81+
// No `agent`: Node uses createConnection only when no agent is given.
82+
createConnection: () => client as never,
83+
},
84+
(res) => {
85+
const chunks: Buffer[] = [];
86+
res.on("data", (chunk: Buffer) => chunks.push(chunk));
87+
res.on("error", rejectAnswer);
88+
res.on("end", () => {
89+
const headers: Record<string, string> = {};
90+
for (const [name, value] of Object.entries(res.headers)) {
91+
if (value !== undefined && name !== "connection" && name !== "transfer-encoding")
92+
headers[name] = Array.isArray(value) ? value.join(", ") : value;
93+
}
94+
resolveAnswer({ status: res.statusCode ?? 500, headers, body: Buffer.concat(chunks) });
95+
});
96+
},
97+
);
98+
req.on("error", rejectAnswer);
99+
req.end();
100+
});
101+
}
102+
103+
let inProcessServers = 0;
104+
const inProcessAnswers = new Map<
105+
string,
106+
(request: InProcessRequest) => Promise<InProcessResponse>
107+
>();
108+
109+
/** The in-process answer for a URL served by `serveStaticProjectHtml` when listen() was refused, else undefined. */
110+
export function inProcessAnswer(url: string) {
111+
return inProcessAnswers.get(new URL(url).origin);
27112
}
28113

29114
/**
@@ -229,8 +314,27 @@ export async function serveStaticProjectHtml(
229314
if (!resolvedPort) rejectPort(new Error(bindErrorMessage));
230315
else resolvePort(resolvedPort);
231316
});
317+
}).catch((error: unknown) => {
318+
if (REFUSED_LISTEN.has((error as NodeJS.ErrnoException).code ?? "")) return 0;
319+
throw error;
232320
});
233321

322+
if (port === 0) {
323+
server.removeAllListeners("error");
324+
// A sandbox (e.g. an agent's) may refuse listen(); the browser asks this origin and the process answers.
325+
const url = `http://hyperframes-${++inProcessServers}.localhost/`;
326+
const answer = (request: InProcessRequest) => answerInProcess(server, request);
327+
inProcessAnswers.set(new URL(url).origin, answer);
328+
return {
329+
url,
330+
port: 0,
331+
close: async () => {
332+
inProcessAnswers.delete(new URL(url).origin);
333+
},
334+
answer,
335+
};
336+
}
337+
234338
return {
235339
url: `http://127.0.0.1:${port}/`,
236340
port,

0 commit comments

Comments
 (0)