Code-by-wire
luojiahai/code-by-wire
Cockpit para controlar múltiplas sessões do Claude Code localmente
Ver no GitHubPainel de controle unificado para gerenciar e monitorar sessões locais do Claude Code. Lê o histórico de execução e oferece visualização em tempo real de estado, transcrição completa, terminal integrado e telemetria de custos e contexto.
Instalação
npx convez-ai luojiahai/code-by-wire1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.
Métricas
Casos de uso
- Monitorar múltiplos agentes de IA em execução simultânea
- Acompanhar uso de tokens, contexto e custos de operação
- Retomar sessões interrompidas com acesso a histórico completo
Veredito

Ferramenta sólida para quem trabalha intensivamente com Claude Code. O painel unificado resolve bem o problema de rastrear múltiplas sessões, mas é altamente específico do ecossistema Anthropic — útil principalmente para desenvolvedores que usam Claude Code em fluxo local.
README
A tradução para o português deste README ainda está na fila.
Code-by-wire (CBW)
English | 简体中文
The cockpit for local Claude Code.
Claude Code runs in your terminal and writes a rich trail to ~/.claude as it
works: every turn, every token, every tool call, the running cost, the context
window. The CLI shows you almost none of it. A statusline is one line at the
bottom of one terminal, and the moment a second session is running it's already
not enough.
Code-by-wire reads that trail and turns it into one live dashboard. Every Claude Code session on your machine in one place: live state, the full transcript, an embedded terminal to drive or take over, and the cost, context, and usage telemetry the terminal never shows you. One pane instead of a dozen terminal windows.
The name
Fly-by-wire didn't take the plane away from the pilot. It put a computer between the stick and the control surfaces, so the pilot commands intent and the machine handles execution. The pilot still flies, just more capable and more precise.
Code-by-wire is that idea for software. You command intent, the agent executes, and you stay pilot in command: live state, the full transcript, and the controls to take over whenever you want.
Preview

Features
Code-by-wire reads everything Claude Code writes under ~/.claude and turns it
into one live dashboard. Nothing to set up: open the app and every session
already running on your machine is there.
👀 See every session at a glance
One rail, every session. The left rail lists every Claude Code session on your machine, one row each. A filter box narrows the list as you type.
Grouped by what needs you. Rows are grouped by state in priority order: Waiting → Working → Idle → Ended, each group with a sticky header and a live count. Ended is collapsed by default. It's the archive, not the live work.
🕹️ Drive or watch any session
Spawn a managed session. Pick a directory and a model, and Code-by-wire
starts claude there and drives it from a live terminal embedded in the
workspace.
Observe the rest. A session you started anywhere else shows up read-only: full state and transcript, but no input, because two processes writing one transcript would corrupt it.
Adopt when it ends. Once an observed session ends, adopt it to resume it inside the app and take the controls. The button appears only once the original process is gone, which is the only time it's safe.
Terminal or transcript. A managed session toggles between its live terminal and the rendered transcript. Switching away only detaches the view. The terminal keeps buffering, so you never lose scrollback.
📜 Read exactly what the agent did
The full transcript. Every message, tool call, and tool result, reconstructed from the raw transcript on disk and rendered cleanly, step by step.
Turn timeline. Below the live view, a turn-by-turn strip: each prompt you sent, how many tools it triggered, how long the turn ran, and how long ago it started.
📊 The telemetry Claude Code keeps out of sight
A right-hand rail of live panels:
- Context. How full the window is, as a ring toward the ceiling, using Claude's own number when it reports one. The session rail also flags any session whose context is running high.
- Cost. The session's spend, with a donut of where it went by token kind and how much the prompt cache saved. On a subscription account this is equivalent API value: what the tokens would cost at API rates. A reference figure, never money owed.
- Tokens. Input, output, and cached totals as a stacked bar.
- Token speed. Live throughput, output and input rates over a rolling window.
- Git. Branch, lines added and removed, ahead/behind, current SHA, and working-tree status. Hidden when the directory isn't a repo.
- Tasks. The session's task list with each item's status and what it's blocked by.
- Subagents. The tree of child sessions a session spawned, nested by depth.
- Session. Model, effort level, and the run clock.
📈 The whole story across every session
Overview is where the app opens. Pinned to the top of the rail, it's an app-level view that totals every Claude Code session on your machine, not just the one you're watching. Pick a range: Today, 7d, 30d, 90d, or All.
Headline numbers. Sessions, turns, tokens, and equivalent API value for the range, with a stacked bar of where the tokens went.
A contributions calendar. A year of activity as a heatmap, colored by turns, tokens, or equivalent API value. Click any day to scope the whole page to it.
Daily usage. One stacked bar per day, split by token kind or by model.
Three ways to slice it. By model, by project with each project's branches folded in, and by session in a sortable table. An Include cache toggle decides whether cached tokens count toward the totals.
Exact, never estimated. Every number is read straight from the transcripts on disk, deduped and totalled. No sampling, no guesses. The first launch backfills your history behind a progress bar, then it stays live like everything else.
💳 Know your account
The rail header reads your account straight from ~/.claude. On a subscription
(Pro or Max) it shows your plan and rate-limit gauges with live reset
countdowns, so you can see how close you are to a wall. On an API account it
shows the endpoint host and plan. The app works out which from whether your
sessions report rate limits, and shows cost the right way for each.
Install
Download the prebuilt app, or build it yourself.
Download
- Download the latest
.dmg. - Open it and drag Code-by-wire to Applications.
- Launch it. The app is signed and notarized by Apple, so it opens straight away, no Gatekeeper warning and no quarantine workaround.
Build from source
Build an unsigned .dmg locally instead:
pnpm install
pnpm rebuild:native # rebuild better-sqlite3 + node-pty for Electron's ABI
pnpm dist # writes the .dmg to release/
Open the .dmg from release/ and drag Code-by-wire to Applications. Because
it's unsigned, the first launch may need a right-click → Open, or clearing
the quarantine flag:
xattr -dr com.apple.quarantine /Applications/Code-by-wire.app
Requirements
- macOS (Apple Silicon)
- Claude Code installed locally, so there are sessions to observe and control
Develop
pnpm install
pnpm rebuild:native # rebuild better-sqlite3 + node-pty for Electron's ABI
pnpm dev # launch the app
pnpm test runs the provider read tests over the redacted ~/.claude fixtures
in tests/fixtures/. pnpm typecheck checks the main and renderer projects.
See CONTRIBUTING.md to get started.
Project layout
src/
main/ Electron main process: providers, db, git, terminal, sync
preload/ the IPC bridge
renderer/ React UI (session list, workspace panels, terminal)
shared/ types and helpers shared across processes