Add streamdeck-ctl JSON control CLI
streamdeck-ctl reports device/daemon/key status as JSON and edits the config (brightness, key set/clear/press, daemon control) so front-ends don't have to reimplement YAML handling or device probing. - internal/config/edit.go: comment-preserving, node-level YAML edits with atomic writes; key indices written as !!int so config.Load accepts them. - internal/device: add model names, Lookup() and Present() for probing without opening the HID handle. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01BjuZBBfzXqZgxRhxzJvkkC
This commit is contained in:
Levi Woodard
402
internal/config/edit.go
Normal file
402
internal/config/edit.go
Normal file
@@ -0,0 +1,402 @@
|
||||
package config
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"fmt"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"regexp"
|
||||
"sort"
|
||||
"strconv"
|
||||
"strings"
|
||||
|
||||
"gopkg.in/yaml.v3"
|
||||
)
|
||||
|
||||
// Editing works at the yaml.Node level rather than by marshalling the Config
|
||||
// struct back out. The struct round-trip would drop every comment in the file
|
||||
// and materialise defaults the user never wrote; node-level edits touch only
|
||||
// the mapping entries that actually change.
|
||||
//
|
||||
// Writes are atomic (temp file in the same directory, then rename). The daemon
|
||||
// watches both the config file and its parent directory, so the rename lands as
|
||||
// a CREATE event on the directory watch and triggers a hot reload.
|
||||
|
||||
// KeyEdit describes a change to a single key. Fields present in Set are written
|
||||
// (creating the key block if needed); names listed in Unset are removed. Unset
|
||||
// is applied first, so a field named in both ends up set. Values may be strings,
|
||||
// ints, or map[string]string (params).
|
||||
type KeyEdit struct {
|
||||
Set map[string]any
|
||||
Unset []string
|
||||
}
|
||||
|
||||
// SetBrightness rewrites the top-level brightness value, clamped to 0–100.
|
||||
func SetBrightness(path string, value int) error {
|
||||
if value < 0 {
|
||||
value = 0
|
||||
}
|
||||
if value > 100 {
|
||||
value = 100
|
||||
}
|
||||
return editDocument(path, func(root *yaml.Node) error {
|
||||
mapSet(root, "brightness", scalarNode(strconv.Itoa(value), "!!int"))
|
||||
return nil
|
||||
})
|
||||
}
|
||||
|
||||
// ApplyKeyEdit merges an edit into the keys block for the given index, creating
|
||||
// the keys block or the key entry if either is missing.
|
||||
func ApplyKeyEdit(path string, index int, edit KeyEdit) error {
|
||||
return editDocument(path, func(root *yaml.Node) error {
|
||||
keys := mapGet(root, "keys")
|
||||
if keys == nil || keys.Kind != yaml.MappingNode {
|
||||
keys = &yaml.Node{Kind: yaml.MappingNode}
|
||||
mapSet(root, "keys", keys)
|
||||
}
|
||||
// A fresh config from the installer carries `keys: {}` — a flow-style
|
||||
// empty mapping. Force block style or new entries render inline.
|
||||
keys.Style = 0
|
||||
|
||||
entry := mapGet(keys, strconv.Itoa(index))
|
||||
if entry == nil || entry.Kind != yaml.MappingNode {
|
||||
entry = &yaml.Node{Kind: yaml.MappingNode}
|
||||
// The index must be an int scalar: config.Load unmarshals keys into
|
||||
// map[int]KeyConfig, and yaml.v3 refuses to coerce a !!str key ("25":)
|
||||
// into an int — a string-tagged key here bricks the config on reload.
|
||||
mapSetNode(keys, scalarNode(strconv.Itoa(index), "!!int"), entry)
|
||||
}
|
||||
entry.Style = 0
|
||||
|
||||
for _, name := range edit.Unset {
|
||||
mapDelete(entry, name)
|
||||
}
|
||||
// Deterministic ordering so repeated edits don't shuffle the file, and so
|
||||
// a brand-new key block reads in a sensible order.
|
||||
for _, name := range sortedFieldNames(edit.Set) {
|
||||
node, err := valueNode(edit.Set[name])
|
||||
if err != nil {
|
||||
return fmt.Errorf("field %q: %w", name, err)
|
||||
}
|
||||
mapSet(entry, name, node)
|
||||
}
|
||||
return nil
|
||||
})
|
||||
}
|
||||
|
||||
// ClearKey removes a key entry entirely. Removing a key that isn't there is not
|
||||
// an error — the caller's intent (that slot ends up empty) is already satisfied.
|
||||
func ClearKey(path string, index int) error {
|
||||
return editDocument(path, func(root *yaml.Node) error {
|
||||
keys := mapGet(root, "keys")
|
||||
if keys == nil || keys.Kind != yaml.MappingNode {
|
||||
return nil
|
||||
}
|
||||
mapDelete(keys, strconv.Itoa(index))
|
||||
return nil
|
||||
})
|
||||
}
|
||||
|
||||
// fieldOrder is the order key fields are written in when a key block is built or
|
||||
// extended, so generated YAML reads the way the hand-written examples do.
|
||||
var fieldOrder = []string{
|
||||
"icon", "icon_true", "icon_false",
|
||||
"text", "text_color", "text_command", "refresh",
|
||||
"module", "function", "params",
|
||||
"command", "poll",
|
||||
}
|
||||
|
||||
func sortedFieldNames(m map[string]any) []string {
|
||||
rank := make(map[string]int, len(fieldOrder))
|
||||
for i, name := range fieldOrder {
|
||||
rank[name] = i
|
||||
}
|
||||
names := make([]string, 0, len(m))
|
||||
for name := range m {
|
||||
names = append(names, name)
|
||||
}
|
||||
sort.Slice(names, func(i, j int) bool {
|
||||
ri, oki := rank[names[i]]
|
||||
rj, okj := rank[names[j]]
|
||||
if oki != okj {
|
||||
return oki // known fields sort before unknown ones
|
||||
}
|
||||
if oki && ri != rj {
|
||||
return ri < rj
|
||||
}
|
||||
return names[i] < names[j]
|
||||
})
|
||||
return names
|
||||
}
|
||||
|
||||
// editDocument parses path, hands the root mapping to fn, and writes the result
|
||||
// back atomically. The file must already exist and parse.
|
||||
func editDocument(path string, fn func(root *yaml.Node) error) error {
|
||||
raw, err := os.ReadFile(path)
|
||||
if err != nil {
|
||||
return fmt.Errorf("read config %q: %w", path, err)
|
||||
}
|
||||
|
||||
// yaml.v3 keeps comments but discards blank lines, so a config edited from a
|
||||
// GUI would slowly lose its paragraph breaks. Standing them in as sentinel
|
||||
// comments carries them through the round-trip.
|
||||
data, blanksProtected := protectBlankLines(raw)
|
||||
|
||||
var doc yaml.Node
|
||||
if err := yaml.Unmarshal(data, &doc); err != nil {
|
||||
return fmt.Errorf("parse config %q: %w", path, err)
|
||||
}
|
||||
|
||||
var root *yaml.Node
|
||||
switch {
|
||||
case doc.Kind == yaml.DocumentNode && len(doc.Content) > 0:
|
||||
root = doc.Content[0]
|
||||
case doc.Kind == 0:
|
||||
// Empty (or comment-only) file — start a mapping so edits have somewhere to go.
|
||||
root = &yaml.Node{Kind: yaml.MappingNode}
|
||||
doc = yaml.Node{Kind: yaml.DocumentNode, Content: []*yaml.Node{root}}
|
||||
default:
|
||||
return fmt.Errorf("config %q: unexpected document shape", path)
|
||||
}
|
||||
if root.Kind != yaml.MappingNode {
|
||||
return fmt.Errorf("config %q: top level is not a mapping", path)
|
||||
}
|
||||
|
||||
if err := fn(root); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
var buf bytes.Buffer
|
||||
enc := yaml.NewEncoder(&buf)
|
||||
enc.SetIndent(2)
|
||||
if err := enc.Encode(&doc); err != nil {
|
||||
return fmt.Errorf("encode config: %w", err)
|
||||
}
|
||||
if err := enc.Close(); err != nil {
|
||||
return fmt.Errorf("encode config: %w", err)
|
||||
}
|
||||
|
||||
out := buf.Bytes()
|
||||
if blanksProtected {
|
||||
out = restoreBlankLines(out)
|
||||
}
|
||||
return writeAtomic(path, out)
|
||||
}
|
||||
|
||||
// blankSentinel stands in for a blank line across the parse/encode round-trip.
|
||||
// It is deliberately obscure so it cannot collide with a real comment.
|
||||
const blankSentinel = "#__streamdeck_go_blank_line__"
|
||||
|
||||
// protectBlankLines rewrites blank lines as sentinel comments. It reports false
|
||||
// (and leaves the input untouched) when the document contains a block scalar,
|
||||
// where an inserted line would become part of the string's content rather than
|
||||
// structure. Losing blank-line formatting is a cosmetic regression; corrupting a
|
||||
// multi-line command is not, so the ambiguous case declines to act.
|
||||
func protectBlankLines(data []byte) ([]byte, bool) {
|
||||
if blockScalarPattern.Match(data) {
|
||||
return data, false
|
||||
}
|
||||
lines := strings.Split(string(data), "\n")
|
||||
changed := false
|
||||
for i, line := range lines {
|
||||
if strings.TrimSpace(line) == "" && i != len(lines)-1 {
|
||||
lines[i] = blankSentinel
|
||||
changed = true
|
||||
}
|
||||
}
|
||||
if !changed {
|
||||
return data, false
|
||||
}
|
||||
return []byte(strings.Join(lines, "\n")), true
|
||||
}
|
||||
|
||||
// restoreBlankLines turns sentinel comments back into blank lines. The encoder
|
||||
// may have indented them along with the comment block they joined, so the match
|
||||
// is on the trimmed line.
|
||||
func restoreBlankLines(data []byte) []byte {
|
||||
lines := strings.Split(string(data), "\n")
|
||||
for i, line := range lines {
|
||||
if strings.TrimSpace(line) == blankSentinel {
|
||||
lines[i] = ""
|
||||
}
|
||||
}
|
||||
return []byte(strings.Join(lines, "\n"))
|
||||
}
|
||||
|
||||
// blockScalarPattern matches a literal or folded block scalar header, e.g.
|
||||
// `command: |`, `command: >-`, or `command: |2 # note`.
|
||||
var blockScalarPattern = regexp.MustCompile(`(?m):[ \t]*[|>][-+0-9]*[ \t]*(#.*)?$`)
|
||||
|
||||
// writeAtomic writes to a temp file in the same directory and renames it into
|
||||
// place, so a reader (or the daemon's fsnotify reload) never sees a half-written
|
||||
// config. The original mode is preserved when it can be read.
|
||||
func writeAtomic(path string, data []byte) error {
|
||||
dir := filepath.Dir(path)
|
||||
mode := os.FileMode(0o644)
|
||||
if info, err := os.Stat(path); err == nil {
|
||||
mode = info.Mode().Perm()
|
||||
}
|
||||
|
||||
tmp, err := os.CreateTemp(dir, ".streamdeck-config-*.yaml")
|
||||
if err != nil {
|
||||
return fmt.Errorf("create temp file in %q: %w", dir, err)
|
||||
}
|
||||
tmpName := tmp.Name()
|
||||
defer os.Remove(tmpName) // no-op once the rename succeeds
|
||||
|
||||
if _, err := tmp.Write(data); err != nil {
|
||||
tmp.Close()
|
||||
return fmt.Errorf("write temp file: %w", err)
|
||||
}
|
||||
if err := tmp.Sync(); err != nil {
|
||||
tmp.Close()
|
||||
return fmt.Errorf("sync temp file: %w", err)
|
||||
}
|
||||
if err := tmp.Close(); err != nil {
|
||||
return fmt.Errorf("close temp file: %w", err)
|
||||
}
|
||||
if err := os.Chmod(tmpName, mode); err != nil {
|
||||
return fmt.Errorf("chmod temp file: %w", err)
|
||||
}
|
||||
if err := os.Rename(tmpName, path); err != nil {
|
||||
return fmt.Errorf("replace %q: %w", path, err)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// ── yaml.Node mapping helpers ────────────────────────────────────────────────
|
||||
//
|
||||
// A MappingNode stores Content as a flat [key, value, key, value, ...] slice.
|
||||
|
||||
func mapGet(m *yaml.Node, key string) *yaml.Node {
|
||||
if m == nil || m.Kind != yaml.MappingNode {
|
||||
return nil
|
||||
}
|
||||
for i := 0; i+1 < len(m.Content); i += 2 {
|
||||
if m.Content[i].Value == key {
|
||||
return m.Content[i+1]
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// mapSet replaces the value for key, or appends the pair if it isn't present.
|
||||
// Replacing keeps the existing key node so its comments stay attached.
|
||||
func mapSet(m *yaml.Node, key string, value *yaml.Node) {
|
||||
for i := 0; i+1 < len(m.Content); i += 2 {
|
||||
if m.Content[i].Value == key {
|
||||
// Carry the old value's comments onto the replacement — they describe
|
||||
// the setting, not the specific value being overwritten.
|
||||
old := m.Content[i+1]
|
||||
if value.HeadComment == "" {
|
||||
value.HeadComment = old.HeadComment
|
||||
}
|
||||
if value.LineComment == "" {
|
||||
value.LineComment = old.LineComment
|
||||
}
|
||||
if value.FootComment == "" {
|
||||
value.FootComment = old.FootComment
|
||||
}
|
||||
m.Content[i+1] = value
|
||||
return
|
||||
}
|
||||
}
|
||||
m.Content = append(m.Content, scalarNode(key, "!!str"), value)
|
||||
}
|
||||
|
||||
// mapSetNode is mapSet with a caller-built key node, for keys that must carry a
|
||||
// non-string tag (e.g. the !!int key indices under `keys:`).
|
||||
func mapSetNode(m *yaml.Node, key, value *yaml.Node) {
|
||||
for i := 0; i+1 < len(m.Content); i += 2 {
|
||||
if m.Content[i].Value == key.Value {
|
||||
m.Content[i+1] = value
|
||||
return
|
||||
}
|
||||
}
|
||||
m.Content = append(m.Content, key, value)
|
||||
}
|
||||
|
||||
func mapDelete(m *yaml.Node, key string) {
|
||||
if m == nil || m.Kind != yaml.MappingNode {
|
||||
return
|
||||
}
|
||||
for i := 0; i+1 < len(m.Content); i += 2 {
|
||||
if m.Content[i].Value == key {
|
||||
m.Content = append(m.Content[:i], m.Content[i+2:]...)
|
||||
return
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func scalarNode(value, tag string) *yaml.Node {
|
||||
return &yaml.Node{Kind: yaml.ScalarNode, Tag: tag, Value: value}
|
||||
}
|
||||
|
||||
// valueNode converts a Go value from a KeyEdit into a yaml.Node.
|
||||
func valueNode(v any) (*yaml.Node, error) {
|
||||
switch typed := v.(type) {
|
||||
case string:
|
||||
return stringNode(typed), nil
|
||||
case int:
|
||||
return scalarNode(strconv.Itoa(typed), "!!int"), nil
|
||||
case bool:
|
||||
return scalarNode(strconv.FormatBool(typed), "!!bool"), nil
|
||||
case map[string]string:
|
||||
node := &yaml.Node{Kind: yaml.MappingNode}
|
||||
names := make([]string, 0, len(typed))
|
||||
for name := range typed {
|
||||
names = append(names, name)
|
||||
}
|
||||
sort.Strings(names)
|
||||
for _, name := range names {
|
||||
node.Content = append(node.Content, scalarNode(name, "!!str"), stringNode(typed[name]))
|
||||
}
|
||||
return node, nil
|
||||
default:
|
||||
return nil, fmt.Errorf("unsupported value type %T", v)
|
||||
}
|
||||
}
|
||||
|
||||
// stringNode emits a string scalar, quoting it when leaving it bare would change
|
||||
// its meaning on re-parse (empty, leading/trailing space, or a value YAML would
|
||||
// read back as a bool/number/null).
|
||||
func stringNode(s string) *yaml.Node {
|
||||
node := scalarNode(s, "!!str")
|
||||
if needsQuoting(s) {
|
||||
node.Style = yaml.DoubleQuotedStyle
|
||||
}
|
||||
return node
|
||||
}
|
||||
|
||||
func needsQuoting(s string) bool {
|
||||
if s == "" {
|
||||
return true
|
||||
}
|
||||
if s != trimSpace(s) {
|
||||
return true
|
||||
}
|
||||
var probe any
|
||||
if err := yaml.Unmarshal([]byte(s), &probe); err != nil {
|
||||
// Not parseable bare (e.g. contains ": ") — quote it and let the encoder escape.
|
||||
return true
|
||||
}
|
||||
if _, isString := probe.(string); !isString {
|
||||
return true
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
func trimSpace(s string) string {
|
||||
start, end := 0, len(s)
|
||||
for start < end && isSpace(s[start]) {
|
||||
start++
|
||||
}
|
||||
for end > start && isSpace(s[end-1]) {
|
||||
end--
|
||||
}
|
||||
return s[start:end]
|
||||
}
|
||||
|
||||
func isSpace(b byte) bool {
|
||||
return b == ' ' || b == '\t' || b == '\n' || b == '\r'
|
||||
}
|
||||
126
internal/config/edit_test.go
Normal file
126
internal/config/edit_test.go
Normal file
@@ -0,0 +1,126 @@
|
||||
package config
|
||||
|
||||
import (
|
||||
"os"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func writeConfig(t *testing.T, content string) string {
|
||||
t.Helper()
|
||||
path := filepath.Join(t.TempDir(), "config.yaml")
|
||||
if err := os.WriteFile(path, []byte(content), 0o644); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
return path
|
||||
}
|
||||
|
||||
// Regression: a new key's index must be written as an int scalar. A !!str key
|
||||
// ("25":) makes config.Load fail — yaml.v3 refuses string keys for map[int] —
|
||||
// which bricked the config on the daemon's next hot reload.
|
||||
func TestApplyKeyEditNewSlotLoadsBack(t *testing.T) {
|
||||
path := writeConfig(t, "icons_dir: ./icons\nbrightness: 70\nkeys: {}\n")
|
||||
|
||||
err := ApplyKeyEdit(path, 25, KeyEdit{Set: map[string]any{
|
||||
"icon": "test.png",
|
||||
"command": "echo hi",
|
||||
}})
|
||||
if err != nil {
|
||||
t.Fatalf("ApplyKeyEdit: %v", err)
|
||||
}
|
||||
|
||||
cfg, err := Load(path)
|
||||
if err != nil {
|
||||
t.Fatalf("Load after edit: %v", err)
|
||||
}
|
||||
key, ok := cfg.Keys[25]
|
||||
if !ok {
|
||||
t.Fatalf("key 25 missing after edit; keys=%v", cfg.Keys)
|
||||
}
|
||||
if key.Icon != "test.png" || key.Command != "echo hi" {
|
||||
t.Fatalf("key 25 = %+v", key)
|
||||
}
|
||||
|
||||
raw, _ := os.ReadFile(path)
|
||||
if strings.Contains(string(raw), `"25"`) {
|
||||
t.Fatalf("index written as a quoted string:\n%s", raw)
|
||||
}
|
||||
}
|
||||
|
||||
// Editing an existing key must merge, and comments/blank lines must survive.
|
||||
func TestApplyKeyEditMergePreservesFormatting(t *testing.T) {
|
||||
path := writeConfig(t, `icons_dir: ./icons
|
||||
|
||||
# the deck
|
||||
keys:
|
||||
0:
|
||||
icon: a.png # keep me
|
||||
command: run-a
|
||||
`)
|
||||
|
||||
if err := ApplyKeyEdit(path, 0, KeyEdit{Set: map[string]any{"text": "Hi"}}); err != nil {
|
||||
t.Fatalf("ApplyKeyEdit: %v", err)
|
||||
}
|
||||
|
||||
raw, _ := os.ReadFile(path)
|
||||
text := string(raw)
|
||||
for _, want := range []string{"# the deck", "# keep me", "command: run-a", "text: Hi", "\n\n"} {
|
||||
if !strings.Contains(text, want) {
|
||||
t.Fatalf("output missing %q:\n%s", want, text)
|
||||
}
|
||||
}
|
||||
|
||||
cfg, err := Load(path)
|
||||
if err != nil {
|
||||
t.Fatalf("Load: %v", err)
|
||||
}
|
||||
if cfg.Keys[0].Icon != "a.png" || cfg.Keys[0].Text != "Hi" {
|
||||
t.Fatalf("merge lost fields: %+v", cfg.Keys[0])
|
||||
}
|
||||
}
|
||||
|
||||
// Unset is applied before Set, so a field named in both ends up set.
|
||||
func TestApplyKeyEditSetWinsOverUnset(t *testing.T) {
|
||||
path := writeConfig(t, "keys:\n 0:\n command: old\n")
|
||||
|
||||
err := ApplyKeyEdit(path, 0, KeyEdit{
|
||||
Set: map[string]any{"command": "new"},
|
||||
Unset: []string{"command"},
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("ApplyKeyEdit: %v", err)
|
||||
}
|
||||
cfg, err := Load(path)
|
||||
if err != nil {
|
||||
t.Fatalf("Load: %v", err)
|
||||
}
|
||||
if cfg.Keys[0].Command != "new" {
|
||||
t.Fatalf("command = %q, want %q", cfg.Keys[0].Command, "new")
|
||||
}
|
||||
}
|
||||
|
||||
func TestClearKeyAndSetBrightness(t *testing.T) {
|
||||
path := writeConfig(t, "brightness: 70\nkeys:\n 3:\n command: x\n")
|
||||
|
||||
if err := ClearKey(path, 3); err != nil {
|
||||
t.Fatalf("ClearKey: %v", err)
|
||||
}
|
||||
if err := ClearKey(path, 99); err != nil { // absent key is not an error
|
||||
t.Fatalf("ClearKey absent: %v", err)
|
||||
}
|
||||
if err := SetBrightness(path, 140); err != nil { // clamped
|
||||
t.Fatalf("SetBrightness: %v", err)
|
||||
}
|
||||
|
||||
cfg, err := Load(path)
|
||||
if err != nil {
|
||||
t.Fatalf("Load: %v", err)
|
||||
}
|
||||
if len(cfg.Keys) != 0 {
|
||||
t.Fatalf("keys not cleared: %v", cfg.Keys)
|
||||
}
|
||||
if cfg.Brightness != 100 {
|
||||
t.Fatalf("brightness = %d, want 100", cfg.Brightness)
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user