convez.ai
PluginAutomaçãoIntermediário
luojiahai

Code-by-wire

luojiahai/code-by-wire

Cockpit para controlar múltiplas sessões do Claude Code localmente

Ver no GitHub
BomPluginScore · de 0 a 100

Painel 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-wire

1 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

Estrelas
74
Forks
4
Acompanhando
0
Saúde
100%
Último commit
há 5 dias
Versão
v0.1.49
Issues abertas
46
Contribuidores
2

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 | 简体中文

CI License: MIT Latest release Sponsor

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.

Download for macOS (Apple Silicon)

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

code-by-wire

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

  1. Download the latest .dmg.
  2. Open it and drag Code-by-wire to Applications.
  3. 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

License

MIT

Ver o original no GitHub

Bom para

Relacionados