sysinfo.go

package main

import (
	"fmt"
	"os"
	"os/exec"
	"path/filepath"
	"regexp"
	"strconv"
	"strings"
	"syscall"
	"time"
)

func osRelease() map[string]string {
	m := map[string]string{}
	for _, p := range []string{"/etc/os-release", "/usr/lib/os-release"} {
		data, err := os.ReadFile(p)
		if err != nil {
			continue
		}
		for _, line := range strings.Split(string(data), "\n") {
			k, v, ok := strings.Cut(line, "=")
			if !ok {
				continue
			}
			m[k] = strings.Trim(v, `"`)
		}
		break
	}
	return m
}

func utsField(f [65]int8) string {
	b := make([]byte, 0, len(f))
	for _, c := range f {
		if c == 0 {
			break
		}
		b = append(b, byte(c))
	}
	return string(b)
}

func uname() (release, machine string) {
	var u syscall.Utsname
	if err := syscall.Uname(&u); err != nil {
		return "", ""
	}
	return utsField(u.Release), utsField(u.Machine)
}

type osDetails struct {
	Name    string
	Short   string
	ID      string
	Version string
	Arch    string
}

func osInfo() osDetails {
	rel := osRelease()
	d := osDetails{
		Name:    rel["PRETTY_NAME"],
		Short:   rel["NAME"],
		ID:      rel["ID"],
		Version: rel["VERSION_ID"],
	}
	if d.Name == "" {
		d.Name = d.Short
	}
	if d.Name == "" {
		d.Name = "Linux"
	}
	if d.Short == "" {
		d.Short = d.Name
	}
	_, d.Arch = uname()
	return d
}

func deName() string {
	de := os.Getenv("XDG_CURRENT_DESKTOP")
	if de == "" {
		de = os.Getenv("DESKTOP_SESSION")
	}
	if de == "" {
		return ""
	}
	de = strings.Split(de, ":")[0]
	if t := os.Getenv("XDG_SESSION_TYPE"); t != "" {
		de += " (" + t + ")"
	}
	return de
}

func uptime() time.Duration {
	data, err := os.ReadFile("/proc/uptime")
	if err != nil {
		return 0
	}
	fields := strings.Fields(string(data))
	if len(fields) == 0 {
		return 0
	}
	secs, _ := strconv.ParseFloat(fields[0], 64)
	return time.Duration(secs) * time.Second
}

func prettyUptime(d time.Duration) string {
	days := int(d.Hours()) / 24
	hours := int(d.Hours()) % 24
	mins := int(d.Minutes()) % 60
	var parts []string
	if days > 0 {
		parts = append(parts, fmt.Sprintf("%d day%s", days, plural(days)))
	}
	if hours > 0 {
		parts = append(parts, fmt.Sprintf("%d hour%s", hours, plural(hours)))
	}
	parts = append(parts, fmt.Sprintf("%d min%s", mins, plural(mins)))
	return strings.Join(parts, ", ")
}

func plural(n int) string {
	if n == 1 {
		return ""
	}
	return "s"
}

type cpuInfo struct {
	Model string
	Count int
	Freq  string
}

func cpus() []cpuInfo {
	data, err := os.ReadFile("/proc/cpuinfo")
	if err != nil {
		return nil
	}
	counts := map[string]int{}
	var order []string
	for _, line := range strings.Split(string(data), "\n") {
		k, v, ok := strings.Cut(line, ":")
		if !ok || strings.TrimSpace(k) != "model name" {
			continue
		}
		model := cleanCPUModel(strings.TrimSpace(v))
		if counts[model] == 0 {
			order = append(order, model)
		}
		counts[model]++
	}
	freq := cpuMaxFreq()
	var out []cpuInfo
	for _, m := range order {
		out = append(out, cpuInfo{Model: m, Count: counts[m], Freq: freq})
	}
	return out
}

var coreCountRE = regexp.MustCompile(`\s+\d+-Core`)

func cleanCPUModel(m string) string {
	for _, junk := range []string{"(R)", "(TM)", "(tm)", "CPU", "Processor"} {
		m = strings.ReplaceAll(m, junk, " ")
	}
	m = coreCountRE.ReplaceAllString(m, "")
	if i := strings.Index(m, "@"); i > 0 {
		m = m[:i]
	}
	if i := strings.Index(m, " with Radeon"); i > 0 {
		m = m[:i]
	}
	return strings.Join(strings.Fields(m), " ")
}

func cpuMaxFreq() string {
	for _, p := range []string{
		"/sys/devices/system/cpu/cpu0/cpufreq/cpuinfo_max_freq",
		"/sys/devices/system/cpu/cpu0/cpufreq/scaling_max_freq",
	} {
		data, err := os.ReadFile(p)
		if err != nil {
			continue
		}
		khz, err := strconv.ParseFloat(strings.TrimSpace(string(data)), 64)
		if err != nil || khz <= 0 {
			continue
		}
		return fmt.Sprintf("%.2f GHz", khz/1e6)
	}
	return ""
}

func gpus() []string {
	devs, _ := filepath.Glob("/sys/bus/pci/devices/*")
	ids := loadPCIIDs()
	var out []string
	for _, dev := range devs {
		class := sysRead(dev, "class")
		if !strings.HasPrefix(class, "0x03") {
			continue
		}
		vendor := strings.TrimPrefix(sysRead(dev, "vendor"), "0x")
		device := strings.TrimPrefix(sysRead(dev, "device"), "0x")
		name := ids.lookup(vendor, device)
		if name == "" {
			name = fmt.Sprintf("Unknown GPU [%s:%s]", vendor, device)
		}
		out = append(out, name)
	}
	return out
}

func sysRead(dir, file string) string {
	data, err := os.ReadFile(filepath.Join(dir, file))
	if err != nil {
		return ""
	}
	return strings.TrimSpace(string(data))
}

type pciIDs struct {
	vendorNames map[string]string
	deviceNames map[string]map[string]string
}

func loadPCIIDs() *pciIDs {
	ids := &pciIDs{vendorNames: map[string]string{}, deviceNames: map[string]map[string]string{}}
	var data []byte
	for _, p := range []string{
		"/usr/share/hwdata/pci.ids",
		"/usr/share/misc/pci.ids",
		"/usr/share/pci.ids",
	} {
		var err error
		if data, err = os.ReadFile(p); err == nil {
			break
		}
	}
	if data == nil {
		return ids
	}
	var vendor string
	for _, line := range strings.Split(string(data), "\n") {
		if line == "" || line[0] == '#' {
			continue
		}
		if line[0] != '\t' {
			if len(line) > 6 {
				vendor = line[:4]
				ids.vendorNames[vendor] = strings.TrimSpace(line[4:])
			}
			continue
		}
		isSubsystemLine := len(line) > 1 && line[1] == '\t'
		if isSubsystemLine {
			continue
		}
		l := strings.TrimPrefix(line, "\t")
		if len(l) > 6 && vendor != "" {
			if ids.deviceNames[vendor] == nil {
				ids.deviceNames[vendor] = map[string]string{}
			}
			ids.deviceNames[vendor][l[:4]] = strings.TrimSpace(l[4:])
		}
	}
	return ids
}

func (ids *pciIDs) lookup(vendor, device string) string {
	vname := shortVendor(ids.vendorNames[vendor])
	dname := ids.deviceNames[vendor][device]
	if dname == "" {
		return vname
	}
	if i := strings.Index(dname, "["); i >= 0 {
		if j := strings.Index(dname[i:], "]"); j > 0 {
			dname = dname[i+1 : i+j]
		}
	}
	return strings.TrimSpace(vname + " " + dname)
}

func shortVendor(v string) string {
	switch {
	case strings.Contains(v, "NVIDIA"):
		return "NVIDIA"
	case strings.Contains(v, "Advanced Micro Devices"), strings.Contains(v, "ATI"):
		return "AMD"
	case strings.Contains(v, "Intel"):
		return "Intel"
	}
	return strings.TrimSuffix(strings.TrimSpace(v), " Corporation")
}

func meminfo() (used, total uint64) {
	data, err := os.ReadFile("/proc/meminfo")
	if err != nil {
		return 0, 0
	}
	var avail uint64
	for _, line := range strings.Split(string(data), "\n") {
		k, v, ok := strings.Cut(line, ":")
		if !ok {
			continue
		}
		n, _ := strconv.ParseUint(strings.Fields(v)[0], 10, 64)
		switch k {
		case "MemTotal":
			total = n * 1024
		case "MemAvailable":
			avail = n * 1024
		}
	}
	if total >= avail {
		used = total - avail
	}
	return used, total
}

type mountInfo struct {
	Mount string
	Used  uint64
	Total uint64
}

var realFS = map[string]bool{
	"ext2": true, "ext3": true, "ext4": true, "btrfs": true, "xfs": true,
	"f2fs": true, "zfs": true, "vfat": true, "exfat": true, "ntfs": true,
	"ntfs3": true, "bcachefs": true, "jfs": true, "reiserfs": true,
}

func mounts(requested []string) []mountInfo {
	var points []string
	if len(requested) > 0 {
		points = requested
	} else {
		points = autoMounts()
	}
	var out []mountInfo
	for _, p := range points {
		var st syscall.Statfs_t
		if err := syscall.Statfs(p, &st); err != nil {
			continue
		}
		total := st.Blocks * uint64(st.Bsize)
		free := st.Bavail * uint64(st.Bsize)
		if total == 0 {
			continue
		}
		out = append(out, mountInfo{Mount: p, Used: total - free, Total: total})
	}
	return out
}

func autoMounts() []string {
	data, err := os.ReadFile("/proc/mounts")
	if err != nil {
		return []string{"/"}
	}
	var out []string
	seen := map[string]bool{}
	for _, line := range strings.Split(string(data), "\n") {
		f := strings.Fields(line)
		if len(f) < 3 || !realFS[f[2]] || !strings.HasPrefix(f[0], "/dev/") {
			continue
		}
		mount := strings.ReplaceAll(f[1], `\040`, " ")
		key := f[0] + " " + mount
		if seen[key] || strings.HasPrefix(mount, "/boot") {
			continue
		}
		seen[key] = true
		out = append(out, mount)
	}
	if len(out) == 0 {
		return []string{"/"}
	}
	return out
}

func hostModel() string {
	name := sysRead("/sys/devices/virtual/dmi/id", "product_name")
	version := sysRead("/sys/devices/virtual/dmi/id", "product_version")
	if strings.Contains(version, "To be filled") || version == "None" {
		version = ""
	}
	return strings.TrimSpace(name + " " + version)
}

func shellName() string {
	return filepath.Base(os.Getenv("SHELL"))
}

func terminalName() string {
	switch {
	case os.Getenv("KITTY_WINDOW_ID") != "":
		return "kitty"
	case os.Getenv("GHOSTTY_RESOURCES_DIR") != "" || os.Getenv("TERM") == "xterm-ghostty":
		return "ghostty"
	case os.Getenv("WEZTERM_EXECUTABLE") != "":
		return "WezTerm"
	case os.Getenv("KONSOLE_VERSION") != "":
		return "Konsole"
	case os.Getenv("VTE_VERSION") != "":
		return "GNOME Terminal"
	case os.Getenv("TERM_PROGRAM") != "":
		return os.Getenv("TERM_PROGRAM")
	}
	return os.Getenv("TERM")
}

func runCustom(command string) string {
	out, err := exec.Command("sh", "-c", command).Output()
	if err != nil {
		return ""
	}
	s := strings.TrimSpace(string(out))
	if i := strings.IndexByte(s, '\n'); i >= 0 {
		s = s[:i]
	}
	return s
}

func humanBytes(b uint64) string {
	const unit = 1024
	units := []string{"B", "KiB", "MiB", "GiB", "TiB", "PiB"}
	f := float64(b)
	i := 0
	for f >= unit && i < len(units)-1 {
		f /= unit
		i++
	}
	if i == 0 {
		return fmt.Sprintf("%d %s", b, units[i])
	}
	return fmt.Sprintf("%.1f %s", f, units[i])
}