Rove

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

FieldStatusWhat it does
id, name, versionRequiredIdentify the plugin.
min_rove_versionRequiredThe oldest Rove version the plugin works on.
[[events]]OptionalThe daemon runs your argv when an event fires.
[[panes]]OptionalAdds a tab in the task workspace.
[[actions]]OptionalRuns on demand.
[[engines]]OptionalAdds 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

PluginDescription
Sma1lboy/rove-plugins/notifyDesktop or ntfy notification when an agent finishes a turn or needs input
Sma1lboy/rove-plugins/github-startStart a task straight from a GitHub issue or pull request
Sma1lboy/rove-plugins/worktree-includeCopy chosen ignored files into every new worktree
Sma1lboy/rove-plugins/linear-startPick a Linear issue with fzf and start a task on its branch
Sma1lboy/rove-plugins/browserA real Chromium rendered as terminal cells in a pane tab
Sma1lboy/rove-plugins/lazygitOpen 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

SourceEnginesOffered
Built inclaude, codex, copilot, kimiAlways
Contrib cataloguegemini, opencode, cursor, grokOnly 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

  1. 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.
  2. Add the GitHub topic rove-plugin. On the repository page, open the gear next to About, then Topics.
  3. 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.