feat: type directly to the DUT serial console

The client now switches the terminal to raw mode during a run and
forwards every keystroke - including Ctrl-C, Ctrl-D and Ctrl-Z -
straight to the DUT. Press Ctrl-A then x to quit the session. Raw
mode is build-tagged for Linux and macOS, with a no-op fallback on
other platforms so the client still builds everywhere. (#121)

Signed-off-by: llogen <christoph.lange@blindspot.software>

Author: llogen

cmds/dutctl/rawmode_darwin.go

@@ -0,0 +1,15 @@
+// Copyright 2025 Blindspot Software
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build darwin
+
+package main
+
+import "golang.org/x/sys/unix"
+
+// Terminal get/set ioctl request numbers for macOS (BSD-derived).
+const (
+	tcGetReq = unix.TIOCGETA
+	tcSetReq = unix.TIOCSETA
+)

cmds/dutctl/rawmode_linux.go

@@ -0,0 +1,15 @@
+// Copyright 2025 Blindspot Software
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build linux
+
+package main
+
+import "golang.org/x/sys/unix"
+
+// Terminal get/set ioctl request numbers for Linux.
+const (
+	tcGetReq = unix.TCGETS
+	tcSetReq = unix.TCSETS
+)

cmds/dutctl/rawmode_other.go

@@ -0,0 +1,14 @@
+// Copyright 2025 Blindspot Software
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build !linux && !darwin
+
+package main
+
+// setRawInput is a no-op on platforms without termios support (e.g. Windows).
+// Input stays line-buffered; the interactive serial experience is degraded but
+// the client still builds and runs.
+func setRawInput(_ int) func() {
+	return nil
+}

cmds/dutctl/rawmode_unix.go

@@ -0,0 +1,52 @@
+// Copyright 2025 Blindspot Software
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build linux || darwin
+
+package main
+
+import "golang.org/x/sys/unix"
+
+// setRawInput puts the terminal into raw input mode so the interactive serial
+// session behaves like a direct console:
+//
+//   - ECHO/ICANON off: keystrokes are delivered immediately, character at a
+//     time, and not echoed locally (the DUT echoes them back).
+//   - ISIG off: control characters such as Ctrl-C, Ctrl-Z and Ctrl-\ are NOT
+//     turned into local signals; they are forwarded to the DUT as raw bytes.
+//   - IXON off: Ctrl-S/Ctrl-Q flow control is forwarded to the DUT instead of
+//     being swallowed by the local terminal.
+//   - IEXTEN off: Ctrl-V and friends are forwarded literally.
+//   - ICRNL off: a typed CR is sent as CR, not translated to NL.
+//
+// dutctl is exited with the client-side escape sequence (Ctrl-A x), not with a
+// terminal signal — see filterEscape in rpc.go.
+//
+// It returns a restore function, or nil if the fd is not a terminal (in which
+// case input stays line-buffered, which is the correct fallback for pipes).
+//
+// The ioctl request numbers differ per OS (tcGetReq/tcSetReq are defined in the
+// platform-specific files); the termios flags themselves are shared across
+// unix platforms.
+func setRawInput(fileDescriptor int) func() {
+	termios, err := unix.IoctlGetTermios(fileDescriptor, tcGetReq)
+	if err != nil {
+		return nil
+	}
+
+	old := *termios
+
+	termios.Iflag &^= unix.ICRNL | unix.IXON
+	termios.Lflag &^= unix.ECHO | unix.ICANON | unix.ISIG | unix.IEXTEN
+	termios.Cc[unix.VMIN] = 1
+	termios.Cc[unix.VTIME] = 0
+
+	if err := unix.IoctlSetTermios(fileDescriptor, tcSetReq, termios); err != nil {
+		return nil
+	}
+
+	return func() {
+		_ = unix.IoctlSetTermios(fileDescriptor, tcSetReq, &old)
+	}
+}

cmds/dutctl/rpc.go

@@ -5,7 +5,6 @@
 package main
 
 import (
-	"bufio"
 	"context"
 	"errors"
 	"fmt"
@@ -188,10 +187,74 @@ func (app *application) detailsRPC(device, command, keyword string) error {
 	return nil
 }
 
+// Interactive escape sequence. Ctrl-A is the prefix; the following key decides:
+//   - 'x'/'X'/Ctrl-X: quit dutctl.
+//   - Ctrl-A: send a single literal Ctrl-A to the DUT.
+//   - anything else: forward both the prefix and the key unchanged.
+//
+// Every other byte (Ctrl-C, Ctrl-D, Ctrl-Z, ...) is forwarded to the DUT.
+const (
+	escapePrefix   = 0x01 // Ctrl-A
+	escapeQuitCtrl = 0x18 // Ctrl-X
+)
+
+// filterEscape applies the interactive escape state machine to in. It returns
+// the bytes to forward to the DUT and whether the quit sequence was seen.
+// escapePending carries the "prefix seen" state across reads, so the prefix and
+// its following key may arrive in separate stdin reads.
+func filterEscape(in []byte, escapePending *bool) (out []byte, quit bool) {
+	out = make([]byte, 0, len(in))
+
+	for _, b := range in {
+		if *escapePending {
+			*escapePending = false
+
+			switch b {
+			case 'x', 'X', escapeQuitCtrl:
+				return out, true
+			case escapePrefix: // Ctrl-A Ctrl-A -> one literal Ctrl-A
+				out = append(out, escapePrefix)
+			default: // not an escape; forward the prefix and this byte
+				out = append(out, escapePrefix, b)
+			}
+
+			continue
+		}
+
+		if b == escapePrefix {
+			*escapePending = true
+
+			continue
+		}
+
+		out = append(out, b)
+	}
+
+	return out, false
+}
+
 //nolint:funlen,cyclop,gocognit
 func (app *application) runRPC(device, command string, cmdArgs []string) error {
 	const numWorkers = 2 // The send and receive worker goroutines
 
+	// Set raw input mode: disable local echo, canonical mode and signal
+	// generation so each keystroke — including control characters like Ctrl-C —
+	// is forwarded to the DUT immediately. Interactive modules like serial rely
+	// on the remote side to echo input. Only a real terminal is switched to raw
+	// mode; piped/scripted stdin stays untouched so it is forwarded verbatim.
+	interactive := false
+
+	if f, ok := app.stdin.(*os.File); ok {
+		if restore := setRawInput(int(f.Fd())); restore != nil {
+			interactive = true
+
+			defer restore()
+
+			// The escape sequence is the only way to quit while raw mode is on.
+			fmt.Fprint(os.Stderr, "\r\n[dutctl] interactive session — press Ctrl-A then x to quit\r\n")
+		}
+	}
+
 	runCtx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 
@@ -324,18 +387,22 @@ func (app *application) runRPC(device, command string, cmdArgs []string) error {
 		}
 	}()
 
-	// Send routine — reads lines from stdin and forwards them to the server.
+	// Send routine — reads raw bytes from stdin and forwards them to the server.
 	//
 	// Unlike the receive routine this goroutine intentionally does NOT defer
-	// cancel(). When stdin reaches EOF (e.g. /dev/null in non-interactive
-	// runs) this goroutine returns immediately. If it cancelled the context
-	// on exit, the receive routine would be torn down before it could read
-	// and print the server's response.
+	// cancel() for the EOF case. When stdin reaches EOF (e.g. /dev/null in
+	// non-interactive runs) this goroutine returns immediately; if it cancelled
+	// the context on exit, the receive routine would be torn down before it
+	// could read and print the server's response.
 	//
-	// Only the receive routine drives context cancellation so that all
-	// server output is processed before the RPC terminates.
+	// It DOES cancel when the user types the interactive escape sequence
+	// (Ctrl-A x): that is an explicit request to end the session.
 	go func() {
-		reader := bufio.NewReader(app.stdin)
+		const stdinBufSize = 256
+
+		buf := make([]byte, stdinBufSize)
+
+		var escapePending bool
 
 		for {
 			select {
@@ -346,7 +413,7 @@ func (app *application) runRPC(device, command string, cmdArgs []string) error {
 			default:
 			}
 
-			text, err := reader.ReadString('\n')
+			nRead, err := app.stdin.Read(buf)
 			if err != nil {
 				if !errors.Is(err, io.EOF) {
 					errChan <- fmt.Errorf("reading stdin: %w", err)
@@ -355,17 +422,35 @@ func (app *application) runRPC(device, command string, cmdArgs []string) error {
 				return
 			}
 
-			err = stream.Send(&pb.RunRequest{
-				Msg: &pb.RunRequest_Console{
-					Console: &pb.Console{
-						Data: &pb.Console_Stdin{
-							Stdin: []byte(text),
+			payload := buf[:nRead]
+
+			quit := false
+			if interactive {
+				// Intercept the escape sequence; forward everything else
+				// (including Ctrl-C) untouched.
+				payload, quit = filterEscape(payload, &escapePending)
+			}
+
+			if len(payload) > 0 {
+				sendErr := stream.Send(&pb.RunRequest{
+					Msg: &pb.RunRequest_Console{
+						Console: &pb.Console{
+							Data: &pb.Console_Stdin{
+								Stdin: payload,
+							},
 						},
 					},
-				},
-			})
-			if err != nil {
-				errChan <- fmt.Errorf("sending RPC message: %w", err)
+				})
+				if sendErr != nil {
+					errChan <- fmt.Errorf("sending RPC message: %w", sendErr)
+
+					return
+				}
+			}
+
+			if quit {
+				log.Println("Send routine terminating: escape sequence")
+				cancel()
 
 				return
 			}