en2zmax/streamdeck-lets-go
1
0
Fork 0
Code Issues 1 Activity

Multi-device support, dynamic grid adaptation, keyboard action

Browse Source 
- Multi-device: OpenAllDecks(), GET /api/decks, per-deck PageManagers
- Dynamic grid: frontend adapts to connected device layout
- Keyboard action: new action type for sending key combos via wtype/xdotool
- Key recorder UI: click-based modifier toggles + single key capture
- Config: remove hardcoded maxKey validation
- Screensaver and auto-switch sync across all decks
This commit is contained in:
Maksim Totmin 2026-06-16 22:51:39 +07:00
parent 4c98a9d670
commit dfe6544686
8 changed files with 216 additions and 53 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
.gitignore vendored
View File

@ -3,3 +3,4 @@ streamdeck-lets-go
*.out
*.exe
/images/
PLAN.md

136
daemon.go
View File

@ -37,11 +37,11 @@ func Run(ctx context.Context, cfg *config.Config, opts RunOptions) error {
return nil
}
var deck *Deck
var decks []*Deck
var err error
for {
deck, err = OpenDeck("")
decks, err = OpenAllDecks()
if err == nil {
break
}
@ -52,18 +52,34 @@ func Run(ctx context.Context, cfg *config.Config, opts RunOptions) error {
case <-time.After(5 * time.Second):
}
}
defer deck.Close()
deck.SetBrightness(deviceBrightness(cfg))
pm := NewPageManager(deck)
pm.LoadPages(cfg.Pages)
web.SetPageManager(pm)
if err := pm.ActivatePage(cfg.DefaultPage); err != nil {
slog.Warn("activate default page", "error", err)
pageMgrs := make([]*PageManager, len(decks))
for i, d := range decks {
pageMgrs[i] = NewPageManager(d)
pageMgrs[i].LoadPages(cfg.Pages)
}
primaryPM := pageMgrs[0]
primaryDeck := decks[0]
defer func() {
for _, d := range decks {
d.Close()
}
}()
for _, d := range decks {
d.SetBrightness(deviceBrightness(cfg, d.Serial()))
}
web.SetDecks(decks)
web.SetPageManager(primaryPM)
for _, pm := range pageMgrs {
if err := pm.ActivatePage(cfg.DefaultPage); err != nil {
slog.Warn("activate default page", "error", err)
}
pm.startPeriodicKeys()
}
pm.startPeriodicKeys()
var windowCh <-chan Window
var detector WindowDetector
@ -93,20 +109,23 @@ func Run(ctx context.Context, cfg *config.Config, opts RunOptions) error {
defer configTicker.Stop()
var lastConfigMod time.Time
slog.Info("daemon started")
slog.Info("daemon started", "decks", len(decks))
defer slog.Info("daemon stopped")
for {
select {
case evt, ok := <-deck.Events():
case evt, ok := <-primaryDeck.Events():
if !ok {
slog.Warn("deck event channel closed, attempting reconnect...")
deck.Close()
deck = reconnectDeck(ctx, cfg, &pm, asm)
if deck == nil {
primaryDeck.Close()
newDeck := reconnectDeck(ctx, cfg, &primaryPM, asm)
if newDeck == nil {
return ctx.Err()
}
deck.SetBrightness(deviceBrightness(cfg))
decks[0] = newDeck
primaryDeck = newDeck
web.SetDecks(decks)
newDeck.SetBrightness(deviceBrightness(cfg, newDeck.Serial()))
continue
}
@ -115,22 +134,24 @@ func Run(ctx context.Context, cfg *config.Config, opts RunOptions) error {
if evt.Kind == EventKeyPressed {
if wasSsActive {
ssCtrl.Deactivate(deck)
ssCtrl.Deactivate(primaryDeck)
savedOutputs := pm.GetDisplayOutputs()
savedOutputs := primaryPM.GetDisplayOutputs()
if page := pm.ActivePage(); page != nil {
if err := pm.ActivatePage(pm.ActivePageName()); err != nil {
slog.Warn("screensaver: re-render page", "error", err)
if page := primaryPM.ActivePage(); page != nil {
for _, pm := range pageMgrs {
if err := pm.ActivatePage(primaryPM.ActivePageName()); err != nil {
slog.Warn("screensaver: re-render page", "error", err)
}
}
}
for idx, output := range savedOutputs {
pm.ReRenderDisplayKey(idx, output)
primaryPM.ReRenderDisplayKey(idx, output)
}
}
page := pm.ActivePage()
page := primaryPM.ActivePage()
if page == nil {
continue
}
@ -143,9 +164,14 @@ func Run(ctx context.Context, cfg *config.Config, opts RunOptions) error {
}
go func(a *config.Action) {
if err := ExecuteAction(a, deck, pm); err != nil {
if err := ExecuteAction(a, primaryDeck, primaryPM); err != nil {
slog.Error("execute action", "error", err)
}
if a.Type == "page" {
for _, pm := range pageMgrs[1:] {
pm.ActivatePage(a.Page)
}
}
}(k.Action)
break
}
@ -153,15 +179,17 @@ func Run(ctx context.Context, cfg *config.Config, opts RunOptions) error {
}
case win := <-windowCh:
if page, ok := asm.Evaluate(win, pm.ActivePageName()); ok {
if err := pm.ActivatePage(page); err != nil {
slog.Warn("auto-switch: activate page", "error", err)
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.startPeriodicKeys()
}
pm.startPeriodicKeys()
}
case <-configTicker.C:
path := config.ConfigPath(opts.ConfigPath)
path := config.ConfigPath(opts.ConfigPath)
fi, err := os.Stat(path)
if err != nil {
continue
@ -178,37 +206,48 @@ func Run(ctx context.Context, cfg *config.Config, opts RunOptions) error {
cfg = newCfg
web.UpdateConfig(cfg)
ssCtrl = NewScreensaver(&cfg.Screensaver)
deck.SetBrightness(deviceBrightness(cfg))
pm.stopPeriodicKeys()
pm.LoadPages(cfg.Pages)
for _, d := range decks {
d.SetBrightness(deviceBrightness(cfg, d.Serial()))
}
for _, pm := range pageMgrs {
pm.stopPeriodicKeys()
pm.LoadPages(cfg.Pages)
}
asm.Reload(cfg.AutoSwitch)
if len(cfg.AutoSwitch) > 0 && detector == nil {
detector = NewWindowDetector()
windowCh, _ = detector.Start(ctx)
}
if err := pm.ActivatePage(cfg.DefaultPage); err != nil {
slog.Warn("reload: activate default page", "error", err)
for _, pm := range pageMgrs {
if err := pm.ActivatePage(cfg.DefaultPage); err != nil {
slog.Warn("reload: activate default page", "error", err)
}
pm.startPeriodicKeys()
}
pm.startPeriodicKeys()
}
if lastConfigMod.IsZero() {
lastConfigMod = mt
}
case <-reconnectTicker.C:
if err := deck.SetBrightness(deck.Brightness()); err != nil {
if err := primaryDeck.SetBrightness(primaryDeck.Brightness()); err != nil {
slog.Warn("deck connection lost, reconnecting...", "error", err)
deck.Close()
deck = reconnectDeck(ctx, cfg, &pm, asm)
if deck == nil {
primaryDeck.Close()
newDeck := reconnectDeck(ctx, cfg, &primaryPM, asm)
if newDeck == nil {
return ctx.Err()
}
deck.SetBrightness(deviceBrightness(cfg))
decks[0] = newDeck
primaryDeck = newDeck
web.SetDecks(decks)
newDeck.SetBrightness(deviceBrightness(cfg, newDeck.Serial()))
}
case <-ssTicker.C:
if ssCtrl.Check() {
ssCtrl.Activate(deck, &cfg.Screensaver)
for _, d := range decks {
ssCtrl.Activate(d, &cfg.Screensaver)
}
}
case <-ctx.Done():
@ -229,9 +268,14 @@ func checkKeyboardTool() {
}
}
func deviceBrightness(cfg *config.Config) int {
if len(cfg.Devices) > 0 && cfg.Devices[0].Brightness > 0 {
return cfg.Devices[0].Brightness
func deviceBrightness(cfg *config.Config, serial string) int {
for _, d := range cfg.Devices {
if d.Serial == serial || d.Serial == "" {
if d.Brightness > 0 {
return d.Brightness
}
return 75
}
}
return 75
}

45
deck.go
View File

@ -163,6 +163,51 @@ func (d *Deck) Events() <-chan Event { return d.events }
func (d *Deck) NumKeys() int { return d.cfg.KeysX * d.cfg.KeysY }
func (d *Deck) KeySize() int { return d.cfg.KeySize }
func (d *Deck) Config() DeckConfig { return d.cfg }
func (d *Deck) Model() string { return d.cfg.Name }
type DeckInfo struct {
Serial string `json:"serial"`
Model string `json:"model"`
KeysX int `json:"keys_x"`
KeysY int `json:"keys_y"`
NumKeys int `json:"num_keys"`
KeySize int `json:"key_size"`
}
func (d *Deck) DeckInfo() DeckInfo {
return DeckInfo{
Serial: d.serial,
Model: d.cfg.Name,
KeysX: d.cfg.KeysX,
KeysY: d.cfg.KeysY,
NumKeys: d.cfg.KeysX * d.cfg.KeysY,
KeySize: d.cfg.KeySize,
}
}
func OpenAllDecks() ([]*Deck, error) {
devices := hid.Enumerate(streamdeck.VendorID, 0)
if len(devices) == 0 {
return nil, fmt.Errorf("no stream deck devices found")
}
var decks []*Deck
for _, d := range devices {
if _, ok := findConfig(d.ProductID); !ok {
slog.Warn("skipping unsupported device", "pid", fmt.Sprintf("0x%04x", d.ProductID))
continue
}
deck, err := OpenDeck(d.Serial)
if err != nil {
slog.Warn("failed to open deck", "serial", d.Serial, "error", err)
continue
}
decks = append(decks, deck)
}
if len(decks) == 0 {
return nil, fmt.Errorf("no supported stream deck devices could be opened")
}
return decks, nil
}
func (d *Deck) SetBrightness(val int) error {
if val < 0 {

4
internal/config/config.go
View File

@ -160,14 +160,10 @@ func (c *Config) Validate() error {
pageNames[p.Name] = true
seenKeys := make(map[int]bool)
maxKey := 31
for _, k := range p.Keys {
if k.Index < 0 {
return fmt.Errorf("page %s: key index must be >= 0", p.Name)
}
if k.Index > maxKey {
return fmt.Errorf("page %s: key index %d exceeds max %d", p.Name, k.Index, maxKey)
}
if seenKeys[k.Index] {
return fmt.Errorf("page %s: duplicate key index %d", p.Name, k.Index)
}

23
static/app.js
View File

@ -10,6 +10,8 @@ document.addEventListener('alpine:init', () => {
toast: null,
displayOutputs: {},
isCapturingKey: false,
decks: [],
activeDeckSerial: '',
// ── Edit state ──
editing: null,
@ -25,9 +27,22 @@ document.addEventListener('alpine:init', () => {
// ── Init ──
async init() {
await this.loadConfig()
await this.loadDecks()
setInterval(() => this.pollDisplayOutputs(), 3000)
},
async loadDecks() {
try {
const res = await fetch('/api/decks')
if (res.ok) {
this.decks = await res.json()
if (this.decks.length > 0 && !this.activeDeckSerial) {
this.activeDeckSerial = this.decks[0].serial
}
}
} catch (_) {}
},
async pollDisplayOutputs() {
if (this.view !== 'grid') return
try {
@ -69,12 +84,18 @@ document.addEventListener('alpine:init', () => {
return this.pages.map(p => p.name)
},
get activeDeck() {
return this.decks.find(d => d.serial === this.activeDeckSerial)
|| { keys_x: 5, keys_y: 3, num_keys: 15 }
},
// ── Grid ──
get gridKeys() {
const page = this.currentPage
if (!page) return []
const keys = []
for (let i = 0; i < 15; i++) {
const n = this.activeDeck.num_keys
for (let i = 0; i < n; i++) {
const kc = page.keys.find(k => k.index === i)
keys.push({
index: i,

10
static/index.html
View File

@ -45,7 +45,15 @@
<!-- ═══ Grid View ═══ -->
<main x-show="view === 'grid' && !subView">
<div class="deck-grid">
<div class="deck-selector" x-show="decks.length > 1">
<template x-for="d in decks" :key="d.serial">
<button class="deck-btn"
:class="{ active: d.serial === activeDeckSerial }"
@click="activeDeckSerial = d.serial"
x-text="d.model + ' (' + d.keys_x + '\u00d7' + d.keys_y + ')'"></button>
</template>
</div>
<div class="deck-grid" :style="'grid-template-columns: repeat(' + activeDeck.keys_x + ', 1fr)'">
<template x-for="key in gridKeys" :key="key.index">
<button class="key-btn"
:class="{ empty: !key.configured }"

28
static/styles.css
View File

@ -107,7 +107,6 @@ main {
.deck-grid {
display: grid;
grid-template-columns: repeat(5, 1fr);
gap: 8px;
padding: 20px;
background: var(--surface);
@ -115,6 +114,33 @@ main {
border: 1px solid var(--border);
}
.deck-selector {
display: flex;
gap: 4px;
margin-bottom: 8px;
align-self: stretch;
}
.deck-btn {
flex: 1;
padding: 6px 10px;
background: var(--bg);
border: 1px solid var(--border);
border-radius: var(--radius-xs);
color: var(--text-muted);
font-size: 11px;
font-weight: 600;
font-family: inherit;
cursor: pointer;
transition: all var(--transition);
text-align: center;
}
.deck-btn:hover { color: var(--text); border-color: var(--border-light); }
.deck-btn.active {
background: var(--accent);
color: #fff;
border-color: var(--accent);
}
.key-btn {
aspect-ratio: 1;
border: 1px solid var(--border);

22
web.go
View File

@ -37,6 +37,7 @@ type WebServer struct {
cfg *config.Config
configPath string
pm *PageManager
decks []*Deck
mu sync.RWMutex
}
@ -56,6 +57,12 @@ func (s *WebServer) SetPageManager(pm *PageManager) {
s.pm = pm
}
func (s *WebServer) SetDecks(decks []*Deck) {
s.mu.Lock()
defer s.mu.Unlock()
s.decks = decks
}
func (s *WebServer) Serve(ctx context.Context, addr string) error {
mux := http.NewServeMux()
@ -75,6 +82,8 @@ func (s *WebServer) Serve(ctx context.Context, addr string) error {
mux.HandleFunc("GET /api/models", s.handleGetModels)
mux.HandleFunc("GET /api/decks", s.handleGetDecks)
mux.HandleFunc("GET /api/status", s.handleGetStatus)
mux.Handle("GET /static/", http.StripPrefix("/static/", http.FileServer(http.FS(staticRoot))))
@ -471,6 +480,19 @@ func (s *WebServer) handleGetModels(w http.ResponseWriter, r *http.Request) {
json.NewEncoder(w).Encode(models)
}
func (s *WebServer) handleGetDecks(w http.ResponseWriter, r *http.Request) {
s.mu.RLock()
defer s.mu.RUnlock()
infos := make([]DeckInfo, 0, len(s.decks))
for _, d := range s.decks {
infos = append(infos, d.DeckInfo())
}
w.Header().Set("Content-Type", "application/json")
json.NewEncoder(w).Encode(infos)
}
func (s *WebServer) handleGetStatus(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json")
json.NewEncoder(w).Encode(map[string]interface{}{