mirror of
https://github.com/heygen-com/hyperframes.git
synced 2026-11-19 11:26:02 +00:00
18e31c726352ec3e6b7db08e6d261a7702ec8dfb
307
Commits
| Author | SHA1 | Message | Date | |
|---|---|---|---|---|
|
|
43582dcb72 |
fix(producer): resume and proxy joins reuse only pieces this install made (#8089)
* fix(producer): resume checks the segment file the join reads, not the manifest's path A resumed segmented render now validates each reusable segment at its own computed path in the segment folder. It must be a plain file, not a link, and match a slice of this render's plan. The path a manifest records is never opened or probed. * fix(engine,producer): concat joins open only the list and encoder containers Both concat-demuxer joins (the engine's chunk and segment concat and the distributed assemble join) now pass a format whitelist of concat, mov and matroska. ffmpeg applies it to every file the list opens, so a listed file that is a playlist or manifest cannot pull in other files, while mp4, mov and webm joins work as before. * fix(producer): resume reuses only segments this install recorded Segment manifests are now signed with an HMAC keyed by a per-install secret kept in the HyperFrames config folder, outside every project. Resume trusts a manifest only when its signature checks out, so a segment folder copied from another machine or shipped inside a project is captured again, while a render's own interrupted run resumes as before. * docs(producer): restore the segment path ordering comment and rewrap resume docs * fix(producer): replace an empty or short resume key file A key file too short to use is now replaced by a fresh key instead of disabling resume for good. A missing key is still linked into place, so renders that create it at the same time share one key; a test runs eight processes against one path to check that. * fix(producer): warn under --resume when no resume key is available When the resume key can be neither read nor created, for example on a read-only home folder, a file system without hard links or a serverless runtime, --resume now logs one warning that every segment will be captured again instead of only reporting zero complete segments. * fix(engine): fail a concat join at a list entry ffmpeg refuses The concat demuxer ends the stream at a listed file it cannot open and ffmpeg still exits 0, which cut the output short without an error. -xerror on the concat input makes the join fail instead. mp4, mov and webm joins still exit 0. * fix(producer): resume checks each reused segment's SHA-256 Each finished segment's SHA-256 is now recorded in the signed manifest. The hash is taken once when the segment closes, and on resume only the files about to be reused are hashed again, so a file swapped for another of the same size is captured again. * docs(cli): note that resume re-checks segment hashes and recaptures older segments once * fix(studio-server): proxy joins only its own pieces, through the shared concat input Studio's chunked proxy copy now names its pieces with a tag keyed by the user's preview token, so pieces that arrive inside a project folder sit at names it never looks up and every piece is encoded fresh. A stopped copy of the user's own still continues from its finished pieces. The piece join uses concatListInputArgs, now in @hyperframes/parsers so the engine, producer and Studio share it. It allows only local files in the concat, mov or matroska formats and fails at a refused entry. The cache sweep recognizes both tagged and older piece names. * test(parsers): prove the concat protocol whitelist with a data: entry ffmpeg already refuses http:// in a concat list opened from a file, so the test passed without the whitelist. A data: entry opens by default; the test now asserts it is refused as not on the 'file' whitelist. * fix(studio-server): only the copy's own tagged pieces count as lock progress The copy lock counted any .part-<key>- file as the owner's progress, so a piece shipped with a future modified time kept a stalled lock looking active. It now counts only names under the copy's own tagged piece prefix. The cache sweep removes untagged pieces past the usual age even while that copy runs, and measures age in both directions so a future-dated piece is swept too. * fix(studio-server): say once when proxy pieces cannot be keyed to the user Without a preview token, piece names use a per-process secret, so pieces are reused only within that Studio process. Studio now logs that once, so a copy restarting from its first piece after a restart has a visible cause. * test(studio-server): name the proxy join test for what it checks * fix(producer): derive the segment manifest key from the preview token Sign segment manifests with an HMAC key derived from the per-user preview token instead of a separate key file. The token is created with an exclusive open, so concurrent renders never end up with different keys, and it is only used when the file is private to this user. Resume now checks a segment's SHA-256 before probing it, and a real-ffmpeg test documents how the concat join treats an entry that is itself an ffconcat list. * docs(producer): describe the manifest key per user and the no-token case |
||
|
|
fc289b0dfc |
fix(cli): play and present answer unknown paths with an inert refusal (SECOPS-2642 part 3) (#8160)
* fix(cli): play and present answer unknown paths with an inert refusal (SECOPS-2642 part 3) An OAuth return that lands on the play or present port was a 404 document on the same origin as the composition frame, so project script could read its ?code=&state= through a frame, a popup or the authorize redirect. Unknown paths, missing composition files and any request carrying code or state now get a fixed text/plain 404 on an opaque origin (CSP sandbox) that cannot be framed and drops its opener (COOP same-origin). play's app setup moves into an exported buildPlayApp so tests can serve it. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * fix(cli): trim the inert refusal's comments to the package share Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> --------- Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com> |
||
|
|
ed3f05a05b |
fix(aws-lambda): pin the shell ZIP route, gate ZIP headroom, match arm64 fonts to x86 (#8170)
- build-zip --source=chrome-headless-shell stages only the repo's pinned build (managedChromeVersion) and only when its folder matches the pinned digest (isPinnedHeadlessShell), instead of the newest folder in the cache. The folder cannot fit a ZIP function, so lambda deploy refuses --chrome-source chrome-headless-shell up front on either arch, and the docs say the arm64 video image is where the shell runs. - build-zip prints the headroom under the unzipped gate, and a new "Lambda handler ZIP" workflow builds the ZIP on PRs that touch the code it bundles, so growth fails before merge rather than in the release job. - The arm64 image keeps @sparticuz/chromium's fonts and fonts.conf from the handler ZIP (FONTCONFIG_PATH=/var/task/fonts) instead of liberation-fonts, so text falls back to the same fonts as on x86. The image workflow renders a mixed-script page on both arches and fails when any line resolves to different platform fonts. Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com> |
||
|
|
81d73d2278 |
fix(aws-lambda): chrome-headless-shell 158 in the arm64 video image, sparticuz 153 in the x86 ZIP (#8155)
* fix(aws-lambda): run chrome-headless-shell 158 in the arm64 video image The arm64 video image now installs Chrome for Testing's linux-arm64 chrome-headless-shell 158.0.8127.36, pinned by sha256 and fetched with curl -f, as the whole shell folder. The Lambda Node 22 base has none of the shared libraries the shell links and no fonts, so the image installs them from the base's repository at the same pinned release. The image sets HYPERFRAMES_LAMBDA_CHROME_SOURCE and HYPERFRAMES_LAMBDA_CHROME_PATH itself, and the nested video function no longer passes ChromeSource, which would override them. stage-arm64-image.ts stops fetching the sparticuz arm64 pack and drops the ZIP's x86 sparticuz Chrome instead. The x86 handler ZIP stays on @sparticuz/chromium, bumped from 148.0.0 to 153.0.0. It builds at 258,502,222 bytes unzipped, under Lambda's 262,144,000-byte limit and the 248 MiB in-house gate. Two fixes for --source=chrome-headless-shell: - build-zip.ts staged only the executable, which exits at launch without its ICU data and .pak files. It now stages the whole shell folder at chrome-headless-shell-linux64/. - Nothing set HYPERFRAMES_LAMBDA_CHROME_PATH, which src/chromium.ts requires for that source. The SAM template and the CDK stack now set it to the bundled shell when ChromeSource asks for it. Drops the unused @types/aws-lambda devDependency, which the dead-code audit reports whenever this package's manifest changes. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * ci(publish): build the Lambda arm64 video image on an ARM runner The video stage now installs Chrome's system libraries with microdnf, so it runs code for arm64. The pack job built that image on ubuntu-latest with no emulation, which it could do only while the stage copied files. A new lambda-video-image job builds it natively on ubuntu-24.04-arm, from the handler zip whose sha256 the zip job reported, and reports the OCI tarball's sha256. Pack downloads that tarball, checks the sha256 against the job's, and pins it as before. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * chore(aws-lambda): fit the comment ratchet and the package size budget chromium.ts loses the two doc lines on BUNDLED_SHELL_DIR and BUNDLED_SHELL_PATH; the names and the SAM template's comment already say what they are. @hyperframes/aws-lambda's unpacked budget goes from 290,508 to 298,000 bytes. The package unpacks to 295,324 bytes, up from the shared chrome-headless-shell staging module the ZIP and image scripts now import and from the README and docs that describe the two Chrome sources. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> --------- Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com> |
||
|
|
e99cd75b42 |
fix(cli): run global updates from the home directory (#8131)
* fix(cli): run global updates from the home directory * fix(cli): skip self-updates inside package scripts and explain unsafe homes |
||
|
|
c27adb35ff |
fix(cli): media-use scripts read the host's kept record copy as the CLI does (#8119)
The media-use copy of the received-files rule now reads the host app's kept copy of an expected project's record, as the CLI does. It adds back each kept entry whose path still holds something, checks the folder identity for a project found only by dev and ino, and counts every file as received when the copy has no list, is doubted, a link, oversized, unparsable or another project's. In both the CLI and the copy: - a kept copy whose identity names another folder counts every file as received instead of being ignored; - a kept copy that fails its first read, for example because the app replaced it mid-read, is read once more before every file counts as received; - a kept copy named both by path and by dev and ino is read once. The docs no longer suggest that the app's next read restores a kept entry whose file is gone. |
||
|
|
183bf2a416 |
fix(cli): keep files received that a host's kept record still lists (#8100)
* fix(cli): keep files received that a host's kept record still lists When the received-state file names a project as expected and the host keeps its own copy of that project's record beside the state file, the received-file checks read the record together with each entry that copy lists whose path still holds something. A record shortened or emptied outside the host no longer makes those files read as the person's own. A kept copy with no list, a doubted one, a link or one that cannot be read counts every file as received; with no kept copy, nothing changes. * fix(cli): keep a record's own lines when the host's kept copy cannot be read A kept copy with no list, or one that cannot be read, now counts every file as received through its own entry, named by the kept copy's path, instead of hiding the record's lines from Studio's rename and move tracking. A copy found only by folder identity counts only when its identity matches the folder, and a copy that disappears mid-read counts as no copy. * docs(cli): say a kept entry whose file is gone is not added back |
||
|
|
4a59fef2d0 |
fix(cli): say a listed received file is gone, and drop a media file's line on rename (#8098)
* fix(cli): say a listed received file is gone, and drop a media file's line on rename Follow-up to the change that keeps a deleted received page listed. - The render warning for a listed file that no longer exists now says it is gone and how to clear it. - A listed file whose name was already a media name drops its old line when renamed to another media name, so repeated renames leave no dead lines. - The docs say that any listed file that is not media by its first bytes stays listed after a delete, and that the line can sit in a record above or inside the project. - A test restores content after a plain Studio delete and checks that outside files stay refused. * test(cli): match the gone-file warning without a POSIX path, for Windows |
||
|
|
e099c7d0cb |
fix(cli): keep a deleted received page listed in the received-files record (#8090)
A Studio delete took a received page's line off the record, and files created afterwards were not followed. A script in the preview could delete every received page and create it again with new bytes, so the project no longer counted as received and outside files were read. A deleted page, stylesheet or script now stays listed, so whatever is written in its place counts as received. A received page renamed to a media name keeps its old line too. Deleted or renamed media, fonts and images still drop off, so a media-only project keeps working. |
||
|
|
820d63d7f9 |
feat(cli): check finds text over a face, measure cuts names resumed takes, measure hands (#8074)
* feat(cli): check reports text drawn over a face in a video The layout audit reports text painted in front of an opaque video with its word boxes and where the video's frame lands; Node finds the faces in the video file with the detector `measure face` uses and adds a `text_over_face` finding (info from 5% of the face covered, warning from 30%) with `coveredFraction` and `faceRect`. `layout.faceCheck` in the report says whether the pass looked. `data-layout-allow-on-face` waives it. Also reads a two-token `object-position` whose first token is "50%" as the horizontal one. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> * feat(cli): measure cuts names the shot a take resumes A shot that returns to an earlier camera setup after at least one other shot (a wide take, a close-up cut into it, the wide take again) carries `continues`: the index in `shots` of the shot it resumes. It is read from the signatures `cuts` already decodes, by the scene's edges, so a person who has moved or an exposure that drifted does not hide the match. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> * feat(cli): measure hands follows a hand through a clip `measure hands <video>` reports where a hand's palm (with the hand's size), index fingertip or pinch is in each sampled frame of a stretch of up to 15 s, from MediaPipe's hand landmarker. A frame with no such hand is null, never filled in. The landmarker runs in the CLI's headless Chrome on a page answered from disk; its code and model are not shipped and are downloaded on first use, pinned by size and sha256, into the trusted cache. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> * fix(cli): text_over_face is info only, and a stalled OpenCV download no longer stalls check The face detector can take texture for a face, so text_over_face is reported as info however much of the face is covered and never fails --strict. check passes its deadline and a 30 s limit into the detector's first-use OpenCV download. A download that does not answer costs the face pass only: faceCheck is { ran: false, reason }, the other findings are kept and the process exits. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> --------- Co-authored-by: Claude Fable 5.2 <noreply@anthropic.com> |
||
|
|
90de9b6196 |
fix(cli): a project .env provider key prints a note when it is used (#8056)
A provider key from a project .env is still used when no own credential competes. Capture vision (OpenRouter, Gemini, Google and both Vertex parts), snapshot --describe, Gemini speech and Lyria music now print one note per key before it is first used, naming the variable and the escaped .env path, as the ElevenLabs note does. The ignoring notes escape the path too, and the media-use skill gets a generated copy of the CLI's terminal-text helper. |
||
|
|
39347da9de |
fix(cli): leave files from outside the project out of Lambda and Cloud Run site uploads (#8060)
* fix(cli): leave files from outside the project out of Lambda and Cloud Run site uploads A site upload for `lambda` or `cloudrun` followed every symlink in the project and shipped what it pointed at, wherever that was on the machine. `publish` and `cloud render` already ask first. Site uploads now leave a file or folder linked in from outside the project out and name each one; `--include-outside-files` (or `includeOutsideFiles` in the SDK's deploySite, renderToLambda and renderToCloudRun) uploads them. publishProjectArchive called without a prepared archive now leaves outside files out too, since nothing approved them. — Rames Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * fix(producer): drop the new option comments the comment ratchet refuses Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> --------- Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com> |
||
|
|
5ea86450a2 |
fix(cli): a host can name projects whose received files are expected or all received (#8025)
* fix(cli): a host can name projects whose received files are expected or all received HYPERFRAMES_RECEIVED_STATE_FILE points at a JSON file a host app keeps, listing project folders (by path, and optionally by device and inode) as "expected" or "all". For an expected project, a missing received-files record counts every file as received and is not started afresh; for an all project, every file counts as received whatever the record lists. A state file that is named but cannot be read counts every file as received. A record lock dated in the future is taken over like a stale one. * fix(cli): read host provenance state through one file handle * fix(cli): canonicalize host state paths like record writes * test(cli): expect canonical received warning paths |
||
|
|
14c4e4c268 |
fix(cli): a project .env provider key gives way to the person's own credential (#8041)
* fix(cli): a project .env provider key gives way to the person's own credential A project .env could set OPENROUTER_API_KEY, GEMINI_API_KEY, GOOGLE_API_KEY, the Vertex settings or ELEVENLABS_API_KEY and outrank a credential the person set in their shell or saved settings. The earlier rule covered only received projects; a cloned or downloaded project still won. Now every project .env provider key is unset, with a note naming the file, when a competing provider has a credential from a surer source: the shell or saved settings first, then the person's own project .env, then a received one. A project key with no competing credential is still used, model and timeout settings still apply, and the media-use scripts note an ElevenLabs key from any project .env before speech starts. In the CLI process an own-project key yields only within the vision choice; the media-use scripts remake the Gemini audio choice from the passed key origins. * fix(cli): weigh an own project's provider key only against credentials its feature can use Review found that the global yield removed a person's own project keys where the shell credential could not do the job: snapshot's Gemini key next to a shell OpenRouter key, and a Gemini key that music needs next to a shell service account. - Startup keeps the received-project rule only. - Capture drops a project .env vision key only when the shell or settings hold another complete vision credential; the two Vertex parts are one credential and are not weighed against each other. - A key dropped once is not brought back when capture re-reads the same .env, so its note prints once. - In the audio scripts, an own project's Gemini key gives way only to the other Gemini API key, which speech and music both accept, and an own ElevenLabs key stays for an explicit provider choice. |
||
|
|
8239fe4702 |
fix: the dev Studio's renders follow the received-project rule, and a received project's .env keys never replace the person's own (#8004)
* fix(studio): dev Studio renders apply the received-project rule for outside files The Vite Studio adapter started every render with files from outside the project allowed. It now asks the CLI's outsideAssetsAllowed, the same check the CLI's embedded Studio, hyperframes render and benchmark use. A project whose received-files record lists code files, or cannot be read, renders without files from outside the project, and the reason prints with a [studio] prefix. The adapter loads the rule from the CLI source through the dev server, as it already does for background removal. It runs only from a source checkout, so studio takes no package dependency on the CLI. * fix(cli): a received project's .env provider key never replaces your own credential A received project's .env could set OPENROUTER_API_KEY, GEMINI_API_KEY, GOOGLE_API_KEY or Vertex settings that outranked a vision or Gemini credential the person set in the shell, so capture, snapshot describe and media-use speech and music could send content to another account. After the CLI and capture load a project .env, each provider key it set is unset when that .env came with a received project (a received-files record lists it, or a record cannot be read) and the person has their own credential for a competing provider. One stderr line names the key, the .env file and the credential used instead. A person's own project .env keeps its keys and its current precedence, so an OPENROUTER_API_KEY in a project .env still wins over a Gemini key in the shell, as the docs describe. Voice needs no change: the person's HeyGen credential already ranks above ElevenLabs. * fix(cli,media-use): media-use scripts apply the received .env rule, ElevenLabs included The media-use audio scripts read the project .env again, so a Gemini key the CLI had left out came back. They now apply the same rule after loading: a key from a received project's .env gives way to the person's own credential for a competing provider. GEMINI_API_KEY and GOOGLE_API_KEY give way to the person's Gemini key or service account. ELEVENLABS_API_KEY gives way to the person's HeyGen sign-in, saved key or shell key. A dropped key gets one stderr line that names the file and the credential used instead. A received ElevenLabs key that is still used, because the person has no competing credential, gets one stderr line naming the .env before speech starts. hyperframes media-use tells the engine which keys it took from a project .env (HYPERFRAMES_PROJECT_ENV_ORIGINS), so a key the CLI loaded is not mistaken for the shell's. When the project's folders are too many to scan for received-files records, the CLI's note now says the project's origin could not be checked, instead of calling it a received project. * refactor(studio): check the shape of the CLI's outside-files rule before calling it The Vite adapter loads outsideAssetsAllowed from the CLI source at run time. It now checks that the export is a function and treats only a true result as allowed, instead of casting the module's export. * docs(auth): a received project's ElevenLabs key gives way to your HeyGen credential * test(studio): load the received-project rule before render waits start |
||
|
|
e58fb3249b |
fix(cli): render --docker applies the received-project rule on the host (#8016)
* fix(cli): render --docker applies the received-files rule decided on the host The container mounts only the project, so it cannot see a received-files record in a folder above it. The host now makes that check for single and batch Docker renders and passes --refuse-outside-files into the container when it refuses outside files. * fix(cli): a Docker batch decides the received-files rule once A batch render now applies the received-files rule once and hands the result to every row, so it warns once instead of once per row. A test now drives renderDocker itself and checks the docker run arguments it starts. |
||
|
|
22b615f1a7 |
fix(cli): files from outside the project are uploaded only once approved (#7995)
* fix(cli): files from outside the project are uploaded only once approved publish, cloud render and feedback --file-issue copied every image, video, audio, font and CSS file a composition named from outside the project folder, and every project file that links outside it, and only listed them. A project that came from someone else could pull a file from anywhere on the uploader's disk into an upload. Now each such file needs approval. In a terminal the command lists them and asks, defaulting to no; a yes is remembered per project in the CLI's config folder (~/.hyperframes/outside-files.json), never in the project. --yes, --json, --dry-run and unattended runs leave them out with a warning naming each file and saying how to include it. --include-outside-files uploads them without asking. — Rames Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * test(cli): check the approvals file mode only where files have POSIX modes Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> --------- Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com> |
||
|
|
346579b6b9 |
fix(cli): compare and keyframes --shot serve only the files a bare HTML file names (#8006)
* fix(cli): compare and keyframes --shot serve only the files a bare HTML file names A bare .html file given to compare or keyframes --shot is staged with only the files its markup, stylesheets and sub-compositions name inside its own folder, and only types a composition loads. Private files stay out. A scene its project's index.html mounts is staged from the project, so it keeps its shell. * fix(cli): stage root-relative names, string imports, SVG links and grading tables A bare HTML file's staging now also copies the files named by a leading-slash URL (resolved against the staged folder), a string-form CSS @import, an SVG xlink:href and the LUT of data-color-grading. compare and keyframes --shot print one line naming any file they left out. The CLI docs describe the single-file rule. |
||
|
|
581a43bb6a |
fix(producer): local renders leave out scripts from outside the project unless included (#7998)
A local render brought in .js and .mjs files that markup or a project link reached outside the project, so an imported composition could copy a script from elsewhere on disk into the page it runs and read it. Images, video, audio, fonts and CSS still come in. Scripts are left out with a warning that names each one and how to include it: move it into the project, or pass the new --include-outside-files to hyperframes render. The policy covers the compiler's outside-asset copy, the file server's linked files and the distributed plan's project copy. — Rames Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com> |
||
|
|
32fe10a8b3 |
fix(studio-server): history writes and claims follow Studio's write rule (#7988)
History undo, restore and Cmd+Z now leave alone every file that Studio's file routes refuse to write. This covers tool-trusted, private, hidden and node_modules paths, and scripts the project's package.json runs. Cmd+Z passes over an edit that only changed such files. A claim no longer takes such a file's pending change. A claim's `overwrote` version now counts only when the server itself saw that version at that path. A version stored for another file can no longer become a file's earlier state. The write rule also refuses more files that tools and agents load on their own: opencode and crush settings, compose override files, Dockerfile.* and Containerfile, every lefthook spelling, mise, nodemon, devbox, wrangler, vercel and netlify settings, *.config.jsonc, tsconfig.*.json, Taskfile.dist, simple-git-hooks, Ruby build files, and .nix and .fish scripts. |
||
|
|
ca25558083 |
fix(cli): enforce private cache install paths (#7981)
* fix(cli): cache installs only use folders the current user owns Code the CLI downloads or builds into its cache (Chrome, the TTS script, audio helpers, whisper.cpp, OpenCV, the Lambda handler, optional packages) now goes into folders created by the current user with owner-only write, and each installed file is checked again before it is returned. - A cache root that other accounts can add entries to, sticky or not, is no longer used for code; the per-user cache is used instead. - The ownership check reads links rather than following them, and a link that leads out of the cache root is not trusted. * fix(cli): validate cache ancestry before filesystem side effects * fix(core): check links before parent path segments * fix(cli): validate cached libraries and clarify private parent requirements * fix(cli): use the shared staging directory helper for Apple builds |
||
|
|
e6d5c699b1 |
feat(cli): diff --hide scores a project's layer by what it adds (#7972)
* feat(cli): diff --hide scores a project's layer by what it adds A project folder is captured a second time with the layer hidden (a clone, so its fonts and sub-compositions stay). Where the captures differ is the layer's footprint; over it, benefit = 1 - MAE(original, with) / MAE(original, without), and the original's copy of the layer is fitted by position (+-40 px) and size (80-120%) into an instruction such as "move down 12 px". Moments where leaving the layer out already matches the original are not scored. Reported in the result's `layer`; `pass` is unchanged. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * fix(cli): diff --hide scores a layer over most of the frame without running out of stack The footprint's box came from Math.min(...pixels), which throws RangeError past about 150k pixels (a 500x300 card at 1080p), aborting the whole diff. The box is now one loop, and the position/size fit reads an evenly strided sample of at most 20k footprint pixels; benefit still reads all of them. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> --------- Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com> |
||
|
|
47d007e5b0 |
fix(cli): render --json gives each missing tool, a held slot and an old Node its own code (#7842)
* fix(cli): render --json gives each missing tool, a held slot and an old Node its own code Every failed `render --json` answered with `error.code: "runtime_error"`, so a script could only tell a missing FFmpeg from a busy render slot by matching the human message. A CliRuntimeError now carries a code, as CliUsageError does, and the envelope reports it: chrome_not_found, ffmpeg_not_found, ffprobe_not_found, render_locked. A Node older than 22 prints the envelope too (node_version_unsupported) when the run asked for --json. Other failures keep runtime_error. Refs #7408 Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> * test(cli): give the bin entry test's runtimeVersion stub the new JSON export bin/hyperframes.mjs now imports runtimeVersionJson, so the stub dist file binEntry.test.ts writes must export it too, or the bin fails to load. --------- Co-authored-by: Claude Fable 5.2 <noreply@anthropic.com> |
||
|
|
071a2da0b5 |
fix(cli): own render-slot lock dir; refuse cache files other accounts can write (#7951)
* fix(cli): own render-slot lock dir; refuse cache files other accounts can write Sharing one render slot across accounts no longer means sharing HYPERFRAMES_CACHE_DIR, which holds the browser, packages and helpers each account runs. HYPERFRAMES_RENDER_LOCK_DIR names a folder of lock records only, created sticky and writable by all (1777); the per-user lock folder is created 0700. Help text, errors and docs no longer suggest sharing the cache or chmod 777. foreignWritablePath (core/cache-dir) refuses a cached file whose path up to the cache root is owned by another account or is group/world-writable. Chrome (CLI, engine, inspector), optional packages (incl. the Sherpa runtime), the whisper.cpp build, the TTS script, the Apple audio helpers, opencv.js and the Lambda handler reinstall or rebuild instead of running such a file, and trustedCacheRoot moves their installs to ~/.cache/hyperframes when another account can write HYPERFRAMES_CACHE_DIR. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * fix(cli): seal own cache installs against umask 002 and repair old lock folder modes sealCacheInstall (core/cache-dir) takes group and world write off what this account just installed and the folders above it up to the cache root, so an install made under umask 002 passes foreignWritablePath on the next run instead of being refused and fetched again. Chrome, optional packages, the whisper.cpp build, opencv.js, the TTS script, the Apple audio helpers and the Lambda handler call it after installing. ensureLockDir makes an existing per-user lock folder 0700 again when an older release left it open, and adds the sticky bit to an existing HYPERFRAMES_RENDER_LOCK_DIR folder, warning once with the folder's name when it cannot. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * refactor(cli): drop added comments to pass the comment ratchet The explanations move into names: the mode bits in core/cache-dir are GROUP_OR_WORLD_WRITE and WITHOUT_GROUP_OR_WORLD_WRITE, and the owner check is anotherAccountCanWrite. No change in behaviour. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * fix(cli): verify the lock folder through a no-follow handle and stage installs owner-only The render lock folder is opened with O_NOFOLLOW | O_DIRECTORY and checked and chmod-ed through that descriptor: a link, or a folder another account owns (root may own a shared one), is refused with RenderLockFolderRefused instead of being made world-writable or used as is. Chrome staging, the optional-package staging folder, the whisper.cpp build folder and the opencv, TTS, Apple helper and Lambda handler folders are created 0700, and Chrome's staged tree is sealed before it leaves staging, so nothing is group-writable while it installs. foreignWritablePath accepts a sticky folder owned by this account or root, as /tmp is, and tolerates a statSync without options; tests whose cache sat directly in /tmp, and tests that mock statSync, failed on both. Docs note that a record naming a live process of another account holds the shared slot. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * test(cli): skip the uid-based Chrome cache refusal cases where there is no uid Windows has no process.getuid, so the ownership check never runs there and the two cases that expect a refusal cannot hold. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * chore(core): raise the unpacked size budget for the cache ownership checks core grew to 4418013 bytes unpacked with foreignWritablePath, sealCacheInstall and trustedCacheRoot; the budget follows the usual 5% headroom over that size. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> --------- Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com> |
||
|
|
78648113db |
fix(cli): check and info never probe a composition's remote media URLs (#7942)
* fix(cli): check and info --media leave remote media sources unprobed mediaPath handed an http(s) src to ffprobe, so check's HDR and sound probes and info --media's clip lengths opened composition URLs from the CLI process. Remote sources are now left unprobed, as timeline and check's clip audit already do. check's report lists the remote video and image sources HDR inspection skipped under hdr.remoteNotInspected, and a remote video that may carry sound keeps the film from being reported as silent. * fix(cli): drop credentials from remoteNotInspected and document unprobed remote media |
||
|
|
d5f0b1a5bf |
fix: nested .hyperframes stays private, capture page server checks Host, project manifests pin no CLI (#7927)
* fix(core): a .hyperframes folder in a subfolder stays private too The private-file rule treated .hyperframes as the app's records folder only at the project root. A project copied into a subfolder keeps its own .hyperframes/, and its chat history, hand-off and other records there were listed in the file tree and served by Studio's file and preview routes and by the other file servers that share the rule. A .hyperframes segment at any depth is now private, in every spelling Windows opens. Studio's own files and the prepared-assets and requests folders stay servable only at the root, the one place Studio reads and writes them. The file tree also skips .hyperframes/backup at any depth. * fix(cli): the capture --local-file page server answers only its own host The page server that capture --local-file starts on a loopback port answered a request whatever its Host header said. A site whose name resolves to 127.0.0.1 could then read the files it serves from the browser. The server now refuses, before any file lookup, a request whose Host is not its own loopback name and port, with the same isOwnLoopbackHost rule the static project server and the engine file server use. Every response carries X-Content-Type-Options: nosniff. The capture browser loads the page by 127.0.0.1 and its port, and fetchLocalPageUrl reads from disk, so both work as before. * fix(skills): a plugin manifest in the project pins no CLI release The skills launcher read a plugin manifest from the folder above skills/ wherever the skills were installed. For a project-level install that folder is the project itself or its .agents or .claude folder, so a plugin.json shipped with a project could pin an old hyperframes release and turn off update checks and standalone skill refreshes. The launcher now reads a manifest only from a bundle of its own: a folder whose name does not start with a dot and that is neither the folder the CLI works in nor one that contains it. Plugin managers install bundles into their own folders, so those keep their pin. A manifest anywhere else leaves the call the same as with no manifest. A manifest that pins a release older than 0.9.34, the launcher's floor, is refused. The agent-facing plugin rules and the skills guide say the same. * fix(skills): a plugin bundle inside the working folder pins only behind a dot folder A package inside a monorepo could still pin the CLI: with the agent working at the monorepo root, <mono>/packages/video/plugin.json sat beside a skills folder the launcher took for a bundle. The launcher now also refuses a bundle inside the working folder unless a folder whose name starts with a dot lies between them, as .claude does in ~/.claude/plugins/cache when the agent works in the home folder. Bundles in ~/.claude/plugins, ~/.cursor/plugins and ~/.gemini/extensions keep their pin from the home folder or a project. The plugin rules and the skills guide now state the three conditions the launcher checks. * docs(cli): a .hyperframes folder in a subfolder is left out and not served The private-file rule now treats a .hyperframes/ folder at any depth as the app's records. Files stored in one inside a subfolder, assets included, stay out of uploads and are not served by Studio, preview or render. The cloud render section now says so beside the rule it already describes. * fix(cli): capture pages keep loading scripts with no or unlisted extensions With nosniff on every response, a script the capture page server did not know the type of (a .cjs file, or a file with no extension) was served as application/octet-stream, and the browser refused to run it. The server now names .cjs, .wasm, .xml, source maps, web manifests, CSV, WebVTT, glTF and more audio, video and image types. A file whose type is still unlisted is served without nosniff, so the browser sniffs it as it did before and such a script runs. Every listed type and every empty error response keeps nosniff. * fix(share): sync and share leave out a .hyperframes folder below the root The .hyperframes rules in the source path policy matched only at the project root, so a copy's records in a subfolder, such as sub/.hyperframes/agent-runs.jsonl, fell through to the default rule and travelled with share and sync. A new nested-hyperframes-state rule leaves out a .hyperframes folder at any depth below the root. It sits before the first allow rule, as the contract's rule order requires. The root folder's Studio files and other portable files travel as before. Stored snapshot reads skip the new rule through stored_manifest.legacy_rule_regexes, the shape the server and Desktop copies already use, so snapshots and bindings captured earlier still read. |
||
|
|
b2e6076b7e |
feat(cli): show and open the page to manage or cancel a paid plan (#7784)
* feat(cli): show and open the page to manage or cancel a paid plan * chore(cli): drop two comments the names already carry |
||
|
|
5d8605eb8e | wip: paused before review (#7890) | ||
|
|
9bc2b231d3 |
fix(cli): cloud render sends one zip when it fits and uploads only the largest media (#7859)
* fix(cli): cloud render sends one zip when it fits and uploads only the largest media * fix(cli): cloud render leaves unused media out only when the zip is over the limit * test(cli): eight-at-once upload test waits for eight in flight, never a timer * test(cli): eight-at-once upload test also fails when more than eight run |
||
|
|
c030e3193d |
fix(cli): publish and cloud render staging skip other computers' network shares (#7858)
* fix(cli): never open another computer's share while staging an upload publish and cloud render now leave out a reference to another computer's network share or a Windows device path before any file-system call on it, and report it as left out with the network_share reason. A page that came in with an imported project has its outside references left out before the files they name are checked. * test(cli): the Windows staging test's lstat mock honours throwIfNoEntry |
||
|
|
de1ce68988 |
fix(cli): a project .env key is used only when nothing is saved (#7848)
A HEYGEN_API_KEY or HYPERFRAMES_API_KEY that a project .env sets now comes after every credential the person saved or exported. The CLI resolver, the media environment and the media-use skill use it only when there is no saved login, no saved API key and no key in the shell. When one is used, a single stderr line names the .env file. An expired, foreign-client, unreadable or refused login now raises the login error instead of switching to a project .env key, whether or not the folder has a received-files record. A key exported in the shell, or set by the app that launched the CLI, keeps its current place, and the host gateway path is unchanged. |
||
|
|
e426ce4eb4 |
feat(cli): uploads list every file they carry from outside the project (#7831)
* fix(cli): uploads leave out outside scripts; .ts counts as video only when it is one * chore(studio-server): raise unpacked size budget for the upload file-type rule * fix(studio-server): transport stream check never waits on a pipe and needs binary bytes * feat(cli): uploads list every file they carry from outside the project |
||
|
|
04202e8a4c |
fix(cli): uploads leave out outside scripts; .ts counts as video only when it is one (#7818)
* fix(cli): uploads leave out outside scripts; .ts counts as video only when it is one * chore(studio-server): raise unpacked size budget for the upload file-type rule * fix(studio-server): transport stream check never waits on a pipe and needs binary bytes |
||
|
|
ac02474105 |
fix(cli): play and present check the Host like preview; local render leaves out outside files for a received composition (#7792)
* fix(cli): a subfolder of an imported project keeps its received-files record Publish, cloud render and feedback now read the received-files record at the nearest folder at or above the one they stage, so staging a subfolder of an imported project still leaves out the outside files its received files reference. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * fix(cli): a received file counts under any spelling of the same file on disk The received-files lookup now also matches a project file that is the same file on disk as a listed path, so a name respelled in letter case on a case-insensitive disk keeps its received status. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * fix(cli): cloud render prepares only the GIFs staging kept The entry GIF prep before a cloud render upload now reads only the staged copies it is handed. An image whose source staging left out keeps its reference as written and is never read from disk. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * fix(cli,studio-server): never hand a playlist named as media to ffmpeg A media file whose first bytes are an HLS playlist, an XML manifest or a concat script now stays out of ffprobe and ffmpeg: cloud render leaves it in the zip as authored, the media probe reports it as not media, and the proxy copy refuses it. Real media never starts with these bytes, so it probes and transcodes as before. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * fix(studio-server): catch playlists with control bytes, and keep them from stills and audio probes A text playlist or concat script is detected whatever bytes follow its first line; only markup must be all text. A still frame and the audio probe behind waveforms, peaks and loudness now refuse a file the probe reads as not media, as the proxy copy already does. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * fix(cli): a parent folder's state the CLI cannot read never marks a project received The walk up for a received-files record now skips a parent whose record cannot be reached. Only a record file that is there but cannot be read or parsed counts every file as received. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * fix(cli): a drive that reports no file ids matches no received file by identity Some network and virtual drives report a file id of 0 for every file, so the same-file match now gives such a file no identity instead of matching it to every listed file. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * refactor(studio-server): read a media file's first bytes with a read stream The playlist check reads the first 64 bytes through a bounded read stream instead of a raw file descriptor, and the audio-track probe's doc comment sits on its function again. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * chore(studio-server): raise the packed size budget for the media playlist check Main packs @hyperframes/studio-server close to the 1% tolerance on the 168500 budget, and the playlist check adds about 320 bytes, which put the Build over. Set the budget to 172000. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * fix(cli,studio-server): open media only through self-contained media demuxers Every ffprobe and ffmpeg input that cloud render offload, the publish proxy bake and Studio's media helpers open now carries a demuxer whitelist built from the supported media extensions: MP4/MOV/M4A/AVIF, Matroska/WebM, MXF, AVI, MPEG-PS/TS, FLV, ASF, Ogg, WAV, MP3, AAC, FLAC, AIFF and the still-image formats. Playlist, manifest and concat demuxers can no longer open, whatever a file's bytes say. The proxy's own concat step is left as it is. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * fix(cli,studio-server): keep media probe argv flat, and expect the demuxer list in loudness args Two probe argv literals built from nested spreads are flat again, so "--" stays the visible second-to-last entry the argv contract checks. The normalize-audio test expects the demuxer list before the input. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * fix(cli): play and present answer only local host names and allowed hosts play and present listen on every interface. Each request now passes the same Host check preview uses: localhost, loopback addresses and this machine's own addresses and names are answered, and any other host name gets a 403 naming HYPERFRAMES_PREVIEW_ALLOWED_HOSTS until it is listed there. Phones and other machines on the network still open them by LAN address or .local name. * fix(cli): a local render of a received composition leaves out files outside the project When the composition a local render opens is listed in the project's received-files record, hyperframes render (full and range) no longer brings in files outside the project. It prints one line naming the references it leaves out and why. An unreadable record counts as received. A project whose entry is the person's own, or that has no record, renders exactly as before. * fix(cli): received-render scan reads safely and treats an unreadable record as unknown The scan behind the received-composition notice skips a file it cannot read, finds url() references with a linear forward scan, and reads at most 2 MB of each file. An unreadable received-files record no longer counts as everything received for local render: the render keeps outside files and names the record it could not read. Publish and cloud upload still treat it as received. The notice now says the render stops on a sub-composition outside the project rather than leaving it out. * fix(cli): the studio render of a received composition leaves out files outside the project The Studio render route applies the same rule as hyperframes render: when the composition it renders is listed in the received-files record, the job does not bring in files outside the project, and the server log names the references it refuses. * chore(cli): name the unreadable received-files record helper without a comment * fix(cli): local render refuses outside files when any composition it plays was received The received-file rule for local render (CLI and Studio) now checks every page and stylesheet the render pulls in, not only the entry, so an own index.html that plays a received scene also reads nothing outside the project, and the notice names the received file. An unreadable, truncated or empty received-files record refuses outside files too, as publish and cloud upload do, and the notice names the record it could not read. * fix(cli): decide a received render from the files the compiler reads Local render (CLI and Studio) now leaves outside-file handling as it is for a project with no received-files record or an empty one, without scanning anything. When the record lists files, the compiler's own read list for the composition decides: the bundler runs out of process with a deadline and reports every project file it reads, so stylesheet imports and files past any scan limit count. A received file in that list, a build that fails or runs past its deadline, or an unreadable record refuses outside files. The scan that names refused references in the notice is advisory only: it guards every file system call, tracks visited files by real path, and caps the files and bytes it reads. * fix(cli,producer): decide a received render with the render compiler's own composition traversal The producer exports renderCompositionFiles, which walks data-composition-src with the same resolution, normalization and private file rules the render's sub-composition pass uses; that pass now calls the same helper. The received-render decision adds those files to the bundler's read list, so leading-slash and percent-encoded references the render reads count. The advisory scan resolves compositions the same way and reads template contents. * fix(cli): refuse outside files in a local render whenever the project has received files A local render (CLI and Studio) reads nothing outside the project when the project's received-files record lists any file, or cannot be read. No static list matches what a render consumes: the page loads its stylesheets and scripts through the browser at capture time, and scripts can load more, so the decision no longer depends on one. The reference scan stays only to name what the notice says is left out. This drops the out-of-process bundler read list and the producer composition walk added for that decision. * fix(cli): refuse outside files only when a received file can load other files A local render (CLI and Studio) reads nothing outside the project when the received-files record cannot be read, or lists a received file that can reference others: an .html, .htm, .css, .js, .mjs, .cjs or .svg name, or content that reads as HTML, SVG or CSS. A project that only received images, video, audio or fonts keeps bringing in outside files as before. * fix(cli): keep outside files only when every received file is positively media, a font or an image A local render keeps bringing in outside files only when each file the received-files record lists has a known media, font or image extension and starts with that type's signature bytes. Any other received file, a listed file that is missing or unreadable, or a mismatch between name and content refuses outside files. An ancestor record's entries now match a subfolder whose name is spelled in another Unicode form; the entry keeps its own spelling on disk. * fix(producer,core): a sub-composition must be an .html file The render compiler and the runtime load a data-composition-src only when it names an .html or .htm file. Any other file, such as an image or video, is refused as a page: render stops naming it, and the runtime reports the load failure without fetching it. * fix(producer,cli): the render and static file servers forbid type sniffing Both servers send X-Content-Type-Options: nosniff with every response, so the browser loads a file only as the type its extension names: an image or video cannot run as a script or apply as a stylesheet. .cjs is served as JavaScript. * test(cli): a received media file in a composition slot is refused as a page * test(cli): an empty nested received-files record cannot hide an outer record's received page * fix(cli): a received media file reached under another name refuses outside files The received-render decision now compares file identities, not names. It walks the project once, bounded by entry count and time, and refuses outside files when a hardlink or a symlink with a name that is not media reaches a received file, or when the walk cannot finish. A received file with no identity matches nothing, as in the received files check. * fix(cli): compare received files by link target and keep outside files for an empty record A received media file and every other project name are now compared by the identity of the file they reach with links followed. A linked folder that leads outside the project, or a file whose identity cannot be read, counts as unchecked and refuses outside files. An empty received-files record keeps outside files without walking the project. * chore: raise the producer unpacked size budget for the composition file checks --------- Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com> |
||
|
|
a75e61f31c |
fix(cli): discover mounted scenes inside templates (#7822)
* fix(cli): discover mounted scenes inside templates * test(cli): cover recursive template scene discovery * test(cli): cover media edits in nested template scenes * test(cli): cover nested audio edits and duplicate targets * docs(cli): explain nested scene discovery and ambiguity |
||
|
|
a07d4cf738 |
fix(cli): printed Windows commands read folder names literally in every shell (#7769)
* fix(cli): printed Windows commands read folder names literally in PowerShell, cmd and Git Bash shellArg's Windows branch wrapped any non-plain name in double quotes, where PowerShell and Git Bash still expand $ and backticks. Names with those characters (or PowerShell's curly quotes) are now single-quoted, which both shells read literally; a name that cmd.exe would also split on & | < > ^ gets no printed path, and the hint says to run the command from the project folder. A bare comma or leading @ is quoted so PowerShell does not read an array or a splat. Ordinary names with spaces, accents and apostrophes print as before. The background preview's stop footer uses the same helper instead of JSON quoting, which left $(...) live in POSIX shells and PowerShell. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * fix(cli): printed Windows paths with backslashes keep them in Git Bash A Windows word containing a backslash printed bare, and Git Bash strips unquoted backslashes, so C:\Users\Bob\film reached the CLI as C:UsersBobfilm. Such words now take double quotes, which PowerShell, cmd.exe and Git Bash all read as written; trailing backslashes are doubled so they do not escape the closing quote. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * fix(cli): open --json gives a null stopCommand when the folder has no safe spelling When no spelling of the project folder is safe to paste in every Windows shell, the left-running preview's stopCommand held prose. It is now null, and stopCommandFromProject names the command to run from inside the project folder. The printed line is unchanged. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * chore(cli): drop a comment the nullable return type already states Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * fix(cli): a Windows name with no spelling common to every shell prints no path PowerShell single quotes do not group a word in cmd.exe, and Git Bash reads 'it''s' as its, so the single-quoted form printed for names with $, a backtick or a curly double quote was wrong in two of the three shells. Those names now take the existing null fallback, and the hint says to run the command from the project folder. Round-trip tests check that every printed Windows word reaches the program unchanged: through Git Bash everywhere, and through cmd.exe and PowerShell on Windows, where the CLI's Windows CI job now runs them. The names cover apostrophes, typographic quotes, mixed quotes, cmd operators and trailing backslashes. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * test(cli): run the cmd.exe round-trip through spawnSync execFileSync's options type has no windowsVerbatimArguments, so the Windows-only cmd.exe test failed typecheck. spawnSync takes the option, and the test now also checks the exit status. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * test(cli): expect the quoted Windows path in the relative open command On Windows a relative path holds a backslash, which shellArg now prints in double quotes so Git Bash keeps it. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * fix(cli): a Windows name with %NAME% or ! prints no path cmd.exe expands %NAME% inside double quotes, and interactive Git Bash history-expands ! there, so neither name reads literally in every Windows shell. Both now take the null fallback. A lone % such as 100% still prints. --------- Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com> |
||
|
|
477a3aea13 |
fix(cli): upload archives always leave out env files and private records (#7796)
publish, cloud render and feedback --file-issue build their archive from a walk of the project folder that only consulted .hyperframesignore, so a rule re-including dotfiles also uploaded .env files. The walk now leaves out env files, Git data and Studio's private records whatever the ignore rules say, and reports each one as left out with the reason "private". Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com> |
||
|
|
88beb282f2 |
fix(cli): an unknown flag lists the command's real flags (#7740)
The error only said to run --help, so an agent guessed another flag. It now names every long flag the command declares, and --search points to --query. |
||
|
|
50c21c355a |
fix(cli): parse capture and grade-compare --timeout as a duration (#7715)
capture read --timeout with parseInt, so `--timeout 1s` became a 1 ms page-load timeout. grade-compare dropped an invalid value without a warning. Both now use the shared parseTimeoutMs helper that check and snapshot already use, keeping their defaults of 120000 ms and 5000 ms. Fixes #7671 |
||
|
|
45882027bd |
feat(cli): check warns when text leaves the 9:16 social safe areas (#7680)
* feat(cli): check warns when text leaves the 9:16 social safe areas * feat(core): safe areas owned by core; check adds --safe-zone standard * style(cli): format * refactor(core): name the safe-area band fields * fix(cli): defects outrank safe-zone warnings at the issue cap * style(cli): format * test: read the safe-box constants from core |
||
|
|
0ca4bb8aec |
fix(cli): validate compare --timeout (#7545)
Co-authored-by: Yuxuan Xia <333204300+yuxuanx-rain@users.noreply.github.com> |
||
|
|
89a7aa3004 |
fix(cli): copy only media, font, CSS and JS files from outside the project (#7636)
* fix(cli): copy only media, font, CSS and JS files from outside the project Publish, cloud render and feedback now copy an outside reference into _ext/ only when its extension is an image, video, audio, font, CSS or JS type, taken from studio-server's MIME map (new ./mime subpath; .avif added). Anything else outside the project is left out with a warning and a left_out entry whose reason is file_type; telemetry counts it. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * fix(cli): keep the new outside-type file under its package's comment share Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * fix(cli): copy the outside media cloud render re-encodes or converts The outside allowlist now also takes the video, audio and still-image extensions cloud render re-encodes or converts (.avi, .ogv, .aiff, .tif, .bmp and the rest), from one shared list offload imports too. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> --------- Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com> |
||
|
|
2591abfbf0 |
feat(cli): cloud render --json lists the files an upload leaves out (#7631)
* feat(cli): cloud render --json lists the files an upload leaves out
`cloud render --dry-run --json` now reports `left_out`: each file outside the
project that the upload leaves out, with the file that points at it, the
reference as written, its path from the project, the reason (blocklisted or
received) and how many folders above the project it is. A wrapper can ask
before uploading. A full `--json` run carries the same list in its result and
prints a `{"event":"left_out"}` line on stderr for each, beside the warning a
person reads.
Publish, cloud render and feedback's repro send `cli_upload_left_out` when an
upload leaves something out: counts and folder depths only, never a name or
a path.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* refactor(cli): keep the left-out report's comment share at its package's
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---------
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
|
||
|
|
24d56e6813 |
fix(engine): launch Chrome with only the env it needs (#7629)
* fix(engine): launch Chrome with only the env it needs Every Chrome HyperFrames starts (render, GPU probe, HDR capture, startup diagnosis, version and shell probes, CLI browsers, inspector) now gets an allowlisted environment from @hyperframes/core/chrome-env instead of the whole process env. HYPERFRAMES_CHROME_ENV_PASSTHROUGH names any extra variable a host needs. Refs #7623 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * fix(core): keep the Chrome env passthrough across repeat filtering The CLI GPU probe filters its env twice, which dropped the names HYPERFRAMES_CHROME_ENV_PASSTHROUGH adds, so the probe and the render saw different envs. Keep the passthrough variable itself. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> --------- Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com> |
||
|
|
400a4e2285 |
fix(engine): keep Chrome's sandbox on for local renders where the host supports it (#7625)
* fix(engine): keep Chrome's sandbox on for local renders where the host supports it Chrome launched with --no-sandbox on every host. Keep the sandbox on macOS, Windows and non-root Linux outside containers; drop it as root, in Docker/Podman/Kubernetes, on Lambda and Cloud Run, and where Linux restricts unprivileged user namespaces. --no-zygote now ships only with --no-sandbox, since Chrome refuses it while sandboxed. A sandboxed Linux launch that fails at startup retries once without the sandbox and warns. HYPERFRAMES_CHROME_SANDBOX=1|0 overrides the choice. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * test(cli): cover the Linux sandbox retry in managed browser launches The off-macOS closed-pipe case now passes --no-sandbox, so it still pins "no seatbelt relaunch" rather than the new Linux sandbox retry, which gets its own case. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * fix(engine): honor HYPERFRAMES_CHROME_SANDBOX=1 and latch the fallback on clear evidence only With the override set to 1, a sandboxed launch Chrome refuses now fails instead of retrying unsandboxed. A bare startup exit (TargetCloseError) retries that launch without the sandbox but only latches the sandbox off after a second one, so a single unrelated early kill no longer disables it for the rest of a long-lived process. Chrome naming the sandbox in its error still latches at once. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> --------- Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com> |
||
|
|
2a70733c15 |
fix: track local Studio sharing CTA interactions (#7566)
* fix: track local Studio sharing CTA intent * fix: tag local Studio and CLI share upgrade links with where they came from The local Studio share modal's Upgrade to Pro link opens /pricing?from=cli&entry=local_studio_share, and hyperframes share's source-files notice links /pricing?from=cli&entry=cli_share, so the pricing page can tell which link a visit came from and return the visitor to their terminal. The modal accepts its own pricing page with any query, still only on hyperframes.dev's two origins. share_upgrade_clicked carries cta=share_modal_upgrade. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * refactor: name the local Studio upgrade CTA and drop the explaining comments Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * fix: keep the local Studio upgrade link's return page unchanged Only entry=local_studio_share is added to the local Studio share window's Upgrade to Pro link. from=cli would have told these buyers to go back to their terminal after checkout, but they return to a browser tab. hyperframes share's link keeps from=cli, as the CLI's other upgrade links do. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> --------- Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com> |
||
|
|
668983e1a6 |
fix(cli): preview uses the bundled Studio unless local Studio mode is opted in (#7551)
Local Studio mode runs Vite in the resolved @hyperframes/studio folder, so the project folder decided which config and binary ran. Use it only when the project resolves to the same Studio the CLI itself resolves (a source checkout running its own build) or when HYPERFRAMES_LOCAL_STUDIO=1 is set; otherwise serve the embedded Studio. Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com> |
||
|
|
04947d99f7 |
feat(cli): share rendered videos through unified reviews (#7135)
* feat(cli): share rendered videos through unified reviews (#7135) * feat(share): attach editable project sources to reviews (#7137) * feat(share): measure local sharing outcomes (#7138) * feat(cli): stage the sixty-day publish transition (#7136) * feat(studio): share review pages from local preview (#7140) Advertise the CLI sharing bridge before bootstrapping it so standalone Studio does not request unsupported routes. Preserve origin and session checks. Budget the intended sharing artifact: clean main packs at 8,060,519 bytes versus 8,162,979 with sharing (8,169,168 in CI). Required policy and Unicode tables, bundled sharing code, and Studio controls account for the growth. Set the packed-only budget to 8,577,627, following the 5% headroom convention; retain the unpacked cap and all package checks. * fix(share): persist refusals and improve CLI retry feedback * fix(ci): restore render diagnostics and include sharing workspace * fix(cli): keep sharing owner error codes stable * fix(share): clarify update feedback and align audience changes * fix(share): clarify updates and avoid scratch-file rerenders * fix(cli): report active shares and preserve update channels * fix(cli): resolve update channel when checking registry * fix(ci): refresh sharing package budgets after rebase * fix(share): require consent before uploading project files |
||
|
|
1a9fb8acb6 |
feat: opt-in 4:4:4 chroma for SDR MP4 masters (#5820)
* feat(engine): decouple transparent background from png capture format PNG capture used to imply a cleared page background. A new CaptureOptions.transparentBackground lets lossless opaque PNG capture (4:4:4 MP4 output) keep the page background. Absent, it still follows format === "png", so alpha output and motion blur are unchanged. Opaque PNG skips drawElement, whose verification and worker-encode paths are JPEG-only. Refs #5555 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * feat(engine): add 4:4:4 chroma option to getEncoderPreset getEncoderPreset takes an optional chromaSubsampling ("420" by default). "444" returns yuv444p for SDR MP4, so libx264 encodes the High 4:4:4 Predictive profile and odd sizes need no even padding. WebM, MOV and HDR presets ignore it. The ChromaSubsampling type is exported for the producer. Refs #5555 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * feat(producer): chromaSubsampling render option with lossless png capture RenderConfig.chromaSubsampling ("420" by default) opts an SDR MP4 render into 4:4:4. "444" encodes libx264 yuv444p and captures every frame as opaque PNG: Chrome's quality-100 JPEG is already 4:2:0 on beginFrame and screenshot capture, and drawElement can fall back to screenshot mid-render, so PNG is the only capture that keeps the colour. drawElement is turned off for these renders. The probe and main capture options share resolveCaptureSurface, so they cannot disagree on format, quality or background. Formats other than mp4, GPU encoding and HDR output are rejected before any work starts, auto-detected HDR sources fail before capture, and distributed requests refuse 444. The default render is unchanged. Refs #5555 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * feat(producer,studio-server): accept chromaSubsampling on render routes The shared parseEncoderOptions validates chromaSubsampling and answers 400 for "444" with a non-mp4 format, gpu, or force-hdr, so a request that would come back 4:2:0 never starts a render. The Studio render route, both Studio adapters and the producer HTTP server forward it. The producer server also refuses "444" with outputDynamicRange "hdr", which parseEncoderOptions cannot see. No Studio UI control; the option is route-level like crf and hdrMode. Refs #5555 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * feat(cli): add --chroma-subsampling flag `hyperframes render --chroma-subsampling 444` opts an SDR MP4 render into full-resolution chroma (yuv444p with lossless PNG capture). The default stays 420. The plan rejects 444 with a non-mp4 format, --gpu or --hdr before anything renders, with a usage error that names the conflicting flag. The value reaches the local render request and, only when it is 444, the Docker argv, so default Docker invocations are unchanged. Refs #5555 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * docs: document 4:4:4 chroma subsampling Add a "4:4:4 masters" section to the rendering guide: when to use --chroma-subsampling 444, why it captures PNG, the measured chroma gain (large for text and UI, none for footage and gradients), its limits, and a player compatibility table to be filled in from testing. Document the flag in the CLI reference, the built-in rendering docs and the hyperframes-cli skill reference (with the regenerated skills manifest), and the chromaSubsampling option in the producer docs. Refs #5555 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * docs: add 4:4:4 player compatibility results Fill the 4:4:4 compatibility table from testing H.264 High 4:4:4 Predictive output. Chrome 155, Edge 155, VLC 3.0, Safari on iOS 26.6 and Safari 26.6 on macOS play it, and so does AVFoundation on macOS 26.6, the framework QuickTime Player plays through. Firefox 157 on Windows and both Windows media players do not. Refs #5555 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * docs: note the measured render cost of 4:4:4 output Replace the vague "slower capture" note with measured numbers: a text and UI composition rendered in about twice the default time, full-frame footage in about three and a half times, because PNG encoding cost grows with image detail. Refs #5555 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * fix(producer): reject chromaSubsampling 444 in distributed render config Distributed configs have no chroma field and validateDistributedRenderConfig ignored unknown keys, so a JS caller passing chromaSubsampling: "444" to the Lambda or Cloud Run SDK got a 4:2:0 file with no error. Reject it, and make the rendering guide say so precisely. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * test(producer): check a 444 render reaches the encoder as yuv444p Every helper had tests, but nothing checked the orchestrator passes chromaSubsampling through, so dropping it from the encoder preset or capture surface would turn 444 renders back into 4:2:0 with all tests green. Render a small fixture with "444" and with the default and check pix_fmt with ffprobe. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * refactor(producer): move the 444 drawElement gate into a helper Keeps runCompileStage under the fallow complexity threshold. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * chore: keep comment share at or below the merge-base comment-ratchet failed on 11 files this PR touched. Keep the 4:4:4 rationale once in chromaSubsampling.ts, move the distributed-render reason into its error message, and cut the rest. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * test(producer): check a 444 render captures full-resolution chroma The encoder check alone passes when chromaSubsampling is dropped from the capture surface: frames are captured as JPEG and encoded yuv444p with 4:2:0 colour. Put a red/blue edge at an odd x, inside a 4:2:0 chroma pair, and require the two pixels to differ in Cb. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * chore(producer): trim the chromaSubsampling.ts header to the package comment share Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * fix: finish switching to capturesAlpha from #6262 The merge that adopted main's transparent / capturesAlpha left these files uncommitted, so resolveCaptureSurface still returned transparentBackground. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * refactor(engine): use transparent / capturesAlpha from #6262 main added CaptureOptions.transparent and capturesAlpha (#6262), which do what this PR's transparentBackground did. Use them, keep the PNG check in drawElementWorkerEncodeEligible, and re-pin test-classification.mjs and the skills manifest against current main. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * chore(producer): cut the 4:4:4 comment blocks to one to three lines The reasoning lives in the PR description with the measurements. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * refactor: reconcile 4:4:4 chroma with latest main Keep main's video-layer capture overrides, template entry resolution, ProRes profile parsing and blur-differential tests alongside the chroma option, and fold the encoder sub-parsers into one loop. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * chore: keep main's compile-stage tests and regenerate the skills manifest Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> --------- Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com> |
||
|
|
3a24da8a8e |
fix(cli): spaced-path hint takes the longest path and reads --flag=value; telemetry docs name the reverse session id (#7452)
Follow-ups from review on #7443 and #7444: - The quote hint returned the first run of words that existed, so a "Final Cut/" folder hid "Final Cut export.mp4". It now names the longest. - "--compare=my clip.mp4" got no hint; the value after = now starts a run. - The telemetry section lists the skill a reverse or templates command ran for, and the HeyGen session id a recorded reverse run carries. |