fix(F1): add OnConnect/OnDisconnect callbacks to fire ws_connect/ws_disconnect pipelines

The WebSocket hub's register channel fires when a new connection is added, but
the wsTrigger only listened for inbound messages. Add global connect/disconnect
handler hooks (same pattern as the existing message handler) so the trigger can
call TriggerCallback("connect", ...) and TriggerCallback("disconnect", ...).

- trigger_websocket.go: globalWSConnectHandler + globalWSDisconnectHandler vars,
  set/call helpers, wsTrigger.Start wires both; Stop clears all three handlers.
- module_ws_server.go: fire callGlobalWSConnectHandler in a goroutine after
  hub.register so the welcome message can be sent immediately on connect.
- connection.go: fire callGlobalWSDisconnectHandler from readPump defer so the
  ws_disconnect pipeline triggers when the client's read loop exits.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: intel352

internal/connection.go

@@ -18,6 +18,7 @@ type connection struct {
 
 func (c *connection) readPump(onMessage func(connID string, msg []byte)) {
 	defer func() {
+		callGlobalWSDisconnectHandler(c.id)
 		c.hub.unregister <- c
 		c.close()
 	}()

internal/module_ws_server.go

@@ -139,6 +139,9 @@ func (m *wsServerModule) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 	}
 
 	m.hub.register <- conn
+	// Fire connect event after the connection is registered in the hub so that
+	// ws_connect pipelines (e.g. welcome message) can send immediately.
+	go callGlobalWSConnectHandler(connID)
 	go conn.writePump()
 	go conn.readPump(func(connID string, msg []byte) {
 		callGlobalWSMessageHandler(connID, msg)

internal/trigger_websocket.go

@@ -15,6 +15,14 @@ import (
 var (
 	globalWSMessageHandler   func(connID string, msg []byte)
 	globalWSMessageHandlerMu sync.RWMutex
+
+	// globalWSConnectHandler fires once per new connection, before the first message.
+	globalWSConnectHandler   func(connID string)
+	globalWSConnectHandlerMu sync.RWMutex
+
+	// globalWSDisconnectHandler fires when a connection closes.
+	globalWSDisconnectHandler   func(connID string)
+	globalWSDisconnectHandlerMu sync.RWMutex
 )
 
 func setGlobalWSMessageHandler(h func(connID string, msg []byte)) {
@@ -34,6 +42,40 @@ func callGlobalWSMessageHandler(connID string, msg []byte) {
 	}
 }
 
+func setGlobalWSConnectHandler(h func(connID string)) {
+	globalWSConnectHandlerMu.Lock()
+	defer globalWSConnectHandlerMu.Unlock()
+	globalWSConnectHandler = h
+}
+
+// callGlobalWSConnectHandler is called by wsServerModule.ServeHTTP after a new
+// connection is registered in the hub.
+func callGlobalWSConnectHandler(connID string) {
+	globalWSConnectHandlerMu.RLock()
+	h := globalWSConnectHandler
+	globalWSConnectHandlerMu.RUnlock()
+	if h != nil {
+		h(connID)
+	}
+}
+
+func setGlobalWSDisconnectHandler(h func(connID string)) {
+	globalWSDisconnectHandlerMu.Lock()
+	defer globalWSDisconnectHandlerMu.Unlock()
+	globalWSDisconnectHandler = h
+}
+
+// callGlobalWSDisconnectHandler is called by connection.readPump when a
+// connection's read loop exits (i.e. the client disconnected).
+func callGlobalWSDisconnectHandler(connID string) {
+	globalWSDisconnectHandlerMu.RLock()
+	h := globalWSDisconnectHandler
+	globalWSDisconnectHandlerMu.RUnlock()
+	if h != nil {
+		h(connID)
+	}
+}
+
 // wsTrigger implements sdk.ModuleInstance for the "websocket" trigger type.
 // The host engine creates this via CreateModule("websocket", ...) and calls
 // Init/Start/Stop to manage its lifecycle (same pattern as RemoteTrigger).
@@ -46,6 +88,12 @@ func callGlobalWSMessageHandler(connID string, msg []byte) {
 //	payload      — decoded JSON object (if the message is valid JSON)
 //	room         — first room the connection belongs to (empty if none)
 //	rooms        — all rooms the connection belongs to
+//
+// Connect/disconnect lifecycle events are also fired:
+//
+//	event "connect"    — fired immediately after the connection is registered;
+//	                     only connectionId is populated (no message/payload).
+//	event "disconnect" — fired when the read loop exits (client gone).
 type wsTrigger struct {
 	cb sdk.TriggerCallback
 }
@@ -97,10 +145,31 @@ func (t *wsTrigger) Start(_ context.Context) error {
 
 		_ = t.cb("message", data)
 	})
+
+	setGlobalWSConnectHandler(func(connID string) {
+		if t.cb == nil {
+			return
+		}
+		_ = t.cb("connect", map[string]any{
+			"connectionId": connID,
+		})
+	})
+
+	setGlobalWSDisconnectHandler(func(connID string) {
+		if t.cb == nil {
+			return
+		}
+		_ = t.cb("disconnect", map[string]any{
+			"connectionId": connID,
+		})
+	})
+
 	return nil
 }
 
 func (t *wsTrigger) Stop(_ context.Context) error {
 	setGlobalWSMessageHandler(nil)
+	setGlobalWSConnectHandler(nil)
+	setGlobalWSDisconnectHandler(nil)
 	return nil
 }