tutorial

Monitoring GotTY Web Terminal with Vigilmon

GotTY turns any CLI tool into a web app in one command — but a crashed Go process leaves your terminal dashboard dark. Here's how to monitor GotTY's web UI, TCP port, TLS health, and backing process with Vigilmon.

GotTY (Go + TTY) does one thing well: it takes any command and makes it accessible in a browser as a terminal. Real-time dashboards with htop, shared debugging sessions with bash, live log tailing with tail -f — all browser-accessible with a single Go binary and no runtime dependencies. But that single binary has no watchdog. When GotTY crashes or the backing command exits, users hit a dead browser tab and nobody knows why. Vigilmon gives you HTTP availability checks, TCP port probes, TLS certificate monitoring, and heartbeat confirmation that the backing command is running and serving output.

What You'll Set Up

  • HTTP uptime monitor for the GotTY web terminal UI (port 8080)
  • TCP port probe confirming the Go HTTP server is accepting connections
  • SSL certificate expiry alert for TLS-enabled GotTY deployments
  • Heartbeat monitor confirming the backing command started and the web terminal is serving

Prerequisites

  • GotTY installed and running (port 8080 by default)
  • A domain or IP address accessible from the internet (or from Vigilmon's probe network)
  • A free Vigilmon account

Step 1: Monitor the GotTY Web UI

GotTY serves the hterm/xterm.js web terminal frontend at / on port 8080. A successful GET / returns a 200 OK with the terminal HTML page, confirming the Go net/http server is running and the terminal UI is being served.

  1. Log in to vigilmon.online and click Add Monitor.
  2. Set Type to HTTP / HTTPS.
  3. Enter the URL: http://your-server:8080/ (or https://your-terminal.domain.com/ if behind a reverse proxy).
  4. Set Check interval to 1 minute.
  5. Set Expected HTTP status to 200.
  6. Optionally, set a Keyword check to GotTY or gotty to verify the page content, not just the status code.
  7. Click Save.

GotTY's default port is 8080 but is configurable via --port. If you've changed the port or bound to a custom address with --address, update the URL accordingly. The keyword check on gotty distinguishes a healthy GotTY response from an nginx error page or a different service that might be occupying port 8080.

Step 2: TCP Port Probe for the Go HTTP Server

A TCP connection check to port 8080 confirms that the Go net/http server is listening and accepting connections, independent of HTTP response content. This is useful as a fast-path check that complements the full HTTP probe.

  1. Click Add Monitor → TCP Port.
  2. Enter your server's hostname or IP.
  3. Set Port to 8080 (or the custom port GotTY is using with --port).
  4. Set Check interval to 1 minute.
  5. Click Save.

The TCP probe catches scenarios where the port is temporarily unavailable — such as when GotTY is restarting, the Go runtime is panicking and recovering, or the port binding failed silently after a system restart.

Step 3: SSL Certificate Alerts for TLS Deployments

GotTY supports native TLS via --tls --tls-cert /path/to/cert.pem --tls-key /path/to/key.pem, or you can terminate TLS at a reverse proxy (nginx, Caddy, Traefik). Either way, a certificate expiry locks everyone out of the terminal — browsers reject the connection and show a security error instead of the terminal.

Enable SSL monitoring on the HTTP monitor created in Step 1:

  1. Open the monitor for your GotTY URL.
  2. Enable Monitor SSL certificate.
  3. Set Alert when certificate expires in less than 21 days.
  4. Click Save.

For native GotTY TLS, make sure the monitored URL uses https:// and points to the GotTY port. For reverse-proxied TLS, use your domain URL. The SSL check fires independently of the HTTP status check, so you get separate alerts for "GotTY is down" versus "GotTY is up but the certificate is about to expire."

To check your certificate's current expiry from the command line:

# For native GotTY TLS
echo | openssl s_client -connect your-server:8080 2>/dev/null | openssl x509 -noout -dates

# For reverse-proxied TLS
echo | openssl s_client -connect your-terminal.domain.com:443 2>/dev/null | openssl x509 -noout -dates

Step 4: Heartbeat Monitoring for the Backing Command

GotTY executes a backing command — top, bash, htop, a custom monitoring script, or anything else. The HTTP interface can return 200 even if the backing command has exited (GotTY keeps serving the frontend HTML while waiting for new WebSocket connections), but new sessions won't get any terminal output. A Vigilmon heartbeat confirms that the backing command is actually running and the web terminal is producing output.

Create the heartbeat monitor

  1. In Vigilmon, click Add Monitor → Cron Heartbeat.
  2. Set the expected ping interval to 5 minutes.
  3. Copy the heartbeat URL: https://vigilmon.online/heartbeat/YOUR_TOKEN.

Create a wrapper script

#!/bin/bash
# /usr/local/bin/gotty-health-check.sh
# Verifies GotTY is serving the terminal UI and pings Vigilmon

GOTTY_URL="http://localhost:8080/"
HEARTBEAT_URL="https://vigilmon.online/heartbeat/YOUR_TOKEN"

# Check GotTY is responding with terminal HTML
response=$(curl -sf --max-time 5 "$GOTTY_URL")
if echo "$response" | grep -qi "gotty"; then
    curl -sf "$HEARTBEAT_URL" > /dev/null
else
    echo "GotTY health check failed — response did not contain 'gotty'"
    exit 1
fi

Schedule the check

# Add to crontab: crontab -e
*/5 * * * * /usr/local/bin/gotty-health-check.sh

Make the script executable:

chmod +x /usr/local/bin/gotty-health-check.sh

For long-running GotTY processes (e.g., a persistent htop dashboard or a bash session), combine the HTTP check with a process check:

# Check GotTY process is running
if pgrep -x gotty > /dev/null; then
    curl -sf "$HEARTBEAT_URL" > /dev/null
fi

Step 5: Configure Alert Channels

  1. Go to Alert Channels in Vigilmon and add email, Slack, or a webhook.
  2. On the HTTP monitor, set Consecutive failures before alert to 2 — GotTY restarts under a process manager may cause one missed probe.
  3. On the TCP port probe, set Consecutive failures before alert to 1 — a closed port is a hard failure, not a transient one.

If you restart GotTY to change the backing command or update the binary, use a maintenance window to avoid false alerts:

# Open a 3-minute maintenance window
curl -X POST https://vigilmon.online/api/maintenance \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -d '{"monitor_id": "YOUR_MONITOR_ID", "duration_minutes": 3}'

pkill gotty
gotty --port 8080 --tls htop &

Summary

| Monitor | Target | What It Catches | |---|---|---| | HTTP uptime | http://your-server:8080/ | GotTY process crash, Go server failure | | TCP port probe | Port 8080 | Port closed, server not accepting connections | | SSL certificate | GotTY HTTPS domain | Certificate expiry blocking browser access | | Cron heartbeat | Heartbeat URL | Backing command exit, terminal not producing output |

GotTY's single-binary, zero-dependency design is what makes it fast to deploy — and what makes it easy to overlook when monitoring. With Vigilmon watching the HTTP interface, TCP port, TLS certificate, and backing command health, you get comprehensive coverage of every layer between your users and their browser terminal.

Monitor your app with Vigilmon

Free plan — 5 monitors, no credit card required. Up and running in 60 seconds.

Start free →
← Back to all articles