feat: Implement WebSocket-based SSH terminal functionality and refactor the frontend using the Tabler.io framework.

2026-02-18 00:38:31 +01:00
parent f088a6fba9
commit e68e355e3f
9 changed files with 1068 additions and 229 deletions
@@ -0,0 +1,153 @@
+package webserver
+
+import (
+	"fmt"
+	"log"
+	"net/http"
+
+	serveractions "manage-servers/server-actions"
+
+	"github.com/gorilla/websocket"
+	"golang.org/x/crypto/ssh"
+)
+
+var upgrader = websocket.Upgrader{
+	ReadBufferSize:  1024,
+	WriteBufferSize: 1024,
+	CheckOrigin: func(r *http.Request) bool {
+		return true // Allowing all origins for local tool
+	},
+}
+
+func (ws *WebServer) handleSSH(w http.ResponseWriter, r *http.Request) {
+	serverName := r.URL.Query().Get("name")
+	if serverName == "" {
+		http.Error(w, "Missing server name", http.StatusBadRequest)
+		return
+	}
+
+	var targetServer *serveractions.Server
+	for _, s := range ws.servers {
+		if s.Name == serverName {
+			targetServer = &s
+			break
+		}
+	}
+
+	if targetServer == nil {
+		http.Error(w, "Server not found", http.StatusNotFound)
+		return
+	}
+
+	if targetServer.SSHUser == "" || targetServer.SSHPass == "" {
+		conn, err := upgrader.Upgrade(w, r, nil)
+		if err == nil {
+			conn.WriteMessage(websocket.TextMessage, []byte("\r\n[Error] SSH Credentials missing for this node.\r\nPlease edit the server entry and save with a Username and Password.\r\n"))
+			conn.Close()
+		}
+		return
+	}
+
+	conn, err := upgrader.Upgrade(w, r, nil)
+	if err != nil {
+		log.Printf("Websocket upgrade failed: %v", err)
+		return
+	}
+	defer conn.Close()
+
+	client, err := serveractions.GetSSHClient(*targetServer)
+	if err != nil {
+		conn.WriteMessage(websocket.TextMessage, []byte(fmt.Sprintf("\r\n[Error] SSH Connection failed: %v\r\n", err)))
+		return
+	}
+	defer client.Close()
+
+	session, err := client.NewSession()
+	if err != nil {
+		conn.WriteMessage(websocket.TextMessage, []byte(fmt.Sprintf("\r\n[Error] SSH Session failed: %v\r\n", err)))
+		return
+	}
+	defer session.Close()
+
+	// Request pseudo-terminal
+	modes := ssh.TerminalModes{
+		ssh.ECHO:          1,
+		ssh.TTY_OP_ISPEED: 14400,
+		ssh.TTY_OP_OSPEED: 14400,
+	}
+
+	// Default to 24x80 if not provided
+	rows := 24
+	cols := 80
+	if r.URL.Query().Get("rows") != "" {
+		fmt.Sscanf(r.URL.Query().Get("rows"), "%d", &rows)
+	}
+	if r.URL.Query().Get("cols") != "" {
+		fmt.Sscanf(r.URL.Query().Get("cols"), "%d", &cols)
+	}
+
+	if err := session.RequestPty("xterm-256color", rows, cols, modes); err != nil {
+		conn.WriteMessage(websocket.TextMessage, []byte(fmt.Sprintf("\r\n[Error] Request for PTY failed: %v\r\n", err)))
+		return
+	}
+
+	stdin, err := session.StdinPipe()
+	if err != nil {
+		return
+	}
+	stdout, err := session.StdoutPipe()
+	if err != nil {
+		return
+	}
+	stderr, err := session.StderrPipe()
+	if err != nil {
+		return
+	}
+
+	if err := session.Shell(); err != nil {
+		conn.WriteMessage(websocket.TextMessage, []byte(fmt.Sprintf("\r\n[Error] Shell start failed: %v\r\n", err)))
+		return
+	}
+
+	// Proxy stdout/stderr to WebSocket
+	go func() {
+		buf := make([]byte, 1024)
+		for {
+			n, err := stdout.Read(buf)
+			if n > 0 {
+				if err := conn.WriteMessage(websocket.TextMessage, buf[:n]); err != nil {
+					return
+				}
+			}
+			if err != nil {
+				return
+			}
+		}
+	}()
+
+	go func() {
+		buf := make([]byte, 1024)
+		for {
+			n, err := stderr.Read(buf)
+			if n > 0 {
+				if err := conn.WriteMessage(websocket.TextMessage, buf[:n]); err != nil {
+					return
+				}
+			}
+			if err != nil {
+				return
+			}
+		}
+	}()
+
+	// Proxy WebSocket to stdin
+	for {
+		_, message, err := conn.ReadMessage()
+		if err != nil {
+			break
+		}
+		if _, err := stdin.Write(message); err != nil {
+			break
+		}
+	}
+}
@@ -24,6 +24,8 @@ func StartWebServer(servers []serveractions.Server) {
 	http.HandleFunc("/shutdown", ws.handleShutdownServer)
 	http.HandleFunc("/reboot", ws.handleRebootServer)
 	http.HandleFunc("/status", ws.handleStatus)
+	http.HandleFunc("/find-mac", ws.handleFindMac)
+	http.HandleFunc("/ssh", ws.handleSSH)

 	if err := http.ListenAndServe(":8080", nil); err != nil {
 		fmt.Printf("Error starting server: %v\n", err)
@@ -31,15 +33,19 @@ func StartWebServer(servers []serveractions.Server) {
 }

 func (ws *WebServer) handleRoot(w http.ResponseWriter, r *http.Request) {
+	serveractions.LogDebug("Handling root request: %s %s", r.Method, r.URL.Path)
 	http.ServeFile(w, r, "index.html")
 }

 func (ws *WebServer) handleServers(w http.ResponseWriter, r *http.Request) {
+	serveractions.LogDebug("Handling /servers request: %s", r.Method)
 	switch r.Method {
 	case http.MethodGet:
 		ws.getServers(w, r)
 	case http.MethodPost:
 		ws.addServer(w, r)
+	case http.MethodPut:
+		ws.updateServer(w, r)
 	case http.MethodDelete:
 		ws.deleteServer(w, r)
 	default:
@@ -52,6 +58,42 @@ func (ws *WebServer) getServers(w http.ResponseWriter, r *http.Request) {
 	json.NewEncoder(w).Encode(ws.servers)
 }

+func (ws *WebServer) updateServer(w http.ResponseWriter, r *http.Request) {
+	oldName := r.URL.Query().Get("oldName")
+	if oldName == "" {
+		http.Error(w, "Missing old server name", http.StatusBadRequest)
+		return
+	}
+
+	var updatedServer serveractions.Server
+	if err := json.NewDecoder(r.Body).Decode(&updatedServer); err != nil {
+		http.Error(w, "Invalid request body", http.StatusBadRequest)
+		return
+	}
+
+	found := false
+	for i, server := range ws.servers {
+		if server.Name == oldName {
+			ws.servers[i] = updatedServer
+			found = true
+			break
+		}
+	}
+
+	if !found {
+		http.Error(w, "Server not found", http.StatusNotFound)
+		return
+	}
+
+	viper.Set("servers", ws.servers)
+	if err := viper.WriteConfig(); err != nil {
+		http.Error(w, fmt.Sprintf("Error writing config file: %v", err), http.StatusInternalServerError)
+		return
+	}
+
+	w.WriteHeader(http.StatusOK)
+}
+
 func (ws *WebServer) addServer(w http.ResponseWriter, r *http.Request) {
 	var newServer serveractions.Server
 	if err := json.NewDecoder(r.Body).Decode(&newServer); err != nil {
@@ -143,6 +185,7 @@ func (ws *WebServer) handleRebootServer(w http.ResponseWriter, r *http.Request)

 func (ws *WebServer) handleStatus(w http.ResponseWriter, r *http.Request) {
 	serverName := r.URL.Query().Get("name")
+	serveractions.LogDebug("Checking status for server: %s", serverName)
 	if serverName == "" {
 		http.Error(w, "Missing server name", http.StatusBadRequest)
 		return
@@ -162,3 +205,36 @@ func (ws *WebServer) handleStatus(w http.ResponseWriter, r *http.Request) {

 	http.Error(w, "Server not found", http.StatusNotFound)
 }
+
+func (ws *WebServer) handleFindMac(w http.ResponseWriter, r *http.Request) {
+	ip := r.URL.Query().Get("ip")
+	user := r.URL.Query().Get("user")
+	pass := r.URL.Query().Get("pass")
+
+	serveractions.LogDebug("Handling /find-mac request for IP: %s (SSH provided: %v)", ip, user != "")
+	if ip == "" {
+		http.Error(w, "Missing IP address", http.StatusBadRequest)
+		return
+	}
+
+	// Try ARP first
+	mac, err := serveractions.GetMacAddress(ip)
+	if err != nil {
+		serveractions.LogDebug("ARP lookup failed for %s: %v. Trying SSH fallback...", ip, err)
+		// Try SSH fallback if credentials are provided
+		if user != "" && pass != "" {
+			mac, err = serveractions.GetMacAddressSSH(ip, user, pass)
+			if err != nil {
+				serveractions.LogDebug("SSH lookup also failed for %s: %v", ip, err)
+				http.Error(w, "MAC address not found via ARP or SSH", http.StatusNotFound)
+				return
+			}
+		} else {
+			serveractions.LogDebug("No SSH credentials for fallback for %s", ip)
+			http.Error(w, "MAC address not found in local network. Please provide SSH credentials for remote lookup.", http.StatusNotFound)
+			return
+		}
+	}
+
+	w.Write([]byte(mac))
+}