Plugins built on the Rove CLI
A Rove plugin is a directory with a rove-plugin.toml manifest. That is the whole requirement. There is no required SDK, because the entire Rove CLI is the plugin API.
From a subdirectory List installed
Anything you can script against your fleet, you can ship to someone else.
Manifest fields
| Field | Status | What it does |
|---|---|---|
| id, name, version | Required | Identify the plugin. |
| min_rove_version | Required | The oldest Rove version the plugin works on. |
| [[events]] | Optional | The daemon runs your argv when an event fires. |
| [[panes]] | Optional | Adds a tab in the task workspace. |
| [[actions]] | Optional | Runs on demand. |
| [[engines]] | Optional | Adds an engine. See below. |
A plugin connects to Rove through one file, the manifest. Rove reads it, and from then on the plugin is ordinary argv that Rove knows when to launch: on a daemon event, on demand, or as a pane tab.
No required SDK. Anything you can already script against your fleet, such as a rove api verb, a shell one-liner or a binary you wrote, is a plugin the moment a manifest sits beside it. The TypeScript SDK, @sma1lboy/rove-plugin-sdk, is optional.
First-party plugins
| Plugin | Description |
|---|---|
| Sma1lboy/rove-plugins/notify | Desktop or ntfy notification when an agent finishes a turn or needs input |
| Sma1lboy/rove-plugins/github-start | Start a task straight from a GitHub issue or pull request |
| Sma1lboy/rove-plugins/worktree-include | Copy chosen ignored files into every new worktree |
| Sma1lboy/rove-plugins/linear-start | Pick a Linear issue with fzf and start a task on its branch |
| Sma1lboy/rove-plugins/browser | A real Chromium rendered as terminal cells in a pane tab |
| Sma1lboy/rove-plugins/lazygit | Open lazygit on the task worktree, in a terminal-tab pane |
Install one with rove plugin install <plugin>. One repository holds all six, so the trailing segment selects one: that is what owner/repo/subdir is for. rove plugin list shows what is installed.
These six ship as examples. Each is a workflow that does not belong in every install: a notification channel, two starting points from an issue tracker, a file-copy rule, a browser, a git UI.
The browser and lazygit plugins arrive as [[panes]]: a terminal tab in the task workspace, running in the task's own worktree. Nothing about a pane is special-cased for them.
Engine contribution
| Source | Engines | Offered |
|---|---|---|
| Built in | claude, codex, copilot, kimi | Always |
| Contrib catalogue | gemini, opencode, cursor, grok | Only if the binary is found on PATH |
| Plugin | [[engines]] | Always, without the binary check |
A plugin can contribute an engine. An [[engines]] entry registers one with a display name, a launch command, a screen manifest and an identity. These are the same four things the built-in engines supply.
One deliberate difference: the built-in contrib catalogue only offers an engine once it finds that engine's binary; a plugin engine is offered without the look-up. Installing the plugin is the opt-in.
The screen manifest is what lets Rove read state off a terminal it has never seen: rules that map lines on screen to working, blocked, and the rest. The status marks in the sidebar come from exactly that.
Manifest example
id = "acme.lazygit" name = "Lazygit" version = "0.1.0" min_rove_version = "0.9.0" [[panes]] id = "git" title = "lazygit" command = ["lazygit"] # cwd = the task worktree
A complete rove-plugin.toml of nine lines. The first four are the whole requirement. Everything after the blank line is one optional contribution.
Everything below the blank line is a contribution. Panes, events, actions and engines are each a table array, so a manifest may carry none, one, or all four.
command is argv, not a shell string. Rove launches it directly.
Plugin catalogue
Discovery is not curated. Every public repository carrying the GitHub topic rove-plugin is on this list. The listing is a search.
Stars, language and push date come from the GitHub API on page load. The six first-party plugins above are listed from this repository, because a subdirectory cannot carry a topic.
Read the manifest before you install it. It is short by design and lists every command Rove will launch. These are community repositories, listed automatically and reviewed by nobody. A plugin runs with your shell's privileges.
A plugin is not sandboxed and it is not inspected. Rove checks that a manifest parses, not what its commands do. Whatever your own commands can reach, such as your files, your keys and your network, it can reach too.
Publish a plugin
- Put a manifest in a public repository. A rove-plugin.toml at the repo root, or in a subdirectory if you keep several plugins in one repo.
- Add the GitHub topic rove-plugin. On the repository page, open the gear next to About, then Topics.
- Done. It appears in the catalogue above on the next load, and anyone can run rove plugin install you/your-repo.
Publishing is three steps because there is nothing to publish to. There is no submission form, no review queue and no registry. The catalogue above is a search that runs in your browser, so the only thing that lists a plugin is the topic on your own repository.
The plugin authoring guide at docs.rove.run has the event catalogue, the environment contract, and the placement rules a pane can ask for.
A plugin you publish is read by strangers with your commands in their hands. Keep the manifest legible, and name the commands it launches in the README beside it.