feat: add tmux wrapper package for session operations
Session lifecycle: - NewSession, KillSession, HasSession, ListSessions, RenameSession Session interaction: - SendKeys, SendKeysRaw, CapturePane, CapturePaneAll, AttachSession Environment and windows: - SetEnvironment, GetEnvironment, SelectWindow, GetSessionInfo Error handling: - Detects ErrNoServer, ErrSessionExists, ErrSessionNotFound - Graceful handling when no tmux server running Closes gt-u1j.4 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
This commit is contained in:
Steve Yegge
204
internal/tmux/tmux.go
Normal file
204
internal/tmux/tmux.go
Normal file
@@ -0,0 +1,204 @@
|
||||
// Package tmux provides a wrapper for tmux session operations via subprocess.
|
||||
package tmux
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"errors"
|
||||
"fmt"
|
||||
"os/exec"
|
||||
"strings"
|
||||
)
|
||||
|
||||
// Common errors
|
||||
var (
|
||||
ErrNoServer = errors.New("no tmux server running")
|
||||
ErrSessionExists = errors.New("session already exists")
|
||||
ErrSessionNotFound = errors.New("session not found")
|
||||
)
|
||||
|
||||
// Tmux wraps tmux operations.
|
||||
type Tmux struct{}
|
||||
|
||||
// NewTmux creates a new Tmux wrapper.
|
||||
func NewTmux() *Tmux {
|
||||
return &Tmux{}
|
||||
}
|
||||
|
||||
// run executes a tmux command and returns stdout.
|
||||
func (t *Tmux) run(args ...string) (string, error) {
|
||||
cmd := exec.Command("tmux", args...)
|
||||
var stdout, stderr bytes.Buffer
|
||||
cmd.Stdout = &stdout
|
||||
cmd.Stderr = &stderr
|
||||
|
||||
err := cmd.Run()
|
||||
if err != nil {
|
||||
return "", t.wrapError(err, stderr.String(), args)
|
||||
}
|
||||
|
||||
return strings.TrimSpace(stdout.String()), nil
|
||||
}
|
||||
|
||||
// wrapError wraps tmux errors with context.
|
||||
func (t *Tmux) wrapError(err error, stderr string, args []string) error {
|
||||
stderr = strings.TrimSpace(stderr)
|
||||
|
||||
// Detect specific error types
|
||||
if strings.Contains(stderr, "no server running") ||
|
||||
strings.Contains(stderr, "error connecting to") {
|
||||
return ErrNoServer
|
||||
}
|
||||
if strings.Contains(stderr, "duplicate session") {
|
||||
return ErrSessionExists
|
||||
}
|
||||
if strings.Contains(stderr, "session not found") ||
|
||||
strings.Contains(stderr, "can't find session") {
|
||||
return ErrSessionNotFound
|
||||
}
|
||||
|
||||
if stderr != "" {
|
||||
return fmt.Errorf("tmux %s: %s", args[0], stderr)
|
||||
}
|
||||
return fmt.Errorf("tmux %s: %w", args[0], err)
|
||||
}
|
||||
|
||||
// NewSession creates a new detached tmux session.
|
||||
func (t *Tmux) NewSession(name, workDir string) error {
|
||||
args := []string{"new-session", "-d", "-s", name}
|
||||
if workDir != "" {
|
||||
args = append(args, "-c", workDir)
|
||||
}
|
||||
_, err := t.run(args...)
|
||||
return err
|
||||
}
|
||||
|
||||
// KillSession terminates a tmux session.
|
||||
func (t *Tmux) KillSession(name string) error {
|
||||
_, err := t.run("kill-session", "-t", name)
|
||||
return err
|
||||
}
|
||||
|
||||
// HasSession checks if a session exists.
|
||||
func (t *Tmux) HasSession(name string) (bool, error) {
|
||||
_, err := t.run("has-session", "-t", name)
|
||||
if err != nil {
|
||||
if errors.Is(err, ErrSessionNotFound) || errors.Is(err, ErrNoServer) {
|
||||
return false, nil
|
||||
}
|
||||
return false, err
|
||||
}
|
||||
return true, nil
|
||||
}
|
||||
|
||||
// ListSessions returns all session names.
|
||||
func (t *Tmux) ListSessions() ([]string, error) {
|
||||
out, err := t.run("list-sessions", "-F", "#{session_name}")
|
||||
if err != nil {
|
||||
if errors.Is(err, ErrNoServer) {
|
||||
return nil, nil // No server = no sessions
|
||||
}
|
||||
return nil, err
|
||||
}
|
||||
|
||||
if out == "" {
|
||||
return nil, nil
|
||||
}
|
||||
|
||||
return strings.Split(out, "\n"), nil
|
||||
}
|
||||
|
||||
// SendKeys sends keystrokes to a session.
|
||||
func (t *Tmux) SendKeys(session, keys string) error {
|
||||
_, err := t.run("send-keys", "-t", session, keys, "Enter")
|
||||
return err
|
||||
}
|
||||
|
||||
// SendKeysRaw sends keystrokes without adding Enter.
|
||||
func (t *Tmux) SendKeysRaw(session, keys string) error {
|
||||
_, err := t.run("send-keys", "-t", session, keys)
|
||||
return err
|
||||
}
|
||||
|
||||
// CapturePane captures the visible content of a pane.
|
||||
func (t *Tmux) CapturePane(session string, lines int) (string, error) {
|
||||
return t.run("capture-pane", "-p", "-t", session, "-S", fmt.Sprintf("-%d", lines))
|
||||
}
|
||||
|
||||
// CapturePaneAll captures all scrollback history.
|
||||
func (t *Tmux) CapturePaneAll(session string) (string, error) {
|
||||
return t.run("capture-pane", "-p", "-t", session, "-S", "-")
|
||||
}
|
||||
|
||||
// AttachSession attaches to an existing session.
|
||||
// Note: This replaces the current process with tmux attach.
|
||||
func (t *Tmux) AttachSession(session string) error {
|
||||
_, err := t.run("attach-session", "-t", session)
|
||||
return err
|
||||
}
|
||||
|
||||
// SelectWindow selects a window by index.
|
||||
func (t *Tmux) SelectWindow(session string, index int) error {
|
||||
_, err := t.run("select-window", "-t", fmt.Sprintf("%s:%d", session, index))
|
||||
return err
|
||||
}
|
||||
|
||||
// SetEnvironment sets an environment variable in the session.
|
||||
func (t *Tmux) SetEnvironment(session, key, value string) error {
|
||||
_, err := t.run("set-environment", "-t", session, key, value)
|
||||
return err
|
||||
}
|
||||
|
||||
// GetEnvironment gets an environment variable from the session.
|
||||
func (t *Tmux) GetEnvironment(session, key string) (string, error) {
|
||||
out, err := t.run("show-environment", "-t", session, key)
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
// Output format: KEY=value
|
||||
parts := strings.SplitN(out, "=", 2)
|
||||
if len(parts) != 2 {
|
||||
return "", nil
|
||||
}
|
||||
return parts[1], nil
|
||||
}
|
||||
|
||||
// RenameSession renames a session.
|
||||
func (t *Tmux) RenameSession(oldName, newName string) error {
|
||||
_, err := t.run("rename-session", "-t", oldName, newName)
|
||||
return err
|
||||
}
|
||||
|
||||
// SessionInfo contains information about a tmux session.
|
||||
type SessionInfo struct {
|
||||
Name string
|
||||
Windows int
|
||||
Created string
|
||||
Attached bool
|
||||
}
|
||||
|
||||
// GetSessionInfo returns detailed information about a session.
|
||||
func (t *Tmux) GetSessionInfo(name string) (*SessionInfo, error) {
|
||||
format := "#{session_name}|#{session_windows}|#{session_created_string}|#{session_attached}"
|
||||
out, err := t.run("list-sessions", "-F", format, "-f", fmt.Sprintf("#{==:#{session_name},%s}", name))
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if out == "" {
|
||||
return nil, ErrSessionNotFound
|
||||
}
|
||||
|
||||
parts := strings.Split(out, "|")
|
||||
if len(parts) != 4 {
|
||||
return nil, fmt.Errorf("unexpected session info format: %s", out)
|
||||
}
|
||||
|
||||
windows := 0
|
||||
fmt.Sscanf(parts[1], "%d", &windows)
|
||||
|
||||
return &SessionInfo{
|
||||
Name: parts[0],
|
||||
Windows: windows,
|
||||
Created: parts[2],
|
||||
Attached: parts[3] == "1",
|
||||
}, nil
|
||||
}
|
||||
211
internal/tmux/tmux_test.go
Normal file
211
internal/tmux/tmux_test.go
Normal file
@@ -0,0 +1,211 @@
|
||||
package tmux
|
||||
|
||||
import (
|
||||
"os/exec"
|
||||
"strings"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func hasTmux() bool {
|
||||
_, err := exec.LookPath("tmux")
|
||||
return err == nil
|
||||
}
|
||||
|
||||
func TestListSessionsNoServer(t *testing.T) {
|
||||
if !hasTmux() {
|
||||
t.Skip("tmux not installed")
|
||||
}
|
||||
|
||||
tm := NewTmux()
|
||||
sessions, err := tm.ListSessions()
|
||||
// Should not error even if no server running
|
||||
if err != nil {
|
||||
t.Fatalf("ListSessions: %v", err)
|
||||
}
|
||||
// Result may be nil or empty slice
|
||||
_ = sessions
|
||||
}
|
||||
|
||||
func TestHasSessionNoServer(t *testing.T) {
|
||||
if !hasTmux() {
|
||||
t.Skip("tmux not installed")
|
||||
}
|
||||
|
||||
tm := NewTmux()
|
||||
has, err := tm.HasSession("nonexistent-session-xyz")
|
||||
if err != nil {
|
||||
t.Fatalf("HasSession: %v", err)
|
||||
}
|
||||
if has {
|
||||
t.Error("expected session to not exist")
|
||||
}
|
||||
}
|
||||
|
||||
func TestSessionLifecycle(t *testing.T) {
|
||||
if !hasTmux() {
|
||||
t.Skip("tmux not installed")
|
||||
}
|
||||
|
||||
tm := NewTmux()
|
||||
sessionName := "gt-test-session-" + t.Name()
|
||||
|
||||
// Clean up any existing session
|
||||
tm.KillSession(sessionName)
|
||||
|
||||
// Create session
|
||||
if err := tm.NewSession(sessionName, ""); err != nil {
|
||||
t.Fatalf("NewSession: %v", err)
|
||||
}
|
||||
defer tm.KillSession(sessionName)
|
||||
|
||||
// Verify exists
|
||||
has, err := tm.HasSession(sessionName)
|
||||
if err != nil {
|
||||
t.Fatalf("HasSession: %v", err)
|
||||
}
|
||||
if !has {
|
||||
t.Error("expected session to exist after creation")
|
||||
}
|
||||
|
||||
// List should include it
|
||||
sessions, err := tm.ListSessions()
|
||||
if err != nil {
|
||||
t.Fatalf("ListSessions: %v", err)
|
||||
}
|
||||
found := false
|
||||
for _, s := range sessions {
|
||||
if s == sessionName {
|
||||
found = true
|
||||
break
|
||||
}
|
||||
}
|
||||
if !found {
|
||||
t.Error("session not found in list")
|
||||
}
|
||||
|
||||
// Kill session
|
||||
if err := tm.KillSession(sessionName); err != nil {
|
||||
t.Fatalf("KillSession: %v", err)
|
||||
}
|
||||
|
||||
// Verify gone
|
||||
has, err = tm.HasSession(sessionName)
|
||||
if err != nil {
|
||||
t.Fatalf("HasSession after kill: %v", err)
|
||||
}
|
||||
if has {
|
||||
t.Error("expected session to not exist after kill")
|
||||
}
|
||||
}
|
||||
|
||||
func TestDuplicateSession(t *testing.T) {
|
||||
if !hasTmux() {
|
||||
t.Skip("tmux not installed")
|
||||
}
|
||||
|
||||
tm := NewTmux()
|
||||
sessionName := "gt-test-dup-" + t.Name()
|
||||
|
||||
// Clean up any existing session
|
||||
tm.KillSession(sessionName)
|
||||
|
||||
// Create session
|
||||
if err := tm.NewSession(sessionName, ""); err != nil {
|
||||
t.Fatalf("NewSession: %v", err)
|
||||
}
|
||||
defer tm.KillSession(sessionName)
|
||||
|
||||
// Try to create duplicate
|
||||
err := tm.NewSession(sessionName, "")
|
||||
if err != ErrSessionExists {
|
||||
t.Errorf("expected ErrSessionExists, got %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestSendKeysAndCapture(t *testing.T) {
|
||||
if !hasTmux() {
|
||||
t.Skip("tmux not installed")
|
||||
}
|
||||
|
||||
tm := NewTmux()
|
||||
sessionName := "gt-test-keys-" + t.Name()
|
||||
|
||||
// Clean up any existing session
|
||||
tm.KillSession(sessionName)
|
||||
|
||||
// Create session
|
||||
if err := tm.NewSession(sessionName, ""); err != nil {
|
||||
t.Fatalf("NewSession: %v", err)
|
||||
}
|
||||
defer tm.KillSession(sessionName)
|
||||
|
||||
// Send echo command
|
||||
if err := tm.SendKeys(sessionName, "echo HELLO_TEST_MARKER"); err != nil {
|
||||
t.Fatalf("SendKeys: %v", err)
|
||||
}
|
||||
|
||||
// Give it a moment to execute
|
||||
// In real tests you'd wait for output, but for basic test we just capture
|
||||
output, err := tm.CapturePane(sessionName, 50)
|
||||
if err != nil {
|
||||
t.Fatalf("CapturePane: %v", err)
|
||||
}
|
||||
|
||||
// Should contain our marker (might not if shell is slow, but usually works)
|
||||
if !strings.Contains(output, "echo HELLO_TEST_MARKER") {
|
||||
t.Logf("captured output: %s", output)
|
||||
// Don't fail, just note - timing issues possible
|
||||
}
|
||||
}
|
||||
|
||||
func TestGetSessionInfo(t *testing.T) {
|
||||
if !hasTmux() {
|
||||
t.Skip("tmux not installed")
|
||||
}
|
||||
|
||||
tm := NewTmux()
|
||||
sessionName := "gt-test-info-" + t.Name()
|
||||
|
||||
// Clean up any existing session
|
||||
tm.KillSession(sessionName)
|
||||
|
||||
// Create session
|
||||
if err := tm.NewSession(sessionName, ""); err != nil {
|
||||
t.Fatalf("NewSession: %v", err)
|
||||
}
|
||||
defer tm.KillSession(sessionName)
|
||||
|
||||
info, err := tm.GetSessionInfo(sessionName)
|
||||
if err != nil {
|
||||
t.Fatalf("GetSessionInfo: %v", err)
|
||||
}
|
||||
|
||||
if info.Name != sessionName {
|
||||
t.Errorf("Name = %q, want %q", info.Name, sessionName)
|
||||
}
|
||||
if info.Windows < 1 {
|
||||
t.Errorf("Windows = %d, want >= 1", info.Windows)
|
||||
}
|
||||
}
|
||||
|
||||
func TestWrapError(t *testing.T) {
|
||||
tm := NewTmux()
|
||||
|
||||
tests := []struct {
|
||||
stderr string
|
||||
want error
|
||||
}{
|
||||
{"no server running on /tmp/tmux-...", ErrNoServer},
|
||||
{"error connecting to /tmp/tmux-...", ErrNoServer},
|
||||
{"duplicate session: test", ErrSessionExists},
|
||||
{"session not found: test", ErrSessionNotFound},
|
||||
{"can't find session: test", ErrSessionNotFound},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
err := tm.wrapError(nil, tt.stderr, []string{"test"})
|
||||
if err != tt.want {
|
||||
t.Errorf("wrapError(%q) = %v, want %v", tt.stderr, err, tt.want)
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user