feat: Replace SSE with WebSocket for UI notifications (#36965)

* Closes #36942
* Fixes #19265 

Replaces the SSE-based push channel (`/user/events`) with a WebSocket
endpoint (`/-/ws`).

### What changes

- **New `/-/ws` endpoint** (authenticated). One WebSocket per origin,
shared across tabs via a single `SharedWorker`.
- **Pubsub broker** (`services/pubsub`) for fan-out by topic, behind a
`Broker` interface. `MemoryBroker` is the default (single process); a
Redis backend is available for multi-process setups, configured via
`[websocket].PUBSUB_TYPE` / `PUBSUB_CONN_STR`. The internal Gitea queue
was not usable here because it has FIFO/single-consumer semantics.
- **Push-only event production.** Events are emitted by write-triggered
notifiers — `NotificationCountChange`, `PublishStopwatchesForUser`, and
the logout publisher — wired into the existing `notify.Notifier`
interface. No server-side pollers.
- **Typed pub/sub on the client.** `web_src/js/modules/worker.ts` is a
singleton transport; features subscribe per event type via
`onUserEvent('notification-count', cb)` instead of branching on
`event.data.type`.
- **Wire contract** (`UserEventType` union) is shared between the worker
and consumers via `web_src/js/types.ts`, kept in sync with
`services/websocket/events.go`.
- **Client-side periodic polling fallback** kicks in only when the
WebSocket cannot be established (e.g. proxy blocks WS, browser lacks
module-SharedWorker support).

### What's removed

- `modules/eventsource` (SSE manager, run loop, messenger).
- `/user/events` route and `tests/integration/eventsource_test.go`.
- All server-side polling for stopwatches and notification counts.

### Stopwatch multi-tab fix

The navbar stopwatch icon was previously rendered conditionally on `{{if
$activeStopwatch}}`, so tabs loaded before the timer started had no DOM
element to update. The icon and popup are now always rendered (toggled
with `tw-hidden`), and the start/stop/cancel handlers POST silently so
all open tabs reflect the change in real time.

### Deployment note

WebSocket needs the upgrade headers to pass through a reverse proxy,
e.g. for nginx:

```nginx
proxy_set_header Upgrade $http_upgrade;
proxy_set_header Connection "upgrade";
```

Without them the WebSocket cannot be established, and after 3
consecutive failed opens the shared worker signals `push-unavailable`:
the notification count and stopwatch fall back to periodic polling on
the existing `[ui.notification]` timeouts. Real-time push is lost, the
features keep working. The reverse-proxy docs need the same note (see
the `docs-update-needed` label).

---------

Co-authored-by: silverwind <me@silverwind.io>
Co-authored-by: wxiaoguang <wxiaoguang@gmail.com>
Co-authored-by: Epid <rexmrj@gmail.com>

services/websocket/events.go

@@ -0,0 +1,53 @@
+// Copyright 2026 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package websocket
+
+import (
+	"bytes"
+
+	"gitea.dev/modules/json"
+	"gitea.dev/modules/setting"
+	"gitea.dev/services/pubsub"
+)
+
+// Wire contract with web_src/js/user-events.sharedworker.ts — keep in sync.
+const (
+	EventNotificationCount = "notification-count"
+	EventStopwatches       = "stopwatches"
+	EventLogout            = "logout"
+)
+
+type UserEventMessage[T any] struct {
+	EventType string `json:"eventType"`
+	EventData T      `json:"eventData"`
+}
+
+func publishUserEvent(userID int64, eventType string, eventData any) {
+	if pubsub.DefaultBroker == nil {
+		return
+	}
+	b := MakeUserEventMessage(eventType, eventData)
+	if b == nil {
+		return
+	}
+	pubsub.DefaultBroker.Publish(pubsub.UserTopic(userID), b)
+}
+
+func MakeUserEventMessage(eventType string, eventData any) []byte {
+	buf := &bytes.Buffer{}
+	buf.WriteString(eventType)
+	buf.WriteByte('\n')
+	err := json.MarshalWrite(buf, &UserEventMessage[any]{EventType: eventType, EventData: eventData})
+	payloadBytes := bytes.TrimSuffix(buf.Bytes(), []byte("\n")) // json v1 adds extra "\n" but we don't want it
+	if err != nil {
+		setting.PanicInDevOrTesting("websocket: marshal event: %v", err)
+		return nil
+	}
+	return payloadBytes
+}
+
+func ExtractUserEventMessage(b []byte) (string, []byte) {
+	eventType, eventDataBytes, _ := bytes.Cut(b, []byte("\n"))
+	return string(eventType), eventDataBytes
+}

services/websocket/logout_publisher.go

@@ -0,0 +1,12 @@
+// Copyright 2026 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package websocket
+
+type LogoutEventData struct {
+	SessionID string `json:"sessionID,omitempty"`
+}
+
+func PublishLogout(userID int64, sessionID string) {
+	publishUserEvent(userID, EventLogout, LogoutEventData{SessionID: sessionID})
+}

services/websocket/notification_notifier.go

@@ -0,0 +1,39 @@
+// Copyright 2026 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package websocket
+
+import (
+	"context"
+
+	activities_model "gitea.dev/models/activities"
+	"gitea.dev/models/db"
+	"gitea.dev/modules/log"
+	notify_service "gitea.dev/services/notify"
+	"gitea.dev/services/pubsub"
+)
+
+type notificationCountEventData struct {
+	Count int64 `json:"count"`
+}
+
+type wsNotifier struct {
+	notify_service.NullNotifier
+}
+
+var _ notify_service.Notifier = &wsNotifier{}
+
+func (n *wsNotifier) NotificationCountChange(ctx context.Context, userID int64) {
+	if !pubsub.DefaultBroker.HasTopicSubscribers(pubsub.UserTopic(userID)) {
+		return
+	}
+	count, err := db.Count[activities_model.Notification](ctx, activities_model.FindNotificationOptions{
+		UserID: userID,
+		Status: []activities_model.NotificationStatus{activities_model.NotificationStatusUnread},
+	})
+	if err != nil {
+		log.Error("websocket: count notifications for user %d: %v", userID, err)
+		return
+	}
+	publishUserEvent(userID, EventNotificationCount, notificationCountEventData{Count: count})
+}

services/websocket/notifier.go

@@ -0,0 +1,18 @@
+// Copyright 2026 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package websocket
+
+import (
+	notify_service "gitea.dev/services/notify"
+	"gitea.dev/services/pubsub"
+)
+
+func Init() error {
+	// the pubsub broker must be ready before the notifier starts publishing to it
+	if err := pubsub.Init(); err != nil {
+		return err
+	}
+	notify_service.RegisterNotifier(&wsNotifier{})
+	return nil
+}

services/websocket/stopwatch_notifier.go

@@ -0,0 +1,37 @@
+// Copyright 2026 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package websocket
+
+import (
+	"context"
+
+	"gitea.dev/models/db"
+	issues_model "gitea.dev/models/issues"
+	user_model "gitea.dev/models/user"
+	"gitea.dev/modules/log"
+	"gitea.dev/modules/util"
+	"gitea.dev/services/convert"
+	"gitea.dev/services/pubsub"
+)
+
+func (n *wsNotifier) StopwatchChanged(ctx context.Context, user *user_model.User) {
+	if !pubsub.DefaultBroker.HasTopicSubscribers(pubsub.UserTopic(user.ID)) {
+		return
+	}
+
+	sws, err := issues_model.GetUserStopwatches(ctx, user.ID, db.ListOptions{})
+	if err != nil {
+		log.Error("websocket: GetUserStopwatches %d: %v", user.ID, err)
+		return
+	}
+
+	apiStopWatches, err := convert.ToStopWatches(ctx, user, sws)
+	if err != nil {
+		if !issues_model.IsErrIssueNotExist(err) {
+			log.Error("websocket: ToStopWatches: %v", err)
+		}
+		return
+	}
+	publishUserEvent(user.ID, EventStopwatches, util.SliceNilAsEmpty(apiStopWatches))
+}