@pi-in-go/pigpen-ahp 0.1.0

package/extensions/ahp/internal/svc/pty.go

@@ -0,0 +1,64 @@
+package svc
+
+import (
+	"errors"
+	"unicode/utf8"
+)
+
+// PtyOptions describe the pseudoterminal to open.
+type PtyOptions struct {
+	Name       string // $TERM
+	Cols, Rows int
+	Cwd        string
+	Env        []string // extra environment entries; nil inherits the host process environment
+}
+
+// PtyHandlers receive the process's output and exit. OnData gets whole UTF-8 text (a multi-byte
+// character is never split across two calls); OnExit is called once, after the last OnData.
+type PtyHandlers struct {
+	OnData func(data string)
+	OnExit func(exitCode int)
+}
+
+// PtyProcess is a running child on a pseudoterminal.
+type PtyProcess interface {
+	Write(data string) error
+	Resize(cols, rows int) error
+	Kill() error
+}
+
+// PtySpawner starts file on a new pseudoterminal.
+type PtySpawner func(file string, args []string, opts PtyOptions, h PtyHandlers) (PtyProcess, error)
+
+// ErrPtyUnsupported is returned by the default spawner on platforms without pseudoterminals.
+var ErrPtyUnsupported = errors.New("pseudoterminals are not supported on this platform")
+
+// utf8Decoder turns a byte stream into strings without splitting a character: an incomplete
+// trailing sequence is held back until the next chunk (or flushed at the end).
+type utf8Decoder struct{ held []byte }
+
+func (d *utf8Decoder) Write(chunk []byte) string {
+	buf := append(d.held, chunk...)
+	d.held = nil
+	// hold back an incomplete trailing sequence (at most 3 bytes)
+	for back := 1; back <= 3 && back <= len(buf); back++ {
+		b := buf[len(buf)-back]
+		if b < 0x80 {
+			break
+		}
+		if utf8.RuneStart(b) {
+			if !utf8.FullRune(buf[len(buf)-back:]) {
+				d.held = append([]byte(nil), buf[len(buf)-back:]...)
+				buf = buf[:len(buf)-back]
+			}
+			break
+		}
+	}
+	return string(buf)
+}
+
+func (d *utf8Decoder) Flush() string {
+	out := string(d.held)
+	d.held = nil
+	return out
+}

package/extensions/ahp/internal/svc/pty_darwin.go

@@ -0,0 +1,42 @@
+//go:build darwin
+
+package svc
+
+import (
+	"os"
+	"syscall"
+	"unsafe"
+)
+
+const (
+	tiocPTYGRANT = 0x20007454
+	tiocPTYUNLK  = 0x20007452
+	tiocPTYGNAME = 0x40807453
+)
+
+func openPty() (master, slave *os.File, err error) {
+	master, err = os.OpenFile("/dev/ptmx", os.O_RDWR|syscall.O_NOCTTY, 0)
+	if err != nil {
+		return nil, nil, err
+	}
+	fail := func(e error) (*os.File, *os.File, error) { master.Close(); return nil, nil, e }
+	if _, _, e := syscall.Syscall(syscall.SYS_IOCTL, master.Fd(), tiocPTYGRANT, 0); e != 0 {
+		return fail(e)
+	}
+	if _, _, e := syscall.Syscall(syscall.SYS_IOCTL, master.Fd(), tiocPTYUNLK, 0); e != 0 {
+		return fail(e)
+	}
+	var name [128]byte
+	if _, _, e := syscall.Syscall(syscall.SYS_IOCTL, master.Fd(), tiocPTYGNAME, uintptr(unsafe.Pointer(&name[0]))); e != 0 {
+		return fail(e)
+	}
+	n := 0
+	for n < len(name) && name[n] != 0 {
+		n++
+	}
+	slave, err = os.OpenFile(string(name[:n]), os.O_RDWR|syscall.O_NOCTTY, 0)
+	if err != nil {
+		return fail(err)
+	}
+	return master, slave, nil
+}

package/extensions/ahp/internal/svc/pty_linux.go

@@ -0,0 +1,36 @@
+//go:build linux
+
+package svc
+
+import (
+	"fmt"
+	"os"
+	"syscall"
+	"unsafe"
+)
+
+const (
+	tiocGPTN   = 0x80045430
+	tiocSPTLCK = 0x40045431
+)
+
+func openPty() (master, slave *os.File, err error) {
+	master, err = os.OpenFile("/dev/ptmx", os.O_RDWR|syscall.O_NOCTTY|syscall.O_CLOEXEC, 0)
+	if err != nil {
+		return nil, nil, err
+	}
+	fail := func(e error) (*os.File, *os.File, error) { master.Close(); return nil, nil, e }
+	var unlock int32
+	if _, _, e := syscall.Syscall(syscall.SYS_IOCTL, master.Fd(), tiocSPTLCK, uintptr(unsafe.Pointer(&unlock))); e != 0 {
+		return fail(e)
+	}
+	var n uint32
+	if _, _, e := syscall.Syscall(syscall.SYS_IOCTL, master.Fd(), tiocGPTN, uintptr(unsafe.Pointer(&n))); e != 0 {
+		return fail(e)
+	}
+	slave, err = os.OpenFile(fmt.Sprintf("/dev/pts/%d", n), os.O_RDWR|syscall.O_NOCTTY, 0)
+	if err != nil {
+		return fail(err)
+	}
+	return master, slave, nil
+}

package/extensions/ahp/internal/svc/pty_other.go

@@ -0,0 +1,9 @@
+//go:build !linux && !darwin
+
+package svc
+
+// SpawnPty is unavailable here: the standard library has no ConPTY or BSD pty support, so the
+// terminal service refuses to start (a documented gap, see PORT.md).
+func SpawnPty(string, []string, PtyOptions, PtyHandlers) (PtyProcess, error) {
+	return nil, ErrPtyUnsupported
+}

package/extensions/ahp/internal/svc/pty_test.go

@@ -0,0 +1,114 @@
+//go:build linux || darwin
+
+package svc
+
+import (
+	"strings"
+	"sync"
+	"testing"
+	"time"
+
+	"github.com/MichaelKinsy/pigpen/ahp/internal/twin"
+)
+
+// Twins of upstream test/pty.test.ts: a real shell on a real pseudoterminal.
+
+type ptyRun struct {
+	mu     sync.Mutex
+	output strings.Builder
+	exited chan int
+	onData func(all string)
+}
+
+func spawnRun(t *testing.T, file string, args []string, onData func(*ptyRun, string)) (*ptyRun, PtyProcess) {
+	t.Helper()
+	run := &ptyRun{exited: make(chan int, 1)}
+	pty, err := SpawnPty(file, args, PtyOptions{Name: "xterm-256color", Cols: 80, Rows: 24, Cwd: t.TempDir()}, PtyHandlers{
+		OnData: func(data string) {
+			run.mu.Lock()
+			run.output.WriteString(data)
+			all := run.output.String()
+			run.mu.Unlock()
+			if onData != nil {
+				onData(run, all)
+			}
+		},
+		OnExit: func(code int) { run.exited <- code },
+	})
+	if err != nil {
+		t.Fatalf("spawn: %v", err)
+	}
+	t.Cleanup(func() { _ = pty.Kill() })
+	return run, pty
+}
+
+func (r *ptyRun) Output() string { r.mu.Lock(); defer r.mu.Unlock(); return r.output.String() }
+
+func (r *ptyRun) wait(t *testing.T) int {
+	t.Helper()
+	select {
+	case code := <-r.exited:
+		return code
+	case <-time.After(5 * time.Second):
+		t.Fatalf("PTY did not exit; output: %q", r.Output())
+		return -1
+	}
+}
+
+func TestPty(t *testing.T) {
+	twin.Run(t, "pty", "round-trips input through a resized TTY", func(t *testing.T) {
+		marker := "pi-ahp-" + newUUID()
+		script := `test -t 0 && test -t 1 && test -t 2 || exit 70; test "$TERM" = xterm-256color || exit 71; IFS= read -r line; set -- $(stty size); printf "PTY:%s:%sx%s\n" "$line" "$1" "$2"`
+		run, pty := spawnRun(t, "sh", []string{"-c", script}, nil)
+		if err := pty.Resize(97, 31); err != nil {
+			t.Fatal(err)
+		}
+		if err := pty.Write(marker + "\r"); err != nil {
+			t.Fatal(err)
+		}
+		if code := run.wait(t); code != 0 {
+			t.Fatalf("PTY setup failed (exit %d); output: %q", code, run.Output())
+		}
+		expected := "PTY:" + marker + ":31x97"
+		if !strings.Contains(run.Output(), expected) {
+			t.Fatalf("missing %s in %q", expected, run.Output())
+		}
+	})
+
+	twin.Run(t, "pty", "delivers Ctrl-C to the foreground job without killing the shell", func(t *testing.T) {
+		marker := strings.ReplaceAll(newUUID(), "-", "")
+		childScript := `trap 'printf "INT:%s\n" "$MARKER"; exit 42' INT; printf "READY:%s\n" "$MARKER"; while :; do sleep 1; done`
+		stage := 0
+		var pty PtyProcess
+		var mu sync.Mutex
+		run, p := spawnRun(t, "sh", nil, func(_ *ptyRun, all string) {
+			mu.Lock()
+			defer mu.Unlock()
+			if stage == 0 && strings.Contains(all, "READY:"+marker) {
+				stage = 1
+				_ = pty.Write("\x03")
+			}
+			if stage == 1 && strings.Contains(all, "INT:"+marker) {
+				stage = 2
+				_ = pty.Write("printf 'AFTER:%s\\n' '" + marker + "'; exit\r")
+			}
+		})
+		mu.Lock()
+		pty = p
+		mu.Unlock()
+		// Expected markers are assembled by the child, so terminal echo cannot satisfy them.
+		quoted := "'" + strings.ReplaceAll(childScript, "'", `'\''`) + "'"
+		if err := p.Write("MARKER='" + marker + "' sh -c " + quoted + "\r"); err != nil {
+			t.Fatal(err)
+		}
+		code := run.wait(t)
+		mu.Lock()
+		defer mu.Unlock()
+		if code != 0 {
+			t.Fatalf("interactive shell died (exit %d): %q", code, run.Output())
+		}
+		if stage != 2 || !strings.Contains(run.Output(), "AFTER:"+marker) {
+			t.Fatalf("Ctrl-C flow stopped at stage %d: %q", stage, run.Output())
+		}
+	})
+}

package/extensions/ahp/internal/svc/pty_unix.go

@@ -0,0 +1,147 @@
+//go:build linux || darwin
+
+package svc
+
+import (
+	"errors"
+	"fmt"
+	"io"
+	"os"
+	"os/exec"
+	"sync"
+	"syscall"
+	"time"
+	"unsafe"
+)
+
+// SpawnPty starts file on a new pseudoterminal using only the standard library: it opens the
+// master, unlocks and opens the slave, makes it the child's controlling terminal (new session) and
+// reads the master until the child side closes.
+func SpawnPty(file string, args []string, opts PtyOptions, h PtyHandlers) (PtyProcess, error) {
+	master, slave, err := openPty()
+	if err != nil {
+		return nil, fmt.Errorf("open pty: %w", err)
+	}
+	p := &unixPty{master: master}
+	if err := p.Resize(opts.Cols, opts.Rows); err != nil {
+		master.Close()
+		slave.Close()
+		return nil, err
+	}
+	cmd := exec.Command(file, args...)
+	cmd.Dir = opts.Cwd
+	env := opts.Env
+	if env == nil {
+		env = os.Environ()
+	}
+	name := opts.Name
+	if name == "" {
+		name = "xterm-256color"
+	}
+	cmd.Env = append(append([]string(nil), env...), "TERM="+name)
+	cmd.Stdin, cmd.Stdout, cmd.Stderr = slave, slave, slave
+	cmd.SysProcAttr = &syscall.SysProcAttr{Setsid: true, Setctty: true, Ctty: 0}
+	if err := cmd.Start(); err != nil {
+		master.Close()
+		slave.Close()
+		return nil, err
+	}
+	slave.Close() // the child owns the only slave end now
+	p.cmd = cmd
+	p.exited = make(chan struct{})
+
+	readDone := make(chan struct{})
+	go func() {
+		defer close(readDone)
+		var dec utf8Decoder
+		buf := make([]byte, 32*1024)
+		for {
+			n, err := master.Read(buf)
+			if n > 0 && h.OnData != nil {
+				if text := dec.Write(buf[:n]); text != "" {
+					h.OnData(text)
+				}
+			}
+			if err != nil {
+				// EIO is how a Linux master reports that every slave end closed.
+				if !errors.Is(err, io.EOF) && !errors.Is(err, syscall.EIO) && !errors.Is(err, os.ErrClosed) {
+					_ = err
+				}
+				if tail := dec.Flush(); tail != "" && h.OnData != nil {
+					h.OnData(tail)
+				}
+				return
+			}
+		}
+	}()
+	go func() {
+		waitErr := cmd.Wait()
+		code := 0
+		if state := cmd.ProcessState; state != nil {
+			code = state.ExitCode()
+			if ws, ok := state.Sys().(syscall.WaitStatus); ok && ws.Signaled() {
+				code = 128 + int(ws.Signal())
+			}
+		} else if waitErr != nil {
+			code = 1
+		}
+		// Let the reader drain what the child wrote before it died; a grandchild that kept the slave
+		// open must not hold the exit back forever.
+		select {
+		case <-readDone:
+		case <-time.After(250 * time.Millisecond):
+		}
+		master.Close()
+		<-readDone
+		close(p.exited)
+		if h.OnExit != nil {
+			h.OnExit(code)
+		}
+	}()
+	return p, nil
+}
+
+type unixPty struct {
+	master *os.File
+	cmd    *exec.Cmd
+	exited chan struct{}
+
+	killOnce sync.Once
+}
+
+func (p *unixPty) Write(data string) error {
+	_, err := p.master.WriteString(data)
+	return err
+}
+
+type winsize struct{ Row, Col, X, Y uint16 }
+
+func (p *unixPty) Resize(cols, rows int) error {
+	ws := winsize{Row: uint16(rows), Col: uint16(cols)}
+	if _, _, e := syscall.Syscall(syscall.SYS_IOCTL, p.master.Fd(), uintptr(syscall.TIOCSWINSZ), uintptr(unsafe.Pointer(&ws))); e != 0 {
+		return e
+	}
+	return nil
+}
+
+// Kill hangs up the session's process group and escalates to SIGKILL if it lingers.
+func (p *unixPty) Kill() error {
+	var err error
+	p.killOnce.Do(func() {
+		if p.cmd == nil || p.cmd.Process == nil {
+			return
+		}
+		pid := p.cmd.Process.Pid
+		if e := syscall.Kill(-pid, syscall.SIGHUP); e != nil && !errors.Is(e, syscall.ESRCH) {
+			err = e
+		}
+		go func() {
+			select {
+			case <-p.exited:
+			case <-time.After(2 * time.Second):
+				_ = syscall.Kill(-pid, syscall.SIGKILL)
+			}
+		}()
+	})
+	return err
+}