convez.ai
AgenteProdutividadeIntermediário
ronle

Clayrune – Dashboard de Gerenciamento Multi-Projeto

ronle/clayrune

Orquestre múltiplos agentes Claude Code a partir de uma interface unificada

Ver no GitHub
InicialPluginScore · de 0 a 100

Dashboard centralizado para coordenar, despachar e monitorar agentes Claude Code em múltiplos projetos simultaneamente. Oferece rastreamento em tempo real, sincronização com GitHub Issues, gerenciamento de backlog, agendamento de tarefas automatizadas e análise de uso de tokens.

Instalação

$npx convez-ai ronle/clayrune

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
17
Forks
2
Acompanhando
0
Saúde
42%
Último commit
há 1 dia
Versão
v2.4.8
Issues abertas
0
Contribuidores
1

Casos de uso

  • Coordenar tarefas de codificação em paralelo em vários projetos
  • Monitorar e controlar agentes de IA via painel centralizado com janelas multi-modais
  • Sincronizar backlogs com GitHub Issues e agendar execuções automatizadas
  • Acompanhar consumo de tokens e custos de operação entre sessões e agentes

Veredito

Ferramenta madura e bem estruturada para quem precisa orquestrar múltiplos agentes Claude em escala. Prático para times que usam Claude Code em diversos projetos, com instalador one-click e interface intuitiva; requer familiaridade com Claude CLI e Python para customizações mais profundas.

README

A tradução para o português deste README ainda está na fila.

Clayrune

A multi-project management dashboard for Claude Code agents. Manage, dispatch, and monitor AI coding agents across all your projects from a single interface.

What It Does

Clayrune gives you a centralized dashboard to:

  • Manage multiple projects with status tracking, descriptions, and domains
  • Dispatch Claude Code agents to work on tasks across any project
  • Reuse previous chat sessions under same project for reducing overall token usage
  • Monitor agent activity in real-time via streaming output
  • Maintain project backlogs with priorities, drag-and-drop ordering, and file attachments
  • Schedule automated tasks with once, daily, or interval-based triggers
  • Sync backlogs with GitHub Issues — bidirectional sync via gh CLI
  • Track token usage and costs across all sessions with time-range filtering
  • Open multiple project windows simultaneously (multi-modal windowing system) — open conversations and their layouts persist across page refresh and reboot
  • Manage from any device via the clayrune.io tunnel — including a one-click server restart from your phone after deploying changes
  • View agent plans in a dedicated wide-format viewer
  • Share baseline rules across all projects (SHARED_RULES.md)
  • Arrange project tiles freely on a grid (Android home screen style)
  • First-run walkthrough tour guides new users through the interface

Quick Start (Windows)

  1. Download the installer from clayrune.io (Clayrune-Installer.exe)
  2. Double-click it and follow the prompts

The installer sets up Claude CLI, clones Clayrune, installs dependencies, and drops a Desktop/Start Menu shortcut. First launch opens the dashboard at http://localhost:5199.

Prefer running from source instead? See Running from Source below.

Prerequisites (from source only)

If you prefer running from source instead of the prebuilt exe:

Running from Source

Option A: Desktop Window

git clone https://github.com/ronle/clayrune.git
cd mission-control
pip install -r requirements.txt
python app.py

Opens a native window with the dashboard. Flask server runs in the background.

Option B: Browser Only

git clone https://github.com/ronle/clayrune.git
cd mission-control
pip install flask
python server.py
# Open http://localhost:5199 in your browser

First run: the in-app Settings panel walks you through the port, project directory, agent model, and other settings — no setup script needed.

Prefer a guided, no-clone install? Use the one-click installer at clayrune.io (Windows .exe / macOS / Linux), which drives the whole setup for you.

Configuration

On first run, a config.json file is created with defaults:

{
  "port": 5199,
  "shared_rules_path": "data/SHARED_RULES.md",
  "projects_base": "/home/you",
  "agent_model": "",
  "agent_max_turns": 0,
  "use_streaming_agent": false,
  "user_name": "",
  "agent_name": ""
}
SettingDescriptionDefault
portServer port5199
shared_rules_pathPath to shared rules file (injected into all agent prompts)data/SHARED_RULES.md
projects_baseBase directory for project path validationUser home directory
agent_modelDefault Claude model for all projects"" (CLI default)
agent_max_turnsMax agent turns per session (0 = unlimited)0
use_streaming_agentEnable Mode B persistent agent processfalse
user_nameYour name (shown in agent context)""
agent_nameAgent display name""

You can also set the port via environment variable: MC_PORT=8080 python server.py

Features

Project Dashboard

  • Tile-based overview of all projects with status indicators (Active, Waiting, Blocked, Parked)
  • Snap-to-grid tile arrangement — drag tiles to any position, leave gaps, swap tiles
  • Domain categorization with customizable colors
  • Per-project accent color theming
  • Activity stream across all projects
  • Filter by status or domain
  • Compact button to remove grid gaps

Agent Management

  • Dispatch tasks to Claude Code agents with one click
  • Real-time streaming output with syntax highlighting
  • Send follow-up messages to running or idle agents
  • Multiple concurrent agent sessions per project
  • Stop/resume agent sessions
  • Paste screenshots directly into agent prompts
  • Per-project model selection (Sonnet 4.5, Opus 4.6, Haiku 4.5)
  • Interactive question forms when agents call AskUserQuestion
  • Plan approval button for agents stuck in ExitPlanMode
  • Token usage and cost tracking per session
  • Live elapsed timer for running sessions

Agent Modes

  • Mode A (default): Spawns a new claude process per turn. Follow-ups queue and auto-dispatch.
  • Mode B (use_streaming_agent: true): Persistent process with --input-format stream-json. Follow-ups write directly to stdin for faster responses. Process stays alive between turns.

Scheduler

  • Automate agent dispatch on a schedule
  • Three schedule types: Once (specific datetime), Daily (time + day-of-week), Interval (every N minutes)
  • Enable/disable individual schedules
  • Upcoming jobs banner shows next 5 scheduled tasks

Backlog

  • Per-project task backlog with priorities (low/normal/high/critical)
  • Drag-and-drop reordering
  • File attachments with drag-and-drop upload
  • Mark items done/reopen
  • Dispatch backlog items directly to an agent session
  • GitHub Issues sync (bidirectional)

GitHub Issues Sync

  • Connect any project to a GitHub repository (owner/repo)
  • Backlog items sync with GitHub Issues in both directions
  • Priority labels mapped automatically (high/medium/low)
  • Open/closed status synchronized
  • Manual sync button or automatic sync every 5 minutes
  • Requires gh CLI for authentication

Plan Viewer

  • Agent plans open in a dedicated wider window for easier reading
  • Auto-detection of plan mode output
  • Plans History tab shows all historical plans per project
  • Pop-out button for viewing any agent output in a larger window
  • Ctrl+scroll zoom support

Memory

  • Per-project persistent memory using Claude Code's native MEMORY.md
  • Memory content injected into agent context automatically
  • Auto-memory: session summaries appended on completion
  • Shared between Clayrune and direct Claude CLI usage

Multi-Window System

  • Open multiple project modals simultaneously
  • Drag, resize, minimize, and restore windows
  • Keyboard navigation (Escape to close)
  • Minimized tray at bottom of screen
  • Touch support: drag, resize, and pinch-to-zoom on mobile devices

Token Tracking

  • Global token counter in header (input/output tokens + USD cost)
  • Click to filter by time range: All Time, Today, This Week, This Month
  • Per-session token badge after completion

Walkthrough Tour

  • 18-step guided tour for new users
  • Auto-triggers on first run (zero projects)
  • Re-triggerable via "Tour" button in header
  • Virtual demo tile and modal shown during tour

Architecture

mission-control/
  app.py                 Desktop entry point (pywebview + Flask)
  server.py              Flask backend (API + static serving)
  github_sync.py         GitHub Issues sync module
  static/
    index.html           Single-page app (HTML + CSS + JS, no build step)
  data/
    projects/            Project JSON files (auto-created)
    uploads/             File attachments
  config.json            User configuration (auto-created, gitignored)
  installer/             Hosted one-click installer (clayrune.io)
  • Backend: Python Flask server on configurable port (default 5199)
  • Frontend: Vanilla HTML/CSS/JS single-page app (no framework, no build step)
  • Data: JSON files on disk (no database required)
  • Agent: Spawns claude CLI as subprocess with streaming JSON output
  • Desktop: Native window via pywebview (WebView2); run python app.py from source

Contributing

Contributions are welcome! Here's how to get started:

  1. Fork the repository
  2. Create a feature branch: git checkout -b feature/my-feature
  3. Make your changes
  4. Test locally: python server.py and verify in browser
  5. Submit a pull request

Development Notes

  • The entire frontend is in a single static/index.html file — no build step needed
  • The server is a single server.py file with Flask
  • GitHub sync logic is in github_sync.py (imported by server.py)
  • Data is stored as JSON files in data/projects/
  • Agent sessions use Server-Sent Events (SSE) for real-time streaming
  • The claude CLI is invoked via subprocess.Popen with --output-format stream-json

License

MIT — except two source-available-but-proprietary directories:

PathLicense
Everything else (core: server.py, static/, github_sync.py, mc_remote_iface/, …)MIT
mc_remote/Proprietary — see mc_remote/PROPRIETARY.md
mc_tunnel/Proprietary — see mc_tunnel/PROPRIETARY.md

mc_remote + mc_tunnel are the closed platform-binding moat for clayrune.io; they live in this repo for build convenience but are not MIT. The open-core seam is mc_remote_iface/ (MIT) — implement that contract to plug in your own remote-access provider without touching the proprietary modules. Rationale: docs/remote-access/07-licensing.md.

Ver o original no GitHub

Bom para

Relacionados