DEV Community: SangheeSon

I still don't want to give Claude SSH access, so I built a doctor for my homelab

SangheeSon — Mon, 18 May 2026 01:32:36 +0000

A few weeks ago I wrote about why I don't want to give Claude SSH access to my home server.

It's not that AI agents are useless. It's the opposite. They got good enough that handing one a shell started to feel reckless.

A shell isn't really an interface. It's a weapon with tab completion. It can read anything, delete anything, restart anything, and confidently run the wrong command on the wrong machine at 2am.

So I've been building HomeButler in the other direction:

Not "AI runs my server."
"AI asks my server safe, structured questions."

The thing dashboards don't do

The first version of HomeButler was mostly about visibility:

homebutler status
homebutler docker list
homebutler ports
homebutler report

It worked. But after running it on my own homelab for a while, I noticed something.

Raw status isn't enough.

Most of the time I don't actually want to see every metric. I want to know four things:

Is something wrong?
Is it urgent?
What changed?
What should I check next?

Dashboards don't really answer those. They show you CPU, memory, disk, containers, ports, uptime, graphs, colors, tables — and then quietly hand the interpretation back to you.

That's fine when I'm sitting at my desk. It's much less useful when I'm checking my phone half-awake, wondering if something is quietly on fire.

For a small homelab I don't need a mini NOC. I need a calm answer.

So I added a new command:

homebutler doctor

Output looks like this:

🩺 HomeButler Doctor — mac-mini

✅ CPU looks normal
✅ Memory looks normal
⚠️ Disk usage is high: 91%
⚠️ 1 container is stopped
⚠️ Public listener found on 0.0.0.0:8080
⚠️ Latest backup is older than 7 days

Suggested next steps:
→ homebutler docker list
→ homebutler ports
→ homebutler backup list

Not "here is everything." More like "here is what deserves your attention."

Why this matters more once an AI is in the loop

This shape becomes a lot more interesting when an agent is involved.

Imagine giving an agent SSH and asking:

"Is my server okay?"

Now the agent has to decide what to run. Probably something like:

df -h
free -m
docker ps
docker logs ...
ss -tulpn
systemctl status ...

That can work. But the agent is now exploring my box through a general-purpose shell. It can run too much, see too much, or run the right command on the wrong host. The blast radius is "whatever the shell can do," which is everything.

With HomeButler, the agent gets a much smaller surface:

homebutler doctor --json

Structured output. Read-only. Bounded scope.

The agent doesn't need to be the operator. It can be the interpreter. That distinction is the whole point of the project for me.

What doctor actually checks

homebutler doctor is intentionally boring. That's the feature.

It checks the kinds of things I usually only notice once they've already become a problem:

high CPU, memory, or disk usage
stopped containers
public bind ports
missing or stale backups
notification readiness
whether report has a baseline for change detection

There's a strict mode for cron and CI:

homebutler doctor --strict

And because everything is machine-readable:

homebutler doctor --json

An agent can consume the result directly. No scraping terminal output, no parsing colored text, no guessing what df -h formatted on a particular distro.

Report vs Doctor

After using both for a while, I've started thinking about HomeButler as having two distinct kinds of answers.

report answers: "What changed since last time?"

homebutler report

It saves snapshots, compares the current state with the previous one, and summarizes notable changes.

doctor answers: "What looks risky right now?"

homebutler doctor

One looks backward. One looks at the current risk. Together they're much more useful than raw metrics, and honestly more useful than most of the dashboards I've run.

The pattern I keep coming back to

The longer I work on this, the more I think the framing matters more than the features:

AI agents don't need more power by default. They need better tools.

A shell gives an agent maximum power and maximum ambiguity. A narrow tool gives it less power but more meaning. For homelab ops, that tradeoff feels right to me. I don't want an agent freely roaming my server. I want it to ask specific, bounded questions:

homebutler doctor --json
homebutler report --json
homebutler inventory scan --json
homebutler backup drill uptime-kuma --json

And then explain the result in plain language.

That's a very different security model from "here is SSH, good luck."

Try it

HomeButler is a single Go binary. No daemon, no database, no always-on service.

brew tap Higangssh/homebutler
brew install homebutler

Or:

curl -fsSL https://raw.githubusercontent.com/Higangssh/homebutler/main/install.sh | sh

Then:

homebutler init
homebutler doctor
homebutler report

Repo: https://github.com/Higangssh/homebutler

I'm still building this around one idea: the future of AI-assisted ops shouldn't be "give the agent a shell." It should be "give the agent a tool that says what it means."

Genuine question for anyone running a homelab: what's the last thing your setup broke without warning? I'm collecting ideas for what doctor should check next.

Every developer deserves end credits

SangheeSon — Sun, 03 May 2026 04:30:46 +0000

When a movie ends, everyone gets credit. The grip. The caterer. The second assistant editor who probably saved the entire third act in post.

When we ship software? git log and a Slack thank-you that scrolls into the void by Monday.

I wanted to fix that. So I built gitcredits — a CLI that takes your git history and rolls it like end credits.

Higangssh / gitcredits

Git log doesn't do them justice. Turn your contributors into movie stars.

gitcredits

Git log doesn't do them justice. Turn your contributors into movie stars.

Install

Quick install (recommended)

curl -sL https://raw.githubusercontent.com/Higangssh/gitcredits/main/install.sh | sh

Supports macOS (Intel/Apple Silicon), Linux (x86_64/ARM64), and Windows (x86_64 via Git Bash).

Pre-built binaries

Download the latest release for your platform from GitHub Releases.

Go

go install github.com/Higangssh/gitcredits@latest

From source

git clone https://github.com/Higangssh/gitcredits.git
cd gitcredits
go build -o gitcredits .

Usage

cd your-repo
gitcredits

# or target another repository directly
gitcredits /path/to/your-repo

That's it. Run gitcredits inside a Git repository, or pass a target repository path directly.

Themes

Matrix — digital rain with text resolve effect:

gitcredits --theme matrix

Spider-Man — glitch effects with radial web transitions:

gitcredits --theme spiderman

Export to GIF

Save the credits as a high-quality GIF — perfect for READMEs, presentations, or sharing.

gitcredits --output credits.gif
gitcredits --output credits.gif --theme matrix
gitcredits --output credits.gif --theme spiderman
gitcredits /path/to/your-repo --output credits.gif

Requires VHS and…

View on GitHub

What it does

Run it in any repo:

gitcredits

Your contributors scroll up the terminal, movie-style. Names, commit counts, the whole thing. It's the closing scene of your project — except your project is still running.

Why I made it

I've been shipping side projects and contributing to open source for a while now, and something kept bothering me: the people who help you build something almost never get a moment.

A teammate who debugged a nasty race condition at 2am. A stranger on GitHub who opened a PR fixing your typo. The reviewer who caught the security bug before it shipped. They get a commit hash. Maybe a line in CONTRIBUTORS.md if you remember.

Movies figured this out a hundred years ago. Everyone who touched the thing gets their name on screen, in big letters, while music plays. It costs nothing and it means everything.

So I gave that to git.

Try it (30 seconds)

go install github.com/Higangssh/gitcredits@latest
cd your-favorite-repo
gitcredits

That's it. Works on any git repo. No config, no setup.

Built with

Go — single binary, no dependencies to fight
Bubble Tea — the TUI framework that makes terminal animations actually pleasant to write
lipgloss — for styling that doesn't look like 1995

The scroll animation was the fun part. Getting it to feel like credits and not like a list scrolling took more iterations than I want to admit. Easing curves matter, even in a terminal.

What's next

I'm thinking about:

Custom themes (Star Wars crawl, anyone?)
Music support (yes, really)
Per-file credits — who actually wrote this function?

If any of that sounds fun, the repo is open. PRs welcome. You'll get your name in the credits.

Every contributor deserves a moment on screen. Even if the screen is a terminal.

⭐ github.com/Higangssh/gitcredits — star it if it made you smile.

I don't want to give Claude SSH access to my home server

SangheeSon — Wed, 29 Apr 2026 13:47:36 +0000

AI agents are getting scary good at ops work.

Claude Code, Codex, OpenHands — they can SSH into a server, read logs, restart containers, fix configs. It works.

But I still won't give my home server an SSH key for an agent.

A shell is too sharp. It can inspect anything. It can delete anything. It can rm -rf the wrong path very fast and very confidently.

I want the agent to help operate my server, not be the operator.

So I've been building HomeButler in the opposite direction: not "AI runs my server," but "AI talks to my server through a narrow, structured interface."

The shape of the tool

HomeButler is a single Go binary. No daemon. No database. No always-on web service.

You can copy it onto a server, run it from cron, pipe it into a script, open the web dashboard, or hook it into Claude Desktop via MCP. Same binary, same core, different surfaces.

┌──────────────────────────────────────────────────┐
│  Layer 3 — Chat Interface                        │
│  Telegram · Slack · Discord · Terminal · Browser │
└──────────────────────┬───────────────────────────┘
                       │
┌──────────────────────▼───────────────────────────┐
│  Layer 2 — AI Agent                              │
│  Claude · LangChain · n8n · OpenClaw             │
└──────────────────────┬───────────────────────────┘
                       │  CLI exec or MCP (stdio)
┌──────────────────────▼───────────────────────────┐
│  Layer 1 — Tool (homebutler)   ← YOU ARE HERE    │
│                                                  │
│   CLI · MCP · Web    → same internal/ core       │
│   system · docker · ports · backup · watch       │
└──────────────────────────────────────────────────┘

The agent gets explicit, JSON-returning operations. It can't reach outside this surface. The blast radius of a wrong call is bounded.

I sleep better.

Three things HomeButler does that I actually care about

There's a long feature list in the README. Three of them are why I keep working on this.

1. `report` — what changed, not just what is

Most homelab dashboards show state. Beautiful graphs, lots of dots.

But my home server doesn't fail because I lack data. It fails because I don't notice the right change at the right time.

🏠 Homebutler Report — mac-mini

── Current Status ──
   CPU: 5.0% · Memory: 8.3/16.0 GB · Disk: 4%
   Containers: 1 running, 1 stopped · Public ports: 5

── Needs Attention ──
   ⚠️  1 container(s) stopped

── Notable Changes ──
   No significant changes since last report.

── Suggested Actions ──
   → Address items in 'Needs attention' above.

First run takes a baseline. Every run after diffs against the last snapshot and tells you what moved. --json for piping into agents.

What I want it to answer is just three things:

What looks wrong?
What changed?
What should I check next?

Not "here's a graph, you figure it out."

2. `watch` — the 3 AM container death problem

Your container crashed at 3 AM. Why? By morning, the logs are gone, the container is back up, and you have no idea what happened.

watch catches the moment it dies, saves the pre-death and post-restart logs, and analyzes the cause:

[03:14:22] INCIDENT: nginx (incident nginx-20260410-031422-7a2124)
  Crash: OOM — process killed by SIGKILL (oom, confidence: high)
  ⚠ FLAPPING: acute (3 restarts in short window)

It uses exit codes (137 = OOM, 139 = segfault, 143 = SIGTERM) plus log pattern matching (panic:, Out of memory, FATAL) to categorize the crash. Flapping detection flags processes stuck in restart loops — acute (3+ in 10 min) or chronic (5+ in 24h).

Supports Docker (real-time event stream), systemd, and PM2.

homebutler watch add nginx           # interactive: pick docker / systemd / pm2
homebutler watch start               # foreground monitoring
homebutler watch history             # list past incidents
homebutler watch show <incident-id>  # full crash report

This is the feature I built for myself first. Every homelabber has had a 3 AM container death they couldn't explain.

3. `backup drill` — "having a backup" vs "being able to restore"

These are different things. I learned this the hard way.

backup drill boots your backup in an isolated Docker network, runs an HTTP health check against the booted app, and tears it all down. Like a fire drill for your data.

🔍 Backup Drill — uptime-kuma

  📦 Backup: backup_2026-04-04_1711.tar.gz (18.6 MB)
  🔐 Integrity: ✅ tar valid (8 files)
  🚀 Boot: ✅ container started in 0s
  🌐 Health: ✅ HTTP 200 on port 58574
  ⏱️  Total: 2s

  ✅ DRILL PASSED

Zero risk to your running services — completely isolated environment, random port, separate network. If the drill fails, your backup is theater. Better to find out today than on the day you actually need it.

Why this shape, not another dashboard

Portainer, Netdata, CasaOS, Uptime Kuma — these are all great. I run several of them. They solve real problems.

But on a small home server, my bottleneck isn't observability. It's me, the operator, with five tabs open trying to remember what "normal" looked like yesterday.

A small structured CLI fits that gap better than another tab:

Cron-friendly — homebutler report --json | jq at 8 AM with my coffee
Script-friendly — exit codes that mean something, JSON everywhere
Agent-friendly — MCP server built in, works with Claude Desktop / ChatGPT / Cursor out of the box
Air-gap friendly — single binary, no daemon, no phone-home

The dashboard is also there (homebutler serve for a go:embed web UI), but it's opt-in. The default mode is "command you run, answer you get, exit."

The bigger bet

I think the next interesting interface for ops isn't a prettier dashboard. It's the conversation:

"Is anything weird with the server?"

(Claude calls homebutler report via MCP, reads the JSON, summarizes)

"Yeah — Vaultwarden has been restarting every ~2 hours since yesterday. Want me to pull the crash logs?"

For that to be safe, the agent needs a narrow tool, not a shell. That's what HomeButler is becoming.

Try it

brew install Higangssh/homebutler/homebutler

Or:

curl -fsSL https://raw.githubusercontent.com/Higangssh/homebutler/main/install.sh | sh

Then:

homebutler init        # interactive setup
homebutler report      # baseline + summary
homebutler watch tui   # terminal dashboard

Repo: https://github.com/Higangssh/homebutler
Site: https://homebutler.dev

If you run a homelab, I'd love to hear: what's the one thing you wish someone would just tell you about your server every morning? That's the next thing I want report to answer.

My friend unplugged my Raspberry Pi — so I built a homelab manager

SangheeSon — Sun, 29 Mar 2026 13:47:01 +0000

It started with an accident.
My friend was at my place, tripped over a cable,
and unplugged my Raspberry Pi. The SD card got
corrupted. Network partition gone. Files — gone.
I had to re-flash everything from scratch.
No backup. No remote monitoring. No alerts.
I didn't even know it was down until I tried
to SSH in the next day.
That's when I decided: never again.

The Problem

If you run a homelab, you probably know the drill:

SSH into each server manually
Run docker ps to check containers
Forgot which port Uptime Kuma is on
No idea if your disk is 90% full
Deploying a new app means writing YAML by hand

I had 2 servers (Mac Mini + Raspberry Pi 5).
Managing them was death by a thousand SSH sessions.

What I Built

homebutler
— a single 15MB Go binary that manages
your entire homelab.

# Check all servers at once
homebutler status --all
# Install an app in 30 seconds
homebutler install uptime-kuma
# Container resource usage
homebutler docker stats
# Wake a sleeping machine
homebutler wake nas

No Docker required to run it. No database.
No config files to write (there's an init wizard).
Just download and go.

One-Command App Install

This is the feature I'm most proud of.
Instead of writing docker-compose files:

homebutler install jellyfin --media /mnt/movies

That's it. It:

Checks if Docker is running
Checks if the port is available
Generates docker-compose.yml
Pulls the image and starts the container
Verifies it's running

Currently supports 6 apps: uptime-kuma,
vaultwarden, filebrowser, it-tools, gitea,
and jellyfin.

Built-in AI Integration

homebutler includes a built-in MCP server
with 15 tools. Connect it to Claude, ChatGPT,
or Cursor, and you can manage your homelab
from chat:

"Install uptime-kuma on the raspberry pi"
"What's the CPU usage on all servers?"
"Restart the nginx container"

The AI part is completely optional.
homebutler works perfectly as a standalone CLI.

The Tech

Go — single binary, cross-compiled for Linux/macOS (ARM + x86)
cobra — CLI framework with auto-generated help and shell completion
go:embed — web dashboard baked into the binary
Bubble Tea — terminal TUI dashboard
No frameworks for HTTP — just net/http

The whole thing is 15MB. Zero runtime dependencies.

What's Next

More installable apps (targeting 15+)
Scheduled backups with one-command restore
Server down notifications (Telegram/Discord)
Reverse proxy auto-configuration

Try It

brew install Higangssh/homebutler/homebutler
# or
curl -fsSL https://raw.githubusercontent.com/Higangssh/homebutler/main/install.sh | sh

Then:

homebutler init    # setup wizard
homebutler status  # see your server

GitHub: https://github.com/Higangssh/homebutler

Demo video: https://www.youtube.com/watch?v=MFoDiYRH_nE

What's your homelab stack?
I'd love to know what apps you'd want homebutler to support next.

git log is boring. So I made this instead.

SangheeSon — Tue, 10 Mar 2026 15:26:49 +0000

Ever watched a movie and thought "damn, those end credits look cool"? Now imagine that — but for your Git contributors.

git log is boring. git shortlog -sn is slightly less boring. But neither of them makes your contributors feel like the stars they are.

I wanted something fun. Something you could run at a team demo or after a big release. Something that makes people go "wait, what is that?"

So I built gitcredits

gitcredits demo

It's a single binary. You run gitcredits in any Git repo, and it rolls your contributors like movie credits — complete with ASCII art titles, starfield background, and smooth scrolling.

How it works

Reads your Git history
Extracts contributors, commit counts, recent features
Renders it all as a terminal animation using Bubble Tea (https://github.com/charmbracelet/bubbletea) + Lip Gloss (https://github.com/charmbracelet/lipgloss)

No config files. No setup. Just run it in any Git repo.

Themes

The default theme gives you Star Wars-style scrolling credits with a starfield.

But my favorite is the Matrix theme — digital rain with a text resolve effect:

matrix theme

What it shows

• Title — your repo name in big ASCII art
• Project Lead — whoever has the most commits
• Starring — all contributors with their commit counts
• Notable Scenes — recent feat/fix commits
• Stats — total commits, contributors, stars, language, license

Why I built it

I've been contributing to open source for a while, and I realized there's no fun way to celebrate the people behind a project. GitHub's contributor graph is nice, but it's just a chart.

I wanted something that felt like a moment. Run it at the end of a sprint. Run it at a hackathon. Run it just because your terminal deserves better.

Check it out

GitHub: (https://github.com/Higangssh/gitcredits)

It's open source, MIT licensed, and contributions are welcome 🎬

I built a single binary to manage all my homelab servers from Telegram

SangheeSon — Sat, 28 Feb 2026 07:29:25 +0000

I run 3 servers at home — a Mac Mini, a Raspberry Pi, and a NAS. Managing them used to mean opening 3 SSH sessions, running the same commands on each, and switching between terminal tabs at 2 AM when something breaks.

I got tired of it. So I built homebutler.

The moment that started it all

3 AM. Phone buzzes. Disk alert on my NAS — 91% full.

Old workflow: grab laptop → SSH into NAS → check what's eating disk → restart the problem service → SSH into the other servers to make sure they're fine → go back to sleep 40 minutes later.

I wanted this instead: pick up phone → read the alert → type "what's eating disk?" → type "restart postgres" → sleep. All from one chat window.

What homebutler does

It's a single Go binary (~13MB, zero dependencies) that does two things:

1. CLI for your terminal

$ homebutler status --all

🖥 mac-mini (darwin/arm64)
   CPU: 23% | Memory: 5.2/8.0 GB | Disk: 37%

🖥 raspberry-pi (linux/arm64)
   CPU: 12% | Memory: 1.6/4.0 GB | Disk: 47%

🖥 nas-box (linux/amd64)
   CPU: 8% | Memory: 12.4/32 GB | Disk: 87% ⚠️

One command, all servers. It connects to remote servers over SSH in parallel.

2. MCP server for AI chat

homebutler speaks MCP, so Claude, ChatGPT, Cursor — anything that supports MCP — can use it as a tool.

{
  "mcpServers": {
    "homebutler": {
      "command": "npx",
      "args": ["-y", "homebutler@latest"]
    }
  }
}

This is what it looks like in practice:

🚨 Alert: CPU at 92% on nas-box

Me: "What's eating CPU?"

Bot: postgres — 85.2%

Me: "Restart postgres"

Bot: ✅ Done. CPU 92% → 12%

No SSH. No laptop. No dashboard login.

What's inside

System monitoring — CPU, memory, disk, uptime
Docker management — list, restart, stop, view logs
Wake-on-LAN — power on machines from anywhere
Port scanner — see what's listening
Network scan — discover LAN devices
Multi-server SSH — manage all servers from one place
Web dashboard — dark-themed UI, embedded in the binary
Alerts — threshold-based notifications
JSON output — pipe-friendly for scripts and AI

Why a single binary?

I've tried Netdata, Glances, CasaOS. They all need Docker, or a running daemon, or a web server that's always on.

homebutler is different:

Copy one file to your Pi. Done.
No Docker. No Node. No Python. No config server.
Runs when you need it, sleeps when you don't.
Air-gapped install? Just scp the binary.

Multi-server: the part I'm most proud of

# ~/.config/homebutler/config.yaml
servers:
  - name: mac-mini
    local: true
  - name: raspberry-pi
    host: 192.168.1.30
    user: pi
  - name: nas-box
    host: 192.168.1.20
    user: admin

Once configured, every command works across all servers:

homebutler docker list --all    # containers on every server
homebutler alerts --all         # alerts from everywhere
homebutler serve                # web dashboard for all servers

Try it

# Homebrew
brew install Higangssh/tap/homebutler

# npm (for MCP server)
npx -y homebutler@latest

# Go
go install github.com/Higangssh/homebutler@latest

GitHub: github.com/Higangssh/homebutler

It's MIT licensed, open source, and I'm actively maintaining it. If you run a homelab, I'd love to hear what you think.

DEV Community: SangheeSon

I still don't want to give Claude SSH access, so I built a doctor for my homelab

The thing dashboards don't do

Why this matters more once an AI is in the loop

What doctor actually checks

Report vs Doctor

The pattern I keep coming back to

Try it

Every developer deserves end credits

Higangssh / gitcredits

Git log doesn't do them justice. Turn your contributors into movie stars.

gitcredits

Install

Quick install (recommended)

Pre-built binaries

Go

From source

Usage

Themes

Export to GIF

What it does

Why I made it

Try it (30 seconds)

Built with

What's next

I don't want to give Claude SSH access to my home server

The shape of the tool

Three things HomeButler does that I actually care about

1. report — what changed, not just what is

2. watch — the 3 AM container death problem

3. backup drill — "having a backup" vs "being able to restore"

Why this shape, not another dashboard

The bigger bet

Try it

My friend unplugged my Raspberry Pi — so I built a homelab manager

The Problem

What I Built

One-Command App Install

Built-in AI Integration

The Tech

What's Next

Try It

git log is boring. So I made this instead.

I built a single binary to manage all my homelab servers from Telegram

The moment that started it all

What homebutler does

What's inside

Why a single binary?

Multi-server: the part I'm most proud of

Try it

1. `report` — what changed, not just what is

2. `watch` — the 3 AM container death problem

3. `backup drill` — "having a backup" vs "being able to restore"