feat: show device lock state in list output

ListResponse now carries structured DeviceInfo with per-device lock state
instead of bare device names. The dutctl client renders locked devices with
a "[locked by ...]" annotation and adds a lock-result output type for the
upcoming lock/unlock commands.

Signed-off-by: Fabian Wienand <fabian.wienand@blindspot.software>

Author: RiSKeD

cmds/dutagent/rpc.go

@@ -44,8 +44,27 @@ func (a *rpcService) List(
 ) (*connect.Response[pb.ListResponse], error) {
 	log.Println("Server received List request")
 
+	locks := a.locker.StatusAll()
+
+	names := a.devices.Names()
+	infos := make([]*pb.DeviceInfo, 0, len(names))
+
+	for _, name := range names {
+		info := &pb.DeviceInfo{Name: name}
+
+		if explicit := locks[name].Explicit; explicit != nil {
+			info.Lock = &pb.LockInfo{
+				Owner:     explicit.Owner,
+				LockedAt:  explicit.LockedAt.Unix(),
+				ExpiresAt: explicit.ExpiresAt.Unix(),
+			}
+		}
+
+		infos = append(infos, info)
+	}
+
 	res := connect.NewResponse(&pb.ListResponse{
-		Devices: a.devices.Names(),
+		Devices: infos,
 	})
 
 	log.Print("List-RPC finished")

cmds/dutagent/rpc_test.go

@@ -7,6 +7,7 @@ import (
 	"context"
 	"strings"
 	"testing"
+	"time"
 
 	"connectrpc.com/connect"
 	"github.com/BlindspotSoftware/dutctl/internal/dutagent"
@@ -160,3 +161,57 @@ func TestLockRPCZeroDurationRejected(t *testing.T) {
 		}
 	}
 }
+
+func TestListRPCHidesAutoOnlyLock(t *testing.T) {
+	svc := newTestService()
+
+	if _, err := svc.locker.AutoLock("devA", "alice"); err != nil {
+		t.Fatalf("AutoLock: %v", err)
+	}
+
+	res, err := svc.List(context.Background(), connect.NewRequest(&pb.ListRequest{}))
+	if err != nil {
+		t.Fatalf("List: %v", err)
+	}
+
+	var got *pb.LockInfo
+
+	for _, info := range res.Msg.GetDevices() {
+		if info.GetName() == "devA" {
+			got = info.GetLock()
+		}
+	}
+
+	if got != nil {
+		t.Errorf("auto-only lock surfaced in List: %+v, want no lock info", got)
+	}
+}
+
+func TestListRPCExplicitShadowsAuto(t *testing.T) {
+	svc := newTestService()
+
+	if _, err := svc.locker.AutoLock("devA", "alice"); err != nil {
+		t.Fatalf("AutoLock: %v", err)
+	}
+
+	if _, err := svc.locker.Lock("devA", "alice", time.Minute); err != nil {
+		t.Fatalf("Lock: %v", err)
+	}
+
+	res, err := svc.List(context.Background(), connect.NewRequest(&pb.ListRequest{}))
+	if err != nil {
+		t.Fatalf("List: %v", err)
+	}
+
+	var got *pb.LockInfo
+
+	for _, info := range res.Msg.GetDevices() {
+		if info.GetName() == "devA" {
+			got = info.GetLock()
+		}
+	}
+
+	if got.GetExpiresAt() == 0 {
+		t.Error("expected explicit-slot expires_at to win, got 0")
+	}
+}

cmds/dutctl/rpc.go

@@ -30,9 +30,23 @@ func (app *application) listRPC() error {
 		return err
 	}
 
+	devices := make([]output.DeviceEntry, 0, len(res.Msg.GetDevices()))
+
+	for _, info := range res.Msg.GetDevices() {
+		entry := output.DeviceEntry{Name: info.GetName()}
+
+		if lock := info.GetLock(); lock != nil {
+			entry.Locked = true
+			entry.Owner = lock.GetOwner()
+			entry.ExpiresAt = lock.GetExpiresAt()
+		}
+
+		devices = append(devices, entry)
+	}
+
 	app.formatter.WriteContent(output.Content{
 		Type: output.TypeDeviceList,
-		Data: res.Msg.GetDevices(),
+		Data: devices,
 		Metadata: map[string]string{
 			"server": app.serverAddr,
 			"msg":    "List Response",

cmds/exp/dutserver/rpc.go

@@ -100,8 +100,16 @@ func (s *rpcService) List(
 ) (*connect.Response[pb.ListResponse], error) {
 	log.Println("Server received List request")
 
+	names := slices.Sorted(maps.Keys(s.agents))
+	infos := make([]*pb.DeviceInfo, 0, len(names))
+
+	// dutserver does not track lock state; Lock is left unset.
+	for _, name := range names {
+		infos = append(infos, &pb.DeviceInfo{Name: name})
+	}
+
 	res := connect.NewResponse(&pb.ListResponse{
-		Devices: slices.Sorted(maps.Keys(s.agents)),
+		Devices: infos,
 	})
 
 	log.Print("List-RPC finished")

internal/output/json_test.go

@@ -29,7 +29,7 @@ func TestJSONFormatter(t *testing.T) {
 	// Test case 2: Output with metadata
 	formatter.WriteContent(Content{
 		Type: TypeDeviceList,
-		Data: []string{"device1", "device2", "device3"},
+		Data: []DeviceEntry{{Name: "device1"}, {Name: "device2"}, {Name: "device3"}},
 		Metadata: map[string]string{
 			"server": "localhost:1024",
 			"device": "test-device",

internal/output/oneline.go

@@ -112,12 +112,31 @@ func formatDataValue(data interface{}, separator string) string {
 		return formatQuotedString(joined, separator)
 	case []byte:
 		return formatQuotedString(string(dataValue), separator)
+	case []DeviceEntry:
+		entries := make([]string, 0, len(dataValue))
+		for _, d := range dataValue {
+			entries = append(entries, deviceEntryString(d))
+		}
+
+		return formatQuotedString(strings.Join(entries, "|"), separator)
+	case DeviceEntry:
+		return formatQuotedString(deviceEntryString(dataValue), separator)
 	default:
 		// Convert anything else to string
 		return formatQuotedString(fmt.Sprintf("%v", dataValue), separator)
 	}
 }
 
+// deviceEntryString renders a DeviceEntry as a compact "name" or
+// "name=locked:owner" token for single-line output.
+func deviceEntryString(d DeviceEntry) string {
+	if !d.Locked {
+		return d.Name
+	}
+
+	return fmt.Sprintf("%s=locked:%s", d.Name, d.Owner)
+}
+
 // output writes the formatted line to the appropriate destination.
 func (f *OneLineFormatter) output(line string, isError bool) {
 	if f.buffering {

internal/output/oneline_test.go

@@ -28,7 +28,7 @@ func TestOneLineFormatter(t *testing.T) {
 	// Test case 2: Output with metadata
 	formatter.WriteContent(Content{
 		Type: TypeDeviceList,
-		Data: []string{"device1", "device2", "device3"},
+		Data: []DeviceEntry{{Name: "device1"}, {Name: "device2"}, {Name: "device3"}},
 		Metadata: map[string]string{
 			"server": "localhost:1024",
 			"device": "test-device",

internal/output/output.go

@@ -30,8 +30,19 @@ const (
 
 	// TypeVersion represents version information.
 	TypeVersion ContentType = "version"
+
+	// TypeLockResult represents the result of a lock or unlock operation.
+	TypeLockResult ContentType = "lock-result"
 )
 
+// DeviceEntry describes a device and its lock state for TypeDeviceList output.
+type DeviceEntry struct {
+	Name      string
+	Locked    bool
+	Owner     string
+	ExpiresAt int64 // Unix seconds, 0 means no expiry.
+}
+
 // Content is a structured data unit to be formatted and displayed.
 type Content struct {
 	// Type identifies the category of this content.

internal/output/text.go

@@ -11,6 +11,7 @@ import (
 	"os"
 	"slices"
 	"strings"
+	"time"
 )
 
 // TextFormatter implements Formatter with plain text formatting capabilities.
@@ -53,9 +54,9 @@ func newTextFormatter(config Config) *TextFormatter {
 	}
 }
 
-// WriteContent formats and outputs structured content.
-func (f *TextFormatter) WriteContent(content Content) {
-	// Get appropriate writer based on buffering mode and error state
+// selectWriter returns the writer for content based on buffering mode and
+// error state.
+func (f *TextFormatter) selectWriter(content Content) io.Writer {
 	var writer io.Writer
 
 	if f.buffering {
@@ -72,6 +73,13 @@ func (f *TextFormatter) WriteContent(content Content) {
 		}
 	}
 
+	return writer
+}
+
+// WriteContent formats and outputs structured content.
+func (f *TextFormatter) WriteContent(content Content) {
+	writer := f.selectWriter(content)
+
 	// Format and write content based on type, regardless of error state
 	switch content.Type {
 	case TypeDeviceList:
@@ -84,6 +92,8 @@ func (f *TextFormatter) WriteContent(content Content) {
 		f.writeDetailTo(content, writer)
 	case TypeModuleOutput:
 		f.writeModuleOutputTo(content, writer)
+	case TypeLockResult:
+		f.writeLockResultTo(content, writer)
 	default:
 		// For general text or unrecognized types
 		f.writeGeneralTo(content, writer)
@@ -148,17 +158,79 @@ func (f *TextFormatter) Flush() error {
 
 // Helper methods for different content types
 
+// humanDuration renders dur as a compact "1h30m"-style string, rounded to the
+// minute. A non-positive duration renders as "0m".
+func humanDuration(dur time.Duration) string {
+	dur = dur.Round(time.Minute)
+	if dur <= 0 {
+		return "0m"
+	}
+
+	hours := dur / time.Hour
+	minutes := (dur % time.Hour) / time.Minute
+
+	switch {
+	case hours > 0 && minutes > 0:
+		return fmt.Sprintf("%dh%dm", hours, minutes)
+	case hours > 0:
+		return fmt.Sprintf("%dh", hours)
+	default:
+		return fmt.Sprintf("%dm", minutes)
+	}
+}
+
+// lockAnnotation renders the bracketed lock note for a locked device, e.g.
+// ` [locked by "alice@host" for 25m]`. ExpiresAt of 0 omits the duration.
+func lockAnnotation(entry DeviceEntry) string {
+	if entry.ExpiresAt == 0 {
+		return fmt.Sprintf(" [locked by %q]", entry.Owner)
+	}
+
+	remaining := humanDuration(time.Until(time.Unix(entry.ExpiresAt, 0)))
+
+	return fmt.Sprintf(" [locked by %q for %s]", entry.Owner, remaining)
+}
+
 // writeDeviceListTo formats and writes a list of devices with bullet points.
 func (f *TextFormatter) writeDeviceListTo(content Content, writer io.Writer) {
-	if devices, ok := content.Data.([]string); ok {
-		// Print metadata before content
-		f.writeMetadata(content, writer)
+	devices, ok := content.Data.([]DeviceEntry)
+	if !ok {
+		f.writeGeneralTo(content, writer)
+
+		return
+	}
 
-		for _, device := range devices {
-			fmt.Fprintf(writer, "- %s\n", device)
+	// Print metadata before content
+	f.writeMetadata(content, writer)
+
+	for _, device := range devices {
+		if device.Locked {
+			fmt.Fprintf(writer, "- %s%s\n", device.Name, lockAnnotation(device))
+		} else {
+			fmt.Fprintf(writer, "- %s\n", device.Name)
 		}
-	} else {
+	}
+}
+
+// writeLockResultTo formats and writes the result of a lock or unlock operation.
+func (f *TextFormatter) writeLockResultTo(content Content, writer io.Writer) {
+	entry, ok := content.Data.(DeviceEntry)
+	if !ok {
 		f.writeGeneralTo(content, writer)
+
+		return
+	}
+
+	f.writeMetadata(content, writer)
+
+	switch {
+	case !entry.Locked:
+		fmt.Fprintf(writer, "Device %q unlocked\n", entry.Name)
+	case entry.ExpiresAt == 0:
+		fmt.Fprintf(writer, "Device %q locked by %q\n", entry.Name, entry.Owner)
+	default:
+		remaining := humanDuration(time.Until(time.Unix(entry.ExpiresAt, 0)))
+		fmt.Fprintf(writer, "Device %q locked by %q for %s\n", entry.Name, entry.Owner, remaining)
 	}
 }