fix(state): lock staterc and replace it atomically

CHANGELOG.md

@@ -20,6 +20,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 
 
 ### Fixed
+- State: `~/.local/state/hyde/staterc` no longer loses entries when two HyDE commands write it at once (#2194). `waybar.py`, `set_conf()` and the Lua selectors (workflows, animations, layouts, shaders) each read staterc and rewrote it in place, without a lock. A writer that read it during another one's rewrite saw an empty file and wrote back only its own key, so two overlapping `hyde-shell waybar --set` calls could wipe it down to one line and reset the workflow, animation, theme and shader. All three now take an `flock` on `staterc.lock` and replace staterc through a temp file and a rename, so it is never seen half written. Bash and Lua share the new `staterc.sh`, which also stores values literally: `set_conf()` used `sed`'s `c` command, which ate backslashes, and appended a third copy of a key that was already there twice
 - Keybinds: `SUPER + T/E/B/C` (terminal, file manager, browser, editor) now launch the app configured in `config.toml` instead of always falling back to the `variables.lua` default (#2087). `key_binds.lua` loads before `dynamic.lua` merges the user's `~/.config/hyde/config.toml`, so binding `hl.dsp.exec_cmd(hyde.config.app.terminal)` read and froze the pre-merge default at bind time. The four binds now use `hyde.config.exec("app.terminal")` (and the matching paths for the others), which resolves the config value at keypress time instead.
 - Waybar: the sensors module recovers from an empty or invalid saved page instead of crashing on every refresh.
 - Waybar: the bar's systemd unit now survives a prior crash loop (#2160). `run_waybar()` and `--watch` launch it via `systemd-run --unit=hyde-<session>-bar.service`, but without `--collect` a unit that lands in `failed` (e.g. `start-limit-hit`) keeps that name until it is manually `reset-failed` or garbage-collected later. The next `systemd-run` with the same name was then rejected ("Unit already exists"), so `hyde-shell reload` and `waybar --update` redeployed the CSS but the bar stayed down. `--collect` makes systemd free the name as soon as the unit fails, so the next launch recreates it cleanly

Configs/.local/lib/hyde/globalcontrol.sh

@@ -299,15 +299,9 @@ get_aurhlpr() {
         aurhlpr="paru"
     fi
 }
+# Locked, atomic and literal; shared with Lua's staterc_set (see staterc.sh).
 set_conf() {
-    local varName="$1"
-    local varData="$2"
-    touch "$XDG_STATE_HOME/hyde/staterc"
-    if [ "$(grep -c "^$varName=" "$XDG_STATE_HOME/hyde/staterc")" -eq 1 ]; then
-        sed -i "/^$varName=/c$varName=\"$varData\"" "$XDG_STATE_HOME/hyde/staterc"
-    else
-        echo "$varName=\"$varData\"" >>"$XDG_STATE_HOME/hyde/staterc"
-    fi
+    "$scrDir/staterc.sh" set "$1" "$2"
 }
 set_hash() {
     local hashImage="$1"

Configs/.local/lib/hyde/luautils/global/state.lua

@@ -52,29 +52,34 @@ function S.staterc_get(key)
     return nil
 end
 
+local function sh_quote(s)
+    return "'" .. tostring(s):gsub("'", "'\\''") .. "'"
+end
+
+-- staterc.sh sits next to luautils/; found from this file's own path, like
+-- luautils/init.lua finds HYDE_SCRIPTS_PATH, else where globalcontrol.sh
+-- puts $scrDir.
+local function find_staterc_helper()
+    local src = debug.getinfo(1, "S").source
+    local dir = src:sub(1, 1) == "@" and src:sub(2):match("(.*/)luautils/global/state%.lua$")
+    if dir then
+        return dir .. "staterc.sh"
+    end
+    return (os.getenv("LIB_DIR") or (os.getenv("HOME") .. "/.local/lib")) .. "/hyde/staterc.sh"
+end
+local staterc_helper = find_staterc_helper()
+
 --- Write (or replace) a key in staterc in bash KEY="value" format.
+-- Goes through staterc.sh, which locks staterc against waybar.py and
+-- set_conf() and replaces it atomically (HyDE-Project/HyDE#2194).
+-- Raises an error if the write fails or the key is not a shell variable name.
 function S.staterc_set(key, value)
-    ensure_dir(xdg.state .. "/hyde")
-    local lines = {}
-    local found = false
-    local f = io.open(staterc_path, "r")
-    if f then
-        for line in f:lines() do
-            if line:match("^" .. key .. "=") then
-                lines[#lines + 1] = key .. '="' .. tostring(value) .. '"'
-                found = true
-            else
-                lines[#lines + 1] = line
-            end
-        end
-        f:close()
-    end
-    if not found then
-        lines[#lines + 1] = key .. '="' .. tostring(value) .. '"'
+    -- Pass xdg.state on, so the helper writes the staterc this module reads.
+    local ok = os.execute("XDG_STATE_HOME=" .. sh_quote(xdg.state) .. " " .. sh_quote(staterc_helper)
+        .. " set " .. sh_quote(key) .. " " .. sh_quote(value))
+    if ok ~= true and ok ~= 0 then
+        error("staterc_set failed: " .. tostring(key))
     end
-    local out = assert(io.open(staterc_path, "w"))
-    out:write(table.concat(lines, "\n") .. "\n")
-    out:close()
 end
 
 -- ── lua_state (fast Lua-only cache, per-selector .lua stub files) ─────────────

Configs/.local/lib/hyde/staterc.sh

@@ -0,0 +1,72 @@
+#!/usr/bin/env bash
+##
+# Locked, atomic writer for $XDG_STATE_HOME/hyde/staterc.
+#
+# Usage: staterc.sh set KEY VALUE
+#
+# waybar.py, set_conf() and the Lua selectors all rewrite staterc. Unlocked
+# and truncated in place, two of them running at once could wipe it down to
+# one line, since a writer that read it mid-rewrite saw an empty file
+# (HyDE-Project/HyDE#2194). Here the read-modify-write runs under an flock
+# on staterc.lock, which waybar.py takes too (fcntl.flock is the same lock),
+# and the result replaces staterc with a rename, so a script sourcing it
+# never sees half a file.
+#
+# The value is written literally: it reaches awk through the environment,
+# not through sed's c command, which ate backslashes ("a\nb" became two
+# lines). A key present twice is collapsed instead of appended again.
+#
+# Do not delete staterc.lock while it is held: the lock lives on the open
+# file, so a second writer would lock a new file at the same path and run
+# concurrently (same as wallpaper_acquire_lock in globalcontrol.sh).
+#
+# Exit status: 0 written, 1 write failed, 2 usage error.
+##
+
+if [ "$#" -ne 3 ] || [ "$1" != "set" ]; then
+    echo "usage: staterc.sh set KEY VALUE" >&2
+    exit 2
+fi
+key=$2
+if [[ ! "$key" =~ ^[A-Za-z_][A-Za-z0-9_]*$ ]]; then
+    echo "staterc.sh: invalid key '$key'" >&2
+    exit 2
+fi
+
+state_dir="${XDG_STATE_HOME:-$HOME/.local/state}/hyde"
+staterc="$state_dir/staterc"
+mkdir -p "$state_dir" || exit 1
+
+# A writer that can't get the lock in time still writes: losing the setting
+# is worse than the rare race it would otherwise wait out. The braces keep
+# 2>/dev/null to the open: on a bare exec it would silence the whole script.
+lock_wait=${STATERC_LOCK_WAIT:-10}
+if { exec {lock_fd}>"$state_dir/staterc.lock"; } 2>/dev/null; then
+    flock -w "$lock_wait" "$lock_fd" ||
+        echo "staterc.sh: staterc is still locked after ${lock_wait}s, writing without the lock" >&2
+else
+    echo "staterc.sh: cannot open staterc.lock, writing without the lock" >&2
+fi
+
+tmp=$(mktemp "$state_dir/.staterc.XXXXXX" 2>/dev/null) || exit 1
+trap 'rm -f "$tmp"' EXIT
+
+# Replace the first KEY= line, drop later duplicates, append if absent.
+src=/dev/null
+[ -f "$staterc" ] && src=$staterc
+STATERC_VALUE=$3 awk -v key="$key" '
+    BEGIN { line = key "=\"" ENVIRON["STATERC_VALUE"] "\"" }
+    index($0, key "=") == 1 { if (!done) { print line; done = 1 }; next }
+    { print }
+    END { if (!done) print line }
+' "$src" >"$tmp" || exit 1
+
+# mktemp creates 0600: keep the old file's mode, or give a new one what a
+# plain redirect would (0666 minus the umask).
+if [ -f "$staterc" ]; then
+    chmod --reference="$staterc" "$tmp"
+else
+    chmod "$(printf '%o' $((0666 & ~0$(umask))))" "$tmp"
+fi || exit 1
+
+mv -f "$tmp" "$staterc" || exit 1

Configs/.local/lib/hyde/waybar.py

@@ -1,5 +1,7 @@
 #!/usr/bin/env python3
 # TODO:Refactor. This what happens when you just want it to work lol.
+import contextlib
+import fcntl
 import json
 import os
 import glob
@@ -11,6 +13,7 @@
 import sys
 import hashlib
 import signal
+import tempfile
 
 from pathlib import Path
 
@@ -152,35 +155,98 @@ def get_config_value(key, default=None):
     return default
 
 
-def set_state_value(key, value):
-    """Set or update a value in the state file, removing any duplicates."""
+@contextlib.contextmanager
+def _staterc_lock():
+    """Hold the flock on staterc.lock that staterc.sh (set_conf, Lua) takes too.
+
+    Unlocked, two writers rewriting staterc at once could wipe it down to one
+    line (HyDE-Project/HyDE#2194). fcntl.flock is the same lock as the
+    flock command. A writer still waiting after 10s writes anyway: losing the
+    setting is worse than the rare race. Never delete staterc.lock.
+    """
     STATE_FILE.parent.mkdir(parents=True, exist_ok=True)
+    try:
+        lock = open(STATE_FILE.with_name("staterc.lock"), "a")
+    except OSError as exc:
+        # e.g. left root-owned by a sudo run; staterc.sh writes on too.
+        logger.warning(f"cannot open staterc.lock ({exc}), writing without the lock")
+        yield
+        return
+    with lock:
+        deadline = time.monotonic() + 10
+        while True:
+            try:
+                fcntl.flock(lock, fcntl.LOCK_EX | fcntl.LOCK_NB)
+                break
+            except BlockingIOError:
+                if time.monotonic() >= deadline:
+                    logger.warning("staterc is still locked after 10s, writing without the lock")
+                    break
+                time.sleep(0.05)
+            except OSError as exc:
+                logger.warning(f"cannot lock staterc.lock ({exc}), writing without the lock")
+                break
+        yield
 
-    if not STATE_FILE.exists():
-        with open(STATE_FILE, "w") as file:
-            file.write(f"{key}={value}\n")
-        return True
 
-    existing_lines = []
-    seen_keys = set()
-    if os.path.exists(STATE_FILE):
-        with open(STATE_FILE, "r") as file:
-            for line in file:
-                line = line.strip()
-                if not line:
-                    continue
-                try:
-                    current_key = line.split("=", 1)[0]
-                    if current_key not in seen_keys and current_key != key:
-                        existing_lines.append(line)
-                        seen_keys.add(current_key)
-                except Exception:
-                    existing_lines.append(line)
+def _replace_state_file(text):
+    """Replace staterc with text in one step, so no reader sees it half written."""
+    fd, tmp_path = tempfile.mkstemp(dir=STATE_FILE.parent, prefix=".staterc.")
+    try:
+        with os.fdopen(fd, "w") as file:
+            file.write(text)
+        # mkstemp creates the file as 0600; keep the old mode, or give a new
+        # file what open(..., "w") would (0666 minus the umask).
+        if STATE_FILE.exists():
+            shutil.copymode(STATE_FILE, tmp_path)
+        else:
+            umask = os.umask(0)
+            os.umask(umask)
+            os.chmod(tmp_path, 0o666 & ~umask)
+        os.replace(tmp_path, STATE_FILE)
+    except BaseException:
+        if os.path.exists(tmp_path):
+            os.unlink(tmp_path)
+        raise
+
+
+def _add_missing_state_values(values):
+    """Add the keys of values that staterc still lacks, in one locked step.
+
+    Returns the keys added. A key another writer set in the meantime is kept.
+    """
+    with _staterc_lock():
+        text = STATE_FILE.read_text() if STATE_FILE.exists() else ""
+        present = {line.split("=", 1)[0] for line in text.splitlines() if "=" in line}
+        added = [key for key in values if key not in present]
+        if added:
+            if text and not text.endswith("\n"):
+                text += "\n"
+            _replace_state_file(text + "".join(f"{key}={values[key]}\n" for key in added))
+    return added
+
 
-    existing_lines.append(f"{key}={value}")
+def set_state_value(key, value):
+    """Set or update a value in the state file, removing any duplicates."""
+    with _staterc_lock():
+        existing_lines = []
+        seen_keys = set()
+        if STATE_FILE.exists():
+            with open(STATE_FILE, "r") as file:
+                for line in file:
+                    line = line.strip()
+                    if not line:
+                        continue
+                    try:
+                        current_key = line.split("=", 1)[0]
+                        if current_key not in seen_keys and current_key != key:
+                            existing_lines.append(line)
+                            seen_keys.add(current_key)
+                    except Exception:
+                        existing_lines.append(line)
 
-    with open(STATE_FILE, "w") as file:
-        file.write("\n".join(existing_lines) + "\n")
+        existing_lines.append(f"{key}={value}")
+        _replace_state_file("\n".join(existing_lines) + "\n")
 
     return True
 
@@ -255,53 +321,50 @@ def get_current_layout_from_config():
 
 
 def ensure_state_file():
-    """Ensure the state file has the necessary entries."""
+    """Ensure the state file has the necessary entries.
+
+    The values are worked out first, then added in one locked step that skips
+    any key another writer set in the meantime. Holding the lock while working
+    them out would deadlock: get_current_layout_from_config() writes staterc
+    too (HyDE-Project/HyDE#2194).
+    """
     STATE_FILE.parent.mkdir(parents=True, exist_ok=True)
 
     logger.debug(f"Ensuring state file exists at: {STATE_FILE}")
 
+    keys = ("WAYBAR_LAYOUT_PATH", "WAYBAR_LAYOUT_NAME", "WAYBAR_STYLE_PATH")
     if not STATE_FILE.exists():
         logger.debug("State file does not exist, creating it")
         current_layout = get_current_layout_from_config()
-        layout_name = (
-            os.path.basename(current_layout).replace(".jsonc", "") if current_layout else ""
+        if not current_layout:
+            STATE_FILE.touch()
+            logger.warning("No layout found to write to state file")
+            return
+        missing = set(keys)
+    else:
+        with open(STATE_FILE, "r") as file:
+            lines = file.readlines()
+        missing = {key for key in keys if not any(line.startswith(f"{key}=") for line in lines)}
+        if not missing:
+            return
+        logger.debug("State file is missing entries, updating it")
+        # A layout already in staterc is the one to describe; look it up only
+        # when the path itself is missing.
+        current_layout = (
+            get_current_layout_from_config()
+            if "WAYBAR_LAYOUT_PATH" in missing
+            else get_state_value("WAYBAR_LAYOUT_PATH")
         )
-        style_path = resolve_style_path(current_layout) if current_layout else ""
-
-        with open(STATE_FILE, "w") as file:
-            if current_layout:
-                file.write(f"WAYBAR_LAYOUT_PATH={current_layout}\n")
-                file.write(f"WAYBAR_LAYOUT_NAME={layout_name}\n")
-                file.write(f"WAYBAR_STYLE_PATH={style_path}\n")
-                logger.debug(f"Created state file with layout: {current_layout}")
-            else:
-                logger.warning("No layout found to write to state file")
-        return
-
-    with open(STATE_FILE, "r") as file:
-        lines = file.readlines()
-
-    layout_path_exists = any(line.startswith("WAYBAR_LAYOUT_PATH=") for line in lines)
-    layout_name_exists = any(line.startswith("WAYBAR_LAYOUT_NAME=") for line in lines)
-    style_path_exists = any(line.startswith("WAYBAR_STYLE_PATH=") for line in lines)
+        if not current_layout:
+            return
 
-    if not layout_path_exists or not layout_name_exists or not style_path_exists:
-        logger.debug("State file is missing entries, updating it")
-        current_layout = get_current_layout_from_config() if not layout_path_exists else None
-        if current_layout:
-            layout_name = os.path.basename(current_layout).replace(".jsonc", "")
-            style_path = resolve_style_path(current_layout)
-
-            with open(STATE_FILE, "a") as file:
-                if not layout_path_exists:
-                    file.write(f"WAYBAR_LAYOUT_PATH={current_layout}\n")
-                    logger.debug(f"Added WAYBAR_LAYOUT_PATH={current_layout}")
-                if not layout_name_exists:
-                    file.write(f"WAYBAR_LAYOUT_NAME={layout_name}\n")
-                    logger.debug(f"Added WAYBAR_LAYOUT_NAME={layout_name}")
-                if not style_path_exists:
-                    file.write(f"WAYBAR_STYLE_PATH={style_path}\n")
-                    logger.debug(f"Added WAYBAR_STYLE_PATH={style_path}")
+    values = {
+        "WAYBAR_LAYOUT_PATH": current_layout,
+        "WAYBAR_LAYOUT_NAME": os.path.basename(current_layout).replace(".jsonc", ""),
+        "WAYBAR_STYLE_PATH": resolve_style_path(current_layout),
+    }
+    for key in _add_missing_state_values({key: values[key] for key in keys if key in missing}):
+        logger.debug(f"Added {key}={values[key]}")
 
 
 def resolve_style_path(layout_path):