Skip to content

Every agent's model. One place. Codex on DeepSeek, Claude Code on Kimi, from the menu bar.

14.0 KB
Raw Blame
// Package omarchy is what magpie knows of Omarchy (omarchy.org), the
// Hyprland desktop: whether it runs on one, and the look its current theme
// gives every surface, so magpie's windows can take that look there and
// nowhere else.
//
// Omarchy (4.x) keeps the current theme under
// ~/.local/state/omarchy/current/theme: colors.toml, the palette every app's
// theme is made from, and shell.toml, the tokens its own shell draws with
// (controls, popups, menus). The font is omarchy-font-current's, the corners
// Hyprland's decoration:rounding (0 unless changed) and the border its
// general:border_size in the colour of the active window's.
package omarchy

import (
	"bufio"
	"bytes"
	"context"
	"fmt"
	"os"
	"path/filepath"
	"runtime"
	"strconv"
	"strings"
	"sync"
	"time"

	"github.com/yetone/magpie/internal/appdir"
	"github.com/yetone/magpie/internal/proc"
)

// Detect reports whether magpie runs on Omarchy. MAGPIE_OMARCHY=1 says it
// does (with MAGPIE_OMARCHY_THEME the theme's folder), =0 that it doesn't.
func Detect() bool {
	switch os.Getenv("MAGPIE_OMARCHY") {
	case "1":
		return true
	case "0":
		return false
	}
	if runtime.GOOS != "linux" || ThemeDir() == "" {
		return false
	}
	if appdir.Getenv("OMARCHY_PATH") != "" {
		return true
	}
	home, _ := os.UserHomeDir()
	for _, d := range []string{"/usr/share/omarchy", filepath.Join(home, ".local", "share", "omarchy")} {
		if fi, err := os.Stat(d); err == nil && fi.IsDir() {
			return true
		}
	}
	return false
}

// ThemeDir is the current theme's folder, or "" when there is none.
func ThemeDir() string {
	if d := os.Getenv("MAGPIE_OMARCHY_THEME"); d != "" {
		return d
	}
	home, _ := os.UserHomeDir()
	state := appdir.Getenv("XDG_STATE_HOME")
	if state == "" {
		state = filepath.Join(home, ".local", "state")
	}
	for _, d := range []string{
		filepath.Join(state, "omarchy", "current", "theme"),
		filepath.Join(home, ".config", "omarchy", "current", "theme"), // before 4.0
	} {
		if _, err := os.Stat(filepath.Join(d, "colors.toml")); err == nil {
			return d
		}
	}
	return ""
}

// Theme is the current theme as magpie draws with it.
type Theme struct {
	Name  string            `json:"name"`  // tokyo-night
	Mode  string            `json:"mode"`  // dark or light
	Stamp string            `json:"stamp"` // changes when any of it does
	Vars  map[string]string `json:"vars"`  // CSS custom properties
}

// Parse reads a TOML file's key = value lines, a section's keys as
// "section.key": the little of TOML the theme files use (strings, numbers,
// booleans, comments).
func Parse(b []byte) map[string]string {
	out := map[string]string{}
	section := ""
	sc := bufio.NewScanner(bytes.NewReader(b))
	for sc.Scan() {
		line := strings.TrimSpace(sc.Text())
		if line == "" || line[0] == '#' {
			continue
		}
		if line[0] == '[' {
			section = strings.Trim(line, "[] ")
			continue
		}
		k, v, ok := strings.Cut(line, "=")
		if !ok {
			continue
		}
		k, v = strings.TrimSpace(k), strings.TrimSpace(v)
		if strings.HasPrefix(v, `"`) {
			if end := strings.Index(v[1:], `"`); end >= 0 {
				v = v[1 : end+1]
			}
		} else if i := strings.Index(v, "#"); i >= 0 {
			v = strings.TrimSpace(v[:i])
		}
		if section != "" {
			k = section + "." + k
		}
		out[k] = v
	}
	return out
}

// color is an RGBA colour, each part 0..1.
type color struct{ r, g, b, a float64 }

// parseColor reads #rgb, #rrggbb, #rrggbbaa, Hyprland's rgb(rrggbb) and
// rgba(rrggbbaa), and CSS's rgb(r, g, b) and rgba(r, g, b, a). A gradient
// ("rgba(…) rgba(…) 45deg") is read as its first colour.
func parseColor(s string) (color, bool) {
	s = strings.TrimSpace(strings.ToLower(s))
	if f := strings.Fields(s); len(f) > 1 && !strings.Contains(s, ",") {
		s = f[0]
	}
	hex := func(h string) (color, bool) {
		switch len(h) {
		case 3:
			h = string([]byte{h[0], h[0], h[1], h[1], h[2], h[2]})
		case 6:
		case 8:
		default:
			return color{}, false
		}
		n, err := strconv.ParseUint(h, 16, 32)
		if err != nil {
			return color{}, false
		}
		if len(h) == 6 {
			n = n<<8 | 0xff
		}
		return color{float64(n>>24&0xff) / 255, float64(n>>16&0xff) / 255, float64(n>>8&0xff) / 255, float64(n&0xff) / 255}, true
	}
	switch {
	case strings.HasPrefix(s, "#"):
		return hex(s[1:])
	case strings.HasPrefix(s, "rgb"):
		open, end := strings.Index(s, "("), strings.LastIndex(s, ")")
		if open < 0 || end < open {
			return color{}, false
		}
		in := strings.TrimSpace(s[open+1 : end])
		if !strings.Contains(in, ",") {
			return hex(in)
		}
		parts := strings.Split(in, ",")
		if len(parts) < 3 {
			return color{}, false
		}
		var v [4]float64
		v[3] = 1
		for i, p := range parts[:min(len(parts), 4)] {
			f, err := strconv.ParseFloat(strings.TrimSpace(p), 64)
			if err != nil {
				return color{}, false
			}
			if i < 3 {
				f /= 255
			}
			v[i] = f
		}
		return color{v[0], v[1], v[2], v[3]}, true
	}
	return color{}, false
}

func (c color) css() string {
	to := func(f float64) int { return int(max(0, min(255, f*255+0.5))) }
	if c.a >= 0.999 {
		return fmt.Sprintf("#%02x%02x%02x", to(c.r), to(c.g), to(c.b))
	}
	return fmt.Sprintf("rgba(%d, %d, %d, %s)", to(c.r), to(c.g), to(c.b), strconv.FormatFloat(max(0, min(1, c.a)), 'f', 3, 64))
}

// over is c at alpha a laid over the opaque bg, as one opaque colour.
func (c color) over(bg color, a float64) color {
	return color{bg.r + (c.r-bg.r)*a, bg.g + (c.g-bg.g)*a, bg.b + (c.b-bg.b)*a, 1}
}

func (c color) alpha(a float64) color { c.a = a; return c }

// luminance is c's relative luminance, to tell a light theme from a dark one
// that doesn't say.
func (c color) luminance() float64 { return 0.2126*c.r + 0.7152*c.g + 0.0722*c.b }

// Vars turns the theme's palette (colors.toml) and shell tokens
// (shell.toml) into magpie's CSS custom properties, the rest given: the
// font's family, the corners' radius and the border's width.
func Vars(colors, shell map[string]string, font string, rounding, border int) (map[string]string, string) {
	get := func(m map[string]string, fallback color, keys ...string) color {
		for _, k := range keys {
			v := m[k]
			// a shell token may name another: "hyprland.active-border"
			for range 3 {
				if ref, ok := shell[v]; ok {
					v = ref
				}
			}
			if c, ok := parseColor(v); ok {
				return c
			}
		}
		return fallback
	}
	num := func(k string, fallback float64) float64 {
		if f, err := strconv.ParseFloat(shell[k], 64); err == nil {
			return f
		}
		return fallback
	}
	black := color{0, 0, 0, 1}
	bg := get(shell, get(colors, color{0.102, 0.106, 0.149, 1}, "background"), "popups.background")
	bg.a = 1
	fg := get(shell, get(colors, color{0.663, 0.694, 0.839, 1}, "foreground"), "popups.text")
	mode := strings.ToLower(colors["mode"])
	if mode != "light" && mode != "dark" {
		mode = "dark"
		if bg.luminance() > 0.5 {
			mode = "light"
		}
	}
	dim := get(colors, fg.over(bg, 0.55), "dark_foreground")
	if mode == "light" {
		dim = get(colors, fg.over(bg, 0.6), "muted", "dark_foreground")
	}
	accent := get(shell, get(colors, color{0.478, 0.635, 0.969, 1}, "accent", "blue"), "menu.selected-text")
	bright := get(colors, fg, "bright_foreground")
	red := get(colors, color{0.969, 0.463, 0.557, 1}, "red")
	green := get(colors, color{0.62, 0.808, 0.416, 1}, "green")
	yellow := get(colors, color{0.878, 0.686, 0.408, 1}, "yellow")
	orange := get(colors, yellow, "orange")
	cyan := get(colors, color{0.267, 0.616, 0.671, 1}, "cyan")
	blue := get(colors, accent, "blue")
	magenta := get(colors, color{0.678, 0.557, 0.902, 1}, "magenta")
	edge := get(shell, accent, "popups.border", "hyprland.active-border")
	selFg := get(shell, fg, "menu.selected-background")
	selA := num("menu.selected-background-alpha", 0.08)
	fillA := num("controls.normal-fill-alpha", 0.04)
	hoverA := num("controls.hover-cursor-fill-alpha", 0.08)
	ctlBorderA := num("controls.normal-border-alpha", 0.4)
	pressA := num("controls.pressed-fill-alpha", 0.22)
	selectedA := num("controls.selected-fill-alpha", 0.18)
	size := num("font.base-size", 12)
	soft := func(c color) string { return c.over(bg, 0.16).css() }
	shadow := black.alpha(0.35)
	if mode == "light" {
		shadow = black.alpha(0.12)
	}
	invert := "1"
	if mode == "light" {
		invert = "0"
	}
	if font == "" {
		font = "JetBrainsMono Nerd Font"
	}
	family := fmt.Sprintf("%q, \"JetBrainsMono Nerd Font\", \"JetBrains Mono\", ui-monospace, monospace", font)
	v := map[string]string{
		"--bg":          bg.css(),
		"--card":        fg.over(bg, fillA).css(),
		"--card-2":      fg.over(bg, fillA/2).css(),
		"--pill":        fg.over(bg, fillA).css(),
		"--pill-hover":  fg.over(bg, hoverA).css(),
		"--pill-line":   fg.alpha(ctlBorderA).css(),
		"--pill-shadow": "none",
		"--card-edge":   "none",
		"--seg-track":   "transparent",
		"--seg-thumb":   fg.over(bg, selectedA).css(),
		"--seg-edge":    "none",
		"--line":        fg.over(bg, 0.16).css(),
		"--line-2":      fg.over(bg, 0.1).css(),
		"--fg":          fg.css(),
		"--fg-2":        fg.css(),
		"--fg-hi":       bright.css(),
		"--muted":       dim.css(),
		"--faint":       fg.over(bg, 0.38).css(),
		"--accent":      accent.css(),
		"--accent-soft": accent.over(bg, 0.14).css(),
		"--accent-fg":   bg.css(),
		"--sel":         selFg.over(bg, selA).css(),
		"--press":       fg.over(bg, pressA).css(),
		"--green":       green.css(),
		"--green-soft":  soft(green),
		"--red":         red.css(),
		"--red-soft":    soft(red),
		"--amber":       yellow.css(),
		"--amber-soft":  soft(yellow),
		"--drift":       red.css(),
		"--drift-soft":  soft(red),
		"--pop-bg":      bg.css(),
		"--shadow":      "0 8px 24px " + shadow.css(),
		"--skel":        fg.over(bg, 0.06).css(),
		"--skel-hi":     fg.over(bg, 0.12).css(),
		"--font":        family,
		"--code":        family,
		"--logo-invert": invert,
		"--tk-s":        green.css(), "--tk-k": magenta.css(), "--tk-f": blue.css(),
		"--tk-n": orange.css(), "--tk-v": cyan.css(), "--tk-o": magenta.css(), "--tk-c": dim.css(),
		"--om-edge":       edge.css(),
		"--om-border":     strconv.Itoa(max(border, 1)) + "px",
		"--om-radius":     strconv.Itoa(max(rounding, 0)) + "px",
		"--om-size":       strconv.FormatFloat(size, 'f', -1, 64) + "px",
		"--om-hover":      fg.alpha(hoverA).css(),
		"--om-hover-line": fg.alpha(num("controls.hover-cursor-border-alpha", 0.25)).css(),
		"--om-sel":        selFg.alpha(selA).css(),
		"--om-sel-line":   get(shell, fg, "menu.selected-border").alpha(num("menu.selected-border-alpha", 0.25)).css(),
		"--om-cyan":       cyan.css(),
		"--om-magenta":    magenta.css(),
		"--om-orange":     orange.css(),
	}
	return v, mode
}

var (
	mu     sync.Mutex
	cached Theme
	seen   string // the theme's files' stamp cached was read at
	asked  time.Time
	// the font and Hyprland's corners and border, asked of
	// omarchy-font-current and hyprctl only when their own files change: a
	// theme set reloads Hyprland, and hyprctl asked meanwhile can stall for
	// seconds, so a new theme is read from its files alone
	desk     string // the font's and Hyprland's files' stamp they were asked at
	font     string
	rounding int
	border   int
)

// the files whose change changes the look: the theme's, and the font's
// (omarchy-font-set writes fontconfig's) and Hyprland's config
func themeFiles(dir string) []string {
	return []string{
		filepath.Join(dir, "colors.toml"),
		filepath.Join(dir, "shell.toml"),
		filepath.Join(filepath.Dir(dir), "theme.name"),
	}
}

func deskFiles() []string {
	home, _ := os.UserHomeDir()
	cfg := appdir.Getenv("XDG_CONFIG_HOME")
	if cfg == "" {
		cfg = filepath.Join(home, ".config")
	}
	hypr, _ := filepath.Glob(filepath.Join(cfg, "hypr", "*"))
	return append([]string{filepath.Join(cfg, "fontconfig", "fonts.conf")}, hypr...)
}

func stampOf(files []string) string {
	var b strings.Builder
	for _, f := range files {
		if fi, err := os.Stat(f); err == nil {
			fmt.Fprintf(&b, "%s:%d:%d;", filepath.Base(f), fi.ModTime().UnixNano(), fi.Size())
		}
	}
	return b.String()
}

// Current is the theme as it is now: read again only when one of its files
// has changed, and those looked at no more than once a second.
func Current() (Theme, bool) {
	dir := ThemeDir()
	if dir == "" {
		return Theme{}, false
	}
	mu.Lock()
	defer mu.Unlock()
	if !asked.IsZero() && time.Since(asked) < time.Second && cached.Stamp != "" {
		return cached, true
	}
	asked = time.Now()
	stamp, d := stampOf(themeFiles(dir)), stampOf(deskFiles())
	if stamp == seen && d == desk && cached.Stamp != "" {
		return cached, true
	}
	if d != desk || cached.Stamp == "" {
		font = fontName()
		rounding, border = hyprInt("decoration:rounding", 0), hyprInt("general:border_size", 2)
		desk = d
	}
	colors, _ := os.ReadFile(filepath.Join(dir, "colors.toml"))
	shell, _ := os.ReadFile(filepath.Join(dir, "shell.toml"))
	name, _ := os.ReadFile(filepath.Join(filepath.Dir(dir), "theme.name"))
	vars, mode := Vars(Parse(colors), Parse(shell), font, rounding, border)
	seen = stamp
	cached = Theme{
		Name: strings.TrimSpace(string(name)), Mode: mode, Vars: vars,
		Stamp: fmt.Sprintf("%x", fnv(stamp+d+font+strconv.Itoa(rounding)+strconv.Itoa(border))),
	}
	return cached, true
}

func fnv(s string) uint64 {
	h := uint64(14695981039346656037)
	for i := 0; i < len(s); i++ {
		h ^= uint64(s[i])
		h *= 1099511628211
	}
	return h
}

// fontName is the font Omarchy sets for everything, as omarchy-font-current
// says.
func fontName() string {
	if f := os.Getenv("MAGPIE_OMARCHY_FONT"); f != "" {
		return f
	}
	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
	defer cancel()
	out, err := proc.CommandContext(ctx, "omarchy-font-current").Output()
	if err != nil {
		return ""
	}
	return strings.TrimSpace(string(out))
}

// hyprInt is one of Hyprland's integer options ("int: 0"), or fallback when
// Hyprland doesn't answer.
func hyprInt(option string, fallback int) int {
	if os.Getenv("HYPRLAND_INSTANCE_SIGNATURE") == "" {
		return fallback
	}
	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
	defer cancel()
	out, err := proc.CommandContext(ctx, "hyprctl", "getoption", option).Output()
	if err != nil {
		return fallback
	}
	for _, line := range strings.Split(string(out), "\n") {
		if v, ok := strings.CutPrefix(strings.TrimSpace(line), "int:"); ok {
			if n, err := strconv.Atoi(strings.TrimSpace(v)); err == nil {
				return n
			}
		}
	}
	return fallback
}