hamlab/cmd/hamlab/main.go

// Ham Lab — Proxmox-style web console for a bare-metal Debian host.
package main

import (
	"context"
	"errors"
	"flag"
	"fmt"
	"log"
	"net/http"
	"os"
	"os/signal"
	"os/user"
	"path/filepath"
	"runtime"
	"strings"
	"syscall"
	"time"

	"golang.org/x/term"

	"hamlab/internal/api"
	"hamlab/internal/auth"
	"hamlab/internal/config"
	"hamlab/internal/cron"
	"hamlab/internal/files"
	"hamlab/internal/metrics"
	"hamlab/internal/nodes"
	"hamlab/internal/services"
	"hamlab/internal/storage"
	"hamlab/internal/store"
	"hamlab/internal/tasks"
	hterm "hamlab/internal/term"
	"hamlab/internal/tlsauto"
	"hamlab/internal/updates"
	"hamlab/internal/web"
)

var version = "dev"

func main() {
	defaultCfg := os.Getenv("HAMLAB_CONFIG")
	if defaultCfg == "" {
		home, _ := os.UserHomeDir()
		defaultCfg = filepath.Join(home, "apps", "hamlab", "config.json")
	}
	cfgPath := flag.String("config", defaultCfg, "path to config.json")
	flag.Usage = func() {
		fmt.Fprintf(os.Stderr, "usage: hamlab [-config path] [serve|passwd|version|push-nodes|fs …]\n")
		flag.PrintDefaults()
	}
	flag.Parse()

	cmd := "serve"
	if flag.NArg() > 0 {
		cmd = flag.Arg(0)
	}
	if cmd == "fs" { // privileged helper for the Files tab (run via sudo by the daemon)
		os.Exit(files.Helper(flag.Args()[1:], os.Stdin, os.Stdout, os.Stderr))
	}
	cfg, err := config.Load(*cfgPath)
	if err != nil {
		log.Fatal(err)
	}
	switch cmd {
	case "version":
		fmt.Println("hamlab", version)
	case "passwd":
		if err := passwd(cfg); err != nil {
			log.Fatal(err)
		}
	case "push-nodes": // hub CLI: send this binary to every managed machine
		exe, _ := os.Executable()
		host, _ := os.Hostname()
		nm := nodes.New(cfg, host)
		results := nm.PushAll(context.Background(), exe, runtime.GOARCH)
		if len(results) == 0 {
			fmt.Println("no managed machines in", cfg.Path())
		}
		failed := 0
		for _, r := range results {
			if r.OK {
				fmt.Printf("%-12s updated to %s\n", r.Name, r.Version)
			} else {
				failed++
				fmt.Printf("%-12s FAILED: %s\n", r.Name, r.Error)
			}
		}
		if failed > 0 {
			os.Exit(1)
		}
	case "serve":
		if err := serve(cfg); err != nil {
			log.Fatal(err)
		}
	default:
		flag.Usage()
		os.Exit(2)
	}
}

func passwd(cfg *config.Config) error {
	fmt.Fprint(os.Stderr, "New password: ")
	p1, err := term.ReadPassword(int(os.Stdin.Fd()))
	fmt.Fprintln(os.Stderr)
	if err != nil {
		return err
	}
	fmt.Fprint(os.Stderr, "Again: ")
	p2, err := term.ReadPassword(int(os.Stdin.Fd()))
	fmt.Fprintln(os.Stderr)
	if err != nil {
		return err
	}
	if string(p1) != string(p2) {
		return errors.New("passwords do not match")
	}
	if len(p1) < 12 {
		return errors.New("password must be at least 12 characters")
	}
	h, err := auth.HashPassword(string(p1))
	if err != nil {
		return err
	}
	cfg.PasswordHash = h
	if err := cfg.Save(); err != nil {
		return err
	}
	fmt.Fprintln(os.Stderr, "password set in", cfg.Path())
	return nil
}

func serve(cfg *config.Config) error {
	if cfg.PasswordHash == "" {
		return fmt.Errorf("no password set — run: hamlab -config %s passwd", cfg.Path())
	}
	if err := os.MkdirAll(cfg.DataDir(), 0o700); err != nil {
		return err
	}
	st, err := store.Open(filepath.Join(cfg.DataDir(), "state.json"))
	if err != nil {
		return err
	}
	sessions := auth.NewSessions(st)

	u, err := user.Current()
	if err != nil {
		return err
	}
	shell := os.Getenv("SHELL")
	if shell == "" {
		shell = loginShell(u.Username)
	}
	mgr := hterm.NewManager(shell, u.HomeDir)
	mgr.OnChange = func(list []hterm.Info) {
		_ = st.Update(func(s *store.State) {
			s.Terminals = s.Terminals[:0]
			for _, t := range list {
				s.Terminals = append(s.Terminals, store.Terminal{ID: t.ID, Name: t.Name})
			}
		})
	}
	// Re-open the shells that existed before the last restart (fresh processes,
	// same names/order) so the sidebar comes back as it was.
	var saved []store.Terminal
	st.View(func(s *store.State) { saved = append(saved, s.Terminals...) })
	for _, t := range saved {
		if _, err := mgr.Create(t.ID, t.Name); err != nil {
			log.Printf("restore terminal %q: %v", t.Name, err)
		}
	}

	col := metrics.NewCollector()
	go col.Run(context.Background())

	svc := services.New()
	cr := cron.New(svc.Sudo(), svc.JournalSudo())
	tm := tasks.New()
	up := updates.New(svc.Sudo(), tm)
	sto := storage.New(svc.Sudo())
	self, _ := os.Executable()
	var sudoFS files.FS
	if svc.Sudo() && self != "" {
		sudoFS = files.Sudo{Self: self}
	}
	host, _ := os.Hostname()
	nm := nodes.New(cfg, host)
	go nm.Run(context.Background())

	certPath, keyPath, fingerprint := "", "", ""
	if cfg.TLS == "auto" {
		var err error
		certPath, keyPath, fingerprint, err = tlsauto.Ensure(cfg.DataDir())
		if err != nil {
			return fmt.Errorf("tls: %w", err)
		}
	}
	srv := api.New(cfg, sessions, mgr, col, st, svc, cr, tm, up, sto, files.Local{}, sudoFS, nm, fingerprint, web.FS(), version)
	hs := &http.Server{
		Addr:              cfg.Listen,
		Handler:           srv.Handler(),
		ReadHeaderTimeout: 10 * time.Second,
	}
	go func() {
		sig := make(chan os.Signal, 1)
		signal.Notify(sig, syscall.SIGINT, syscall.SIGTERM)
		<-sig
		log.Print("shutting down")
		ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
		defer cancel()
		_ = hs.Shutdown(ctx)
		mgr.Shutdown()
	}()
	if certPath != "" {
		log.Printf("hamlab %s listening on https://%s as %s (shell %s) cert %s", version, cfg.Listen, u.Username, shell, fingerprint)
		if err := hs.ListenAndServeTLS(certPath, keyPath); !errors.Is(err, http.ErrServerClosed) {
			return err
		}
		return nil
	}
	log.Printf("hamlab %s listening on %s as %s (shell %s)", version, cfg.Listen, u.Username, shell)
	if err := hs.ListenAndServe(); !errors.Is(err, http.ErrServerClosed) {
		return err
	}
	return nil
}

// loginShell returns the user's shell from /etc/passwd, falling back to bash if
// present and /bin/sh otherwise. Systemd units don't export $SHELL.
func loginShell(username string) string {
	if b, err := os.ReadFile("/etc/passwd"); err == nil {
		for _, line := range strings.Split(string(b), "\n") {
			f := strings.Split(line, ":")
			if len(f) >= 7 && f[0] == username && f[6] != "" {
				if _, err := os.Stat(f[6]); err == nil {
					return f[6]
				}
			}
		}
	}
	for _, sh := range []string{"/bin/bash", "/usr/bin/bash", "/bin/zsh", "/bin/sh"} {
		if _, err := os.Stat(sh); err == nil {
			return sh
		}
	}
	return "/bin/sh"
}