Monitoring Crafty Controller with Vigilmon

Crafty Controller is an open-source Minecraft server management panel that lets you run multiple Java game servers, manage mods and plugins, schedule backups, and track players — all from a single web dashboard. When you host it yourself, you own the entire stack: if the Crafty web process dies, if a Java server process hangs, or if a backup job fails silently, no one is automatically watching. Vigilmon fills that gap, giving you uptime alerts and heartbeat monitoring for every critical piece of your Crafty deployment.

What You'll Set Up

• HTTP uptime monitor for the Crafty web dashboard
• Java game server process heartbeat
• Java process watchdog service monitor
• Backup job execution heartbeat
• Mod/plugin management API health check
• Player tracking service heartbeat
• Resource usage monitor via API
• Server start/stop scheduler monitor

Prerequisites

• Crafty Controller installed and running (Python 3.9+, web dashboard on port 8000 by default)
• At least one Minecraft Java server configured in Crafty
• A free Vigilmon account

Step 1: Monitor the Crafty Web Dashboard

The Crafty web interface is your primary control plane. If it goes down, you can't manage servers, review logs, or trigger actions.

1. Log in to vigilmon.online and click Add Monitor.
2. Set Type to HTTP / HTTPS.
3. Enter your Crafty URL: https://crafty.yourdomain.com (or http://YOUR_SERVER_IP:8000).
4. Set Check interval to 1 minute.
5. Set Expected HTTP status to 200.
6. Under Keyword match, enter Crafty to confirm the login page renders rather than showing an error.
7. Click Save.

If you run Crafty behind an nginx or Caddy reverse proxy with HTTPS, enable Monitor SSL certificate and set the alert threshold to 21 days.

Step 2: Monitor the Crafty API Endpoint

Crafty exposes a REST API at /api/v2/. Monitoring it confirms the application layer is healthy independently of the static login page.

1. Add Monitor → HTTP / HTTPS.
2. URL: https://crafty.yourdomain.com/api/v2/ (returns a JSON response with API info).
3. Expected HTTP status: 200.
4. Keyword match: crafty or version.
5. Check interval: 1 minute.

This exercises the Python web process and its internal routing without requiring authentication.

Step 3: Java Game Server Process Heartbeat

Minecraft Java servers can silently hang — the process is alive but the server is stuck in a read loop, not accepting player connections. Use Crafty's API to verify the server reports itself as running, and pair it with a direct TCP check on the game port.

TCP port monitor for the game server:

1. Add Monitor → TCP Port.
2. Host: your server's public IP or domain.
3. Port: 25565 (default Minecraft port, or your configured port).
4. Check interval: 1 minute.

API-based server status heartbeat:

Create a script that queries Crafty's server status API:

#!/bin/bash
API_KEY="YOUR_CRAFTY_API_KEY"
SERVER_ID="YOUR_SERVER_ID"
BASE_URL="https://crafty.yourdomain.com"

STATUS=$(curl -s -H "Authorization: Bearer $API_KEY" \
  "$BASE_URL/api/v2/servers/$SERVER_ID/stats" \
  | python3 -c "import sys,json; d=json.load(sys.stdin); print(d['data']['running'])" 2>/dev/null)

if [ "$STATUS" = "True" ]; then
  curl -s https://vigilmon.online/heartbeat/GAMESERVER_HEARTBEAT_ID
fi

Run it via cron every minute. In Vigilmon, set the heartbeat interval to 2 minutes.

Step 4: Java Process Watchdog Service Monitor

Crafty's internal watchdog monitors Java processes and restarts them on crash. If the watchdog service itself fails, crashed servers won't be restarted automatically.

Add a heartbeat that confirms the watchdog is active:

#!/bin/bash
# Check if the Crafty process (which includes the watchdog) is running
CRAFTY_PID=$(pgrep -f "crafty_web.py" 2>/dev/null)
if [ -n "$CRAFTY_PID" ]; then
  curl -s https://vigilmon.online/heartbeat/WATCHDOG_HEARTBEAT_ID
fi

Save it to /usr/local/bin/check-crafty-watchdog.sh, make it executable, and schedule it every minute:

* * * * * /usr/local/bin/check-crafty-watchdog.sh

In Vigilmon:

1. Add Monitor → Cron Heartbeat.
2. Expected ping interval: 2 minutes.

Step 5: Backup Job Execution Heartbeat

Crafty supports scheduled world backups. If a backup job fails — due to disk space, permission errors, or a misconfigured path — you won't know until you need the backup.

Add a ping to your backup completion hook. In Crafty's backup configuration, you can run a post-backup command. Add a curl call there:

# In Crafty's backup "run after" command field:
curl -s https://vigilmon.online/heartbeat/BACKUP_HEARTBEAT_ID

If Crafty doesn't expose a post-backup hook in your version, use a wrapper script:

#!/bin/bash
# Triggered by cron on your backup schedule
/home/crafty/crafty-4/scripts/backup.sh
if [ $? -eq 0 ]; then
  curl -s https://vigilmon.online/heartbeat/BACKUP_HEARTBEAT_ID
fi

In Vigilmon:

1. Add Monitor → Cron Heartbeat.
2. Set Expected ping interval to match your backup schedule (e.g., 1440 minutes for daily backups).
3. An alert fires if no successful backup completes within that window.

Step 6: Monitor the Mod/Plugin Management API

Crafty's mod and plugin management endpoints let you install, update, and remove server modifications. If this API becomes unavailable, mod operations fail silently.

Query the server files/mods API:

#!/bin/bash
API_KEY="YOUR_CRAFTY_API_KEY"
SERVER_ID="YOUR_SERVER_ID"

STATUS=$(curl -s -o /dev/null -w "%{http_code}" \
  -H "Authorization: Bearer $API_KEY" \
  "https://crafty.yourdomain.com/api/v2/servers/$SERVER_ID/files")

if [ "$STATUS" = "200" ]; then
  curl -s https://vigilmon.online/heartbeat/MODAPI_HEARTBEAT_ID
fi

Run this every 5 minutes via cron and set the Vigilmon heartbeat interval to 10 minutes. A longer interval is appropriate here since mod management is less time-critical than server uptime.

Alternatively, use a direct Vigilmon HTTP monitor pointed at the API endpoint with an auth header if Vigilmon supports custom request headers in your plan.

Step 7: Player Tracking Service Heartbeat

Crafty tracks connected players and reports player counts in real time. If the player tracking subsystem stalls, the dashboard shows stale data and player-based automations (like keeping a server alive while players are online) can misbehave.

Use the server stats API to confirm the player list is being updated:

#!/bin/bash
API_KEY="YOUR_CRAFTY_API_KEY"
SERVER_ID="YOUR_SERVER_ID"

ONLINE=$(curl -s \
  -H "Authorization: Bearer $API_KEY" \
  "https://crafty.yourdomain.com/api/v2/servers/$SERVER_ID/stats" \
  | python3 -c "import sys,json; d=json.load(sys.stdin); print(d['data']['online'])" 2>/dev/null)

# A valid response (even 0 players) means tracking is working
if echo "$ONLINE" | grep -qE '^[0-9]+$'; then
  curl -s https://vigilmon.online/heartbeat/PLAYERTRACK_HEARTBEAT_ID
fi

Schedule this every 2 minutes. In Vigilmon, set the heartbeat interval to 5 minutes.

Step 8: Resource Usage and Server Scheduler Monitor

Crafty reports CPU and RAM usage per server via its stats API. An unresponsive server that's consuming 100% CPU won't appear in player stats but will degrade the host. Monitor resource availability separately:

#!/bin/bash
API_KEY="YOUR_CRAFTY_API_KEY"
SERVER_ID="YOUR_SERVER_ID"

CPU=$(curl -s \
  -H "Authorization: Bearer $API_KEY" \
  "https://crafty.yourdomain.com/api/v2/servers/$SERVER_ID/stats" \
  | python3 -c "import sys,json; d=json.load(sys.stdin); print(d['data']['cpu'])" 2>/dev/null)

# Alert if CPU > 90% by NOT sending heartbeat
if echo "$CPU" | python3 -c "import sys; v=float(sys.stdin.read()); sys.exit(0 if v < 90 else 1)" 2>/dev/null; then
  curl -s https://vigilmon.online/heartbeat/RESOURCES_HEARTBEAT_ID
fi

For the server start/stop scheduler, confirm Crafty's task scheduler is running by checking a scheduled task's last-executed timestamp via the API. If your version exposes scheduled task data:

#!/bin/bash
API_KEY="YOUR_CRAFTY_API_KEY"
TASKS=$(curl -s -o /dev/null -w "%{http_code}" \
  -H "Authorization: Bearer $API_KEY" \
  "https://crafty.yourdomain.com/api/v2/tasks/")

if [ "$TASKS" = "200" ]; then
  curl -s https://vigilmon.online/heartbeat/SCHEDULER_HEARTBEAT_ID
fi

Set the heartbeat interval to 10 minutes.

Step 9: Configure Alert Channels

1. Go to Alert Channels in Vigilmon and add your preferred channel (Discord webhook works well for gaming communities, Slack, or email).
2. Set Consecutive failures before alert to 2 for the web dashboard monitor to avoid alerts during rolling restarts.
3. Set it to 1 for the game server TCP monitor and backup heartbeat — player-facing outages and missed backups are always urgent.
4. Use Maintenance windows to suppress alerts when you're deliberately taking Crafty or a game server offline for updates.

Summary

| Monitor | Target | What It Catches | |---|---|---| | Crafty web dashboard | https://crafty.yourdomain.com | Python process crash, web error | | Crafty API | /api/v2/ | Application layer failure | | Game server TCP | :25565 | Java server unreachable | | Game server API heartbeat | Stats API script | Server hung, not accepting connections | | Watchdog heartbeat | Process check script | Crafty process crash, auto-restart broken | | Backup heartbeat | Post-backup ping | Backup job failure, disk full | | Mod API heartbeat | Files API script | Mod management API unavailable | | Player tracking heartbeat | Stats API script | Player data stale, tracking broken | | Resource heartbeat | CPU check script | Server pegged at 100% CPU | | Scheduler heartbeat | Tasks API script | Cron scheduler not running |

Crafty Controller puts serious Minecraft server management power in your hands — but that power comes with the responsibility of watching your own infrastructure. With Vigilmon monitoring every layer from the web dashboard to Java process health and backup completion, your game servers stay reliable for the players counting on them.