@vira-ui/cli 0.4.1-alpha → 1.0.1

package/dist/go/mainGo.js

@@ -4,524 +4,559 @@ exports.mainGo = void 0;
 exports.mainGo = `package main
 
 import (
-  "context"
-  "encoding/json"
-  "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/gorilla/websocket"
-  "github.com/google/uuid"
-  "github.com/rs/zerolog"
-  "github.com/rs/zerolog/log"
-
-  "vira-engine-backend/internal/cache"
-  "vira-engine-backend/internal/config"
-  "vira-engine-backend/internal/db"
-  "vira-engine-backend/internal/events"
+	"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"
+	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"\`
+	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
+	*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),
-  }
+	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.mu.Unlock()
+	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)
-  h.mu.Unlock()
-  _ = c.Close()
+	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()
+	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)
-    _ = c.WriteMessage(websocket.TextMessage, raw)
-  }
+	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()
+	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 := c.WriteMessage(websocket.TextMessage, raw); err != nil {
-      _ = c.Close()
-      h.remove(c)
-    }
-  }
+	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)
+	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)
+	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 },
+	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)
-
-    go func(c *websocket.Conn) {
-      pingInterval := 15 * time.Second
-      ping := time.NewTicker(pingInterval)
-      defer ping.Stop()
-      defer hub.remove(c)
-      for {
-        select {
-        case <-ping.C:
-          _ = c.WriteMessage(websocket.TextMessage, []byte(fmt.Sprintf("{\"type\":\"ping\",\"ts\":%d}", time.Now().UnixMilli())))
-        default:
-          _, msg, err := c.ReadMessage()
-          if err != nil {
-            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})
-            _ = c.WriteMessage(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})
-            _ = c.WriteMessage(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,
-              })
-              _ = c.WriteMessage(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,
-              })
-              _ = c.WriteMessage(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(),
-            })
-            _ = c.WriteMessage(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()})
-            _ = c.WriteMessage(websocket.TextMessage, pong)
-          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")
-  }
+	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))
-    })
-  }
+	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")
-    })
-  }
+	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)
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(status)
+	_ = json.NewEncoder(w).Encode(payload)
 }
 
 func httpAddr(port int) string {
-  return ":" + strconv.Itoa(port)
+	return ":" + strconv.Itoa(port)
 }
 `;