Skip to content
Back to search

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.

Checked today

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
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/veedstudio--open-edit/badge.svg)](/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

i

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.

  1. # @veedstudio/openedit-cli
  2. The Open Edit command-line tool: agent-driven video creation and editing,
  3. powered by VEED.
  4. The package carries the agent skill that `init` installs into a workspace;
  5. everything else is a command below. The source is public at
  6. [veedstudio/open-edit](https://github.com/veedstudio/open-edit), whose README
  7. covers what Open Edit is and what it makes; this page is the command surface.
  8. ## Usage
  9. ```sh
  10. npx @veedstudio/openedit-cli --help
  11. ```
  12. ## Commands
  13. ### login
  14. Log in with VEED (OAuth 2.1 + PKCE via the browser; the token is stored locally
  15. and refreshed automatically):
  16. ```sh
  17. npx @veedstudio/openedit-cli login
  18. ```
  19. Pass `--manual` (or set `VEED_LOGIN_MANUAL=1`) when no reachable browser exists:
  20. the URL is printed, and the redirect is pasted back instead of caught on a
  21. localhost loopback.
  22. ### token
  23. Print a valid VEED access token for other tools to consume, refreshing it
  24. first when stale (`VEED_ACCESS_TOKEN`, when set, is passed through as-is). The
  25. value is printed only when the output is captured; run it straight in a terminal
  26. and it reports that a token exists without putting one in your scrollback:
  27. ```sh
  28. npx @veedstudio/openedit-cli token
  29. ```
  30. Exits non-zero when no login is stored. `--path` prints the token store
  31. location instead of a token.
  32. ### transcribe
  33. Transcribe videos, writing `runs/<key>/transcript.json`. The provider is the
  34. user's choice, recorded once with `--record`: a bare `transcribe video.mp4` runs
  35. the recorded one (and refuses, saying why, when nothing usable is recorded), and
  36. `--provider` names another for one run. Locally with WhisperX (free, offline,
  37. nothing billed anywhere):
  38. ```sh
  39. npx @veedstudio/openedit-cli transcribe --provider whisperx video.mp4 [...] [--model medium] [--language de] [--force]
  40. ```
  41. A transcript already on disk is left alone (it may have been retimed onto an
  42. edit); `--force` transcribes it again.
  43. Or hosted by VEED (premium quality; requires the one-time `login`, and spends
  44. the workspace's VEED transcription credits — `--workspace <id>` names which,
  45. required only when the account has several):
  46. ```sh
  47. npx @veedstudio/openedit-cli transcribe --provider veed video.mp4 [...]
  48. ```
  49. `--record <veed|whisperx|custom> [--model <id>]` records the transcription
  50. provider choice in `.open-edit-prefs.json` instead of running anything.
  51. ### whisper
  52. Map a speech-to-text JSON produced by your own service or a fal model into the
  53. same `runs/<key>/transcript.json`: Whisper's segments with word times
  54. (WhisperX, openai-whisper, whisper-timestamped, mlx-whisper), the OpenAI API's
  55. `verbose_json` with word granularity, whisper.cpp `-oj -ml 1`, a timed word
  56. list, fal's whisper and wizper chunks, a voice model's character timestamps, or
  57. the `fal-result.json` that `fal run` keeps a model's answer in:
  58. ```sh
  59. npx @veedstudio/openedit-cli whisper transcription.json media.mp4 [...] [--force]
  60. ```
  61. Word timestamps are required; the media argument may be a video or an audio
  62. file. Every command that reads a transcript (`review`, `retime-transcript`,
  63. `shots`, `veed-project`, `words`) takes the same formats, mapped in memory, and
  64. prints one line naming the format it read.
  65. ### words
  66. Print a transcript as timed lines, one per word with its start and end in
  67. seconds, or one per cue with `--cues`; `--from`/`--to` keep the lines that
  68. overlap that stretch. It reads a `transcript.json` or any format `whisper` maps,
  69. and writes nothing:
  70. ```sh
  71. npx @veedstudio/openedit-cli words runs/<key>/transcript.json [--from <sec>] [--to <sec>] [--cues]
  72. ```
  73. ### generate / generate-set / sample-presenter
  74. Fabric generation — source footage from a script, when there is no video to
  75. caption. Generating draws the named workspace's AI Playground credits twice —
  76. the speech is synthesized, then lip-synced — so it is two commands: the first
  77. quotes the sum and records the approval, the second
  78. spends exactly what was approved (no `--script` on the spend pass — the
  79. recorded, hashed script is what bills):
  80. ```sh
  81. npx @veedstudio/openedit-cli generate --script "spoken words" --key my-run --workspace <id>
  82. npx @veedstudio/openedit-cli generate --key my-run --yes
  83. ```
  84. `--resume` collects a job already created and paid for; `--abandon <sessionId>`
  85. clears one abandoned charge record. `generate-set --shots shots.json` covers
  86. several shots under one approval, and `sample-presenter` proposes a
  87. deterministic character/voice pair for a run key (listing costs nothing).
  88. ### background-removal / lipsync
  89. Remove a video's background, or re-lipsync a video to a new audio track.
  90. Background removal tries VEED's free route first; when that route cannot run,
  91. it stops having spent nothing and prints what fal's model would cost and the
  92. command to run with `--fal`. Only `--fal` (the full model, uploaded to fal's own
  93. storage) or `--fast` (fal's fast model) buys anything, and lipsync always goes
  94. through fal. Every fal call bills your own fal key, never a VEED workspace; a
  95. re-run of the same inputs resumes the paid job instead of buying it again:
  96. ```sh
  97. npx @veedstudio/openedit-cli background-removal video.mp4 [--fal|--fast] [--mask-only] [--no-refine] [--out <path>]
  98. npx @veedstudio/openedit-cli lipsync video.mp4 narration.mp3 [--out <path>]
  99. ```
  100. The fal key comes from `FAL_KEY`, or `OPEN_EDIT_FAL_KEY_FILE` pointing at a
  101. file that holds it.
  102. ### veed-project / veed-pull
  103. Hand a finished edit to VEED's editor as a project a person can take apart:
  104. footage cuts, text, captions, images and each audio track become the editor's
  105. own items, and each page element the plan names becomes a transparent clip cut
  106. to its box. It uses your VEED login and spends no VEED credits and nothing on your
  107. fal key. The last step runs in
  108. your browser: click the "OpenEdit to VEED" bookmark on VEED. The way back is the
  109. "Send to Claude" bookmark on a project open in the editor, and `veed-pull`:
  110. ```sh
  111. npx @veedstudio/openedit-cli veed-project --install-bookmark
  112. npx @veedstudio/openedit-cli veed-project plan.json [--workspace <id>] [--local]
  113. npx @veedstudio/openedit-cli veed-pull ~/Downloads/openedit-<project id>.json --out <dir>
  114. ```
  115. `veed-project --help` lists the plan's fields; `veed-pull` writes the project
  116. back as such a plan.
  117. ### fal
  118. Run any fal model on your own key. Local file paths inside the input are
  119. uploaded for you (multipart above 90 MB), outputs are downloaded, and each job
  120. ends with a cost line: the billed figure when your key can read fal's billing,
  121. otherwise `cost: unknown` beside fal's listed price. An identical request is
  122. bought once, even across processes and crashes:
  123. ```sh
  124. npx @veedstudio/openedit-cli fal schema <model>
  125. npx @veedstudio/openedit-cli fal run <model> --input '{"prompt":"…"}' [--out <dir>]
  126. npx @veedstudio/openedit-cli fal run --batch jobs.json [--concurrency N] # [{model, input, name?}]
  127. ```
  128. ### install-ffmpeg / install-whisperx
  129. `install-ffmpeg` looks for an existing FFmpeg first (`OPENEDIT_FFMPEG` and
  130. `OPENEDIT_FFPROBE`, then a previous install, then PATH) and only downloads when
  131. there is none — a checksum-verified static build into the app-data dir (the
  132. download route is Windows-only; macOS points at `brew install ffmpeg`, Linux at
  133. `apt`). A set `OPENEDIT_FFMPEG` or `OPENEDIT_FFPROBE` is run first, and fails
  134. the command, naming the variable, when its binary does not start, since nothing
  135. else is used while it is set; `--check` runs whichever pair every command would.
  136. `--force` reinstalls the app-data copy, and is refused while either override is
  137. set, since no command would run the copy it installs.
  138. `install-whisperx` installs the local transcription provider into an isolated
  139. uv/pipx tool environment; it never touches the system Python.
  140. ```sh
  141. npx @veedstudio/openedit-cli install-ffmpeg [--check|--force]
  142. npx @veedstudio/openedit-cli install-whisperx [<version>]
  143. ```
  144. ### brief
  145. Record what the user asked of a piece once, in its folder: how long it runs,
  146. where it is posted and their own words. `review` compares the video's length
  147. with it and the numbers on screen with the words, `render` and `apply-edl` print
  148. a line when what they made misses that length, `safe-zone` takes its zone from
  149. the platform, `render` gives that zone to a page that links none, and `reframe`
  150. takes its shape; a value given to the tool itself wins, and the tool says which
  151. it used. A tool finds
  152. `brief.json` from the file it works on, in that file's folder or the nearest
  153. one above it inside the workspace. Each call sets the fields it is given and
  154. keeps the others:
  155. ```sh
  156. npx @veedstudio/openedit-cli brief runs/<key> --length 60 --platform tiktok --words "Doors open at 7"
  157. npx @veedstudio/openedit-cli brief runs/<key> --platform "linkedin 1:1"
  158. npx @veedstudio/openedit-cli brief runs/<key> # prints the brief that applies there
  159. ```
  160. ### render / fonts / safe-zone / install-browser
  161. Render an HTML page to video in headless Chrome, frame-exact. The page runs on a
  162. virtual clock (timers, `requestAnimationFrame`, `Date.now` and a seeded
  163. `Math.random` advance one frame per frame); CSS and Web Animations, GSAP's
  164. global timeline and an optional `window.__seek(t)` are set to each frame's time,
  165. and `<video>` elements show the picture at that time. The output is silent H.264
  166. (or ProRes 4444 with `--transparent`), identical whatever the worker count:
  167. ```sh
  168. npx @veedstudio/openedit-cli render page.html --out out.mp4 --fps 30000/1001 --duration 12 [--workers N]
  169. npx @veedstudio/openedit-cli render page.html --out out.mp4 --footage clip.mp4 # the clip's rate and length
  170. npx @veedstudio/openedit-cli render page.html --out out.mp4 --from 4 --to 6 # re-render only that stretch
  171. npx @veedstudio/openedit-cli render page.html --out stills --stills 0.5,2,4 --sheet sheet.jpg
  172. ```
  173. Segments and a manifest are cached in `<out>.render/`, so `--from`/`--to`
  174. re-renders the segments it overlaps, and any other whose page or files changed
  175. since it was drawn (a cue that moved, a clip replaced at its path), and rejoins
  176. the rest by stream copy; every frame of the joined file is checked against its
  177. time. A page marked
  178. `data-stateless` is checked on one frame before the workers start, and rendered
  179. as an unmarked page, with a line saying why, when the mark does not hold.
  180. A page's long-GOP videos, and any in a codec Chrome has no decoder for (HEVC
  181. or ProRes, say), are served from all-intra copies, made once per source, keyed
  182. by its content, in the workspace's `runs/.media`, which stills into any
  183. directory, renders and patches share (`render --help` says how much it keeps).
  184. It fails naming the cause when Chrome does not start or stops answering, the
  185. page throws, or every frame is one flat colour, and a signal stops it with the
  186. Chromes and ffmpegs it started. A video render then looks at what it made, as the
  187. review's blank-frames and dead-air checks do, and prints a line, failing
  188. nothing, for a first frame that is blank, near-black or partway into a fade-in,
  189. and for each still held longer than its words allow; a patch looks only near
  190. the range it re-rendered. `fonts` downloads Google Fonts as local woff2 files
  191. with a `fonts.css`; `install-browser` fetches the pinned Chrome Headless Shell,
  192. which `render` also does on first use. `safe-zone` writes the stylesheet for where
  193. a video will be posted: the stage at its shape's size, and a `[data-safe]`
  194. container on that platform's safe zone as the page's text layer. With no zone
  195. named, it takes the platform in the piece's brief. A zone is the app the user
  196. names (`tiktok`, `reels`, `shorts`, `youtube`, `x`, `linkedin`, `facebook`).
  197. With none named, or several, it is the shape: `9:16`, `1:1` and `4:5` are each clear
  198. of every app's UI listed for them, while `16:9` is YouTube's player, so a 16:9 piece
  199. for a feed names that feed's app (`4:3` has one zone). For Instagram, name where it
  200. goes: `reels` for a 9:16 Reel, the feed shape (`1:1` or `4:5`) or the app with its
  201. shape (`instagram 4:5`), or pass the canvas with `--canvas`; LinkedIn and Facebook
  202. are named or take `--canvas` the same way. Add
  203. `--ad` when a 9:16 video is an ad: ads reserve more of the frame than an ordinary
  204. post's UI takes. Ordinary posts and feeds are kept clear of the UI each app draws
  205. over them, ads of the platforms' published ad safe zones, and 4:3 has television
  206. title-safe sides (`safe-zone --help` says exactly what each zone keeps clear). The
  207. container is a size container, so `cqw` and `cqh` measure the zone for what is
  208. inside it. Its other defaults lose to any rule the page writes: text inside starts
  209. at the shape's minimum (and so do `small`, `sub`, `sup`, `h5`, `h6` and form
  210. controls), a word too long for its line breaks, boxes inside keep within its width
  211. unless they set `max-width: none` (a ticker's track also sets `width:
  212. max-content`), and nothing is clipped:
  213. ```sh
  214. npx @veedstudio/openedit-cli fonts "Inter:wght@400;700" Anton --out fonts
  215. npx @veedstudio/openedit-cli safe-zone --out runs/<key> # the platform in the piece's brief
  216. npx @veedstudio/openedit-cli safe-zone tiktok --out runs/<key>
  217. npx @veedstudio/openedit-cli safe-zone 9:16 --ad --out runs/<key>
  218. npx @veedstudio/openedit-cli safe-zone instagram --canvas 1080x1350 --out runs/<key>
  219. npx @veedstudio/openedit-cli install-browser [--check|--force]
  220. ```
  221. ### captions
  222. Caption every spoken word of a transcript on the page. `captions` writes
  223. `captions.js` beside the transcript (`--out` names another file): its words and
  224. the code that shows them as cues on the page's clock. The page loads it with a
  225. `<script>` tag and gives it an empty element marked `data-captions` where the
  226. captions go, inside `[data-safe]` when the page has a safe zone. Each cue comes
  227. up with its first word and stays half a second past its last, held until the
  228. next when the gap is under half a second, so the screen clears only in a silence
  229. of a second or more. Cues break where the speech does (a sentence end, a pause,
  230. a clause), speak for at most 7 seconds, and take at most two lines of 42
  231. characters, fitted to the element's width in the page's own font. With
  232. `faces.js` loaded the cues are placed off the faces and the graphics burned into
  233. the footage, inside the safe zone, at one place through each shot: they can move
  234. only at a cut, and inside a shot only where no single place stays clear for every
  235. cue up in it, however briefly, as few times as that takes, which the console
  236. says. The script sets
  237. structure and state only, never a look: the cue
  238. on screen is a `[data-cue]` of `[data-line]`s of `[data-word]` spans
  239. (punctuation in a `[data-punct]` of its own), each word's `data-state` is
  240. `next`, `now` or `said`, and `--since`, `--progress`, `--cue-since`,
  241. `--cue-until` and `--cue-progress` give the page's CSS each frame's timing to
  242. animate from. `data-lines`,
  243. `data-words` (1 for one word at a time), `data-chars`, `data-at` (where the
  244. transcript's clip starts on the page), `data-from` and `data-to` on the element
  245. change the cues; `captions --help` lists them all. A speech-to-text JSON is read
  246. as `whisper` reads it:
  247. ```sh
  248. npx @veedstudio/openedit-cli captions runs/<key>/transcript.json [--out <file>]
  249. ```
  250. ### mux-audio / mix-audio
  251. Put sound on a render. `mux-audio` lays a track (the source clip, or a built
  252. soundtrack) onto a silent render, levelled to -14 LUFS / -1 dBTP
  253. (`--no-loudnorm` keeps the source level; the line it prints says which
  254. correction ran), starts a clip that `render --footage-at` placed later in the
  255. piece at that same moment, and prints a silent opening or ending longer than a
  256. second in what it wrote. `--music <file>` in place of `--audio` lays a music
  257. file alone, run to the picture's last frame;
  258. `mix-audio` first builds one track from many pieces — narration, music,
  259. effects — per the run's mix spec, with music and effects ducked under the voice,
  260. effects given no gain set under it by measured loudness (give an effect a
  261. gain for a deliberate loud hit), and the music bed run to the end of the film:
  262. looped with a crossfade when its sound ends sooner, faded out at the end.
  263. `--video` takes the mix's length from the render, and the sound of each
  264. `<video>` its page plays is laid in where the render played it, trims, loops
  265. and speed included, under the voice; the spec's `pageVideos` leaves one out or
  266. lays it otherwise:
  267. ```sh
  268. npx @veedstudio/openedit-cli mix-audio runs/<key> --video runs/<key>/out.mp4 # → runs/<key>/audio/mix.m4a
  269. npx @veedstudio/openedit-cli mux-audio --video runs/<key>/out.mp4 --audio runs/<key>/audio/mix.m4a --out runs/<key>/final.mp4
  270. npx @veedstudio/openedit-cli mux-audio --video runs/<key>/out.mp4 --music runs/<key>/assets/music.mp3 --out runs/<key>/final.mp4
  271. ```
  272. ### review
  273. Run every delivery check on the video about to be delivered and print one
  274. report. It changes nothing, and exits 0 whatever it finds. The blank-frames
  275. check reports a flash, a frame or two of one flat colour (a blank white page
  276. with only a caption on it, say) between other pictures; any flat colour held
  277. with nothing on it for more than a second; and a first frame that is blank,
  278. near-black or partway into a fade-in, since platforms show it as the cover.
  279. The dead-tail check reports a picture that runs on more than a second past its
  280. last sound or its last spoken word. The words come from the `transcript.json`
  281. in the video's folder, or the one `--transcript` names, in any format `whisper`
  282. maps; the review never transcribes, and without a transcript it says what it
  283. skipped. A picture that runs on past the last word with sound under it to the
  284. end is an end card when
  285. new text is on screen through it: text that came up from the pause before the
  286. last spoken phrase on, in an element that showed no other words before then.
  287. It passes unless it is held longer than its words take to read: 0.2 seconds a
  288. word, plus 2 seconds to find the text (3 from ten words) and a one-second beat,
  289. never less than 4 seconds and never more than 4.5. So a card brought up with
  290. the spoken call to action counts, while a caption left on into the music, a
  291. title up since earlier or a watermark does not. A run-on with more than a
  292. second of no end card is reported as background left running; without the
  293. record of on-screen text (below) it is reported, and the report says the end
  294. card could not be judged. The dead-air check reports a stretch with nothing
  295. happening anywhere in the video. In the picture, that is a still, frozen or
  296. nearly so (a slow zoom or a drift over a held card), held longer than a still
  297. may hold, end cards included: as long as an end card of as many words when it
  298. has words on screen, 3 seconds when it has none. Footage that moves almost
  299. everywhere, such as a slow pan, is not still. A talking head can measure as
  300. still as a held card, so a nearly still picture passes while a voice talks over
  301. it without pausing more than 2 seconds; without a transcript it is reported,
  302. and the report says the voice could not be checked. A frozen picture is
  303. reported whoever speaks over it. In the sound, it is a first sound more than a
  304. second after the first frame, and more than 2 seconds of silence between two
  305. sounds; a silence after the last sound is the dead-tail check's to report, so
  306. no silence is reported twice. The length check reports a picture that runs longer
  307. or shorter than the length asked for, in seconds (`--length`, else the length in
  308. the piece's brief), by more than a second or 5% of that length, whichever is
  309. more; without either it is skipped. The
  310. canvas check reports a picture nearly one of the platform shapes (9:16, 1:1, 4:5,
  311. 16:9) but not exactly it, such as a 606x1080 crop of 1080p footage, and one under
  312. 1080 px on its short side; a picture of another shape is judged on its short
  313. side alone.
  314. The text, captions, numbers and graphics checks read the record of on-screen text that `render`
  315. writes beside each video, `<video>.text.json`: the text the page draws in its
  316. HTML and SVG (not text inside an image, a canvas or the footage), read about
  317. every 100 ms of the page's time, with its words, its box and font size in the
  318. video's pixels, its colour, its opacity and how opaque the backgrounds painted
  319. under it are, and each `<video>` the page shows, with its clip, the second of
  320. it on screen and where its picture lies. `mux-audio` carries the record to
  321. the file it writes, and a patch with `--from/--to` keeps it whole. The text
  322. check reports text smaller than a phone's body text, measured against the
  323. frame's shorter side, and text under WCAG's 3:1 contrast for large text against
  324. what is really behind it, measured on the video's pixels around the glyphs, so a
  325. backing, a stroke or a shadow counts; it skips the contrast of a transparent
  326. render, and of text that is translucent or has no solid fill of its own. The
  327. captions check reports a second or more of speech with no caption on screen. A
  328. caption is a text in the page's caption track (an element marked
  329. `data-captions`, which `captions.js` fills), a text that shows the words being
  330. spoken, or, in another language than the voice, one of a run of texts in one
  331. place that change with the spoken phrases; a title is not one. It is skipped when the page captions too little of
  332. the speech to be captioning it, or there is no transcript. The numbers check
  333. reports a number on screen that neither the transcript nor the user's own words
  334. say, with where and when it shows: a time, a price, a percentage or an amount
  335. worked out or guessed while the video was made, such as "Ready in 15 min" over
  336. narration of "about 10 minutes". Numbers are compared by value, in digits or in
  337. English words, so "15 min", "fifteen minutes" and "0:15" agree, as do "$5" and
  338. "five dollars", "50%" and "half", "2018" and "twenty eighteen", and a rounding
  339. such as "1.4M" for 1,423,000; a range or a score is two numbers. A list's own
  340. numbering ("01", "Tip 2") and the count of its items, a clock or a count running
  341. in one place, a number up for under a quarter of a second, and digits in a name
  342. ("MP4"), an address or a handle are set aside. The user's words come from
  343. `--brief`, their message itself or a file holding it, repeatable, else from the
  344. words in the piece's brief (`brief --words`); without either the numbers are
  345. compared with the transcript only, without a transcript with the user's words
  346. only, and with neither the check is skipped. It cannot see the
  347. footage, so a number read off the picture (a scoreboard, a page in shot) is
  348. reported too. The graphics check reports text drawn over a graphic burned into
  349. the footage while it is up: the record names the clip `--footage` laid under the
  350. page, and each `<video>` the page plays with the second of its clip on screen
  351. and where its picture lies. It reads the graphics `faces` found on a clip, or
  352. looks for them itself when `faces` has not run on it, and counts a text only
  353. where the video still shows the clip's picture around it, so text on a card or
  354. band that covers the graphic passes. A video without a record, or with one for a
  355. picture of another size or length or older than the video, skips all four:
  356. ```sh
  357. npx @veedstudio/openedit-cli review runs/<key>/final.mp4 [--transcript <transcript.json>] [--length <sec>] [--brief <text|file>]
  358. ```
  359. ### Frames and joins
  360. Tools for looking at and joining footage:
  361. ```sh
  362. npx @veedstudio/openedit-cli concat-videos [--canvas WxH] [--fit crop|letterbox] <out> <in1> <in2> [...]
  363. 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
  364. npx @veedstudio/openedit-cli frames --images <image|dir> [...] [--width N] [--cols N] # pictures that already exist, on one sheet
  365. 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
  366. ```
  367. The cut tools, for an edit made before captioning: measure where speech starts,
  368. stops and pauses; assemble the kept ranges of an EDL (edit decision list) with
  369. crossfaded joins, each range snapped to the frame grid and optionally at its own
  370. speed (slow motion by repeated or interpolated frames, sound time-stretched or
  371. silenced) and grade (exposure, contrast, saturation, temperature, a LUT, grain),
  372. a source at another frame rate converted to the first's and each source's speech
  373. levelled to the quietest's, moving the per-word timings, the face boxes and the burned-in graphics the
  374. sources already have onto the cut instead of finding them again. Each range's picture is kept in `<cut>.ranges/` under
  375. a name made of its source's content and everything applied to it, so a second run
  376. that changes one range encodes only that range. A path in the EDL is read beside
  377. it, else from the working directory or the workspace when the file is there.
  378. After the cut, `apply-edl` prints what it removed from each source, with times,
  379. each range whose picture runs on past its last sound, and each stretch held
  380. still with nothing heard, measured on the cut, and a line when the cut misses
  381. the length in the piece's brief.
  382. `--gap` and `--crossfade` are milliseconds; the EDL is seconds.
  383. ```sh
  384. npx @veedstudio/openedit-cli speech-probe <video> [--range a:b] [--gap 250] [--window 10] [--json]
  385. npx @veedstudio/openedit-cli apply-edl --edl edl.json --out cut.mp4 [--crossfade 40] [--crf 20] [--fit crop|letterbox] [--keep-levels]
  386. npx @veedstudio/openedit-cli retime-transcript --edl edl.json --out <transcript.json>
  387. ```
  388. Both joins put every clip on one canvas, sized as the clips are shown (a phone
  389. clip stored sideways counts as upright). A clip of another shape is cut to the
  390. canvas's shape with `reframe`'s own code, around its faces when `faces` has run
  391. on it and from the middle otherwise, and a line says which; `--fit letterbox`
  392. keeps it whole and pads it instead. `render --footage` refuses footage of
  393. another shape than the stage and names the `reframe` command that cuts it.
  394. The retimed transcript goes where a transcription of the cut would land,
  395. `runs/<key>/transcript.json` under the workspace, so the transcription routes
  396. refuse to overwrite it and the cut is never transcribed. `retime-transcript`
  397. writes the same transcript from an EDL alone, to any path.
  398. ### faces / reframe / install-mediapipe
  399. Find the faces in each shot of a clip and write their boxes, for laying text
  400. out around them and for `reframe` (and the joins, which cut a clip of another
  401. shape as it does). They go to `runs/<key>/faces-<hash>/`, a folder of the clip's
  402. own named by its real path, so two clips of one name never share one; `faces`
  403. prints the path, and every reader looks there (and in a `runs/<key>/faces.json`
  404. an older `faces` wrote, when it names that same clip). One decode finds the cuts, those between two
  405. shots of one set that change the picture little included, and samples four
  406. frames a second (`--every 0.25`), each labelled by its presentation time, so
  407. variable-frame-rate footage is sampled in time; a shot sampled fewer than four
  408. times also gets its first frame and the first at or past the middle of each
  409. quarter of it;
  410. MediaPipe's full-range BlazeFace model finds the faces on CPU. The same
  411. sampled frames, small and grey, show the graphics burned into the footage (a
  412. lower third, a score bar, old subtitles, a logo), without OCR or a model: sharp
  413. edges, mostly square to the frame, that hold their value while most of the frame
  414. changes around them, at a cut or as the camera moves (a step in the camera's
  415. exposure is no change), or that come up over, or give way to, other steady
  416. content in a still shot, each with the seconds it is up. `faces.json`
  417. holds the boxes per sampled frame of each shot and the graphics; `faces.js` holds them too, with
  418. `openeditFaces.place(el, from, to)`, which moves a laid-out element the least
  419. distance that clears every face on screen, and every graphic up, between those seconds of the clip.
  420. For elements shown one after another in one spot, such as caption cues,
  421. `openeditFaces.placer(spans, measure)` gives them one place through each shot,
  422. moving them only at a cut, or where no single place stays clear for every element
  423. up in a shot, however briefly. `measure(i)` gives the box `{x, y, w, h}` element
  424. i is laid out in, in viewport pixels, and is called by `prepare(i)`, which the
  425. page runs while none of the elements is on screen, before showing one; a page
  426. that never calls `prepare` still works, with `place()` measuring each time.
  427. `place(el, i, sec)` takes an element's index and one second of the clip rather
  428. than a span. `part(i, sec)` changes at each cut, and the page places an element
  429. up across it again there. `captions.js` places its cues with it.
  430. `install-mediapipe` puts MediaPipe, every package it runs on at the versions
  431. verified together (OpenCV's headless build) and the model into an environment
  432. of their own under the app-data directory, never the system Python: with uv
  433. when present, which fetches a Python it can use, else with `python3 -m venv`
  434. when that python3 is 3.12 or newer. MediaPipe 1.1.1 has no Intel Mac build; on
  435. an Apple Silicon Mac run an arm64 Node, and on Windows on ARM install uv and set
  436. `OPEN_EDIT_MEDIAPIPE_PYTHON=cpython-3.12-windows-x86_64-none`:
  437. ```sh
  438. npx @veedstudio/openedit-cli install-mediapipe [<version>]
  439. npx @veedstudio/openedit-cli faces video.mp4 [--out <dir>] [--every 0.25] [--threshold 10] [--confidence 0.5] [--margin 0.25]
  440. ```
  441. `reframe` cuts a clip to another shape (16:9 to 9:16, say). With those boxes,
  442. and without guessing who is who, each shot, which can be split again where a
  443. face seen alone for four samples jumps further than its own width and is seen
  444. alone there for four more (a dissolve or a cut the cut detection missed), is
  445. followed when it shows one face only (never two at once, each found
  446. overlapping the one before), the crop holding still while the face stays inside
  447. it and easing to a new place only when it must, and held at one place when it
  448. shows more, where the faces wholly inside add up to the most height; at a cut
  449. or a split it jumps. A face less than half the height of the tallest found with
  450. it is someone in the background and does not count. Without them it cuts the
  451. clip from the middle. Where a face does not lie wholly inside the crop, larger
  452. than it or beside another face a held shot keeps, it prints those seconds. The
  453. crop is
  454. scaled (lanczos) to 1080 px on its short side, the platforms' canvas for their
  455. shapes: 1080x1920 for 9:16, 1080x1080 for 1:1, 1080x1350 for 4:5, 1920x1080 for
  456. 16:9. `--size` names another size of the shape, such as 2160x3840 for 4K, and
  457. `--size native` keeps the crop in the source's own pixels. It always re-encodes:
  458. upright, in square pixels, H.264, a clip already in that shape included and
  459. scaled the same way. With the clip's boxes it also writes the output's own, in
  460. the output's folder where `faces` would write them, each box and burned-in
  461. graphic moved and scaled with the crop and cut where the crop cuts it, so
  462. `faces` need not run on the clip it made.
  463. When the crop cuts in part a graphic `faces` found (old subtitles, a lower
  464. third), a last line says so, with the rows it is in and what erasing them
  465. costs. `--erase` erases those rows, across the whole width and for the whole
  466. clip, since the search misses a line of text that is up for under a second and
  467. a half. The first run cuts the clip into parts of at most 6 s for the eraser,
  468. a video editor on fal told to remove the subtitles and keep the rest, beside
  469. `--out`, and prints the price of every part as one total: an estimate, each
  470. run's seconds, in whole seconds as fal bills them, at fal's price per second,
  471. with a quote id. Nothing is spent, and no run exists, until `--approve` passes
  472. that price and quote back once the user has said yes to it. That run writes
  473. each part's input and prints the fal runs to make: one batch for `openedit
  474. fal` on a fal key, or, with no key set, one run a part for the environment's
  475. own `fal` command, one whose help says it runs a model with its input. A quote
  476. approves once, so one yes prints each run once: running a part again may buy
  477. it twice, so a part that is not back is priced again, under a quote of its
  478. own, and its run printed only for an `--approve` of that. `reframe` never runs
  479. the eraser itself. Once the parts are back, the same command lays only the
  480. erased rows over the clip, keeping every other pixel, every frame and the
  481. sound, writes that clip with its boxes and its graphics searched for again,
  482. and reframes it. Text the crop still cuts is said in a last line; the parts it
  483. is in that last 2 s or more are cut in two for the eraser again, and sending
  484. them is a second spend, with a price and an `--approve` of its own. A shorter
  485. part is left as it is, and the line says so.
  486. ```sh
  487. npx @veedstudio/openedit-cli reframe video.mp4 --aspect 9:16 --out tall.mp4 [--faces <faces.json>] [--size WxH|native] [--erase [--approve <usd:quote>]]
  488. npx @veedstudio/openedit-cli reframe video.mp4 --out runs/<key>/tall.mp4 # the shape of the platform in the piece's brief
  489. ```
  490. ### zoom
  491. Find the clicks in a screen recording and write `zoom.js`, a camera that holds
  492. each click zoomed until the text there reaches the minimum text size of the
  493. stage it is shown on. One decode compares small grey frames a tenth of a second
  494. apart, with no model: the drawn cursor is followed where it leaves a patch of its
  495. own outline and shows the same outline elsewhere, and a click is a rest of the
  496. cursor that the screen answers near it, or a page changing wholesale soon after
  497. it arrives; with no cursor drawn, the first change after half a second of none.
  498. The text nearest each click is measured on its frame, from the line's top to its
  499. baseline. `--clicks` names points of your own instead. The page loads `zoom.js`
  500. and calls `openeditZoom.apply(el, t)` each frame on the element showing the clip,
  501. whose parent the camera fills; `zoom.json` beside it also lists the stretches
  502. in which nothing changes.
  503. ```sh
  504. npx @veedstudio/openedit-cli zoom recording.mp4 [--clicks <clicks.json>] [--aspect 16:9,9:16] [--out <dir>] [--every 0.1] [--json]
  505. ```
  506. ### stills
  507. `stills` fetches licensed pictures from Wikimedia Commons, recording each
  508. file's terms beside it (`search` / `show` / `save`):
  509. ```sh
  510. npx @veedstudio/openedit-cli stills search "berlin skyline" --limit 10
  511. ```
  512. ### sfx
  513. `sfx` takes recorded sound effects from a stock library, where the environment
  514. serves one at `OPEN_EDIT_LIBRARY_URL`. A search takes a plain description and
  515. lists each sound's id, length and title. With `--run`, it leaves out the sounds
  516. that run already saved, so the next search finds a different one. `save`
  517. downloads a sound into the run's `assets/` and records it in the asset manifest:
  518. ```sh
  519. npx @veedstudio/openedit-cli sfx search "a door slamming in an empty hallway" --run runs/<key> --max-seconds 3
  520. npx @veedstudio/openedit-cli sfx save <id> --run runs/<key> --as door-slam
  521. ```
  522. ### init
  523. `init` is the workspace setup: it checks the machine dependencies (Node,
  524. ffmpeg) and npm-ifies the workspace (a minimal private `package.json` when none
  525. exists, this CLI exact-pinned as a devDependency and installed, `git init` when
  526. git is available, `runs/` gitignored, the skill refreshed from packaged content
  527. into `.claude/skills/` for Claude Code and `.agents/skills/` for Codex and Gemini
  528. CLI). In a clone whose `node_modules` lacks the pinned CLI, init asks for
  529. approval to run the project's install (with lifecycle scripts off), since until
  530. then `npx` would run the registry's latest rather than the pinned version.
  531. It adds nothing to agent settings, and removes the SessionStart hooks earlier
  532. versions added. Bare `init` applies only safe,
  533. workspace-local setup; `--dry` reports without writing; `--auto-approve` also
  534. applies the machine-global installs init can run on the system (Node and FFmpeg
  535. only through Homebrew on macOS; on Windows bare init already fetches FFmpeg into
  536. the app-data dir, no admin rights needed; the rest it prints for the user to
  537. run), and is only for after a person has approved every reported
  538. action. Exit 10 means something is awaiting
  539. that approval; on success the workspace root is printed on stdout.
  540. The CLI never updates itself. About once a day per machine a command asks the
  541. registry whether a newer release is out; from the next command on, until the
  542. update, each prints `update available` with both versions and the exact
  543. `init --update <version>` that installs that version and refreshes the skill.
  544. `NO_UPDATE_NOTIFIER=1` turns the lookup off.
  545. ```sh
  546. npx @veedstudio/openedit-cli init --dry --workspace <dir>
  547. npx @veedstudio/openedit-cli init --workspace <dir>
  548. npx @veedstudio/openedit-cli init --update <version> --workspace <dir>
  549. ```
  550. ## Configuration
  551. | Environment variable | Effect |
  552. | --- | --- |
  553. | `VEED_ORIGIN` | Overrides the default `https://www.veed.io` origin. |
  554. | `OPENEDIT_STATE_DIR` | Overrides where login state, the update-check cache and init's lease are stored. |
  555. | `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). |
  556. | `OPENEDIT_PACKAGE_SOURCE` | Overrides what init pins into a scaffolded workspace (a packed tarball path in tests and CI). |
  557. | `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. |
  558. | `NO_UPDATE_NOTIFIER` | Any non-empty value stops the once-a-day lookup and the `update available` notice. CI runs skip both already. |
  559. | `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). |
  560. | `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). |
  561. | `WHISPERX_BIN` / `WHISPERX_MODEL` | WhisperX binary and fallback model tier (defaults: `whisperx` on `PATH`, `small.en`). |
  562. | `OPEN_EDIT_WHISPERX_DEVICE` / `OPEN_EDIT_WHISPERX_COMPUTE` | WhisperX device/compute (defaults: `cpu`/`int8`). |
  563. | `OPEN_EDIT_LIBRARY_URL` | The stock sound library `sfx` searches and saves from (unset: `sfx` says there is none, and effects come from `fal`). |
  564. | `OPEN_EDIT_MEDIAPIPE_PYTHON` | The Python version `install-mediapipe` asks uv for (default: `3.12`; the pinned packages need 3.12 or newer). |
  565. Login state lives in the platform's per-user app-data directory:
  566. `~/Library/Application Support/veed-openedit` on macOS, `%APPDATA%\veed-openedit`
  567. on Windows, and `$XDG_CONFIG_HOME/veed-openedit` (default `~/.config/veed-openedit`)
  568. on Linux.
  569. ## License
  570. Apache-2.0. See the bundled `LICENSE` and `NOTICE` files.

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.