mirror of
https://github.com/heygen-com/hyperframes.git
synced 2026-11-19 11:26:02 +00:00
* test(studio-server): a loopback page with no fetch metadata is marked unless it is the app's own * fix(studio-server): a loopback page with no fetch metadata is marked unless the app framed it * test(studio-server): a page marked by its Referer names Referer in Vary * fix(studio-server): a page marked by its Referer tells caches it varies by Referer
1352 lines
54 KiB
TypeScript
1352 lines
54 KiB
TypeScript
import {
|
|
waitForRenderCancellation,
|
|
cancelAndVerifyArtifacts,
|
|
} from "../../../../test-utils/renderCancellation";
|
|
import { EventEmitter } from "node:events";
|
|
import { afterEach, describe, expect, it, vi } from "vitest";
|
|
import {
|
|
existsSync,
|
|
mkdirSync,
|
|
mkdtempSync,
|
|
readdirSync,
|
|
readFileSync,
|
|
renameSync,
|
|
rmSync,
|
|
symlinkSync,
|
|
writeFileSync,
|
|
} from "node:fs";
|
|
import { tmpdir } from "node:os";
|
|
import { basename, join } from "node:path";
|
|
import {
|
|
createProjectSignature,
|
|
fileContentVersion,
|
|
HistoryBusyError,
|
|
HistoryClosedError,
|
|
} from "@hyperframes/studio-server";
|
|
import { loadHyperframeRuntimeSource } from "@hyperframes/core";
|
|
import { loadRuntimeSource } from "./runtimeSource.js";
|
|
import { findFFmpeg, findFFprobe } from "../browser/ffmpeg.js";
|
|
import { createStudioServer, type StudioServer } from "./studioServer.js";
|
|
|
|
// Forces loadStudioProducer() down its production import branch (real
|
|
// isDevMode() is true for a .ts test file, which instead throws a
|
|
// "requires bun" error before ever reaching executeRenderJob — see
|
|
// studioServer.ts's loadStudioProducer). Only startRender reads this.
|
|
vi.mock("../utils/env.js", () => ({ isDevMode: () => false }));
|
|
|
|
const producerState = vi.hoisted(() => ({
|
|
// Set per-test to control when the render "finishes" so a shutdown that
|
|
// races an in-flight render is observable instead of vacuous.
|
|
executeRenderJob: (
|
|
_job: unknown,
|
|
_dir: string,
|
|
_outputPath: string,
|
|
_onProgress: unknown,
|
|
_signal: AbortSignal,
|
|
): Promise<void> => Promise.resolve(),
|
|
}));
|
|
vi.mock("@hyperframes/producer", () => ({
|
|
createRenderJob: (opts: Record<string, unknown>) => ({ ...opts, perfSummary: undefined }),
|
|
executeRenderJob: (...args: Parameters<typeof producerState.executeRenderJob>) =>
|
|
producerState.executeRenderJob(...args),
|
|
}));
|
|
// Stand-ins for the HEIF and GIF steps: each writes a converted file where a real conversion would.
|
|
const imagePrep = vi.hoisted(() => ({
|
|
convert: async (html: string, options: { outputDir: string }) => {
|
|
const { mkdirSync, writeFileSync } = await import("node:fs");
|
|
mkdirSync(options.outputDir, { recursive: true });
|
|
writeFileSync(`${options.outputDir}/converted`, "image");
|
|
return { html, preparedAssets: new Map<string, string>() };
|
|
},
|
|
}));
|
|
vi.mock("../../../producer/src/services/heifImagePrep.js", () => ({
|
|
prepareHeifImageInputs: async (html: string, options: { outputDir: string }) => ({
|
|
...(await imagePrep.convert(html, options)),
|
|
preparedImages: [],
|
|
}),
|
|
}));
|
|
vi.mock("../../../producer/src/services/animatedGifPrep.js", () => ({
|
|
prepareAnimatedGifInputs: async (html: string, options: { outputDir: string }) => ({
|
|
...(await imagePrep.convert(html, options)),
|
|
preparedGifs: [],
|
|
}),
|
|
}));
|
|
const engineState = vi.hoisted(() => ({
|
|
acquireBrowser: async (..._args: unknown[]): Promise<unknown> => {
|
|
throw new Error("acquireBrowser called without a test double");
|
|
},
|
|
closeBrowserPool: async (): Promise<void> => {},
|
|
}));
|
|
vi.mock("@hyperframes/engine", () => ({
|
|
acquireBrowser: (...args: unknown[]) => engineState.acquireBrowser(...args),
|
|
buildChromeArgs: () => [],
|
|
killTrackedProcesses: () => {},
|
|
closeBrowserPool: () => engineState.closeBrowserPool(),
|
|
getSystemTotalMb: () => 0,
|
|
}));
|
|
vi.mock("../browser/gpuPolicy.js", () => ({
|
|
resolveCaptureBrowserGpuMode: async () => "software",
|
|
resolveLocalBrowserGpuMode: () => "software",
|
|
compositionRequiresWebGpu: () => false,
|
|
assertWebGpuAdapterAvailable: async () => {},
|
|
resolveLocalWebGpu: (browserGpuMode: string) => ({
|
|
gpuConfig: { browserGpuMode, allowSoftwareWebGpu: false },
|
|
softwareWebGpu: false,
|
|
}),
|
|
}));
|
|
vi.mock("../browser/preflight.js", async (importOriginal) => ({
|
|
...(await importOriginal<typeof import("../browser/preflight.js")>()),
|
|
resolveRenderBrowser: async () => ({ executablePath: "/fake/chrome", source: "system" }),
|
|
}));
|
|
vi.mock("../browser/manager.js", () => ({
|
|
ensureBrowser: async () => ({ executablePath: undefined, source: "system" }),
|
|
}));
|
|
|
|
const cpuSamplerState = vi.hoisted(() => ({
|
|
samplers: [] as { requesterOptedIn: boolean; stopped: boolean }[],
|
|
}));
|
|
vi.mock("../telemetry/renderCpu.js", () => ({
|
|
startRenderCpuSampler: (requesterOptedIn = true) => {
|
|
const sampler = { requesterOptedIn, stopped: false };
|
|
cpuSamplerState.samplers.push(sampler);
|
|
return {
|
|
stop: () => {
|
|
sampler.stopped = true;
|
|
return { cpuBusyAvgPct: 57, cpuBusyPeakPct: 90 };
|
|
},
|
|
};
|
|
},
|
|
}));
|
|
|
|
// Lets one test hold the project history in its opening; every other test opens the real one.
|
|
const historyState = vi.hoisted(() => ({
|
|
open: null as null | ((...args: unknown[]) => Promise<unknown>),
|
|
}));
|
|
vi.mock("@hyperframes/studio-server", async (importOriginal) => {
|
|
const original = await importOriginal<typeof import("@hyperframes/studio-server")>();
|
|
return {
|
|
...original,
|
|
createProjectSignature: vi.fn(original.createProjectSignature),
|
|
openProjectHistory: (...args: Parameters<typeof original.openProjectHistory>) =>
|
|
historyState.open ? historyState.open(...args) : original.openProjectHistory(...args),
|
|
};
|
|
});
|
|
|
|
// Only `fs.watch` is replaced, so the SSE describe below can fire a file-change
|
|
// on demand; every other server test keeps reading and writing real files.
|
|
const mockWatcher = new EventEmitter() as EventEmitter & { close: () => void };
|
|
mockWatcher.close = vi.fn();
|
|
|
|
vi.mock("node:fs", async (importOriginal) => {
|
|
const original = await importOriginal<typeof import("node:fs")>();
|
|
const watch = vi.fn(
|
|
(_path: string, _options: unknown, onChange: (event: string, filename: string) => void) => {
|
|
mockWatcher.on("change", onChange);
|
|
return mockWatcher;
|
|
},
|
|
);
|
|
return { ...original, default: { ...original, watch }, watch };
|
|
});
|
|
|
|
// Every server-backed describe below wants the same two things: a throwaway
|
|
// project directory, and a server whose watcher is closed afterwards. Three
|
|
// copies of that got out of step, so it lives here once.
|
|
const dirs: string[] = [];
|
|
let server: StudioServer | undefined;
|
|
|
|
function tmpProject(): string {
|
|
const dir = mkdtempSync(join(tmpdir(), "hf-studio-server-test-"));
|
|
dirs.push(dir);
|
|
return dir;
|
|
}
|
|
|
|
const openReaders: ReadableStreamDefaultReader<Uint8Array>[] = [];
|
|
|
|
afterEach(async () => {
|
|
await Promise.all(openReaders.splice(0).map((reader) => reader.cancel().catch(() => {})));
|
|
mockWatcher.removeAllListeners();
|
|
server?.watcher.close();
|
|
server = undefined;
|
|
delete process.env.HYPERFRAMES_FFMPEG_PATH;
|
|
delete process.env.HYPERFRAMES_FFPROBE_PATH;
|
|
for (const dir of dirs.splice(0)) rmSync(dir, { recursive: true, force: true });
|
|
});
|
|
|
|
describe("loadRuntimeSource", () => {
|
|
it("loads runtime source from the published core entrypoint", async () => {
|
|
await expect(loadRuntimeSource()).resolves.toBe(loadHyperframeRuntimeSource());
|
|
});
|
|
});
|
|
|
|
describe("Studio thumbnail GPU capture plumbing", () => {
|
|
it("uses the shared auto probe, resolved launch mode, requirement guard, and completion-aware seek", () => {
|
|
const source = readFileSync(new URL("./studioServer.ts", import.meta.url), "utf8");
|
|
expect(source).toContain("resolveCaptureBrowserGpuMode");
|
|
expect(source).toContain("resolveLocalWebGpu(resolvedGpuMode, true)");
|
|
expect(source).toContain("requiresWebGpu && session.softwareWebGpu");
|
|
expect(source).toContain("await seekCompositionTimeline(page, opts.seekTime");
|
|
});
|
|
});
|
|
|
|
describe("createStudioServer project history (D-491)", () => {
|
|
it("serves the project's history, and a change the watcher sees becomes an entry", async () => {
|
|
const projectDir = tmpProject();
|
|
writeFileSync(join(projectDir, "index.html"), "<html>before</html>");
|
|
server = createStudioServer({ projectDir, historyRoot: tmpProject() });
|
|
const historyUrl = `/api/projects/${encodeURIComponent(basename(projectDir))}/history`;
|
|
const list = async () =>
|
|
(await (await server!.app.request(historyUrl)).json()) as {
|
|
entries: Array<{ who: { kind: string } }>;
|
|
back: { label: string } | null;
|
|
};
|
|
expect(await list()).toMatchObject({ entries: [], back: null });
|
|
|
|
writeFileSync(join(projectDir, "index.html"), "<html>agent</html>");
|
|
mockWatcher.emit("change", "change", "index.html");
|
|
|
|
// Writes with no window open group until 2 s of quiet.
|
|
await vi.waitFor(async () => expect((await list()).entries).toHaveLength(1), {
|
|
timeout: 5_000,
|
|
interval: 200,
|
|
});
|
|
expect((await list()).entries[0]!.who.kind).toBe("outside");
|
|
await server.shutdown();
|
|
});
|
|
|
|
it.each([
|
|
["another process was holding", new HistoryBusyError(1)],
|
|
["whose folder changed while it opened", new HistoryClosedError("now another project")],
|
|
])(
|
|
"tries a history %s again on the next request, instead of turning it off",
|
|
async (_, refusal) => {
|
|
historyState.open = async () => {
|
|
historyState.open = null;
|
|
throw refusal;
|
|
};
|
|
const projectDir = tmpProject();
|
|
server = createStudioServer({ projectDir, historyRoot: tmpProject() });
|
|
const historyUrl = `/api/projects/${encodeURIComponent(basename(projectDir))}/history`;
|
|
expect((await server.app.request(historyUrl)).status).toBe(404);
|
|
expect((await server.app.request(historyUrl)).status).toBe(200);
|
|
await server.shutdown();
|
|
},
|
|
);
|
|
|
|
// A preview an agent starts inside a host app's run can outlive it; holding the lock, it refused every later run.
|
|
it("never opens the history inside a host app's run, which owns it", async () => {
|
|
const opens: unknown[] = [];
|
|
historyState.open = async (options) => {
|
|
opens.push(options);
|
|
throw new Error("the history was opened");
|
|
};
|
|
vi.stubEnv("HYPERFRAMES_DESKTOP_PROJECT", "/a/project");
|
|
try {
|
|
const projectDir = tmpProject();
|
|
server = createStudioServer({ projectDir, historyRoot: tmpProject() });
|
|
const historyUrl = `/api/projects/${encodeURIComponent(basename(projectDir))}/history`;
|
|
expect((await server.app.request(historyUrl)).status).toBe(404);
|
|
expect(opens).toEqual([]);
|
|
await server.shutdown();
|
|
} finally {
|
|
vi.unstubAllEnvs();
|
|
historyState.open = null;
|
|
}
|
|
});
|
|
|
|
it("never makes a request wait on another process's history lock again once it was busy", async () => {
|
|
const waits: unknown[] = [];
|
|
historyState.open = async (options) => {
|
|
waits.push((options as { ownerWaitMs?: number }).ownerWaitMs);
|
|
throw new HistoryBusyError(1);
|
|
};
|
|
const projectDir = tmpProject();
|
|
server = createStudioServer({ projectDir, historyRoot: tmpProject() });
|
|
const historyUrl = `/api/projects/${encodeURIComponent(basename(projectDir))}/history`;
|
|
await server.app.request(historyUrl);
|
|
await server.app.request(historyUrl);
|
|
historyState.open = null;
|
|
expect(waits).toEqual([undefined, 0]);
|
|
await server.shutdown();
|
|
});
|
|
|
|
it("waits for the history lock again once a history opened after a busy one", async () => {
|
|
const waits: unknown[] = [];
|
|
const reopenable = { replacedAtPath: () => true, close: async () => {} };
|
|
let opens = 0;
|
|
historyState.open = async (options) => {
|
|
waits.push((options as { ownerWaitMs?: number }).ownerWaitMs);
|
|
opens += 1;
|
|
if (opens === 1) throw new HistoryBusyError(1);
|
|
if (opens === 2) return reopenable;
|
|
historyState.open = null;
|
|
throw new HistoryBusyError(1);
|
|
};
|
|
const projectDir = tmpProject();
|
|
server = createStudioServer({ projectDir, historyRoot: tmpProject() });
|
|
const historyUrl = `/api/projects/${encodeURIComponent(basename(projectDir))}/history`;
|
|
await server.app.request(historyUrl);
|
|
await server.app.request(historyUrl);
|
|
historyState.open = null;
|
|
expect(waits).toEqual([undefined, 0, undefined]);
|
|
await server.shutdown();
|
|
});
|
|
|
|
it("opens a new project's own history once it takes the folder's path", async () => {
|
|
const projectDir = tmpProject();
|
|
writeFileSync(join(projectDir, "index.html"), "<html>before</html>");
|
|
server = createStudioServer({ projectDir, historyRoot: tmpProject() });
|
|
const historyUrl = `/api/projects/${encodeURIComponent(basename(projectDir))}/history`;
|
|
expect((await server.app.request(historyUrl)).status).toBe(200);
|
|
renameSync(projectDir, `${projectDir}-moved`);
|
|
dirs.push(`${projectDir}-moved`);
|
|
mkdirSync(projectDir);
|
|
writeFileSync(join(projectDir, "index.html"), "<html>new</html>");
|
|
|
|
expect((await server.app.request(historyUrl)).status).toBe(200);
|
|
expect(existsSync(join(projectDir, ".hyperframes", "history-id"))).toBe(true);
|
|
await server.shutdown();
|
|
});
|
|
|
|
it("shutdown returns within preview's exit watchdog while the history is still opening", async () => {
|
|
historyState.open = () => new Promise(() => {});
|
|
try {
|
|
const projectDir = tmpProject();
|
|
server = createStudioServer({ projectDir, historyRoot: tmpProject() });
|
|
void server.app.request(`/api/projects/${encodeURIComponent(basename(projectDir))}/history`);
|
|
await new Promise((resolve) => setTimeout(resolve, 50));
|
|
const started = Date.now();
|
|
await server.shutdown();
|
|
expect(Date.now() - started).toBeLessThan(2_900);
|
|
} finally {
|
|
historyState.open = null;
|
|
}
|
|
});
|
|
});
|
|
|
|
describe("createStudioServer autoProxy plumbing", () => {
|
|
it("hyperframes.json media.autoProxy=false flows through to the adapter", () => {
|
|
const projectDir = tmpProject();
|
|
writeFileSync(
|
|
join(projectDir, "hyperframes.json"),
|
|
JSON.stringify({ media: { autoProxy: false } }),
|
|
);
|
|
|
|
server = createStudioServer({ projectDir });
|
|
|
|
expect(server.adapter.autoProxy).toBe(false);
|
|
});
|
|
|
|
it("defaults the adapter to autoProxy=true when neither option nor config disables it", () => {
|
|
server = createStudioServer({ projectDir: tmpProject() });
|
|
expect(server.adapter.autoProxy).toBe(true);
|
|
});
|
|
|
|
it("an explicit option (the preview command's resolved --proxy flag) wins over config", () => {
|
|
const projectDir = tmpProject();
|
|
writeFileSync(
|
|
join(projectDir, "hyperframes.json"),
|
|
JSON.stringify({ media: { autoProxy: false } }),
|
|
);
|
|
|
|
server = createStudioServer({ projectDir, autoProxy: true });
|
|
|
|
expect(server.adapter.autoProxy).toBe(true);
|
|
});
|
|
|
|
it("advertises the GPU policy used for thumbnail capture", async () => {
|
|
const projectDir = tmpProject();
|
|
server = createStudioServer({ projectDir, browserGpuMode: "software" });
|
|
|
|
const response = await server.app.request("/__hyperframes_config");
|
|
|
|
expect(response.status).toBe(200);
|
|
await expect(response.json()).resolves.toMatchObject({ browserGpuMode: "software" });
|
|
});
|
|
});
|
|
|
|
// A render that never reaches the executor (browser check refused, import failed) must fail with
|
|
// its reason, not hang until the suite timeout.
|
|
async function untilStarted(started: Promise<void>, state: { status: string; error?: string }) {
|
|
let timer: ReturnType<typeof setTimeout> | undefined;
|
|
const never = new Promise<never>((_, reject) => {
|
|
timer = setTimeout(
|
|
() =>
|
|
reject(
|
|
new Error(
|
|
`render never reached executeRenderJob: status=${state.status} error=${state.error}`,
|
|
),
|
|
),
|
|
5_000,
|
|
);
|
|
});
|
|
try {
|
|
await Promise.race([started, never]);
|
|
} finally {
|
|
clearTimeout(timer);
|
|
}
|
|
}
|
|
|
|
describe("createStudioServer shutdown", () => {
|
|
function startRenderOpts(jobId: string, outputPath: string) {
|
|
return {
|
|
project: { id: "demo", dir: tmpProject(), title: "demo" },
|
|
outputPath,
|
|
format: "mp4" as const,
|
|
fps: { num: 30, den: 1 },
|
|
quality: "draft",
|
|
jobId,
|
|
};
|
|
}
|
|
|
|
it("hands the limiter's audioLoweredDb to the job state and the render sidecar", async () => {
|
|
producerState.executeRenderJob = async (job) => {
|
|
if (typeof job === "object" && job !== null) Reflect.set(job, "audioLoweredDb", 1.44);
|
|
};
|
|
const outputPath = join(mkdtempSync(join(tmpdir(), "hf-lowered-")), "out.mp4");
|
|
server = createStudioServer({ projectDir: tmpProject() });
|
|
const state = server.adapter.startRender(startRenderOpts("job-lowered", outputPath));
|
|
await vi.waitFor(() => expect(state.status, state.error).toBe("complete"), { timeout: 5_000 });
|
|
expect(state.audioLoweredDb).toBe(1.44);
|
|
const meta = JSON.parse(readFileSync(outputPath.replace(/\.mp4$/, ".meta.json"), "utf8"));
|
|
expect(meta.audioLoweredDb).toBe(1.44);
|
|
});
|
|
|
|
it("stops measuring CPU however a render ends, and never for an opted-out requester", async () => {
|
|
cpuSamplerState.samplers = [];
|
|
const outDir = mkdtempSync(join(tmpdir(), "hf-render-cpu-"));
|
|
server = createStudioServer({ projectDir: tmpProject() });
|
|
|
|
producerState.executeRenderJob = async () => {};
|
|
const done = server.adapter.startRender(startRenderOpts("job-done", join(outDir, "a.mp4")));
|
|
await vi.waitFor(() => expect(done.status, done.error).toBe("complete"), { timeout: 5_000 });
|
|
|
|
producerState.executeRenderJob = async () => {
|
|
throw new Error("boom");
|
|
};
|
|
const failed = server.adapter.startRender({
|
|
...startRenderOpts("job-failed", join(outDir, "b.mp4")),
|
|
telemetryOptOut: true,
|
|
});
|
|
await vi.waitFor(() => expect(failed.status).toBe("failed"), { timeout: 5_000 });
|
|
|
|
let started!: () => void;
|
|
const startedPromise = new Promise<void>((resolve) => {
|
|
started = resolve;
|
|
});
|
|
producerState.executeRenderJob = (_job, _dir, _outputPath, _onProgress, signal) => {
|
|
started();
|
|
return new Promise((_resolve, reject) => {
|
|
const onAbort = () => reject(Object.assign(new Error("cancelled"), { name: "AbortError" }));
|
|
if (signal.aborted) onAbort();
|
|
else signal.addEventListener("abort", onAbort);
|
|
});
|
|
};
|
|
const cancelled = server.adapter.startRender(
|
|
startRenderOpts("job-cancelled", join(outDir, "c.mp4")),
|
|
);
|
|
await untilStarted(startedPromise, cancelled);
|
|
cancelled.cancel?.();
|
|
await vi.waitFor(() => expect(cancelled.status).toBe("cancelled"), { timeout: 5_000 });
|
|
|
|
expect(cpuSamplerState.samplers).toEqual([
|
|
{ requesterOptedIn: true, stopped: true },
|
|
{ requesterOptedIn: false, stopped: true },
|
|
{ requesterOptedIn: true, stopped: true },
|
|
]);
|
|
rmSync(outDir, { recursive: true, force: true });
|
|
});
|
|
|
|
it("forwards GIF loop count and writes a metadata sidecar without overwriting output", async () => {
|
|
producerState.executeRenderJob = async (job, _dir, outputPath) => {
|
|
expect(job).toMatchObject({ format: "gif", gifLoop: 3 });
|
|
writeFileSync(outputPath, "GIF89a");
|
|
};
|
|
const projectDir = tmpProject();
|
|
const outputPath = join(projectDir, "out.gif");
|
|
server = createStudioServer({ projectDir });
|
|
const state = server.adapter.startRender({
|
|
...startRenderOpts("gif-job", outputPath),
|
|
format: "gif",
|
|
gifLoop: 3,
|
|
});
|
|
await vi.waitFor(() => expect(state.status, state.error).toBe("complete"));
|
|
expect(readFileSync(outputPath, "utf8")).toBe("GIF89a");
|
|
expect(JSON.parse(readFileSync(join(projectDir, "out.meta.json"), "utf8"))).toMatchObject({
|
|
status: "complete",
|
|
});
|
|
});
|
|
|
|
it.each([false, true])(
|
|
"removes cancelled GIF output and sidecar (late completion: %s)",
|
|
async (lateCompletion) => {
|
|
const projectDir = tmpProject();
|
|
const outputPath = join(projectDir, "out.gif");
|
|
const metaPath = join(projectDir, "out.meta.json");
|
|
producerState.executeRenderJob = async (_job, _dir, output, _progress, signal) => {
|
|
writeFileSync(output, "partial-gif");
|
|
writeFileSync(metaPath, "{}");
|
|
await waitForRenderCancellation(signal, lateCompletion);
|
|
};
|
|
server = createStudioServer({ projectDir });
|
|
const state = server.adapter.startRender({
|
|
...startRenderOpts("gif-job", outputPath),
|
|
format: "gif",
|
|
});
|
|
await cancelAndVerifyArtifacts(state, outputPath, metaPath);
|
|
},
|
|
);
|
|
|
|
it("cancels an in-flight render's signal and waits for it before draining the browser pool", async () => {
|
|
const events: string[] = [];
|
|
let started!: () => void;
|
|
const startedPromise = new Promise<void>((resolve) => {
|
|
started = resolve;
|
|
});
|
|
producerState.executeRenderJob = (_job, _dir, _outputPath, _onProgress, signal) => {
|
|
started();
|
|
return new Promise((_resolve, reject) => {
|
|
const onAbort = () =>
|
|
setTimeout(() => {
|
|
events.push("render-settled");
|
|
reject(Object.assign(new Error("cancelled"), { name: "AbortError" }));
|
|
}, 20);
|
|
// A signal aborted before this executor ran would never fire a later
|
|
// "abort" listener (edge-triggered, not level-triggered) — check the
|
|
// already-aborted case too, same as real capture code must.
|
|
if (signal.aborted) onAbort();
|
|
else signal.addEventListener("abort", onAbort);
|
|
});
|
|
};
|
|
|
|
server = createStudioServer({ projectDir: tmpProject() });
|
|
const outputPath = join(tmpdir(), "shutdown-render.mp4");
|
|
const state = server.adapter.startRender(startRenderOpts("job-1", outputPath));
|
|
expect(state.status).toBe("rendering");
|
|
|
|
// Wait until the render has actually reached executeRenderJob (several
|
|
// microtask hops through loadStudioProducer/ensureBrowser) before racing
|
|
// it against shutdown, or shutdown could abort a signal nothing is
|
|
// listening on yet — a race in this test, not in the fix under test.
|
|
await untilStarted(startedPromise, state);
|
|
|
|
await server.shutdown();
|
|
events.push("drain-and-shutdown-returned");
|
|
|
|
expect(events).toEqual(["render-settled", "drain-and-shutdown-returned"]);
|
|
});
|
|
|
|
it("refuses a render started after shutdown has begun instead of launching a fresh browser", async () => {
|
|
let releaseFirstRender: () => void = () => {};
|
|
let started!: () => void;
|
|
const startedPromise = new Promise<void>((resolve) => {
|
|
started = resolve;
|
|
});
|
|
producerState.executeRenderJob = () => {
|
|
started();
|
|
return new Promise<void>((resolve) => {
|
|
releaseFirstRender = resolve;
|
|
});
|
|
};
|
|
|
|
server = createStudioServer({ projectDir: tmpProject() });
|
|
const first = server.adapter.startRender(startRenderOpts("job-1", join(tmpdir(), "a.mp4")));
|
|
await untilStarted(startedPromise, first);
|
|
|
|
const shutdownPromise = server.shutdown();
|
|
// shuttingDown is set synchronously as shutdown()'s first statement, so a
|
|
// render request arriving anywhere after that call has been made (even
|
|
// before it resolves) must already see it.
|
|
const late = server.adapter.startRender(startRenderOpts("job-2", join(tmpdir(), "b.mp4")));
|
|
|
|
expect(late.status).toBe("failed");
|
|
expect(late.error).toMatch(/shutting down/i);
|
|
|
|
releaseFirstRender();
|
|
await shutdownPromise;
|
|
});
|
|
|
|
const thumbnailOpts = () => ({
|
|
project: { id: "demo", dir: tmpProject(), title: "demo" },
|
|
compPath: "index.html",
|
|
seekTime: 0.5,
|
|
width: 640,
|
|
height: 360,
|
|
outputWidth: 640,
|
|
outputHeight: 360,
|
|
previewUrl: "http://localhost/preview",
|
|
signal: new AbortController().signal,
|
|
});
|
|
|
|
it("does not launch a browser for a thumbnail request after shutdown has begun", async () => {
|
|
const acquire = vi.fn();
|
|
engineState.acquireBrowser = acquire;
|
|
server = createStudioServer({ projectDir: tmpProject() });
|
|
await server.shutdown();
|
|
|
|
await expect(server.adapter.generateThumbnail?.(thumbnailOpts())).resolves.toBeNull();
|
|
expect(acquire).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it("releases a thumbnail browser that finished launching after shutdown began", async () => {
|
|
const release = vi.fn(async () => {});
|
|
let launched!: () => void;
|
|
const launchedPromise = new Promise<void>((resolve) => (launched = resolve));
|
|
let finishLaunch: () => void = () => {};
|
|
engineState.acquireBrowser = async () => {
|
|
launched();
|
|
await new Promise<void>((resolve) => (finishLaunch = resolve));
|
|
return { browser: new EventEmitter(), release };
|
|
};
|
|
let reachedBrowserClose!: () => void;
|
|
const reachedBrowserClosePromise = new Promise<void>(
|
|
(resolve) => (reachedBrowserClose = resolve),
|
|
);
|
|
engineState.closeBrowserPool = async () => reachedBrowserClose();
|
|
server = createStudioServer({ projectDir: tmpProject() });
|
|
const thumbnail = server.adapter.generateThumbnail?.(thumbnailOpts());
|
|
await launchedPromise;
|
|
|
|
const shutdown = server.shutdown();
|
|
// shutdown() starts the pool close alongside the thumbnail-browser close,
|
|
// before it waits on renders: closing is the signal the close has begun
|
|
// while the launch is still pending, without racing a fixed sleep.
|
|
await reachedBrowserClosePromise;
|
|
finishLaunch();
|
|
await shutdown;
|
|
|
|
await expect(thumbnail).resolves.toBeNull();
|
|
expect(release).toHaveBeenCalledTimes(1);
|
|
});
|
|
|
|
it("closes browsers within a bounded timeout even when a render's done promise never settles", async () => {
|
|
const closeBrowserPool = vi.fn(async () => {});
|
|
engineState.closeBrowserPool = closeBrowserPool;
|
|
const release = vi.fn(async () => {});
|
|
let launched!: () => void;
|
|
const launchedPromise = new Promise<void>((resolve) => (launched = resolve));
|
|
let finishLaunch: () => void = () => {};
|
|
engineState.acquireBrowser = async () => {
|
|
launched();
|
|
await new Promise<void>((resolve) => (finishLaunch = resolve));
|
|
return { browser: new EventEmitter(), release };
|
|
};
|
|
|
|
let started!: () => void;
|
|
const startedPromise = new Promise<void>((resolve) => {
|
|
started = resolve;
|
|
});
|
|
producerState.executeRenderJob = () => {
|
|
started();
|
|
// Never settles, even once aborted -- the pathological case the CLI's
|
|
// 3s exit watchdog exists to survive.
|
|
return new Promise<void>(() => {});
|
|
};
|
|
|
|
server = createStudioServer({ projectDir: tmpProject() });
|
|
const state = server.adapter.startRender(startRenderOpts("job-1", join(tmpdir(), "hang.mp4")));
|
|
await untilStarted(startedPromise, state);
|
|
|
|
const thumbnail = server.adapter.generateThumbnail?.(thumbnailOpts());
|
|
await launchedPromise;
|
|
finishLaunch();
|
|
|
|
let timer: ReturnType<typeof setTimeout> | undefined;
|
|
const never = new Promise<never>((_, reject) => {
|
|
timer = setTimeout(
|
|
() => reject(new Error("shutdown() did not resolve within its bound")),
|
|
3_000,
|
|
);
|
|
});
|
|
try {
|
|
await Promise.race([server.shutdown(), never]);
|
|
} finally {
|
|
clearTimeout(timer);
|
|
}
|
|
|
|
expect(release).toHaveBeenCalledTimes(1);
|
|
expect(closeBrowserPool).toHaveBeenCalledTimes(1);
|
|
await expect(thumbnail).resolves.toBeNull();
|
|
});
|
|
|
|
it("does not hand an already-leased browser to a new caller once shutdown has begun", async () => {
|
|
const release = vi.fn(async () => {});
|
|
const newPage = vi.fn(async () => {
|
|
throw new Error("no real page in this test double");
|
|
});
|
|
engineState.acquireBrowser = async () => ({
|
|
browser: { connected: true, newPage, on: () => {} },
|
|
release,
|
|
});
|
|
|
|
server = createStudioServer({ projectDir: tmpProject() });
|
|
await server.adapter.generateThumbnail?.(thumbnailOpts());
|
|
expect(newPage).toHaveBeenCalledTimes(1);
|
|
|
|
const shutdownPromise = server.shutdown();
|
|
// shuttingDown flips true synchronously as shutdown()'s first statement,
|
|
// before its closeThumbnailBrowser() call runs -- this request lands in
|
|
// that window and must not reuse the still-connected lease.
|
|
const late = server.adapter.generateThumbnail?.(thumbnailOpts());
|
|
|
|
await expect(late).resolves.toBeNull();
|
|
expect(newPage).toHaveBeenCalledTimes(1);
|
|
await shutdownPromise;
|
|
});
|
|
});
|
|
|
|
describe("Studio thumbnail capture", () => {
|
|
// The thumbnail browser lease is module-wide; without a shutdown the next test inherits this one's fake.
|
|
afterEach(async () => {
|
|
await server?.shutdown();
|
|
});
|
|
function fakePageBrowser(onEvaluate = () => {}) {
|
|
const screenshot = vi.fn(async () => Buffer.from("jpeg"));
|
|
const evaluate = vi.fn(async () => onEvaluate());
|
|
const page = new Proxy(
|
|
{ screenshot, evaluate },
|
|
{
|
|
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 () => {},
|
|
});
|
|
return { screenshot, evaluate };
|
|
}
|
|
const opts = (dir: string, signal = new AbortController().signal) => ({
|
|
project: { id: "demo", dir, title: "demo" },
|
|
compPath: "index.html",
|
|
seekTime: 0.5,
|
|
width: 640,
|
|
height: 360,
|
|
outputWidth: 640,
|
|
outputHeight: 360,
|
|
previewUrl: "http://localhost/preview",
|
|
signal,
|
|
});
|
|
|
|
it("stops a thumbnail whose request is aborted before its screenshot", async () => {
|
|
let abortOnEvaluate: AbortController | undefined;
|
|
const { screenshot } = fakePageBrowser(() => abortOnEvaluate?.abort());
|
|
const dir = tmpProject();
|
|
server = createStudioServer({ projectDir: dir });
|
|
await expect(server.adapter.generateThumbnail?.(opts(dir))).resolves.toBeInstanceOf(Buffer);
|
|
expect(screenshot).toHaveBeenCalledTimes(1);
|
|
|
|
const aborting = new AbortController();
|
|
abortOnEvaluate = aborting;
|
|
await expect(
|
|
server.adapter.generateThumbnail?.(opts(dir, aborting.signal)),
|
|
).resolves.toBeNull();
|
|
expect(screenshot).toHaveBeenCalledTimes(1);
|
|
});
|
|
|
|
// fails without the fix: the thumbnail browser launched with no page server, so with
|
|
// PRODUCER_RESTRICT_PAGE_NETWORK on its proxy refused the Studio's own preview and every thumbnail failed.
|
|
it("gives the thumbnail browser the preview's server, and a new browser for a preview on another host", async () => {
|
|
fakePageBrowser();
|
|
const launch = vi.spyOn(engineState, "acquireBrowser");
|
|
const dir = tmpProject();
|
|
server = createStudioServer({ projectDir: dir });
|
|
const at = (previewUrl: string) => ({ ...opts(dir), previewUrl });
|
|
await server.adapter.generateThumbnail?.(at("http://127.0.0.1:4100/api/projects/demo/preview"));
|
|
await server.adapter.generateThumbnail?.(at("http://127.0.0.1:4100/api/projects/demo/preview"));
|
|
await server.adapter.generateThumbnail?.(at("http://localhost:4200/api/projects/demo/preview"));
|
|
expect(
|
|
launch.mock.calls.map((call) => (call[1] as { pageServerUrl?: string }).pageServerUrl),
|
|
).toEqual([
|
|
"http://127.0.0.1:4100/api/projects/demo/preview",
|
|
"http://localhost:4200/api/projects/demo/preview",
|
|
]);
|
|
});
|
|
|
|
// fails without the fix: the direct host came from each preview URL, which a request's loopback Host header
|
|
// can name, so a request could open another local port to the thumbnail page and two spellings of one server
|
|
// closed each other's browser.
|
|
it("gives the thumbnail browser the server's own origin, whatever host a request named", async () => {
|
|
fakePageBrowser();
|
|
const launch = vi.spyOn(engineState, "acquireBrowser");
|
|
const dir = tmpProject();
|
|
server = createStudioServer({ projectDir: dir, origin: () => "http://127.0.0.1:4100" });
|
|
const at = (previewUrl: string) => ({ ...opts(dir), previewUrl });
|
|
await server.adapter.generateThumbnail?.(at("http://127.0.0.1:4100/api/projects/demo/preview"));
|
|
await server.adapter.generateThumbnail?.(at("http://localhost:4100/api/projects/demo/preview"));
|
|
await server.adapter.generateThumbnail?.(at("http://localhost:9999/api/projects/demo/preview"));
|
|
expect(
|
|
launch.mock.calls.map((call) => (call[1] as { pageServerUrl?: string }).pageServerUrl),
|
|
).toEqual(["http://127.0.0.1:4100"]);
|
|
});
|
|
|
|
it("undoes a row's isolation after its screenshot, since the page is reused", async () => {
|
|
const { screenshot, evaluate } = fakePageBrowser();
|
|
const dir = tmpProject();
|
|
server = createStudioServer({ projectDir: dir });
|
|
await server.adapter.generateThumbnail?.({ ...opts(dir), selector: "#title" });
|
|
const clears = evaluate.mock.calls.flatMap((call, i) =>
|
|
((call as unknown[])[0] as { name?: string }).name === "clearElementScreenshotIsolation"
|
|
? [evaluate.mock.invocationCallOrder[i]!]
|
|
: [],
|
|
);
|
|
expect(clears).toHaveLength(1);
|
|
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"), '<div data-composition-id="main"></div>');
|
|
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", {
|
|
headers: { "Sec-Fetch-Site": "same-origin" },
|
|
});
|
|
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();
|
|
server = createStudioServer({ projectDir: dir });
|
|
await server.adapter.generateThumbnail?.(opts(dir));
|
|
const walks = vi.mocked(createProjectSignature).mock.calls.length;
|
|
for (let i = 0; i < 3; i++) await server.adapter.generateThumbnail?.(opts(dir));
|
|
expect(vi.mocked(createProjectSignature).mock.calls.length).toBe(walks);
|
|
});
|
|
});
|
|
|
|
describe("Studio project lint endpoint", () => {
|
|
it("surfaces findings that require the complete project graph", async () => {
|
|
const projectDir = tmpProject();
|
|
mkdirSync(join(projectDir, "compositions"));
|
|
mkdirSync(join(projectDir, "scenes"));
|
|
writeFileSync(
|
|
join(projectDir, "index.html"),
|
|
`<html><body><div data-composition-id="main" data-width="1920" data-height="1080" data-start="0" data-duration="10"></div></body></html>`,
|
|
);
|
|
writeFileSync(
|
|
join(projectDir, "compositions", "index.html"),
|
|
`<html><body><div data-composition-id="authored" data-width="1920" data-height="1080" data-start="0" data-duration="5"><div class="clip" data-start="0" data-duration="5">Visible</div></div></body></html>`,
|
|
);
|
|
writeFileSync(join(projectDir, "scenes", "intro.html"), "<html><body>Intro</body></html>");
|
|
server = createStudioServer({ projectDir, projectName: "demo" });
|
|
|
|
const response = await server.app.request("http://localhost/api/projects/demo/lint");
|
|
const payload = (await response.json()) as {
|
|
findings?: Array<{ code?: string; file?: string }>;
|
|
};
|
|
|
|
expect(response.status).toBe(200);
|
|
expect(payload.findings).toContainEqual(
|
|
expect.objectContaining({ code: "blank_root_with_standalone_composition" }),
|
|
);
|
|
expect(payload.findings).toContainEqual(expect.objectContaining({ file: "scenes/intro.html" }));
|
|
expect(payload.findings?.every((finding) => !finding.file?.startsWith(projectDir))).toBe(true);
|
|
});
|
|
});
|
|
|
|
describe("host guarding on identity-bearing responses", () => {
|
|
// NOTE: the SPA-injection branch itself is covered in telemetryIdentity.test.ts
|
|
// via buildStudioHeadScriptsForHost. It cannot be asserted here: this route
|
|
// only reaches the injection branch when packages/studio/dist is built,
|
|
// which is true locally and false in the CI test lane, so a route-level
|
|
// assertion on the returned HTML passes on a dev box and fails in CI.
|
|
|
|
it("refuses the identity endpoint for a hostile Host", async () => {
|
|
server = createStudioServer({ projectDir: tmpProject() });
|
|
const res = await server.app.request("/api/telemetry-identity", {
|
|
headers: { host: "evil.example.com" },
|
|
});
|
|
expect(res.status).toBe(403);
|
|
expect(await res.text()).not.toContain('distinctId":"');
|
|
});
|
|
|
|
it("gives the thumbnail browser the origin it listens on, not the request's", async () => {
|
|
let listening: string | undefined;
|
|
server = createStudioServer({ projectDir: tmpProject(), origin: () => listening });
|
|
expect(server.adapter.serverOrigin?.()).toBeUndefined();
|
|
listening = "http://127.0.0.1:3002";
|
|
expect(server.adapter.serverOrigin?.()).toBe("http://127.0.0.1:3002");
|
|
});
|
|
|
|
it("serves the identity endpoint on a loopback Host", async () => {
|
|
server = createStudioServer({ projectDir: tmpProject() });
|
|
const res = await server.app.request("/api/telemetry-identity", {
|
|
headers: { host: "127.0.0.1:5173" },
|
|
});
|
|
expect(res.status).toBe(200);
|
|
// The seed is no longer served here at all — Studio gets decisions
|
|
// injected instead, so nothing needs it over HTTP.
|
|
expect(Object.keys((await res.json()) as object)).toEqual(["distinctId"]);
|
|
});
|
|
});
|
|
|
|
// Studio asks this before it offers Export, so a machine without an encoder
|
|
// gets an install command up front instead of a 503 after the work is done.
|
|
describe("FFmpeg environment endpoint", () => {
|
|
it("reports the cause and a pasteable command when FFmpeg is unusable", async () => {
|
|
// A configured-but-missing override is the one "no FFmpeg" state a test can
|
|
// force on a machine that does have FFmpeg installed.
|
|
process.env.HYPERFRAMES_FFMPEG_PATH = join(tmpdir(), "hf-missing-ffmpeg");
|
|
server = createStudioServer({ projectDir: tmpProject() });
|
|
|
|
const res = await server.app.request("/api/environment/ffmpeg");
|
|
expect(res.status).toBe(200);
|
|
const body = (await res.json()) as {
|
|
ok: boolean;
|
|
title?: string;
|
|
detail?: string;
|
|
command?: string;
|
|
};
|
|
|
|
expect(body.ok).toBe(false);
|
|
expect(body.title).toContain("not found");
|
|
expect(body.detail).toBeTruthy();
|
|
// Undefined only on platforms with no one-line install; CI runs none.
|
|
expect(body.command).toBeTruthy();
|
|
});
|
|
|
|
// Needs a real FFmpeg: the check runs `-version` on whatever it resolves, so
|
|
// a stand-in binary would only prove the stand-in works. Skipped rather than
|
|
// faked on machines without one.
|
|
it.skipIf(!findFFmpeg() || !findFFprobe())(
|
|
"answers a plain ok when both binaries resolve",
|
|
async () => {
|
|
server = createStudioServer({ projectDir: tmpProject() });
|
|
|
|
const res = await server.app.request("/api/environment/ffmpeg");
|
|
|
|
expect(await res.json()).toEqual({ ok: true });
|
|
},
|
|
);
|
|
});
|
|
|
|
describe("Studio file-change SSE", () => {
|
|
/** Opens `count` `/api/events` connections and waits for each to register its listener. */
|
|
async function subscribe(count: number): Promise<ReadableStreamDefaultReader<Uint8Array>[]> {
|
|
const responses = await Promise.all(
|
|
Array.from({ length: count }, () => server!.app.request("/api/events")),
|
|
);
|
|
const streams = responses.map((response) => {
|
|
const reader = response.body!.getReader();
|
|
openReaders.push(reader);
|
|
return reader;
|
|
});
|
|
// streamSSE runs its callback after the Response resolves, so the listener
|
|
// each connection adds has to exist before the watcher fires.
|
|
await new Promise((resolve) => setTimeout(resolve, 20));
|
|
return streams;
|
|
}
|
|
|
|
const nextEvent = async (reader: ReadableStreamDefaultReader<Uint8Array>): Promise<string> =>
|
|
new TextDecoder().decode((await reader.read()).value);
|
|
|
|
/** The version as it appears inside the JSON-encoded SSE data line. */
|
|
const encodedVersion = (content: string): string =>
|
|
fileContentVersion(content).replaceAll('"', '\\"');
|
|
|
|
/** A project whose preview has been loaded once, as an open Studio tab does on its first render. */
|
|
async function previewedProject(): Promise<{ projectDir: string; projectUrl: string }> {
|
|
const projectDir = tmpProject();
|
|
mkdirSync(join(projectDir, "assets"));
|
|
writeFileSync(join(projectDir, "assets", "logo.png"), "logo-v1");
|
|
writeFileSync(
|
|
join(projectDir, "index.html"),
|
|
'<html><body><div data-composition-id="root"><img src="assets/logo.png"></div></body></html>',
|
|
);
|
|
server = createStudioServer({ projectDir });
|
|
const projectUrl = `/api/projects/${encodeURIComponent(basename(projectDir))}`;
|
|
// An unread asset body keeps logo.png open, and Windows refuses to move a folder holding an open file.
|
|
for (const path of [`${projectUrl}/preview`, `${projectUrl}/preview/assets/logo.png`]) {
|
|
const response = await server.app.request(path);
|
|
expect(response.status).toBe(200);
|
|
await response.arrayBuffer();
|
|
}
|
|
return { projectDir, projectUrl };
|
|
}
|
|
|
|
it("leaves no timer behind once the tab disconnects, so a stopping CLI can exit", async () => {
|
|
server = createStudioServer({ projectDir: tmpProject() });
|
|
const timeouts = vi.spyOn(globalThis, "setTimeout");
|
|
const [stream] = await subscribe(1);
|
|
await stream!.cancel();
|
|
|
|
const keepAlive = timeouts.mock.calls.filter(([, ms]) => (ms ?? 0) >= 30_000);
|
|
timeouts.mockRestore();
|
|
expect(keepAlive).toEqual([]);
|
|
});
|
|
|
|
it("marks a notes write as not affecting the preview, so the tab does not reload", async () => {
|
|
const { projectDir } = await previewedProject();
|
|
const [stream] = await subscribe(1);
|
|
|
|
writeFileSync(join(projectDir, "notes.md"), "review notes");
|
|
mockWatcher.emit("change", "rename", "notes.md");
|
|
|
|
const payload = await nextEvent(stream!);
|
|
expect(payload).toContain('"path":"notes.md"');
|
|
expect(payload).toContain('"affectsPreview":false');
|
|
expect(payload).toContain('"affectedCompositions":[]');
|
|
});
|
|
|
|
it("marks a write to an asset the preview loaded as affecting it", async () => {
|
|
const { projectDir } = await previewedProject();
|
|
const [stream] = await subscribe(1);
|
|
|
|
writeFileSync(join(projectDir, "assets", "logo.png"), "logo-v2");
|
|
mockWatcher.emit("change", "change", "assets/logo.png");
|
|
|
|
expect(await nextEvent(stream!)).toContain('"affectsPreview":true');
|
|
});
|
|
|
|
it("reloads when a folder holding an asset the preview missed is moved in", async () => {
|
|
const { projectDir, projectUrl } = await previewedProject();
|
|
expect((await server!.app.request(`${projectUrl}/preview/media/clip.png`)).status).toBe(404);
|
|
const [stream] = await subscribe(1);
|
|
|
|
mkdirSync(join(projectDir, "media"));
|
|
writeFileSync(join(projectDir, "media", "clip.png"), "clip");
|
|
mockWatcher.emit("change", "rename", "media");
|
|
|
|
const payload = await nextEvent(stream!);
|
|
expect(payload).toContain('"path":"media"');
|
|
expect(payload).toContain('"affectsPreview":true');
|
|
});
|
|
|
|
it("reloads when a folder holding an asset the preview loaded is moved out", async () => {
|
|
const { projectDir } = await previewedProject();
|
|
const [stream] = await subscribe(1);
|
|
|
|
renameSync(join(projectDir, "assets"), join(tmpProject(), "assets"));
|
|
mockWatcher.emit("change", "rename", "assets");
|
|
|
|
expect(await nextEvent(stream!)).toContain('"affectsPreview":true');
|
|
});
|
|
|
|
it("still delivers a new file in a folder an old watchIgnore listed, for the file tree", async () => {
|
|
const { projectDir } = await previewedProject();
|
|
writeFileSync(
|
|
join(projectDir, "hyperframes.json"),
|
|
JSON.stringify({ preview: { watchIgnore: ["docs"] } }),
|
|
);
|
|
const [stream] = await subscribe(1);
|
|
|
|
mkdirSync(join(projectDir, "docs"));
|
|
writeFileSync(join(projectDir, "docs", "report.json"), "{}");
|
|
mockWatcher.emit("change", "rename", "docs/report.json");
|
|
|
|
const payload = await nextEvent(stream!);
|
|
expect(payload).toContain('"path":"docs/report.json"');
|
|
expect(payload).toContain('"affectsPreview":false');
|
|
});
|
|
|
|
it("counts every write as affecting the preview until the preview has loaded anything", async () => {
|
|
const projectDir = tmpProject();
|
|
writeFileSync(join(projectDir, "index.html"), "<html></html>");
|
|
server = createStudioServer({ projectDir });
|
|
const [stream] = await subscribe(1);
|
|
|
|
writeFileSync(join(projectDir, "notes.md"), "notes");
|
|
mockWatcher.emit("change", "rename", "notes.md");
|
|
|
|
expect(await nextEvent(stream!)).toContain('"affectsPreview":true');
|
|
});
|
|
|
|
it("labels a Studio write for every open subscriber, not just the first", async () => {
|
|
const projectDir = tmpProject();
|
|
writeFileSync(join(projectDir, "index.html"), "<html>before</html>");
|
|
server = createStudioServer({ projectDir });
|
|
const streams = await subscribe(2);
|
|
|
|
const written = "<html>after</html>";
|
|
const write = await server.app.request(
|
|
`/api/projects/${encodeURIComponent(basename(projectDir))}/files/index.html`,
|
|
{
|
|
method: "PUT",
|
|
headers: {
|
|
"If-Match": fileContentVersion("<html>before</html>"),
|
|
"X-Hyperframes-Write-Token": "studio-write-1",
|
|
},
|
|
body: written,
|
|
},
|
|
);
|
|
expect(write.status).toBe(200);
|
|
mockWatcher.emit("change", "change", "index.html");
|
|
|
|
for (const payload of await Promise.all(streams.map(nextEvent))) {
|
|
expect(payload).toContain("studio-write-1");
|
|
expect(payload).toContain(encodedVersion(written));
|
|
}
|
|
});
|
|
|
|
it("still reports an external write with a version so subscribers can dedupe it", async () => {
|
|
const projectDir = tmpProject();
|
|
writeFileSync(join(projectDir, "index.html"), "<html>before</html>");
|
|
server = createStudioServer({ projectDir });
|
|
const streams = await subscribe(2);
|
|
|
|
writeFileSync(join(projectDir, "index.html"), "<html>agent</html>");
|
|
mockWatcher.emit("change", "change", "index.html");
|
|
|
|
for (const payload of await Promise.all(streams.map(nextEvent))) {
|
|
expect(payload).not.toContain("writeToken");
|
|
expect(payload).toContain(encodedVersion("<html>agent</html>"));
|
|
}
|
|
});
|
|
|
|
it("labels the deletion an undo from Studio makes with Studio's write token", async () => {
|
|
const projectDir = tmpProject();
|
|
writeFileSync(join(projectDir, "index.html"), "<html>before</html>");
|
|
server = createStudioServer({ projectDir, historyRoot: tmpProject() });
|
|
const history = `/api/projects/${encodeURIComponent(basename(projectDir))}/history`;
|
|
const post = (path: string, body: object, headers: Record<string, string> = {}) =>
|
|
server!.app.request(`${history}${path}`, {
|
|
method: "POST",
|
|
headers: { "Content-Type": "application/json", ...headers },
|
|
body: JSON.stringify(body),
|
|
});
|
|
await server.app.request(history); // opens the history, as Studio's first load does
|
|
writeFileSync(join(projectDir, "extra.html"), "<html>added</html>");
|
|
await post("/claim", { label: "Added a section", paths: ["extra.html"] });
|
|
const streams = await subscribe(1);
|
|
|
|
await post("/step", { direction: "back" }, { "X-Hyperframes-Write-Token": "studio-undo-1" });
|
|
expect(existsSync(join(projectDir, "extra.html"))).toBe(false);
|
|
mockWatcher.emit("change", "rename", "extra.html");
|
|
|
|
const [payload] = await Promise.all(streams.map(nextEvent));
|
|
expect(payload).toContain("studio-undo-1");
|
|
});
|
|
|
|
// `/api/events` is one connection per SERVER, not per project: a tab left
|
|
// open from a `preview` run whose port was later reused by a DIFFERENT
|
|
// project shares this exact stream. Without `projectId` on the wire, that
|
|
// stale tab cannot tell "my project changed" from "the other project this
|
|
// server now serves changed" — see useExternalFileChangeCoordinator's
|
|
// cross-project filter, which reads this field.
|
|
it("labels every file-change with this server's project id", async () => {
|
|
const projectDir = tmpProject();
|
|
writeFileSync(join(projectDir, "index.html"), "<html>before</html>");
|
|
server = createStudioServer({ projectDir, projectName: "demo-project" });
|
|
const streams = await subscribe(1);
|
|
|
|
writeFileSync(join(projectDir, "index.html"), "<html>agent</html>");
|
|
mockWatcher.emit("change", "change", "index.html");
|
|
|
|
const [payload] = await Promise.all(streams.map(nextEvent));
|
|
expect(payload).toContain('"projectId":"demo-project"');
|
|
});
|
|
});
|
|
|
|
describe("createStudioServer /api write guard allowed hosts", () => {
|
|
const TUNNEL_HOST = "demo.tunnels.example";
|
|
|
|
async function tunnelWrite(projectDir: string): Promise<Response> {
|
|
// A write from the Studio page behind a tunnel, driven through the
|
|
// CLI's own /api/* forwarder, the way a browser save reaches the API.
|
|
return server!.app.request(
|
|
`http://${TUNNEL_HOST}/api/projects/${encodeURIComponent(basename(projectDir))}/files/planted.html`,
|
|
{
|
|
method: "POST",
|
|
headers: {
|
|
Host: TUNNEL_HOST,
|
|
Origin: `https://${TUNNEL_HOST}`,
|
|
"X-Forwarded-Proto": "https",
|
|
"Content-Type": "text/plain",
|
|
},
|
|
body: "<html>planted</html>",
|
|
},
|
|
);
|
|
}
|
|
|
|
it("refuses a tunnel write without the env var, naming the host and the var", async () => {
|
|
const projectDir = tmpProject();
|
|
writeFileSync(join(projectDir, "index.html"), "<html>before</html>");
|
|
delete process.env.HYPERFRAMES_PREVIEW_ALLOWED_HOSTS;
|
|
server = createStudioServer({ projectDir });
|
|
|
|
const res = await tunnelWrite(projectDir);
|
|
expect(res.status).toBe(403);
|
|
const body = (await res.json()) as { error: string };
|
|
expect(body.error).toContain(TUNNEL_HOST);
|
|
expect(body.error).toContain("HYPERFRAMES_PREVIEW_ALLOWED_HOSTS");
|
|
expect(existsSync(join(projectDir, "planted.html"))).toBe(false);
|
|
});
|
|
|
|
it("accepts a tunnel write when HYPERFRAMES_PREVIEW_ALLOWED_HOSTS names the host", async () => {
|
|
const projectDir = tmpProject();
|
|
writeFileSync(join(projectDir, "index.html"), "<html>before</html>");
|
|
process.env.HYPERFRAMES_PREVIEW_ALLOWED_HOSTS = `other.example, ${TUNNEL_HOST}`;
|
|
try {
|
|
server = createStudioServer({ projectDir });
|
|
const res = await tunnelWrite(projectDir);
|
|
expect(res.status).toBe(201);
|
|
expect(existsSync(join(projectDir, "planted.html"))).toBe(true);
|
|
} finally {
|
|
delete process.env.HYPERFRAMES_PREVIEW_ALLOWED_HOSTS;
|
|
}
|
|
});
|
|
});
|
|
|
|
describe("createStudioServer Host check on every route", () => {
|
|
const FOREIGN_HOST = "rebound.example:3002";
|
|
|
|
function read(path: string, host: string, extra: Record<string, string> = {}): Promise<Response> {
|
|
return Promise.resolve(
|
|
server!.app.request(`http://${host}${path}`, { headers: { Host: host, ...extra } }),
|
|
);
|
|
}
|
|
|
|
function routes(projectDir: string): string[] {
|
|
const id = encodeURIComponent(basename(projectDir));
|
|
return [
|
|
"/__hyperframes_config",
|
|
"/api/projects",
|
|
`/api/projects/${id}/files/index.html`,
|
|
"/api/events",
|
|
"/",
|
|
];
|
|
}
|
|
|
|
it("refuses reads on every route for a Host the server does not answer on", async () => {
|
|
const projectDir = tmpProject();
|
|
writeFileSync(join(projectDir, "index.html"), "<html>secret-body</html>");
|
|
delete process.env.HYPERFRAMES_PREVIEW_ALLOWED_HOSTS;
|
|
server = createStudioServer({ projectDir });
|
|
|
|
for (const path of routes(projectDir)) {
|
|
const res = await read(path, FOREIGN_HOST);
|
|
expect(res.status, path).toBe(403);
|
|
const text = await res.text();
|
|
expect(text, path).not.toContain("secret-body");
|
|
expect(text, path).not.toContain(projectDir);
|
|
expect(text, path).toContain("HYPERFRAMES_PREVIEW_ALLOWED_HOSTS");
|
|
}
|
|
});
|
|
|
|
it("does not let X-Forwarded-Host stand in for the Host header", async () => {
|
|
const projectDir = tmpProject();
|
|
writeFileSync(join(projectDir, "index.html"), "<html>secret-body</html>");
|
|
server = createStudioServer({ projectDir });
|
|
|
|
const res = await read("/__hyperframes_config", FOREIGN_HOST, {
|
|
"X-Forwarded-Host": "localhost:3002",
|
|
});
|
|
expect(res.status).toBe(403);
|
|
});
|
|
|
|
it("answers loopback names", async () => {
|
|
const projectDir = tmpProject();
|
|
writeFileSync(join(projectDir, "index.html"), "<html>secret-body</html>");
|
|
server = createStudioServer({ projectDir });
|
|
|
|
for (const host of ["localhost:3002", "127.0.0.1:3002", "[::1]:3002"]) {
|
|
const config = await read("/__hyperframes_config", host);
|
|
expect(config.status, host).toBe(200);
|
|
const file = await read(
|
|
`/api/projects/${encodeURIComponent(basename(projectDir))}/files/index.html`,
|
|
host,
|
|
);
|
|
expect(file.status, host).toBe(200);
|
|
expect(await file.text(), host).toContain("secret-body");
|
|
}
|
|
});
|
|
|
|
it("answers a host named in HYPERFRAMES_PREVIEW_ALLOWED_HOSTS", async () => {
|
|
const projectDir = tmpProject();
|
|
writeFileSync(join(projectDir, "index.html"), "<html>secret-body</html>");
|
|
process.env.HYPERFRAMES_PREVIEW_ALLOWED_HOSTS = "demo.tunnels.example";
|
|
try {
|
|
server = createStudioServer({ projectDir });
|
|
const res = await read("/__hyperframes_config", "demo.tunnels.example");
|
|
expect(res.status).toBe(200);
|
|
const other = await read("/__hyperframes_config", FOREIGN_HOST);
|
|
expect(other.status).toBe(403);
|
|
} finally {
|
|
delete process.env.HYPERFRAMES_PREVIEW_ALLOWED_HOSTS;
|
|
}
|
|
});
|
|
});
|
|
|
|
describe("createStudioServer preview image preparation", () => {
|
|
const html = '<div data-composition-id="main"><img src="photo.png"></div>';
|
|
const prepared = (projectDir: string) =>
|
|
["heif", "gif"].filter((kind) =>
|
|
existsSync(join(projectDir, ".hyperframes", "prepared-assets", kind, "converted")),
|
|
);
|
|
|
|
it("prepares HEIF and GIF images inside a project's own .hyperframes folder", async () => {
|
|
const projectDir = tmpProject();
|
|
server = createStudioServer({ projectDir });
|
|
|
|
await server.adapter.transformPreviewHtml?.({
|
|
html,
|
|
project: { id: "p", dir: projectDir },
|
|
activeCompositionPath: "index.html",
|
|
});
|
|
|
|
expect(prepared(projectDir)).toEqual(["heif", "gif"]);
|
|
});
|
|
|
|
it.skipIf(process.platform === "win32")(
|
|
"serves images unprepared when .hyperframes is a link, and writes nothing where it points",
|
|
async () => {
|
|
const projectDir = tmpProject();
|
|
const outside = tmpProject();
|
|
symlinkSync(outside, join(projectDir, ".hyperframes"));
|
|
server = createStudioServer({ projectDir });
|
|
|
|
const served = await server.adapter.transformPreviewHtml?.({
|
|
html,
|
|
project: { id: "p", dir: projectDir },
|
|
activeCompositionPath: "index.html",
|
|
});
|
|
|
|
expect(served).toContain('src="photo.png"');
|
|
expect(readdirSync(outside)).toEqual([]);
|
|
},
|
|
);
|
|
});
|