Skip to content
Back to search

Monet

SkillWorks with Claude CodeGitHub

Edit Videos and Design Images with Claude code or Codex

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/monet-ai-editor--monet/badge.svg)](/listings/monet-ai-editor--monet)

HTML

<a href="/listings/monet-ai-editor--monet"><img src="/api/listings/monet-ai-editor--monet/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.

These steps run a script from the network that findsafeskills does not scan.

macOS app

Monet is currently macOS-first. Install with one command in your terminal — no Gatekeeper prompts:

curl -fsSL https://raw.githubusercontent.com/Monet-AI-Editor/Monet/main/install.sh | bash

This fetches the latest release ZIP directly (bypassing browser quarantine), installs `Monet.app` to `/Applications`, and launches it.

For a local packaged build from source:

npm install
npm run dist:mac

That produces stable release artifact names like:

- `release/Monet-macOS-arm64.dmg` - `release/Monet-macOS-arm64.zip` - `release/mac-arm64/Monet.app`

Run from source

Requirements:

- Node.js 18+ - `ffmpeg` on your system path - macOS - optional telemetry env vars via a local `.env`

Optional local transcription runtime:

npm run setup:local-transcription

Start the app:

npm install
npm run dev

If you want Sentry and Aptabase enabled locally or in release builds, set env vars outside git-tracked files:

cp .env.example .env

Available vars:

- `MONET_SENTRY_DSN` - `MONET_APTABASE_APP_KEY` - `VITE_MONET_SENTRY_DSN`

For local use, `VITE_MONET_SENTRY_DSN` can usually match `MONET_SENTRY_DSN`.

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.

SKILL.md · Manifest · 322 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. # AI Video Editor — Agent Control Reference
  2. ## ⚠️ FINDING `editorctl` — MANDATORY (read this first)
  3. `editorctl` is the Monet CLI. Always try it directly first — Monet keeps it on `PATH` for every shell it spawns and persists the bin dir to `~/.zshrc` / `~/.bash_profile` so it survives subshells and PATH-rewriting wrappers. **If `command -v editorctl` returns nothing**, fall back in order:
  4. 1. `"$HOME/Library/Application Support/Monet/bin/editorctl"` — macOS install (most users)
  5. 2. `node /Applications/Monet.app/Contents/Resources/app.asar.unpacked/out/cli/cli/editorctl.js …`
  6. 3. `node ./out/cli/cli/editorctl.js …` — dev tree
  7. Never give up after the first "command not found". Prefer `editorctl` over raw `curl localhost:51847` — it always exposes the current command surface and arg shapes.
  8. ## ⚠️ OUTPUT FILE NAMING — MANDATORY (read this first)
  9. **Never reuse a filename when editing or regenerating a video or image.** The asset cache holds the previous file by path, so writing to the same name silently shows stale content. Every edit/regenerate must produce a **new unique filename** (e.g. `clip_v1.mp4`, `clip_v2.mp4`, or a timestamp suffix). Applies to all video renders, image generations, canvas exports, and thumbnails. If a target path already exists, append `_v2`, `_v3`, … — do not overwrite.
  10. ## ⚠️ AUDIO ON MULTI-CLIP TIMELINES — MANDATORY
  11. When adding audio to a timeline with **more than one video clip**, audio cuts at every clip boundary. Required flow:
  12. 1. Tell the user: *"To keep audio from cutting between clips, I'll merge all video clips into one combined video first, then add the audio. OK to proceed?"*
  13. 2. Wait for confirmation — do not auto-merge.
  14. 3. Concatenate all clips into a single new file (unique filename per the rule above).
  15. 4. Replace the multi-clip video track with that merged clip, then add the audio.
  16. Single-clip timelines: skip the merge.
  17. ---
  18. ## ⚠️ CANVAS MODE — MANDATORY RULES (read this first)
  19. When `activeView=canvas` is reported by the hook or `editorctl get-state`:
  20. **There are EXACTLY 3 canvas options. No others exist.**
  21. 1. **Paper.js** — code drawing with vector graphics (`canvas-run-paperjs`)
  22. 2. **Matter.js** — physics and animation (`canvas-run-matterjs`)
  23. 3. **GPT image 2** — AI-generated image (`generate-image` + `canvas-add-image`)
  24. **REMOVED — do NOT offer these under any name:**
  25. - ~~Design mode~~ — removed
  26. - ~~Editable layers~~ — removed
  27. - ~~Figma-style layout~~ — removed
  28. - ~~Node-based design~~ — removed
  29. - ~~Direct canvas design~~ — removed
  30. When the user asks for something visual in canvas mode, present ONLY these three options using these EXACT labels. Copy them verbatim. Do not invent a fourth option or rephrase option 1 as anything design-related.
  31. ---
  32. **API Bridge:** `POST http://localhost:51847` — JSON body `{"command":"<name>","args":{...}}`
  33. ```python
  34. import urllib.request, json
  35. def call(command, **args):
  36. data = json.dumps({"command": command, "args": args}).encode()
  37. req = urllib.request.Request(
  38. "http://localhost:51847", data=data,
  39. headers={"Content-Type": "application/json"}, method="POST"
  40. )
  41. return json.loads(urllib.request.urlopen(req).read())["result"]
  42. call("ping") # → {"status":"ok","version":"1.0.0","port":51847}
  43. call("help") # → full command list
  44. ```
  45. ---
  46. ## Commands
  47. ### Project / Settings
  48. | Command | Args | Returns |
  49. |---------|------|---------|
  50. | `get_project` | — | Full project JSON |
  51. | `get_settings` | — | Model + provider config |
  52. ### Assets
  53. | Command | Args | Returns |
  54. |---------|------|---------|
  55. | `list_assets` | — | `[{id, name, path, type, duration, semantic}]` |
  56. | `get_asset` | `assetId` | Single asset with semantic + transcript |
  57. | `import_files` | `paths: string[]` | Imported asset records |
  58. | `transcribe_asset` | `assetId`, `language?` | `{segments}` via Whisper |
  59. | `embed_assets` | `all?: bool` | `{embedded, total}` via text-embedding-3-small |
  60. | `search_media` | `query, limit?` | Cosine similarity search (falls back to keyword) |
  61. | `search_spoken` | `query, limit?` | Substring search within transcribed segments |
  62. ### Sequences & Tracks
  63. | Command | Args | Returns |
  64. |---------|------|---------|
  65. | `list_sequences` | — | All sequences |
  66. | `create_sequence` | `name` | New sequence |
  67. | `activate_sequence` | `sequenceId` | Activated sequence |
  68. | `get_tracks` | — | `[{id, name, kind, clipCount}]` for active sequence |
  69. | `add_track` | `kind: video\|audio\|caption` | Updated sequence |
  70. ### Clips
  71. | Command | Args | Returns |
  72. |---------|------|---------|
  73. | `list_clips` | `sequenceId?` | All clips sorted by startTime, with trackKind |
  74. | `add_clip` | `assetId, trackId, startTime, duration?, inPoint?` | `{clipId, clip}` |
  75. | `remove_clip` | `clipId` | `{success}` |
  76. | `move_clip` | `clipId, startTime` | `{success}` |
  77. | `trim_clip` | `clipId, inPoint?, duration?, startTime?` | Updated clip |
  78. | `split_clip` | `clipId, time` | Updated sequence |
  79. | `duplicate_clip` | `clipId, offsetSeconds?` | `{clipId, clip}` |
  80. | `update_clip_label` | `clipId, label` | `{success}` |
  81. ### Effects & Properties
  82. | Command | Args | Returns |
  83. |---------|------|---------|
  84. | `list_effects` | — | Available effects + parameter docs |
  85. | `add_effect` | `clipId, effectType, parameters` | Updated project |
  86. | `remove_effect` | `clipId, effectId` | Updated project |
  87. | `set_speed` | `clipId, speed` | Updated project (0.1–10× playback) |
  88. | `set_volume` | `clipId, volume` | Updated project (0–4, 1=normal) |
  89. | `set_transition` | `clipId, side: in\|out, type, duration?` | `{success}` |
  90. ### History
  91. | Command | Args |
  92. |---------|------|
  93. | `undo` | — |
  94. | `redo` | — |
  95. ---
  96. ## Effect Types
  97. | Type | Parameters |
  98. |------|-----------|
  99. | `fade_in` | `duration` (sec) |
  100. | `fade_out` | `duration` (sec) |
  101. | `color_grade` | `brightness` (-1→1), `contrast` (0.5→2), `saturation` (0→3) |
  102. | `blur` | `radius` (px, default 5) |
  103. | `sharpen` | `amount` (0→3, default 1) |
  104. ## Transition Types
  105. `crossfade` · `dip_to_black` · `wipe` · `slide`
  106. ---
  107. ## Key Concepts
  108. - `inPoint` = position in the source file where clip playback starts
  109. - `startTime` = position on the timeline where the clip is placed
  110. - `duration` = how long the clip plays (can be shorter than source)
  111. - Every mutation instantly pushes `project:updated` → UI reflects changes live
  112. - Effects are previewed in real-time (CSS) and baked via FFmpeg on export
  113. ## Editing Safety Rules
  114. - Treat timeline gaps as a bug unless the user explicitly asks for a pause, beat, or black gap.
  115. - After creating a sequence or moving clips, verify continuity with `list_clips(sequenceId)` and check that each clip starts exactly when the previous clip ends if the edit is meant to be continuous.
  116. - Do not assume `create_sequence` or `activate_sequence` is enough on its own. Always verify the active sequence afterward with `list_sequences` or `get_project`.
  117. - When building a spoken highlight cut, move video, audio, captions, and markers together. Do not leave captions or markers on old timings after tightening the edit.
  118. - If playback appears to stop between clips, inspect the timeline first for empty gaps before assuming the preview player is broken.
  119. - Prefer exact target starts over cumulative offset math when tightening a cut. Recompute each clip's intended `startTime` from the cut plan.
  120. ---
  121. ## Brand Aesthetic from a URL
  122. > **MANDATORY — NO EXCEPTIONS**: If the user's message contains any URL or domain, you MUST run the fetch commands below and extract brand tokens before writing any canvas/design code. Do not use assumed or memorized brand colors. Fetch first, design second — every time. If the fetch fails, ask the user to paste the hex values; never fall back to guessing.
  123. ```bash
  124. curl -sL "<url>" | grep -Eo '(#[0-9a-fA-F]{3,8}|font-family:[^;"}]+|font-size:[^;"}]+|border-radius:[^;"}]+)' | sort -u | head -60
  125. ```
  126. Extract: background colors, surface colors, primary/accent colors, text colors, font families, font sizes/weights, border radii, spacing, and box-shadows. Also find the logo — it's the ground truth for brand colors and visual tone. Hard-code those exact values — never guess when a real URL is available.
  127. ```bash
  128. # Find logo
  129. curl -sL "<url>" | grep -Eo '(src|href)="[^"]*logo[^"]*"' | head -10
  130. curl -sL "<url>" | grep 'og:image'
  131. ```
  132. ---
  133. ## Canvas — Matter.js Physics Frames
  134. Use `canvas_run_matterjs` to place a live interactive physics scene on the canvas.
  135. ### MCP tools
  136. | Tool | Args |
  137. |------|------|
  138. | `canvas_run_matterjs` | `id?` (frame id to update), `name?`, `script` (JS string), `width?`, `height?` |
  139. | `canvas_add_frame` | `name`, `width`, `height`, `mode: 'matterjs'` |
  140. | `canvas_matterjs_scene` | `style` (balls/stacks/pendulum/bridge/ragdoll), `gravity?`, `count?`, `colors?` |
  141. | `canvas_frames` | — → `{frames: [{id, name, mode, width, height}]}` |
  142. ### Script patterns — pick ONE
  143. **Pattern A — Self-contained (rich UIs, custom 2D drawing, rAF loop)**
  144. ```js
  145. const { Engine, Bodies, Composite, Mouse, MouseConstraint, Events } = Matter;
  146. const W = 390, H = 844;
  147. const engine = Engine.create({ gravity: { y: 1.5 } });
  148. const canvas = document.querySelector('canvas'); // ← always use this; never create a new one
  149. canvas.width = W; canvas.height = H;
  150. const ctx = canvas.getContext('2d');
  151. // ... add bodies, set up mouse ...
  152. function loop() {
  153. Engine.update(engine, 1000/60);
  154. ctx.fillStyle = '#121212'; ctx.fillRect(0, 0, W, H);
  155. // draw with ctx
  156. requestAnimationFrame(loop);
  157. }
  158. loop();
  159. ```
  160. **Pattern B — Bodies only (template manages engine/render/runner)**
  161. ```js
  162. // engine, render, width, height, and all Matter vars are already declared — do NOT redeclare them
  163. var ground = Bodies.rectangle(width/2, height+25, width, 50, { isStatic: true, render: { fillStyle: '#334155' } });
  164. var ball = Bodies.circle(width/2, 50, 30, { restitution: 0.8, render: { fillStyle: '#5b82f7' } });
  165. Composite.add(engine.world, [ground, ball]);
  166. engine.gravity.y = 1;
  167. // Runner.run and Render.run are called automatically after this script — do not call them here
  168. ```
  169. ### Critical rules
  170. - **`Runner.run` needs two args**: `Runner.run(Runner.create(), engine)` — single-arg `Runner.run(engine)` silently does nothing in Matter.js 0.20.0
  171. - **Never `element: document.body`** in `Render.create` — spawns an invisible second canvas; use `canvas: document.querySelector('canvas')` instead
  172. - **Never declare `const engine` or `let engine` in Pattern B** — the template already has `var engine`; redeclaring with `const`/`let` causes a SyntaxError that silently blanks the canvas
  173. - **Never call `Render.run` / `Runner.run` in Pattern B** — the template does this after your script runs; calling them twice causes double-speed or broken rendering
  174. - **Never import or redeclare Matter vars in Pattern B** — `Engine`, `Bodies`, `Composite`, etc. are already destructured; `const { Engine } = Matter` will SyntaxError
  175. ### Pattern B available globals
  176. `engine` · `render` · `width` · `height` · `Engine` · `Render` · `Runner` · `Bodies` · `Composite` · `World` · `Body` · `Events` · `Constraint` · `Mouse` · `MouseConstraint`
  177. ### CLI
  178. ```bash
  179. editorctl canvas-add-frame "Name" 390 844 matterjs # matterjs|paperjs|html
  180. editorctl canvas-run-matterjs <frameId> "$(cat script.js)"
  181. editorctl canvas-run-paperjs <frameId> "$(cat script.js)"
  182. editorctl canvas-run-html <frameId> "$(cat scene.html)"
  183. editorctl canvas-frames
  184. editorctl canvas-done
  185. ```
  186. ---
  187. ## Remotion — React Video Composition
  188. Use Remotion to generate animated video assets (title cards, lower thirds, slideshows, motion graphics) and import them directly into the timeline.
  189. ### MCP tools
  190. | Tool | Args | Returns |
  191. |------|------|---------|
  192. | `video_editor_list_remotion_compositions` | — | List of composition IDs |
  193. | `video_editor_render_remotion` | `compositionId, outputFilename?, props?, durationInFrames?, fps?` | `{outputPath, assetId}` |
  194. ### CLI
  195. ```bash
  196. npm run remotion:studio # live preview at localhost:3000
  197. npx remotion render remotion/src/index.ts <ID> out.mp4 --props '{"key":"value"}'
  198. ```
  199. ### Built-in compositions
  200. | ID | Props |
  201. |----|-------|
  202. | `TitleCard` | `title` (str), `subtitle?` (str), `backgroundColor`, `textColor`, `accentColor` — 150 frames @ 30fps |
  203. | `Slideshow` | `images` (abs path[]), `frameDuration` (frames), `transitionDuration` (frames) — 300 frames @ 30fps |
  204. | `HtmlInCanvasGlitch` | `title`, `subtitle`, `glitchIntensity` (0–40), `backgroundColor`, `textColor`, `accentColor` — 180 frames @ 30fps. RGB-split glitch via `<HtmlInCanvas>` |
  205. ### HTML-in-canvas (Remotion ≥ 4.0.455)
  206. > ⚠️ **Naming collision — read first.** Remotion `<HtmlInCanvas>` (this section) produces a **video file** for the timeline. **Monet canvas HTML frames** (`canvas-add-frame ... html`, `canvas_update_frame`) produce a **live HTML scene in the canvas-tab artboard**. Different systems. Pick by destination: timeline → Remotion; canvas tab → Monet HTML frame. Never mix the two in one task.
  207. Use [`<HtmlInCanvas>`](https://www.remotion.dev/docs/html-in-canvas) to draw a DOM subtree into a `<canvas>` and post-process with Canvas 2D / WebGL / WebGPU. Best for glitch, magnifying glass, CRT, displacement, hue-rotate effects.
  208. ```tsx
  209. import { HtmlInCanvas, type HtmlInCanvasOnPaint } from 'remotion'
  210. const onPaint: HtmlInCanvasOnPaint = ({ canvas, element, elementImage }) => {
  211. const ctx = canvas.getContext('2d')!
  212. ctx.reset()
  213. ctx.filter = 'blur(8px)'
  214. const transform = ctx.drawElementImage(elementImage, 0, 0)
  215. element.style.transform = transform.toString() // <-- always reapply
  216. }
  217. <HtmlInCanvas width={1920} height={1080} onPaint={onPaint}>
  218. <YourDomTree />
  219. </HtmlInCanvas>
  220. ```
  221. Rules:
  222. - **Always** reapply the `drawElementImage` return value to `element.style.transform` so layout/input stay correct.
  223. - **Never** nest `<HtmlInCanvas>` inside another — Chrome paints only the outer one and Remotion throws. Merge effects into one `onPaint`.
  224. - `Config.setChromiumOpenGlRenderer('angle')` is already set in `remotion.config.ts` so WebGL/WebGPU shaders render correctly via `npx remotion render` and our MCP renderer.
  225. - Studio preview needs Chrome Canary ≥ 149 with `chrome://flags/#canvas-draw-element` enabled. Renders work everywhere — Remotion ships its own patched Chromium.
  226. ### Adding a composition
  227. 1. Create `remotion/src/compositions/MyComp.tsx` — export `myCompSchema` (zod) + `MyComp` component
  228. 2. Register in `remotion/src/Root.tsx` with `<Composition id="MyComp" ... />`
  229. 3. Renders go to `remotion-renders/` and are auto-imported when using the MCP tool
  230. ### Timing
  231. - Duration is in **frames** (`durationInFrames`). Default fps = 30. 30 frames = 1 second.
  232. - Use `useCurrentFrame()` + `spring()` + `interpolate()` for animation.
  233. ---
  234. ## Example — Minimal Edit
  235. ```python
  236. assets = call("list_assets")
  237. tracks = call("get_tracks")
  238. vid = next(a for a in assets if a["type"] == "video")
  239. vt = next(t for t in tracks if t["kind"] == "video")
  240. # Place first 10s of video at t=0
  241. r = call("add_clip", assetId=vid["id"], trackId=vt["id"],
  242. startTime=0, duration=10, inPoint=0)
  243. cid = r["clipId"]
  244. # Fade in over 1s, color grade, transition out
  245. call("add_effect", clipId=cid, effectType="fade_in", parameters={"duration": 1.0})
  246. call("add_effect", clipId=cid, effectType="color_grade",
  247. parameters={"brightness": 0.05, "contrast": 1.1, "saturation": 1.2})
  248. call("set_transition", clipId=cid, side="out", type="dip_to_black", duration=0.8)
  249. ```
README.md · README · 342 lines · 2 findings marked

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. <h1 align="center">Monet</h1>
  2. <p align="center">AI video editor and design canvas for coding agents</p>
  3. <p align="center">
  4. <img src="./resources/monet-mark.png" alt="Monet logo" width="120" />
  5. </p>
  6. <p align="center">
  7. Local-first video editing, a live design canvas, terminal-native agent workflows, real timeline operations, local transcription, and export in one macOS app.
  8. </p>
  9. <p align="center">
  10. <strong>Monet is no longer just an AI video editor.</strong> Use Claude Code or Codex directly inside Monet Canvas to design vector graphics, animate, simulate physics, and drop the result straight into your video timeline.
  11. </p>
  12. <p align="center">
  13. Built by Het Patel
  14. </p>
  15. <p align="center">
  16. <code>curl -fsSL https://raw.githubusercontent.com/Monet-AI-Editor/Monet/main/install.sh | bash</code>
    • Note: Pipes a downloaded script directly into a shell (curl | sh / wget | bash)
    • Line 21 on GitHub
  17. </p>
  18. ## What Monet Is
  19. Monet is a desktop video editor designed for people who want coding agents to work on video directly, not through a fragile bridge into another editor.
  20. The app combines:
  21. - a real timeline and preview
  22. - local project files with autosave and recovery
  23. - an embedded PTY terminal for Claude Code, Codex, and other terminal agents
  24. - deterministic editor tools through `editorctl`, a local API bridge, and MCP
  25. - local transcription with `faster-whisper`
  26. - semantic search powered by embeddings when an OpenAI key is configured
  27. - the same OpenAI key can also be reused for GPT Image 2 generation
  28. Monet is not a chat demo wrapped around a timeline. The terminal, project graph, and editor runtime are the product.
  29. ## Features
  30. <table>
  31. <tr>
  32. <td width="42%" valign="top">
  33. <h3>Agent-native terminal</h3>
  34. Claude Code and Codex can run inside Monet's built-in terminal with project-aware context, live editor access, and deterministic commands through <code>editorctl</code>.
  35. </td>
  36. <td width="58%">
  37. <img src="./resources/ai_demo.png" alt="Monet terminal and preview" width="100%" />
  38. </td>
  39. </tr>
  40. <tr>
  41. <td width="42%" valign="top">
  42. <h3>Real timeline editing</h3>
  43. Import media, scrub, trim, split, move, duplicate, ripple edit, generate captions, add markers, and export from a real multi-track timeline.
  44. </td>
  45. <td width="58%">
  46. <img src="./resources/timeline.png" alt="Monet timeline" width="100%" />
  47. </td>
  48. </tr>
  49. <tr>
  50. <td width="42%" valign="top">
  51. <h3>Monet Canvas — design alongside the editor</h3>
  52. A new artboard-based design surface inside Monet. Ask Claude Code or Codex to draw with <strong>Paper.js</strong>, simulate physics with <strong>Matter.js</strong>, or build any HTML/CSS/JS frame.
  53. <td width="58%">
  54. <img src="./resources/canvas.png" alt="Monet Canvas" width="100%" />
  55. </td>
  56. </tr>
  57. </table>
  58. - **Terminal-first AI workflow** — Use Claude Code or Codex directly in the app instead of relying on a built-in chatbot abstraction
  59. - **Monet Canvas** — design surface with Paper.js + Matter.js + raw HTML modes, live agent loading per frame, auto-export to the video media library, JSON export/import for canvas state, and PNG render for individual frames
  60. - **Deterministic editing tools** — `editorctl`, local API bridge, and MCP entrypoint for inspect/edit/export operations across both timeline and canvas
  61. - **Local transcription** — Uses `faster-whisper` on-device by default, with OpenAI fallback when configured
  62. - **Semantic search** — Search spoken content, metadata, and embedded project context
  63. - **Autosave and recovery** — Reopen current work, recover sessions, and manage multiple saved projects
  64. - **Export pipeline** — 720p, 1080p, and 4K outputs, export progress UI, and one-click `Show in Finder`
  65. - **React video composition** — [Remotion](https://www.remotion.dev) is built in with `PaperCanvas` and `PhysicsScene` compositions plus title cards, lower thirds, kinetic text, audio visualizers — all auto-import as timeline assets
  66. - **Basic motion and compositing** — transforms, opacity, text overlays, chroma key, and layered export baking
  67. - **Privacy-aware telemetry** — Anonymous usage analytics are optional; Sentry handles crash reporting
  68. ## Why Monet
  69. Most AI video workflows today still depend on a human driving Premiere, Resolve, or another editor by hand. Even when tools exist, they usually stop at prompts, scripts, or rough cuts.
  70. Monet is built around a different model:
  71. - the project is a structured graph, not an opaque binary
  72. - the terminal is a first-class editing surface
  73. - agents can inspect the live editor state, import media, search transcripts, cut sequences, and export results
  74. The goal is simple: make video editing something coding agents can actually operate.
  75. ## Install
  76. ### macOS app
  77. Monet is currently macOS-first. Install with one command in your terminal — no Gatekeeper prompts:
  78. ```bash
  79. curl -fsSL https://raw.githubusercontent.com/Monet-AI-Editor/Monet/main/install.sh | bash
    • Note: Pipes a downloaded script directly into a shell (curl | sh / wget | bash)
    • Line 101 on GitHub
  80. ```
  81. This fetches the latest release ZIP directly (bypassing browser quarantine), installs `Monet.app` to `/Applications`, and launches it.
  82. For a local packaged build from source:
  83. ```bash
  84. npm install
  85. npm run dist:mac
  86. ```
  87. That produces stable release artifact names like:
  88. - `release/Monet-macOS-arm64.dmg`
  89. - `release/Monet-macOS-arm64.zip`
  90. - `release/mac-arm64/Monet.app`
  91. ### Run from source
  92. Requirements:
  93. - Node.js 18+
  94. - `ffmpeg` on your system path
  95. - macOS
  96. - optional telemetry env vars via a local `.env`
  97. Optional local transcription runtime:
  98. ```bash
  99. npm run setup:local-transcription
  100. ```
  101. Start the app:
  102. ```bash
  103. npm install
  104. npm run dev
  105. ```
  106. If you want Sentry and Aptabase enabled locally or in release builds, set env vars outside git-tracked files:
  107. ```bash
  108. cp .env.example .env
  109. ```
  110. Available vars:
  111. - `MONET_SENTRY_DSN`
  112. - `MONET_APTABASE_APP_KEY`
  113. - `VITE_MONET_SENTRY_DSN`
  114. For local use, `VITE_MONET_SENTRY_DSN` can usually match `MONET_SENTRY_DSN`.
  115. ## First Run
  116. On first launch, Monet asks for:
  117. - an OpenAI API key for embeddings and semantic search, with the same key reusable for GPT Image 2 generation
  118. - an explicit anonymous usage analytics choice
  119. - nothing else up front
  120. Claude Code and Codex installation help is shown next to the terminal when needed, instead of blocking onboarding.
  121. ### Codex sandbox
  122. Monet's embedded terminal automatically launches Codex with `-s danger-full-access` so that `editorctl` can reach the live app API on `localhost:51847`. Without this flag, Codex's default `read-only` sandbox blocks outbound localhost connections and every `editorctl` command falls back to file mode.
  123. This flag is injected by Monet's wrapper script (written to `userData/bin/codex` on each terminal start) and **only applies when Codex is launched from inside Monet**. Codex sessions started from any other terminal are unaffected.
  124. ## What Agents Can Do
  125. Through the embedded terminal, `editorctl`, API bridge, and MCP surfaces, agents can operate **both** the video editor and the design canvas.
  126. ### Video Editor
  127. - inspect the current project and active sequence
  128. - list assets, tracks, clips, markers, and segments
  129. - import media from disk
  130. - split, trim, move, duplicate, rename, and remove clips
  131. - add tracks and transitions
  132. - generate captions from transcript segments
  133. - create rough cuts and selects from search results
  134. - extract frames and create contact sheets
  135. - run transcription
  136. - generate images with GPT and import to media
  137. - export the active sequence
  138. ### Monet Canvas
  139. - create artboard frames in `paperjs`, `matterjs`, or `html` mode
  140. - run any Paper.js script (vector graphics, animation, generative art)
  141. - run any Matter.js scene (2D physics simulations)
  142. - inject inline HTML/CSS/JS for arbitrary web-native designs
  143. - update, rename, resize, or delete individual frames
  144. - export entire canvas state as JSON (full backup) or render any single frame as PNG
  145. - import JSON canvas state, adding to existing frames without overwriting
  146. - auto-import every rendered frame into the video editor's media library
  147. - show live grid loading overlays per frame as the agent works
  148. ### Tool Surface
  149. | Surface | Used by | Purpose |
  150. | --- | --- | --- |
  151. | `editorctl` CLI | Claude Code, Codex, terminal scripts | Deterministic timeline + canvas commands inside the embedded terminal |
  152. | MCP server | MCP-aware agent hosts | Same operations exposed as Model Context Protocol tools |
  153. | HTTP API bridge | Anything that can `curl localhost:51847` | Fallback path; auto-discovers a free port if the default is busy |
  154. | `[MONET]` UserPromptSubmit hook | Claude Code | Injects current `activeView` (canvas vs editor) into the agent's context every turn |
  155. ### Examples
  156. ```bash
  157. # Video editor
  158. editorctl get-state
  159. editorctl search-segments "terminal workflow"
  160. editorctl export /tmp/monet-export.mp4 high 1080p mp4
  161. # Canvas — Paper.js, Matter.js, or raw HTML
  162. editorctl canvas-add-frame "Paper Layout" 1440 900 paperjs
  163. editorctl canvas-add-frame "Glitch" 1280 720 paperjs
  164. editorctl canvas-frames
  165. editorctl canvas-run-paperjs <id> "var c = new Path.Circle({ center: view.center, radius: 100, fillColor: '#7aa2f7' });"
  166. editorctl canvas-render-png <id> ~/Desktop/glitch.png
  167. editorctl canvas-export ~/Desktop/my-canvas.json
  168. ```
  169. ## Local AI Stack
  170. Monet is intentionally local-first.
  171. - **Transcription**: local `faster-whisper` by default
  172. - **Embeddings**: OpenAI API key required
  173. - **GPT Image 2 generation**: the same OpenAI API key can be reused
  174. - **Export**: local `ffmpeg`
  175. - **Project files**: plain `.aiveproj.json` files plus autosaves
  176. If embeddings or transcripts do not exist yet, Monet should say that directly instead of pretending otherwise.
  177. ## Project Model
  178. Monet projects are structured, inspectable, and tool-friendly.
  179. That includes:
  180. - assets
  181. - sequences
  182. - tracks
  183. - clips
  184. - transcript segments
  185. - markers
  186. - captions
  187. - effects
  188. - exports
  189. This is what allows coding agents to operate the editor directly instead of scraping the UI.
  190. ## Current Scope
  191. Monet already supports:
  192. - timeline editing
  193. - preview and scrubbing
  194. - autosave / recover
  195. - local transcription
  196. - semantic search foundations
  197. - captions and markers
  198. - terminal-native agent workflows
  199. - packaged macOS app builds
  200. Monet is still evolving in areas like:
  201. - richer color finishing
  202. - deeper motion tooling
  203. - broader codec coverage
  204. - more advanced compositing
  205. - wider platform support beyond macOS
  206. ## Privacy
  207. Monet does not collect project content for analytics.
  208. That means:
  209. - no filenames
  210. - no prompts
  211. - no transcript text
  212. - no media content
  213. - no API keys
  214. Anonymous usage analytics are optional. Crash reporting is handled separately.
  215. Telemetry keys are injected from environment variables at build time and are not stored in the repository.
  216. ## Build
  217. ```bash
  218. npm run build
  219. ```
  220. Other useful scripts:
  221. ```bash
  222. npm run dev
  223. npm run typecheck
  224. npm run build:cli
  225. npm run build:mcp
  226. npm run dist:mac
  227. ```
  228. ## Repository Layout
  229. - `src/main` — Electron main process, project store, export, transcription, terminal, updater, analytics
  230. - `src/renderer` — React app UI
  231. - `src/cli` — `editorctl`
  232. - `src/mcp-server` — MCP server entrypoint
  233. - `resources` — screenshots and app icon assets
  234. - `release` — packaged macOS artifacts
  235. ## Status
  236. Monet is already usable as a real macOS app, but it is still best described as an early public alpha rather than a finished mass-market editor.
  237. If you want to help shape it:
  238. - open issues
  239. - test the app on real media
  240. - try the terminal agent workflow
  241. - report reliability problems before polish problems
  242. ## License
  243. Monet is released under the MIT License.
  244. ## Built with
  245. - [xterm.js](https://xtermjs.org) — terminal emulator powering the embedded shell
  246. - [Remotion](https://www.remotion.dev) — React-based video composition and rendering
  247. - [Paper.js](http://paperjs.org) — vector graphics scripting in Monet Canvas (paperjs frames)
  248. - [Matter.js](https://brm.io/matter-js/) — 2D rigid-body physics engine in Monet Canvas (matterjs frames)
  249. - [node-pty](https://github.com/microsoft/node-pty) — pseudo-terminal backend
  250. - [FFmpeg](https://ffmpeg.org) — video export and processing
  251. - [faster-whisper](https://github.com/SYSTRAN/faster-whisper) — local transcription runtime

Ratings and comments

Sign in to rate this skill.

Sign in

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