mirror of
https://github.com/heygen-com/hyperframes.git
synced 2026-08-31 02:41:44 +00:00
Miguel Ángel
5058236eda
Exporting without FFmpeg installed used to show "Server error (503). Check
the terminal for details." The server already knew the exact cause and sent
a per-platform install command in the response body; Studio discarded that
body and printed the status code. The user found out only after the
composition was finished.
Studio now asks the dev server on load whether this machine can encode, and
the Renders panel shows the cause plus a copyable install command when it
cannot, with a Recheck that avoids restarting Studio.
- New GET /api/environment/ffmpeg calls runEnvironmentChecks() with every
optional check off, which is exactly the FFmpeg and ffprobe pair `doctor`
runs, so Studio and the CLI cannot disagree. Only a passing result is
cached.
- The refusal lives in startRender, not in a button. Studio renders from
three places (the panel's Export, the header's, and each composition card
in the sidebar), so a per-button check would leave the others free to
queue a render that cannot finish. The header and sidebar controls reveal
the prompt rather than going dead.
- A null probe result means "no answer", not "missing", so an older or
unreachable dev server cannot lock a working setup.
- Failed render responses now surface the server's { error, hint }.
- getFFmpegInstallCommand() is the single owner of platform-to-command, with
the prose hint derived from it. Windows gains a winget command and keeps
the manual download route.
Accessibility: the prompt's explanatory line measured 2.2:1 on the card's
amber background against a 4.5:1 minimum, because the panel's usual grey for
secondary text does not survive the tint. Now 6.6:1. Keyboard focus was
invisible on all three controls and now matches the panel's focus ring.
Also folds in cleanups the repo's gates required: the Renders tab moves out
of StudioRightPanel (it was at the 600-line cap and every field it needed was
already on the shell context), StudioContextInput stops keeping a second copy
of the renderQueue shape, and the server tests share one temp-project helper.
185 lines
6.2 KiB
JavaScript
185 lines
6.2 KiB
JavaScript
#!/usr/bin/env node
|
|
|
|
import { createRequire } from "node:module";
|
|
import { join } from "node:path";
|
|
import { fileURLToPath } from "node:url";
|
|
|
|
const ROOT = join(import.meta.dirname, "..");
|
|
const PROJECT_ID = "smoke-test";
|
|
export const SMOKE_COMPOSITION_HTML =
|
|
'<!doctype html><html><body><div data-composition-id="root" data-width="1920" ' +
|
|
'data-height="1080" data-duration="1" data-start="0"><div class="clip" ' +
|
|
'data-hf-id="title" data-start="0" data-duration="1">Test</div></div></body></html>';
|
|
const SMOKE_THUMBNAIL_SVG =
|
|
'<svg xmlns="http://www.w3.org/2000/svg" width="16" height="9"><rect width="16" height="9"/></svg>';
|
|
|
|
function json(body, status = 200) {
|
|
return { status, contentType: "application/json", body: JSON.stringify(body) };
|
|
}
|
|
|
|
function text(body, contentType = "text/plain") {
|
|
return { status: 200, contentType, body };
|
|
}
|
|
|
|
const PROJECT_PATH = `/api/projects/${PROJECT_ID}`;
|
|
const GET_RESPONSES = new Map([
|
|
[
|
|
"/api/projects",
|
|
json({ projects: [{ id: PROJECT_ID, dir: "/tmp/smoke-test", title: "Smoke test" }] }),
|
|
],
|
|
[
|
|
PROJECT_PATH,
|
|
json({
|
|
id: PROJECT_ID,
|
|
dir: "/tmp/smoke-test",
|
|
title: "Smoke test",
|
|
files: ["index.html"],
|
|
compositions: ["index.html"],
|
|
}),
|
|
],
|
|
[`${PROJECT_PATH}/preview`, text(SMOKE_COMPOSITION_HTML, "text/html")],
|
|
[`${PROJECT_PATH}/thumbnail/index.html`, text(SMOKE_THUMBNAIL_SVG, "image/svg+xml")],
|
|
[`${PROJECT_PATH}/renders`, json({ renders: [] })],
|
|
[`${PROJECT_PATH}/lint`, json({ findings: [] })],
|
|
[
|
|
`${PROJECT_PATH}/storyboard`,
|
|
json({
|
|
exists: false,
|
|
path: "STORYBOARD.md",
|
|
globals: { extra: {} },
|
|
frames: [],
|
|
warnings: [],
|
|
script: { exists: false, path: "SCRIPT.md", content: "" },
|
|
}),
|
|
],
|
|
[`${PROJECT_PATH}/selection`, json({ selection: null, updatedAt: null })],
|
|
["/api/registry/blocks", json([])],
|
|
["/api/fonts", json({ fonts: [] })],
|
|
["/api/fonts/google", json({ fonts: [] })],
|
|
["/api/assets/global", json({ assets: [] })],
|
|
// Studio asks this on load so it can warn before Export instead of failing
|
|
// at encode time. A usable encoder is the case this smoke run wants: the
|
|
// interesting assertion is that the shell mounts clean, not that a blocking
|
|
// notice renders. The notice has its own tests.
|
|
["/api/environment/ffmpeg", json({ ok: true })],
|
|
]);
|
|
const MUTATION_RESPONSES = new Map([
|
|
[`${PROJECT_PATH}/selection`, json({ ok: true, selection: null, updatedAt: null })],
|
|
]);
|
|
|
|
function projectFileResponse(pathname) {
|
|
if (!pathname.startsWith(`${PROJECT_PATH}/files/`)) return undefined;
|
|
const filename = decodeURIComponent(pathname.split("/files/")[1] ?? "");
|
|
return json({
|
|
filename,
|
|
content: filename === "index.html" ? SMOKE_COMPOSITION_HTML : "",
|
|
});
|
|
}
|
|
|
|
function projectPreviewResponse(pathname) {
|
|
if (!pathname.startsWith(`${PROJECT_PATH}/preview/`)) return undefined;
|
|
return pathname.endsWith("/.media/manifest.jsonl")
|
|
? text("", "application/x-ndjson")
|
|
: text(SMOKE_COMPOSITION_HTML, "text/html");
|
|
}
|
|
|
|
function gsapAnimationsResponse(pathname) {
|
|
if (!pathname.startsWith(`${PROJECT_PATH}/gsap-animations/`)) return undefined;
|
|
return json({ animations: [], timelineVar: "tl", preamble: "", postamble: "" });
|
|
}
|
|
|
|
function getStudioSmokeResponse(pathname) {
|
|
return (
|
|
GET_RESPONSES.get(pathname) ??
|
|
projectFileResponse(pathname) ??
|
|
projectPreviewResponse(pathname) ??
|
|
gsapAnimationsResponse(pathname)
|
|
);
|
|
}
|
|
|
|
function studioSmokeApiPathResponse(method, pathname) {
|
|
return method === "GET"
|
|
? (getStudioSmokeResponse(pathname) ?? null)
|
|
: (MUTATION_RESPONSES.get(pathname) ?? null);
|
|
}
|
|
|
|
export function studioSmokeApiResponse(method, requestUrl) {
|
|
const { pathname } = new URL(requestUrl);
|
|
return pathname.startsWith("/api/") ? studioSmokeApiPathResponse(method, pathname) : undefined;
|
|
}
|
|
|
|
export function isExpectedStudioSmokeError(message) {
|
|
return message.includes("favicon.ico");
|
|
}
|
|
|
|
async function loadPuppeteer() {
|
|
const requireFromProducer = createRequire(join(ROOT, "packages", "producer", "package.json"));
|
|
return requireFromProducer("puppeteer");
|
|
}
|
|
|
|
export async function runStudioRuntimeSmoke(targetUrl) {
|
|
const puppeteer = await loadPuppeteer();
|
|
const browser = await puppeteer.launch({
|
|
headless: "new",
|
|
args: ["--no-sandbox", "--disable-setuid-sandbox"],
|
|
});
|
|
const page = await browser.newPage();
|
|
const errors = [];
|
|
const unmockedApiRequests = [];
|
|
|
|
page.on("pageerror", (error) => errors.push(error.message));
|
|
page.on("console", (message) => {
|
|
if (message.type() === "error") errors.push(message.text());
|
|
});
|
|
await page.setRequestInterception(true);
|
|
page.on("request", (request) => {
|
|
const response = studioSmokeApiResponse(request.method(), request.url());
|
|
if (response === undefined) {
|
|
void request.continue();
|
|
return;
|
|
}
|
|
if (response === null) {
|
|
unmockedApiRequests.push(`${request.method()} ${new URL(request.url()).pathname}`);
|
|
void request.respond(json({ error: "unmocked smoke endpoint" }, 501));
|
|
return;
|
|
}
|
|
void request.respond(response);
|
|
});
|
|
|
|
try {
|
|
await page.goto(targetUrl, { waitUntil: "networkidle0", timeout: 30_000 });
|
|
await new Promise((resolve) => setTimeout(resolve, 3_000));
|
|
const errorBoundary = await page.evaluate(() => {
|
|
const textContent = document.body.innerText;
|
|
return textContent.includes("Something went wrong") ? textContent : null;
|
|
});
|
|
if (errorBoundary) errors.push(`React error boundary triggered: ${errorBoundary}`);
|
|
} finally {
|
|
await browser.close();
|
|
}
|
|
|
|
const fatal = errors.filter((error) => !isExpectedStudioSmokeError(error));
|
|
const failures = [
|
|
...new Set(unmockedApiRequests.map((request) => `unmocked API request: ${request}`)),
|
|
...fatal,
|
|
];
|
|
if (failures.length > 0) {
|
|
throw new Error(
|
|
`Studio runtime smoke failed:\n${failures.map((error) => `- ${error}`).join("\n")}`,
|
|
);
|
|
}
|
|
}
|
|
|
|
async function main() {
|
|
const targetUrl = process.argv[2] ?? "http://localhost:5199/#project=smoke-test";
|
|
await runStudioRuntimeSmoke(targetUrl);
|
|
console.log("PASS: studio loaded with schema-valid API fixtures and no runtime errors");
|
|
}
|
|
|
|
if (process.argv[1] === fileURLToPath(import.meta.url)) {
|
|
main().catch((error) => {
|
|
console.error(error instanceof Error ? error.message : error);
|
|
process.exitCode = 1;
|
|
});
|
|
}
|