feat: add supervisor prototype with embedded frontend

internal/httpserver/handlers/ws_terminal.go

@@ -0,0 +1,155 @@
+package handlers
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"time"
+
+	"github.com/gorilla/websocket"
+
+	"supervisor/internal/domain"
+	"supervisor/internal/ws"
+)
+
+type WSTerminalHandler struct {
+	manager  SessionService
+	upgrader websocket.Upgrader
+}
+
+func NewWSTerminalHandler(manager SessionService) *WSTerminalHandler {
+	return &WSTerminalHandler{
+		manager: manager,
+		upgrader: websocket.Upgrader{
+			CheckOrigin: func(_ *http.Request) bool { return true },
+		},
+	}
+}
+
+func (h *WSTerminalHandler) Handle(w http.ResponseWriter, r *http.Request) {
+	sessionID := r.PathValue("id")
+	current, err := h.manager.GetSession(r.Context(), sessionID)
+	if err != nil {
+		writeError(w, http.StatusNotFound, err)
+		return
+	}
+
+	conn, err := h.upgrader.Upgrade(w, r, nil)
+	if err != nil {
+		return
+	}
+	defer conn.Close()
+
+	events, cancel, err := h.manager.Subscribe(sessionID)
+	if err != nil {
+		_ = conn.WriteJSON(errorEnvelope(sessionID, err.Error()))
+		return
+	}
+	defer cancel()
+
+	if err := conn.WriteJSON(map[string]any{
+		"type":    string(domain.EventSessionStatus),
+		"session": sessionID,
+		"payload": ws.SessionStatusPayload{Status: string(current.Status), ExitCode: current.ExitCode},
+	}); err != nil {
+		return
+	}
+
+	scrollback, _ := h.manager.Scrollback(sessionID)
+	if len(scrollback) > 0 {
+		if err := conn.WriteJSON(map[string]any{
+			"type":    string(domain.EventTerminalOutput),
+			"session": sessionID,
+			"payload": ws.TerminalOutputPayload{Data: string(scrollback)},
+		}); err != nil {
+			return
+		}
+	}
+
+	ctx, stop := context.WithCancel(r.Context())
+	defer stop()
+
+	readErr := make(chan error, 1)
+	go func() {
+		readErr <- h.readLoop(ctx, conn, sessionID)
+	}()
+
+	for {
+		select {
+		case err := <-readErr:
+			if err == nil || websocket.IsCloseError(err, websocket.CloseNormalClosure, websocket.CloseGoingAway) {
+				return
+			}
+			_ = conn.WriteJSON(errorEnvelope(sessionID, err.Error()))
+			return
+		case event, ok := <-events:
+			if !ok {
+				return
+			}
+			if err := conn.WriteJSON(toEnvelope(event)); err != nil {
+				return
+			}
+		}
+	}
+}
+
+func (h *WSTerminalHandler) readLoop(ctx context.Context, conn *websocket.Conn, sessionID string) error {
+	conn.SetReadLimit(1 << 20)
+	_ = conn.SetReadDeadline(time.Time{})
+
+	for {
+		select {
+		case <-ctx.Done():
+			return nil
+		default:
+		}
+
+		_, msg, err := conn.ReadMessage()
+		if err != nil {
+			return err
+		}
+
+		var envelope ws.Envelope
+		if err := json.Unmarshal(msg, &envelope); err != nil {
+			return err
+		}
+
+		switch envelope.Type {
+		case "terminal.input":
+			var payload ws.TerminalInputPayload
+			if err := json.Unmarshal(envelope.Payload, &payload); err != nil {
+				return err
+			}
+			if err := h.manager.WriteInput(ctx, sessionID, payload.Data); err != nil {
+				return err
+			}
+		case "terminal.resize":
+			var payload ws.TerminalResizePayload
+			if err := json.Unmarshal(envelope.Payload, &payload); err != nil {
+				return err
+			}
+			if err := h.manager.Resize(ctx, sessionID, payload.Cols, payload.Rows); err != nil {
+				return err
+			}
+		default:
+			return fmt.Errorf("unsupported message type: %s", envelope.Type)
+		}
+	}
+}
+
+func toEnvelope(event domain.Event) map[string]any {
+	return map[string]any{
+		"type":    string(event.Type),
+		"session": event.SessionID,
+		"payload": event.Payload,
+	}
+}
+
+func errorEnvelope(sessionID string, message string) map[string]any {
+	return map[string]any{
+		"type":    "error",
+		"session": sessionID,
+		"payload": ws.ErrorPayload{Message: message},
+	}
+}