vendor: github.com/moby/term v0.5.0

- split exported functions from implementation
- windows: IsConsole(): fix deprecation comment
- deprecate Termios in favor of unix.Termios
- windows: keyToString(): fix string conversion
- gha: update actions, add macOS, and add Go1.20
- gha: add windows

full diff: https://github.com/moby/term/compare/c43b287e0e0f...v0.5.0

Signed-off-by: Sebastiaan van Stijn <github@gone.nl>

vendor.mod

@@ -26,7 +26,7 @@ require (
 	github.com/moby/swarmkit/v2 v2.0.0-20230406225228-75e92ce14ff7
 	github.com/moby/sys/sequential v0.5.0
 	github.com/moby/sys/signal v0.7.0
-	github.com/moby/term v0.0.0-20221128092401-c43b287e0e0f
+	github.com/moby/term v0.5.0
 	github.com/morikuni/aec v1.0.0
 	github.com/opencontainers/go-digest v1.0.0
 	github.com/opencontainers/image-spec v1.1.0-rc2.0.20221005185240-3a7f492d3f1b

vendor.sum

@@ -281,8 +281,8 @@ github.com/moby/sys/signal v0.7.0 h1:25RW3d5TnQEoKvRbEKUGay6DCQ46IxAVTT9CUMgmsSI
 github.com/moby/sys/signal v0.7.0/go.mod h1:GQ6ObYZfqacOwTtlXvcmh9A26dVRul/hbOZn88Kg8Tg=
 github.com/moby/sys/symlink v0.2.0 h1:tk1rOM+Ljp0nFmfOIBtlV3rTDlWOwFRhjEeAhZB0nZc=
 github.com/moby/sys/symlink v0.2.0/go.mod h1:7uZVF2dqJjG/NsClqul95CqKOBRQyYSNnJ6BMgR/gFs=
-github.com/moby/term v0.0.0-20221128092401-c43b287e0e0f h1:J/7hjLaHLD7epG0m6TBMGmp4NQ+ibBYLfeyJWdAIFLA=
+github.com/moby/term v0.5.0 h1:xt8Q1nalod/v7BqbG21f8mQPqH+xAaC9C3N3wfWbVP0=
-github.com/moby/term v0.0.0-20221128092401-c43b287e0e0f/go.mod h1:15ce4BGCFxt7I5NQKT+HV0yEDxmf6fSysfEDiVo3zFM=
+github.com/moby/term v0.5.0/go.mod h1:8FzsFHVUBGZdbDsJw/ot+X+d5HLUbvklYLJ9uGfcI3Y=
 github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
 github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
 github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=

vendor/github.com/moby/term/doc.go

@@ -0,0 +1,3 @@
+// Package term provides structures and helper functions to work with
+// terminal (state, sizes).
+package term

vendor/github.com/moby/term/tc.go

@@ -1,20 +0,0 @@
-//go:build !windows
-// +build !windows
-
-package term
-
-import (
-	"golang.org/x/sys/unix"
-)
-
-func tcget(fd uintptr) (*Termios, error) {
-	p, err := unix.IoctlGetTermios(int(fd), getTermios)
-	if err != nil {
-		return nil, err
-	}
-	return p, nil
-}
-
-func tcset(fd uintptr, p *Termios) error {
-	return unix.IoctlSetTermios(int(fd), setTermios, p)
-}

vendor/github.com/moby/term/term.go

@@ -1,100 +1,85 @@
-//go:build !windows
-// +build !windows
-
-// Package term provides structures and helper functions to work with
-// terminal (state, sizes).
 package term
 
-import (
+import "io"
-	"errors"
-	"io"
-	"os"
 
-	"golang.org/x/sys/unix"
+// State holds the platform-specific state / console mode for the terminal.
-)
+type State terminalState
-
-// ErrInvalidState is returned if the state of the terminal is invalid.
-var ErrInvalidState = errors.New("Invalid terminal state")
-
-// State represents the state of the terminal.
-type State struct {
-	termios Termios
-}
 
 // Winsize represents the size of the terminal window.
 type Winsize struct {
 	Height uint16
 	Width  uint16
-	x      uint16
+
-	y      uint16
+	// Only used on Unix
+	x uint16
+	y uint16
 }
 
 // StdStreams returns the standard streams (stdin, stdout, stderr).
+//
+// On Windows, it attempts to turn on VT handling on all std handles if
+// supported, or falls back to terminal emulation. On Unix, this returns
+// the standard [os.Stdin], [os.Stdout] and [os.Stderr].
 func StdStreams() (stdIn io.ReadCloser, stdOut, stdErr io.Writer) {
-	return os.Stdin, os.Stdout, os.Stderr
+	return stdStreams()
 }
 
 // GetFdInfo returns the file descriptor for an os.File and indicates whether the file represents a terminal.
-func GetFdInfo(in interface{}) (uintptr, bool) {
+func GetFdInfo(in interface{}) (fd uintptr, isTerminal bool) {
-	var inFd uintptr
+	return getFdInfo(in)
-	var isTerminalIn bool
+}
-	if file, ok := in.(*os.File); ok {
+
-		inFd = file.Fd()
+// GetWinsize returns the window size based on the specified file descriptor.
-		isTerminalIn = IsTerminal(inFd)
+func GetWinsize(fd uintptr) (*Winsize, error) {
-	}
+	return getWinsize(fd)
-	return inFd, isTerminalIn
+}
+
+// SetWinsize tries to set the specified window size for the specified file
+// descriptor. It is only implemented on Unix, and returns an error on Windows.
+func SetWinsize(fd uintptr, ws *Winsize) error {
+	return setWinsize(fd, ws)
 }
 
 // IsTerminal returns true if the given file descriptor is a terminal.
 func IsTerminal(fd uintptr) bool {
-	_, err := tcget(fd)
+	return isTerminal(fd)
-	return err == nil
 }
 
 // RestoreTerminal restores the terminal connected to the given file descriptor
 // to a previous state.
 func RestoreTerminal(fd uintptr, state *State) error {
-	if state == nil {
+	return restoreTerminal(fd, state)
-		return ErrInvalidState
-	}
-	return tcset(fd, &state.termios)
 }
 
 // SaveState saves the state of the terminal connected to the given file descriptor.
 func SaveState(fd uintptr) (*State, error) {
-	termios, err := tcget(fd)
+	return saveState(fd)
-	if err != nil {
-		return nil, err
-	}
-	return &State{termios: *termios}, nil
 }
 
 // DisableEcho applies the specified state to the terminal connected to the file
 // descriptor, with echo disabled.
 func DisableEcho(fd uintptr, state *State) error {
-	newState := state.termios
+	return disableEcho(fd, state)
-	newState.Lflag &^= unix.ECHO
-
-	if err := tcset(fd, &newState); err != nil {
-		return err
-	}
-	return nil
 }
 
 // SetRawTerminal puts the terminal connected to the given file descriptor into
-// raw mode and returns the previous state. On UNIX, this puts both the input
+// raw mode and returns the previous state. On UNIX, this is the equivalent of
-// and output into raw mode. On Windows, it only puts the input into raw mode.
+// [MakeRaw], and puts both the input and output into raw mode. On Windows, it
-func SetRawTerminal(fd uintptr) (*State, error) {
+// only puts the input into raw mode.
-	oldState, err := MakeRaw(fd)
+func SetRawTerminal(fd uintptr) (previousState *State, err error) {
-	if err != nil {
+	return setRawTerminal(fd)
-		return nil, err
-	}
-	return oldState, err
 }
 
 // SetRawTerminalOutput puts the output of terminal connected to the given file
 // descriptor into raw mode. On UNIX, this does nothing and returns nil for the
 // state. On Windows, it disables LF -> CRLF translation.
-func SetRawTerminalOutput(fd uintptr) (*State, error) {
+func SetRawTerminalOutput(fd uintptr) (previousState *State, err error) {
-	return nil, nil
+	return setRawTerminalOutput(fd)
+}
+
+// MakeRaw puts the terminal (Windows Console) connected to the
+// given file descriptor into raw mode and returns the previous state of
+// the terminal so that it can be restored.
+func MakeRaw(fd uintptr) (previousState *State, err error) {
+	return makeRaw(fd)
 }

vendor/github.com/moby/term/term_unix.go

@@ -0,0 +1,98 @@
+//go:build !windows
+// +build !windows
+
+package term
+
+import (
+	"errors"
+	"io"
+	"os"
+
+	"golang.org/x/sys/unix"
+)
+
+// ErrInvalidState is returned if the state of the terminal is invalid.
+//
+// Deprecated: ErrInvalidState is no longer used.
+var ErrInvalidState = errors.New("Invalid terminal state")
+
+// terminalState holds the platform-specific state / console mode for the terminal.
+type terminalState struct {
+	termios unix.Termios
+}
+
+func stdStreams() (stdIn io.ReadCloser, stdOut, stdErr io.Writer) {
+	return os.Stdin, os.Stdout, os.Stderr
+}
+
+func getFdInfo(in interface{}) (uintptr, bool) {
+	var inFd uintptr
+	var isTerminalIn bool
+	if file, ok := in.(*os.File); ok {
+		inFd = file.Fd()
+		isTerminalIn = isTerminal(inFd)
+	}
+	return inFd, isTerminalIn
+}
+
+func getWinsize(fd uintptr) (*Winsize, error) {
+	uws, err := unix.IoctlGetWinsize(int(fd), unix.TIOCGWINSZ)
+	ws := &Winsize{Height: uws.Row, Width: uws.Col, x: uws.Xpixel, y: uws.Ypixel}
+	return ws, err
+}
+
+func setWinsize(fd uintptr, ws *Winsize) error {
+	return unix.IoctlSetWinsize(int(fd), unix.TIOCSWINSZ, &unix.Winsize{
+		Row:    ws.Height,
+		Col:    ws.Width,
+		Xpixel: ws.x,
+		Ypixel: ws.y,
+	})
+}
+
+func isTerminal(fd uintptr) bool {
+	_, err := tcget(fd)
+	return err == nil
+}
+
+func restoreTerminal(fd uintptr, state *State) error {
+	if state == nil {
+		return errors.New("invalid terminal state")
+	}
+	return tcset(fd, &state.termios)
+}
+
+func saveState(fd uintptr) (*State, error) {
+	termios, err := tcget(fd)
+	if err != nil {
+		return nil, err
+	}
+	return &State{termios: *termios}, nil
+}
+
+func disableEcho(fd uintptr, state *State) error {
+	newState := state.termios
+	newState.Lflag &^= unix.ECHO
+
+	return tcset(fd, &newState)
+}
+
+func setRawTerminal(fd uintptr) (*State, error) {
+	return makeRaw(fd)
+}
+
+func setRawTerminalOutput(fd uintptr) (*State, error) {
+	return nil, nil
+}
+
+func tcget(fd uintptr) (*unix.Termios, error) {
+	p, err := unix.IoctlGetTermios(int(fd), getTermios)
+	if err != nil {
+		return nil, err
+	}
+	return p, nil
+}
+
+func tcset(fd uintptr, p *unix.Termios) error {
+	return unix.IoctlSetTermios(int(fd), setTermios, p)
+}

vendor/github.com/moby/term/term_windows.go

@@ -1,6 +1,7 @@
 package term
 
 import (
+	"fmt"
 	"io"
 	"os"
 	"os/signal"
@@ -9,22 +10,15 @@ import (
 	"golang.org/x/sys/windows"
 )
 
-// State holds the console mode for the terminal.
+// terminalState holds the platform-specific state / console mode for the terminal.
-type State struct {
+type terminalState struct {
 	mode uint32
 }
 
-// Winsize is used for window size.
-type Winsize struct {
-	Height uint16
-	Width  uint16
-}
-
 // vtInputSupported is true if winterm.ENABLE_VIRTUAL_TERMINAL_INPUT is supported by the console
 var vtInputSupported bool
 
-// StdStreams returns the standard streams (stdin, stdout, stderr).
+func stdStreams() (stdIn io.ReadCloser, stdOut, stdErr io.Writer) {
-func StdStreams() (stdIn io.ReadCloser, stdOut, stdErr io.Writer) {
 	// Turn on VT handling on all std handles, if possible. This might
 	// fail, in which case we will fall back to terminal emulation.
 	var (
@@ -87,16 +81,14 @@ func StdStreams() (stdIn io.ReadCloser, stdOut, stdErr io.Writer) {
 		stdErr = os.Stderr
 	}
 
-	return
+	return stdIn, stdOut, stdErr
 }
 
-// GetFdInfo returns the file descriptor for an os.File and indicates whether the file represents a terminal.
+func getFdInfo(in interface{}) (uintptr, bool) {
-func GetFdInfo(in interface{}) (uintptr, bool) {
 	return windowsconsole.GetHandleInfo(in)
 }
 
-// GetWinsize returns the window size based on the specified file descriptor.
+func getWinsize(fd uintptr) (*Winsize, error) {
-func GetWinsize(fd uintptr) (*Winsize, error) {
 	var info windows.ConsoleScreenBufferInfo
 	if err := windows.GetConsoleScreenBufferInfo(windows.Handle(fd), &info); err != nil {
 		return nil, err
@@ -110,21 +102,21 @@ func GetWinsize(fd uintptr) (*Winsize, error) {
 	return winsize, nil
 }
 
-// IsTerminal returns true if the given file descriptor is a terminal.
+func setWinsize(fd uintptr, ws *Winsize) error {
-func IsTerminal(fd uintptr) bool {
+	return fmt.Errorf("not implemented on Windows")
+}
+
+func isTerminal(fd uintptr) bool {
 	var mode uint32
 	err := windows.GetConsoleMode(windows.Handle(fd), &mode)
 	return err == nil
 }
 
-// RestoreTerminal restores the terminal connected to the given file descriptor
+func restoreTerminal(fd uintptr, state *State) error {
-// to a previous state.
-func RestoreTerminal(fd uintptr, state *State) error {
 	return windows.SetConsoleMode(windows.Handle(fd), state.mode)
 }
 
-// SaveState saves the state of the terminal connected to the given file descriptor.
+func saveState(fd uintptr) (*State, error) {
-func SaveState(fd uintptr) (*State, error) {
 	var mode uint32
 
 	if err := windows.GetConsoleMode(windows.Handle(fd), &mode); err != nil {
@@ -134,9 +126,8 @@ func SaveState(fd uintptr) (*State, error) {
 	return &State{mode: mode}, nil
 }
 
-// DisableEcho disables echo for the terminal connected to the given file descriptor.
+func disableEcho(fd uintptr, state *State) error {
-// -- See https://msdn.microsoft.com/en-us/library/windows/desktop/ms683462(v=vs.85).aspx
+	// See https://msdn.microsoft.com/en-us/library/windows/desktop/ms683462(v=vs.85).aspx
-func DisableEcho(fd uintptr, state *State) error {
 	mode := state.mode
 	mode &^= windows.ENABLE_ECHO_INPUT
 	mode |= windows.ENABLE_PROCESSED_INPUT | windows.ENABLE_LINE_INPUT
@@ -150,69 +141,27 @@ func DisableEcho(fd uintptr, state *State) error {
 	return nil
 }
 
-// SetRawTerminal puts the terminal connected to the given file descriptor into
+func setRawTerminal(fd uintptr) (*State, error) {
-// raw mode and returns the previous state. On UNIX, this puts both the input
+	oldState, err := MakeRaw(fd)
-// and output into raw mode. On Windows, it only puts the input into raw mode.
-func SetRawTerminal(fd uintptr) (*State, error) {
-	state, err := MakeRaw(fd)
 	if err != nil {
 		return nil, err
 	}
 
 	// Register an interrupt handler to catch and restore prior state
-	restoreAtInterrupt(fd, state)
+	restoreAtInterrupt(fd, oldState)
-	return state, err
+	return oldState, err
 }
 
-// SetRawTerminalOutput puts the output of terminal connected to the given file
+func setRawTerminalOutput(fd uintptr) (*State, error) {
-// descriptor into raw mode. On UNIX, this does nothing and returns nil for the
+	oldState, err := saveState(fd)
-// state. On Windows, it disables LF -> CRLF translation.
-func SetRawTerminalOutput(fd uintptr) (*State, error) {
-	state, err := SaveState(fd)
 	if err != nil {
 		return nil, err
 	}
 
 	// Ignore failures, since winterm.DISABLE_NEWLINE_AUTO_RETURN might not be supported on this
 	// version of Windows.
-	_ = windows.SetConsoleMode(windows.Handle(fd), state.mode|windows.DISABLE_NEWLINE_AUTO_RETURN)
+	_ = windows.SetConsoleMode(windows.Handle(fd), oldState.mode|windows.DISABLE_NEWLINE_AUTO_RETURN)
-	return state, err
+	return oldState, err
-}
-
-// MakeRaw puts the terminal (Windows Console) connected to the given file descriptor into raw
-// mode and returns the previous state of the terminal so that it can be restored.
-func MakeRaw(fd uintptr) (*State, error) {
-	state, err := SaveState(fd)
-	if err != nil {
-		return nil, err
-	}
-
-	mode := state.mode
-
-	// See
-	// -- https://msdn.microsoft.com/en-us/library/windows/desktop/ms686033(v=vs.85).aspx
-	// -- https://msdn.microsoft.com/en-us/library/windows/desktop/ms683462(v=vs.85).aspx
-
-	// Disable these modes
-	mode &^= windows.ENABLE_ECHO_INPUT
-	mode &^= windows.ENABLE_LINE_INPUT
-	mode &^= windows.ENABLE_MOUSE_INPUT
-	mode &^= windows.ENABLE_WINDOW_INPUT
-	mode &^= windows.ENABLE_PROCESSED_INPUT
-
-	// Enable these modes
-	mode |= windows.ENABLE_EXTENDED_FLAGS
-	mode |= windows.ENABLE_INSERT_MODE
-	mode |= windows.ENABLE_QUICK_EDIT_MODE
-	if vtInputSupported {
-		mode |= windows.ENABLE_VIRTUAL_TERMINAL_INPUT
-	}
-
-	err = windows.SetConsoleMode(windows.Handle(fd), mode)
-	if err != nil {
-		return nil, err
-	}
-	return state, nil
 }
 
 func restoreAtInterrupt(fd uintptr, state *State) {

vendor/github.com/moby/term/termios_unix.go

@@ -8,12 +8,11 @@ import (
 )
 
 // Termios is the Unix API for terminal I/O.
+//
+// Deprecated: use [unix.Termios].
 type Termios = unix.Termios
 
-// MakeRaw puts the terminal connected to the given file descriptor into raw
+func makeRaw(fd uintptr) (*State, error) {
-// mode and returns the previous state of the terminal so that it can be
-// restored.
-func MakeRaw(fd uintptr) (*State, error) {
 	termios, err := tcget(fd)
 	if err != nil {
 		return nil, err
@@ -21,10 +20,10 @@ func MakeRaw(fd uintptr) (*State, error) {
 
 	oldState := State{termios: *termios}
 
-	termios.Iflag &^= (unix.IGNBRK | unix.BRKINT | unix.PARMRK | unix.ISTRIP | unix.INLCR | unix.IGNCR | unix.ICRNL | unix.IXON)
+	termios.Iflag &^= unix.IGNBRK | unix.BRKINT | unix.PARMRK | unix.ISTRIP | unix.INLCR | unix.IGNCR | unix.ICRNL | unix.IXON
 	termios.Oflag &^= unix.OPOST
-	termios.Lflag &^= (unix.ECHO | unix.ECHONL | unix.ICANON | unix.ISIG | unix.IEXTEN)
+	termios.Lflag &^= unix.ECHO | unix.ECHONL | unix.ICANON | unix.ISIG | unix.IEXTEN
-	termios.Cflag &^= (unix.CSIZE | unix.PARENB)
+	termios.Cflag &^= unix.CSIZE | unix.PARENB
 	termios.Cflag |= unix.CS8
 	termios.Cc[unix.VMIN] = 1
 	termios.Cc[unix.VTIME] = 0

vendor/github.com/moby/term/termios_windows.go

@@ -0,0 +1,37 @@
+package term
+
+import "golang.org/x/sys/windows"
+
+func makeRaw(fd uintptr) (*State, error) {
+	state, err := SaveState(fd)
+	if err != nil {
+		return nil, err
+	}
+
+	mode := state.mode
+
+	// See
+	// -- https://msdn.microsoft.com/en-us/library/windows/desktop/ms686033(v=vs.85).aspx
+	// -- https://msdn.microsoft.com/en-us/library/windows/desktop/ms683462(v=vs.85).aspx
+
+	// Disable these modes
+	mode &^= windows.ENABLE_ECHO_INPUT
+	mode &^= windows.ENABLE_LINE_INPUT
+	mode &^= windows.ENABLE_MOUSE_INPUT
+	mode &^= windows.ENABLE_WINDOW_INPUT
+	mode &^= windows.ENABLE_PROCESSED_INPUT
+
+	// Enable these modes
+	mode |= windows.ENABLE_EXTENDED_FLAGS
+	mode |= windows.ENABLE_INSERT_MODE
+	mode |= windows.ENABLE_QUICK_EDIT_MODE
+	if vtInputSupported {
+		mode |= windows.ENABLE_VIRTUAL_TERMINAL_INPUT
+	}
+
+	err = windows.SetConsoleMode(windows.Handle(fd), mode)
+	if err != nil {
+		return nil, err
+	}
+	return state, nil
+}

vendor/github.com/moby/term/windows/ansi_reader.go

@@ -195,10 +195,10 @@ func keyToString(keyEvent *winterm.KEY_EVENT_RECORD, escapeSequence []byte) stri
 
 	// <Alt>+Key generates ESC N Key
 	if !control && alt {
-		return ansiterm.KEY_ESC_N + strings.ToLower(string(keyEvent.UnicodeChar))
+		return ansiterm.KEY_ESC_N + strings.ToLower(string(rune(keyEvent.UnicodeChar)))
 	}
 
-	return string(keyEvent.UnicodeChar)
+	return string(rune(keyEvent.UnicodeChar))
 }
 
 // formatVirtualKey converts a virtual key (e.g., up arrow) into the appropriate ANSI string.

vendor/github.com/moby/term/windows/console.go

@@ -30,8 +30,11 @@ func GetHandleInfo(in interface{}) (uintptr, bool) {
 
 // IsConsole returns true if the given file descriptor is a Windows Console.
 // The code assumes that GetConsoleMode will return an error for file descriptors that are not a console.
-// Deprecated: use golang.org/x/sys/windows.GetConsoleMode() or golang.org/x/term.IsTerminal()
+//
-var IsConsole = isConsole
+// Deprecated: use [windows.GetConsoleMode] or [golang.org/x/term.IsTerminal].
+func IsConsole(fd uintptr) bool {
+	return isConsole(fd)
+}
 
 func isConsole(fd uintptr) bool {
 	var mode uint32

vendor/github.com/moby/term/winsize.go

@@ -1,21 +0,0 @@
-//go:build !windows
-// +build !windows
-
-package term
-
-import (
-	"golang.org/x/sys/unix"
-)
-
-// GetWinsize returns the window size based on the specified file descriptor.
-func GetWinsize(fd uintptr) (*Winsize, error) {
-	uws, err := unix.IoctlGetWinsize(int(fd), unix.TIOCGWINSZ)
-	ws := &Winsize{Height: uws.Row, Width: uws.Col, x: uws.Xpixel, y: uws.Ypixel}
-	return ws, err
-}
-
-// SetWinsize tries to set the specified window size for the specified file descriptor.
-func SetWinsize(fd uintptr, ws *Winsize) error {
-	uws := &unix.Winsize{Row: ws.Height, Col: ws.Width, Xpixel: ws.x, Ypixel: ws.y}
-	return unix.IoctlSetWinsize(int(fd), unix.TIOCSWINSZ, uws)
-}

vendor/modules.txt

@@ -183,7 +183,7 @@ github.com/moby/sys/signal
 # github.com/moby/sys/symlink v0.2.0
 ## explicit; go 1.16
 github.com/moby/sys/symlink
-# github.com/moby/term v0.0.0-20221128092401-c43b287e0e0f
+# github.com/moby/term v0.5.0
 ## explicit; go 1.18
 github.com/moby/term
 github.com/moby/term/windows