open-edit
Open-source, agent-driven editing pipeline: create subtitles, motion graphics, slides, edit and render videos.
Safety scan
A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.
Check it deeper on your machine
It has changed since its scan on 11 Nov 2026.
As a Claude Code plugin, install it and then ask Claude Code:
/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/veedstudio/open-edit with scanskillsafety
Or from a terminal, clone it and run it:
git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/veedstudio/open-edit'
It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.
Badge for your README
Markdown
[](/listings/veedstudio--open-edit)HTML
<a href="/listings/veedstudio--open-edit"><img src="/api/listings/veedstudio--open-edit/badge.svg" alt="findsafeskills safety rating" /></a>Install
Install instructions from the README
As written by the repo's author. findsafeskills has not verified these steps.
`install-ffmpeg` looks for an existing FFmpeg first (`OPENEDIT_FFMPEG` and `OPENEDIT_FFPROBE`, then a previous install, then PATH) and only downloads when there is none — a checksum-verified static build into the app-data dir (the download route is Windows-only; macOS points at `brew install ffmpeg`, Linux at `apt`). A set `OPENEDIT_FFMPEG` or `OPENEDIT_FFPROBE` is run first, and fails the command, naming the variable, when its binary does not start, since nothing else is used while it is set; `--check` runs whichever pair every command would. `--force` reinstalls the app-data copy, and is refused while either override is set, since no command would run the copy it installs. `install-whisperx` installs the local transcription provider into an isolated uv/pipx tool environment; it never touches the system Python.
npx @veedstudio/openedit-cli install-ffmpeg [--check|--force] npx @veedstudio/openedit-cli install-whisperx [<version>]
What was scanned
The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.
README.md · README · 664 lines
View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)
This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.
- # @veedstudio/openedit-cli
- The Open Edit command-line tool: agent-driven video creation and editing,
- powered by VEED.
- The package carries the agent skill that `init` installs into a workspace;
- everything else is a command below. The source is public at
- [veedstudio/open-edit](https://github.com/veedstudio/open-edit), whose README
- covers what Open Edit is and what it makes; this page is the command surface.
- ## Usage
- ```sh
- npx @veedstudio/openedit-cli --help
- ```
- ## Commands
- ### login
- Log in with VEED (OAuth 2.1 + PKCE via the browser; the token is stored locally
- and refreshed automatically):
- ```sh
- npx @veedstudio/openedit-cli login
- ```
- Pass `--manual` (or set `VEED_LOGIN_MANUAL=1`) when no reachable browser exists:
- the URL is printed, and the redirect is pasted back instead of caught on a
- localhost loopback.
- ### token
- Print a valid VEED access token for other tools to consume, refreshing it
- first when stale (`VEED_ACCESS_TOKEN`, when set, is passed through as-is). The
- value is printed only when the output is captured; run it straight in a terminal
- and it reports that a token exists without putting one in your scrollback:
- ```sh
- npx @veedstudio/openedit-cli token
- ```
- Exits non-zero when no login is stored. `--path` prints the token store
- location instead of a token.
- ### transcribe
- Transcribe videos, writing `runs/<key>/transcript.json`. The provider is the
- user's choice, recorded once with `--record`: a bare `transcribe video.mp4` runs
- the recorded one (and refuses, saying why, when nothing usable is recorded), and
- `--provider` names another for one run. Locally with WhisperX (free, offline,
- nothing billed anywhere):
- ```sh
- npx @veedstudio/openedit-cli transcribe --provider whisperx video.mp4 [...] [--model medium] [--language de] [--force]
- ```
- A transcript already on disk is left alone (it may have been retimed onto an
- edit); `--force` transcribes it again.
- Or hosted by VEED (premium quality; requires the one-time `login`, and spends
- the workspace's VEED transcription credits — `--workspace <id>` names which,
- required only when the account has several):
- ```sh
- npx @veedstudio/openedit-cli transcribe --provider veed video.mp4 [...]
- ```
- `--record <veed|whisperx|custom> [--model <id>]` records the transcription
- provider choice in `.open-edit-prefs.json` instead of running anything.
- ### whisper
- Map a speech-to-text JSON produced by your own service or a fal model into the
- same `runs/<key>/transcript.json`: Whisper's segments with word times
- (WhisperX, openai-whisper, whisper-timestamped, mlx-whisper), the OpenAI API's
- `verbose_json` with word granularity, whisper.cpp `-oj -ml 1`, a timed word
- list, fal's whisper and wizper chunks, a voice model's character timestamps, or
- the `fal-result.json` that `fal run` keeps a model's answer in:
- ```sh
- npx @veedstudio/openedit-cli whisper transcription.json media.mp4 [...] [--force]
- ```
- Word timestamps are required; the media argument may be a video or an audio
- file. Every command that reads a transcript (`review`, `retime-transcript`,
- `shots`, `veed-project`, `words`) takes the same formats, mapped in memory, and
- prints one line naming the format it read.
- ### words
- Print a transcript as timed lines, one per word with its start and end in
- seconds, or one per cue with `--cues`; `--from`/`--to` keep the lines that
- overlap that stretch. It reads a `transcript.json` or any format `whisper` maps,
- and writes nothing:
- ```sh
- npx @veedstudio/openedit-cli words runs/<key>/transcript.json [--from <sec>] [--to <sec>] [--cues]
- ```
- ### generate / generate-set / sample-presenter
- Fabric generation — source footage from a script, when there is no video to
- caption. Generating draws the named workspace's AI Playground credits twice —
- the speech is synthesized, then lip-synced — so it is two commands: the first
- quotes the sum and records the approval, the second
- spends exactly what was approved (no `--script` on the spend pass — the
- recorded, hashed script is what bills):
- ```sh
- npx @veedstudio/openedit-cli generate --script "spoken words" --key my-run --workspace <id>
- npx @veedstudio/openedit-cli generate --key my-run --yes
- ```
- `--resume` collects a job already created and paid for; `--abandon <sessionId>`
- clears one abandoned charge record. `generate-set --shots shots.json` covers
- several shots under one approval, and `sample-presenter` proposes a
- deterministic character/voice pair for a run key (listing costs nothing).
- ### background-removal / lipsync
- Remove a video's background, or re-lipsync a video to a new audio track.
- Background removal tries VEED's free route first; when that route cannot run,
- it stops having spent nothing and prints what fal's model would cost and the
- command to run with `--fal`. Only `--fal` (the full model, uploaded to fal's own
- storage) or `--fast` (fal's fast model) buys anything, and lipsync always goes
- through fal. Every fal call bills your own fal key, never a VEED workspace; a
- re-run of the same inputs resumes the paid job instead of buying it again:
- ```sh
- npx @veedstudio/openedit-cli background-removal video.mp4 [--fal|--fast] [--mask-only] [--no-refine] [--out <path>]
- npx @veedstudio/openedit-cli lipsync video.mp4 narration.mp3 [--out <path>]
- ```
- The fal key comes from `FAL_KEY`, or `OPEN_EDIT_FAL_KEY_FILE` pointing at a
- file that holds it.
- ### veed-project / veed-pull
- Hand a finished edit to VEED's editor as a project a person can take apart:
- footage cuts, text, captions, images and each audio track become the editor's
- own items, and each page element the plan names becomes a transparent clip cut
- to its box. It uses your VEED login and spends no VEED credits and nothing on your
- fal key. The last step runs in
- your browser: click the "OpenEdit to VEED" bookmark on VEED. The way back is the
- "Send to Claude" bookmark on a project open in the editor, and `veed-pull`:
- ```sh
- npx @veedstudio/openedit-cli veed-project --install-bookmark
- npx @veedstudio/openedit-cli veed-project plan.json [--workspace <id>] [--local]
- npx @veedstudio/openedit-cli veed-pull ~/Downloads/openedit-<project id>.json --out <dir>
- ```
- `veed-project --help` lists the plan's fields; `veed-pull` writes the project
- back as such a plan.
- ### fal
- Run any fal model on your own key. Local file paths inside the input are
- uploaded for you (multipart above 90 MB), outputs are downloaded, and each job
- ends with a cost line: the billed figure when your key can read fal's billing,
- otherwise `cost: unknown` beside fal's listed price. An identical request is
- bought once, even across processes and crashes:
- ```sh
- npx @veedstudio/openedit-cli fal schema <model>
- npx @veedstudio/openedit-cli fal run <model> --input '{"prompt":"…"}' [--out <dir>]
- npx @veedstudio/openedit-cli fal run --batch jobs.json [--concurrency N] # [{model, input, name?}]
- ```
- ### install-ffmpeg / install-whisperx
- `install-ffmpeg` looks for an existing FFmpeg first (`OPENEDIT_FFMPEG` and
- `OPENEDIT_FFPROBE`, then a previous install, then PATH) and only downloads when
- there is none — a checksum-verified static build into the app-data dir (the
- download route is Windows-only; macOS points at `brew install ffmpeg`, Linux at
- `apt`). A set `OPENEDIT_FFMPEG` or `OPENEDIT_FFPROBE` is run first, and fails
- the command, naming the variable, when its binary does not start, since nothing
- else is used while it is set; `--check` runs whichever pair every command would.
- `--force` reinstalls the app-data copy, and is refused while either override is
- set, since no command would run the copy it installs.
- `install-whisperx` installs the local transcription provider into an isolated
- uv/pipx tool environment; it never touches the system Python.
- ```sh
- npx @veedstudio/openedit-cli install-ffmpeg [--check|--force]
- npx @veedstudio/openedit-cli install-whisperx [<version>]
- ```
- ### brief
- Record what the user asked of a piece once, in its folder: how long it runs,
- where it is posted and their own words. `review` compares the video's length
- with it and the numbers on screen with the words, `render` and `apply-edl` print
- a line when what they made misses that length, `safe-zone` takes its zone from
- the platform, `render` gives that zone to a page that links none, and `reframe`
- takes its shape; a value given to the tool itself wins, and the tool says which
- it used. A tool finds
- `brief.json` from the file it works on, in that file's folder or the nearest
- one above it inside the workspace. Each call sets the fields it is given and
- keeps the others:
- ```sh
- npx @veedstudio/openedit-cli brief runs/<key> --length 60 --platform tiktok --words "Doors open at 7"
- npx @veedstudio/openedit-cli brief runs/<key> --platform "linkedin 1:1"
- npx @veedstudio/openedit-cli brief runs/<key> # prints the brief that applies there
- ```
- ### render / fonts / safe-zone / install-browser
- Render an HTML page to video in headless Chrome, frame-exact. The page runs on a
- virtual clock (timers, `requestAnimationFrame`, `Date.now` and a seeded
- `Math.random` advance one frame per frame); CSS and Web Animations, GSAP's
- global timeline and an optional `window.__seek(t)` are set to each frame's time,
- and `<video>` elements show the picture at that time. The output is silent H.264
- (or ProRes 4444 with `--transparent`), identical whatever the worker count:
- ```sh
- npx @veedstudio/openedit-cli render page.html --out out.mp4 --fps 30000/1001 --duration 12 [--workers N]
- npx @veedstudio/openedit-cli render page.html --out out.mp4 --footage clip.mp4 # the clip's rate and length
- npx @veedstudio/openedit-cli render page.html --out out.mp4 --from 4 --to 6 # re-render only that stretch
- npx @veedstudio/openedit-cli render page.html --out stills --stills 0.5,2,4 --sheet sheet.jpg
- ```
- Segments and a manifest are cached in `<out>.render/`, so `--from`/`--to`
- re-renders the segments it overlaps, and any other whose page or files changed
- since it was drawn (a cue that moved, a clip replaced at its path), and rejoins
- the rest by stream copy; every frame of the joined file is checked against its
- time. A page marked
- `data-stateless` is checked on one frame before the workers start, and rendered
- as an unmarked page, with a line saying why, when the mark does not hold.
- A page's long-GOP videos, and any in a codec Chrome has no decoder for (HEVC
- or ProRes, say), are served from all-intra copies, made once per source, keyed
- by its content, in the workspace's `runs/.media`, which stills into any
- directory, renders and patches share (`render --help` says how much it keeps).
- It fails naming the cause when Chrome does not start or stops answering, the
- page throws, or every frame is one flat colour, and a signal stops it with the
- Chromes and ffmpegs it started. A video render then looks at what it made, as the
- review's blank-frames and dead-air checks do, and prints a line, failing
- nothing, for a first frame that is blank, near-black or partway into a fade-in,
- and for each still held longer than its words allow; a patch looks only near
- the range it re-rendered. `fonts` downloads Google Fonts as local woff2 files
- with a `fonts.css`; `install-browser` fetches the pinned Chrome Headless Shell,
- which `render` also does on first use. `safe-zone` writes the stylesheet for where
- a video will be posted: the stage at its shape's size, and a `[data-safe]`
- container on that platform's safe zone as the page's text layer. With no zone
- named, it takes the platform in the piece's brief. A zone is the app the user
- names (`tiktok`, `reels`, `shorts`, `youtube`, `x`, `linkedin`, `facebook`).
- With none named, or several, it is the shape: `9:16`, `1:1` and `4:5` are each clear
- of every app's UI listed for them, while `16:9` is YouTube's player, so a 16:9 piece
- for a feed names that feed's app (`4:3` has one zone). For Instagram, name where it
- goes: `reels` for a 9:16 Reel, the feed shape (`1:1` or `4:5`) or the app with its
- shape (`instagram 4:5`), or pass the canvas with `--canvas`; LinkedIn and Facebook
- are named or take `--canvas` the same way. Add
- `--ad` when a 9:16 video is an ad: ads reserve more of the frame than an ordinary
- post's UI takes. Ordinary posts and feeds are kept clear of the UI each app draws
- over them, ads of the platforms' published ad safe zones, and 4:3 has television
- title-safe sides (`safe-zone --help` says exactly what each zone keeps clear). The
- container is a size container, so `cqw` and `cqh` measure the zone for what is
- inside it. Its other defaults lose to any rule the page writes: text inside starts
- at the shape's minimum (and so do `small`, `sub`, `sup`, `h5`, `h6` and form
- controls), a word too long for its line breaks, boxes inside keep within its width
- unless they set `max-width: none` (a ticker's track also sets `width:
- max-content`), and nothing is clipped:
- ```sh
- npx @veedstudio/openedit-cli fonts "Inter:wght@400;700" Anton --out fonts
- npx @veedstudio/openedit-cli safe-zone --out runs/<key> # the platform in the piece's brief
- npx @veedstudio/openedit-cli safe-zone tiktok --out runs/<key>
- npx @veedstudio/openedit-cli safe-zone 9:16 --ad --out runs/<key>
- npx @veedstudio/openedit-cli safe-zone instagram --canvas 1080x1350 --out runs/<key>
- npx @veedstudio/openedit-cli install-browser [--check|--force]
- ```
- ### captions
- Caption every spoken word of a transcript on the page. `captions` writes
- `captions.js` beside the transcript (`--out` names another file): its words and
- the code that shows them as cues on the page's clock. The page loads it with a
- `<script>` tag and gives it an empty element marked `data-captions` where the
- captions go, inside `[data-safe]` when the page has a safe zone. Each cue comes
- up with its first word and stays half a second past its last, held until the
- next when the gap is under half a second, so the screen clears only in a silence
- of a second or more. Cues break where the speech does (a sentence end, a pause,
- a clause), speak for at most 7 seconds, and take at most two lines of 42
- characters, fitted to the element's width in the page's own font. With
- `faces.js` loaded the cues are placed off the faces and the graphics burned into
- the footage, inside the safe zone, at one place through each shot: they can move
- only at a cut, and inside a shot only where no single place stays clear for every
- cue up in it, however briefly, as few times as that takes, which the console
- says. The script sets
- structure and state only, never a look: the cue
- on screen is a `[data-cue]` of `[data-line]`s of `[data-word]` spans
- (punctuation in a `[data-punct]` of its own), each word's `data-state` is
- `next`, `now` or `said`, and `--since`, `--progress`, `--cue-since`,
- `--cue-until` and `--cue-progress` give the page's CSS each frame's timing to
- animate from. `data-lines`,
- `data-words` (1 for one word at a time), `data-chars`, `data-at` (where the
- transcript's clip starts on the page), `data-from` and `data-to` on the element
- change the cues; `captions --help` lists them all. A speech-to-text JSON is read
- as `whisper` reads it:
- ```sh
- npx @veedstudio/openedit-cli captions runs/<key>/transcript.json [--out <file>]
- ```
- ### mux-audio / mix-audio
- Put sound on a render. `mux-audio` lays a track (the source clip, or a built
- soundtrack) onto a silent render, levelled to -14 LUFS / -1 dBTP
- (`--no-loudnorm` keeps the source level; the line it prints says which
- correction ran), starts a clip that `render --footage-at` placed later in the
- piece at that same moment, and prints a silent opening or ending longer than a
- second in what it wrote. `--music <file>` in place of `--audio` lays a music
- file alone, run to the picture's last frame;
- `mix-audio` first builds one track from many pieces — narration, music,
- effects — per the run's mix spec, with music and effects ducked under the voice,
- effects given no gain set under it by measured loudness (give an effect a
- gain for a deliberate loud hit), and the music bed run to the end of the film:
- looped with a crossfade when its sound ends sooner, faded out at the end.
- `--video` takes the mix's length from the render, and the sound of each
- `<video>` its page plays is laid in where the render played it, trims, loops
- and speed included, under the voice; the spec's `pageVideos` leaves one out or
- lays it otherwise:
- ```sh
- npx @veedstudio/openedit-cli mix-audio runs/<key> --video runs/<key>/out.mp4 # → runs/<key>/audio/mix.m4a
- npx @veedstudio/openedit-cli mux-audio --video runs/<key>/out.mp4 --audio runs/<key>/audio/mix.m4a --out runs/<key>/final.mp4
- npx @veedstudio/openedit-cli mux-audio --video runs/<key>/out.mp4 --music runs/<key>/assets/music.mp3 --out runs/<key>/final.mp4
- ```
- ### review
- Run every delivery check on the video about to be delivered and print one
- report. It changes nothing, and exits 0 whatever it finds. The blank-frames
- check reports a flash, a frame or two of one flat colour (a blank white page
- with only a caption on it, say) between other pictures; any flat colour held
- with nothing on it for more than a second; and a first frame that is blank,
- near-black or partway into a fade-in, since platforms show it as the cover.
- The dead-tail check reports a picture that runs on more than a second past its
- last sound or its last spoken word. The words come from the `transcript.json`
- in the video's folder, or the one `--transcript` names, in any format `whisper`
- maps; the review never transcribes, and without a transcript it says what it
- skipped. A picture that runs on past the last word with sound under it to the
- end is an end card when
- new text is on screen through it: text that came up from the pause before the
- last spoken phrase on, in an element that showed no other words before then.
- It passes unless it is held longer than its words take to read: 0.2 seconds a
- word, plus 2 seconds to find the text (3 from ten words) and a one-second beat,
- never less than 4 seconds and never more than 4.5. So a card brought up with
- the spoken call to action counts, while a caption left on into the music, a
- title up since earlier or a watermark does not. A run-on with more than a
- second of no end card is reported as background left running; without the
- record of on-screen text (below) it is reported, and the report says the end
- card could not be judged. The dead-air check reports a stretch with nothing
- happening anywhere in the video. In the picture, that is a still, frozen or
- nearly so (a slow zoom or a drift over a held card), held longer than a still
- may hold, end cards included: as long as an end card of as many words when it
- has words on screen, 3 seconds when it has none. Footage that moves almost
- everywhere, such as a slow pan, is not still. A talking head can measure as
- still as a held card, so a nearly still picture passes while a voice talks over
- it without pausing more than 2 seconds; without a transcript it is reported,
- and the report says the voice could not be checked. A frozen picture is
- reported whoever speaks over it. In the sound, it is a first sound more than a
- second after the first frame, and more than 2 seconds of silence between two
- sounds; a silence after the last sound is the dead-tail check's to report, so
- no silence is reported twice. The length check reports a picture that runs longer
- or shorter than the length asked for, in seconds (`--length`, else the length in
- the piece's brief), by more than a second or 5% of that length, whichever is
- more; without either it is skipped. The
- canvas check reports a picture nearly one of the platform shapes (9:16, 1:1, 4:5,
- 16:9) but not exactly it, such as a 606x1080 crop of 1080p footage, and one under
- 1080 px on its short side; a picture of another shape is judged on its short
- side alone.
- The text, captions, numbers and graphics checks read the record of on-screen text that `render`
- writes beside each video, `<video>.text.json`: the text the page draws in its
- HTML and SVG (not text inside an image, a canvas or the footage), read about
- every 100 ms of the page's time, with its words, its box and font size in the
- video's pixels, its colour, its opacity and how opaque the backgrounds painted
- under it are, and each `<video>` the page shows, with its clip, the second of
- it on screen and where its picture lies. `mux-audio` carries the record to
- the file it writes, and a patch with `--from/--to` keeps it whole. The text
- check reports text smaller than a phone's body text, measured against the
- frame's shorter side, and text under WCAG's 3:1 contrast for large text against
- what is really behind it, measured on the video's pixels around the glyphs, so a
- backing, a stroke or a shadow counts; it skips the contrast of a transparent
- render, and of text that is translucent or has no solid fill of its own. The
- captions check reports a second or more of speech with no caption on screen. A
- caption is a text in the page's caption track (an element marked
- `data-captions`, which `captions.js` fills), a text that shows the words being
- spoken, or, in another language than the voice, one of a run of texts in one
- place that change with the spoken phrases; a title is not one. It is skipped when the page captions too little of
- the speech to be captioning it, or there is no transcript. The numbers check
- reports a number on screen that neither the transcript nor the user's own words
- say, with where and when it shows: a time, a price, a percentage or an amount
- worked out or guessed while the video was made, such as "Ready in 15 min" over
- narration of "about 10 minutes". Numbers are compared by value, in digits or in
- English words, so "15 min", "fifteen minutes" and "0:15" agree, as do "$5" and
- "five dollars", "50%" and "half", "2018" and "twenty eighteen", and a rounding
- such as "1.4M" for 1,423,000; a range or a score is two numbers. A list's own
- numbering ("01", "Tip 2") and the count of its items, a clock or a count running
- in one place, a number up for under a quarter of a second, and digits in a name
- ("MP4"), an address or a handle are set aside. The user's words come from
- `--brief`, their message itself or a file holding it, repeatable, else from the
- words in the piece's brief (`brief --words`); without either the numbers are
- compared with the transcript only, without a transcript with the user's words
- only, and with neither the check is skipped. It cannot see the
- footage, so a number read off the picture (a scoreboard, a page in shot) is
- reported too. The graphics check reports text drawn over a graphic burned into
- the footage while it is up: the record names the clip `--footage` laid under the
- page, and each `<video>` the page plays with the second of its clip on screen
- and where its picture lies. It reads the graphics `faces` found on a clip, or
- looks for them itself when `faces` has not run on it, and counts a text only
- where the video still shows the clip's picture around it, so text on a card or
- band that covers the graphic passes. A video without a record, or with one for a
- picture of another size or length or older than the video, skips all four:
- ```sh
- npx @veedstudio/openedit-cli review runs/<key>/final.mp4 [--transcript <transcript.json>] [--length <sec>] [--brief <text|file>]
- ```
- ### Frames and joins
- Tools for looking at and joining footage:
- ```sh
- npx @veedstudio/openedit-cli concat-videos [--canvas WxH] [--fit crop|letterbox] <out> <in1> <in2> [...]
- npx @veedstudio/openedit-cli frames <video> --at 12.5,1:02 --frame 300-306 --every 0.5 --from 8 --to 11 [--sheet] # stills at the moments you name
- npx @veedstudio/openedit-cli frames --images <image|dir> [...] [--width N] [--cols N] # pictures that already exist, on one sheet
- npx @veedstudio/openedit-cli shots <video> [--threshold 0.1] [--min-shot 0.333] [--faces <faces.json>] [--json] # a video as a shot list: cuts, lengths, speech from an existing transcript, shot size from existing face boxes, storyboard sheets
- ```
- The cut tools, for an edit made before captioning: measure where speech starts,
- stops and pauses; assemble the kept ranges of an EDL (edit decision list) with
- crossfaded joins, each range snapped to the frame grid and optionally at its own
- speed (slow motion by repeated or interpolated frames, sound time-stretched or
- silenced) and grade (exposure, contrast, saturation, temperature, a LUT, grain),
- a source at another frame rate converted to the first's and each source's speech
- levelled to the quietest's, moving the per-word timings, the face boxes and the burned-in graphics the
- sources already have onto the cut instead of finding them again. Each range's picture is kept in `<cut>.ranges/` under
- a name made of its source's content and everything applied to it, so a second run
- that changes one range encodes only that range. A path in the EDL is read beside
- it, else from the working directory or the workspace when the file is there.
- After the cut, `apply-edl` prints what it removed from each source, with times,
- each range whose picture runs on past its last sound, and each stretch held
- still with nothing heard, measured on the cut, and a line when the cut misses
- the length in the piece's brief.
- `--gap` and `--crossfade` are milliseconds; the EDL is seconds.
- ```sh
- npx @veedstudio/openedit-cli speech-probe <video> [--range a:b] [--gap 250] [--window 10] [--json]
- npx @veedstudio/openedit-cli apply-edl --edl edl.json --out cut.mp4 [--crossfade 40] [--crf 20] [--fit crop|letterbox] [--keep-levels]
- npx @veedstudio/openedit-cli retime-transcript --edl edl.json --out <transcript.json>
- ```
- Both joins put every clip on one canvas, sized as the clips are shown (a phone
- clip stored sideways counts as upright). A clip of another shape is cut to the
- canvas's shape with `reframe`'s own code, around its faces when `faces` has run
- on it and from the middle otherwise, and a line says which; `--fit letterbox`
- keeps it whole and pads it instead. `render --footage` refuses footage of
- another shape than the stage and names the `reframe` command that cuts it.
- The retimed transcript goes where a transcription of the cut would land,
- `runs/<key>/transcript.json` under the workspace, so the transcription routes
- refuse to overwrite it and the cut is never transcribed. `retime-transcript`
- writes the same transcript from an EDL alone, to any path.
- ### faces / reframe / install-mediapipe
- Find the faces in each shot of a clip and write their boxes, for laying text
- out around them and for `reframe` (and the joins, which cut a clip of another
- shape as it does). They go to `runs/<key>/faces-<hash>/`, a folder of the clip's
- own named by its real path, so two clips of one name never share one; `faces`
- prints the path, and every reader looks there (and in a `runs/<key>/faces.json`
- an older `faces` wrote, when it names that same clip). One decode finds the cuts, those between two
- shots of one set that change the picture little included, and samples four
- frames a second (`--every 0.25`), each labelled by its presentation time, so
- variable-frame-rate footage is sampled in time; a shot sampled fewer than four
- times also gets its first frame and the first at or past the middle of each
- quarter of it;
- MediaPipe's full-range BlazeFace model finds the faces on CPU. The same
- sampled frames, small and grey, show the graphics burned into the footage (a
- lower third, a score bar, old subtitles, a logo), without OCR or a model: sharp
- edges, mostly square to the frame, that hold their value while most of the frame
- changes around them, at a cut or as the camera moves (a step in the camera's
- exposure is no change), or that come up over, or give way to, other steady
- content in a still shot, each with the seconds it is up. `faces.json`
- holds the boxes per sampled frame of each shot and the graphics; `faces.js` holds them too, with
- `openeditFaces.place(el, from, to)`, which moves a laid-out element the least
- distance that clears every face on screen, and every graphic up, between those seconds of the clip.
- For elements shown one after another in one spot, such as caption cues,
- `openeditFaces.placer(spans, measure)` gives them one place through each shot,
- moving them only at a cut, or where no single place stays clear for every element
- up in a shot, however briefly. `measure(i)` gives the box `{x, y, w, h}` element
- i is laid out in, in viewport pixels, and is called by `prepare(i)`, which the
- page runs while none of the elements is on screen, before showing one; a page
- that never calls `prepare` still works, with `place()` measuring each time.
- `place(el, i, sec)` takes an element's index and one second of the clip rather
- than a span. `part(i, sec)` changes at each cut, and the page places an element
- up across it again there. `captions.js` places its cues with it.
- `install-mediapipe` puts MediaPipe, every package it runs on at the versions
- verified together (OpenCV's headless build) and the model into an environment
- of their own under the app-data directory, never the system Python: with uv
- when present, which fetches a Python it can use, else with `python3 -m venv`
- when that python3 is 3.12 or newer. MediaPipe 1.1.1 has no Intel Mac build; on
- an Apple Silicon Mac run an arm64 Node, and on Windows on ARM install uv and set
- `OPEN_EDIT_MEDIAPIPE_PYTHON=cpython-3.12-windows-x86_64-none`:
- ```sh
- npx @veedstudio/openedit-cli install-mediapipe [<version>]
- npx @veedstudio/openedit-cli faces video.mp4 [--out <dir>] [--every 0.25] [--threshold 10] [--confidence 0.5] [--margin 0.25]
- ```
- `reframe` cuts a clip to another shape (16:9 to 9:16, say). With those boxes,
- and without guessing who is who, each shot, which can be split again where a
- face seen alone for four samples jumps further than its own width and is seen
- alone there for four more (a dissolve or a cut the cut detection missed), is
- followed when it shows one face only (never two at once, each found
- overlapping the one before), the crop holding still while the face stays inside
- it and easing to a new place only when it must, and held at one place when it
- shows more, where the faces wholly inside add up to the most height; at a cut
- or a split it jumps. A face less than half the height of the tallest found with
- it is someone in the background and does not count. Without them it cuts the
- clip from the middle. Where a face does not lie wholly inside the crop, larger
- than it or beside another face a held shot keeps, it prints those seconds. The
- crop is
- scaled (lanczos) to 1080 px on its short side, the platforms' canvas for their
- shapes: 1080x1920 for 9:16, 1080x1080 for 1:1, 1080x1350 for 4:5, 1920x1080 for
- 16:9. `--size` names another size of the shape, such as 2160x3840 for 4K, and
- `--size native` keeps the crop in the source's own pixels. It always re-encodes:
- upright, in square pixels, H.264, a clip already in that shape included and
- scaled the same way. With the clip's boxes it also writes the output's own, in
- the output's folder where `faces` would write them, each box and burned-in
- graphic moved and scaled with the crop and cut where the crop cuts it, so
- `faces` need not run on the clip it made.
- When the crop cuts in part a graphic `faces` found (old subtitles, a lower
- third), a last line says so, with the rows it is in and what erasing them
- costs. `--erase` erases those rows, across the whole width and for the whole
- clip, since the search misses a line of text that is up for under a second and
- a half. The first run cuts the clip into parts of at most 6 s for the eraser,
- a video editor on fal told to remove the subtitles and keep the rest, beside
- `--out`, and prints the price of every part as one total: an estimate, each
- run's seconds, in whole seconds as fal bills them, at fal's price per second,
- with a quote id. Nothing is spent, and no run exists, until `--approve` passes
- that price and quote back once the user has said yes to it. That run writes
- each part's input and prints the fal runs to make: one batch for `openedit
- fal` on a fal key, or, with no key set, one run a part for the environment's
- own `fal` command, one whose help says it runs a model with its input. A quote
- approves once, so one yes prints each run once: running a part again may buy
- it twice, so a part that is not back is priced again, under a quote of its
- own, and its run printed only for an `--approve` of that. `reframe` never runs
- the eraser itself. Once the parts are back, the same command lays only the
- erased rows over the clip, keeping every other pixel, every frame and the
- sound, writes that clip with its boxes and its graphics searched for again,
- and reframes it. Text the crop still cuts is said in a last line; the parts it
- is in that last 2 s or more are cut in two for the eraser again, and sending
- them is a second spend, with a price and an `--approve` of its own. A shorter
- part is left as it is, and the line says so.
- ```sh
- npx @veedstudio/openedit-cli reframe video.mp4 --aspect 9:16 --out tall.mp4 [--faces <faces.json>] [--size WxH|native] [--erase [--approve <usd:quote>]]
- npx @veedstudio/openedit-cli reframe video.mp4 --out runs/<key>/tall.mp4 # the shape of the platform in the piece's brief
- ```
- ### zoom
- Find the clicks in a screen recording and write `zoom.js`, a camera that holds
- each click zoomed until the text there reaches the minimum text size of the
- stage it is shown on. One decode compares small grey frames a tenth of a second
- apart, with no model: the drawn cursor is followed where it leaves a patch of its
- own outline and shows the same outline elsewhere, and a click is a rest of the
- cursor that the screen answers near it, or a page changing wholesale soon after
- it arrives; with no cursor drawn, the first change after half a second of none.
- The text nearest each click is measured on its frame, from the line's top to its
- baseline. `--clicks` names points of your own instead. The page loads `zoom.js`
- and calls `openeditZoom.apply(el, t)` each frame on the element showing the clip,
- whose parent the camera fills; `zoom.json` beside it also lists the stretches
- in which nothing changes.
- ```sh
- npx @veedstudio/openedit-cli zoom recording.mp4 [--clicks <clicks.json>] [--aspect 16:9,9:16] [--out <dir>] [--every 0.1] [--json]
- ```
- ### stills
- `stills` fetches licensed pictures from Wikimedia Commons, recording each
- file's terms beside it (`search` / `show` / `save`):
- ```sh
- npx @veedstudio/openedit-cli stills search "berlin skyline" --limit 10
- ```
- ### sfx
- `sfx` takes recorded sound effects from a stock library, where the environment
- serves one at `OPEN_EDIT_LIBRARY_URL`. A search takes a plain description and
- lists each sound's id, length and title. With `--run`, it leaves out the sounds
- that run already saved, so the next search finds a different one. `save`
- downloads a sound into the run's `assets/` and records it in the asset manifest:
- ```sh
- npx @veedstudio/openedit-cli sfx search "a door slamming in an empty hallway" --run runs/<key> --max-seconds 3
- npx @veedstudio/openedit-cli sfx save <id> --run runs/<key> --as door-slam
- ```
- ### init
- `init` is the workspace setup: it checks the machine dependencies (Node,
- ffmpeg) and npm-ifies the workspace (a minimal private `package.json` when none
- exists, this CLI exact-pinned as a devDependency and installed, `git init` when
- git is available, `runs/` gitignored, the skill refreshed from packaged content
- into `.claude/skills/` for Claude Code and `.agents/skills/` for Codex and Gemini
- CLI). In a clone whose `node_modules` lacks the pinned CLI, init asks for
- approval to run the project's install (with lifecycle scripts off), since until
- then `npx` would run the registry's latest rather than the pinned version.
- It adds nothing to agent settings, and removes the SessionStart hooks earlier
- versions added. Bare `init` applies only safe,
- workspace-local setup; `--dry` reports without writing; `--auto-approve` also
- applies the machine-global installs init can run on the system (Node and FFmpeg
- only through Homebrew on macOS; on Windows bare init already fetches FFmpeg into
- the app-data dir, no admin rights needed; the rest it prints for the user to
- run), and is only for after a person has approved every reported
- action. Exit 10 means something is awaiting
- that approval; on success the workspace root is printed on stdout.
- The CLI never updates itself. About once a day per machine a command asks the
- registry whether a newer release is out; from the next command on, until the
- update, each prints `update available` with both versions and the exact
- `init --update <version>` that installs that version and refreshes the skill.
- `NO_UPDATE_NOTIFIER=1` turns the lookup off.
- ```sh
- npx @veedstudio/openedit-cli init --dry --workspace <dir>
- npx @veedstudio/openedit-cli init --workspace <dir>
- npx @veedstudio/openedit-cli init --update <version> --workspace <dir>
- ```
- ## Configuration
- | Environment variable | Effect |
- | --- | --- |
- | `VEED_ORIGIN` | Overrides the default `https://www.veed.io` origin. |
- | `OPENEDIT_STATE_DIR` | Overrides where login state, the update-check cache and init's lease are stored. |
- | `OPEN_EDIT_ROOT` | Where `runs/<key>/` outputs and `.open-edit-prefs.json` are written (default: the nearest project above the working directory, else the app-data directory below). |
- | `OPENEDIT_PACKAGE_SOURCE` | Overrides what init pins into a scaffolded workspace (a packed tarball path in tests and CI). |
- | `OPENEDIT_REGISTRY` | Overrides the registry the update notice reads the latest version from (default: `https://registry.npmjs.org`); installs use npm's own registry config. |
- | `NO_UPDATE_NOTIFIER` | Any non-empty value stops the once-a-day lookup and the `update available` notice. CI runs skip both already. |
- | `OPENEDIT_FFMPEG` / `OPENEDIT_FFPROBE` | ffmpeg/ffprobe binaries (default: the copy `install-ffmpeg` put in the app-data directory, else `PATH`; ffprobe defaults beside a configured ffmpeg; an empty value counts as unset). |
- | `OPENEDIT_CHROME` | The Chrome or Chromium `render`, `behind` and `veed-project` drive when `render --chrome` is not given (default: the pinned Chrome Headless Shell; an empty value counts as unset). |
- | `WHISPERX_BIN` / `WHISPERX_MODEL` | WhisperX binary and fallback model tier (defaults: `whisperx` on `PATH`, `small.en`). |
- | `OPEN_EDIT_WHISPERX_DEVICE` / `OPEN_EDIT_WHISPERX_COMPUTE` | WhisperX device/compute (defaults: `cpu`/`int8`). |
- | `OPEN_EDIT_LIBRARY_URL` | The stock sound library `sfx` searches and saves from (unset: `sfx` says there is none, and effects come from `fal`). |
- | `OPEN_EDIT_MEDIAPIPE_PYTHON` | The Python version `install-mediapipe` asks uv for (default: `3.12`; the pinned packages need 3.12 or newer). |
- Login state lives in the platform's per-user app-data directory:
- `~/Library/Application Support/veed-openedit` on macOS, `%APPDATA%\veed-openedit`
- on Windows, and `$XDG_CONFIG_HOME/veed-openedit` (default `~/.config/veed-openedit`)
- on Linux.
- ## License
- Apache-2.0. See the bundled `LICENSE` and `NOTICE` files.
Ratings and comments
Sign in to rate this skill.
Sign inFree to use. If it’s helped, pass it on.