8.1 KiB

Raw Blame History

Mission Control

A monitoring dashboard for OpenClaw AI agents — built with Python/FastAPI and Next.js.

Why This Exists

When you run OpenClaw seriously — multiple agents, dozens of cron jobs, sub-agents spawning sub-agents, several Telegram groups and WhatsApp, Slack, and Discord channels, 10+ models — information gets scattered fast.

The problem: there was no single place to answer the obvious questions:

Is my gateway actually running right now?
How much have I spent today, and which model is burning the most?
Which cron jobs ran, which failed, and when does the next one fire?
What sessions are active and how much context are they consuming?
Are my sub-agents doing useful work or spinning in circles?
What's the cost trend over the last 7 days — am I accelerating?

The solution: a single dashboard that collects everything in one place — gateway health, costs, cron status, active sessions, sub-agent runs, model usage — refreshed automatically, org-scoped, no login required for local development. Open a browser tab, get the full picture in seconds.

It's not trying to replace the OpenClaw CLI or Telegram interface. It's the at-a-glance overview layer that tells you whether everything is healthy and where your money and compute are going — so you can make decisions without hunting for data.

Features

6 Core Monitoring Panels

💰 Cost Cards & Breakdown — Today's cost, all-time cost, projected monthly, per-model cost breakdown with 7d/30d/all-time tabs. Know exactly which model is burning your budget.
💚 System Health — Gateway status (online/offline), PID, uptime, memory, compaction mode, CPU/RAM/swap/disk gauges. See at a glance whether your gateway is healthy.
⏰ Cron Jobs — All scheduled jobs with status, schedule, last/next run, duration, model. Spot failures instantly and see when the next fire is.
📡 Active Sessions — Recent sessions with model, type badges (DM/group/cron/subagent), context % bars, token counts. See who's consuming what.
🤖 Sub-Agent Activity — Sub-agent runs with cost, duration, status + token breakdown (7d/30d tabs). Know whether sub-agents are productive or spinning.
📈 Cost Trends — Cost trend line over 7d/30d, model cost breakdown bars, acceleration indicators. Catch spending spikes before they hurt.

Architecture

Backend: Python/FastAPI + PostgreSQL + Redis
Frontend: Next.js 16 + React 19 + Tailwind CSS + shadcn/ui
Data collection: Background gateway collector polling OpenClaw RPC endpoints
Real-time: WebSocket endpoint for live agent events
Data processing: Pure Python functions ported from Go dashboard logic (model name normalization, daily chart aggregation, alert computation, token formatting)

API Endpoints

Monitoring Summary Endpoints

Endpoint	Method	Description
`/api/v1/monitoring/cost-summary`	GET	Today's cost, all-time cost, projected monthly
`/api/v1/monitoring/cost-breakdown`	GET	Per-model cost breakdown (7d/30d/all)
`/api/v1/monitoring/health-summary`	GET	Gateway status, system metrics, health gauges
`/api/v1/monitoring/cron-summary`	GET	Cron job statuses, schedules, run history
`/api/v1/monitoring/sessions-summary`	GET	Active sessions with model, context %, tokens
`/api/v1/monitoring/sub-agents-summary`	GET	Sub-agent runs with cost, duration, status
`/api/v1/monitoring/trends`	GET	Cost trends, model breakdown (7d/30d)

Monitoring CRUD Endpoints

Endpoint	Method	Description
`/api/v1/monitoring/cost-snapshots`	GET	Paginated cost snapshot records
`/api/v1/monitoring/cron-jobs`	GET	Paginated cron job status records
`/api/v1/monitoring/sessions`	GET	Paginated session event records
`/api/v1/monitoring/health`	GET	Paginated system health metrics
`/api/v1/monitoring/sub-agents`	GET	Paginated sub-agent run records

WebSocket

Endpoint	Description
`/ws/agents`	Real-time agent events (initial snapshot + polling)

Gateway RPC Integration

The collector service polls these OpenClaw gateway RPC endpoints:

usage.cost + usage.status → Cost snapshots
cron.list → Cron job status
sessions.list + sessions.preview → Session events
health + status → System health metrics

Quick Start

Docker Compose (Recommended)

git clone https://forgejo/null/Mission-Control.git
cd Mission-Control
cp .env.example .env
docker compose up -d

The backend runs on port 8080, frontend on port 3037.

Environment Variables

Variable	Default	Description
`COLLECTION_INTERVAL_COST`	300	Seconds between cost collection
`COLLECTION_INTERVAL_CRON`	60	Seconds between cron collection
`COLLECTION_INTERVAL_SESSION`	30	Seconds between session collection
`COLLECTION_INTERVAL_HEALTH`	60	Seconds between health collection
`LOCAL_AUTH_TOKEN`	—	Token for local dev auth
`POSTGRES_HOST`	db	PostgreSQL host
`POSTGRES_PORT`	5432	PostgreSQL port
`POSTGRES_DB`	mission_control	Database name
`REDIS_URL`	redis://redis:6379/0	Redis connection URL

Project Structure

Mission-Control/
├── src/
│   ├── backend/
│   │   ├── app/
│   │   │   ├── api/           # API routes (monitoring, ws, gateways, etc.)
│   │   │   ├── models/        # SQLModel database models
│   │   │   ├── schemas/       # Pydantic request/response schemas
│   │   │   ├── services/
│   │   │   │   └── monitoring/
│   │   │   │       ├── gateway_collector.py  # Background RPC collector
│   │   │   │       ├── data_processing.py    # Dashboard data transforms
│   │   │   │       ├── event_parser.py       # Session event parser
│   │   │   │       └── models.py            # Pydantic RPC response models
│   │   │   └── main.py        # FastAPI app + lifespan
│   │   ├── migrations/        # Alembic migrations
│   │   └── tests/
│   └── frontend/              # Next.js app
│       └── src/
│           ├── app/            # Next.js App Router pages
│           ├── components/     # React components
│           ├── api/            # Generated API clients
│           └── lib/            # Utilities
├── sources/                    # Reference repos (Go, Node)
├── docker-compose.yml
├── Dockerfile
└── PROJECT.md                  # Full 4-phase implementation plan

Data Collection Flow

OpenClaw Gateway
       │
       │ RPC (usage.cost, cron.list, sessions.list, health, status)
       ▼
GatewayCollectorService (background asyncio task)
       │
       │ Upsert into PostgreSQL
       ▼
Monitoring Models (CostSnapshot, CronJobStatus, SessionEvent, SubAgentRun, SystemHealthMetric)
       │
       │ API endpoints + data_processing transforms
       ▼
Dashboard Frontend (Next.js)
       │
       │ WebSocket for real-time events
       ▼
Live Agent Activity Panel

Source Repos

Mission Control ports functionality from two OpenClaw dashboard projects:

openclaw-dashboard (Go) — Dashboard panels, data processing logic, alert computation
openclaw-pixel-agents-dashboard (Node/Express) — Pixel agent visualization, session watching, event parsing

Key decision: No new backend languages. Go and Node functionality ports to Python/FastAPI within Mission Control's backend. We reuse the gateway RPC transport and data model shapes, but port all processing/aggregation logic as pure Python functions.

Development

# Backend
cd src/backend
pip install -r requirements.txt
uvicorn app.main:app --reload --port 8080

# Frontend
cd src/frontend
npm install
npm run dev

License

MIT

8.1 KiB Raw Blame History