Luigit
repositories / dotfiles

dotfiles

bugabingas dorkfiles

owned by admin

quickshell/nuguland/runtime/theme.nu

Raw
# Nuguland appearance compatibility boundary; Config owns the daily UI.
#
# The existing nugu/mode file is desired state, not a cross-app transaction.
# Installed Nugu artifacts are inputs; generators are never runtime dependencies.
const self = path self
const modes = [dark light]

def fail [message: string] { error make {msg: $message} }

def kind [path: string] {
	if ($path | path exists --no-symlink) { $path | path type } else { "missing" }
}

def regular-or-missing [path: string] {
	if (kind $path) not-in [missing file] { fail $"refusing non-regular runtime file: ($path)" }
}

def directory-or-missing [path: string] {
	if (kind $path) not-in [missing dir] { fail $"refusing non-directory runtime path: ($path)" }
}

def roots [] {
	let home = $env.HOME
	let state = ($env.XDG_STATE_HOME? | default "")
	let config = ($env.XDG_CONFIG_HOME? | default "")
	let roots = {
		home: $home
		directory: ((if ($state | is-empty) { $home | path join .local state } else { $state }) | path join nugu)
		config: (if ($config | is-empty) { $home | path join .config } else { $config })
	}
	if not (($roots.directory | str starts-with "/") and ($roots.config | str starts-with "/")) {
		fail "XDG state/config paths must be absolute"
	}
	$roots
}

# The selected mode; a missing or unreadable selection is dark.
def effective [directory: string] {
	let value = try { open --raw ($directory | path join mode) | into binary | decode utf-8 | str trim } catch { "" }
	if $value in $modes { $value } else { "dark" }
}

# Both variants: an incomplete installation must not select a new mode.
def installed [config: string] {
	$modes | each {|mode|
		let files = [
			(open --raw ($config | path join niri themes $"nugu-($mode).kdl") | into binary)
			(open --raw ($config | path join aerc stylesets $"nugu-($mode)") | into binary)
		]
		if ($files | any {|data| $data | is-empty }) { fail $"empty installed ($mode) theme" }
		{mode: $mode, files: $files}
	}
}

# A temporary beside `path` holding `data`, or null when `path` already holds it.
def stage [path: string, data: binary] {
	regular-or-missing $path
	if ($path | path exists) and (open --raw $path | into binary) == $data { return null }
	let made = (^mktemp -p ($path | path dirname) .theme-XXXXXX | complete)
	if $made.exit_code != 0 { fail ($made.stderr | str trim) }
	let temporary = ($made.stdout | str trim)
	try { $data | save --raw --force $temporary } catch {|error|
		rm --force $temporary
		fail $error.msg
	}
	$temporary
}

def replace [temporary: string, path: string] {
	let moved = (^mv -T -f $temporary $path | complete)
	if $moved.exit_code != 0 { fail ($moved.stderr | str trim) }
}

# A consumer's failure line, or null; each consumer has five seconds.
def consumer [label: string, accepted: list<int>, command: list<string>] {
	let result = (^timeout 5 ...$command | complete)
	if $result.exit_code in $accepted { null } else {
		$"($label): ($command.0) exited ($result.exit_code): ($result.stderr | str trim)"
	}
}

# Runs under the state lock: select, stage, commit authority, then publish.
def reconcile [operation: string, wanted?: string] {
	let roots = roots
	let directory = $roots.directory
	let current = (effective $directory)
	let mode = match $operation {
		"set" => $wanted
		"toggle" => (if $current == "dark" { "light" } else { "dark" })
		_ => $current
	}
	let files = (installed $roots.config | where mode == $mode | first | get files)
	let bridge = ($roots.home | path join .nugu-runtime)
	if (kind $bridge) != "missing" and ((kind $bridge) != "symlink" or (^readlink $bridge | str trim) != $directory) {
		fail $"refusing unrelated runtime path: ($bridge)"
	}
	directory-or-missing ($directory | path join aerc)
	mkdir ($directory | path join aerc)
	let targets = [($directory | path join niri.kdl) ($directory | path join aerc nugu)]
	let authority = ($directory | path join mode)
	regular-or-missing $authority
	mut pending = []
	# Stage every file before committing authority; permission/storage
	# failures here cannot change the selected mode or desktop preference.
	let failure = try {
		for index in 0..1 {
			let path = ($targets | get $index)
			$pending ++= [{path: $path, temporary: (stage $path ($files | get $index))}]
		}
		let selection = if $operation == "prepare" { null } else { stage $authority ($"($mode)\n" | into binary) }
		if $selection != null { $pending ++= [{path: $authority, temporary: $selection}] }
		if (kind $bridge) == "missing" {
			let linked = (^ln -s $directory $bridge | complete)
			if $linked.exit_code != 0 { fail ($linked.stderr | str trim) }
		}
		if $selection != null { replace $selection $authority }
		# Authority is now committed. Each consumer can fail independently.
		# Startup / prepare / same-mode set reconcile, never roll back intent.
		mut failures = [(consumer "desktop preference" [0] [gsettings set org.gnome.desktop.interface color-scheme $"prefer-($mode)"])]
		mut mail_ready = false
		for item in ($pending | first 2) {
			let problem = try {
				if $item.temporary != null { replace $item.temporary $item.path }
				null
			} catch {|error| $error.msg }
			if $problem != null { $failures ++= [$"($item.path): ($problem)"] } else if $item.path == $targets.1 { $mail_ready = true }
		}
		if $operation != "prepare" and $mail_ready and ($env.XDG_RUNTIME_DIR? | default "" | is-not-empty) {
			$failures ++= [(consumer "aerc reload" [0 1] [pkill --signal HUP --uid (^id -u | str trim) --exact aerc])]
		}
		let failed = ($failures | compact)
		if ($failed | is-empty) { null } else {
			$"selected ($mode); incomplete reconciliation: ($failed | str join '; '); retry set ($mode)"
		}
	} catch {|error| $error.msg }
	for item in $pending {
		if $item.temporary != null { rm --force $item.temporary }
	}
	if $failure != null { fail $failure }
	$mode
}

def invoke [operation: string, mode?: string] {
	let roots = roots
	if $operation == "status" { return (effective $roots.directory) }
	# Preflight installed inputs before creating even the lock directory.
	installed $roots.config
	for tool in [gsettings pkill flock timeout] {
		if (which $tool | is-empty) { fail $"missing runtime executable: ($tool)" }
	}
	directory-or-missing $roots.directory
	mkdir $roots.directory
	let lock = ($roots.directory | path join .theme.lock)
	regular-or-missing $lock
	let arguments = if $mode == null { [$operation] } else { [$operation $mode] }
	let result = (^flock $lock nu --no-config-file $self --locked ...$arguments | complete)
	if $result.exit_code != 0 { fail ($result.stderr | str trim | str replace --regex '^theme: ' '') }
	$result.stdout | str trim
}

export def status [] { invoke status }
export def prepare [] { invoke prepare }
export def set [mode: string] {
	if $mode not-in $modes { fail $"invalid mode: ($mode)" }
	invoke set $mode
}
export def toggle [] { invoke toggle }

# `nu theme.nu <operation> [mode]`: the mode on stdout, or one plain line on stderr.
def main [operation: string, mode?: string, --locked] {
	try {
		if $operation not-in [status prepare set toggle] { fail $"invalid operation: ($operation)" }
		if ($operation == "set") != ($mode in $modes) { fail "only set requires a mode: dark or light" }
		print (if $locked { reconcile $operation $mode } else { invoke $operation $mode })
	} catch {|error|
		print --stderr $"theme: ($error.msg)"
		exit 1
	}
}