blight : Backlight Idle Daemon for FreeBSD/KDE/Plasma/Wayland

pkg install python3

which python3
# should be /usr/local/bin/python3

mkdir -p ~/bin
# paste the script content into ~/bin/blight
chmod +x ~/bin/blight

echo $PATH | grep -o "$HOME/bin"

# Should show crw-rw---- root video
ls -la /dev/backlight/backlight0

# Should show crw-rw-rw- root wheel (world readable)
ls -la /dev/psm0

cat > ~/.config/plasma-workspace/env/blight.sh << 'EOF'
#!/bin/sh
blight start
EOF
chmod +x ~/.config/plasma-workspace/env/blight.sh

blight                   # start (daemonizes)
blight start             # same
blight stop              # stop and restore brightness
blight status            # show running state and current brightness
blight -f                # run in foreground (no daemonize)
blight -f -v             # foreground + verbose logging to stderr
blight -t 60             # start with 60 second timeout
blight -f -v -t 15       # foreground, verbose, 15s timeout (testing)

IDLE_TIMEOUT  = 300           # seconds before blanking (default: 5 min)
BACKLIGHT     = "/dev/backlight/backlight0"
INPUT_DEVICES = ["/dev/psm0", "/dev/input/event5", "/dev/input/event10"]  # trackpad (PS/2), Logitech Bolt mouse
PIDFILE       = "/tmp/blight.pid"
LOGFILE       = "/tmp/blight.log"
SELECT_CHUNK  = 2.0           # select() polling interval in seconds

kldstat | grep evdev
ls /dev/input/

tail -f /tmp/blight.log
blight status

blight stop
blight -f -v -t 15

ls -la ~/.config/plasma-workspace/env/blight.sh
cat ~/.config/plasma-workspace/env/blight.sh

backlight -f /dev/backlight/backlight0 100

#!/usr/local/bin/python3
"""
blight - backlight idle daemon for FreeBSD KDE Plasma Wayland
Watches input devices for activity via select().
After IDLE_TIMEOUT seconds of no activity, dims backlight to 0.
On any activity while dimmed, restores previous brightness.

No D-Bus. No logind. No powerdevil. Just /dev/psm0 and /dev/backlight/.
"""

import os
import sys
import select
import time
import subprocess
import signal
import logging
import argparse

# --- config ---
IDLE_TIMEOUT  = 300           # seconds before blanking
BACKLIGHT     = "/dev/backlight/backlight0"
INPUT_DEVICES = ["/dev/psm0", "/dev/input/event5", "/dev/input/event10"]  # trackpad (PS/2), Logitech Bolt mouse
PIDFILE       = "/tmp/blight.pid"
LOGFILE       = "/tmp/blight.log"
SELECT_CHUNK  = 2.0           # select() timeout in seconds
# --------------

log = logging.getLogger("blight")


def setup_logging(verbose=False):
    level = logging.DEBUG if verbose else logging.INFO
    logging.basicConfig(
        filename=LOGFILE,
        level=level,
        format="%(asctime)s %(levelname)s %(message)s",
        datefmt="%Y-%m-%d %H:%M:%S",
    )
    if verbose:
        logging.getLogger().addHandler(logging.StreamHandler())


def get_brightness():
    try:
        out = subprocess.check_output(
            ["backlight", "-f", BACKLIGHT], text=True, stderr=subprocess.DEVNULL
        )
        return int(out.strip().split()[-1])
    except Exception as e:
        log.warning(f"get_brightness failed: {e}")
        return 100


def set_brightness(val):
    val = max(0, min(100, int(val)))
    try:
        subprocess.call(["backlight", "-f", BACKLIGHT, str(val)], stderr=subprocess.DEVNULL)
        log.debug(f"set_brightness -> {val}")
    except Exception as e:
        log.error(f"set_brightness({val}) failed: {e}")


def write_pidfile():
    with open(PIDFILE, "w") as f:
        f.write(str(os.getpid()) + "\n")


def remove_pidfile():
    try:
        os.unlink(PIDFILE)
    except FileNotFoundError:
        pass


def run(idle_timeout=IDLE_TIMEOUT, verbose=False):
    setup_logging(verbose)
    write_pidfile()
    log.info(f"Started : timeout={idle_timeout}s backlight={BACKLIGHT}")

    saved_brightness = None  # None = screen active

    def handle_signal(signum, frame):
        log.info("Caught signal, restoring brightness and exiting")
        if saved_brightness is not None:
            set_brightness(saved_brightness)
        remove_pidfile()
        sys.exit(0)

    signal.signal(signal.SIGTERM, handle_signal)
    signal.signal(signal.SIGINT, handle_signal)

    fds = []
    for dev in INPUT_DEVICES:
        try:
            fds.append(os.open(dev, os.O_RDONLY | os.O_NONBLOCK))
            log.info(f"Watching {dev}")
        except OSError as e:
            log.warning(f"Cannot open {dev}: {e} (skipping)")

    if not fds:
        log.error("No input devices available, exiting")
        remove_pidfile()
        sys.exit(1)

    last_activity = time.monotonic()

    while True:
        try:
            readable, _, _ = select.select(fds, [], [], SELECT_CHUNK)
        except Exception as e:
            log.error(f"select() error: {e}")
            time.sleep(1)
            continue

        if readable:
            for fd in readable:
                try:
                    os.read(fd, 4096)
                except OSError:
                    pass

            last_activity = time.monotonic()

            if saved_brightness is not None:
                log.info(f"Activity : restoring brightness to {saved_brightness}")
                set_brightness(saved_brightness)
                saved_brightness = None
        else:
            idle = time.monotonic() - last_activity
            if idle >= idle_timeout and saved_brightness is None:
                current = get_brightness()
                if current > 0:
                    saved_brightness = current
                    log.info(f"Idle {idle:.0f}s : blanking (saved={saved_brightness})")
                    set_brightness(0)


def stop():
    if not os.path.exists(PIDFILE):
        print("blight not running")
        return
    try:
        with open(PIDFILE) as f:
            pid = int(f.read().strip())
        os.kill(pid, signal.SIGTERM)
        print(f"blight stopped (pid {pid})")
    except (ValueError, ProcessLookupError, PermissionError) as e:
        print(f"Failed to stop blight: {e}")


def status():
    if not os.path.exists(PIDFILE):
        print("blight not running")
        return
    try:
        with open(PIDFILE) as f:
            pid = int(f.read().strip())
        os.kill(pid, 0)
        print(f"blight running (pid {pid})")
        print(f"brightness: {get_brightness()}")
    except (ValueError, ProcessLookupError):
        print("blight not running (stale pidfile)")
        remove_pidfile()


def main():
    parser = argparse.ArgumentParser(description="blight : backlight idle daemon")
    parser.add_argument("command", nargs="?", default="start",
                        choices=["start", "stop", "status"])
    parser.add_argument("-t", "--timeout", type=int, default=IDLE_TIMEOUT,
                        help=f"idle timeout in seconds (default: {IDLE_TIMEOUT})")
    parser.add_argument("-v", "--verbose", action="store_true")
    parser.add_argument("-f", "--foreground", action="store_true",
                        help="run in foreground, don't daemonize")
    args = parser.parse_args()

    if args.command == "stop":
        stop(); return
    if args.command == "status":
        status(); return

    if os.path.exists(PIDFILE):
        try:
            with open(PIDFILE) as f:
                pid = int(f.read().strip())
            os.kill(pid, 0)
            print(f"blight already running (pid {pid})")
            sys.exit(1)
        except (ValueError, ProcessLookupError):
            remove_pidfile()

    if args.foreground:
        run(idle_timeout=args.timeout, verbose=args.verbose)
    else:
        pid = os.fork()
        if pid > 0:
            print(f"blight started (pid {pid})")
            sys.exit(0)
        os.setsid()
        if os.fork() > 0:
            sys.exit(0)
        for fd_num, devnull_mode in ((0, "r"), (1, "w"), (2, "w")):
            with open(os.devnull, devnull_mode) as dn:
                os.dup2(dn.fileno(), fd_num)
        run(idle_timeout=args.timeout, verbose=args.verbose)


if __name__ == "__main__":
    main()