# Install

Requirements, the repository, rapid setup, the plugin, and the daemon, by hand.

The [install prompt](/install/prompt.md) has Claude Code run these steps and check each one. This is the same install by hand.

## Requirements

| Need | Why | Check |
|---|---|---|
| macOS | built and measured on Apple silicon | `uname -s` prints `Darwin` |
| Node 24 or later | the daemon, CLI, and engine are TypeScript Node runs directly, no build step | `node --version` |
| pnpm | the repository is one pnpm workspace | `pnpm --version` |
| Git and Git LFS | the styles' proofs and the repository's videos are in LFS | `git lfs version` |
| Google Chrome | scenes render in headless Chrome, from `/Applications/Google Chrome.app` or `CHROME_PATH` | |
| ffmpeg and ffprobe | on `PATH`: encode, join, mix, measure | `ffmpeg -version` |
| Claude Code, signed in | drives the agents and shows the pane | `claude --version` |

Two more, each for one feature:

| Need | For | Check |
|---|---|---|
| `uv` | videos [cut to a track](/docs/music): it runs the listener, which brings its own Python and installs itself on first use (`brew install uv`) | `uv --version` |
| Blender | [product shots](/docs/blender-shots) from a 3D model: `/Applications/Blender.app`, or the binary in `RAPID_BLENDER` | `/Applications/Blender.app/Contents/MacOS/Blender --version` |

## 1. The repository

```sh
git lfs install
git clone https://github.com/fakeplant/rapid.git
cd rapid
pnpm install
```

Run `git lfs install` before the clone. A checkout cloned without it holds LFS pointers in place of the proofs' videos and frames, and their checks fail; `git lfs pull` fetches the files. `file styles/swiss/proof/poster.png` says `PNG image data` when they are there.

## 2. rapid setup

```sh
node daemon/bin/rapid.ts setup
```

Writes a shim, `~/.local/bin/rapid` (`--bin-dir <dir>` for another folder), that runs this checkout's CLI, builds the screening page (`screen/dist`) if it is missing, and reports what the machine has. It never edits a shell profile or installs a tool. A file at the shim's path that isn't rapid's is left alone.

If it reports `~/.local/bin is not on PATH`, add the line it prints to your shell profile and open a new shell:

```sh
export PATH="$HOME/.local/bin:$PATH"
```

## 3. rapid setup --check

```sh
rapid setup --check
```

Reports and writes nothing. One line per check, `ok` or `missing` with its fix; exits 1 until all pass:

```text
ok       rapid command: /Users/you/.local/bin/rapid is in place
ok       Node 24 or newer: node v24.8.0
ok       ffmpeg: ffmpeg version 7.1.1
ok       ffprobe: ffprobe version 7.1.1
ok       Google Chrome: /Applications/Google Chrome.app/Contents/MacOS/Google Chrome
ok       Claude Code: claude 2.1.280 (Claude Code)
ok       Claude sign-in: signed in (claude.ai)
ok       The page: built
ok       uv (for music): uv 0.9.0
rapid is ready.
```

Without `uv`, its line reads `optional` and rapid is still ready. Setup doesn't check for Blender; a video that plans a shot fails at that node if it can't start it.

The sign-in check reads `claude auth status --json`, or passes when `ANTHROPIC_API_KEY` is set. Fix: run `claude`, then `/login`. A missing page: `pnpm --filter @rapid/screen build` in the checkout; rebuild it after pulling changes to `screen/`.

## 4. The plugin

In Claude Code:

```text
/plugin marketplace add fakeplant/rapid
/plugin install rapid@rapid
```

From a shell: `claude plugin marketplace add fakeplant/rapid`, then `claude plugin install rapid@rapid`; `claude plugin list` lists `rapid`. The plugin loads in the next session. It brings the pane, `/rapid`, the agents and skills, and the MCP server, in the terminal and the desktop app alike.

To load a checkout's plugin without installing it:

```sh
claude --plugin-dir ./plugin
```

The plugin runs the `rapid` command. If it isn't on the `PATH` Claude Code sees, set the plugin's `cli` option to the command as words: `node /Users/you/code/rapid/daemon/bin/rapid.ts`. With `cli` left at `rapid` and no `rapid` on `PATH`, the MCP server falls back to the checkout the plugin sits in. `/rapid setup` prints the setup report inside Claude Code.

## The daemon

The daemon owns the work: the job graph, the lanes, the event log, and the screening page, on `http://127.0.0.1:4317`. Starting it by hand is rarely needed: `rapid video`, `rapid open`, and the MCP tools that need it start it in the background, and the pane has a **Start daemon** button.

```sh
rapid daemon ensure   # started: rapid daemon 0.1.0 at http://127.0.0.1:4317 (pid 4242)
rapid daemon status   # whether it answers, and where its state and log are; exits 1 when none does
rapid daemon stop     # stops the daemon ensure started
```

A background daemon logs to `$RAPID_HOME/daemon.log` and keeps its PID in `$RAPID_HOME/daemon.pid` (`RAPID_HOME` defaults to `~/.rapid`). In the foreground:

```sh
rapid serve           # rapid daemon on http://127.0.0.1:4317 (state in ~/.rapid); Ctrl-C stops it
```

| Option | Means |
|---|---|
| `--port <port>` | another port; other commands then need `RAPID_PORT=<port>` or `RAPID_URL` |
| `--home <dir>` | another state folder (also `RAPID_HOME`): the event log, installed packages, `config.json` |
| `--plugin <dir>` | the plugin folder agent sessions load (default: the checkout's `plugin/`) |
| `--dev` | serve the screening page from Vite's dev server, for work on `screen/` |

Agent nodes run as Claude Agent SDK sessions on this machine, on Claude Code's sign-in or `ANTHROPIC_API_KEY`. One that can't sign in fails saying so.

Bare style names resolve against rapid's GitHub repository unless `styles_repo` in `$RAPID_HOME/config.json` names another; see [sharing styles](/docs/sharing-styles#by-name).

Next: [your first video](/docs/first-video).