macOS menu bar · OpenCode

Every OpenCode session, at a glance.

Perch sits in your menu bar and watches every OpenCode session on your Mac — live state, what each one is running, the tokens and the exact cost, and how much code it changed. Approve a permission or answer a question from your phone.

Get Perch — $29One-time purchase · macOS 13 or later
The Perch panel open from the macOS menu bar, showing four agent sessions with live state, model, context window and spend

How it works

A plugin you own, and a boundary it can’t cross

A plugin

Installed into every OpenCode root Perch finds

OpenCode takes plugins rather than hook files, so Perch writes a small owned plugin into each root it discovers. It's owner-only, carries an owner marker and a hash of its own body, and refuses to overwrite a file it didn't write or that you've since edited. Removing the integration takes it back out and verifies it's gone.

A boundary

The plugin forwards metadata, and nothing else

The JavaScript sends events; a signed helper inside the Perch app bundle does the validating, normalising and persisting. Message bodies, text deltas, reasoning and attachments never cross that line — not filtered downstream, never sent in the first place.

A fallback

Sessions from before you installed it

Perch also reads OpenCode's own session database — opened read-only, and aware of a write-ahead log so it doesn't miss what hasn't been checkpointed yet. That's what backfills Stats and what catches sessions the plugin never saw.

One thing to know on day one: OpenCode reads its plugins at startup, so a session that was already open when Perch installed its plugin keeps running without it and stays at Idle. Start a new session and it reports straight away.

What lands on the row

OpenCode tells Perch more than almost anything else does

Perch was built against Claude Code first, and most of what it learned there is only partly portable. OpenCode is the exception — its event stream carries nearly the whole set, so nearly the whole app works.

Waiting, and ended

OpenCode says when it's asking a human and when a session is really over, so a row reaches “needs you” and then disappears — rather than sitting at idle, or lingering after the session is gone.

Five-part token counts

Input, output, reasoning, and cache reads and writes, split out rather than summed into one number — so a session that looks expensive can be read for why.

Exact cost, not an estimate

OpenCode reports what a turn actually cost, so the figure on the row is the real one instead of tokens multiplied by a price table Perch keeps up to date by hand.

Lines changed

How much code a session actually touched, on the row. Most agents don't report it — Codex's logs carry no line counts at all — so this is one of the few places OpenCode is more legible than the incumbents.

Real subagents

Delegated work nests under the session that started it, and the parent stays “running” while it happens — so the finished ping lands when the work is done, not when the main thread paused.

Todos as they're ticked

OpenCode's own checklist, read live, so a long run reads as “task 4 of 5” with the current step named — on the Mac and on your lock screen.

Answering

Type the answer back without handing over your keyboard

To answer another agent’s question from a notification, Perch has to type it into your terminal for you — which means asking macOS for Accessibility access, the permission that lets an app control your Mac. Plenty of people decline it, reasonably.

OpenCode takes the answer directly, through the same plugin that reports the session. So a reply you type on the lock screen goes back as an answer rather than as synthetic keystrokes, and Perch asks for no Accessibility grant at all to do it.

Permission prompts work the same way — Approve maps to OpenCode’s own one-time approval, Deny rejects it. A multiple-choice question is the one thing that still has to be answered in OpenCode itself.

On the lock screen

perch asks: which database?

OpenCode · api-gateway

the staging one|

No Accessibility access required

Usage

Quota bars computed entirely on your Mac

Three windows

A rolling five hours, the ISO week, and the month from its anchor date — your recorded per-message spend, read against the dollar caps this integration works to.

No network call, at all

There is no OpenCode usage API to ask, and Perch doesn’t invent one. No cookies are read, no credentials are touched, and nothing leaves the machine to build these bars.

Labelled as an estimate

The plan reads Go · local estimate rather than posing as a figure from a server. It applies to opencode-go and says so.

On the phone and the watch

The same bars ride along to Perch Companion and the Apple Watch app, next to your other agents’ limits, with a heads-up before you run out.

What it doesn’t do

Four gaps, and what each one is

Rather than let you find these out after paying:

Remote OpenCode

Perch watches OpenCode running on the same Mac. An SSH-hosted session isn’t covered, and neither is the IDE surface — both are unbuilt rather than impossible.

Usage is an estimate

Reconstructed locally, and only for opencode-go. There’s no server-authoritative number to check it against, so there’s no per-model breakdown and no credit balance either.

No separate “done”

Sessions move between running, waiting, idle and ended. Nothing OpenCode reports maps to the distinct “done” state Claude Code sessions get — you still get the finished notification.

Everything else is there

Live state, remote approvals, direct replies, jump-to-session, exact cost, lines changed, Stats, the phone, the watch, the Live Activity, and the same one-time license.

Stats

Sessions, streaks and a year of days

A contribution heatmap, current and longest streak, your longest session and busiest day, and token totals that OpenCode is actually able to fill in — down to the favourite model and the breakdown behind it. Filter to OpenCode alone, or read it against every other agent you run.

Built by reading OpenCode’s own session database on your Mac, so the history you had before installing Perch is counted too. Nothing is uploaded to produce it.

The Perch stats panel showing a contribution heatmap, streaks, and a per-model token breakdown

Pricing

Pay once, keep it

Solo

$29one-time
  • Lifetime license — pay once, keep it
  • One Mac at a time; deactivate in-app to move
  • iOS companion, push alerts & Live Activities included
  • Notarized app with signed automatic updates
Buy Perch — $29

Team

$29per seat, one-time · 2+ seats
5
seats × $29 = $145
  • A license key for every teammate — not one shared key
  • Assign and revoke seats by email from your customer portal
  • Your seat is claimed on purchase; invite the rest by email
  • Same lifetime license and updates on every seat
Buy 5 seats — $145

FAQ

Questions OpenCode users ask

Do I have to configure anything?
No. Perch finds your OpenCode installs and writes its plugin into each one. There's no config file to edit, no key to paste, and no setting to turn on.
My OpenCode sessions all say Idle after installing Perch. Why?
Because OpenCode loads plugins when it starts, so a session that was already open when Perch installed its plugin is running without it. Start a new session and it reports immediately. This looks exactly like a broken integration and isn't — it's the one rough edge worth knowing about up front.
What does the plugin actually send?
Metadata about the session: its state, the model, token counts, cost, lines changed, the todo list, and which subagents are running. Message bodies, text deltas, reasoning traces and attachments never leave OpenCode — the plugin doesn't read them. Everything it does send goes to a signed helper on the same machine, over a local socket.
Can I answer OpenCode's questions from my phone?
A free-text question, yes — type the answer on the notification and it goes straight back. Perch needs no Accessibility permission to do it, because OpenCode accepts the answer directly rather than Perch having to type it into your terminal for you. Multiple-choice questions still have to be answered in OpenCode itself.
Where do the OpenCode usage bars come from?
Your own Mac. OpenCode has no usage API to ask, so Perch adds up the per-message costs it has recorded locally and reads them against the dollar caps this integration works to — a rolling 5-hour window, the ISO week, and the month. It's labelled as an estimate because that's exactly what it is: your spend against a figure Perch carries, not a number returned by a server. It applies to opencode-go only. No cookies, no credentials, no network call.
Does it work with OpenCode over SSH?
Not yet. Perch watches OpenCode running on the Mac it's installed on; a remote SSH-hosted OpenCode is out of scope for now, as is the IDE surface. Everything on this page is about local sessions.
Does my code leave my Mac?
No. Session state, tokens, cost and usage stay local. Data leaves only for features that require it: your paired iPhone (encrypted, over your LAN or your own tailnet), the push relay, and Polar for license checks.

Running Claude Code, Codex, Cursor or Devin too? Perch watches all 5 from one menu bar.