chore(aur): sync PKGBUILD for cmd/ layout, pkgrel 3

- build: ./cmd/streamdeck-lets-go (not '.')
- source: bare filenames (AUR forbids subdirectories)
- install: srcdir root (matching source paths)

.gitignore

@@ -1,4 +1,4 @@
-streamdeck-lets-go
+/streamdeck-lets-go
 *.test
 *.out
 *.exe

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024-2026 Wakatron
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

Makefile

@@ -0,0 +1,33 @@
+BINARY  := streamdeck-lets-go
+MODULE  := streamdeck-lets-go
+CMDDIR  := cmd/streamdeck-lets-go
+PKGARCH := packaging
+
+.PHONY: all build test vet fmt clean install
+
+all: build
+
+build:
+	CGO_ENABLED=1 go build -ldflags "-s -w" -o $(BINARY) ./$(CMDDIR)
+
+test:
+	go test ./...
+
+vet:
+	go vet ./...
+
+fmt:
+	gofmt -l .
+
+clean:
+	rm -f $(BINARY)
+
+install: build
+	install -Dm755 $(BINARY) /usr/local/bin/$(BINARY)
+	install -Dm644 $(PKGARCH)/streamdeck-lets-go.service /usr/lib/systemd/user/streamdeck-lets-go.service
+	install -Dm644 $(PKGARCH)/90-streamdeck.rules /usr/lib/udev/rules.d/90-streamdeck.rules
+
+uninstall:
+	rm -f /usr/local/bin/$(BINARY)
+	rm -f /usr/lib/systemd/user/streamdeck-lets-go.service
+	rm -f /usr/lib/udev/rules.d/90-streamdeck.rules

README.md

@@ -27,7 +27,9 @@
 ### Install from source
 
 ```bash
-go build -o streamdeck-lets-go .
+make build
+# or
+go build -o streamdeck-lets-go ./cmd/streamdeck-lets-go
 ```
 
 ### Run
@@ -47,7 +49,19 @@ Open `http://localhost:9090` in your browser.
 
 ---
 
-## Configuration
+## Project structure
+
+```
+cmd/streamdeck-lets-go   entry point (CLI: daemon, switch, discover)
+internal/
+  config                 JSON config model, load/save/validate
+  deck                   Stream Deck hardware: open, render, brightness, events
+  render                 Key rendering, icon/fonts, PageManager, display outputs
+  web                    HTTP API + embedded Alpine.js SPA
+  daemon                 Event loop, autoswitch, screensaver, actions, gestures
+packaging/               AUR PKGBUILD, systemd unit, udev rule
+Makefile                 build, test, vet, fmt, install
+```
 
 The config file is stored at `~/.config/streamdeck-lets-go/config.json`. You can edit it manually or through the web UI.
 
@@ -127,6 +141,213 @@ Server down!
 
 If no color is specified, the key uses its configured background or the default black.
 
+### Dynamic Key Generators
+
+Generate an entire page of keys dynamically by running any executable (shell script, Python, Go binary, etc.). Useful for game launchers, music collections, Docker containers, monitoring dashboards — anything where the set of keys is not known at config time.
+
+```
+┌──────────────────────────────────────────────────┐
+│  Generator script (any language)                 │
+│  → queries Lutris DB, Steam API, etc.           │
+│  → outputs JSON array of KeyConfig to stdout     │
+│  → receives STREAMDECK_KEY_COUNT env var         │
+└──────────────┬───────────────────────────────────┘
+               │ stdout: [{"index":0,"icon":"...",...}]
+               ▼
+┌──────────────────────────────────────────────────┐
+│  streamdeck-lets-go daemon                       │
+│  → parses JSON                                   │
+│  → merges with static keys (static wins)         │
+│  → renders keys on the deck                      │
+│  → re-runs on interval (default 60s)             │
+└──────────────────────────────────────────────────┘
+```
+
+#### Config
+
+Add `dynamic_keys` to any page:
+
+```json
+{
+  "name": "Games",
+  "icon": "fa:gamepad",
+  "keys": [
+    {
+      "index": 0,
+      "icon": "fa:arrow-left",
+      "actions": [
+        { "trigger": "tap", "type": "page", "page": "main" }
+      ]
+    }
+  ],
+  "dynamic_keys": {
+    "command": "/home/user/bin/game-list",
+    "interval": "120s",
+    "timeout": "15s",
+    "max_keys": 14
+  }
+}
+```
+
+| Field | Type | Default | Description |
+|---|---|---|---|
+| `command` | string | — | Shell command to execute (mutually exclusive with `script`) |
+| `script` | string | — | Path to an executable script; relative paths resolve against `~/.config/streamdeck-lets-go/` |
+| `interval` | string | `"60s"` | How often to re-run the generator (minimum 1s, maximum 24h) |
+| `timeout` | string | `"15s"` | Maximum execution time before the generator is killed |
+| `max_keys` | int | `deck.NumKeys()` | Maximum number of keys to accept (e.g. `13` to reserve 2 for navigation) |
+
+#### Generator contract
+
+The script **must** print a JSON array of key configs to stdout and exit with code 0. Each element supports the full `KeyConfig` schema:
+
+```json
+[
+  {
+    "index": 0,
+    "icon": "/home/user/.local/share/lutris/coverart/cyberpunk-2077.jpg",
+    "label": "Cyberpunk 2077",
+    "font_size": 12,
+    "icon_scale": 1.0,
+    "background": "#222222",
+    "actions": [
+      {
+        "trigger": "tap",
+        "type": "command",
+        "command": "lutris lutris:rungame/cyberpunk-2077",
+        "background": true
+      }
+    ]
+  }
+]
+```
+
+Every field from a static key is available:
+
+| Field | Type | Description |
+|---|---|---|
+| `index` | int | Key position on the deck (0-based) |
+| `icon` | string | Icon source: `fa:terminal`, `emoji:fire`, `@firefox`, `/absolute/path.png`, relative path |
+| `label` | string | Text shown below the icon |
+| `font_size` | number | Font size in points (default 18, recommended 11–14 for labels) |
+| `icon_scale` | number | Icon scale factor (0.0–1.0, default 0.55) |
+| `background` | string | Hex background color `"#222222"` |
+| `actions` | array | Same action schema as static keys — supports all triggers (`tap`, `long_press`, `double_tap`) and all action types (`command`, `builtin`, `script`, `page`, `keyboard`) |
+| `display` | object | Periodic display block (same as static key `display`) — command/script runs on interval and text is overlaid on the key |
+
+#### Merge behavior
+
+Static `keys` (defined directly on the page) and dynamic keys are **merged** at runtime:
+
+| Priority | Source |
+|---|---|
+| 1 (highest) | Static keys — their indices are reserved |
+| 2 | Dynamic keys — fill indices not occupied by static keys |
+
+This lets you keep navigation buttons fixed while the generator fills the rest of the deck:
+
+```
+Static:   [← back] [  ] [  ] [  ] [  ] [  ] [  ] [  ] [  ] [  ] [  ] [  ] [  ] [  ] [  ]
+            index 0   └────────────────────── dynamic (indices 1–14) ──────────────────────→
+```
+
+#### Environment variables
+
+The generator receives these environment variables:
+
+| Variable | Example | Description |
+|---|---|---|
+| `STREAMDECK_KEY_COUNT` | `15` | Maximum number of keys to output (derived from deck model or `max_keys` config) |
+| `STREAMDECK_CONFIG_DIR` | `/home/user/.config/streamdeck-lets-go` | Path to the config directory — useful for finding companion files |
+
+#### Error handling
+
+| Situation | Behavior |
+|---|---|
+| Script fails (non-zero exit, timeout) | Warning logged; previous keys preserved |
+| Script returns empty array `[]` | Only static keys rendered |
+| Script returns invalid JSON | Warning logged; previous keys preserved |
+| Script outputs debug to stderr | Logged at DEBUG level; stdout JSON parsed cleanly |
+| More keys than `max_keys` | Excess keys silently dropped |
+| Generator updates while page is active | Keys re-rendered in place (no flicker) |
+
+#### Examples
+
+**Python — Lutris game launcher**
+
+Place this at `~/.config/streamdeck-lets-go/scripts/lutris-keys`, make executable (`chmod +x`).
+
+```python
+#!/usr/bin/env python3
+import json, os, sqlite3, pathlib
+
+db = pathlib.Path.home() / '.local/share/lutris/pga.db'
+cover = pathlib.Path.home() / '.local/share/lutris/coverart'
+max_keys = int(os.environ.get('STREAMDECK_KEY_COUNT', 15))
+
+if not db.exists():
+    print('[]')
+    exit(0)
+
+conn = sqlite3.connect(db)
+games = conn.execute(
+    "SELECT slug, name FROM games WHERE installed = 1 ORDER BY name"
+).fetchall()
+conn.close()
+
+keys = []
+for idx, (slug, name) in enumerate(games):
+    if idx >= max_keys:
+        break
+    icon = next(cover.glob(f'{slug}.*'), None)
+    key = {
+        "index": idx,
+        "icon_scale": 1.0,
+        "actions": [{
+            "trigger": "tap",
+            "type": "command",
+            "command": f"lutris lutris:rungame/{slug}",
+            "background": True
+        }]
+    }
+    if icon:
+        key["icon"] = str(icon)
+    keys.append(key)
+
+print(json.dumps(keys))
+```
+
+Reference it in config:
+```json
+{
+  "name": "Games",
+  "dynamic_keys": {
+    "script": "scripts/lutris-keys",
+    "interval": "120s"
+  }
+}
+```
+
+**Shell — Simple test generator**
+
+```bash
+#!/bin/sh
+for i in $(seq 0 $((STREAMDECK_KEY_COUNT - 1))); do
+  [ "$i" -gt 0 ] && echo ","
+  printf '{"index":%d,"icon":"fa:hashtag","label":"Item %d"}' "$i" "$i"
+done
+```
+
+Run with any language you like — the only requirement is a valid JSON array on stdout.
+
+#### Tips
+
+- Use `max_keys` to reserve space for static navigation buttons
+- Enable `show_label_background: true` in the global config if labels on full-bleed icons are hard to read
+- Test your generator standalone before wiring it up: `STREAMDECK_KEY_COUNT=15 ./my-generator`
+- For large data sources, pass pagination params through the command string: `"command": "scripts/albums --page 0"`
+- Dynamic keys support `display` blocks — nest monitoring data inside generated keys
+
 ### Gesture timing
 
 Configured in the web UI (Settings → Gesture Timing) or in `config.json`:
@@ -164,9 +385,9 @@ After a configurable idle period the deck dims or shows a custom image.
 ## Building from source
 
 ```bash
-git clone git@git.totmin.ru:en2zmax/streamdeck-lets-go.git
+git clone https://github.com/totmin/streamdeck-lets-go.git
 cd streamdeck-lets-go
-go build -o streamdeck-lets-go .
+make build
 ```
 
 Dependencies:
@@ -191,6 +412,16 @@ Dependencies:
 
 ---
 
+## Credits
+
+This project builds on the work of the following open-source libraries:
+
+- **[dh1tw/streamdeck](https://github.com/dh1tw/streamdeck)** (MIT) — Go protocol driver for Elgato Stream Deck devices
+- **[bearsh/hid](https://github.com/bearsh/hid)** (MIT) — Go USB HID bindings via CGO / libusb
+- **[disintegration/gift](https://github.com/disintegration/gift)** (MIT) — Go Image Filtering Toolkit
+
+---
+
 ## License
 
 MIT

cmd/streamdeck-lets-go/main.go

@@ -1,12 +1,16 @@
 package main
 
 import (
+	"bytes"
 	"context"
+	"encoding/json"
 	"flag"
 	"fmt"
 	"log/slog"
+	"net/http"
 	"os"
 	"os/signal"
+	"strings"
 	"syscall"
 
 	_ "image/gif"
@@ -14,6 +18,8 @@ import (
 	_ "image/png"
 
 	"streamdeck-lets-go/internal/config"
+	"streamdeck-lets-go/internal/daemon"
+	"streamdeck-lets-go/internal/deck"
 )
 
 func main() {
@@ -22,15 +28,16 @@ func main() {
 	fs := flag.NewFlagSet("streamdeck-lets-go", flag.ExitOnError)
 	configPath := fs.String("config", "", "path to config.json (default: ~/.config/streamdeck-lets-go/config.json)")
 	httpAddr := fs.String("addr", ":9090", "web UI listen address")
+	startPage := fs.String("page", "", "page to activate on startup (default: config's default_page)")
 	noDeck := fs.Bool("no-deck", false, "run without Stream Deck hardware (config editing only)")
 	verbose := fs.Bool("v", false, "verbose output")
 
-	if len(os.Args) < 2 {
+	if len(os.Args) < 2 || os.Args[1] == "--help" || os.Args[1] == "-help" || os.Args[1] == "-h" {
 		fmt.Fprintf(os.Stderr, "Usage: streamdeck-lets-go [flags] [command]\n\n")
 		fmt.Fprintf(os.Stderr, "Commands:\n")
-		fmt.Fprintf(os.Stderr, "  daemon  run the Stream Deck daemon with web UI (default)\n")
+		fmt.Fprintf(os.Stderr, "  daemon   run the Stream Deck daemon with web UI (default)\n")
-		fmt.Fprintf(os.Stderr, "  serve   run web UI only (no deck hardware)\n")
+		fmt.Fprintf(os.Stderr, "  switch   switch running daemon to a page (e.g. 'switch games')\n")
-		fmt.Fprintf(os.Stderr, "  discover  list connected Stream Decks\n")
+		fmt.Fprintf(os.Stderr, "  discover list connected Stream Decks\n")
 		fmt.Fprintf(os.Stderr, "\nFlags:\n")
 		fs.PrintDefaults()
 		os.Exit(0)
@@ -42,13 +49,26 @@ func main() {
 	switch cmd {
 	case "daemon":
 		fs.Parse(args)
-	case "serve":
+	case "switch":
 		fs.Parse(args)
-		*noDeck = true
+		if fs.NArg() == 0 {
+			fmt.Fprintf(os.Stderr, "Usage: streamdeck-lets-go switch <page>\n")
+			os.Exit(1)
+		}
+		if err := switchToPage(*httpAddr, fs.Arg(0)); err != nil {
+			fmt.Fprintf(os.Stderr, "error: %v\n", err)
+			os.Exit(1)
+		}
+		fmt.Printf("switched to page %q\n", fs.Arg(0))
+		return
 	case "discover":
 		discover()
 		return
 	default:
+		if cmd == "serve" {
+			fmt.Fprintf(os.Stderr, "streamdeck-lets-go: 'serve' removed; use 'daemon --no-deck' instead\n")
+			os.Exit(1)
+		}
 		fs.Parse(os.Args[1:])
 	}
 
@@ -66,11 +86,12 @@ func main() {
 	defer cancel()
 
 	httpEnabled := true
-	if err := Run(ctx, cfg, RunOptions{
+	if err := daemon.Run(ctx, cfg, daemon.RunOptions{
 		ConfigPath:  *configPath,
 		HTTPAddr:    *httpAddr,
 		HTTPEnabled: httpEnabled,
 		NoDeck:      *noDeck,
+		StartPage:   *startPage,
 	}); err != nil {
 		slog.Error("run", "error", err)
 		os.Exit(1)
@@ -78,7 +99,7 @@ func main() {
 }
 
 func discover() {
-	devices, err := EnumerateDevices()
+	devices, err := deck.EnumerateDevices()
 	if err != nil {
 		slog.Error("discover", "error", err)
 		os.Exit(1)
@@ -92,3 +113,25 @@ func discover() {
 		fmt.Printf("  Serial: %s  Model: %s  PID: 0x%04x\n", d.Serial, d.Model, d.PID)
 	}
 }
+
+// switchToPage tells the running daemon (at httpAddr) to activate the given page
+// by POSTing to its /api/activate-page endpoint.
+func switchToPage(httpAddr, page string) error {
+	host := httpAddr
+	if strings.HasPrefix(host, ":") {
+		host = "127.0.0.1" + host
+	}
+	url := "http://" + host + "/api/activate-page"
+
+	body, _ := json.Marshal(map[string]string{"page": page})
+	resp, err := http.Post(url, "application/json", bytes.NewReader(body))
+	if err != nil {
+		return fmt.Errorf("daemon not running? %v", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		return fmt.Errorf("switch failed (HTTP %d)", resp.StatusCode)
+	}
+	return nil
+}

config.example.json

@@ -40,6 +40,19 @@
             }
           ]
         },
+        {
+          "index": 2,
+          "icon": "fa:gamepad",
+          "label": "Games",
+          "font_size": 11,
+          "actions": [
+            {
+              "trigger": "tap",
+              "type": "page",
+              "page": "games"
+            }
+          ]
+        },
         {
           "index": 7,
           "icon": "fa:chevron-right",
@@ -58,6 +71,23 @@
           ]
         }
       ]
+    },
+    {
+      "name": "games",
+      "icon": "fa:gamepad",
+      "keys": [
+        {
+          "index": 0,
+          "icon": "fa:arrow-left",
+          "actions": [
+            { "trigger": "tap", "type": "page", "page": "main" }
+          ]
+        }
+      ],
+      "dynamic_keys": {
+        "script": "scripts/lutris-keys",
+        "interval": "120s"
+      }
     }
   ],
   "auto_switch": [],

emoji.go

@@ -1,209 +0,0 @@
-package main
-
-import "sync"
-
-var emojiShortcodes = map[string]rune{
-	// media
-	"play_pause":                    0x25B6,
-	"stop":                          0x23F9,
-	"record":                        0x23FA,
-	"eject":                         0x23CF,
-	"track_previous":                0x23EE,
-	"track_next":                    0x23ED,
-	"fast_forward":                  0x23E9,
-	"rewind":                        0x23EA,
-	"shuffle":                       0x1F500,
-	"repeat":                        0x1F501,
-	"repeat_one":                    0x1F502,
-
-	// volume
-	"speaker":                       0x1F50A,
-	"mute":                          0x1F507,
-	"sound":                         0x1F509,
-
-	// navigation
-	"arrow_up":                      0x2B06,
-	"arrow_down":                    0x2B07,
-	"arrow_left":                    0x2B05,
-	"arrow_right":                   0x27A1,
-	"arrows_clockwise":              0x1F503,
-	"arrows_counterclockwise":       0x1F504,
-
-	// status
-	"check":                         0x2705,
-	"heavy_check_mark":              0x2714,
-	"x":                             0x274C,
-	"heavy_multiplication_x":        0x2716,
-	"warning":                       0x26A0,
-	"information_source":            0x2139,
-	"question":                      0x2753,
-	"exclamation":                   0x2757,
-	"white_check_mark":              0x2705,
-	"heavy_plus_sign":               0x2795,
-	"heavy_minus_sign":              0x2796,
-	"heavy_division_sign":           0x2797,
-
-	// actions
-	"gear":                          0x2699,
-	"hammer":                        0x1F528,
-	"wrench":                        0x1F527,
-	"key":                           0x1F511,
-	"lock":                          0x1F512,
-	"unlocked":                      0x1F513,
-	"magnifying_glass":              0x1F50D,
-	"home":                          0x1F3E0,
-	"bookmark":                      0x1F516,
-	"bell":                          0x1F514,
-	"clock":                         0x1F550,
-	"alarm_clock":                   0x23F0,
-	"hourglass":                     0x231B,
-	"calendar":                      0x1F4C5,
-	"envelope":                      0x2709,
-	"camera":                        0x1F4F7,
-	"video_camera":                  0x1F4F9,
-	"microphone":                    0x1F3A4,
-	"telephone":                     0x260E,
-	"phone":                         0x1F4DE,
-	"computer":                      0x1F4BB,
-	"laptop":                        0x1F4BB,
-	"folder":                        0x1F4C1,
-	"open_file_folder":              0x1F4C2,
-	"clipboard":                     0x1F4CB,
-	"memo":                          0x1F4DD,
-	"pencil":                        0x270F,
-	"scissors":                      0x2702,
-	"link":                          0x1F517,
-	"paperclip":                     0x1F4CE,
-	"pushpin":                       0x1F4CC,
-	"trash":                         0x1F5D1,
-	"star":                          0x2B50,
-	"trophy":                        0x1F3C6,
-	"medal":                         0x1F3C5,
-	"target":                        0x1F3AF,
-	"dart":                          0x1F3AF,
-
-	// objects
-	"lightbulb":                     0x1F4A1,
-	"bulb":                          0x1F4A1,
-	"battery":                       0x1F50B,
-	"electric_plug":                 0x1F50C,
-	"rocket":                        0x1F680,
-	"airplane":                      0x2708,
-	"car":                           0x1F697,
-	"bicycle":                       0x1F6B2,
-	"headphones":                    0x1F3A7,
-	"gamepad":                       0x1F3AE,
-	"joystick":                      0x1F579,
-	"musical_note":                  0x1F3B5,
-	"notes":                         0x1F3B6,
-	"printer":                       0x1F5A8,
-	"keyboard":                      0x2328,
-
-	// weather
-	"sun":                           0x2600,
-	"sunny":                         0x2600,
-	"moon":                          0x1F319,
-	"cloud":                         0x2601,
-	"rainbow":                       0x1F308,
-	"fire":                          0x1F525,
-	"flame":                         0x1F525,
-	"zap":                           0x26A1,
-	"lightning":                     0x26A1,
-	"snowflake":                     0x2744,
-	"umbrella":                      0x2602,
-
-	// hearts
-	"heart":                         0x2764,
-	"yellow_heart":                  0x1F49B,
-	"green_heart":                   0x1F49A,
-	"blue_heart":                    0x1F499,
-	"purple_heart":                  0x1F49C,
-	"black_heart":                   0x1F5A4,
-	"broken_heart":                  0x1F494,
-	"two_hearts":                    0x1F495,
-	"sparkling_heart":               0x1F496,
-	"heartpulse":                    0x1F497,
-	"heart_beat":                    0x1F493,
-	"revolving_hearts":              0x1F49E,
-	"cupid":                         0x1F498,
-	"gift_heart":                    0x1F49D,
-
-	// faces
-	"smile":                         0x1F600,
-	"smiley":                        0x1F603,
-	"grinning":                      0x1F604,
-	"blush":                         0x1F60A,
-	"wink":                          0x1F609,
-	"heart_eyes":                    0x1F60D,
-	"kissing_heart":                 0x1F618,
-	"kissing":                       0x1F617,
-	"smirk":                         0x1F60F,
-	"stuck_out_tongue":              0x1F61B,
-	"stuck_out_tongue_winking_eye":  0x1F61C,
-	"sunglasses":                    0x1F60E,
-	"innocent":                      0x1F607,
-	"neutral_face":                  0x1F610,
-	"expressionless":                0x1F611,
-	"thinking":                      0x1F914,
-	"confused":                      0x1F615,
-	"worried":                       0x1F61F,
-	"frown":                         0x1F641,
-	"persevere":                     0x1F623,
-	"tired":                         0x1F62B,
-	"weary":                         0x1F629,
-	"cry":                           0x1F622,
-	"sob":                           0x1F62D,
-	"sweat_smile":                   0x1F605,
-	"joy":                           0x1F602,
-	"relaxed":                       0x263A,
-	"angry":                         0x1F620,
-	"rage":                          0x1F621,
-	"skull":                         0x1F480,
-	"ghost":                         0x1F47B,
-	"robot":                         0x1F916,
-	"sleeping":                      0x1F634,
-	"sleep":                         0x1F634,
-	"zzz":                           0x1F4A4,
-	"dizzy":                         0x1F4AB,
-	"boom":                          0x1F4A5,
-	"collision":                     0x1F4A5,
-	"sweat_drops":                   0x1F4A6,
-	"dash":                          0x1F4A8,
-	"alien":                         0x1F47D,
-	"poop":                          0x1F4A9,
-
-	// hands & gestures
-	"thumbsup":                      0x1F44D,
-	"thumbsdown":                    0x1F44E,
-	"ok_hand":                       0x1F44C,
-	"wave":                          0x1F44B,
-	"clap":                          0x1F44F,
-	"open_hands":                    0x1F450,
-	"raised_hands":                  0x1F64C,
-	"pray":                          0x1F64F,
-	"muscle":                        0x1F4AA,
-	"point_up":                      0x261D,
-	"point_down":                    0x1F447,
-	"point_left":                    0x1F448,
-	"point_right":                   0x1F449,
-	"fist":                          0x270A,
-	"raised_hand":                   0x270B,
-	"v":                             0x270C,
-	"victory":                       0x270C,
-	"crossed_fingers":               0x1F91E,
-	"writing_hand":                  0x270D,
-	"call_me":                       0x1F919,
-	"hand":                          0x270B,
-}
-
-var (
-	emojiColorFontOnce sync.Once
-	emojiColorFontData []byte
-)
-
-func loadColorEmojiFont() []byte {
-	emojiColorFontOnce.Do(func() {
-		emojiColorFontData = fcRead("emoji")
-	})
-	return emojiColorFontData
-}

internal/config/config.go

@@ -11,16 +11,16 @@ import (
 )
 
 type Config struct {
-	Version              int            `json:"version"`
+	Version             int            `json:"version"`
-	LogLevel             string         `json:"log_level"`
+	LogLevel            string         `json:"log_level"`
-	DefaultPage          string         `json:"default_page"`
+	DefaultPage         string         `json:"default_page"`
-	Font                 string         `json:"font,omitempty"`
+	Font                string         `json:"font,omitempty"`
-	ShowLabelBackground  bool           `json:"show_label_background"`
+	ShowLabelBackground bool           `json:"show_label_background"`
-	Devices              []DeviceConfig `json:"devices"`
+	Devices             []DeviceConfig `json:"devices"`
-	Pages                []PageConfig   `json:"pages"`
+	Pages               []PageConfig   `json:"pages"`
-	AutoSwitch           []SwitchRule   `json:"auto_switch"`
+	AutoSwitch          []SwitchRule   `json:"auto_switch"`
-	Screensaver          ScreensaverCfg `json:"screensaver"`
+	Screensaver         ScreensaverCfg `json:"screensaver"`
-	Timing               TimingConfig   `json:"timing,omitempty"`
+	Timing              TimingConfig   `json:"timing,omitempty"`
 }
 
 type TimingConfig struct {
@@ -43,20 +43,29 @@ type PageConfig struct {
 	Name        string          `json:"name"`
 	Icon        string          `json:"icon,omitempty"`
 	Keys        []KeyConfig     `json:"keys"`
+	DynamicKeys *DynamicKeyGen  `json:"dynamic_keys,omitempty"`
 	Background  string          `json:"background,omitempty"`
 	Screensaver *ScreensaverCfg `json:"screensaver,omitempty"`
 }
 
+type DynamicKeyGen struct {
+	Command  string `json:"command,omitempty"`
+	Script   string `json:"script,omitempty"`
+	Interval string `json:"interval,omitempty"`
+	Timeout  string `json:"timeout,omitempty"`
+	MaxKeys  int    `json:"max_keys,omitempty"`
+}
+
 type KeyConfig struct {
-	Index      int           `json:"index"`
+	Index      int         `json:"index"`
-	Icon       string        `json:"icon,omitempty"`
+	Icon       string      `json:"icon,omitempty"`
-	Background string        `json:"background,omitempty"`
+	Background string      `json:"background,omitempty"`
-	Label      string        `json:"label,omitempty"`
+	Label      string      `json:"label,omitempty"`
-	Font       string        `json:"font,omitempty"`
+	Font       string      `json:"font,omitempty"`
-	FontSize   *float64      `json:"font_size,omitempty"`
+	FontSize   *float64    `json:"font_size,omitempty"`
-	IconScale  *float64      `json:"icon_scale,omitempty"`
+	IconScale  *float64    `json:"icon_scale,omitempty"`
-	Actions    []KeyAction   `json:"actions,omitempty"`
+	Actions    []KeyAction `json:"actions,omitempty"`
-	Display    *DisplayCfg   `json:"display,omitempty"`
+	Display    *DisplayCfg `json:"display,omitempty"`
 }
 
 type KeyAction struct {
@@ -142,6 +151,21 @@ func ConfigPath(path string) string {
 	return filepath.Join(home, ".config", "streamdeck-lets-go", "config.json")
 }
 
+var cachedConfigDir string
+
+func ConfigDir() string {
+	if cachedConfigDir != "" {
+		return cachedConfigDir
+	}
+	home, err := os.UserHomeDir()
+	if err != nil {
+		cachedConfigDir = "."
+		return cachedConfigDir
+	}
+	cachedConfigDir = filepath.Join(home, ".config", "streamdeck-lets-go")
+	return cachedConfigDir
+}
+
 func LoadConfig(path string) (*Config, error) {
 	path = ConfigPath(path)
 	data, err := os.ReadFile(path)
@@ -293,6 +317,35 @@ func (c *Config) Validate() error {
 				}
 			}
 		}
+
+		if p.DynamicKeys != nil {
+			if p.DynamicKeys.Command == "" && p.DynamicKeys.Script == "" {
+				return fmt.Errorf("page %s: dynamic_keys requires command or script", p.Name)
+			}
+			if p.DynamicKeys.Command != "" && p.DynamicKeys.Script != "" {
+				return fmt.Errorf("page %s: dynamic_keys command and script are mutually exclusive", p.Name)
+			}
+			if p.DynamicKeys.Interval != "" {
+				interval, err := time.ParseDuration(p.DynamicKeys.Interval)
+				if err != nil {
+					return fmt.Errorf("page %s: invalid dynamic_keys interval %q: %w", p.Name, p.DynamicKeys.Interval, err)
+				}
+				if interval < time.Second {
+					return fmt.Errorf("page %s: dynamic_keys interval must be at least 1s", p.Name)
+				}
+				if interval > 24*time.Hour {
+					return fmt.Errorf("page %s: dynamic_keys interval must not exceed 24h", p.Name)
+				}
+			}
+			if p.DynamicKeys.Timeout != "" {
+				if _, err := time.ParseDuration(p.DynamicKeys.Timeout); err != nil {
+					return fmt.Errorf("page %s: invalid dynamic_keys timeout %q: %w", p.Name, p.DynamicKeys.Timeout, err)
+				}
+			}
+			if p.DynamicKeys.MaxKeys < 0 {
+				return fmt.Errorf("page %s: dynamic_keys max_keys must be >= 0", p.Name)
+			}
+		}
 	}
 
 	for _, p := range c.Pages {

internal/daemon/action.go

@@ -1,19 +1,18 @@
-package main
+package daemon
 
 import (
-	"bytes"
-	"context"
 	"fmt"
 	"log/slog"
 	"os"
 	"os/exec"
 	"strings"
-	"time"
 
 	"streamdeck-lets-go/internal/config"
+	"streamdeck-lets-go/internal/deck"
+	"streamdeck-lets-go/internal/render"
 )
 
-func ExecuteAction(a *config.Action, deck *Deck, pm *PageManager) error {
+func ExecuteAction(a *config.Action, deck *deck.Deck, pm *render.PageManager) error {
 	if a == nil {
 		return nil
 	}
@@ -74,32 +73,7 @@ func execScript(a *config.Action) error {
 	return nil
 }
 
-func execDisplayCapture(d *config.DisplayCfg, timeout time.Duration) (string, error) {
+func execBuiltin(a *config.Action, deck *deck.Deck, pm *render.PageManager) error {
-	ctx, cancel := context.WithTimeout(context.Background(), timeout)
-	defer cancel()
-
-	var cmd *exec.Cmd
-	if d.Command != "" {
-		cmd = exec.CommandContext(ctx, "sh", "-c", d.Command)
-	} else {
-		cmd = exec.CommandContext(ctx, d.Script)
-	}
-	var stdout, stderr bytes.Buffer
-	cmd.Stdout = &stdout
-	cmd.Stderr = &stderr
-
-	err := cmd.Run()
-	output := stdout.String()
-	if stderr.Len() > 0 {
-		if output != "" {
-			output += "\n"
-		}
-		output += stderr.String()
-	}
-	return output, err
-}
-
-func execBuiltin(a *config.Action, deck *Deck, pm *PageManager) error {
 	parts := strings.SplitN(a.Builtin, ":", 2)
 	if len(parts) < 1 {
 		return fmt.Errorf("invalid builtin: %s", a.Builtin)
@@ -177,10 +151,10 @@ func brightnessAction(action string) error {
 	return exec.Command("sh", "-c", cmd).Run()
 }
 
-func pageBuiltinAction(action string, pm *PageManager) error {
+func pageBuiltinAction(action string, pm *render.PageManager) error {
 	switch action {
 	case "next":
-		pageNames := pm.PageNames()
+		pageNames := pm.GetPageNames()
 		current := pm.ActivePageName()
 		for i, name := range pageNames {
 			if name == current {
@@ -192,7 +166,7 @@ func pageBuiltinAction(action string, pm *PageManager) error {
 			return pm.ActivatePage(pageNames[0])
 		}
 	case "prev":
-		pageNames := pm.PageNames()
+		pageNames := pm.GetPageNames()
 		current := pm.ActivePageName()
 		for i, name := range pageNames {
 			if name == current {
@@ -209,7 +183,7 @@ func pageBuiltinAction(action string, pm *PageManager) error {
 	return nil
 }
 
-func deckBuiltinAction(action string, deck *Deck) error {
+func deckBuiltinAction(action string, deck *deck.Deck) error {
 	switch action {
 	case "brightness-up":
 		current := deck.Brightness()
@@ -232,6 +206,9 @@ func deckBuiltinAction(action string, deck *Deck) error {
 
 func keyboardTool() string {
 	if os.Getenv("WAYLAND_DISPLAY") != "" {
+		if _, err := exec.LookPath("ydotool"); err == nil {
+			return "ydotool"
+		}
 		if _, err := exec.LookPath("wtype"); err == nil {
 			return "wtype"
 		}
@@ -264,6 +241,8 @@ func execKeyboard(a *config.Action) error {
 	}
 
 	switch tool {
+	case "ydotool":
+		return execYDOTool(keys)
 	case "wtype":
 		return execWType(parts)
 	case "xdotool":
@@ -300,12 +279,10 @@ func execXDoTool(keys string) error {
 	return cmd.Run()
 }
 
-func (pm *PageManager) PageNames() []string {
+func execYDOTool(keys string) error {
-	pm.mu.RLock()
+	// Use 'type' command instead of 'key' for better compatibility with Wine/games on Wayland
-	defer pm.mu.RUnlock()
+	cmd := exec.Command("ydotool", "type", keys)
-	names := make([]string, 0, len(pm.pages))
+	cmd.Stdout = os.Stdout
-	for name := range pm.pages {
+	cmd.Stderr = os.Stderr
-		names = append(names, name)
+	return cmd.Run()
-	}
-	return names
 }

internal/daemon/autoswitch.go

@@ -1,4 +1,4 @@
-package main
+package daemon
 
 import (
 	"context"
@@ -9,6 +9,7 @@ import (
 	"regexp"
 	"strings"
 	"sync"
+	"sync/atomic"
 	"time"
 
 	"streamdeck-lets-go/internal/config"
@@ -264,6 +265,7 @@ func (d *niriDetector) getWindow(ctx context.Context) Window {
 }
 
 type gnomeDetector struct{ basePoll }
+
 func (d *gnomeDetector) Start(ctx context.Context) (<-chan Window, error) {
 	d.pollFn = d.getWindow
 	ctx, d.cancel = context.WithCancel(ctx)
@@ -306,6 +308,7 @@ func parseGnomeEval(out string) string {
 }
 
 type kdeDetector struct{ basePoll }
+
 func (d *kdeDetector) Start(ctx context.Context) (<-chan Window, error) {
 	d.pollFn = d.getWindow
 	ctx, d.cancel = context.WithCancel(ctx)
@@ -322,6 +325,7 @@ func (d *kdeDetector) getWindow(ctx context.Context) Window {
 }
 
 type x11Detector struct{ basePoll }
+
 func (d *x11Detector) Start(ctx context.Context) (<-chan Window, error) {
 	d.pollFn = d.getWindow
 	ctx, d.cancel = context.WithCancel(ctx)
@@ -338,6 +342,7 @@ func (d *x11Detector) getWindow(ctx context.Context) Window {
 }
 
 type portalDetector struct{ basePoll }
+
 func (d *portalDetector) Start(ctx context.Context) (<-chan Window, error) {
 	d.pollFn = d.getWindow
 	ctx, d.cancel = context.WithCancel(ctx)
@@ -357,6 +362,7 @@ type AutoSwitchManager struct {
 	lastManualPage string
 	autoPage       string
 	autoStay       bool
+	paused         atomic.Bool // disables auto-switch when device is disconnected
 }
 
 type compiledRule struct {
@@ -410,6 +416,25 @@ func (m *AutoSwitchManager) NotifyManualPage(name string) {
 	slog.Debug("auto-switch: manual page set", "page", name)
 }
 
+// Pause disables auto-switch evaluation — use when the device is disconnected
+// to prevent unnecessary page switches on a closed deck.
+func (m *AutoSwitchManager) Pause() {
+	m.paused.Store(true)
+	slog.Debug("auto-switch: paused")
+}
+
+// Resume re-enables auto-switch evaluation after reconnect.
+// Stale window events should be drained from the channel before resuming.
+func (m *AutoSwitchManager) Resume() {
+	m.paused.Store(false)
+	slog.Debug("auto-switch: resumed")
+}
+
+// IsPaused returns true when auto-switch evaluation is paused.
+func (m *AutoSwitchManager) IsPaused() bool {
+	return m.paused.Load()
+}
+
 func (m *AutoSwitchManager) Evaluate(win Window, currentPage string) (page string, shouldSwitch bool) {
 	m.mu.Lock()
 	defer m.mu.Unlock()

internal/daemon/autoswitch_test.go

@@ -1,4 +1,4 @@
-package main
+package daemon
 
 import (
 	"encoding/json"

internal/daemon/daemon.go

@@ -1,4 +1,4 @@
-package main
+package daemon
 
 import (
 	"context"
@@ -8,6 +8,9 @@ import (
 	"time"
 
 	"streamdeck-lets-go/internal/config"
+	"streamdeck-lets-go/internal/deck"
+	"streamdeck-lets-go/internal/render"
+	"streamdeck-lets-go/internal/web"
 )
 
 type RunOptions struct {
@@ -15,10 +18,11 @@ type RunOptions struct {
 	HTTPAddr    string
 	HTTPEnabled bool
 	NoDeck      bool
+	StartPage   string
 }
 
 func Run(ctx context.Context, cfg *config.Config, opts RunOptions) error {
-	web := NewWebServer(cfg, opts.ConfigPath)
+	web := web.NewWebServer(cfg, opts.ConfigPath)
 
 	if !opts.NoDeck || opts.HTTPEnabled {
 		checkKeyboardTool()
@@ -37,11 +41,11 @@ func Run(ctx context.Context, cfg *config.Config, opts RunOptions) error {
 		return nil
 	}
 
-	var decks []*Deck
+	var decks []*deck.Deck
 	var err error
 
 	for {
-		decks, err = OpenAllDecks()
+		decks, err = deck.OpenAllDecks()
 		if err == nil {
 			break
 		}
@@ -53,16 +57,26 @@ func Run(ctx context.Context, cfg *config.Config, opts RunOptions) error {
 		}
 	}
 
-	pageMgrs := make([]*PageManager, len(decks))
+	pageMgrs := make([]*render.PageManager, len(decks))
 	for i, d := range decks {
-		pageMgrs[i] = NewPageManager(d)
+		pageMgrs[i] = render.NewPageManager(d)
-		pageMgrs[i].defaultFont = cfg.Font
+		pageMgrs[i].DefaultFont = cfg.Font
-		pageMgrs[i].showLabelBackground = cfg.ShowLabelBackground
+		pageMgrs[i].ShowLabelBackground = cfg.ShowLabelBackground
 		pageMgrs[i].LoadPages(cfg.Pages)
 	}
 	primaryPM := pageMgrs[0]
 	primaryDeck := decks[0]
 
+	startPage := opts.StartPage
+	if startPage == "" {
+		startPage = cfg.DefaultPage
+	}
+	if !pageExists(cfg.Pages, startPage) {
+		slog.Warn("start page not found in pages, falling back to default",
+			"requested", startPage, "default", cfg.DefaultPage)
+		startPage = cfg.DefaultPage
+	}
+
 	defer func() {
 		for _, d := range decks {
 			d.Close()
@@ -78,10 +92,10 @@ func Run(ctx context.Context, cfg *config.Config, opts RunOptions) error {
 	web.SetExtraPageManagers(pageMgrs[1:])
 
 	for _, pm := range pageMgrs {
-		if err := pm.ActivatePage(cfg.DefaultPage); err != nil {
+		if err := pm.ActivatePage(startPage); err != nil {
-			slog.Warn("activate default page", "error", err)
+			slog.Warn("activate start page", "error", err)
 		}
-		pm.startPeriodicKeys()
+		pm.StartPeriodicKeys()
 	}
 
 	var windowCh <-chan Window
@@ -98,7 +112,7 @@ func Run(ctx context.Context, cfg *config.Config, opts RunOptions) error {
 		windowCh, _ = detector.Start(ctx)
 	}
 
-	asm := NewAutoSwitchManager(cfg.AutoSwitch, cfg.DefaultPage)
+	asm := NewAutoSwitchManager(cfg.AutoSwitch, startPage)
 
 	ssCtrl := NewScreensaver(&cfg.Screensaver)
 
@@ -116,8 +130,8 @@ func Run(ctx context.Context, cfg *config.Config, opts RunOptions) error {
 				asm.NotifyManualPage(a.Page)
 			}
 			for _, pm := range pageMgrs {
-				pm.stopPeriodicKeys()
+				pm.StopPeriodicKeys()
-				pm.startPeriodicKeys()
+				pm.StartPeriodicKeys()
 			}
 			web.BroadcastPageChange(newPage)
 		} else {
@@ -125,7 +139,7 @@ func Run(ctx context.Context, cfg *config.Config, opts RunOptions) error {
 		}
 	})
 
-	reconnectTicker := time.NewTicker(5 * time.Second)
+	reconnectTicker := time.NewTicker(2 * time.Second)
 	defer reconnectTicker.Stop()
 
 	ssTicker := time.NewTicker(5 * time.Second)
@@ -143,22 +157,34 @@ func Run(ctx context.Context, cfg *config.Config, opts RunOptions) error {
 		case evt, ok := <-primaryDeck.Events():
 			if !ok {
 				slog.Warn("deck event channel closed, attempting reconnect...")
+
+				// Stop all periodic scripts to avoid wasting cycles on a closed device.
+				primaryPM.StopPeriodicKeys()
+				asm.Pause()
+
 				primaryDeck.Close()
-				newDeck := reconnectDeck(ctx, cfg, &primaryPM, asm)
+				newDeck := reconnectDeck(ctx, cfg, &primaryPM, startPage)
 				if newDeck == nil {
 					return ctx.Err()
 				}
+
+				// Update all references to the new device and page manager.
+				pageMgrs[0] = primaryPM
 				decks[0] = newDeck
 				primaryDeck = newDeck
 				web.SetDecks(decks)
+				web.SetPageManager(primaryPM)
+
 				newDeck.SetBrightness(deviceBrightness(cfg, newDeck.Serial()))
+				asm.NotifyManualPage(startPage)
+				asm.Resume()
 				continue
 			}
 
 			wasSsActive := ssCtrl.IsActive()
 			ssCtrl.NotifyInput()
 
-			if evt.Kind == EventKeyPressed {
+			if evt.Kind == deck.EventKeyPressed {
 				if wasSsActive {
 					ssCtrl.Deactivate(primaryDeck)
 
@@ -184,7 +210,7 @@ func Run(ctx context.Context, cfg *config.Config, opts RunOptions) error {
 			if page == nil {
 				continue
 			}
-			for _, k := range page.Keys {
+			for _, k := range primaryPM.ActiveKeys() {
 				if k.Index == evt.Index {
 					if len(k.Actions) > 0 {
 						ge.HandleEvent(evt, k.Actions)
@@ -194,13 +220,20 @@ func Run(ctx context.Context, cfg *config.Config, opts RunOptions) error {
 			}
 
 		case win := <-windowCh:
+			if asm.IsPaused() {
+				// Drain buffered window events accumulated while disconnected.
+				for len(windowCh) > 0 {
+					<-windowCh
+				}
+				continue
+			}
 			if page, ok := asm.Evaluate(win, primaryPM.ActivePageName()); ok {
 				for _, pm := range pageMgrs {
 					if err := pm.ActivatePage(page); err != nil {
 						slog.Warn("auto-switch: activate page", "error", err)
 					}
-					pm.stopPeriodicKeys()
+					pm.StopPeriodicKeys()
-					pm.startPeriodicKeys()
+					pm.StartPeriodicKeys()
 				}
 				web.BroadcastPageChange(page)
 			}
@@ -226,14 +259,14 @@ func Run(ctx context.Context, cfg *config.Config, opts RunOptions) error {
 				for _, d := range decks {
 					d.SetBrightness(deviceBrightness(cfg, d.Serial()))
 				}
-			var activePages []string
+				var activePages []string
-			for _, pm := range pageMgrs {
+				for _, pm := range pageMgrs {
-				activePages = append(activePages, pm.ActivePageName())
+					activePages = append(activePages, pm.ActivePageName())
-				pm.stopPeriodicKeys()
+					pm.StopPeriodicKeys()
-				pm.defaultFont = cfg.Font
+					pm.DefaultFont = cfg.Font
-				pm.showLabelBackground = cfg.ShowLabelBackground
+					pm.ShowLabelBackground = cfg.ShowLabelBackground
-				pm.LoadPages(cfg.Pages)
+					pm.LoadPages(cfg.Pages)
-			}
+				}
 				ge.ReloadTiming(cfg.Timing.LongPressMs, cfg.Timing.DoubleTapMs)
 				asm.Reload(cfg.AutoSwitch)
 				if len(cfg.AutoSwitch) > 0 && detector == nil {
@@ -253,7 +286,7 @@ func Run(ctx context.Context, cfg *config.Config, opts RunOptions) error {
 					if err := pm.ActivatePage(page); err != nil {
 						slog.Warn("reload: activate page", "error", err)
 					}
-					pm.startPeriodicKeys()
+					pm.StartPeriodicKeys()
 				}
 			}
 			if lastConfigMod.IsZero() {
@@ -263,15 +296,27 @@ func Run(ctx context.Context, cfg *config.Config, opts RunOptions) error {
 		case <-reconnectTicker.C:
 			if err := primaryDeck.SetBrightness(primaryDeck.Brightness()); err != nil {
 				slog.Warn("deck connection lost, reconnecting...", "error", err)
+
+				// Stop all periodic scripts to avoid wasting cycles on a closed device.
+				primaryPM.StopPeriodicKeys()
+				asm.Pause()
+
 				primaryDeck.Close()
-				newDeck := reconnectDeck(ctx, cfg, &primaryPM, asm)
+				newDeck := reconnectDeck(ctx, cfg, &primaryPM, startPage)
 				if newDeck == nil {
 					return ctx.Err()
 				}
+
+				// Update all references to the new device and page manager.
+				pageMgrs[0] = primaryPM
 				decks[0] = newDeck
 				primaryDeck = newDeck
 				web.SetDecks(decks)
+				web.SetPageManager(primaryPM)
+
 				newDeck.SetBrightness(deviceBrightness(cfg, newDeck.Serial()))
+				asm.NotifyManualPage(startPage)
+				asm.Resume()
 			}
 
 		case <-ssTicker.C:
@@ -289,8 +334,19 @@ func Run(ctx context.Context, cfg *config.Config, opts RunOptions) error {
 
 func checkKeyboardTool() {
 	if os.Getenv("WAYLAND_DISPLAY") != "" {
-		if _, err := exec.LookPath("wtype"); err != nil {
+		// On Wayland, prefer ydotool over wtype
-			slog.Warn("keyboard actions require wtype on Wayland — install it (e.g. apk add wtype) and restart")
+		if _, err := exec.LookPath("ydotool"); err == nil {
+			// Start ydotoold daemon if not already running
+			cmd := exec.Command("ydotoold")
+			cmd.Stdout = nil
+			cmd.Stderr = nil
+			// Run in background, don't wait
+			_ = cmd.Start()
+			slog.Info("ydotoold daemon started for keyboard input")
+		} else if _, err := exec.LookPath("wtype"); err == nil {
+			slog.Warn("ydotool not found, falling back to wtype — consider installing ydotool for better Wayland support (e.g. apk add ydotool)")
+		} else {
+			slog.Warn("keyboard actions require ydotool or wtype on Wayland — install one (e.g. apk add ydotool) and restart")
 		}
 	} else {
 		if _, err := exec.LookPath("xdotool"); err != nil {
@@ -311,23 +367,32 @@ func deviceBrightness(cfg *config.Config, serial string) int {
 	return 75
 }
 
-func reconnectDeck(ctx context.Context, cfg *config.Config, pm **PageManager, asm *AutoSwitchManager) *Deck {
+func reconnectDeck(ctx context.Context, cfg *config.Config, pm **render.PageManager, startPage string) *deck.Deck {
 	for {
-		newDeck, err := OpenDeck("")
+		newDeck, err := deck.OpenDeck("")
 		if err == nil {
-			*pm = NewPageManager(newDeck)
+			*pm = render.NewPageManager(newDeck)
-			(*pm).defaultFont = cfg.Font
+			(*pm).DefaultFont = cfg.Font
-			(*pm).showLabelBackground = cfg.ShowLabelBackground
+			(*pm).ShowLabelBackground = cfg.ShowLabelBackground
 			(*pm).LoadPages(cfg.Pages)
-			(*pm).ActivatePage(cfg.DefaultPage)
+			(*pm).ActivatePage(startPage)
-			(*pm).startPeriodicKeys()
+			(*pm).StartPeriodicKeys()
-			asm.NotifyManualPage(cfg.DefaultPage)
 			return newDeck
 		}
 		select {
 		case <-ctx.Done():
 			return nil
-		case <-time.After(3 * time.Second):
+		case <-time.After(1 * time.Second):
 		}
 	}
 }
+
+// pageExists reports whether pages contains a page with the given name.
+func pageExists(pages []config.PageConfig, name string) bool {
+	for _, p := range pages {
+		if p.Name == name {
+			return true
+		}
+	}
+	return false
+}

internal/daemon/gesture.go

@@ -1,10 +1,11 @@
-package main
+package daemon
 
 import (
 	"sync"
 	"time"
 
 	"streamdeck-lets-go/internal/config"
+	"streamdeck-lets-go/internal/deck"
 )
 
 type ActionCallback func(idx int, a *config.Action)
@@ -95,7 +96,7 @@ func findAction(actions []config.KeyAction, trigger string) *config.Action {
 	return nil
 }
 
-func (ge *GestureEngine) HandleEvent(evt Event, actions []config.KeyAction) {
+func (ge *GestureEngine) HandleEvent(evt deck.Event, actions []config.KeyAction) {
 	state := ge.getState(evt.Index)
 
 	if len(actions) == 0 {
@@ -103,14 +104,14 @@ func (ge *GestureEngine) HandleEvent(evt Event, actions []config.KeyAction) {
 	}
 
 	switch evt.Kind {
-	case EventKeyPressed:
+	case deck.EventKeyPressed:
 		ge.handleKeyPress(state, evt, actions)
-	case EventKeyReleased:
+	case deck.EventKeyReleased:
 		ge.handleKeyRelease(state, evt, actions)
 	}
 }
 
-func (ge *GestureEngine) handleKeyPress(state *gestureKeyState, evt Event, actions []config.KeyAction) {
+func (ge *GestureEngine) handleKeyPress(state *gestureKeyState, evt deck.Event, actions []config.KeyAction) {
 	state.mu.Lock()
 	state.cancelTimers()
 	state.holdActive = false
@@ -130,7 +131,7 @@ func (ge *GestureEngine) handleKeyPress(state *gestureKeyState, evt Event, actio
 	state.mu.Unlock()
 }
 
-func (ge *GestureEngine) handleKeyRelease(state *gestureKeyState, evt Event, actions []config.KeyAction) {
+func (ge *GestureEngine) handleKeyRelease(state *gestureKeyState, evt deck.Event, actions []config.KeyAction) {
 	state.mu.Lock()
 	state.cancelTimers()
 

internal/daemon/screensaver.go

@@ -1,17 +1,19 @@
-package main
+package daemon
 
 import (
 	"log/slog"
 	"time"
 
 	"streamdeck-lets-go/internal/config"
+	"streamdeck-lets-go/internal/deck"
+	"streamdeck-lets-go/internal/render"
 )
 
 type Screensaver struct {
-	enabled    bool
+	enabled         bool
-	idleAfter  time.Duration
+	idleAfter       time.Duration
-	lastInput  time.Time
+	lastInput       time.Time
-	active     bool
+	active          bool
 	savedBrightness int
 }
 
@@ -50,7 +52,7 @@ func (ss *Screensaver) Check() bool {
 	return false
 }
 
-func (ss *Screensaver) Activate(deck *Deck, cfg *config.ScreensaverCfg) {
+func (ss *Screensaver) Activate(deck *deck.Deck, cfg *config.ScreensaverCfg) {
 	ss.savedBrightness = deck.Brightness()
 
 	brightness := cfg.Brightness
@@ -62,7 +64,7 @@ func (ss *Screensaver) Activate(deck *Deck, cfg *config.ScreensaverCfg) {
 	}
 
 	if cfg.Image != "" {
-		img, err := loadImage(cfg.Image, 0, 0)
+		img, err := render.LoadImage(cfg.Image, 0, 0)
 		if err != nil {
 			slog.Warn("screensaver: load image", "path", cfg.Image, "error", err)
 			return
@@ -75,7 +77,7 @@ func (ss *Screensaver) Activate(deck *Deck, cfg *config.ScreensaverCfg) {
 	slog.Info("screensaver activated")
 }
 
-func (ss *Screensaver) Deactivate(deck *Deck) {
+func (ss *Screensaver) Deactivate(deck *deck.Deck) {
 	brightness := ss.savedBrightness
 	if brightness <= 0 {
 		brightness = 75

internal/deck/deck.go

@@ -1,4 +1,4 @@
-package main
+package deck
 
 import (
 	"fmt"
@@ -22,28 +22,28 @@ type DeviceInfo struct {
 }
 
 type DeckConfig struct {
-	PID       uint16
+	PID      uint16
-	Name      string
+	Name     string
-	KeysX     int
+	KeysX    int
-	KeysY     int
+	KeysY    int
-	KeySize   int
+	KeySize  int
-	ImageFmt  string
+	ImageFmt string
-	Rotate    bool
+	Rotate   bool
-	Convert   bool
+	Convert  bool
-	HasDials  bool
+	HasDials bool
-	HasTouch  bool
+	HasTouch bool
 }
 
-var knownDecks = []DeckConfig{
+var KnownDecks = []DeckConfig{
-	{PID: 0x60, Name: "Mini",      KeysX: 3, KeysY: 2, KeySize: 80, ImageFmt: "bmp",  Convert: true},
+	{PID: 0x60, Name: "Mini", KeysX: 3, KeysY: 2, KeySize: 80, ImageFmt: "bmp", Convert: true},
-	{PID: 0x6d, Name: "Original",  KeysX: 5, KeysY: 3, KeySize: 72, ImageFmt: "jpg",  Rotate: true},
+	{PID: 0x6d, Name: "Original", KeysX: 5, KeysY: 3, KeySize: 72, ImageFmt: "jpg", Rotate: true},
-	{PID: 0x63, Name: "OriginalV2",KeysX: 5, KeysY: 3, KeySize: 72, ImageFmt: "bmp"},
+	{PID: 0x63, Name: "OriginalV2", KeysX: 5, KeysY: 3, KeySize: 72, ImageFmt: "bmp"},
-	{PID: 0x80, Name: "MK2",       KeysX: 5, KeysY: 3, KeySize: 72, ImageFmt: "jpg",  Rotate: true},
+	{PID: 0x80, Name: "MK2", KeysX: 5, KeysY: 3, KeySize: 72, ImageFmt: "jpg", Rotate: true},
-	{PID: 0x6c, Name: "XL",        KeysX: 8, KeysY: 4, KeySize: 96, ImageFmt: "jpg"},
+	{PID: 0x6c, Name: "XL", KeysX: 8, KeysY: 4, KeySize: 96, ImageFmt: "jpg"},
 }
 
 func findConfig(pid uint16) (DeckConfig, bool) {
-	for _, d := range knownDecks {
+	for _, d := range KnownDecks {
 		if d.PID == pid {
 			return d, true
 		}
@@ -161,12 +161,12 @@ func (d *Deck) Close() {
 	d.sd.Close()
 }
 
-func (d *Deck) Serial() string  { return d.serial }
+func (d *Deck) Serial() string       { return d.serial }
 func (d *Deck) Events() <-chan Event { return d.events }
-func (d *Deck) NumKeys() int { return d.cfg.KeysX * d.cfg.KeysY }
+func (d *Deck) NumKeys() int         { return d.cfg.KeysX * d.cfg.KeysY }
-func (d *Deck) KeySize() int { return d.cfg.KeySize }
+func (d *Deck) KeySize() int         { return d.cfg.KeySize }
-func (d *Deck) Config() DeckConfig { return d.cfg }
+func (d *Deck) Config() DeckConfig   { return d.cfg }
-func (d *Deck) Model() string { return d.cfg.Name }
+func (d *Deck) Model() string        { return d.cfg.Name }
 
 type DeckInfo struct {
 	Serial  string `json:"serial"`

internal/render/cbdt.go

@@ -1,4 +1,4 @@
-package main
+package render
 
 import (
 	"bytes"
@@ -16,9 +16,9 @@ import (
 )
 
 type cbdtIndex struct {
-	once   sync.Once
+	once  sync.Once
-	imgs   []image.Image
+	imgs  []image.Image
-	scale  int
+	scale int
 }
 
 var emojiCBDT cbdtIndex

internal/render/emoji.go

@@ -0,0 +1,209 @@
+package render
+
+import "sync"
+
+var emojiShortcodes = map[string]rune{
+	// media
+	"play_pause":     0x25B6,
+	"stop":           0x23F9,
+	"record":         0x23FA,
+	"eject":          0x23CF,
+	"track_previous": 0x23EE,
+	"track_next":     0x23ED,
+	"fast_forward":   0x23E9,
+	"rewind":         0x23EA,
+	"shuffle":        0x1F500,
+	"repeat":         0x1F501,
+	"repeat_one":     0x1F502,
+
+	// volume
+	"speaker": 0x1F50A,
+	"mute":    0x1F507,
+	"sound":   0x1F509,
+
+	// navigation
+	"arrow_up":                0x2B06,
+	"arrow_down":              0x2B07,
+	"arrow_left":              0x2B05,
+	"arrow_right":             0x27A1,
+	"arrows_clockwise":        0x1F503,
+	"arrows_counterclockwise": 0x1F504,
+
+	// status
+	"check":                  0x2705,
+	"heavy_check_mark":       0x2714,
+	"x":                      0x274C,
+	"heavy_multiplication_x": 0x2716,
+	"warning":                0x26A0,
+	"information_source":     0x2139,
+	"question":               0x2753,
+	"exclamation":            0x2757,
+	"white_check_mark":       0x2705,
+	"heavy_plus_sign":        0x2795,
+	"heavy_minus_sign":       0x2796,
+	"heavy_division_sign":    0x2797,
+
+	// actions
+	"gear":             0x2699,
+	"hammer":           0x1F528,
+	"wrench":           0x1F527,
+	"key":              0x1F511,
+	"lock":             0x1F512,
+	"unlocked":         0x1F513,
+	"magnifying_glass": 0x1F50D,
+	"home":             0x1F3E0,
+	"bookmark":         0x1F516,
+	"bell":             0x1F514,
+	"clock":            0x1F550,
+	"alarm_clock":      0x23F0,
+	"hourglass":        0x231B,
+	"calendar":         0x1F4C5,
+	"envelope":         0x2709,
+	"camera":           0x1F4F7,
+	"video_camera":     0x1F4F9,
+	"microphone":       0x1F3A4,
+	"telephone":        0x260E,
+	"phone":            0x1F4DE,
+	"computer":         0x1F4BB,
+	"laptop":           0x1F4BB,
+	"folder":           0x1F4C1,
+	"open_file_folder": 0x1F4C2,
+	"clipboard":        0x1F4CB,
+	"memo":             0x1F4DD,
+	"pencil":           0x270F,
+	"scissors":         0x2702,
+	"link":             0x1F517,
+	"paperclip":        0x1F4CE,
+	"pushpin":          0x1F4CC,
+	"trash":            0x1F5D1,
+	"star":             0x2B50,
+	"trophy":           0x1F3C6,
+	"medal":            0x1F3C5,
+	"target":           0x1F3AF,
+	"dart":             0x1F3AF,
+
+	// objects
+	"lightbulb":     0x1F4A1,
+	"bulb":          0x1F4A1,
+	"battery":       0x1F50B,
+	"electric_plug": 0x1F50C,
+	"rocket":        0x1F680,
+	"airplane":      0x2708,
+	"car":           0x1F697,
+	"bicycle":       0x1F6B2,
+	"headphones":    0x1F3A7,
+	"gamepad":       0x1F3AE,
+	"joystick":      0x1F579,
+	"musical_note":  0x1F3B5,
+	"notes":         0x1F3B6,
+	"printer":       0x1F5A8,
+	"keyboard":      0x2328,
+
+	// weather
+	"sun":       0x2600,
+	"sunny":     0x2600,
+	"moon":      0x1F319,
+	"cloud":     0x2601,
+	"rainbow":   0x1F308,
+	"fire":      0x1F525,
+	"flame":     0x1F525,
+	"zap":       0x26A1,
+	"lightning": 0x26A1,
+	"snowflake": 0x2744,
+	"umbrella":  0x2602,
+
+	// hearts
+	"heart":            0x2764,
+	"yellow_heart":     0x1F49B,
+	"green_heart":      0x1F49A,
+	"blue_heart":       0x1F499,
+	"purple_heart":     0x1F49C,
+	"black_heart":      0x1F5A4,
+	"broken_heart":     0x1F494,
+	"two_hearts":       0x1F495,
+	"sparkling_heart":  0x1F496,
+	"heartpulse":       0x1F497,
+	"heart_beat":       0x1F493,
+	"revolving_hearts": 0x1F49E,
+	"cupid":            0x1F498,
+	"gift_heart":       0x1F49D,
+
+	// faces
+	"smile":                        0x1F600,
+	"smiley":                       0x1F603,
+	"grinning":                     0x1F604,
+	"blush":                        0x1F60A,
+	"wink":                         0x1F609,
+	"heart_eyes":                   0x1F60D,
+	"kissing_heart":                0x1F618,
+	"kissing":                      0x1F617,
+	"smirk":                        0x1F60F,
+	"stuck_out_tongue":             0x1F61B,
+	"stuck_out_tongue_winking_eye": 0x1F61C,
+	"sunglasses":                   0x1F60E,
+	"innocent":                     0x1F607,
+	"neutral_face":                 0x1F610,
+	"expressionless":               0x1F611,
+	"thinking":                     0x1F914,
+	"confused":                     0x1F615,
+	"worried":                      0x1F61F,
+	"frown":                        0x1F641,
+	"persevere":                    0x1F623,
+	"tired":                        0x1F62B,
+	"weary":                        0x1F629,
+	"cry":                          0x1F622,
+	"sob":                          0x1F62D,
+	"sweat_smile":                  0x1F605,
+	"joy":                          0x1F602,
+	"relaxed":                      0x263A,
+	"angry":                        0x1F620,
+	"rage":                         0x1F621,
+	"skull":                        0x1F480,
+	"ghost":                        0x1F47B,
+	"robot":                        0x1F916,
+	"sleeping":                     0x1F634,
+	"sleep":                        0x1F634,
+	"zzz":                          0x1F4A4,
+	"dizzy":                        0x1F4AB,
+	"boom":                         0x1F4A5,
+	"collision":                    0x1F4A5,
+	"sweat_drops":                  0x1F4A6,
+	"dash":                         0x1F4A8,
+	"alien":                        0x1F47D,
+	"poop":                         0x1F4A9,
+
+	// hands & gestures
+	"thumbsup":        0x1F44D,
+	"thumbsdown":      0x1F44E,
+	"ok_hand":         0x1F44C,
+	"wave":            0x1F44B,
+	"clap":            0x1F44F,
+	"open_hands":      0x1F450,
+	"raised_hands":    0x1F64C,
+	"pray":            0x1F64F,
+	"muscle":          0x1F4AA,
+	"point_up":        0x261D,
+	"point_down":      0x1F447,
+	"point_left":      0x1F448,
+	"point_right":     0x1F449,
+	"fist":            0x270A,
+	"raised_hand":     0x270B,
+	"v":               0x270C,
+	"victory":         0x270C,
+	"crossed_fingers": 0x1F91E,
+	"writing_hand":    0x270D,
+	"call_me":         0x1F919,
+	"hand":            0x270B,
+}
+
+var (
+	emojiColorFontOnce sync.Once
+	emojiColorFontData []byte
+)
+
+func loadColorEmojiFont() []byte {
+	emojiColorFontOnce.Do(func() {
+		emojiColorFontData = fcRead("emoji")
+	})
+	return emojiColorFontData
+}

internal/render/fontawesome.go

@@ -1,4 +1,4 @@
-package main
+package render
 
 import (
 	"fmt"
@@ -138,4 +138,3 @@ func renderFAGlyph(style faStyle, name string, size int, scale float64) (image.I
 func isFAIconRef(path string) bool {
 	return strings.HasPrefix(path, "fa:") || strings.HasPrefix(path, "far:") || strings.HasPrefix(path, "fab:")
 }
-

internal/render/fontawesome_data.go

@@ -1,4 +1,4 @@
-package main
+package render
 
 import (
 	"embed"
@@ -14,7 +14,7 @@ var faFonts embed.FS
 type faStyle int
 
 const (
-	faSolid  faStyle = iota
+	faSolid faStyle = iota
 	faRegular
 	faBrands
 )

internal/render/icons.go

@@ -1,4 +1,4 @@
-package main
+package render
 
 import (
 	"bytes"

internal/render/page.go

@@ -1,6 +1,7 @@
-package main
+package render
 
 import (
+	"bytes"
 	"context"
 	"encoding/json"
 	"fmt"
@@ -28,6 +29,7 @@ import (
 	"golang.org/x/image/math/fixed"
 
 	"streamdeck-lets-go/internal/config"
+	"streamdeck-lets-go/internal/deck"
 )
 
 type keyState struct {
@@ -44,34 +46,107 @@ type PageManager struct {
 	mu                  sync.RWMutex
 	pages               map[string]*config.PageConfig
 	active              string
-	deck                *Deck
+	deck                *deck.Deck
 	keyStates           map[int]*keyState
 	displayOutputs      map[int]*DisplayOutput
 	displayMu           sync.RWMutex
-	defaultFont         string
+	DefaultFont         string
-	showLabelBackground bool
+	ShowLabelBackground bool
+	dynamicCancel       context.CancelFunc
+	dynamicKeys         []config.KeyConfig
+	dynamicKeysMu       sync.RWMutex
+	dynamicResults      map[string][]config.KeyConfig
 }
 
-func NewPageManager(deck *Deck) *PageManager {
+func NewPageManager(deck *deck.Deck) *PageManager {
 	return &PageManager{
 		pages:          make(map[string]*config.PageConfig),
 		deck:           deck,
 		keyStates:      make(map[int]*keyState),
 		displayOutputs: make(map[int]*DisplayOutput),
-		defaultFont:    "medium",
+		DefaultFont:    "medium",
+		dynamicResults: make(map[string][]config.KeyConfig),
 	}
 }
 
+func (pm *PageManager) ActiveKeys() []config.KeyConfig {
+	pm.mu.RLock()
+	page := pm.pages[pm.active]
+	pm.mu.RUnlock()
+	if page == nil {
+		return nil
+	}
+
+	pm.dynamicKeysMu.RLock()
+	dyn := pm.dynamicKeys
+	pm.dynamicKeysMu.RUnlock()
+
+	if dyn == nil {
+		return page.Keys
+	}
+
+	used := make(map[int]bool, len(page.Keys))
+	result := make([]config.KeyConfig, 0, len(page.Keys)+len(dyn))
+	for _, k := range page.Keys {
+		used[k.Index] = true
+		result = append(result, k)
+	}
+	for _, k := range dyn {
+		if !used[k.Index] {
+			result = append(result, k)
+		}
+	}
+	return result
+}
+
+// GetEffectiveKeys returns merged (static + cached dynamic) keys for a page.
+// Used by the web UI to preview generated keys.
+func (pm *PageManager) GetEffectiveKeys(name string) []config.KeyConfig {
+	pm.mu.RLock()
+	page := pm.pages[name]
+	pm.mu.RUnlock()
+	if page == nil {
+		return nil
+	}
+
+	pm.dynamicKeysMu.RLock()
+	cached := pm.dynamicResults[name]
+	pm.dynamicKeysMu.RUnlock()
+
+	if cached == nil {
+		return page.Keys
+	}
+
+	used := make(map[int]bool, len(page.Keys))
+	result := make([]config.KeyConfig, 0, len(page.Keys)+len(cached))
+	for _, k := range page.Keys {
+		used[k.Index] = true
+		result = append(result, k)
+	}
+	for _, k := range cached {
+		if !used[k.Index] {
+			result = append(result, k)
+		}
+	}
+	return result
+}
+
 func (pm *PageManager) LoadPages(pages []config.PageConfig) {
 	pm.mu.Lock()
-	defer pm.mu.Unlock()
 	pm.pages = make(map[string]*config.PageConfig, len(pages))
 	for i := range pages {
 		pm.pages[pages[i].Name] = &pages[i]
 	}
+	pm.mu.Unlock()
+
+	pm.dynamicKeysMu.Lock()
+	pm.dynamicResults = make(map[string][]config.KeyConfig)
+	pm.dynamicKeysMu.Unlock()
 }
 
 func (pm *PageManager) ActivatePage(name string) error {
+	pm.stopDynamicKeys()
+
 	pm.mu.Lock()
 	defer pm.mu.Unlock()
 
@@ -92,7 +167,7 @@ func (pm *PageManager) ActivatePage(name string) error {
 	}
 
 	if page.Background != "" {
-		if img, err := loadImage(page.Background, 0, 0); err == nil {
+		if img, err := LoadImage(page.Background, 0, 0); err == nil {
 			if err := pm.deck.FillPanel(img); err != nil {
 				slog.Warn("fill panel failed", "error", err)
 			}
@@ -117,6 +192,12 @@ func (pm *PageManager) ActivatePage(name string) error {
 		pm.renderKey(i, &k)
 	}
 
+	if page.DynamicKeys != nil {
+		go func() {
+			pm.startDynamicKeys(page.DynamicKeys)
+		}()
+	}
+
 	return nil
 }
 
@@ -148,14 +229,18 @@ func (pm *PageManager) GetPage(name string) *config.PageConfig {
 	return pm.pages[name]
 }
 
-func (pm *PageManager) RenderKey(keyIndex int) {
+func (pm *PageManager) GetPageNames() []string {
 	pm.mu.RLock()
 	defer pm.mu.RUnlock()
-	page := pm.pages[pm.active]
+	names := make([]string, 0, len(pm.pages))
-	if page == nil {
+	for name := range pm.pages {
-		return
+		names = append(names, name)
 	}
-	for _, k := range page.Keys {
+	return names
+}
+
+func (pm *PageManager) RenderKey(keyIndex int) {
+	for _, k := range pm.ActiveKeys() {
 		if k.Index == keyIndex {
 			pm.renderKey(keyIndex, &k)
 			return
@@ -164,13 +249,7 @@ func (pm *PageManager) RenderKey(keyIndex int) {
 }
 
 func (pm *PageManager) ReRenderDisplayKey(keyIndex int, output string) {
-	pm.mu.RLock()
+	for _, k := range pm.ActiveKeys() {
-	page := pm.pages[pm.active]
-	pm.mu.RUnlock()
-	if page == nil {
-		return
-	}
-	for _, k := range page.Keys {
 		if k.Index == keyIndex && k.Display != nil {
 			pm.renderKeyOutput(keyIndex, k.Display, output, nil)
 			return
@@ -181,7 +260,7 @@ func (pm *PageManager) ReRenderDisplayKey(keyIndex int, output string) {
 func (pm *PageManager) renderKey(idx int, k *config.KeyConfig) {
 	fontName := k.Font
 	if fontName == "" {
-		fontName = pm.defaultFont
+		fontName = pm.DefaultFont
 	}
 	fontSize := 18.0
 	if k.FontSize != nil {
@@ -194,7 +273,7 @@ func (pm *PageManager) renderKey(idx int, k *config.KeyConfig) {
 	}
 
 	if k.Icon != "" {
-		img, err := loadImage(k.Icon, pm.deck.KeySize(), faScale)
+		img, err := LoadImage(k.Icon, pm.deck.KeySize(), faScale)
 		if err != nil {
 			slog.Warn("load icon", "path", k.Icon, "error", err)
 			pm.deck.FillColor(idx, 64, 64, 64)
@@ -218,11 +297,11 @@ func (pm *PageManager) renderKey(idx int, k *config.KeyConfig) {
 		}
 		onImgFontName := fontName
 		if k.Font == "" {
-			onImgFontName = pm.defaultFont
+			onImgFontName = pm.DefaultFont
 		}
 
 		if k.Label != "" {
-			if err := pm.deck.WriteTextOnImage(idx, img, k.Label, onImgFontName, onImgFontSize, pm.showLabelBackground); err != nil {
+			if err := pm.deck.WriteTextOnImage(idx, img, k.Label, onImgFontName, onImgFontSize, pm.ShowLabelBackground); err != nil {
 				slog.Warn("write text on image", "error", err)
 				pm.deck.FillImage(idx, img)
 			}
@@ -238,7 +317,7 @@ func (pm *PageManager) renderKey(idx int, k *config.KeyConfig) {
 				ks := pm.deck.KeySize()
 				img := image.NewRGBA(image.Rect(0, 0, ks, ks))
 				draw.Draw(img, img.Bounds(), &image.Uniform{bg}, image.Point{}, draw.Src)
-				if err := pm.deck.WriteTextOnImage(idx, img, k.Label, fontName, fontSize, pm.showLabelBackground); err != nil {
+				if err := pm.deck.WriteTextOnImage(idx, img, k.Label, fontName, fontSize, pm.ShowLabelBackground); err != nil {
 					slog.Warn("write text on image", "error", err)
 					pm.deck.FillImage(idx, img)
 				}
@@ -246,13 +325,22 @@ func (pm *PageManager) renderKey(idx int, k *config.KeyConfig) {
 			}
 			slog.Warn("invalid background color", "value", k.Background, "error", err)
 		}
-		if err := pm.deck.WriteText(idx, k.Label, image.Black, fontName, fontSize); err != nil {
+		if err := pm.deck.WriteText(idx, k.Label, color.RGBA{0x21, 0x25, 0x2b, 0xff}, fontName, fontSize); err != nil {
 			slog.Warn("write text", "error", err)
 		}
+	} else if k.Background != "" {
+		bg, err := parseHexColor(k.Background)
+		if err == nil {
+			pm.deck.FillColor(idx, bg.R, bg.G, bg.B)
+		} else {
+			slog.Warn("invalid background color", "value", k.Background, "error", err)
+		}
 	}
 }
 
-func (pm *PageManager) stopPeriodicKeys() {
+func (pm *PageManager) StopPeriodicKeys() {
+	pm.stopDynamicKeys()
+
 	pm.mu.Lock()
 	defer pm.mu.Unlock()
 	for _, ks := range pm.keyStates {
@@ -261,7 +349,7 @@ func (pm *PageManager) stopPeriodicKeys() {
 	pm.keyStates = make(map[int]*keyState)
 }
 
-func (pm *PageManager) startPeriodicKeys() {
+func (pm *PageManager) StartPeriodicKeys() {
 	pm.mu.Lock()
 	page := pm.pages[pm.active]
 	if page == nil {
@@ -289,11 +377,136 @@ func (pm *PageManager) startPeriodicKeys() {
 			keys = append(keys, displayKey{index: k.Index, display: k.Display, ctx: ctx})
 		}
 	}
+	dg := page.DynamicKeys
 	pm.mu.Unlock()
 
 	for _, dk := range keys {
 		go pm.runDisplayKey(dk.index, dk.display, dk.ctx)
 	}
+
+	if dg != nil {
+		pm.startDynamicKeys(dg)
+	}
+}
+
+func (pm *PageManager) stopDynamicKeys() {
+	pm.dynamicKeysMu.Lock()
+	if pm.dynamicCancel != nil {
+		pm.dynamicCancel()
+		pm.dynamicCancel = nil
+	}
+	pm.dynamicKeys = nil
+	pm.dynamicKeysMu.Unlock()
+}
+
+func (pm *PageManager) startDynamicKeys(dg *config.DynamicKeyGen) {
+	ctx, cancel := context.WithCancel(context.Background())
+
+	pm.dynamicKeysMu.Lock()
+	if pm.dynamicCancel != nil {
+		pm.dynamicCancel()
+	}
+	pm.dynamicCancel = cancel
+	pm.dynamicKeysMu.Unlock()
+
+	numKeys := dg.MaxKeys
+	if numKeys <= 0 {
+		numKeys = pm.deck.NumKeys()
+	}
+
+	var interval time.Duration
+	if dg.Interval != "" {
+		interval, _ = time.ParseDuration(dg.Interval)
+	}
+	if interval == 0 {
+		interval = 60 * time.Second
+	}
+
+	go pm.runDynamicKeyGenerator(ctx, dg, numKeys, interval)
+}
+
+func (pm *PageManager) runDynamicKeyGenerator(ctx context.Context, dg *config.DynamicKeyGen, numKeys int, interval time.Duration) {
+	timeout := 15 * time.Second
+	if dg.Timeout != "" {
+		if t, err := time.ParseDuration(dg.Timeout); err == nil && t > 0 {
+			timeout = t
+		}
+	}
+
+	pm.updateDynamicKeys(dg, timeout, numKeys)
+
+	ticker := time.NewTicker(interval)
+	defer ticker.Stop()
+
+	for {
+		select {
+		case <-ticker.C:
+			pm.updateDynamicKeys(dg, timeout, numKeys)
+		case <-ctx.Done():
+			return
+		}
+	}
+}
+
+func (pm *PageManager) updateDynamicKeys(dg *config.DynamicKeyGen, timeout time.Duration, numKeys int) {
+	keys, err := execDynamicKeys(dg, timeout, numKeys)
+	if err != nil {
+		slog.Warn("dynamic_keys generator failed", "error", err)
+		return
+	}
+
+	if len(keys) > numKeys {
+		keys = keys[:numKeys]
+	}
+
+	pm.mu.RLock()
+	pageName := pm.active
+	pm.mu.RUnlock()
+
+	pm.dynamicKeysMu.Lock()
+	if pm.dynamicCancel == nil {
+		pm.dynamicKeysMu.Unlock()
+		return
+	}
+	pm.dynamicKeys = keys
+	pm.dynamicResults[pageName] = keys
+	pm.dynamicKeysMu.Unlock()
+
+	slog.Info("dynamic_keys updated", "count", len(keys), "page", pageName)
+
+	pm.rerenderActivePage()
+}
+
+func (pm *PageManager) rerenderActivePage() {
+	pm.mu.RLock()
+	bg := ""
+	if page := pm.pages[pm.active]; page != nil {
+		bg = page.Background
+	}
+	pm.mu.RUnlock()
+
+	if bg != "" {
+		if img, err := LoadImage(bg, 0, 0); err == nil {
+			pm.deck.FillPanel(img)
+		}
+	}
+
+	keys := pm.ActiveKeys()
+	keyByIndex := make(map[int]config.KeyConfig, len(keys))
+	for _, k := range keys {
+		keyByIndex[k.Index] = k
+	}
+
+	for i := 0; i < pm.deck.NumKeys(); i++ {
+		k, ok := keyByIndex[i]
+		if !ok {
+			if bg == "" {
+				pm.deck.ClearKey(i)
+			}
+			continue
+		}
+		pm.renderKey(i, &k)
+	}
 }
 
 func (pm *PageManager) runDisplayKey(idx int, d *config.DisplayCfg, ctx context.Context) {
@@ -386,15 +599,8 @@ func parseDisplayOutput(output string) (*DisplayOutput, color.Color, color.Color
 }
 
 func (pm *PageManager) renderKeyOutput(idx int, d *config.DisplayCfg, output string, execErr error) {
-	pm.mu.RLock()
-	page := pm.pages[pm.active]
-	pm.mu.RUnlock()
-	if page == nil {
-		return
-	}
-
 	var kc *config.KeyConfig
-	for _, k := range page.Keys {
+	for _, k := range pm.ActiveKeys() {
 		if k.Index == idx {
 			kCopy := k
 			kc = &kCopy
@@ -444,7 +650,7 @@ func (pm *PageManager) renderKeyOutput(idx int, d *config.DisplayCfg, output str
 	}
 
 	if kc.Icon != "" {
-		img, err := loadImage(kc.Icon, pm.deck.KeySize(), faScale)
+		img, err := LoadImage(kc.Icon, pm.deck.KeySize(), faScale)
 		if err != nil {
 			slog.Warn("load icon for display", "path", kc.Icon, "error", err)
 			var bg color.Color = color.Black
@@ -470,7 +676,7 @@ func (pm *PageManager) renderKeyOutput(idx int, d *config.DisplayCfg, output str
 			}
 		}
 
-		composite := renderUnicodeTextOnImage(img, text, fontSize, pm.deck.KeySize(), fg, pm.showLabelBackground)
+		composite := renderUnicodeTextOnImage(img, text, fontSize, pm.deck.KeySize(), fg, pm.ShowLabelBackground)
 		if err := pm.deck.FillImage(idx, composite); err != nil {
 			slog.Warn("fill image", "error", err)
 		}
@@ -492,13 +698,7 @@ func (pm *PageManager) renderKeyOutput(idx int, d *config.DisplayCfg, output str
 }
 
 func (pm *PageManager) RefreshDisplayKey(idx int) {
-	pm.mu.RLock()
+	for _, k := range pm.ActiveKeys() {
-	page := pm.pages[pm.active]
-	pm.mu.RUnlock()
-	if page == nil {
-		return
-	}
-	for _, k := range page.Keys {
 		if k.Index == idx && k.Display != nil {
 			timeout := 30 * time.Second
 			if k.Display.Timeout != "" {
@@ -668,7 +868,7 @@ func renderUnicodeText(text string, fontSize float64, keySize int, bg, fg color.
 	return rgba
 }
 
-func renderUnicodeTextOnImage(baseImg image.Image, text string, fontSize float64, keySize int, fg color.Color, showLabelBackground bool) *image.RGBA {
+func renderUnicodeTextOnImage(baseImg image.Image, text string, fontSize float64, keySize int, fg color.Color, ShowLabelBackground bool) *image.RGBA {
 	g := gift.New(gift.Resize(keySize, keySize, gift.LanczosResampling))
 	rgba := image.NewRGBA(image.Rect(0, 0, keySize, keySize))
 	g.Draw(rgba, baseImg)
@@ -677,7 +877,7 @@ func renderUnicodeTextOnImage(baseImg image.Image, text string, fontSize float64
 	if keySize < 72 {
 		barHeight = 16
 	}
-	if showLabelBackground {
+	if ShowLabelBackground {
 		barRect := image.Rect(0, keySize-barHeight, keySize, keySize)
 		draw.Draw(rgba, barRect, &image.Uniform{color.RGBA{0, 0, 0, 180}}, image.Point{}, draw.Over)
 	}
@@ -815,7 +1015,7 @@ func cacheKey(path string, targetSize int, faScale float64) string {
 	return fmt.Sprintf("%s|%d|%.6f", path, targetSize, faScale)
 }
 
-func loadImage(path string, targetSize int, faScale float64) (image.Image, error) {
+func LoadImage(path string, targetSize int, faScale float64) (image.Image, error) {
 	key := cacheKey(path, targetSize, faScale)
 	if cached, ok := imageCache.Load(key); ok {
 		return cached.(image.Image), nil
@@ -852,7 +1052,7 @@ func loadImage(path string, targetSize int, faScale float64) (image.Image, error
 		}
 		resolved = p
 	} else if !strings.HasPrefix(path, "/") {
-		resolved = filepath.Join(configDir(), path)
+		resolved = filepath.Join(config.ConfigDir(), path)
 	}
 
 	if strings.HasSuffix(resolved, ".svg") {
@@ -885,9 +1085,9 @@ func loadImage(path string, targetSize int, faScale float64) (image.Image, error
 			displaySize = 1
 		}
 
-		// Resize to displaySize
+		// Resize to displaySize preserving aspect ratio (crop to fill)
 		if img.Bounds().Dx() != displaySize || img.Bounds().Dy() != displaySize {
-			g := gift.New(gift.Resize(displaySize, displaySize, gift.LanczosResampling))
+			g := gift.New(gift.ResizeToFill(displaySize, displaySize, gift.LanczosResampling, gift.CenterAnchor))
 			scaled := image.NewRGBA(image.Rect(0, 0, displaySize, displaySize))
 			g.Draw(scaled, img)
 			img = scaled
@@ -907,17 +1107,70 @@ func loadImage(path string, targetSize int, faScale float64) (image.Image, error
 	return img, nil
 }
 
-var cachedConfigDir string
+func execDisplayCapture(d *config.DisplayCfg, timeout time.Duration) (string, error) {
+	ctx, cancel := context.WithTimeout(context.Background(), timeout)
+	defer cancel()
 
-func configDir() string {
+	var cmd *exec.Cmd
-	if cachedConfigDir != "" {
+	if d.Command != "" {
-		return cachedConfigDir
+		cmd = exec.CommandContext(ctx, "sh", "-c", d.Command)
+	} else {
+		cmd = exec.CommandContext(ctx, d.Script)
 	}
-	home, err := os.UserHomeDir()
+	var stdout, stderr bytes.Buffer
-	if err != nil {
+	cmd.Stdout = &stdout
-		cachedConfigDir = "."
+	cmd.Stderr = &stderr
-		return cachedConfigDir
+
+	err := cmd.Run()
+	output := stdout.String()
+	if stderr.Len() > 0 {
+		if output != "" {
+			output += "\n"
+		}
+		output += stderr.String()
 	}
-	cachedConfigDir = filepath.Join(home, ".config", "streamdeck-lets-go")
+	return output, err
-	return cachedConfigDir
+}
+
+func execDynamicKeys(dg *config.DynamicKeyGen, timeout time.Duration, keyCount int) ([]config.KeyConfig, error) {
+	ctx, cancel := context.WithTimeout(context.Background(), timeout)
+	defer cancel()
+
+	var cmd *exec.Cmd
+	if dg.Command != "" {
+		cmd = exec.CommandContext(ctx, "sh", "-c", dg.Command)
+	} else {
+		script := dg.Script
+		if !filepath.IsAbs(script) {
+			script = filepath.Join(config.ConfigDir(), script)
+		}
+		cmd = exec.CommandContext(ctx, script)
+	}
+
+	cmd.Env = append(os.Environ(),
+		fmt.Sprintf("STREAMDECK_KEY_COUNT=%d", keyCount),
+		fmt.Sprintf("STREAMDECK_CONFIG_DIR=%s", config.ConfigDir()),
+	)
+
+	var stdout, stderr bytes.Buffer
+	cmd.Stdout = &stdout
+	cmd.Stderr = &stderr
+
+	err := cmd.Run()
+
+	if stderr.Len() > 0 {
+		slog.Debug("dynamic_keys script stderr", "output", stderr.String())
+	}
+
+	if err != nil {
+		return nil, fmt.Errorf("execute dynamic_keys: %w", err)
+	}
+
+	var keys []config.KeyConfig
+	output := stdout.String()
+	if err := json.Unmarshal([]byte(output), &keys); err != nil {
+		return nil, fmt.Errorf("parse dynamic_keys JSON: %w", err)
+	}
+
+	return keys, nil
 }

internal/render/render.go

@@ -1,4 +1,4 @@
-package main
+package render
 
 import (
 	"image"
@@ -32,7 +32,7 @@ func RenderKeyToImage(k *config.KeyConfig, keySize int, showLabelBackground bool
 	}
 
 	if k.Icon != "" {
-		img, err := loadImage(k.Icon, keySize, faScale)
+		img, err := LoadImage(k.Icon, keySize, faScale)
 		if err != nil {
 			img = blankImage(keySize, color.RGBA{64, 64, 64, 255})
 		}
@@ -123,7 +123,7 @@ func composeImageWithLabel(src image.Image, text string, keySize int, fontSize f
 }
 
 func renderTextImage(text string, keySize int, fontSize float64) image.Image {
-	rgba := blankImage(keySize, color.RGBA{0, 0, 0, 255}).(*image.RGBA)
+	rgba := blankImage(keySize, color.RGBA{0, 0, 0, 0}).(*image.RGBA)
 
 	if text != "" {
 		face, err := parseDisplayFace(fontSize)

internal/web/static/app.js

@@ -52,6 +52,7 @@ document.addEventListener('alpine:init', () => {
       await this.loadConfig()
       await this.loadDecks()
       setInterval(() => this.pollDisplayOutputs(), 3000)
+      setInterval(() => this.loadEffectiveKeys(), 10000)
       this.connectSSE()
     },
 
@@ -101,6 +102,7 @@ document.addEventListener('alpine:init', () => {
         const res = await fetch('/api/config')
         this.config = await res.json()
         this.pages = this.config.pages
+        await this.loadEffectiveKeys()
         if (this.pages.length > 0) {
           const saved = localStorage.getItem('sd_active_page')
           if (saved && this.pages.find(p => p.name === saved)) {
@@ -115,6 +117,19 @@ document.addEventListener('alpine:init', () => {
       }
     },
 
+    async loadEffectiveKeys() {
+      try {
+        const res = await fetch('/api/pages')
+        const pagesData = await res.json()
+        for (const pd of pagesData) {
+          const page = this.pages.find(p => p.name === pd.name)
+          if (page && pd.effective_keys && pd.effective_keys.length > 0) {
+            page.effective_keys = pd.effective_keys
+          }
+        }
+      } catch (_) {}
+    },
+
     syncSettings() {
       this.settingsForm = {
         brightness: this.getDeviceConfig(this.activeDeckSerial)?.brightness ?? 75,
@@ -151,10 +166,13 @@ document.addEventListener('alpine:init', () => {
     get gridKeys() {
       const page = this.currentPage
       if (!page) return []
+      const sourceKeys = (page.effective_keys && page.effective_keys.length > 0)
+        ? page.effective_keys
+        : (page.keys || [])
       const keys = []
       const n = this.activeDeck.num_keys
       for (let i = 0; i < n; i++) {
-        const kc = page.keys.find(k => k.index === i)
+        const kc = sourceKeys.find(k => k.index === i)
         const dout = this.displayOutputs[i]
         keys.push({
           index: i,
@@ -163,9 +181,10 @@ document.addEventListener('alpine:init', () => {
           hasDisplay: !!(kc?.display),
           hasAction: !!(kc?.actions?.length),
           actionTypes: this.getActionTypes(kc?.actions || []),
-          displayBg: dout?.background || '',
+          displayBg: (kc?.display && dout?.background) || '',
-          displayText: dout?.text || '',
+          displayText: (kc?.display && dout?.text) || '',
           previewUrl: this.keyPreviewUrl(kc ? kc : {}, dout),
+          isDynamic: !!(page.dynamic_keys && page.effective_keys?.find(k => k.index === i)),
         })
       }
       return keys
@@ -185,7 +204,7 @@ document.addEventListener('alpine:init', () => {
       const k = kc || {}
       let url = '/api/render?key_size=72'
       if (k.icon) url += `&icon=${encodeURIComponent(k.icon)}`
-      const label = dout?.text || this.displayOutputs[k.index]?.text || k.label
+      const label = (k.display && (dout?.text || this.displayOutputs[k.index]?.text)) || k.label
       if (label) url += `&label=${encodeURIComponent(label)}`
       if (k.icon_scale != null) url += `&icon_scale=${k.icon_scale}`
       if (k.font_size != null) url += `&font_size=${k.font_size}`
@@ -306,6 +325,9 @@ document.addEventListener('alpine:init', () => {
       const page = this.currentPage
       if (!page) return
       const kc = page.keys.find(k => k.index === idx)
+      if (!kc && page.dynamic_keys && page.effective_keys?.find(k => k.index === idx)) {
+        return
+      }
       this.editing = idx
       this.showAdvanced = false
 

internal/web/static/index.html

@@ -94,8 +94,11 @@
           :style="{ borderColor: p.name === activePage ? 'var(--accent)' : '' }"
           @click="switchPage(p.name); subView = null">
           <span x-text="p.name"></span>
+          <span x-show="p.dynamic_keys"
+            title="Dynamic keys generator"
+            style="color:var(--accent);font-size:11px;margin-left:4px;">⚡</span>
           <span style="float:right;color:var(--text-muted);font-size:11px;"
-            x-text="p.keys.length + ' keys'"></span>
+            x-text="(p.effective_keys?.length || p.keys.length) + ' keys'"></span>
         </button>
       </template>
     </div>

internal/web/web.go

@@ -1,4 +1,4 @@
-package main
+package web
 
 import (
 	"context"
@@ -18,6 +18,8 @@ import (
 	"time"
 
 	"streamdeck-lets-go/internal/config"
+	"streamdeck-lets-go/internal/deck"
+	"streamdeck-lets-go/internal/render"
 )
 
 //go:embed static/*
@@ -36,9 +38,9 @@ func init() {
 type WebServer struct {
 	cfg        *config.Config
 	configPath string
-	pm         *PageManager
+	pm         *render.PageManager
-	extraPMs   []*PageManager
+	extraPMs   []*render.PageManager
-	decks      []*Deck
+	decks      []*deck.Deck
 	mu         sync.RWMutex
 
 	sseClients map[chan string]struct{}
@@ -59,19 +61,19 @@ func (s *WebServer) UpdateConfig(cfg *config.Config) {
 	s.cfg = cfg
 }
 
-func (s *WebServer) SetPageManager(pm *PageManager) {
+func (s *WebServer) SetPageManager(pm *render.PageManager) {
 	s.mu.Lock()
 	defer s.mu.Unlock()
 	s.pm = pm
 }
 
-func (s *WebServer) SetDecks(decks []*Deck) {
+func (s *WebServer) SetDecks(decks []*deck.Deck) {
 	s.mu.Lock()
 	defer s.mu.Unlock()
 	s.decks = decks
 }
 
-func (s *WebServer) SetExtraPageManagers(pms []*PageManager) {
+func (s *WebServer) SetExtraPageManagers(pms []*render.PageManager) {
 	s.mu.Lock()
 	defer s.mu.Unlock()
 	s.extraPMs = pms
@@ -172,6 +174,14 @@ func (s *WebServer) handleSSE(w http.ResponseWriter, r *http.Request) {
 	s.sseClients[ch] = struct{}{}
 	s.sseMu.Unlock()
 
+	s.mu.RLock()
+	if s.pm != nil {
+		if active := s.pm.ActivePageName(); active != "" {
+			ch <- active
+		}
+	}
+	s.mu.RUnlock()
+
 	notify := r.Context().Done()
 	go func() {
 		<-notify
@@ -208,7 +218,7 @@ func (s *WebServer) handleActivatePage(w http.ResponseWriter, r *http.Request) {
 	}
 
 	s.mu.RLock()
-	allPMs := append([]*PageManager{s.pm}, s.extraPMs...)
+	allPMs := append([]*render.PageManager{s.pm}, s.extraPMs...)
 	s.mu.RUnlock()
 
 	for _, pm := range allPMs {
@@ -218,8 +228,8 @@ func (s *WebServer) handleActivatePage(w http.ResponseWriter, r *http.Request) {
 		if err := pm.ActivatePage(req.Page); err != nil {
 			slog.Warn("activate page", "page", req.Page, "error", err)
 		} else {
-			pm.stopPeriodicKeys()
+			pm.StopPeriodicKeys()
-			pm.startPeriodicKeys()
+			pm.StartPeriodicKeys()
 		}
 	}
 
@@ -339,18 +349,27 @@ func (s *WebServer) handleGetPages(w http.ResponseWriter, r *http.Request) {
 	defer s.mu.RUnlock()
 
 	type pageInfo struct {
-		Name string     `json:"name"`
+		Name          string                `json:"name"`
-		Keys []config.KeyConfig `json:"keys"`
+		Keys          []config.KeyConfig    `json:"keys"`
-		Icon string     `json:"icon,omitempty"`
+		Icon          string                `json:"icon,omitempty"`
+		DynamicKeys   *config.DynamicKeyGen `json:"dynamic_keys,omitempty"`
+		Background    string                `json:"background,omitempty"`
+		EffectiveKeys []config.KeyConfig    `json:"effective_keys,omitempty"`
 	}
 
 	pages := make([]pageInfo, 0, len(s.cfg.Pages))
 	for _, p := range s.cfg.Pages {
-		pages = append(pages, pageInfo{
+		pi := pageInfo{
-			Name: p.Name,
+			Name:        p.Name,
-			Keys: p.Keys,
+			Keys:        p.Keys,
-			Icon: p.Icon,
+			Icon:        p.Icon,
-		})
+			DynamicKeys: p.DynamicKeys,
+			Background:  p.Background,
+		}
+		if p.DynamicKeys != nil && s.pm != nil {
+			pi.EffectiveKeys = s.pm.GetEffectiveKeys(p.Name)
+		}
+		pages = append(pages, pi)
 	}
 
 	w.Header().Set("Content-Type", "application/json")
@@ -404,7 +423,7 @@ func (s *WebServer) handleRender(w http.ResponseWriter, r *http.Request) {
 		kc.Background = bg
 	}
 
-	img := RenderKeyToImage(kc, keySize, s.cfg.ShowLabelBackground)
+	img := render.RenderKeyToImage(kc, keySize, s.cfg.ShowLabelBackground)
 
 	w.Header().Set("Content-Type", "image/png")
 	w.Header().Set("Cache-Control", "no-cache")
@@ -470,7 +489,7 @@ func collectIcons(cfg *config.Config, used map[string]bool) {
 }
 
 func gcImages(cfg *config.Config) {
-	imgDir := filepath.Join(configDir(), "images")
+	imgDir := filepath.Join(config.ConfigDir(), "images")
 	entries, err := os.ReadDir(imgDir)
 	if err != nil {
 		return
@@ -479,7 +498,7 @@ func gcImages(cfg *config.Config) {
 	used := make(map[string]bool)
 	collectIcons(cfg, used)
 
-	backupDir := filepath.Join(configDir(), "backups")
+	backupDir := filepath.Join(config.ConfigDir(), "backups")
 	backupEntries, _ := os.ReadDir(backupDir)
 	for _, be := range backupEntries {
 		if be.IsDir() {
@@ -581,15 +600,15 @@ func (s *WebServer) handleGetBackup(w http.ResponseWriter, r *http.Request) {
 
 func (s *WebServer) handleGetModels(w http.ResponseWriter, r *http.Request) {
 	type modelInfo struct {
-		PID    uint16 `json:"pid"`
+		PID     uint16 `json:"pid"`
-		Name   string `json:"name"`
+		Name    string `json:"name"`
-		KeysX  int    `json:"keys_x"`
+		KeysX   int    `json:"keys_x"`
-		KeysY  int    `json:"keys_y"`
+		KeysY   int    `json:"keys_y"`
-		KeySize int   `json:"key_size"`
+		KeySize int    `json:"key_size"`
 	}
 
-	models := make([]modelInfo, 0, len(knownDecks))
+	models := make([]modelInfo, 0, len(deck.KnownDecks))
-	for _, d := range knownDecks {
+	for _, d := range deck.KnownDecks {
 		models = append(models, modelInfo{
 			PID:     d.PID,
 			Name:    d.Name,
@@ -607,7 +626,7 @@ func (s *WebServer) handleGetDecks(w http.ResponseWriter, r *http.Request) {
 	s.mu.RLock()
 	defer s.mu.RUnlock()
 
-	infos := make([]DeckInfo, 0, len(s.decks))
+	infos := make([]deck.DeckInfo, 0, len(s.decks))
 	for _, d := range s.decks {
 		infos = append(infos, d.DeckInfo())
 	}
@@ -644,7 +663,7 @@ func (s *WebServer) handleUpload(w http.ResponseWriter, r *http.Request) {
 	}
 	defer file.Close()
 
-	uploadDir := filepath.Join(configDir(), "images")
+	uploadDir := filepath.Join(config.ConfigDir(), "images")
 	if err := os.MkdirAll(uploadDir, 0755); err != nil {
 		http.Error(w, fmt.Sprintf("create upload dir: %v", err), http.StatusInternalServerError)
 		return

media.go

@@ -1,11 +0,0 @@
-package main
-
-import (
-	"log/slog"
-)
-
-func init() {
-	slog.Info("media module loaded")
-}
-
-// mediaAction is handled inline in action.go via playerctl/wpctl

packaging/.SRCINFO

@@ -0,0 +1,23 @@
+pkgbase = streamdeck-lets-go-git
+	pkgdesc = Lightweight daemon for controlling Elgato Stream Deck devices with a built-in web UI
+	pkgver = 0.1.0
+	pkgrel = 3
+	url = https://github.com/totmin/streamdeck-lets-go
+	arch = x86_64
+	arch = aarch64
+	license = MIT
+	makedepends = go>=1.26
+	makedepends = git
+	depends = libusb
+	optdepends = librsvg: SVG icon rendering
+	optdepends = fontconfig: system font detection
+	provides = streamdeck-lets-go
+	conflicts = streamdeck-lets-go
+	source = streamdeck-lets-go-git::git+https://github.com/totmin/streamdeck-lets-go.git
+	source = streamdeck-lets-go.service
+	source = 90-streamdeck.rules
+	b2sums = SKIP
+	b2sums = SKIP
+	b2sums = SKIP
+
+pkgname = streamdeck-lets-go-git

packaging/90-streamdeck.rules

@@ -0,0 +1,7 @@
+# Elgato Stream Deck — allow access for locally logged-in users
+# Vendor 0fd9
+SUBSYSTEM=="usb", ATTRS{idVendor}=="0fd9", ATTRS{idProduct}=="0060", TAG+="uaccess"
+SUBSYSTEM=="usb", ATTRS{idVendor}=="0fd9", ATTRS{idProduct}=="0063", TAG+="uaccess"
+SUBSYSTEM=="usb", ATTRS{idVendor}=="0fd9", ATTRS{idProduct}=="006c", TAG+="uaccess"
+SUBSYSTEM=="usb", ATTRS{idVendor}=="0fd9", ATTRS{idProduct}=="006d", TAG+="uaccess"
+SUBSYSTEM=="usb", ATTRS{idVendor}=="0fd9", ATTRS{idProduct}=="0080", TAG+="uaccess"

packaging/PKGBUILD

@@ -0,0 +1,48 @@
+# Maintainer: totmin <totmin@users.noreply.github.com>
+
+pkgname=streamdeck-lets-go-git
+_giturl=https://github.com/totmin/streamdeck-lets-go.git
+pkgver=0.1.0
+pkgrel=3
+pkgdesc="Lightweight daemon for controlling Elgato Stream Deck devices with a built-in web UI"
+arch=('x86_64' 'aarch64')
+url="https://github.com/totmin/streamdeck-lets-go"
+license=('MIT')
+depends=('libusb')
+optdepends=('librsvg: SVG icon rendering'
+            'fontconfig: system font detection')
+makedepends=('go>=1.26' 'git')
+provides=('streamdeck-lets-go')
+conflicts=('streamdeck-lets-go')
+
+source=("${pkgname}::git+${_giturl}"
+         "streamdeck-lets-go.service"
+         "90-streamdeck.rules")
+b2sums=('SKIP'
+        'SKIP'
+        'SKIP')
+
+pkgver() {
+  cd "${srcdir}/${pkgname}"
+  git describe --always --tags 2>/dev/null || echo "r0.$(git rev-parse --short HEAD)"
+}
+
+build() {
+  cd "${srcdir}/${pkgname}"
+  export CGO_ENABLED=1
+  go build \
+    -ldflags "-s -w" \
+    -o streamdeck-lets-go ./cmd/streamdeck-lets-go
+}
+
+package() {
+  cd "${srcdir}/${pkgname}"
+
+  install -Dm755 streamdeck-lets-go "${pkgdir}/usr/bin/streamdeck-lets-go"
+
+  install -Dm644 "${srcdir}/streamdeck-lets-go.service" \
+    "${pkgdir}/usr/lib/systemd/user/streamdeck-lets-go.service"
+
+  install -Dm644 "${srcdir}/90-streamdeck.rules" \
+    "${pkgdir}/usr/lib/udev/rules.d/90-streamdeck.rules"
+}

packaging/streamdeck-lets-go.service

@@ -0,0 +1,14 @@
+[Unit]
+Description=Stream Deck Lets Go daemon
+Documentation=https://github.com/Wakatron/streamdeck-lets-go
+After=graphical-session.target
+Wants=graphical-session.target
+
+[Service]
+Type=simple
+ExecStart=/usr/bin/streamdeck-lets-go daemon
+Restart=on-failure
+RestartSec=3
+
+[Install]
+WantedBy=default.target