feat: OAuth SSO, decoder programming, and wizard drive support

pkgs/bigfred/dcc-bus/cli/cli.go

@@ -60,6 +60,9 @@ type Flags struct {
 	SingleVehicleControl bool
 	AllocatePhysicalSlots bool
 
+	EnableProgramming       bool
+	DefaultProgrammingTrack string
+
 	AllowedOrigins []string
 }
 
@@ -90,6 +93,10 @@ should rarely be invoked manually.`,
 			if err != nil {
 				return fmt.Errorf("dcc-bus station config: %w", err)
 			}
+			progTrack, err := ProgrammingTrackFromFlag(f.DefaultProgrammingTrack)
+			if err != nil {
+				return fmt.Errorf("dcc-bus programming config: %w", err)
+			}
 			cfg := dccbus.Config{
 				LayoutID:         f.LayoutID,
 				CommandStationID: f.CommandStationID,
@@ -119,6 +126,8 @@ should rarely be invoked manually.`,
 				BootStopEnabled:        f.BootStopEnabled,
 				SingleVehicleControl:   f.SingleVehicleControl,
 				AllocatePhysicalSlots:  f.AllocatePhysicalSlots,
+				EnableProgramming:       f.EnableProgramming,
+				DefaultProgrammingTrack: progTrack,
 			}
 			d, err := dccbus.New(c.Context(), log, cfg)
 			if err != nil {
@@ -161,6 +170,8 @@ should rarely be invoked manually.`,
 	cmd.Flags().BoolVar(&f.BootStopEnabled, FlagBootStopEnabled, false, "emergency-stop all roster locomotives once after daemon start")
 	cmd.Flags().BoolVar(&f.SingleVehicleControl, FlagSingleVehicleControl, false, "stop the user's other moving vehicles when driving a different one")
 	cmd.Flags().BoolVar(&f.AllocatePhysicalSlots, FlagAllocatePhysicalSlots, true, "allocate LocoNet slots like a physical FRED (exclusive IN_USE; disable to piggyback)")
+	cmd.Flags().BoolVar(&f.EnableProgramming, FlagEnableProgramming, false, "accept decoder CV and address programming frames (loco.cvRead/cvWrite/addrGet/addrSet)")
+	cmd.Flags().StringVar(&f.DefaultProgrammingTrack, FlagDefaultProgrammingTrack, DefaultProgrammingTrack, "programming track used when a frame omits `mode`: pom (main track) or prog (programming track)")
 
 	cmd.AddCommand(newScanCommand(log))
 

pkgs/bigfred/dcc-bus/cli/station.go

@@ -6,6 +6,7 @@ import (
 	"strconv"
 	"strings"
 
+	"github.com/keskad/loco/pkgs/bigfred/dcc-bus/protocol"
 	"github.com/keskad/loco/pkgs/bigfred/server/domain"
 )
 
@@ -25,8 +26,29 @@ const (
 	FlagBootStopEnabled    = "enable-boot-stop"
 	FlagSingleVehicleControl = "enable-single-vehicle-control"
 	FlagAllocatePhysicalSlots = "allocate-physical-slots"
+	FlagEnableProgramming       = "enable-programming"
+	FlagDefaultProgrammingTrack = "default-programming-track"
 )
 
+// DefaultProgrammingTrack is the track CV / address frames land on when
+// they omit `mode`. It mirrors domain.DefaultCommandStationProgrammingTrackOutput:
+// the isolated programming output cannot disturb locos on the main track.
+const DefaultProgrammingTrack = protocol.ProgrammingModeProg
+
+// ProgrammingTrackFromFlag normalises --default-programming-track. An
+// empty value falls back to DefaultProgrammingTrack.
+func ProgrammingTrackFromFlag(track string) (string, error) {
+	switch t := strings.ToLower(strings.TrimSpace(track)); t {
+	case "":
+		return DefaultProgrammingTrack, nil
+	case protocol.ProgrammingModePOM, protocol.ProgrammingModeProg:
+		return t, nil
+	default:
+		return "", fmt.Errorf("unsupported %s %q (want %q or %q)",
+			FlagDefaultProgrammingTrack, track, protocol.ProgrammingModePOM, protocol.ProgrammingModeProg)
+	}
+}
+
 // AppendStationFlags appends command-station connection flags for cs.
 func AppendStationFlags(args []string, cs domain.CommandStation) []string {
 	return append(args,

pkgs/bigfred/dcc-bus/cli/station_test.go

@@ -51,6 +51,33 @@ func TestAppendSingleVehicleControlFlag(t *testing.T) {
 	}
 }
 
+func TestProgrammingTrackFromFlag(t *testing.T) {
+	for _, tc := range []struct {
+		in      string
+		want    string
+		wantErr bool
+	}{
+		{in: "", want: DefaultProgrammingTrack},
+		{in: "pom", want: "pom"},
+		{in: " PROG ", want: "prog"},
+		{in: "service", wantErr: true},
+	} {
+		got, err := ProgrammingTrackFromFlag(tc.in)
+		if tc.wantErr {
+			if err == nil {
+				t.Fatalf("%q: expected an error, got %q", tc.in, got)
+			}
+			continue
+		}
+		if err != nil {
+			t.Fatalf("%q: %v", tc.in, err)
+		}
+		if got != tc.want {
+			t.Fatalf("%q = %q, want %q", tc.in, got, tc.want)
+		}
+	}
+}
+
 func stringsJoin(ss []string) string {
 	out := ""
 	for i, s := range ss {

pkgs/bigfred/dcc-bus/cmd/control_redis.go

@@ -5,6 +5,8 @@ import (
 	"encoding/json"
 	stderrors "errors"
 
+	"github.com/sirupsen/logrus"
+
 	"github.com/keskad/loco/pkgs/bigfred/contract"
 	"github.com/keskad/loco/pkgs/bigfred/dcc-bus/protocol"
 	"github.com/keskad/loco/pkgs/bigfred/dcc-bus/service"
@@ -48,6 +50,63 @@ func (r *Router) HandleControlCommand(ctx context.Context, raw []byte) {
 			return
 		}
 		r.applyEStopTarget(ctx, p.Addresses)
+
+	case protocol.TypeLocoCVWrite:
+		var p protocol.LocoCVWritePayload
+		if err := json.Unmarshal(env.Payload, &p); err != nil {
+			return
+		}
+		r.logControlProgramming(env.Type, r.HandleLocoCVWrite(ctx, controlActor, noopResponder{}, p, ""))
+
+	case protocol.TypeLocoCVRead:
+		var p protocol.LocoCVReadPayload
+		if err := json.Unmarshal(env.Payload, &p); err != nil {
+			return
+		}
+		r.logControlProgramming(env.Type, r.HandleLocoCVRead(ctx, controlActor, noopResponder{}, p, ""))
+
+	case protocol.TypeLocoAddrSet:
+		var p protocol.LocoAddrSetPayload
+		if err := json.Unmarshal(env.Payload, &p); err != nil {
+			return
+		}
+		r.logControlProgramming(env.Type, r.HandleLocoAddrSet(ctx, controlActor, noopResponder{}, p, ""))
+
+	case protocol.TypeLocoAddrGet:
+		var p protocol.LocoAddrGetPayload
+		if err := json.Unmarshal(env.Payload, &p); err != nil {
+			return
+		}
+		r.logControlProgramming(env.Type, r.HandleLocoAddrGet(ctx, controlActor, noopResponder{}, p, ""))
+	}
+}
+
+// controlActor labels commands that arrive on the Redis control channel
+// rather than from a browser session.
+var controlActor = Actor{Source: "server"}
+
+// logControlProgramming reports the outcome of a control-channel
+// programming command. The channel is fire-and-forget, so on rejection
+// the daemon publishes a control.programming.rejected event on its
+// event channel — that is the server's only signal that the command
+// did not run (loco-server can log it, surface it to an admin HUD, or
+// retry against a different station). On success the daemon log is
+// enough; no event is emitted.
+func (r *Router) logControlProgramming(frameType string, res Result) {
+	if res.OK {
+		return
+	}
+	r.log.WithFields(logrus.Fields{
+		"type": frameType,
+		"code": res.Code,
+	}).Warn("dcc-bus control programming command rejected")
+	if r.redis != nil {
+		_ = r.redis.Publish(context.Background(), protocol.TypeControlProgrammingRejected,
+			protocol.ControlProgrammingRejectedPayload{
+				FrameType: frameType,
+				Code:      res.Code,
+				Address:   res.LocoAddress,
+			})
 	}
 }
 

pkgs/bigfred/dcc-bus/cmd/control_redis_test.go

@@ -0,0 +1,107 @@
+package cmd
+
+import (
+	"context"
+	"encoding/json"
+	"io"
+	"testing"
+	"time"
+
+	"github.com/alicebob/miniredis/v2"
+	"github.com/redis/go-redis/v9"
+	"github.com/sirupsen/logrus"
+
+	"github.com/keskad/loco/pkgs/bigfred/contract"
+	buserrors "github.com/keskad/loco/pkgs/bigfred/dcc-bus/errors"
+	"github.com/keskad/loco/pkgs/bigfred/dcc-bus/protocol"
+	"github.com/keskad/loco/pkgs/bigfred/dcc-bus/state"
+)
+
+func TestLogControlProgramming_publishesRejectionEvent(t *testing.T) {
+	t.Parallel()
+	mr, err := miniredis.Run()
+	if err != nil {
+		t.Fatalf("miniredis: %v", err)
+	}
+	defer mr.Close()
+
+	rs := state.NewRedis(redis.NewClient(&redis.Options{Addr: mr.Addr()}), 2, 1)
+	log := logrus.New()
+	log.SetOutput(io.Discard)
+	r := &Router{redis: rs, log: log}
+
+	// Subscribe to the daemon's event channel before publishing so the
+	// message is not lost to fire-and-forget timing.
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	sub := rs.Client().Subscribe(ctx, contract.DccBusEventChannel(2, 1))
+	defer func() { _ = sub.Close() }()
+	if _, err := sub.Receive(ctx); err != nil {
+		t.Fatalf("subscribe: %v", err)
+	}
+	msgCh := sub.Channel()
+
+	r.logControlProgramming(protocol.TypeLocoCVWrite, Result{
+		OK:          false,
+		Code:        buserrors.CodeProgrammingDisabled,
+		LocoAddress: 47,
+	})
+
+	select {
+	case msg := <-msgCh:
+		var env contract.EnvelopeWire
+		if err := json.Unmarshal([]byte(msg.Payload), &env); err != nil {
+			t.Fatalf("unmarshal envelope: %v", err)
+		}
+		if env.Type != protocol.TypeControlProgrammingRejected {
+			t.Fatalf("event type = %q, want %q", env.Type, protocol.TypeControlProgrammingRejected)
+		}
+		var p protocol.ControlProgrammingRejectedPayload
+		if err := json.Unmarshal(env.Payload, &p); err != nil {
+			t.Fatalf("unmarshal payload: %v", err)
+		}
+		if p.FrameType != protocol.TypeLocoCVWrite {
+			t.Errorf("frameType = %q, want %q", p.FrameType, protocol.TypeLocoCVWrite)
+		}
+		if p.Code != buserrors.CodeProgrammingDisabled {
+			t.Errorf("code = %q, want %q", p.Code, buserrors.CodeProgrammingDisabled)
+		}
+		if p.Address != 47 {
+			t.Errorf("address = %d, want 47", p.Address)
+		}
+	case <-time.After(time.Second):
+		t.Fatal("control.programming.rejected event was not published")
+	}
+}
+
+func TestLogControlProgramming_silentOnSuccess(t *testing.T) {
+	t.Parallel()
+	mr, err := miniredis.Run()
+	if err != nil {
+		t.Fatalf("miniredis: %v", err)
+	}
+	defer mr.Close()
+
+	rs := state.NewRedis(redis.NewClient(&redis.Options{Addr: mr.Addr()}), 2, 1)
+	log := logrus.New()
+	log.SetOutput(io.Discard)
+	r := &Router{redis: rs, log: log}
+
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	sub := rs.Client().Subscribe(ctx, contract.DccBusEventChannel(2, 1))
+	defer func() { _ = sub.Close() }()
+	if _, err := sub.Receive(ctx); err != nil {
+		t.Fatalf("subscribe: %v", err)
+	}
+	msgCh := sub.Channel()
+
+	r.logControlProgramming(protocol.TypeLocoCVWrite, OKResult())
+
+	select {
+	case msg := <-msgCh:
+		t.Fatalf("expected no event on success, got %s", msg.Payload)
+	case <-time.After(150 * time.Millisecond):
+		// ok — no event published.
+	}
+}

pkgs/bigfred/dcc-bus/cmd/port.go

@@ -44,6 +44,25 @@ type Responder interface {
 	SendAck(ctx context.Context, requestID string, payload protocol.AckPayload) error
 }
 
+// noopResponder satisfies Responder for commands that arrive without a
+// client to answer — the Redis control channel is fire-and-forget.
+type noopResponder struct{}
+
+func (noopResponder) Subscribe(...uint16)              {}
+func (noopResponder) Unsubscribe(...uint16)            {}
+func (noopResponder) SubscribedAddrs() []uint16        { return nil }
+func (noopResponder) OldestSubscribed() (uint16, bool) { return 0, false }
+func (noopResponder) SelectedAddr() uint16             { return 0 }
+func (noopResponder) SetSelected(uint16)               {}
+func (noopResponder) ClearSelected()                   {}
+
+func (noopResponder) SendLocoState(context.Context, contract.LocoStateWire) error { return nil }
+func (noopResponder) SendLocoError(context.Context, uint16, string, string) error { return nil }
+func (noopResponder) SendLocoErrorPayload(context.Context, protocol.LocoErrorPayload) error {
+	return nil
+}
+func (noopResponder) SendAck(context.Context, string, protocol.AckPayload) error { return nil }
+
 // SessionView is a snapshot of one live browser session used for fan-out
 // and dead-man bookkeeping without importing the ws package.
 type SessionView struct {