I manage a small fleet of Linux servers and got tired of the options:
Ansible is great but not a dashboard. Grafana + Prometheus is powerful
but heavy. Checkmk and Zabbix are overkill for a handful of machines.
So I built my own.
What is RemotePower?
RemotePower is a self-hosted control plane for Linux servers. One small
Python agent per host, one nginx + CGI server, flat JSON storage. No
database, no framework, no pip dependencies — pure Python stdlib.
The agent heartbeats every 60 seconds. The dashboard auto-refreshes.
Everything just works.
What it does
Remote command execution — run commands, reboot, shutdown,
Wake-on-LAN. Batch across devices. Cron scheduling. Command library
and allowlist. Browser SSH via xterm.js.
CVE scanning — OSV.dev backed, real CVSS v3.1 scoring,
per-CVE ignore list
Patch management — pending updates across the fleet, one-click
upgrade, update history, patch alerts via webhook
Configuration drift detection — hash critical files, baseline
diffing, drift_detected webhook
Proxmox VE integration — manage QEMU VMs and LXC containers,
create and rollback snapshots, no SDK needed
Container awareness — Docker, Podman, Kubernetes
Custom monitoring scripts — write any bash check server-side,
assign it to devices, get fleet-wide pass/fail every 5 minutes.
Exit 0 = OK, anything else = FAIL. No SSH needed.
Monitoring and alerts — ping, TCP, HTTP probes, TLS/DNS expiry,
17 webhook event types (Discord, Slack, ntfy, Gotify)
AI assistant — optional LLM integration (Ollama, Anthropic,
OpenAI). Triage CVEs, prioritise patches, generate monitoring
scripts. Disabled by default, no cloud calls unless you choose one.
MCP server — lets any MCP-capable AI client query fleet state
The architecture
[ agent (Python) ] --heartbeat--> [ nginx + CGI ] --> [ flat JSON ]
Push-based. Agents reach out — the server never needs inbound access
to your hosts. The agent is a single Python file with no dependencies
beyond the standard library.
The server is the same — pure Python CGI behind nginx. Atomic file
writes throughout. The entire thing runs on a Raspberry Pi.
Why no database?
For a small-to-medium fleet, a database is overhead without benefit.
Flat JSON files are:
- Easy to back up (one file, one command)
- Easy to inspect (
cat devices.json) - Easy to version control
- Fast enough for hundreds of devices
The backup export is a single ZIP. Restore is extracting it.
Why no pip dependencies?
Every dependency is a supply chain risk, a version conflict waiting
to happen, and something that breaks on the next distro upgrade.
Python's stdlib covers everything RemotePower needs: HTTP, JSON,
cryptography (hmac, hashlib), subprocess, threading, logging.
The agent deploys as a single file copy. No virtualenv, no pip install,
no Docker required.
Custom monitoring scripts
The newest feature and probably the most useful for day-to-day ops.
You write a bash script on the server — anything you want. Check if
nginx is responding, verify a backup file is fresh, test a database
port. Assign it to any set of devices. The agent runs it every 5
minutes and reports back.
#!/bin/bash
curl -sf --max-time 10 http://localhost/ > /dev/null
echo "HTTP OK"
Exit 0 = OK. Anything else = FAIL. Edge-triggered webhooks fire on
status changes — once when it breaks, once when it recovers. No alert
fatigue.
The UI has an AI generate button — describe the check in plain English,
get a bash script back, review it, save it.
Try the demo
https://demoremote.tvipper.com
Username: demo / Password: demo
Get it
https://github.com/tyxak/remotepower
Clone, point nginx at server/, enrol a host:
git clone https://github.com/tyxak/remotepower
./client/remotepower-agent enroll
Happy to answer questions about the architecture, the no-dependency
approach, or any of the features. And if you self-host your own
servers, I'd love to know what you'd want to see next.