move server to server directory.

server/internal/websocket/filechooserdialog.go

@@ -0,0 +1,67 @@
+package websocket
+
+import (
+	"github.com/demodesk/neko/pkg/types"
+	"github.com/demodesk/neko/pkg/types/event"
+	"github.com/demodesk/neko/pkg/types/message"
+)
+
+func (manager *WebSocketManagerCtx) fileChooserDialogEvents() {
+	var activeSession types.Session
+
+	// when dialog opens, everyone should be notified.
+	manager.desktop.OnFileChooserDialogOpened(func() {
+		manager.logger.Info().Msg("file chooser dialog opened")
+
+		host, hasHost := manager.sessions.GetHost()
+		if !hasHost {
+			manager.logger.Warn().Msg("no host for file chooser dialog found, closing")
+			go manager.desktop.CloseFileChooserDialog()
+			return
+		}
+
+		activeSession = host
+
+		go manager.sessions.Broadcast(
+			event.FILE_CHOOSER_DIALOG_OPENED,
+			message.SessionID{
+				ID: host.ID(),
+			})
+	})
+
+	// when dialog closes, everyone should be notified.
+	manager.desktop.OnFileChooserDialogClosed(func() {
+		manager.logger.Info().Msg("file chooser dialog closed")
+
+		activeSession = nil
+
+		go manager.sessions.Broadcast(
+			event.FILE_CHOOSER_DIALOG_CLOSED,
+			message.SessionID{})
+	})
+
+	// when new user joins, and someone holds dialog, he shouldd be notified about it.
+	manager.sessions.OnConnected(func(session types.Session) {
+		if activeSession == nil {
+			return
+		}
+
+		manager.logger.Debug().Str("session_id", session.ID()).Msg("sending file chooser dialog status to a new session")
+
+		session.Send(
+			event.FILE_CHOOSER_DIALOG_OPENED,
+			message.SessionID{
+				ID: activeSession.ID(),
+			})
+	})
+
+	// when user, that holds dialog, disconnects, it should be closed.
+	manager.sessions.OnDisconnected(func(session types.Session) {
+		if activeSession == nil || activeSession != session {
+			return
+		}
+
+		manager.logger.Info().Msg("file chooser dialog owner left, closing")
+		manager.desktop.CloseFileChooserDialog()
+	})
+}

server/internal/websocket/handler/clipboard.go

@@ -0,0 +1,23 @@
+package handler
+
+import (
+	"errors"
+
+	"github.com/demodesk/neko/pkg/types"
+	"github.com/demodesk/neko/pkg/types/message"
+)
+
+func (h *MessageHandlerCtx) clipboardSet(session types.Session, payload *message.ClipboardData) error {
+	if !session.Profile().CanAccessClipboard {
+		return errors.New("cannot access clipboard")
+	}
+
+	if !session.IsHost() {
+		return errors.New("is not the host")
+	}
+
+	return h.desktop.ClipboardSetText(types.ClipboardText{
+		Text: payload.Text,
+		// TODO: Send HTML?
+	})
+}

server/internal/websocket/handler/control.go

@@ -0,0 +1,228 @@
+package handler
+
+import (
+	"errors"
+
+	"github.com/demodesk/neko/pkg/types"
+	"github.com/demodesk/neko/pkg/types/event"
+	"github.com/demodesk/neko/pkg/types/message"
+	"github.com/demodesk/neko/pkg/xorg"
+)
+
+var (
+	ErrIsNotAllowedToHost = errors.New("is not allowed to host")
+	ErrIsNotTheHost       = errors.New("is not the host")
+	ErrIsAlreadyTheHost   = errors.New("is already the host")
+	ErrIsAlreadyHosted    = errors.New("is already hosted")
+)
+
+func (h *MessageHandlerCtx) controlRelease(session types.Session) error {
+	if !session.Profile().CanHost || session.PrivateModeEnabled() {
+		return ErrIsNotAllowedToHost
+	}
+
+	if !session.IsHost() {
+		return ErrIsNotTheHost
+	}
+
+	h.desktop.ResetKeys()
+	session.ClearHost()
+
+	return nil
+}
+
+func (h *MessageHandlerCtx) controlRequest(session types.Session) error {
+	if !session.Profile().CanHost || session.PrivateModeEnabled() {
+		return ErrIsNotAllowedToHost
+	}
+
+	if session.IsHost() {
+		return ErrIsAlreadyTheHost
+	}
+
+	if h.sessions.Settings().LockedControls && !session.Profile().IsAdmin {
+		return ErrIsNotAllowedToHost
+	}
+
+	// if implicit hosting is enabled, set session as host without asking
+	if h.sessions.Settings().ImplicitHosting {
+		session.SetAsHost()
+		return nil
+	}
+
+	// if there is no host, set session as host
+	host, hasHost := h.sessions.GetHost()
+	if !hasHost {
+		session.SetAsHost()
+		return nil
+	}
+
+	// TODO: Some throttling mechanism to prevent spamming.
+
+	// let host know that someone wants to take control
+	host.Send(
+		event.CONTROL_REQUEST,
+		message.SessionID{
+			ID: session.ID(),
+		})
+
+	return ErrIsAlreadyHosted
+}
+
+func (h *MessageHandlerCtx) controlMove(session types.Session, payload *message.ControlPos) error {
+	if err := h.controlRequest(session); err != nil && !errors.Is(err, ErrIsAlreadyTheHost) {
+		return err
+	}
+
+	// handle active cursor movement
+	h.desktop.Move(payload.X, payload.Y)
+	h.webrtc.SetCursorPosition(payload.X, payload.Y)
+	return nil
+}
+
+func (h *MessageHandlerCtx) controlScroll(session types.Session, payload *message.ControlScroll) error {
+	if err := h.controlRequest(session); err != nil && !errors.Is(err, ErrIsAlreadyTheHost) {
+		return err
+	}
+
+	// TOOD: remove this once the client is fixed
+	if payload.DeltaX == 0 && payload.DeltaY == 0 {
+		payload.DeltaX = payload.X
+		payload.DeltaY = payload.Y
+	}
+
+	h.desktop.Scroll(payload.DeltaX, payload.DeltaY, payload.ControlKey)
+	return nil
+}
+
+func (h *MessageHandlerCtx) controlButtonPress(session types.Session, payload *message.ControlButton) error {
+	if payload.ControlPos != nil {
+		if err := h.controlMove(session, payload.ControlPos); err != nil {
+			return err
+		}
+	} else if err := h.controlRequest(session); err != nil && !errors.Is(err, ErrIsAlreadyTheHost) {
+		return err
+	}
+
+	return h.desktop.ButtonPress(payload.Code)
+}
+
+func (h *MessageHandlerCtx) controlButtonDown(session types.Session, payload *message.ControlButton) error {
+	if payload.ControlPos != nil {
+		if err := h.controlMove(session, payload.ControlPos); err != nil {
+			return err
+		}
+	} else if err := h.controlRequest(session); err != nil && !errors.Is(err, ErrIsAlreadyTheHost) {
+		return err
+	}
+
+	return h.desktop.ButtonDown(payload.Code)
+}
+
+func (h *MessageHandlerCtx) controlButtonUp(session types.Session, payload *message.ControlButton) error {
+	if payload.ControlPos != nil {
+		if err := h.controlMove(session, payload.ControlPos); err != nil {
+			return err
+		}
+	} else if err := h.controlRequest(session); err != nil && !errors.Is(err, ErrIsAlreadyTheHost) {
+		return err
+	}
+
+	return h.desktop.ButtonUp(payload.Code)
+}
+
+func (h *MessageHandlerCtx) controlKeyPress(session types.Session, payload *message.ControlKey) error {
+	if payload.ControlPos != nil {
+		if err := h.controlMove(session, payload.ControlPos); err != nil {
+			return err
+		}
+	} else if err := h.controlRequest(session); err != nil && !errors.Is(err, ErrIsAlreadyTheHost) {
+		return err
+	}
+
+	return h.desktop.KeyPress(payload.Keysym)
+}
+
+func (h *MessageHandlerCtx) controlKeyDown(session types.Session, payload *message.ControlKey) error {
+	if payload.ControlPos != nil {
+		if err := h.controlMove(session, payload.ControlPos); err != nil {
+			return err
+		}
+	} else if err := h.controlRequest(session); err != nil && !errors.Is(err, ErrIsAlreadyTheHost) {
+		return err
+	}
+
+	return h.desktop.KeyDown(payload.Keysym)
+}
+
+func (h *MessageHandlerCtx) controlKeyUp(session types.Session, payload *message.ControlKey) error {
+	if payload.ControlPos != nil {
+		if err := h.controlMove(session, payload.ControlPos); err != nil {
+			return err
+		}
+	} else if err := h.controlRequest(session); err != nil && !errors.Is(err, ErrIsAlreadyTheHost) {
+		return err
+	}
+
+	return h.desktop.KeyUp(payload.Keysym)
+}
+
+func (h *MessageHandlerCtx) controlTouchBegin(session types.Session, payload *message.ControlTouch) error {
+	if err := h.controlRequest(session); err != nil && !errors.Is(err, ErrIsAlreadyTheHost) {
+		return err
+	}
+	return h.desktop.TouchBegin(payload.TouchId, payload.X, payload.Y, payload.Pressure)
+}
+
+func (h *MessageHandlerCtx) controlTouchUpdate(session types.Session, payload *message.ControlTouch) error {
+	if err := h.controlRequest(session); err != nil && !errors.Is(err, ErrIsAlreadyTheHost) {
+		return err
+	}
+	return h.desktop.TouchUpdate(payload.TouchId, payload.X, payload.Y, payload.Pressure)
+}
+
+func (h *MessageHandlerCtx) controlTouchEnd(session types.Session, payload *message.ControlTouch) error {
+	if err := h.controlRequest(session); err != nil && !errors.Is(err, ErrIsAlreadyTheHost) {
+		return err
+	}
+	return h.desktop.TouchEnd(payload.TouchId, payload.X, payload.Y, payload.Pressure)
+}
+
+func (h *MessageHandlerCtx) controlCut(session types.Session) error {
+	if err := h.controlRequest(session); err != nil && !errors.Is(err, ErrIsAlreadyTheHost) {
+		return err
+	}
+
+	return h.desktop.KeyPress(xorg.XK_Control_L, xorg.XK_x)
+}
+
+func (h *MessageHandlerCtx) controlCopy(session types.Session) error {
+	if err := h.controlRequest(session); err != nil && !errors.Is(err, ErrIsAlreadyTheHost) {
+		return err
+	}
+
+	return h.desktop.KeyPress(xorg.XK_Control_L, xorg.XK_c)
+}
+
+func (h *MessageHandlerCtx) controlPaste(session types.Session, payload *message.ClipboardData) error {
+	if err := h.controlRequest(session); err != nil && !errors.Is(err, ErrIsAlreadyTheHost) {
+		return err
+	}
+
+	// if there have been set clipboard data, set them first
+	if payload != nil && payload.Text != "" {
+		if err := h.clipboardSet(session, payload); err != nil {
+			return err
+		}
+	}
+
+	return h.desktop.KeyPress(xorg.XK_Control_L, xorg.XK_v)
+}
+
+func (h *MessageHandlerCtx) controlSelectAll(session types.Session) error {
+	if err := h.controlRequest(session); err != nil && !errors.Is(err, ErrIsAlreadyTheHost) {
+		return err
+	}
+
+	return h.desktop.KeyPress(xorg.XK_Control_L, xorg.XK_a)
+}

server/internal/websocket/handler/handler.go

@@ -0,0 +1,203 @@
+package handler
+
+import (
+	"github.com/rs/zerolog"
+	"github.com/rs/zerolog/log"
+
+	"github.com/demodesk/neko/pkg/types"
+	"github.com/demodesk/neko/pkg/types/event"
+	"github.com/demodesk/neko/pkg/types/message"
+	"github.com/demodesk/neko/pkg/utils"
+)
+
+func New(
+	sessions types.SessionManager,
+	desktop types.DesktopManager,
+	capture types.CaptureManager,
+	webrtc types.WebRTCManager,
+) *MessageHandlerCtx {
+	return &MessageHandlerCtx{
+		logger:   log.With().Str("module", "websocket").Str("submodule", "handler").Logger(),
+		sessions: sessions,
+		desktop:  desktop,
+		capture:  capture,
+		webrtc:   webrtc,
+	}
+}
+
+type MessageHandlerCtx struct {
+	logger   zerolog.Logger
+	sessions types.SessionManager
+	webrtc   types.WebRTCManager
+	desktop  types.DesktopManager
+	capture  types.CaptureManager
+}
+
+func (h *MessageHandlerCtx) Message(session types.Session, data types.WebSocketMessage) bool {
+	var err error
+	switch data.Event {
+	// System Events
+	case event.SYSTEM_LOGS:
+		payload := &message.SystemLogs{}
+		err = utils.Unmarshal(payload, data.Payload, func() error {
+			return h.systemLogs(session, payload)
+		})
+
+	// Signal Events
+	case event.SIGNAL_REQUEST:
+		payload := &message.SignalRequest{}
+		err = utils.Unmarshal(payload, data.Payload, func() error {
+			return h.signalRequest(session, payload)
+		})
+	case event.SIGNAL_RESTART:
+		err = h.signalRestart(session)
+	case event.SIGNAL_OFFER:
+		payload := &message.SignalDescription{}
+		err = utils.Unmarshal(payload, data.Payload, func() error {
+			return h.signalOffer(session, payload)
+		})
+	case event.SIGNAL_ANSWER:
+		payload := &message.SignalDescription{}
+		err = utils.Unmarshal(payload, data.Payload, func() error {
+			return h.signalAnswer(session, payload)
+		})
+	case event.SIGNAL_CANDIDATE:
+		payload := &message.SignalCandidate{}
+		err = utils.Unmarshal(payload, data.Payload, func() error {
+			return h.signalCandidate(session, payload)
+		})
+	case event.SIGNAL_VIDEO:
+		payload := &message.SignalVideo{}
+		err = utils.Unmarshal(payload, data.Payload, func() error {
+			return h.signalVideo(session, payload)
+		})
+	case event.SIGNAL_AUDIO:
+		payload := &message.SignalAudio{}
+		err = utils.Unmarshal(payload, data.Payload, func() error {
+			return h.signalAudio(session, payload)
+		})
+
+	// Control Events
+	case event.CONTROL_RELEASE:
+		err = h.controlRelease(session)
+	case event.CONTROL_REQUEST:
+		err = h.controlRequest(session)
+	case event.CONTROL_MOVE:
+		payload := &message.ControlPos{}
+		err = utils.Unmarshal(payload, data.Payload, func() error {
+			return h.controlMove(session, payload)
+		})
+	case event.CONTROL_SCROLL:
+		payload := &message.ControlScroll{}
+		err = utils.Unmarshal(payload, data.Payload, func() error {
+			return h.controlScroll(session, payload)
+		})
+	case event.CONTROL_BUTTONPRESS:
+		payload := &message.ControlButton{}
+		err = utils.Unmarshal(payload, data.Payload, func() error {
+			return h.controlButtonPress(session, payload)
+		})
+	case event.CONTROL_BUTTONDOWN:
+		payload := &message.ControlButton{}
+		err = utils.Unmarshal(payload, data.Payload, func() error {
+			return h.controlButtonDown(session, payload)
+		})
+	case event.CONTROL_BUTTONUP:
+		payload := &message.ControlButton{}
+		err = utils.Unmarshal(payload, data.Payload, func() error {
+			return h.controlButtonUp(session, payload)
+		})
+	case event.CONTROL_KEYPRESS:
+		payload := &message.ControlKey{}
+		err = utils.Unmarshal(payload, data.Payload, func() error {
+			return h.controlKeyPress(session, payload)
+		})
+	case event.CONTROL_KEYDOWN:
+		payload := &message.ControlKey{}
+		err = utils.Unmarshal(payload, data.Payload, func() error {
+			return h.controlKeyDown(session, payload)
+		})
+	case event.CONTROL_KEYUP:
+		payload := &message.ControlKey{}
+		err = utils.Unmarshal(payload, data.Payload, func() error {
+			return h.controlKeyUp(session, payload)
+		})
+	// touch
+	case event.CONTROL_TOUCHBEGIN:
+		payload := &message.ControlTouch{}
+		err = utils.Unmarshal(payload, data.Payload, func() error {
+			return h.controlTouchBegin(session, payload)
+		})
+	case event.CONTROL_TOUCHUPDATE:
+		payload := &message.ControlTouch{}
+		err = utils.Unmarshal(payload, data.Payload, func() error {
+			return h.controlTouchUpdate(session, payload)
+		})
+	case event.CONTROL_TOUCHEND:
+		payload := &message.ControlTouch{}
+		err = utils.Unmarshal(payload, data.Payload, func() error {
+			return h.controlTouchEnd(session, payload)
+		})
+	// actions
+	case event.CONTROL_CUT:
+		err = h.controlCut(session)
+	case event.CONTROL_COPY:
+		err = h.controlCopy(session)
+	case event.CONTROL_PASTE:
+		payload := &message.ClipboardData{}
+		err = utils.Unmarshal(payload, data.Payload, func() error {
+			return h.controlPaste(session, payload)
+		})
+	case event.CONTROL_SELECT_ALL:
+		err = h.controlSelectAll(session)
+
+	// Screen Events
+	case event.SCREEN_SET:
+		payload := &message.ScreenSize{}
+		err = utils.Unmarshal(payload, data.Payload, func() error {
+			return h.screenSet(session, payload)
+		})
+
+	// Clipboard Events
+	case event.CLIPBOARD_SET:
+		payload := &message.ClipboardData{}
+		err = utils.Unmarshal(payload, data.Payload, func() error {
+			return h.clipboardSet(session, payload)
+		})
+
+	// Keyboard Events
+	case event.KEYBOARD_MAP:
+		payload := &message.KeyboardMap{}
+		err = utils.Unmarshal(payload, data.Payload, func() error {
+			return h.keyboardMap(session, payload)
+		})
+	case event.KEYBOARD_MODIFIERS:
+		payload := &message.KeyboardModifiers{}
+		err = utils.Unmarshal(payload, data.Payload, func() error {
+			return h.keyboardModifiers(session, payload)
+		})
+
+	// Send Events
+	case event.SEND_UNICAST:
+		payload := &message.SendUnicast{}
+		err = utils.Unmarshal(payload, data.Payload, func() error {
+			return h.sendUnicast(session, payload)
+		})
+	case event.SEND_BROADCAST:
+		payload := &message.SendBroadcast{}
+		err = utils.Unmarshal(payload, data.Payload, func() error {
+			return h.sendBroadcast(session, payload)
+		})
+	default:
+		return false
+	}
+
+	if err != nil {
+		h.logger.Warn().Err(err).
+			Str("event", data.Event).
+			Str("session_id", session.ID()).
+			Msg("message handler has failed")
+	}
+
+	return true
+}

server/internal/websocket/handler/keyboard.go

@@ -0,0 +1,25 @@
+package handler
+
+import (
+	"errors"
+
+	"github.com/demodesk/neko/pkg/types"
+	"github.com/demodesk/neko/pkg/types/message"
+)
+
+func (h *MessageHandlerCtx) keyboardMap(session types.Session, payload *message.KeyboardMap) error {
+	if !session.IsHost() {
+		return errors.New("is not the host")
+	}
+
+	return h.desktop.SetKeyboardMap(payload.KeyboardMap)
+}
+
+func (h *MessageHandlerCtx) keyboardModifiers(session types.Session, payload *message.KeyboardModifiers) error {
+	if !session.IsHost() {
+		return errors.New("is not the host")
+	}
+
+	h.desktop.SetKeyboardModifiers(payload.KeyboardModifiers)
+	return nil
+}

server/internal/websocket/handler/screen.go

@@ -0,0 +1,26 @@
+package handler
+
+import (
+	"errors"
+
+	"github.com/demodesk/neko/pkg/types"
+	"github.com/demodesk/neko/pkg/types/event"
+	"github.com/demodesk/neko/pkg/types/message"
+)
+
+func (h *MessageHandlerCtx) screenSet(session types.Session, payload *message.ScreenSize) error {
+	if !session.Profile().IsAdmin {
+		return errors.New("is not the admin")
+	}
+
+	size, err := h.desktop.SetScreenSize(payload.ScreenSize)
+	if err != nil {
+		return err
+	}
+
+	h.sessions.Broadcast(event.SCREEN_UPDATED, message.ScreenSizeUpdate{
+		ID:         session.ID(),
+		ScreenSize: size,
+	})
+	return nil
+}

server/internal/websocket/handler/send.go

@@ -0,0 +1,39 @@
+package handler
+
+import (
+	"errors"
+
+	"github.com/demodesk/neko/pkg/types"
+	"github.com/demodesk/neko/pkg/types/event"
+	"github.com/demodesk/neko/pkg/types/message"
+)
+
+func (h *MessageHandlerCtx) sendUnicast(session types.Session, payload *message.SendUnicast) error {
+	receiver, ok := h.sessions.Get(payload.Receiver)
+	if !ok {
+		return errors.New("receiver session ID not found")
+	}
+
+	receiver.Send(
+		event.SEND_UNICAST,
+		message.SendUnicast{
+			Sender:   session.ID(),
+			Receiver: receiver.ID(),
+			Subject:  payload.Subject,
+			Body:     payload.Body,
+		})
+
+	return nil
+}
+
+func (h *MessageHandlerCtx) sendBroadcast(session types.Session, payload *message.SendBroadcast) error {
+	h.sessions.Broadcast(
+		event.SEND_BROADCAST,
+		message.SendBroadcast{
+			Sender:  session.ID(),
+			Subject: payload.Subject,
+			Body:    payload.Body,
+		}, session.ID())
+
+	return nil
+}

server/internal/websocket/handler/session.go

@@ -0,0 +1,106 @@
+package handler
+
+import (
+	"github.com/demodesk/neko/pkg/types"
+	"github.com/demodesk/neko/pkg/types/event"
+	"github.com/demodesk/neko/pkg/types/message"
+)
+
+func (h *MessageHandlerCtx) SessionCreated(session types.Session) error {
+	h.sessions.Broadcast(
+		event.SESSION_CREATED,
+		message.SessionData{
+			ID:      session.ID(),
+			Profile: session.Profile(),
+			State:   session.State(),
+		})
+
+	return nil
+}
+
+func (h *MessageHandlerCtx) SessionDeleted(session types.Session) error {
+	h.sessions.Broadcast(
+		event.SESSION_DELETED,
+		message.SessionID{
+			ID: session.ID(),
+		})
+
+	return nil
+}
+
+func (h *MessageHandlerCtx) SessionConnected(session types.Session) error {
+	if err := h.systemInit(session); err != nil {
+		return err
+	}
+
+	if session.Profile().IsAdmin {
+		if err := h.systemAdmin(session); err != nil {
+			return err
+		}
+
+		// update settings in atomic way
+		h.sessions.UpdateSettingsFunc(session, func(settings *types.Settings) bool {
+			// if control protection & locked controls: unlock controls
+			if settings.LockedControls && settings.ControlProtection {
+				settings.LockedControls = false
+				return true // update settings
+			}
+			return false // do not update settings
+		})
+	}
+
+	return h.SessionStateChanged(session)
+}
+
+func (h *MessageHandlerCtx) SessionDisconnected(session types.Session) error {
+	// clear host if exists
+	if session.IsHost() {
+		h.desktop.ResetKeys()
+		session.ClearHost()
+	}
+
+	if session.Profile().IsAdmin {
+		hasAdmin := false
+		h.sessions.Range(func(s types.Session) bool {
+			if s.Profile().IsAdmin && s.ID() != session.ID() && s.State().IsConnected {
+				hasAdmin = true
+				return false
+			}
+			return true
+		})
+
+		// update settings in atomic way
+		h.sessions.UpdateSettingsFunc(session, func(settings *types.Settings) bool {
+			// if control protection & not locked controls & no admin: lock controls
+			if !settings.LockedControls && settings.ControlProtection && !hasAdmin {
+				settings.LockedControls = true
+				return true // update settings
+			}
+			return false // do not update settings
+		})
+	}
+
+	return h.SessionStateChanged(session)
+}
+
+func (h *MessageHandlerCtx) SessionProfileChanged(session types.Session, new, old types.MemberProfile) error {
+	h.sessions.Broadcast(
+		event.SESSION_PROFILE,
+		message.MemberProfile{
+			ID:            session.ID(),
+			MemberProfile: new,
+		})
+
+	return nil
+}
+
+func (h *MessageHandlerCtx) SessionStateChanged(session types.Session) error {
+	h.sessions.Broadcast(
+		event.SESSION_STATE,
+		message.SessionState{
+			ID:           session.ID(),
+			SessionState: session.State(),
+		})
+
+	return nil
+}

server/internal/websocket/handler/signal.go

@@ -0,0 +1,162 @@
+package handler
+
+import (
+	"errors"
+
+	"github.com/demodesk/neko/pkg/types"
+	"github.com/demodesk/neko/pkg/types/event"
+	"github.com/demodesk/neko/pkg/types/message"
+	"github.com/pion/webrtc/v3"
+)
+
+func (h *MessageHandlerCtx) signalRequest(session types.Session, payload *message.SignalRequest) error {
+	if !session.Profile().CanWatch {
+		return errors.New("not allowed to watch")
+	}
+
+	offer, peer, err := h.webrtc.CreatePeer(session)
+	if err != nil {
+		return err
+	}
+
+	// set webrtc as paused if session has private mode enabled
+	if session.PrivateModeEnabled() {
+		peer.SetPaused(true)
+	}
+
+	video := payload.Video
+
+	// use default first video, if not provided
+	if video.Selector == nil {
+		videos := h.capture.Video().IDs()
+		video.Selector = &types.StreamSelector{
+			ID:   videos[0],
+			Type: types.StreamSelectorTypeExact,
+		}
+	}
+
+	// TODO: Remove, used for compatibility with old clients.
+	if video.Auto == nil {
+		video.Auto = &payload.Auto
+	}
+
+	// set video stream
+	err = peer.SetVideo(video)
+	if err != nil {
+		return err
+	}
+
+	audio := payload.Audio
+
+	// enable by default if not requested otherwise
+	if audio.Disabled == nil {
+		disabled := false
+		audio.Disabled = &disabled
+	}
+
+	// set audio stream
+	err = peer.SetAudio(audio)
+	if err != nil {
+		return err
+	}
+
+	session.Send(
+		event.SIGNAL_PROVIDE,
+		message.SignalProvide{
+			SDP:        offer.SDP,
+			ICEServers: h.webrtc.ICEServers(),
+
+			Video: peer.Video(),
+			Audio: peer.Audio(),
+		})
+
+	return nil
+}
+
+func (h *MessageHandlerCtx) signalRestart(session types.Session) error {
+	peer := session.GetWebRTCPeer()
+	if peer == nil {
+		return errors.New("webRTC peer does not exist")
+	}
+
+	offer, err := peer.CreateOffer(true)
+	if err != nil {
+		return err
+	}
+
+	// TODO: Use offer event instead.
+	session.Send(
+		event.SIGNAL_RESTART,
+		message.SignalDescription{
+			SDP: offer.SDP,
+		})
+
+	return nil
+}
+
+func (h *MessageHandlerCtx) signalOffer(session types.Session, payload *message.SignalDescription) error {
+	peer := session.GetWebRTCPeer()
+	if peer == nil {
+		return errors.New("webRTC peer does not exist")
+	}
+
+	err := peer.SetRemoteDescription(webrtc.SessionDescription{
+		SDP:  payload.SDP,
+		Type: webrtc.SDPTypeOffer,
+	})
+	if err != nil {
+		return err
+	}
+
+	answer, err := peer.CreateAnswer()
+	if err != nil {
+		return err
+	}
+
+	session.Send(
+		event.SIGNAL_ANSWER,
+		message.SignalDescription{
+			SDP: answer.SDP,
+		})
+
+	return nil
+}
+
+func (h *MessageHandlerCtx) signalAnswer(session types.Session, payload *message.SignalDescription) error {
+	peer := session.GetWebRTCPeer()
+	if peer == nil {
+		return errors.New("webRTC peer does not exist")
+	}
+
+	return peer.SetRemoteDescription(webrtc.SessionDescription{
+		SDP:  payload.SDP,
+		Type: webrtc.SDPTypeAnswer,
+	})
+}
+
+func (h *MessageHandlerCtx) signalCandidate(session types.Session, payload *message.SignalCandidate) error {
+	peer := session.GetWebRTCPeer()
+	if peer == nil {
+		return errors.New("webRTC peer does not exist")
+	}
+
+	return peer.SetCandidate(payload.ICECandidateInit)
+}
+
+func (h *MessageHandlerCtx) signalVideo(session types.Session, payload *message.SignalVideo) error {
+	peer := session.GetWebRTCPeer()
+	if peer == nil {
+		return errors.New("webRTC peer does not exist")
+	}
+
+	return peer.SetVideo(payload.PeerVideoRequest)
+}
+
+func (h *MessageHandlerCtx) signalAudio(session types.Session, payload *message.SignalAudio) error {
+	peer := session.GetWebRTCPeer()
+	if peer == nil {
+		return errors.New("webRTC peer does not exist")
+	}
+
+	return peer.SetAudio(payload.PeerAudioRequest)
+}

server/internal/websocket/handler/system.go

@@ -0,0 +1,96 @@
+package handler
+
+import (
+	"github.com/rs/zerolog"
+	"github.com/rs/zerolog/log"
+
+	"github.com/demodesk/neko/pkg/types"
+	"github.com/demodesk/neko/pkg/types/event"
+	"github.com/demodesk/neko/pkg/types/message"
+)
+
+func (h *MessageHandlerCtx) systemInit(session types.Session) error {
+	host, hasHost := h.sessions.GetHost()
+
+	var hostID string
+	if hasHost {
+		hostID = host.ID()
+	}
+
+	controlHost := message.ControlHost{
+		HasHost: hasHost,
+		HostID:  hostID,
+	}
+
+	sessions := map[string]message.SessionData{}
+	for _, session := range h.sessions.List() {
+		sessionId := session.ID()
+		sessions[sessionId] = message.SessionData{
+			ID:      sessionId,
+			Profile: session.Profile(),
+			State:   session.State(),
+		}
+	}
+
+	session.Send(
+		event.SYSTEM_INIT,
+		message.SystemInit{
+			SessionId:         session.ID(),
+			ControlHost:       controlHost,
+			ScreenSize:        h.desktop.GetScreenSize(),
+			Sessions:          sessions,
+			Settings:          h.sessions.Settings(),
+			TouchEvents:       h.desktop.HasTouchSupport(),
+			ScreencastEnabled: h.capture.Screencast().Enabled(),
+			WebRTC: message.SystemWebRTC{
+				Videos: h.capture.Video().IDs(),
+			},
+		})
+
+	return nil
+}
+
+func (h *MessageHandlerCtx) systemAdmin(session types.Session) error {
+	configurations := h.desktop.ScreenConfigurations()
+
+	list := make([]types.ScreenSize, 0, len(configurations))
+	for _, conf := range configurations {
+		list = append(list, types.ScreenSize{
+			Width:  conf.Width,
+			Height: conf.Height,
+			Rate:   conf.Rate,
+		})
+	}
+
+	broadcast := h.capture.Broadcast()
+	session.Send(
+		event.SYSTEM_ADMIN,
+		message.SystemAdmin{
+			ScreenSizesList: list, // TODO: remove
+			BroadcastStatus: message.BroadcastStatus{
+				IsActive: broadcast.Started(),
+				URL:      broadcast.Url(),
+			},
+		})
+
+	return nil
+}
+
+func (h *MessageHandlerCtx) systemLogs(session types.Session, payload *message.SystemLogs) error {
+	for _, msg := range *payload {
+		level, _ := zerolog.ParseLevel(msg.Level)
+
+		if level < zerolog.DebugLevel || level > zerolog.ErrorLevel {
+			level = zerolog.NoLevel
+		}
+
+		// do not use handler logger context
+		log.WithLevel(level).
+			Fields(msg.Fields).
+			Str("module", "client").
+			Str("session_id", session.ID()).
+			Msg(msg.Message)
+	}
+
+	return nil
+}

server/internal/websocket/manager.go

@@ -0,0 +1,431 @@
+package websocket
+
+import (
+	"encoding/json"
+	"errors"
+	"net/http"
+	"sync"
+	"time"
+
+	"github.com/gorilla/websocket"
+	"github.com/rs/zerolog"
+	"github.com/rs/zerolog/log"
+
+	"github.com/demodesk/neko/internal/websocket/handler"
+	"github.com/demodesk/neko/pkg/types"
+	"github.com/demodesk/neko/pkg/types/event"
+	"github.com/demodesk/neko/pkg/types/message"
+	"github.com/demodesk/neko/pkg/utils"
+)
+
+// send pings to peer with this period - must be less than pongWait
+const pingPeriod = 10 * time.Second
+
+// period for sending inactive cursor messages
+const inactiveCursorsPeriod = 750 * time.Millisecond
+
+// maximum payload length for logging
+const maxPayloadLogLength = 10_000
+
+// events that are not logged in debug mode
+var nologEvents = []string{
+	// don't log twice
+	event.SYSTEM_LOGS,
+	// don't log heartbeat
+	event.SYSTEM_HEARTBEAT,
+	// don't log every cursor update
+	event.SESSION_CURSORS,
+}
+
+func New(
+	sessions types.SessionManager,
+	desktop types.DesktopManager,
+	capture types.CaptureManager,
+	webrtc types.WebRTCManager,
+) *WebSocketManagerCtx {
+	logger := log.With().Str("module", "websocket").Logger()
+
+	return &WebSocketManagerCtx{
+		logger:   logger,
+		shutdown: make(chan struct{}),
+		sessions: sessions,
+		desktop:  desktop,
+		handler:  handler.New(sessions, desktop, capture, webrtc),
+		handlers: []types.WebSocketHandler{},
+	}
+}
+
+type WebSocketManagerCtx struct {
+	logger   zerolog.Logger
+	wg       sync.WaitGroup
+	shutdown chan struct{}
+	sessions types.SessionManager
+	desktop  types.DesktopManager
+	handler  *handler.MessageHandlerCtx
+	handlers []types.WebSocketHandler
+
+	shutdownInactiveCursors chan struct{}
+}
+
+func (manager *WebSocketManagerCtx) Start() {
+	manager.sessions.OnCreated(func(session types.Session) {
+		err := manager.handler.SessionCreated(session)
+		manager.logger.Err(err).
+			Str("session_id", session.ID()).
+			Msg("session created")
+	})
+
+	manager.sessions.OnDeleted(func(session types.Session) {
+		err := manager.handler.SessionDeleted(session)
+		manager.logger.Err(err).
+			Str("session_id", session.ID()).
+			Msg("session deleted")
+	})
+
+	manager.sessions.OnConnected(func(session types.Session) {
+		err := manager.handler.SessionConnected(session)
+		manager.logger.Err(err).
+			Str("session_id", session.ID()).
+			Msg("session connected")
+	})
+
+	manager.sessions.OnDisconnected(func(session types.Session) {
+		err := manager.handler.SessionDisconnected(session)
+		manager.logger.Err(err).
+			Str("session_id", session.ID()).
+			Msg("session disconnected")
+	})
+
+	manager.sessions.OnProfileChanged(func(session types.Session, new, old types.MemberProfile) {
+		err := manager.handler.SessionProfileChanged(session, new, old)
+		manager.logger.Err(err).
+			Str("session_id", session.ID()).
+			Interface("new", new).
+			Interface("old", old).
+			Msg("session profile changed")
+	})
+
+	manager.sessions.OnStateChanged(func(session types.Session) {
+		err := manager.handler.SessionStateChanged(session)
+		manager.logger.Err(err).
+			Str("session_id", session.ID()).
+			Msg("session state changed")
+	})
+
+	manager.sessions.OnHostChanged(func(session, host types.Session) {
+		payload := message.ControlHost{
+			ID:      session.ID(),
+			HasHost: host != nil,
+		}
+
+		if payload.HasHost {
+			payload.HostID = host.ID()
+		}
+
+		manager.sessions.Broadcast(event.CONTROL_HOST, payload)
+
+		manager.logger.Info().
+			Str("session_id", session.ID()).
+			Bool("has_host", payload.HasHost).
+			Str("host_id", payload.HostID).
+			Msg("session host changed")
+	})
+
+	manager.sessions.OnSettingsChanged(func(session types.Session, new, old types.Settings) {
+		// start inactive cursors
+		if new.InactiveCursors && !old.InactiveCursors {
+			manager.startInactiveCursors()
+		}
+
+		// stop inactive cursors
+		if !new.InactiveCursors && old.InactiveCursors {
+			manager.stopInactiveCursors()
+		}
+
+		manager.sessions.Broadcast(event.SYSTEM_SETTINGS, message.SystemSettingsUpdate{
+			ID:       session.ID(),
+			Settings: new,
+		})
+
+		manager.logger.Info().
+			Str("session_id", session.ID()).
+			Interface("new", new).
+			Interface("old", old).
+			Msg("settings changed")
+	})
+
+	manager.desktop.OnClipboardUpdated(func() {
+		host, hasHost := manager.sessions.GetHost()
+		if !hasHost || !host.Profile().CanAccessClipboard {
+			return
+		}
+
+		manager.logger.Info().Msg("sync clipboard")
+
+		data, err := manager.desktop.ClipboardGetText()
+		if err != nil {
+			manager.logger.Err(err).Msg("could not get clipboard content")
+			return
+		}
+
+		host.Send(
+			event.CLIPBOARD_UPDATED,
+			message.ClipboardData{
+				Text: data.Text,
+				// TODO: Send HTML?
+			})
+	})
+
+	if manager.desktop.IsFileChooserDialogEnabled() {
+		manager.fileChooserDialogEvents()
+	}
+
+	if manager.sessions.Settings().InactiveCursors {
+		manager.startInactiveCursors()
+	}
+
+	manager.logger.Info().Msg("websocket starting")
+}
+
+func (manager *WebSocketManagerCtx) Shutdown() error {
+	manager.logger.Info().Msg("shutdown")
+	close(manager.shutdown)
+	manager.stopInactiveCursors()
+	manager.wg.Wait()
+	return nil
+}
+
+func (manager *WebSocketManagerCtx) AddHandler(handler types.WebSocketHandler) {
+	manager.handlers = append(manager.handlers, handler)
+}
+
+func (manager *WebSocketManagerCtx) Upgrade(checkOrigin types.CheckOrigin) types.RouterHandler {
+	return func(w http.ResponseWriter, r *http.Request) error {
+		upgrader := websocket.Upgrader{
+			CheckOrigin: checkOrigin,
+			// Do not return any error while handshake
+			Error: func(w http.ResponseWriter, r *http.Request, status int, reason error) {},
+		}
+
+		connection, err := upgrader.Upgrade(w, r, nil)
+		if err != nil {
+			return utils.HttpBadRequest().WithInternalErr(err)
+		}
+
+		// Cannot write HTTP response after connection upgrade
+		manager.connect(connection, r)
+		return nil
+	}
+}
+
+func (manager *WebSocketManagerCtx) connect(connection *websocket.Conn, r *http.Request) {
+	session, err := manager.sessions.Authenticate(r)
+	if err != nil {
+		manager.logger.Warn().Err(err).Msg("authentication failed")
+		newPeer(manager.logger, connection).Destroy(err.Error())
+		return
+	}
+
+	// add session id to all log messages
+	logger := manager.logger.With().Str("session_id", session.ID()).Logger()
+
+	// create new peer
+	peer := newPeer(logger, connection)
+
+	if !session.Profile().CanConnect {
+		logger.Warn().Msg("connection disabled")
+		peer.Destroy("connection disabled")
+		return
+	}
+
+	if session.State().IsConnected {
+		logger.Warn().Msg("already connected")
+
+		if !manager.sessions.Settings().MercifulReconnect {
+			peer.Destroy("already connected")
+			return
+		}
+
+		logger.Info().Msg("replacing peer connection")
+	}
+
+	logger.Info().
+		Str("address", connection.RemoteAddr().String()).
+		Str("agent", r.UserAgent()).
+		Msg("connection started")
+
+	session.ConnectWebSocketPeer(peer)
+
+	// this is a blocking function that lives
+	// throughout whole websocket connection
+	err = manager.handle(connection, peer, session)
+
+	logger.Info().
+		Str("address", connection.RemoteAddr().String()).
+		Str("agent", r.UserAgent()).
+		Msg("connection ended")
+
+	if err == nil {
+		logger.Debug().Msg("websocket close")
+		session.DisconnectWebSocketPeer(peer, false)
+		return
+	}
+
+	delayedDisconnect := false
+
+	e, ok := err.(*websocket.CloseError)
+	if !ok {
+		err = errors.Unwrap(err) // unwrap if possible
+		logger.Warn().Err(err).Msg("read message error")
+		// client is expected to reconnect soon
+		delayedDisconnect = true
+	} else {
+		switch e.Code {
+		case websocket.CloseNormalClosure:
+			logger.Debug().Str("reason", e.Text).Msg("websocket close")
+		case websocket.CloseGoingAway:
+			logger.Debug().Str("reason", "going away").Msg("websocket close")
+		default:
+			logger.Warn().Err(err).Msg("websocket close")
+			// abnormal websocket closure:
+			// client is expected to reconnect soon
+			delayedDisconnect = true
+		}
+	}
+
+	session.DisconnectWebSocketPeer(peer, delayedDisconnect)
+}
+
+func (manager *WebSocketManagerCtx) handle(connection *websocket.Conn, peer types.WebSocketPeer, session types.Session) error {
+	// add session id to logger context
+	logger := manager.logger.With().Str("session_id", session.ID()).Logger()
+
+	bytes := make(chan []byte)
+	cancel := make(chan error)
+
+	ticker := time.NewTicker(pingPeriod)
+	defer ticker.Stop()
+
+	manager.wg.Add(1)
+	go func() {
+		defer manager.wg.Done()
+
+		for {
+			_, raw, err := connection.ReadMessage()
+			if err != nil {
+				cancel <- err
+				break
+			}
+
+			bytes <- raw
+		}
+	}()
+
+	for {
+		select {
+		case raw := <-bytes:
+			data := types.WebSocketMessage{}
+			if err := json.Unmarshal(raw, &data); err != nil {
+				logger.Err(err).Msg("message unmarshalling has failed")
+				break
+			}
+
+			// log events if not ignored
+			if ok, _ := utils.ArrayIn(data.Event, nologEvents); !ok {
+				payload := data.Payload
+				if len(payload) > maxPayloadLogLength {
+					payload = []byte("<truncated>")
+				}
+
+				logger.Debug().
+					Str("address", connection.RemoteAddr().String()).
+					Str("event", data.Event).
+					Str("payload", string(payload)).
+					Msg("received message from client")
+			}
+
+			handled := manager.handler.Message(session, data)
+			for _, handler := range manager.handlers {
+				if handled {
+					break
+				}
+
+				handled = handler(session, data)
+			}
+
+			if !handled {
+				logger.Warn().Str("event", data.Event).Msg("unhandled message")
+			}
+		case err := <-cancel:
+			return err
+		case <-manager.shutdown:
+			peer.Destroy("connection shutdown")
+			return nil
+		case <-ticker.C:
+			if err := peer.Ping(); err != nil {
+				return err
+			}
+		}
+	}
+}
+
+func (manager *WebSocketManagerCtx) startInactiveCursors() {
+	if manager.shutdownInactiveCursors != nil {
+		manager.logger.Warn().Msg("inactive cursors handler already running")
+		return
+	}
+
+	manager.logger.Info().Msg("starting inactive cursors handler")
+	manager.shutdownInactiveCursors = make(chan struct{})
+
+	manager.wg.Add(1)
+	go func() {
+		defer manager.wg.Done()
+
+		ticker := time.NewTicker(inactiveCursorsPeriod)
+		defer ticker.Stop()
+
+		var currentEmpty bool
+		var lastEmpty = false
+
+		for {
+			select {
+			case <-manager.shutdownInactiveCursors:
+				manager.logger.Info().Msg("stopping inactive cursors handler")
+				manager.shutdownInactiveCursors = nil
+
+				// remove last cursor entries and send empty message
+				_ = manager.sessions.PopCursors()
+				manager.sessions.InactiveCursorsBroadcast(event.SESSION_CURSORS, []message.SessionCursors{})
+				return
+			case <-ticker.C:
+				cursorsMap := manager.sessions.PopCursors()
+
+				currentEmpty = len(cursorsMap) == 0
+				if currentEmpty && lastEmpty {
+					continue
+				}
+				lastEmpty = currentEmpty
+
+				sessionCursors := []message.SessionCursors{}
+				for session, cursors := range cursorsMap {
+					sessionCursors = append(
+						sessionCursors,
+						message.SessionCursors{
+							ID:      session.ID(),
+							Cursors: cursors,
+						},
+					)
+				}
+
+				manager.sessions.InactiveCursorsBroadcast(event.SESSION_CURSORS, sessionCursors)
+			}
+		}
+	}()
+}
+
+func (manager *WebSocketManagerCtx) stopInactiveCursors() {
+	if manager.shutdownInactiveCursors != nil {
+		close(manager.shutdownInactiveCursors)
+	}
+}

server/internal/websocket/peer.go

@@ -0,0 +1,91 @@
+package websocket
+
+import (
+	"encoding/json"
+	"errors"
+	"sync"
+
+	"github.com/gorilla/websocket"
+	"github.com/rs/zerolog"
+
+	"github.com/demodesk/neko/pkg/types"
+	"github.com/demodesk/neko/pkg/types/event"
+	"github.com/demodesk/neko/pkg/types/message"
+	"github.com/demodesk/neko/pkg/utils"
+)
+
+type WebSocketPeerCtx struct {
+	mu         sync.Mutex
+	logger     zerolog.Logger
+	connection *websocket.Conn
+}
+
+func newPeer(logger zerolog.Logger, connection *websocket.Conn) *WebSocketPeerCtx {
+	return &WebSocketPeerCtx{
+		logger:     logger.With().Str("submodule", "peer").Logger(),
+		connection: connection,
+	}
+}
+
+func (peer *WebSocketPeerCtx) Send(event string, payload any) {
+	peer.mu.Lock()
+	defer peer.mu.Unlock()
+
+	raw, err := json.Marshal(payload)
+	if err != nil {
+		peer.logger.Err(err).Str("event", event).Msg("message marshalling has failed")
+		return
+	}
+
+	err = peer.connection.WriteJSON(types.WebSocketMessage{
+		Event:   event,
+		Payload: raw,
+	})
+
+	if err != nil {
+		err = errors.Unwrap(err) // unwrap if possible
+		peer.logger.Warn().Err(err).Str("event", event).Msg("send message error")
+		return
+	}
+
+	// log events if not ignored
+	if ok, _ := utils.ArrayIn(event, nologEvents); !ok {
+		if len(raw) > maxPayloadLogLength {
+			raw = []byte("<truncated>")
+		}
+
+		peer.logger.Debug().
+			Str("address", peer.connection.RemoteAddr().String()).
+			Str("event", event).
+			Str("payload", string(raw)).
+			Msg("sending message to client")
+	}
+}
+
+func (peer *WebSocketPeerCtx) Ping() error {
+	peer.mu.Lock()
+	defer peer.mu.Unlock()
+
+	// application level heartbeat
+	if err := peer.connection.WriteJSON(types.WebSocketMessage{
+		Event: event.SYSTEM_HEARTBEAT,
+	}); err != nil {
+		return err
+	}
+
+	return peer.connection.WriteMessage(websocket.PingMessage, nil)
+}
+
+func (peer *WebSocketPeerCtx) Destroy(reason string) {
+	peer.Send(
+		event.SYSTEM_DISCONNECT,
+		message.SystemDisconnect{
+			Message: reason,
+		})
+
+	peer.mu.Lock()
+	defer peer.mu.Unlock()
+
+	err := peer.connection.Close()
+	peer.logger.Err(err).Msg("peer connection destroyed")
+}