andy/nexus
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 2 Wiki Activity

feat: improve local terminal workflows

Browse Source
This commit is contained in:
Andy Dixon
2026-07-22 11:57:52 +01:00
parent 4fc3b19441
commit 5d5993d9c4
20 changed files with 967 additions and 160 deletions
Download Patch File Download Diff File Expand all files Collapse all files
internal/localshell/localshell.go
+144 -38
View File
@@ -3,11 +3,18 @@
package localshell
import (
"context"
"errors"
"fmt"
"io"
"os"
"os/exec"
"runtime"
"strconv"
"strings"
"sync"
"syscall"
"time"
"github.com/andydixon/nexus/internal/terminalenv"
"github.com/creack/pty"
@@ -15,26 +22,28 @@ import (
// Client manages a local shell PTY session.
type Client struct {
mu sync.Mutex
cmd *exec.Cmd
ptmx *os.File
shell string
onData func([]byte)
onError func(error)
onClose func()
closed bool
cols uint16
rows uint16
mu sync.Mutex
cmd *exec.Cmd
ptmx *os.File
shell string
startDir string
onData func([]byte)
onError func(error)
onClose func()
closed bool
cols uint16
rows uint16
}
// Config holds configuration for a local shell session.
type Config struct {
Shell string // Path to the shell binary (e.g. /bin/zsh)
Cols uint16
Rows uint16
OnData func([]byte)
OnError func(error)
OnClose func()
Shell string // Path to the shell binary (e.g. /bin/zsh)
Cols uint16
Rows uint16
StartDir string // Initial working directory; defaults to the user's home directory.
OnData func([]byte)
OnError func(error)
OnClose func()
}
// DefaultShell returns the system default shell.
@@ -67,13 +76,20 @@ func NewClient(cfg Config) *Client {
if rows == 0 {
rows = 24
}
startDir := cfg.StartDir
if startDir == "" {
if home, err := os.UserHomeDir(); err == nil {
startDir = home
}
}
return &Client{
shell: shell,
cols: cols,
rows: rows,
onData: cfg.OnData,
onError: cfg.OnError,
onClose: cfg.OnClose,
shell: shell,
startDir: startDir,
cols: cols,
rows: rows,
onData: cfg.OnData,
onError: cfg.OnError,
onClose: cfg.OnClose,
}
}
@@ -82,17 +98,16 @@ func (c *Client) Start() error {
c.mu.Lock()
defer c.mu.Unlock()
if c.closed {
return fmt.Errorf("shell already closed")
}
if c.ptmx != nil {
return fmt.Errorf("shell already running")
}
cmd := exec.Command(c.shell)
cmd.Env = terminalenv.LocalShellEnv(os.Environ())
// Start in the user's home directory.
if home, err := os.UserHomeDir(); err == nil {
cmd.Dir = home
}
cmd.Dir = c.startDir
ptmx, err := pty.StartWithSize(cmd, &pty.Winsize{
Cols: c.cols,
@@ -106,7 +121,7 @@ func (c *Client) Start() error {
c.ptmx = ptmx
// Read loop — forward PTY output to the frontend.
go c.readLoop()
go c.readLoop(ptmx)
// Wait for process exit.
go func() {
@@ -114,6 +129,9 @@ func (c *Client) Start() error {
c.mu.Lock()
wasClosed := c.closed
c.closed = true
if c.ptmx == ptmx {
c.ptmx = nil
}
c.mu.Unlock()
if !wasClosed && c.onClose != nil {
@@ -126,6 +144,13 @@ func (c *Client) Start() error {
// Write sends data to the shell's stdin (PTY).
func (c *Client) Write(data []byte) error {
// Capture the shell's current directory before it handles a command or
// EOF. This lets a replacement shell resume in the same directory after
// an ordinary `exit`, without injecting shell-specific prompt hooks.
if bytesContainCommandBoundary(data) {
c.captureWorkingDirectory()
}
c.mu.Lock()
ptmx := c.ptmx
c.mu.Unlock()
@@ -140,7 +165,15 @@ func (c *Client) Write(data []byte) error {
// Resize updates the PTY window size.
func (c *Client) Resize(cols, rows uint16) error {
c.mu.Lock()
if cols > 0 {
c.cols = cols
}
if rows > 0 {
c.rows = rows
}
ptmx := c.ptmx
cols = c.cols
rows = c.rows
c.mu.Unlock()
if ptmx == nil {
@@ -152,26 +185,36 @@ func (c *Client) Resize(cols, rows uint16) error {
// Close terminates the shell process and PTY.
func (c *Client) Close() {
c.mu.Lock()
defer c.mu.Unlock()
if c.closed {
c.mu.Unlock()
return
}
c.closed = true
ptmx := c.ptmx
cmd := c.cmd
c.ptmx = nil
c.mu.Unlock()
if c.ptmx != nil {
c.ptmx.Close()
c.ptmx = nil
if ptmx != nil {
_ = ptmx.Close()
}
if c.cmd != nil && c.cmd.Process != nil {
c.cmd.Process.Kill()
if cmd != nil && cmd.Process != nil {
_ = cmd.Process.Kill()
}
}
func (c *Client) readLoop() {
// WorkingDirectory returns the last directory observed for the shell.
func (c *Client) WorkingDirectory() string {
c.mu.Lock()
defer c.mu.Unlock()
return c.startDir
}
func (c *Client) readLoop(ptmx *os.File) {
defer ptmx.Close()
buf := make([]byte, 32*1024)
for {
n, err := c.ptmx.Read(buf)
n, err := ptmx.Read(buf)
if n > 0 && c.onData != nil {
c.onData(buf[:n])
}
@@ -179,10 +222,73 @@ func (c *Client) readLoop() {
c.mu.Lock()
wasClosed := c.closed
c.mu.Unlock()
if !wasClosed && c.onError != nil {
if !wasClosed && !isNormalPTYClosure(err) && c.onError != nil {
c.onError(err)
}
return
}
}
}
func bytesContainCommandBoundary(data []byte) bool {
for _, b := range data {
if b == '\r' || b == '\n' || b == 0x04 {
return true
}
}
return false
}
func isNormalPTYClosure(err error) bool {
return errors.Is(err, io.EOF) || errors.Is(err, os.ErrClosed) || errors.Is(err, syscall.EIO)
}
func (c *Client) captureWorkingDirectory() {
c.mu.Lock()
cmd := c.cmd
c.mu.Unlock()
if cmd == nil || cmd.Process == nil {
return
}
dir := processWorkingDirectory(cmd.Process.Pid)
if dir == "" || !isDirectory(dir) {
return
}
c.mu.Lock()
if c.cmd == cmd {
c.startDir = dir
}
c.mu.Unlock()
}
func processWorkingDirectory(pid int) string {
switch runtime.GOOS {
case "linux":
dir, err := os.Readlink("/proc/" + strconv.Itoa(pid) + "/cwd")
if err == nil {
return dir
}
case "darwin":
// macOS does not expose /proc. lsof is part of the base system and its
// field output gives us the cwd without parsing a human-readable table.
ctx, cancel := context.WithTimeout(context.Background(), 500*time.Millisecond)
defer cancel()
out, err := exec.CommandContext(ctx, "/usr/sbin/lsof", "-a", "-p", strconv.Itoa(pid), "-d", "cwd", "-Fn").Output()
if err != nil {
return ""
}
for _, line := range strings.Split(string(out), "\n") {
if strings.HasPrefix(line, "n") {
return strings.TrimPrefix(line, "n")
}
}
}
return ""
}
func isDirectory(path string) bool {
info, err := os.Stat(path)
return err == nil && info.IsDir()
}
internal/localshell/localshell_test.go
+146
View File
@@ -0,0 +1,146 @@
package localshell
import (
"bytes"
"os"
"path/filepath"
"runtime"
"strings"
"sync"
"testing"
"time"
)
func TestClientUsesConfiguredDirectoryAndPreStartSize(t *testing.T) {
if runtime.GOOS == "windows" {
t.Skip("local PTY test requires a Unix shell")
}
dir := t.TempDir()
startDir := filepath.Join(dir, "working")
if err := os.Mkdir(startDir, 0o700); err != nil {
t.Fatal(err)
}
script := filepath.Join(dir, "report-terminal.sh")
if err := os.WriteFile(script, []byte("#!/bin/sh\nstty size\npwd\n"), 0o700); err != nil {
t.Fatal(err)
}
var output bytes.Buffer
var outputMu sync.Mutex
closed := make(chan struct{})
errors := make(chan error, 1)
client := NewClient(Config{
Shell: script,
StartDir: startDir,
Cols: 80,
Rows: 24,
OnData: func(data []byte) {
outputMu.Lock()
_, _ = output.Write(data)
outputMu.Unlock()
},
OnError: func(err error) {
errors <- err
},
OnClose: func() {
close(closed)
},
})
// A frontend fit can arrive before the process starts. The stored size
// must become the initial PTY geometry rather than being discarded.
if err := client.Resize(132, 43); err != nil {
t.Fatalf("Resize() before Start() error = %v", err)
}
if err := client.Start(); err != nil {
t.Fatalf("Start() error = %v", err)
}
select {
case err := <-errors:
t.Fatalf("unexpected PTY read error: %v", err)
case <-closed:
case <-time.After(5 * time.Second):
client.Close()
t.Fatal("timed out waiting for local shell to exit")
}
outputMu.Lock()
got := strings.ReplaceAll(output.String(), "\r", "")
outputMu.Unlock()
if !strings.Contains(got, "43 132\n") {
t.Fatalf("PTY output %q does not contain configured size 43 132", got)
}
if !strings.Contains(got, startDir+"\n") {
t.Fatalf("PTY output %q does not contain start directory %q", got, startDir)
}
}
func TestBytesContainCommandBoundary(t *testing.T) {
for _, data := range [][]byte{[]byte("pwd\r"), []byte("pwd\n"), {0x04}} {
if !bytesContainCommandBoundary(data) {
t.Fatalf("bytesContainCommandBoundary(%q) = false, want true", data)
}
}
if bytesContainCommandBoundary([]byte("pwd")) {
t.Fatal("bytesContainCommandBoundary without enter/EOF = true, want false")
}
}
func TestClientCapturesWorkingDirectoryBeforeExit(t *testing.T) {
if runtime.GOOS != "darwin" && runtime.GOOS != "linux" {
t.Skip("process cwd lookup is implemented on macOS and Linux")
}
dir := t.TempDir()
startDir := filepath.Join(dir, "start")
nextDir := filepath.Join(startDir, "next")
if err := os.MkdirAll(nextDir, 0o700); err != nil {
t.Fatal(err)
}
expectedDir, err := filepath.EvalSymlinks(nextDir)
if err != nil {
t.Fatal(err)
}
closed := make(chan struct{})
client := NewClient(Config{
Shell: "/bin/sh",
StartDir: startDir,
OnClose: func() {
close(closed)
},
})
if err := client.Start(); err != nil {
t.Fatalf("Start() error = %v", err)
}
defer client.Close()
if err := client.Write([]byte("cd next\r")); err != nil {
t.Fatalf("Write(cd) error = %v", err)
}
deadline := time.Now().Add(5 * time.Second)
for client.WorkingDirectory() != expectedDir && time.Now().Before(deadline) {
time.Sleep(20 * time.Millisecond)
// The empty command boundary snapshots the directory after cd has run.
if err := client.Write([]byte("\r")); err != nil {
t.Fatalf("Write(snapshot) error = %v", err)
}
}
if got := client.WorkingDirectory(); got != expectedDir {
t.Fatalf("WorkingDirectory() = %q, want %q", got, expectedDir)
}
if err := client.Write([]byte("exit\r")); err != nil {
t.Fatalf("Write(exit) error = %v", err)
}
select {
case <-closed:
case <-time.After(5 * time.Second):
t.Fatal("timed out waiting for local shell to exit")
}
if got := client.WorkingDirectory(); got != expectedDir {
t.Fatalf("WorkingDirectory() after exit = %q, want %q", got, expectedDir)
}
}