@wangyaoshen/remux 0.3.8-dev.a8ceb0c

package/tui/client/connection.go

@@ -0,0 +1,342 @@
+// Package client implements the WebSocket client for connecting to remux servers.
+// It handles authentication, terminal I/O streaming, and control messages.
+package client
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/url"
+	"sync"
+	"time"
+
+	"github.com/gorilla/websocket"
+)
+
+// Host represents a saved remux server connection.
+type Host struct {
+	Name  string `json:"name"`
+	URL   string `json:"url"`
+	Token string `json:"token"`
+}
+
+// Session represents a remote terminal session on a host.
+type Session struct {
+	HostName string
+	Name     string
+	Attached bool
+	Windows  int
+}
+
+// ControlMessage is a message sent/received on the control WebSocket.
+type ControlMessage struct {
+	Type             string           `json:"type"`
+	ClientID         string           `json:"clientId,omitempty"`
+	RequiresPassword bool             `json:"requiresPassword,omitempty"`
+	Session          string           `json:"session,omitempty"`
+	Sessions         []SessionSummary `json:"sessions,omitempty"`
+	State            *StateSnapshot   `json:"state,omitempty"`
+	Reason           string           `json:"reason,omitempty"`
+	Message          string           `json:"message,omitempty"`
+	PaneID           string           `json:"paneId,omitempty"`
+	Text             string           `json:"text,omitempty"`
+	Lines            int              `json:"lines,omitempty"`
+	Name             string           `json:"name,omitempty"`
+}
+
+// SessionSummary matches remux's TmuxSessionSummary.
+type SessionSummary struct {
+	Name     string `json:"name"`
+	Attached bool   `json:"attached"`
+	Windows  int    `json:"windows"`
+}
+
+// StateSnapshot matches remux's TmuxStateSnapshot.
+type StateSnapshot struct {
+	Sessions   []SessionState `json:"sessions"`
+	CapturedAt string         `json:"capturedAt"`
+}
+
+// SessionState matches remux's TmuxSessionState.
+type SessionState struct {
+	Name         string        `json:"name"`
+	Attached     bool          `json:"attached"`
+	Windows      int           `json:"windows"`
+	WindowStates []WindowState `json:"windowStates"`
+}
+
+// WindowState matches remux's TmuxWindowState.
+type WindowState struct {
+	Index     int         `json:"index"`
+	Name      string      `json:"name"`
+	Active    bool        `json:"active"`
+	PaneCount int         `json:"paneCount"`
+	Panes     []PaneState `json:"panes"`
+}
+
+// PaneState matches remux's TmuxPaneState.
+type PaneState struct {
+	Index          int    `json:"index"`
+	ID             string `json:"id"`
+	CurrentCommand string `json:"currentCommand"`
+	Active         bool   `json:"active"`
+	Width          int    `json:"width"`
+	Height         int    `json:"height"`
+	Zoomed         bool   `json:"zoomed"`
+}
+
+// Connection manages a WebSocket connection to a single remux server.
+type Connection struct {
+	host     Host
+	password string
+
+	controlConn  *websocket.Conn
+	terminalConn *websocket.Conn
+	clientID     string
+
+	// Callbacks
+	onTerminalData func(data []byte)
+	onStateUpdate  func(state *StateSnapshot)
+	onSessionList  func(sessions []SessionSummary)
+	onAttached     func(session string)
+	onError        func(err error)
+
+	mu     sync.Mutex
+	closed bool
+}
+
+// NewConnection creates a new connection to a remux host.
+func NewConnection(host Host, password string) *Connection {
+	return &Connection{
+		host:     host,
+		password: password,
+	}
+}
+
+// OnTerminalData sets the callback for terminal output data.
+func (c *Connection) OnTerminalData(fn func(data []byte)) { c.onTerminalData = fn }
+
+// OnStateUpdate sets the callback for state snapshot updates.
+func (c *Connection) OnStateUpdate(fn func(state *StateSnapshot)) { c.onStateUpdate = fn }
+
+// OnSessionList sets the callback for session picker events.
+func (c *Connection) OnSessionList(fn func(sessions []SessionSummary)) { c.onSessionList = fn }
+
+// OnAttached sets the callback for successful session attachment.
+func (c *Connection) OnAttached(fn func(session string)) { c.onAttached = fn }
+
+// OnError sets the callback for connection errors.
+func (c *Connection) OnError(fn func(err error)) { c.onError = fn }
+
+// Connect establishes the control and terminal WebSocket connections.
+func (c *Connection) Connect() error {
+	controlURL, err := c.buildWSURL("/ws/control")
+	if err != nil {
+		return fmt.Errorf("build control URL: %w", err)
+	}
+
+	dialer := websocket.Dialer{
+		HandshakeTimeout: 10 * time.Second,
+	}
+
+	c.controlConn, _, err = dialer.Dial(controlURL, nil)
+	if err != nil {
+		return fmt.Errorf("connect control: %w", err)
+	}
+
+	// Authenticate on control channel.
+	authMsg := map[string]interface{}{
+		"type":  "auth",
+		"token": c.host.Token,
+	}
+	if c.password != "" {
+		authMsg["password"] = c.password
+	}
+	if err := c.controlConn.WriteJSON(authMsg); err != nil {
+		return fmt.Errorf("send auth: %w", err)
+	}
+
+	// Read auth response.
+	var authResp ControlMessage
+	if err := c.controlConn.ReadJSON(&authResp); err != nil {
+		return fmt.Errorf("read auth response: %w", err)
+	}
+	if authResp.Type == "auth_error" {
+		return fmt.Errorf("auth failed: %s", authResp.Reason)
+	}
+	if authResp.Type != "auth_ok" {
+		return fmt.Errorf("unexpected auth response: %s", authResp.Type)
+	}
+	c.clientID = authResp.ClientID
+
+	// Connect terminal WebSocket.
+	terminalURL, err := c.buildWSURL("/ws/terminal")
+	if err != nil {
+		return fmt.Errorf("build terminal URL: %w", err)
+	}
+
+	c.terminalConn, _, err = dialer.Dial(terminalURL, nil)
+	if err != nil {
+		return fmt.Errorf("connect terminal: %w", err)
+	}
+
+	// Authenticate on terminal channel.
+	termAuthMsg := map[string]interface{}{
+		"type":     "auth",
+		"token":    c.host.Token,
+		"clientId": c.clientID,
+	}
+	if c.password != "" {
+		termAuthMsg["password"] = c.password
+	}
+	if err := c.terminalConn.WriteJSON(termAuthMsg); err != nil {
+		return fmt.Errorf("send terminal auth: %w", err)
+	}
+
+	// Start read loops.
+	go c.readControlLoop()
+	go c.readTerminalLoop()
+
+	return nil
+}
+
+// SelectSession sends a select_session control message.
+func (c *Connection) SelectSession(session string) error {
+	return c.sendControl(map[string]interface{}{
+		"type":    "select_session",
+		"session": session,
+	})
+}
+
+// SendInput writes raw terminal input to the terminal WebSocket.
+func (c *Connection) SendInput(data string) error {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	if c.terminalConn == nil {
+		return fmt.Errorf("terminal not connected")
+	}
+	return c.terminalConn.WriteMessage(websocket.TextMessage, []byte(data))
+}
+
+// SendResize sends a resize message to the terminal WebSocket.
+func (c *Connection) SendResize(cols, rows int) error {
+	msg, _ := json.Marshal(map[string]interface{}{
+		"type": "resize",
+		"cols": cols,
+		"rows": rows,
+	})
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	if c.terminalConn == nil {
+		return fmt.Errorf("terminal not connected")
+	}
+	return c.terminalConn.WriteMessage(websocket.TextMessage, msg)
+}
+
+// Close disconnects both WebSocket connections.
+func (c *Connection) Close() {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	c.closed = true
+	if c.controlConn != nil {
+		c.controlConn.Close()
+	}
+	if c.terminalConn != nil {
+		c.terminalConn.Close()
+	}
+}
+
+// ClientID returns the assigned client ID.
+func (c *Connection) ClientID() string {
+	return c.clientID
+}
+
+func (c *Connection) sendControl(msg map[string]interface{}) error {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	if c.controlConn == nil {
+		return fmt.Errorf("control not connected")
+	}
+	return c.controlConn.WriteJSON(msg)
+}
+
+func (c *Connection) readControlLoop() {
+	for {
+		_, raw, err := c.controlConn.ReadMessage()
+		if err != nil {
+			c.mu.Lock()
+			closed := c.closed
+			c.mu.Unlock()
+			if !closed && c.onError != nil {
+				c.onError(fmt.Errorf("control read: %w", err))
+			}
+			return
+		}
+
+		var msg ControlMessage
+		if err := json.Unmarshal(raw, &msg); err != nil {
+			continue
+		}
+
+		switch msg.Type {
+		case "tmux_state":
+			if c.onStateUpdate != nil && msg.State != nil {
+				c.onStateUpdate(msg.State)
+			}
+		case "session_picker":
+			if c.onSessionList != nil {
+				c.onSessionList(msg.Sessions)
+			}
+		case "attached":
+			if c.onAttached != nil {
+				c.onAttached(msg.Session)
+			}
+		case "error":
+			if c.onError != nil {
+				c.onError(fmt.Errorf("server error: %s", msg.Message))
+			}
+		}
+	}
+}
+
+func (c *Connection) readTerminalLoop() {
+	for {
+		msgType, data, err := c.terminalConn.ReadMessage()
+		if err != nil {
+			c.mu.Lock()
+			closed := c.closed
+			c.mu.Unlock()
+			if !closed && c.onError != nil {
+				c.onError(fmt.Errorf("terminal read: %w", err))
+			}
+			return
+		}
+
+		if msgType == websocket.TextMessage || msgType == websocket.BinaryMessage {
+			if c.onTerminalData != nil {
+				c.onTerminalData(data)
+			}
+		}
+	}
+}
+
+func (c *Connection) buildWSURL(path string) (string, error) {
+	u, err := url.Parse(c.host.URL)
+	if err != nil {
+		return "", err
+	}
+
+	switch u.Scheme {
+	case "https":
+		u.Scheme = "wss"
+	default:
+		u.Scheme = "ws"
+	}
+
+	u.Path = path
+	q := u.Query()
+	q.Set("token", c.host.Token)
+	u.RawQuery = q.Encode()
+
+	return u.String(), nil
+}
+

package/tui/client/host_manager.go

@@ -0,0 +1,141 @@
+// Package client implements multi-host connection management.
+package client
+
+import (
+	"fmt"
+	"sync"
+)
+
+// HostManager manages connections to multiple remux hosts and provides
+// a unified view of all sessions across hosts.
+type HostManager struct {
+	mu          sync.RWMutex
+	connections map[string]*Connection // keyed by host name
+	hosts       []Host
+	sessions    []Session // aggregated from all hosts
+	onChange    func()    // called when session list changes
+}
+
+// NewHostManager creates a new multi-host manager.
+func NewHostManager() *HostManager {
+	return &HostManager{
+		connections: make(map[string]*Connection),
+	}
+}
+
+// OnChange sets a callback invoked when the aggregated session list changes.
+func (m *HostManager) OnChange(fn func()) {
+	m.onChange = fn
+}
+
+// AddHost connects to a remux host and starts tracking its sessions.
+func (m *HostManager) AddHost(host Host, password string) error {
+	conn := NewConnection(host, password)
+
+	conn.OnStateUpdate(func(state *StateSnapshot) {
+		m.mu.Lock()
+		m.updateSessionsFromState(host.Name, state)
+		m.mu.Unlock()
+		if m.onChange != nil {
+			m.onChange()
+		}
+	})
+
+	conn.OnSessionList(func(sessions []SessionSummary) {
+		m.mu.Lock()
+		m.updateSessionsFromList(host.Name, sessions)
+		m.mu.Unlock()
+		if m.onChange != nil {
+			m.onChange()
+		}
+	})
+
+	if err := conn.Connect(); err != nil {
+		return fmt.Errorf("connect to %s: %w", host.Name, err)
+	}
+
+	m.mu.Lock()
+	m.connections[host.Name] = conn
+	m.hosts = append(m.hosts, host)
+	m.mu.Unlock()
+
+	return nil
+}
+
+// GetConnection returns the connection for a host.
+func (m *HostManager) GetConnection(hostName string) *Connection {
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+	return m.connections[hostName]
+}
+
+// Sessions returns the current aggregated session list.
+func (m *HostManager) Sessions() []Session {
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+	result := make([]Session, len(m.sessions))
+	copy(result, m.sessions)
+	return result
+}
+
+// Hosts returns the list of connected hosts.
+func (m *HostManager) Hosts() []Host {
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+	result := make([]Host, len(m.hosts))
+	copy(result, m.hosts)
+	return result
+}
+
+// Close disconnects from all hosts.
+func (m *HostManager) Close() {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	for _, conn := range m.connections {
+		conn.Close()
+	}
+	m.connections = make(map[string]*Connection)
+}
+
+func (m *HostManager) updateSessionsFromState(hostName string, state *StateSnapshot) {
+	// Remove old sessions for this host.
+	filtered := m.sessions[:0]
+	for _, s := range m.sessions {
+		if s.HostName != hostName {
+			filtered = append(filtered, s)
+		}
+	}
+
+	// Add new sessions from state.
+	for _, ss := range state.Sessions {
+		filtered = append(filtered, Session{
+			HostName: hostName,
+			Name:     ss.Name,
+			Attached: ss.Attached,
+			Windows:  ss.Windows,
+		})
+	}
+
+	m.sessions = filtered
+}
+
+func (m *HostManager) updateSessionsFromList(hostName string, sessions []SessionSummary) {
+	filtered := m.sessions[:0]
+	for _, s := range m.sessions {
+		if s.HostName != hostName {
+			filtered = append(filtered, s)
+		}
+	}
+
+	for _, ss := range sessions {
+		filtered = append(filtered, Session{
+			HostName: hostName,
+			Name:     ss.Name,
+			Attached: ss.Attached,
+			Windows:  ss.Windows,
+		})
+	}
+
+	m.sessions = filtered
+}
+

package/tui/config/cache.go

@@ -0,0 +1,81 @@
+package config
+
+import (
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"sync"
+)
+
+// ScrollbackCache caches terminal scrollback per session for instant
+// re-scroll and offline viewing. Stored in ~/.remux/cache/<host>/<session>.json.
+type ScrollbackCache struct {
+	mu       sync.Mutex
+	cacheDir string
+}
+
+// CachedSession is the on-disk format for cached session data.
+type CachedSession struct {
+	Lines   []string `json:"lines"`
+	LastSeq int      `json:"lastSeq"`
+	Cursor  [2]int   `json:"cursor"`
+	Cols    int      `json:"cols"`
+	Rows    int      `json:"rows"`
+}
+
+// NewScrollbackCache creates a cache rooted at ~/.remux/cache/.
+func NewScrollbackCache() *ScrollbackCache {
+	home, _ := os.UserHomeDir()
+	return &ScrollbackCache{
+		cacheDir: filepath.Join(home, ".remux", "cache"),
+	}
+}
+
+// Save writes cached session data to disk.
+func (c *ScrollbackCache) Save(hostName, sessionName string, data *CachedSession) error {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+
+	dir := filepath.Join(c.cacheDir, sanitize(hostName))
+	if err := os.MkdirAll(dir, 0700); err != nil {
+		return err
+	}
+
+	bytes, err := json.Marshal(data)
+	if err != nil {
+		return err
+	}
+
+	return os.WriteFile(filepath.Join(dir, sanitize(sessionName)+".json"), bytes, 0600)
+}
+
+// Load reads cached session data from disk.
+func (c *ScrollbackCache) Load(hostName, sessionName string) (*CachedSession, error) {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+
+	path := filepath.Join(c.cacheDir, sanitize(hostName), sanitize(sessionName)+".json")
+	data, err := os.ReadFile(path)
+	if err != nil {
+		return nil, err
+	}
+
+	var cached CachedSession
+	if err := json.Unmarshal(data, &cached); err != nil {
+		return nil, err
+	}
+
+	return &cached, nil
+}
+
+func sanitize(s string) string {
+	result := make([]byte, 0, len(s))
+	for _, c := range []byte(s) {
+		if (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9') || c == '-' || c == '_' || c == '.' {
+			result = append(result, c)
+		} else {
+			result = append(result, '_')
+		}
+	}
+	return string(result)
+}

package/tui/config/config.go

@@ -0,0 +1,53 @@
+// Package config handles loading and saving host configurations.
+package config
+
+import (
+	"encoding/json"
+	"os"
+	"path/filepath"
+
+	"github.com/eisber/remux/tui/client"
+)
+
+// ConfigFile is the structure stored in ~/.remux/hosts.json.
+type ConfigFile struct {
+	Hosts []client.Host `json:"hosts"`
+}
+
+// DefaultConfigPath returns the default config file location.
+func DefaultConfigPath() string {
+	home, _ := os.UserHomeDir()
+	return filepath.Join(home, ".remux", "hosts.json")
+}
+
+// Load reads hosts from the config file.
+func Load(path string) (*ConfigFile, error) {
+	data, err := os.ReadFile(path)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return &ConfigFile{}, nil
+		}
+		return nil, err
+	}
+
+	var cfg ConfigFile
+	if err := json.Unmarshal(data, &cfg); err != nil {
+		return nil, err
+	}
+	return &cfg, nil
+}
+
+// Save writes hosts to the config file.
+func Save(path string, cfg *ConfigFile) error {
+	dir := filepath.Dir(path)
+	if err := os.MkdirAll(dir, 0700); err != nil {
+		return err
+	}
+
+	data, err := json.MarshalIndent(cfg, "", "  ")
+	if err != nil {
+		return err
+	}
+	return os.WriteFile(path, data, 0600)
+}
+

package/tui/config/config_test.go

@@ -0,0 +1,89 @@
+package config
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/eisber/remux/tui/client"
+)
+
+func TestLoadNonExistent(t *testing.T) {
+	cfg, err := Load(filepath.Join(t.TempDir(), "nonexistent.json"))
+	if err != nil {
+		t.Fatalf("expected nil error for missing file, got: %v", err)
+	}
+	if len(cfg.Hosts) != 0 {
+		t.Fatalf("expected 0 hosts, got: %d", len(cfg.Hosts))
+	}
+}
+
+func TestSaveAndLoad(t *testing.T) {
+	dir := t.TempDir()
+	path := filepath.Join(dir, "config", "hosts.json")
+
+	cfg := &ConfigFile{
+		Hosts: []client.Host{
+			{Name: "devbox", URL: "http://localhost:8767", Token: "abc123"},
+			{Name: "cloud", URL: "https://my.devtunnels.ms", Token: "xyz"},
+		},
+	}
+
+	if err := Save(path, cfg); err != nil {
+		t.Fatalf("save failed: %v", err)
+	}
+
+	loaded, err := Load(path)
+	if err != nil {
+		t.Fatalf("load failed: %v", err)
+	}
+
+	if len(loaded.Hosts) != 2 {
+		t.Fatalf("expected 2 hosts, got: %d", len(loaded.Hosts))
+	}
+	if loaded.Hosts[0].Name != "devbox" {
+		t.Fatalf("expected host name 'devbox', got: %s", loaded.Hosts[0].Name)
+	}
+	if loaded.Hosts[1].Token != "xyz" {
+		t.Fatalf("expected token 'xyz', got: %s", loaded.Hosts[1].Token)
+	}
+}
+
+func TestSaveCreatesDirectories(t *testing.T) {
+	dir := t.TempDir()
+	path := filepath.Join(dir, "deep", "nested", "hosts.json")
+
+	cfg := &ConfigFile{Hosts: []client.Host{{Name: "test", URL: "http://localhost", Token: "t"}}}
+	if err := Save(path, cfg); err != nil {
+		t.Fatalf("save failed: %v", err)
+	}
+
+	if _, err := os.Stat(path); os.IsNotExist(err) {
+		t.Fatal("config file was not created")
+	}
+}
+
+func TestSaveFilePermissions(t *testing.T) {
+	if os.Getenv("OS") == "Windows_NT" {
+		t.Skip("file permissions test not reliable on Windows")
+	}
+
+	dir := t.TempDir()
+	path := filepath.Join(dir, "hosts.json")
+
+	cfg := &ConfigFile{Hosts: []client.Host{{Name: "test", URL: "http://localhost", Token: "secret"}}}
+	if err := Save(path, cfg); err != nil {
+		t.Fatalf("save failed: %v", err)
+	}
+
+	info, err := os.Stat(path)
+	if err != nil {
+		t.Fatalf("stat failed: %v", err)
+	}
+
+	perm := info.Mode().Perm()
+	if perm&0077 != 0 {
+		t.Fatalf("config file should not be world/group readable, got: %o", perm)
+	}
+}
+