@vira-ui/cli 1.1.2 → 1.2.0

package/dist/go/mainGo.js

@@ -1,562 +1,562 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.mainGo = void 0;
-exports.mainGo = `package main
-
-import (
-	"context"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"net/http"
-	"os/signal"
-	"strconv"
-	"strings"
-	"sync"
-	"syscall"
-	"time"
-
-	"github.com/go-chi/chi/v5"
-	"github.com/go-chi/chi/v5/middleware"
-	"github.com/go-chi/cors"
-	"github.com/google/uuid"
-	"github.com/gorilla/websocket"
-	"github.com/rs/zerolog"
-
-	"vira-engine-backend/internal/cache"
-	"vira-engine-backend/internal/config"
-	"vira-engine-backend/internal/db"
-	"vira-engine-backend/internal/events"
-)
-
-type ctxKey string
-
-const (
-	ctxReqID  ctxKey = "reqID"
-	ctxUserID ctxKey = "userID"
-)
-
-type healthResponse struct {
-	Status string \`json:"status"\`
-	Time   string \`json:"time"\`
-	DB     string \`json:"db"\`
-	Redis  string \`json:"redis"\`
-	Kafka  string \`json:"kafka"\`
-}
-
-// wsHub wraps events.Hub with WebSocket connection management.
-type wsHub struct {
-	*events.Hub
-	mu          sync.Mutex
-	clients     map[*websocket.Conn]bool
-	subs        map[string]map[*websocket.Conn]bool
-	sessions    map[*websocket.Conn]string
-	sessionSubs map[string][]string // session -> channels (for persist/reconnect)
-	connMu      map[*websocket.Conn]*sync.Mutex
-}
-
-func newWSHub(eventHub *events.Hub) *wsHub {
-	return &wsHub{
-		Hub:         eventHub,
-		clients:     make(map[*websocket.Conn]bool),
-		subs:        make(map[string]map[*websocket.Conn]bool),
-		sessions:    make(map[*websocket.Conn]string),
-		sessionSubs: make(map[string][]string),
-		connMu:      make(map[*websocket.Conn]*sync.Mutex),
-	}
-}
-
-func (h *wsHub) add(c *websocket.Conn) {
-	h.mu.Lock()
-	h.clients[c] = true
-	h.connMu[c] = &sync.Mutex{}
-	h.mu.Unlock()
-}
-
-func (h *wsHub) remove(c *websocket.Conn) {
-	h.mu.Lock()
-	delete(h.clients, c)
-	for ch, set := range h.subs {
-		delete(set, c)
-		if len(set) == 0 {
-			delete(h.subs, ch)
-		}
-	}
-	delete(h.sessions, c)
-	delete(h.connMu, c)
-	h.mu.Unlock()
-	_ = c.Close()
-}
-
-// write serializes writes per connection to avoid concurrent writers.
-func (h *wsHub) write(c *websocket.Conn, msgType int, data []byte) error {
-	h.mu.Lock()
-	mu := h.connMu[c]
-	h.mu.Unlock()
-	if mu == nil {
-		return errors.New("conn mutex missing")
-	}
-	mu.Lock()
-	defer mu.Unlock()
-	return c.WriteMessage(msgType, data)
-}
-
-func (h *wsHub) setSession(c *websocket.Conn, session string) {
-	h.mu.Lock()
-	h.sessions[c] = session
-	// Restore previous subscriptions if session exists
-	if subs, ok := h.sessionSubs[session]; ok {
-		for _, ch := range subs {
-			if _, exists := h.subs[ch]; !exists {
-				h.subs[ch] = make(map[*websocket.Conn]bool)
-			}
-			h.subs[ch][c] = true
-		}
-	}
-	h.mu.Unlock()
-}
-
-func (h *wsHub) subscribe(c *websocket.Conn, channel string) {
-	h.mu.Lock()
-	if _, ok := h.subs[channel]; !ok {
-		h.subs[channel] = make(map[*websocket.Conn]bool)
-	}
-	h.subs[channel][c] = true
-	session := h.sessions[c]
-	if session != "" {
-		// Persist subscription for session
-		subs := h.sessionSubs[session]
-		found := false
-		for _, ch := range subs {
-			if ch == channel {
-				found = true
-				break
-			}
-		}
-		if !found {
-			h.sessionSubs[session] = append(subs, channel)
-		}
-	}
-	h.mu.Unlock()
-
-	// Send snapshot if available
-	if snap, version, ok := h.Snapshot(channel); ok {
-		msg := events.WSMessage{
-			Type:      "update",
-			Channel:   channel,
-			Data:      snap,
-			VersionNo: version,
-			Ts:        time.Now().UnixMilli(),
-		}
-		raw, _ := json.Marshal(msg)
-		_ = h.write(c, websocket.TextMessage, raw)
-	}
-}
-
-func (h *wsHub) unsubscribe(c *websocket.Conn, channel string) {
-	h.mu.Lock()
-	if set, ok := h.subs[channel]; ok {
-		delete(set, c)
-		if len(set) == 0 {
-			delete(h.subs, channel)
-		}
-	}
-	h.mu.Unlock()
-}
-
-func (h *wsHub) broadcast(channel string, raw json.RawMessage) {
-	h.mu.Lock()
-	targets := h.subs[channel]
-	h.mu.Unlock()
-
-	if len(targets) == 0 {
-		return
-	}
-
-	for c := range targets {
-		if err := h.write(c, websocket.TextMessage, raw); err != nil {
-			_ = c.Close()
-			h.remove(c)
-		}
-	}
-}
-
-func handleDemoEvent(ctx context.Context, hub events.EventEmitter, conn *websocket.Conn, msg events.WSMessage) {
-	var payload map[string]any
-	if len(msg.Data) > 0 {
-		_ = json.Unmarshal(msg.Data, &payload)
-	}
-	ch := "demo"
-	if v, ok := payload["channel"].(string); ok && v != "" {
-		ch = v
-	}
-	hub.Update(ch, payload)
-}
-
-func init() {
-	events.Register("demo.echo", handleDemoEvent)
-	// Kanban handlers are auto-registered via registry_kanban.go (generated by CLI)
-}
-
-var upgrader = websocket.Upgrader{
-	CheckOrigin: func(r *http.Request) bool { return true },
-}
-
-func main() {
-	cfg := config.Load("config/app.yaml")
-	logger := config.NewLogger(cfg)
-	eventHub := events.NewHub()
-	hub := newWSHub(eventHub)
-	// Connect Hub's broadcast to wsHub's broadcast
-	events.SetBroadcaster(hub.broadcast)
-	// Apply state settings
-	if strings.ToLower(cfg.State.DiffMode) == "patch" {
-		eventHub.SetDiffMode(events.DiffModePatch)
-	}
-	if cfg.State.MaxHistory > 0 {
-		eventHub.SetHistoryLimit(cfg.State.MaxHistory)
-	}
-	eventHub.ApplyRegistry() // Apply auto-registered handlers
-
-	r := chi.NewRouter()
-	r.Use(middleware.RequestID)
-	r.Use(middleware.RealIP)
-	r.Use(middleware.Recoverer)
-	r.Use(cors.Handler(cors.Options{
-		AllowedOrigins:   []string{"*"},
-		AllowedMethods:   []string{"GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"},
-		AllowedHeaders:   []string{"Accept", "Authorization", "Content-Type", "X-User-ID", "X-Requested-With"},
-		ExposedHeaders:   []string{"Link"},
-		AllowCredentials: false,
-		MaxAge:           300,
-	}))
-	r.Use(requestContext(logger))
-	r.Use(httpLogger(logger))
-
-	ctx, stop := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM)
-	defer stop()
-
-	pool, err := db.NewPool(ctx, cfg, logger)
-	if err != nil {
-		logger.Fatal().Err(err).Msg("failed to init db pool")
-	}
-	defer pool.Close()
-
-	redisClient, err := cache.NewRedisClient(ctx, cfg, logger)
-	if err != nil {
-		logger.Fatal().Err(err).Msg("failed to init redis client")
-	}
-	defer redisClient.Close()
-
-	// Configure persistence
-	if strings.ToLower(cfg.State.Persist) == "redis" {
-		eventHub.SetStore(events.NewRedisStore(redisClient))
-		logger.Info().Msg("state persistence enabled: redis")
-	}
-	if cfg.State.TTLSec > 0 {
-		eventHub.SetTTL(cfg.State.TTLSec)
-	}
-
-	kafkaClient, err := events.NewKafka(cfg, logger)
-	if err != nil {
-		logger.Fatal().Err(err).Msg("failed to init kafka client")
-	}
-	defer kafkaClient.Close()
-
-	r.Get("/healthz", func(w http.ResponseWriter, r *http.Request) {
-		dbStatus := "ok"
-		if err := pool.Ping(r.Context()); err != nil {
-			dbStatus = fmt.Sprintf("error: %v", err)
-		}
-		redisStatus := "ok"
-		if _, err := redisClient.Ping(r.Context()).Result(); err != nil {
-			redisStatus = fmt.Sprintf("error: %v", err)
-		}
-		kafkaStatus := "ok"
-		if err := kafkaClient.Ping(r.Context()); err != nil {
-			kafkaStatus = fmt.Sprintf("error: %v", err)
-		}
-		respondJSON(w, http.StatusOK, healthResponse{
-			Status: "ok",
-			Time:   time.Now().UTC().Format(time.RFC3339),
-			DB:     dbStatus,
-			Redis:  redisStatus,
-			Kafka:  kafkaStatus,
-		})
-	})
-
-	// Debug: current state snapshot
-	r.Get("/api/state/{channel}", func(w http.ResponseWriter, r *http.Request) {
-		ch := chi.URLParam(r, "channel")
-		if ch == "" {
-			respondJSON(w, http.StatusBadRequest, map[string]string{"error": "channel required"})
-			return
-		}
-		snap, ver, ok := eventHub.Snapshot(ch)
-		if !ok {
-			respondJSON(w, http.StatusNotFound, map[string]string{"error": "not found"})
-			return
-		}
-		respondJSON(w, http.StatusOK, map[string]any{
-			"channel":   ch,
-			"versionNo": ver,
-			"data":      json.RawMessage(snap),
-		})
-	})
-
-	// Debug: replay from version
-	r.Get("/api/replay/{channel}", func(w http.ResponseWriter, r *http.Request) {
-		ch := chi.URLParam(r, "channel")
-		if ch == "" {
-			respondJSON(w, http.StatusBadRequest, map[string]string{"error": "channel required"})
-			return
-		}
-		fromStr := r.URL.Query().Get("from")
-		var from int64 = 0
-		if fromStr != "" {
-			if v, err := strconv.ParseInt(fromStr, 10, 64); err == nil {
-				from = v
-			}
-		}
-		snapshots := eventHub.Replay(ch, from)
-		respondJSON(w, http.StatusOK, map[string]any{
-			"channel":   ch,
-			"from":      from,
-			"snapshots": snapshots,
-		})
-	})
-
-	r.Get("/ws", func(w http.ResponseWriter, r *http.Request) {
-		conn, err := upgrader.Upgrade(w, r, nil)
-		if err != nil {
-			logger.Error().Err(err).Msg("upgrade ws")
-			return
-		}
-		hub.add(conn)
-		logger.Info().Msg("ws connected")
-
-		go func(c *websocket.Conn) {
-			pingInterval := 15 * time.Second
-			ping := time.NewTicker(pingInterval)
-			defer ping.Stop()
-			defer hub.remove(c)
-
-			// Handle ping in separate goroutine
-			go func() {
-				for range ping.C {
-					if err := hub.write(c, websocket.TextMessage, []byte(fmt.Sprintf(\`{"type":"ping","ts":%d}\`, time.Now().UnixMilli()))); err != nil {
-						return
-					}
-				}
-			}()
-
-			// Read messages in main goroutine
-			for {
-				_, msg, err := c.ReadMessage()
-				if err != nil {
-					if websocket.IsUnexpectedCloseError(err, websocket.CloseGoingAway, websocket.CloseAbnormalClosure) {
-						logger.Warn().Err(err).Msg("ws read error unexpected")
-					} else {
-						logger.Info().Err(err).Msg("ws read closed")
-					}
-					return
-				}
-				var m events.WSMessage
-				if err := json.Unmarshal(msg, &m); err != nil {
-					logger.Warn().Err(err).Msg("ws decode")
-					continue
-				}
-				switch m.Type {
-				case "sub":
-					for _, ch := range m.Channels {
-						if ch == "" {
-							continue
-						}
-						hub.subscribe(c, ch)
-					}
-					ack, _ := json.Marshal(events.WSMessage{Type: "sub_ack", Channels: m.Channels})
-					_ = hub.write(c, websocket.TextMessage, ack)
-				case "unsub":
-					for _, ch := range m.Channels {
-						if ch == "" {
-							continue
-						}
-						hub.unsubscribe(c, ch)
-					}
-					ack, _ := json.Marshal(events.WSMessage{Type: "unsub_ack", Channels: m.Channels})
-					_ = hub.write(c, websocket.TextMessage, ack)
-				case "handshake":
-					// Validate protocol version
-					if m.Version != "" && m.Version != events.ProtocolVersion() {
-						errMsg, _ := json.Marshal(events.WSMessage{
-							Type:    "error",
-							Code:    "version_mismatch",
-							Message: fmt.Sprintf("Protocol version mismatch: client=%s, server=%s", m.Version, events.ProtocolVersion()),
-							Retry:   false,
-						})
-						_ = hub.write(c, websocket.TextMessage, errMsg)
-						c.Close()
-						return
-					}
-					// Auth token check
-					if cfg.Auth.Token != "" && m.Auth != cfg.Auth.Token {
-						errMsg, _ := json.Marshal(events.WSMessage{
-							Type:    "error",
-							Code:    "unauthorized",
-							Message: "Invalid auth token",
-							Retry:   false,
-						})
-						_ = hub.write(c, websocket.TextMessage, errMsg)
-						c.Close()
-						return
-					}
-					session := m.Session
-					if session == "" {
-						session = uuid.NewString()
-					}
-					hub.setSession(c, session)
-					ack, _ := json.Marshal(events.WSMessage{
-						Type:     "ack",
-						Session:  session,
-						Interval: pingInterval.Milliseconds(),
-						Version:  events.ProtocolVersion(),
-						Ts:       time.Now().UnixMilli(),
-					})
-					_ = hub.write(c, websocket.TextMessage, ack)
-				case "event":
-					if m.Name != "" {
-						// Check idempotency (msgId dedup)
-						if m.MsgID != "" && eventHub.CheckMsgID(m.MsgID) {
-							// Duplicate message, ignore
-							continue
-						}
-						if handler, ok := eventHub.Get(m.Name); ok {
-							handler(context.Background(), eventHub, c, m)
-						}
-					}
-				case "update":
-					if m.Channel != "" {
-						// Check idempotency
-						if m.MsgID != "" && eventHub.CheckMsgID(m.MsgID) {
-							continue
-						}
-						var payload any
-						if len(m.Data) > 0 {
-							_ = json.Unmarshal(m.Data, &payload)
-						}
-						eventHub.Update(m.Channel, payload)
-					}
-				case "diff":
-					if m.Channel != "" {
-						// Check idempotency
-						if m.MsgID != "" && eventHub.CheckMsgID(m.MsgID) {
-							continue
-						}
-						var patch any
-						if len(m.Patch) > 0 {
-							_ = json.Unmarshal(m.Patch, &patch)
-						}
-						eventHub.Diff(m.Channel, patch)
-					}
-				case "ping":
-					pong, _ := json.Marshal(events.WSMessage{Type: "pong", Ts: time.Now().UnixMilli()})
-					if err := hub.write(c, websocket.TextMessage, pong); err != nil {
-						logger.Warn().Err(err).Msg("ws write pong error")
-						return
-					}
-				case "pong":
-					// Client acknowledged ping, connection is healthy
-				default:
-					// ignore unknown
-				}
-			}
-		}(conn)
-	})
-
-	r.Post("/api/demo", func(w http.ResponseWriter, r *http.Request) {
-		var payload map[string]any
-		if err := json.NewDecoder(r.Body).Decode(&payload); err != nil {
-			respondJSON(w, http.StatusBadRequest, map[string]string{"error": "invalid json"})
-			return
-		}
-		ch := "demo"
-		if v, ok := payload["channel"].(string); ok && v != "" {
-			ch = v
-		}
-		eventHub.Emit(ch, payload)
-		respondJSON(w, http.StatusOK, map[string]string{"status": "ok"})
-	})
-
-	srv := &http.Server{
-		Addr:    httpAddr(cfg.HTTP.Port),
-		Handler: r,
-	}
-
-	logger.Info().Str("addr", srv.Addr).Msg("Vira Engine stub API listening")
-	go func() {
-		if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
-			logger.Fatal().Err(err).Msg("server error")
-		}
-	}()
-
-	<-ctx.Done()
-	logger.Info().Msg("shutting down...")
-	shutdownCtx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
-	defer cancel()
-	if err := srv.Shutdown(shutdownCtx); err != nil {
-		logger.Fatal().Err(err).Msg("server shutdown error")
-	}
-}
-
-func requestContext(logger zerolog.Logger) func(next http.Handler) http.Handler {
-	return func(next http.Handler) http.Handler {
-		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-			reqID := middleware.GetReqID(r.Context())
-			userID := r.Header.Get("X-User-ID")
-
-			ctx := context.WithValue(r.Context(), ctxReqID, reqID)
-			if userID != "" {
-				ctx = context.WithValue(ctx, ctxUserID, userID)
-			}
-
-			next.ServeHTTP(w, r.WithContext(ctx))
-		})
-	}
-}
-
-func httpLogger(logger zerolog.Logger) func(next http.Handler) http.Handler {
-	return func(next http.Handler) http.Handler {
-		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-			started := time.Now()
-			ww := middleware.NewWrapResponseWriter(w, r.ProtoMajor)
-
-			next.ServeHTTP(ww, r)
-
-			evt := logger.Info()
-			if reqID, ok := r.Context().Value(ctxReqID).(string); ok && reqID != "" {
-				evt = evt.Str("reqID", reqID)
-			}
-			if userID, ok := r.Context().Value(ctxUserID).(string); ok && userID != "" {
-				evt = evt.Str("userID", userID)
-			}
-
-			evt.
-				Str("method", r.Method).
-				Str("path", r.URL.Path).
-				Int("status", ww.Status()).
-				Dur("latency", time.Since(started)).
-				Msg("http_request")
-		})
-	}
-}
-
-func respondJSON(w http.ResponseWriter, status int, payload any) {
-	w.Header().Set("Content-Type", "application/json")
-	w.WriteHeader(status)
-	_ = json.NewEncoder(w).Encode(payload)
-}
-
-func httpAddr(port int) string {
-	return ":" + strconv.Itoa(port)
-}
+exports.mainGo = `package main
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"net/http"
+	"os/signal"
+	"strconv"
+	"strings"
+	"sync"
+	"syscall"
+	"time"
+
+	"github.com/go-chi/chi/v5"
+	"github.com/go-chi/chi/v5/middleware"
+	"github.com/go-chi/cors"
+	"github.com/google/uuid"
+	"github.com/gorilla/websocket"
+	"github.com/rs/zerolog"
+
+	"vira-engine-backend/internal/cache"
+	"vira-engine-backend/internal/config"
+	"vira-engine-backend/internal/db"
+	"vira-engine-backend/internal/events"
+)
+
+type ctxKey string
+
+const (
+	ctxReqID  ctxKey = "reqID"
+	ctxUserID ctxKey = "userID"
+)
+
+type healthResponse struct {
+	Status string \`json:"status"\`
+	Time   string \`json:"time"\`
+	DB     string \`json:"db"\`
+	Redis  string \`json:"redis"\`
+	Kafka  string \`json:"kafka"\`
+}
+
+// wsHub wraps events.Hub with WebSocket connection management.
+type wsHub struct {
+	*events.Hub
+	mu          sync.Mutex
+	clients     map[*websocket.Conn]bool
+	subs        map[string]map[*websocket.Conn]bool
+	sessions    map[*websocket.Conn]string
+	sessionSubs map[string][]string // session -> channels (for persist/reconnect)
+	connMu      map[*websocket.Conn]*sync.Mutex
+}
+
+func newWSHub(eventHub *events.Hub) *wsHub {
+	return &wsHub{
+		Hub:         eventHub,
+		clients:     make(map[*websocket.Conn]bool),
+		subs:        make(map[string]map[*websocket.Conn]bool),
+		sessions:    make(map[*websocket.Conn]string),
+		sessionSubs: make(map[string][]string),
+		connMu:      make(map[*websocket.Conn]*sync.Mutex),
+	}
+}
+
+func (h *wsHub) add(c *websocket.Conn) {
+	h.mu.Lock()
+	h.clients[c] = true
+	h.connMu[c] = &sync.Mutex{}
+	h.mu.Unlock()
+}
+
+func (h *wsHub) remove(c *websocket.Conn) {
+	h.mu.Lock()
+	delete(h.clients, c)
+	for ch, set := range h.subs {
+		delete(set, c)
+		if len(set) == 0 {
+			delete(h.subs, ch)
+		}
+	}
+	delete(h.sessions, c)
+	delete(h.connMu, c)
+	h.mu.Unlock()
+	_ = c.Close()
+}
+
+// write serializes writes per connection to avoid concurrent writers.
+func (h *wsHub) write(c *websocket.Conn, msgType int, data []byte) error {
+	h.mu.Lock()
+	mu := h.connMu[c]
+	h.mu.Unlock()
+	if mu == nil {
+		return errors.New("conn mutex missing")
+	}
+	mu.Lock()
+	defer mu.Unlock()
+	return c.WriteMessage(msgType, data)
+}
+
+func (h *wsHub) setSession(c *websocket.Conn, session string) {
+	h.mu.Lock()
+	h.sessions[c] = session
+	// Restore previous subscriptions if session exists
+	if subs, ok := h.sessionSubs[session]; ok {
+		for _, ch := range subs {
+			if _, exists := h.subs[ch]; !exists {
+				h.subs[ch] = make(map[*websocket.Conn]bool)
+			}
+			h.subs[ch][c] = true
+		}
+	}
+	h.mu.Unlock()
+}
+
+func (h *wsHub) subscribe(c *websocket.Conn, channel string) {
+	h.mu.Lock()
+	if _, ok := h.subs[channel]; !ok {
+		h.subs[channel] = make(map[*websocket.Conn]bool)
+	}
+	h.subs[channel][c] = true
+	session := h.sessions[c]
+	if session != "" {
+		// Persist subscription for session
+		subs := h.sessionSubs[session]
+		found := false
+		for _, ch := range subs {
+			if ch == channel {
+				found = true
+				break
+			}
+		}
+		if !found {
+			h.sessionSubs[session] = append(subs, channel)
+		}
+	}
+	h.mu.Unlock()
+
+	// Send snapshot if available
+	if snap, version, ok := h.Snapshot(channel); ok {
+		msg := events.WSMessage{
+			Type:      "update",
+			Channel:   channel,
+			Data:      snap,
+			VersionNo: version,
+			Ts:        time.Now().UnixMilli(),
+		}
+		raw, _ := json.Marshal(msg)
+		_ = h.write(c, websocket.TextMessage, raw)
+	}
+}
+
+func (h *wsHub) unsubscribe(c *websocket.Conn, channel string) {
+	h.mu.Lock()
+	if set, ok := h.subs[channel]; ok {
+		delete(set, c)
+		if len(set) == 0 {
+			delete(h.subs, channel)
+		}
+	}
+	h.mu.Unlock()
+}
+
+func (h *wsHub) broadcast(channel string, raw json.RawMessage) {
+	h.mu.Lock()
+	targets := h.subs[channel]
+	h.mu.Unlock()
+
+	if len(targets) == 0 {
+		return
+	}
+
+	for c := range targets {
+		if err := h.write(c, websocket.TextMessage, raw); err != nil {
+			_ = c.Close()
+			h.remove(c)
+		}
+	}
+}
+
+func handleDemoEvent(ctx context.Context, hub events.EventEmitter, conn *websocket.Conn, msg events.WSMessage) {
+	var payload map[string]any
+	if len(msg.Data) > 0 {
+		_ = json.Unmarshal(msg.Data, &payload)
+	}
+	ch := "demo"
+	if v, ok := payload["channel"].(string); ok && v != "" {
+		ch = v
+	}
+	hub.Update(ch, payload)
+}
+
+func init() {
+	events.Register("demo.echo", handleDemoEvent)
+	// Kanban handlers are auto-registered via registry_kanban.go (generated by CLI)
+}
+
+var upgrader = websocket.Upgrader{
+	CheckOrigin: func(r *http.Request) bool { return true },
+}
+
+func main() {
+	cfg := config.Load("config/app.yaml")
+	logger := config.NewLogger(cfg)
+	eventHub := events.NewHub()
+	hub := newWSHub(eventHub)
+	// Connect Hub's broadcast to wsHub's broadcast
+	events.SetBroadcaster(hub.broadcast)
+	// Apply state settings
+	if strings.ToLower(cfg.State.DiffMode) == "patch" {
+		eventHub.SetDiffMode(events.DiffModePatch)
+	}
+	if cfg.State.MaxHistory > 0 {
+		eventHub.SetHistoryLimit(cfg.State.MaxHistory)
+	}
+	eventHub.ApplyRegistry() // Apply auto-registered handlers
+
+	r := chi.NewRouter()
+	r.Use(middleware.RequestID)
+	r.Use(middleware.RealIP)
+	r.Use(middleware.Recoverer)
+	r.Use(cors.Handler(cors.Options{
+		AllowedOrigins:   []string{"*"},
+		AllowedMethods:   []string{"GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"},
+		AllowedHeaders:   []string{"Accept", "Authorization", "Content-Type", "X-User-ID", "X-Requested-With"},
+		ExposedHeaders:   []string{"Link"},
+		AllowCredentials: false,
+		MaxAge:           300,
+	}))
+	r.Use(requestContext(logger))
+	r.Use(httpLogger(logger))
+
+	ctx, stop := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM)
+	defer stop()
+
+	pool, err := db.NewPool(ctx, cfg, logger)
+	if err != nil {
+		logger.Fatal().Err(err).Msg("failed to init db pool")
+	}
+	defer pool.Close()
+
+	redisClient, err := cache.NewRedisClient(ctx, cfg, logger)
+	if err != nil {
+		logger.Fatal().Err(err).Msg("failed to init redis client")
+	}
+	defer redisClient.Close()
+
+	// Configure persistence
+	if strings.ToLower(cfg.State.Persist) == "redis" {
+		eventHub.SetStore(events.NewRedisStore(redisClient))
+		logger.Info().Msg("state persistence enabled: redis")
+	}
+	if cfg.State.TTLSec > 0 {
+		eventHub.SetTTL(cfg.State.TTLSec)
+	}
+
+	kafkaClient, err := events.NewKafka(cfg, logger)
+	if err != nil {
+		logger.Fatal().Err(err).Msg("failed to init kafka client")
+	}
+	defer kafkaClient.Close()
+
+	r.Get("/healthz", func(w http.ResponseWriter, r *http.Request) {
+		dbStatus := "ok"
+		if err := pool.Ping(r.Context()); err != nil {
+			dbStatus = fmt.Sprintf("error: %v", err)
+		}
+		redisStatus := "ok"
+		if _, err := redisClient.Ping(r.Context()).Result(); err != nil {
+			redisStatus = fmt.Sprintf("error: %v", err)
+		}
+		kafkaStatus := "ok"
+		if err := kafkaClient.Ping(r.Context()); err != nil {
+			kafkaStatus = fmt.Sprintf("error: %v", err)
+		}
+		respondJSON(w, http.StatusOK, healthResponse{
+			Status: "ok",
+			Time:   time.Now().UTC().Format(time.RFC3339),
+			DB:     dbStatus,
+			Redis:  redisStatus,
+			Kafka:  kafkaStatus,
+		})
+	})
+
+	// Debug: current state snapshot
+	r.Get("/api/state/{channel}", func(w http.ResponseWriter, r *http.Request) {
+		ch := chi.URLParam(r, "channel")
+		if ch == "" {
+			respondJSON(w, http.StatusBadRequest, map[string]string{"error": "channel required"})
+			return
+		}
+		snap, ver, ok := eventHub.Snapshot(ch)
+		if !ok {
+			respondJSON(w, http.StatusNotFound, map[string]string{"error": "not found"})
+			return
+		}
+		respondJSON(w, http.StatusOK, map[string]any{
+			"channel":   ch,
+			"versionNo": ver,
+			"data":      json.RawMessage(snap),
+		})
+	})
+
+	// Debug: replay from version
+	r.Get("/api/replay/{channel}", func(w http.ResponseWriter, r *http.Request) {
+		ch := chi.URLParam(r, "channel")
+		if ch == "" {
+			respondJSON(w, http.StatusBadRequest, map[string]string{"error": "channel required"})
+			return
+		}
+		fromStr := r.URL.Query().Get("from")
+		var from int64 = 0
+		if fromStr != "" {
+			if v, err := strconv.ParseInt(fromStr, 10, 64); err == nil {
+				from = v
+			}
+		}
+		snapshots := eventHub.Replay(ch, from)
+		respondJSON(w, http.StatusOK, map[string]any{
+			"channel":   ch,
+			"from":      from,
+			"snapshots": snapshots,
+		})
+	})
+
+	r.Get("/ws", func(w http.ResponseWriter, r *http.Request) {
+		conn, err := upgrader.Upgrade(w, r, nil)
+		if err != nil {
+			logger.Error().Err(err).Msg("upgrade ws")
+			return
+		}
+		hub.add(conn)
+		logger.Info().Msg("ws connected")
+
+		go func(c *websocket.Conn) {
+			pingInterval := 15 * time.Second
+			ping := time.NewTicker(pingInterval)
+			defer ping.Stop()
+			defer hub.remove(c)
+
+			// Handle ping in separate goroutine
+			go func() {
+				for range ping.C {
+					if err := hub.write(c, websocket.TextMessage, []byte(fmt.Sprintf(\`{"type":"ping","ts":%d}\`, time.Now().UnixMilli()))); err != nil {
+						return
+					}
+				}
+			}()
+
+			// Read messages in main goroutine
+			for {
+				_, msg, err := c.ReadMessage()
+				if err != nil {
+					if websocket.IsUnexpectedCloseError(err, websocket.CloseGoingAway, websocket.CloseAbnormalClosure) {
+						logger.Warn().Err(err).Msg("ws read error unexpected")
+					} else {
+						logger.Info().Err(err).Msg("ws read closed")
+					}
+					return
+				}
+				var m events.WSMessage
+				if err := json.Unmarshal(msg, &m); err != nil {
+					logger.Warn().Err(err).Msg("ws decode")
+					continue
+				}
+				switch m.Type {
+				case "sub":
+					for _, ch := range m.Channels {
+						if ch == "" {
+							continue
+						}
+						hub.subscribe(c, ch)
+					}
+					ack, _ := json.Marshal(events.WSMessage{Type: "sub_ack", Channels: m.Channels})
+					_ = hub.write(c, websocket.TextMessage, ack)
+				case "unsub":
+					for _, ch := range m.Channels {
+						if ch == "" {
+							continue
+						}
+						hub.unsubscribe(c, ch)
+					}
+					ack, _ := json.Marshal(events.WSMessage{Type: "unsub_ack", Channels: m.Channels})
+					_ = hub.write(c, websocket.TextMessage, ack)
+				case "handshake":
+					// Validate protocol version
+					if m.Version != "" && m.Version != events.ProtocolVersion() {
+						errMsg, _ := json.Marshal(events.WSMessage{
+							Type:    "error",
+							Code:    "version_mismatch",
+							Message: fmt.Sprintf("Protocol version mismatch: client=%s, server=%s", m.Version, events.ProtocolVersion()),
+							Retry:   false,
+						})
+						_ = hub.write(c, websocket.TextMessage, errMsg)
+						c.Close()
+						return
+					}
+					// Auth token check
+					if cfg.Auth.Token != "" && m.Auth != cfg.Auth.Token {
+						errMsg, _ := json.Marshal(events.WSMessage{
+							Type:    "error",
+							Code:    "unauthorized",
+							Message: "Invalid auth token",
+							Retry:   false,
+						})
+						_ = hub.write(c, websocket.TextMessage, errMsg)
+						c.Close()
+						return
+					}
+					session := m.Session
+					if session == "" {
+						session = uuid.NewString()
+					}
+					hub.setSession(c, session)
+					ack, _ := json.Marshal(events.WSMessage{
+						Type:     "ack",
+						Session:  session,
+						Interval: pingInterval.Milliseconds(),
+						Version:  events.ProtocolVersion(),
+						Ts:       time.Now().UnixMilli(),
+					})
+					_ = hub.write(c, websocket.TextMessage, ack)
+				case "event":
+					if m.Name != "" {
+						// Check idempotency (msgId dedup)
+						if m.MsgID != "" && eventHub.CheckMsgID(m.MsgID) {
+							// Duplicate message, ignore
+							continue
+						}
+						if handler, ok := eventHub.Get(m.Name); ok {
+							handler(context.Background(), eventHub, c, m)
+						}
+					}
+				case "update":
+					if m.Channel != "" {
+						// Check idempotency
+						if m.MsgID != "" && eventHub.CheckMsgID(m.MsgID) {
+							continue
+						}
+						var payload any
+						if len(m.Data) > 0 {
+							_ = json.Unmarshal(m.Data, &payload)
+						}
+						eventHub.Update(m.Channel, payload)
+					}
+				case "diff":
+					if m.Channel != "" {
+						// Check idempotency
+						if m.MsgID != "" && eventHub.CheckMsgID(m.MsgID) {
+							continue
+						}
+						var patch any
+						if len(m.Patch) > 0 {
+							_ = json.Unmarshal(m.Patch, &patch)
+						}
+						eventHub.Diff(m.Channel, patch)
+					}
+				case "ping":
+					pong, _ := json.Marshal(events.WSMessage{Type: "pong", Ts: time.Now().UnixMilli()})
+					if err := hub.write(c, websocket.TextMessage, pong); err != nil {
+						logger.Warn().Err(err).Msg("ws write pong error")
+						return
+					}
+				case "pong":
+					// Client acknowledged ping, connection is healthy
+				default:
+					// ignore unknown
+				}
+			}
+		}(conn)
+	})
+
+	r.Post("/api/demo", func(w http.ResponseWriter, r *http.Request) {
+		var payload map[string]any
+		if err := json.NewDecoder(r.Body).Decode(&payload); err != nil {
+			respondJSON(w, http.StatusBadRequest, map[string]string{"error": "invalid json"})
+			return
+		}
+		ch := "demo"
+		if v, ok := payload["channel"].(string); ok && v != "" {
+			ch = v
+		}
+		eventHub.Emit(ch, payload)
+		respondJSON(w, http.StatusOK, map[string]string{"status": "ok"})
+	})
+
+	srv := &http.Server{
+		Addr:    httpAddr(cfg.HTTP.Port),
+		Handler: r,
+	}
+
+	logger.Info().Str("addr", srv.Addr).Msg("Vira Engine stub API listening")
+	go func() {
+		if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
+			logger.Fatal().Err(err).Msg("server error")
+		}
+	}()
+
+	<-ctx.Done()
+	logger.Info().Msg("shutting down...")
+	shutdownCtx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+	if err := srv.Shutdown(shutdownCtx); err != nil {
+		logger.Fatal().Err(err).Msg("server shutdown error")
+	}
+}
+
+func requestContext(logger zerolog.Logger) func(next http.Handler) http.Handler {
+	return func(next http.Handler) http.Handler {
+		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			reqID := middleware.GetReqID(r.Context())
+			userID := r.Header.Get("X-User-ID")
+
+			ctx := context.WithValue(r.Context(), ctxReqID, reqID)
+			if userID != "" {
+				ctx = context.WithValue(ctx, ctxUserID, userID)
+			}
+
+			next.ServeHTTP(w, r.WithContext(ctx))
+		})
+	}
+}
+
+func httpLogger(logger zerolog.Logger) func(next http.Handler) http.Handler {
+	return func(next http.Handler) http.Handler {
+		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			started := time.Now()
+			ww := middleware.NewWrapResponseWriter(w, r.ProtoMajor)
+
+			next.ServeHTTP(ww, r)
+
+			evt := logger.Info()
+			if reqID, ok := r.Context().Value(ctxReqID).(string); ok && reqID != "" {
+				evt = evt.Str("reqID", reqID)
+			}
+			if userID, ok := r.Context().Value(ctxUserID).(string); ok && userID != "" {
+				evt = evt.Str("userID", userID)
+			}
+
+			evt.
+				Str("method", r.Method).
+				Str("path", r.URL.Path).
+				Int("status", ww.Status()).
+				Dur("latency", time.Since(started)).
+				Msg("http_request")
+		})
+	}
+}
+
+func respondJSON(w http.ResponseWriter, status int, payload any) {
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(status)
+	_ = json.NewEncoder(w).Encode(payload)
+}
+
+func httpAddr(port int) string {
+	return ":" + strconv.Itoa(port)
+}
 `;