Stop Wrestling with Ubuntu Servers! Use st CLI Instead

Stop Wrestling with Ubuntu Servers! Use st CLI Instead

You know the drill. It's 2 AM. Your production VPS just threw another cryptic error. You're SSH'd in, frantically Googling apt-get flags you swore you'd memorize, copy-pasting Docker^{↗ Bright Coding Blog} commands from Stack Overflow, and praying your backup script actually ran last night. Your terminal history looks like a battlefield of half-remembered flags, sudo passwords, and desperate ls commands. Sound familiar?

Here's the brutal truth: managing headless Ubuntu servers hasn't evolved much since 2010. We're still cobbling together bash aliases, maintaining brittle dotfiles across ten machines, and pretending that history | grep docker is a valid workflow. Meanwhile, our servers grow more complex—Docker stacks, Tailscale meshes, Restic backup schedules, Telegram alerting. The cognitive load is insane.

But what if I told you there's a secret weapon that top DevOps^{↗ Bright Coding Blog} engineers are quietly adopting? A single, modular CLI that replaces your entire server management toolbox? Enter server-tools—the st command that's about to make your server admin life effortlessly smooth.

Built with Bashly and designed for real-world pain points, st isn't just another bash alias collection. It's a modern, extensible command framework that transforms how you interact with headless Ubuntu servers. And the best part? It installs in seconds with a single curl command. Ready to never lose another night to server wrestling? Let's dive deep.

What is server-tools (st)?

Server Tools (st) is a lightweight, modular CLI application created by Shrikshel and built on top of the Bashly framework—a Ruby-powered CLI generator that produces clean, maintainable bash scripts with proper argument parsing, help generation, and subcommand routing.

Unlike traditional server management tools that demand heavy dependencies or agent installations, st is pure bash brilliance. It requires nothing more than Bash 4+ and sudo privileges on your Ubuntu or Debian-based system. No Python^{↗ Bright Coding Blog} virtual environments. No Node.js version conflicts. No bloated control panels eating your RAM.

The project is currently under active development (with a fair warning that production use should wait until v1.0.0), but its feature set already rivals tools that have been around for years. What makes st genuinely exciting is its philosophy of composability: every major server management domain gets its own subcommand namespace with intuitive aliases, while the underlying architecture makes adding new capabilities straightforward.

The trending factor? In an era where developers increasingly manage their own VPS instances, homelab servers, and edge deployments, st hits a sweet spot between simplicity and power. It doesn't try to be Ansible or Terraform—it's the daily driver you actually reach for when you need to update packages, check disk health, or spin up a tmux session at 3 AM.

Key Features That Make st Irresistible

🔄 One-Command System Maintenance

Forget sudo apt update && sudo apt upgrade -y memorization. st system update-upgrade handles it. Need SMART data for your SSD? st system smart. The system namespace consolidates everything you'd typically dig through man pages to find.

📦 Curated Software Installation

Docker, btop, eza, neofetch, ncdu, duf, vnstat, ufw, bat, rclone, restic, resticprofile—all installable via st install <package>. No more hunting for GPG keys, repository URLs, or install scripts. The uninstall symmetry (st uninstall <package>) means your system stays clean.

🎨 Human-Readable Output

Color-coded, formatted output transforms dense command responses into scannable information. Your eyes will thank you during 2 AM incident response.

🐳 Docker & Compose Management

The st docker namespace goes beyond basic container commands. Stop all running containers (st dc c stop), start all stopped ones (st dc c start), or manage entire Compose stacks (st dc c ms). The alias system (st dc c for st docker compose) saves serious keystrokes.

☁️ Backup & Cloud Integration

Native rclone and restic support with dry-run capabilities (st rc ds before st rc s) prevents catastrophic sync mistakes. Resticprofile integration brings structured backup profiles to casual users.

🔒 Tailscale VPN Control

WireGuard-powered mesh networking with st tailscale up/down/status. Perfect for securing homelab access or creating private admin backchannels.

💬 Telegram Alerting

Built-in notification system via st telegram send and st telegram send-file. Requires only ST_TELEGRAM_BOT_TOKEN and ST_TELEGRAM_CHAT_ID environment variables—no complex webhook infrastructure.

🖥️ Tmux Session Management

Create, attach, list, kill sessions, or pull up a cheatsheet. The st tmux namespace finally makes tmux accessible without memorizing its notorious key combinations.

🧩 Extensible Bashly Architecture

Because it's built with Bashly, adding new commands means editing YAML definitions and regenerating. The modular structure invites contributions without bash scripting expertise.

Real-World Use Cases Where st Dominates

Scenario 1: The Solo Developer with a Side Project VPS

You run a small app on a $5 DigitalOcean droplet. Previously, updating the system meant SSH in, run updates, check Docker, maybe restart services. With st:

st sys updu && st dc c restart && st telegram send --message "Deploy complete ✅"

One line. Updates, container restart, confirmation sent to your phone.

Scenario 2: The Homelab Enthusiast's Backup Ritual

Your NAS runs Ubuntu with rclone to Backblaze B2 and restic to local storage. Before st, you maintained separate cron jobs with different logging. Now:

st rc ds  # Verify what rclone would sync
st rs snap  # Check restic snapshot health
st rp s default  # Review resticprofile configuration

Interactive, verifiable, consistent.

Scenario 3: The Freelancer Managing Client Servers

Five clients, five servers, five different "standard" setups. st's configuration file (~/.config/.st.conf) and uniform command structure mean you SSH into any server and use identical workflows. The st ui TUI menu (powered by gum) even provides visual navigation for less terminal-confident team members.

Scenario 4: The DevOps On-Call Engineer

3 AM page: disk full on a critical service. Traditional response: df -h, du -sh /*, manual hunting. With st:

st sys disk  # Immediate visual breakdown
st sys smart  # Check if SSD degradation is the root cause
st sc logs nginx  # Service logs in one command

Faster diagnosis, faster resolution, faster back to sleep.

Scenario 5: The Security-Conscious Admin

Tailscale for zero-trust network access, UFW for firewall rules, SSH key management—all within st. Rotate keys with st ssh keygen, verify VPN status with st ts s, audit installed tools with st tools.

Step-by-Step Installation & Setup Guide

Prerequisites

• Ubuntu or Debian-based Linux distribution
• Bash 4.0 or higher (bash --version to check)
• sudo privileges
• curl for installation

Quick Install (Recommended)

# One-liner installation from GitHub
curl -sL https://raw.githubusercontent.com/Shrikshel/server-tools/main/scripts/install.sh | bash

This downloads and executes the official install script, which:

1. Detects your system architecture
2. Downloads the appropriate st binary
3. Installs to /usr/local/bin (or equivalent)
4. Sets executable permissions
5. Verifies installation

Verify Installation

st --version  # Should display version information
st --help     # Shows top-level command structure

Configuration Setup

Create your configuration file:

# Create config directory if needed
mkdir -p "$HOME/.config"

# Edit configuration
nano "$HOME/.config/.st.conf"

Example configuration:

# ~/.config/.st.conf
# Disable colored output for logging/CI environments
NO_COLOR=1

# Or keep colors for interactive use (default)
# NO_COLOR=0

For custom config paths:

export ST_CONFIG_FILE="/etc/server-tools/production.conf"

Telegram Integration Setup

For alerting capabilities, set environment variables:

# Add to ~/.bashrc or ~/.profile for persistence
export ST_TELEGRAM_BOT_TOKEN="123456789:ABCdefGHIjklMNOpqrsTUVwxyz"
export ST_TELEGRAM_CHAT_ID="-1001234567890"

Verify with:

st telegram send --message "Server Tools is online! 🚀"

Optional: Install gum for TUI Menu

sudo apt install gum -y
# Now st ui launches interactive menu

Uninstallation

curl -sL https://raw.githubusercontent.com/Shrikshel/server-tools/main/scripts/uninstall.sh | bash

REAL Code Examples from the Repository

Let's examine actual usage patterns from the server-tools documentation, with detailed explanations of how each command works in practice.

Example 1: System Maintenance Workflow

# The classic update-upgrade sequence, simplified
st system update-upgrade

Before st, this required:

sudo apt update && sudo apt upgrade -y && sudo apt autoremove -y

The st version wraps this with progress indication, error handling, and formatted output. The alias st sys updu makes it even faster. For routine maintenance, combine with Telegram notification:

# Full maintenance with confirmation
st sys updu && st telegram send --message "$(hostname) maintenance complete at $(date)"

This pattern is idempotent and safe—run it via cron with confidence.

Example 2: Docker Compose Stack Management

# Stop all running containers across all projects
st docker compose stop-all
# Alias: st dc c stop

# Start all stopped containers  
st docker compose start-all
# Alias: st dc c start

# Interactive stack management
st docker compose manage-stacks
# Alias: st dc c ms

Why this matters: Traditional Docker Compose management requires navigating to each project directory and running docker compose down/up. With multiple projects (reverse proxy, databases, applications), this becomes tedious. st's stop-all and start-all operate globally across all detected Compose files, while manage-stacks provides interactive selection.

The alias architecture deserves attention: st docker compose stop-all → st dc c stop follows a progressive abbreviation pattern. Learn the full command first, then graduate to muscle-memory shortcuts.

Example 3: Restic Backup with Safety Checks

# Step 1: Verify repository health
st restic check
# Alias: st rs chk

# Step 2: List existing snapshots
st restic snapshots
# Alias: st rs snap

# Step 3: Full snapshot details
st restic snapshots --full

# Step 4: Restore specific snapshot to target
st restic restore <snapshot-id> /path/to/restore
# Alias: st rs rst <id> <target>

The critical insight: Restic's power comes with complexity. The forget --prune flags, repository initialization, and snapshot selection confuse newcomers. st encapsulates best practices—the check before operations, the --dry-run equivalents, the consistent alias patterns.

For production backups, wrap in a script:

#!/bin/bash
# /usr/local/bin/backup.sh
set -euo pipefail

st rs chk                    # Verify repo
st rp s daily                # Show profile config
# Actual backup via resticprofile
resticprofile -n daily backup
st tg s --message "✅ Backup complete: $(st rs snap | tail -1)"

Example 4: Network Diagnostics Suite

# Quick network overview
st network interfaces
# Alias: st net ifs

# Physical link speed verification
st network linkspeed
# Alias: st net speed

# Internet performance test
st network speedtest
# Alias: st net st

# IP information for troubleshooting
st network publicip    # External IP
st network localip     # Internal IP
st network wifiinfo    # Wireless details

Practical application: When a user reports "the server is slow," run st net st for baseline bandwidth, st net speed to verify NIC negotiation (is that 1Gbps link running at 100Mbps?), and st net ifs to check for interface errors. The colored, formatted output means you can screenshot results for stakeholders without manual cleanup.

Example 5: SSH Key Generation with Proper Defaults

# Generate new SSH key pair with modern algorithm
st ssh keygen
# Alias: st s k

While the README doesn't specify exact parameters, st's design philosophy suggests this likely generates Ed25519 keys with appropriate comment formatting—eliminating the common mistake of RSA-2048 generation or missing -C "$(whoami)@$(hostname)-$(date +%Y-%m-%d)" comments that make key management chaotic.

Advanced Usage & Best Practices

Master the Alias System

The progressive abbreviation pattern (st docker compose → st dc c) rewards fluency. Start explicit, then optimize. Your .bash_history will shrink dramatically.

Environment-Based Configuration

Use ST_CONFIG_FILE to maintain server-specific configs:

# In /etc/profile.d/server-tools.sh
export ST_CONFIG_FILE="/etc/st/$(hostname).conf"

Cron Integration with Telegram

# /etc/cron.weekly/maintenance
0 3 * * 0 /usr/local/bin/st sys updu && st tg s --message "Weekly update: $(hostname)"

Tmux for Long-Running Operations

st tmux ns backup          # Create 'backup' session
# Run restic backup inside
detach with Ctrl+B, D
st tmux ls                 # Verify session persists
st tmux as backup          # Reattach to check progress

Safety First: Dry Runs

Always use st rclone dry-sync before st rclone sync. The --dry-run pattern prevents data loss.

Self-Update Discipline

st self-update  # Alias: st update

Run weekly to stay current with security fixes.

Comparison with Alternatives

The Verdict: Ansible excels at fleet management but demands investment. Webmin provides GUI comfort at resource cost. Custom scripts offer flexibility with maintenance burden. st occupies the sweet spot: powerful enough for serious work, simple enough for immediate productivity, extensible without expertise.

FAQ: Your Burning Questions Answered

Is st safe for production servers?

The repository carries a clear warning: "Avoid using in production until version 1.0.0." For production, test thoroughly in staging, audit the install scripts, and monitor the project's milestone progress.

Can I use st on non-Ubuntu systems?

Currently Ubuntu/Debian-focused. The Bashly framework and bash foundation suggest portability is achievable, but package management commands assume apt. Community contributions for dnf/pacman support would be welcome.

How does st differ from just using bash aliases?

Aliases lack structured help, argument validation, error handling, and discoverability. st provides st --help hierarchies, consistent patterns, and tested implementations that evolve with the project.

What happens if Bashly or dependencies break?

The compiled st binary is self-contained bash. Runtime dependencies are minimal (standard Ubuntu utilities). Build-time dependencies (Ruby/Bashly) aren't needed for operation.

Can I contribute new commands without knowing Bashly?

The YAML-driven structure lowers barriers, but learning Bashly basics unlocks full contribution potential. The project's CONTRIBUTING.md (when published) will detail the workflow.

How do I migrate from my existing dotfiles?

Gradually. Install st, run commands alongside your aliases, then replace aliases as comfort grows. The st config namespace helps manage the transition.

Is there a Docker image available?

Not currently—the tool is designed for host-level server management. Containerizing a server management tool creates privilege and scope complications.

Conclusion: Your Server Management Just Got Upgraded

Let's be honest: server administration will never be fun. But it doesn't have to be painful. The st CLI from server-tools represents a rare combination of pragmatic design and genuine innovation in a space that desperately needs both.

After walking through its capabilities—from one-command system maintenance to integrated Telegram alerting, from Docker stack orchestration to restic backup workflows—one thing becomes clear: this isn't another abandoned dotfiles repo. It's a growing ecosystem with thoughtful architecture, active development, and real-world problem solving at its core.

Yes, it's pre-1.0.0. Yes, you should test before trusting production workloads to it. But for your homelab, your development VPS, your side-project servers? st is ready to save you hours of terminal archaeology and memorization drudgery.

The installation is one command. The learning curve is measured in minutes, not days. The payoff compounds with every server you manage.

Ready to stop wrestling and start commanding?

👉 Install st now from GitHub — star the repo, open an issue with your wishlist, and join the community building the future of effortless server management. Your future self, staring at a terminal at 2 AM, will thank you.

Server Tools (st) — Effortless server management for everyone!