diff --git a/packages/cli/src/server/studioServer.test.ts b/packages/cli/src/server/studioServer.test.ts index 6d08dad7a7..6e8046b7cc 100644 --- a/packages/cli/src/server/studioServer.test.ts +++ b/packages/cli/src/server/studioServer.test.ts @@ -761,6 +761,53 @@ describe("Studio thumbnail capture", () => { expect(clears[0]).toBeGreaterThan(screenshot.mock.invocationCallOrder[0]!); }); + it("serves thumbnail capture documents in an opaque origin", async () => { + const dir = tmpProject(); + writeFileSync(join(dir, "index.html"), '
'); + server = createStudioServer({ projectDir: dir, projectName: "demo" }); + const capture = await server.app.request( + "http://localhost/api/projects/demo/preview?hf-capture=1", + ); + expect(capture.headers.get("content-security-policy")).toBe("sandbox allow-scripts"); + const preview = await server.app.request("http://localhost/api/projects/demo/preview"); + expect(preview.headers.get("content-security-policy")).toBeNull(); + }); + + it("grants the capture page's loads on its own session before it navigates", async () => { + const calls: string[] = []; + const session = { + send: vi.fn(async (method: string) => void calls.push(method)), + on: vi.fn(), + }; + const page = new Proxy( + { + createCDPSession: async () => session, + goto: async () => void calls.push("goto"), + screenshot: async () => Buffer.from("jpeg"), + }, + { + get: (target, key) => + key === "then" + ? undefined + : key in target + ? target[key as keyof typeof target] + : async () => {}, + }, + ); + engineState.acquireBrowser = async () => ({ + browser: { connected: true, newPage: async () => page, on: () => {} }, + release: async () => {}, + }); + const dir = tmpProject(); + server = createStudioServer({ projectDir: dir }); + const previewUrl = "http://127.0.0.1:3002/api/projects/demo/preview?hf-capture=1"; + await expect( + server.adapter.generateThumbnail?.({ ...opts(dir), previewUrl }), + ).resolves.toBeInstanceOf(Buffer); + expect(calls.slice(0, 2)).toEqual(["Fetch.enable", "goto"]); + expect(session.on).toHaveBeenCalledWith("Fetch.requestPaused", expect.any(Function)); + }); + it("reuses the cached project signature instead of walking the project per thumbnail", async () => { fakePageBrowser(); const dir = tmpProject(); diff --git a/packages/cli/src/server/studioServer.ts b/packages/cli/src/server/studioServer.ts index de9ce8eae3..77b8c8082d 100644 --- a/packages/cli/src/server/studioServer.ts +++ b/packages/cli/src/server/studioServer.ts @@ -64,6 +64,7 @@ import { PREVIEW_BUNDLE_OPTIONS, createPreviewDocumentStore, thumbnailDeviceScaleFactor, + grantCaptureLoads, type ResolvedProject, type RenderJobState, type BackgroundRemovalRender, @@ -805,6 +806,7 @@ export function createStudioServer(options: StudioServerOptions): StudioServer { opts.seekTime, async (page) => { await page.setViewport(viewport); + await grantCaptureLoads(await page.createCDPSession(), opts.previewUrl); await page.goto(opts.previewUrl, { waitUntil: "domcontentloaded", timeout: 10000 }); await assertWebGpuAdapterAvailable( page, @@ -1119,7 +1121,7 @@ export function createStudioServer(options: StudioServerOptions): StudioServer { // Mount the shared studio API at /api. // Use fetch() forwarding (not .route()) so the sub-app sees paths without // the /api prefix — the shared module's path extraction uses c.req.path. - const api = createStudioApi(adapter, { allowedHosts }); + const api = createStudioApi(adapter, { allowedHosts, sandboxThumbnailCaptures: true }); app.all("/api/*", async (c) => { const url = new URL(c.req.url); url.pathname = url.pathname.slice(4); // Strip "/api" prefix diff --git a/packages/shader-transitions/src/hyper-shader.preview.test.ts b/packages/shader-transitions/src/hyper-shader.preview.test.ts index b5c354312b..903b9f6be0 100644 --- a/packages/shader-transitions/src/hyper-shader.preview.test.ts +++ b/packages/shader-transitions/src/hyper-shader.preview.test.ts @@ -354,3 +354,31 @@ describe("a runtime seek while the prewarm runs", () => { expect(tl.totalTime()).toBe(1); }); }); + +describe("a document without IndexedDB access", () => { + it("prepares its transitions without the snapshot cache", async () => { + stubGsap(); + stubWebGl(); + const warn = vi.spyOn(console, "warn").mockImplementation(() => {}); + const denied = new DOMException( + "access to the Indexed Database API is denied", + "SecurityError", + ); + const open = vi.fn(() => { + throw denied; + }); + vi.stubGlobal("indexedDB", { open }); + // The cache's connection is module state, so a fresh module opens it under this stub. + vi.resetModules(); + const { init: initFresh } = await import("./hyper-shader.js"); + mountScenes(["s1", "s2"]); + initFresh({ + bgColor: "#000", + scenes: ["s1", "s2"], + transitions: [{ time: 2, duration: 0.8, shader: "domain-warp" }], + }); + await prewarmDone(); + expect(open).toHaveBeenCalled(); + expect(warn.mock.calls.flat()).not.toContain(denied); + }); +}); diff --git a/packages/shader-transitions/src/hyper-shader.ts b/packages/shader-transitions/src/hyper-shader.ts index f696533965..d1f41a205e 100644 --- a/packages/shader-transitions/src/hyper-shader.ts +++ b/packages/shader-transitions/src/hyper-shader.ts @@ -328,8 +328,13 @@ function makeSnapshotKey(cacheKey: string, sampleIndex: number, side: "from" | " function openSnapshotDb(): Promise { if (typeof indexedDB === "undefined") return Promise.resolve(null); + let request: IDBOpenDBRequest; + try { + request = indexedDB.open(SNAPSHOT_CACHE_DB, SNAPSHOT_CACHE_VERSION); + } catch { + return Promise.resolve(null); + } return new Promise((resolve) => { - const request = indexedDB.open(SNAPSHOT_CACHE_DB, SNAPSHOT_CACHE_VERSION); request.onupgradeneeded = () => { const db = request.result; if (!db.objectStoreNames.contains(SNAPSHOT_CACHE_STORE)) { diff --git a/packages/studio-server/src/createStudioApi.ts b/packages/studio-server/src/createStudioApi.ts index b8ae0b71ac..05b8a7520d 100644 --- a/packages/studio-server/src/createStudioApi.ts +++ b/packages/studio-server/src/createStudioApi.ts @@ -2,7 +2,7 @@ import { Hono, type Context, type Next } from "hono"; import type { StudioApiAdapter } from "./types.js"; import { registerProjectRoutes } from "./routes/projects.js"; import { registerFileRoutes } from "./routes/files.js"; -import { registerPreviewRoutes } from "./routes/preview.js"; +import { PREVIEW_CAPTURE_PARAM, registerPreviewRoutes } from "./routes/preview.js"; import { registerLintRoutes } from "./routes/lint.js"; import { registerRenderRoutes } from "./routes/render.js"; import { registerImageThumbnailRoutes } from "./routes/imageThumbnail.js"; @@ -25,6 +25,7 @@ import { sameOriginPost, } from "./helpers/requestIdentity.js"; import { previewErrorPage } from "./helpers/previewErrorPage.js"; +import type { CaptureSandboxOption } from "./helpers/captureLoads.js"; async function answerRefusedFrameWithPage(c: Context, next: Next) { await next(); @@ -43,11 +44,15 @@ const fromAnotherSite = (c: Context) => { return site === "cross-site" || site === "same-site"; }; -async function sandboxPreviewOpenedFromAnotherSite(c: Context, next: Next) { - await next(); - c.header("Vary", "Sec-Fetch-Site", { append: true }); - if (fromAnotherSite(c)) c.header("Content-Security-Policy", "sandbox allow-scripts"); -} +const isThumbnailCapture = (c: Context) => c.req.query(PREVIEW_CAPTURE_PARAM) !== undefined; + +const sandboxPreviewForAnotherSiteOrCapture = + (sandboxCaptures: boolean) => async (c: Context, next: Next) => { + await next(); + c.header("Vary", "Sec-Fetch-Site", { append: true }); + if (fromAnotherSite(c) || (sandboxCaptures && isThumbnailCapture(c))) + c.header("Content-Security-Policy", "sandbox allow-scripts"); + }; async function refuseThumbnailForAnotherSite(c: Context, next: Next) { if (fromAnotherSite(c)) @@ -71,13 +76,17 @@ function urlScheme(url: string): string | undefined { } } -export interface StudioApiOptions { +export interface StudioApiOptions extends CaptureSandboxOption { allowedHosts?: readonly string[]; } export function createStudioApi(adapter: StudioApiAdapter, options: StudioApiOptions = {}): Hono { const api = new Hono(); - api.use("/projects/:id/preview/*", sandboxPreviewOpenedFromAnotherSite); + const sandboxThumbnailCaptures = options.sandboxThumbnailCaptures ?? false; + api.use( + "/projects/:id/preview/*", + sandboxPreviewForAnotherSiteOrCapture(sandboxThumbnailCaptures), + ); api.use("/projects/:id/thumbnail/*", refuseThumbnailForAnotherSite); // This API is unauthenticated and simple cross-origin POSTs need no // preflight, so the guard rejects writes the shared predicate refuses. @@ -151,7 +160,7 @@ export function createStudioApi(adapter: StudioApiAdapter, options: StudioApiOpt registerProjectRoutes(api, adapter); registerFileRoutes(api, adapter); - registerPreviewRoutes(api, adapter); + registerPreviewRoutes(api, adapter, { sandboxThumbnailCaptures }); registerLintRoutes(api, adapter); registerRenderRoutes(api, adapter); registerThumbnailRoutes(api, adapter); diff --git a/packages/studio-server/src/helpers/captureLoads.test.ts b/packages/studio-server/src/helpers/captureLoads.test.ts new file mode 100644 index 0000000000..2a35c4c1f2 --- /dev/null +++ b/packages/studio-server/src/helpers/captureLoads.test.ts @@ -0,0 +1,186 @@ +import { describe, expect, it, vi } from "vitest"; +import { captureLoadGrant, grantCaptureLoads, type CaptureCdpSession } from "./captureLoads"; + +const ORIGIN = "http://127.0.0.1:3002"; +const PREVIEW = `${ORIGIN}/api/projects/demo/preview`; +const CAPTURE = `${PREVIEW}/comp/compositions/intro.html?hf-capture=1`; + +describe("captureLoadGrant", () => { + it.each([ + ["Font", `${PREVIEW}/assets/brand.woff2`], + ["Script", `${PREVIEW}/assets/scene.mjs`], + ["Stylesheet", `${PREVIEW}/style.css`], + ["Image", `${PREVIEW}/assets/logo.png`], + ["Media", `${PREVIEW}/assets/clip.mp4`], + ["Media", `${PREVIEW}/assets/clip.mov?hf-proxy=h264`], + ["XHR", `${PREVIEW}/compositions/scene.html`], + ["Fetch", `${PREVIEW}/models/device.glb`], + ["XHR", `${PREVIEW}/assets/fonts/Geist-Bold.ttf`], + ["XHR", `${PREVIEW}/notes.txt`], + ["XHR", `${PREVIEW}/assets/clip.mov?hf-proxy=h264&hf-proxy-box=1448x724`], + ])("lets the frame read a %s load of %s", (resourceType, url) => { + expect(captureLoadGrant({ url, method: "GET", resourceType }, CAPTURE)).toBe("read"); + }); + + it("answers the preflight of the runtime's wait for a video's preview copy", () => { + const url = `${PREVIEW}/assets/clip.mov?hf-proxy=h264&hf-proxy-box=1448x724`; + expect(captureLoadGrant({ url, method: "OPTIONS", resourceType: "XHR" }, CAPTURE)).toBe( + "preflight", + ); + }); + + it.each([ + ["XHR", `${PREVIEW}/.env`, "GET"], + ["XHR", `${PREVIEW}/.git/config`, "GET"], + ["XHR", `${PREVIEW}/assets/.npmrc`, "GET"], + ["XHR", `${PREVIEW}/%2Eenv`, "GET"], + ["XHR", `${PREVIEW}/%E0%A4%A.html`, "GET"], + ["Script", `${PREVIEW}/.env`, "GET"], + ["Image", `${PREVIEW}/.git/logo.png`, "GET"], + ["Document", `${PREVIEW}/compositions/scene.html`, "GET"], + ["XHR", `${ORIGIN}/api/projects/demo/files/index.html`, "GET"], + ["XHR", `${ORIGIN}/api/projects/other/preview/index.html`, "GET"], + ["XHR", `http://127.0.0.1:9999/api/projects/demo/preview/index.html`, "GET"], + ["XHR", `${PREVIEW}/compositions/scene.html`, "PUT"], + ["XHR", `${PREVIEW}/compositions/scene.html`, "POST"], + ["XHR", `${PREVIEW}/compositions/scene.html`, "OPTIONS"], + ["XHR", `${PREVIEW}/.env?hf-proxy=h264`, "OPTIONS"], + ["XHR", `${PREVIEW}/notes.txt?hf-proxy=h264`, "OPTIONS"], + ["XHR", `${PREVIEW}/assets/clip.mov?hf-proxy=h264`, "PUT"], + ])("refuses a %s load of %s (%s)", (resourceType, url, method) => { + expect(captureLoadGrant({ url, method, resourceType }, CAPTURE)).toBeNull(); + }); + + it("grants nothing for a URL that is not a preview document", () => { + const load = { url: `${PREVIEW}/assets/brand.woff2`, method: "GET", resourceType: "Font" }; + expect(captureLoadGrant(load, `${ORIGIN}/api/projects/demo/files/index.html`)).toBeNull(); + expect(captureLoadGrant(load, "not a url")).toBeNull(); + }); +}); + +type Paused = Parameters[1]>[0]; + +function fakeSession() { + let paused: ((event: Paused) => void) | undefined; + const send = vi.fn(async (_method: string, _params?: object) => undefined); + const session: CaptureCdpSession = { + send, + on: (_event, handler) => { + paused = handler; + }, + }; + return { session, send, pause: (event: Paused) => paused?.(event) }; +} + +const response = (url: string, resourceType: string, extra: Partial = {}): Paused => ({ + requestId: "r1", + request: { url, method: "GET" }, + resourceType, + responseStatusCode: 200, + responseHeaders: [{ name: "Content-Type", value: "font/woff2" }], + ...extra, +}); + +describe("grantCaptureLoads", () => { + it("intercepts responses under the project's preview path only", async () => { + const { session, send } = fakeSession(); + await grantCaptureLoads(session, CAPTURE); + const enable = send.mock.calls.find(([method]) => method === "Fetch.enable"); + expect(enable).toBeDefined(); + const { patterns } = enable![1] as { patterns: Array> }; + expect(patterns.map((pattern) => pattern.resourceType)).toEqual( + expect.arrayContaining(["Font", "Image", "Media", "XHR"]), + ); + for (const pattern of patterns) { + expect(pattern.urlPattern).toBe(`${PREVIEW}/*`); + expect(pattern.requestStage).toBe("Response"); + } + }); + + it("adds the CORS header to a granted load and keeps its own headers", async () => { + const { session, send, pause } = fakeSession(); + await grantCaptureLoads(session, CAPTURE); + pause(response(`${PREVIEW}/assets/brand.woff2`, "Font")); + expect(send).toHaveBeenLastCalledWith("Fetch.continueResponse", { + requestId: "r1", + responseCode: 200, + responseHeaders: [ + { name: "Content-Type", value: "font/woff2" }, + { name: "Access-Control-Allow-Origin", value: "null" }, + { name: "X-Content-Type-Options", value: "nosniff" }, + expect.objectContaining({ name: "Access-Control-Expose-Headers" }), + ], + }); + }); + + it("lets the frame read a missing file's status, as a same-origin page would", async () => { + const { session, send, pause } = fakeSession(); + await grantCaptureLoads(session, CAPTURE); + pause(response(`${PREVIEW}/assets/fonts/Missing.ttf`, "XHR", { responseStatusCode: 404 })); + expect(send).toHaveBeenLastCalledWith( + "Fetch.continueResponse", + expect.objectContaining({ responseCode: 404 }), + ); + }); + + it("exposes the preview copy's progress headers to the runtime's wait", async () => { + const { session, send, pause } = fakeSession(); + await grantCaptureLoads(session, CAPTURE); + pause( + response(`${PREVIEW}/assets/clip.mov?hf-proxy=h264`, "XHR", { + responseStatusCode: 202, + responseHeaders: [{ name: "Retry-After", value: "2" }], + }), + ); + expect(send).toHaveBeenLastCalledWith("Fetch.continueResponse", { + requestId: "r1", + responseCode: 202, + responseHeaders: expect.arrayContaining([ + { name: "Access-Control-Allow-Origin", value: "null" }, + { name: "Access-Control-Expose-Headers", value: expect.stringContaining("Retry-After") }, + ]), + }); + }); + + it("answers the wait's preflight itself, whatever the server said", async () => { + const { session, send, pause } = fakeSession(); + await grantCaptureLoads(session, CAPTURE); + pause({ + ...response(`${PREVIEW}/assets/clip.mov?hf-proxy=h264`, "XHR", { responseStatusCode: 404 }), + request: { url: `${PREVIEW}/assets/clip.mov?hf-proxy=h264`, method: "OPTIONS" }, + }); + expect(send).toHaveBeenLastCalledWith("Fetch.fulfillRequest", { + requestId: "r1", + responseCode: 204, + responseHeaders: expect.arrayContaining([ + { name: "Access-Control-Allow-Origin", value: "null" }, + { name: "Access-Control-Allow-Methods", value: "GET" }, + ]), + }); + }); + + it.each([ + ["a file fetch() may not read", response(`${PREVIEW}/.env`, "XHR")], + [ + "a request paused before its response", + response(`${PREVIEW}/assets/brand.woff2`, "Font", { responseStatusCode: undefined }), + ], + [ + "a load that already answers CORS", + response(`${PREVIEW}/assets/brand.woff2`, "Font", { + responseHeaders: [{ name: "access-control-allow-origin", value: "*" }], + }), + ], + ])("passes %s through unchanged", async (_name, event) => { + const { session, send, pause } = fakeSession(); + await grantCaptureLoads(session, CAPTURE); + pause(event); + expect(send).toHaveBeenLastCalledWith("Fetch.continueRequest", { requestId: "r1" }); + }); + + it("does nothing for a URL that is not a preview document", async () => { + const { session, send } = fakeSession(); + await grantCaptureLoads(session, `${ORIGIN}/api/projects/demo/files/index.html`); + expect(send).not.toHaveBeenCalled(); + }); +}); diff --git a/packages/studio-server/src/helpers/captureLoads.ts b/packages/studio-server/src/helpers/captureLoads.ts new file mode 100644 index 0000000000..3e40e908df --- /dev/null +++ b/packages/studio-server/src/helpers/captureLoads.ts @@ -0,0 +1,138 @@ +import { PREVIEW_PROXY_PRIORITY_HEADER, PREVIEW_PROXY_PROGRESS_HEADER } from "@hyperframes/core"; + +/** + * A sandboxed capture document's CORS-mode loads fail, so the trusted renderer adds CORS headers for + * its own page: every GET of the project's preview files except a dotfile or dot-folder (`.env`, + * `.git/`), and the preflight of the runtime's wait for a video's `?hf-proxy=` copy. + */ +// Chrome reports a page's `fetch()`, and its preflight, as `XHR`. +const GRANTED_TYPES = new Set(["Font", "Script", "Stylesheet", "Image", "Media", "Fetch", "XHR"]); + +const PROXY_PARAM = "hf-proxy"; +const VIDEO_FILE = /\.(mp4|webm|mov|mkv|avi|m4v|mxf|mts|m2ts)$/i; + +function capturePreviewPrefix(captureUrl: string): string | null { + let url: URL; + try { + url = new URL(captureUrl); + } catch { + return null; + } + const path = /^\/api\/projects\/[^/]+\/preview(?=\/|$)/.exec(url.pathname)?.[0]; + return path ? `${url.origin}${path}/` : null; +} + +export interface CaptureSandboxOption { + /** + * Serve thumbnail capture documents (`?hf-capture`) in an opaque origin. Default off. Turn it on + * only with a thumbnail renderer that calls `grantCaptureLoads` on each capture page before loading + * it; without that grant its captures lose fonts, module scripts, nested scenes and video pixels. + */ + sandboxThumbnailCaptures?: boolean; +} + +export interface CaptureLoad { + url: string; + method: string; + resourceType: string; +} + +const decodedSegment = (segment: string) => { + try { + return decodeURIComponent(segment); + } catch { + return "."; + } +}; + +const isDotPath = (url: URL, prefix: string) => + url.pathname + .slice(new URL(prefix).pathname.length) + .split("/") + .some((segment) => decodedSegment(segment).startsWith(".")); + +export function captureLoadGrant( + load: CaptureLoad, + captureUrl: string, +): "read" | "preflight" | null { + const prefix = capturePreviewPrefix(captureUrl); + if (!prefix || !load.url.startsWith(prefix)) return null; + const url = new URL(load.url); + if (isDotPath(url, prefix) || !GRANTED_TYPES.has(load.resourceType)) return null; + const proxyWait = + (load.resourceType === "XHR" || load.resourceType === "Fetch") && + url.searchParams.has(PROXY_PARAM) && + VIDEO_FILE.test(url.pathname); + if (load.method === "OPTIONS") return proxyWait ? "preflight" : null; + return load.method === "GET" ? "read" : null; +} + +type Header = { name: string; value: string }; + +export interface CaptureCdpSession { + send(method: string, params?: object): Promise; + on( + event: "Fetch.requestPaused", + handler: (event: { + requestId: string; + request: { url: string; method: string }; + resourceType: string; + responseStatusCode?: number; + responseHeaders?: Header[]; + }) => void, + ): unknown; +} + +const OPAQUE_CALLER: Header[] = [ + { name: "Access-Control-Allow-Origin", value: "null" }, + { name: "X-Content-Type-Options", value: "nosniff" }, + { + name: "Access-Control-Expose-Headers", + value: `Retry-After, ${PREVIEW_PROXY_PROGRESS_HEADER}, Content-Range`, + }, +]; +const PREFLIGHT_ANSWER: Header[] = [ + { name: "Access-Control-Allow-Origin", value: "null" }, + { name: "Access-Control-Allow-Methods", value: "GET" }, + { name: "Access-Control-Allow-Headers", value: `Range, ${PREVIEW_PROXY_PRIORITY_HEADER}` }, +]; + +/** Call on the capture page's own session before it navigates; keep the session for the page's life. */ +export async function grantCaptureLoads(cdp: CaptureCdpSession, captureUrl: string): Promise { + const prefix = capturePreviewPrefix(captureUrl); + if (!prefix) return; + cdp.on("Fetch.requestPaused", (event) => { + const { requestId } = event; + const headers = event.responseHeaders ?? []; + const status = event.responseStatusCode; + const grant = captureLoadGrant( + { url: event.request.url, method: event.request.method, resourceType: event.resourceType }, + captureUrl, + ); + const answered = + status !== undefined && + !headers.some((header) => header.name.toLowerCase() === "access-control-allow-origin"); + const sent = + grant === "preflight" + ? cdp.send("Fetch.fulfillRequest", { + requestId, + responseCode: 204, + responseHeaders: PREFLIGHT_ANSWER, + }) + : grant && answered + ? cdp.send("Fetch.continueResponse", { + requestId, + responseCode: status, + responseHeaders: [...headers, ...OPAQUE_CALLER], + }) + : cdp.send("Fetch.continueRequest", { requestId }); + void sent.catch(() => undefined); + }); + await cdp.send("Fetch.enable", { + patterns: [...GRANTED_TYPES].map((resourceType) => ({ + urlPattern: `${prefix}*`, + resourceType, + requestStage: "Response", + })), + }); +} diff --git a/packages/studio-server/src/helpers/captureVideos.test.ts b/packages/studio-server/src/helpers/captureVideos.test.ts new file mode 100644 index 0000000000..d0cb2786fa --- /dev/null +++ b/packages/studio-server/src/helpers/captureVideos.test.ts @@ -0,0 +1,29 @@ +import { describe, expect, it } from "vitest"; +import { corsProjectVideos } from "./captureVideos.js"; + +const doc = (body: string) => `${body}`; + +describe("corsProjectVideos", () => { + it("loads the project's own videos with CORS and leaves the rest alone", () => { + const html = corsProjectVideos( + doc( + '' + + '' + + '' + + '' + + '' + + '' + + '' + + '', + ), + ); + const marked = [...html.matchAll(/