@vira-ui/cli 0.3.3-alpha → 0.4.1-alpha

package/dist/go/mainGo.js

@@ -0,0 +1,527 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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"
+)
+
+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
+}
+
+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),
+  }
+}
+
+func (h *wsHub) add(c *websocket.Conn) {
+  h.mu.Lock()
+  h.clients[c] = true
+  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()
+}
+
+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)
+    _ = c.WriteMessage(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 := c.WriteMessage(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)
+
+    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")
+  }
+}
+
+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)
+}
+`;

package/dist/go/readme.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readme = void 0;
+exports.readme = `# Vira Engine Monorepo (scaffold)
+
+Структура:
+- frontend/ — Vite + Vira UI приложение
+- backend/ — Go API (стаб)
+- ui/ — Vira UI пакет/шоукейсы (vite)
+- cli/ — CLI расширения/плагины
+- plugins/ — интеграции
+- migrations/ — SQL/Go миграции
+- deploy/ — docker-compose/devops артефакты
+`;

package/dist/go/redisGo.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.redisGo = void 0;
+exports.redisGo = `package cache
+
+import (
+  "context"
+  "fmt"
+  "time"
+
+  "github.com/redis/go-redis/v9"
+  "github.com/rs/zerolog"
+
+  "vira-engine-backend/internal/config"
+)
+
+func NewRedisClient(ctx context.Context, cfg config.Config, logger zerolog.Logger) (*redis.Client, error) {
+  addr := fmt.Sprintf("%s:%d", cfg.Redis.Host, cfg.Redis.Port)
+  client := redis.NewClient(&redis.Options{
+    Addr:     addr,
+    Password: cfg.Redis.Password,
+    DB:       cfg.Redis.DB,
+    ReadTimeout:  3 * time.Second,
+    WriteTimeout: 3 * time.Second,
+    DialTimeout:  3 * time.Second,
+  })
+
+  if _, err := client.Ping(ctx).Result(); err != nil {
+    return nil, fmt.Errorf("ping redis: %w", err)
+  }
+
+  logger.Info().Str("redis.addr", addr).Int("redis.db", cfg.Redis.DB).Msg("redis ready")
+  return client, nil
+}
+`;

package/dist/go/redisYaml.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.redisYaml = void 0;
+exports.redisYaml = `host: localhost
+port: 6379
+db: 0
+password: ""
+`;

package/dist/go/registryGo.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registryGo = void 0;
+exports.registryGo = `package events
+
+import (
+  "context"
+  "github.com/gorilla/websocket"
+)
+
+// Registry holds all registered event handlers.
+var Registry = make(map[string]EventHandler)
+
+// Register registers an event handler by name.
+func Register(name string, handler EventHandler) {
+  Registry[name] = handler
+}
+
+// RegisterAll registers multiple handlers at once.
+func RegisterAll(handlers map[string]EventHandler) {
+  for name, handler := range handlers {
+    Registry[name] = handler
+  }
+}
+
+// Get returns a handler by name.
+func Get(name string) (EventHandler, bool) {
+  handler, ok := Registry[name]
+  return handler, ok
+}
+
+// Apply registers all handlers from Registry into a Hub.
+func (h *Hub) ApplyRegistry() {
+  h.mu.Lock()
+  defer h.mu.Unlock()
+  for name, handler := range Registry {
+    h.events[name] = handler
+  }
+}
+
+// Example handler registration (auto-generated by CLI):
+// func init() {
+//   Register("demo.echo", handleDemoEvent)
+//   Register("task.update", handleTaskUpdate)
+//   Register("user.setStatus", handleUserStatus)
+// }
+`;

package/dist/go/sqlcYaml.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sqlcYaml = void 0;
+exports.sqlcYaml = `version: "2"
+sql:
+  - engine: "postgresql"
+    schema: "migrations"
+    queries: "queries"
+    gen:
+      go:
+        package: "gen"
+        out: "internal/db/gen"
+        sql_package: "pgx/v5"
+        emit_interface: true
+        emit_db_tags: true
+        emit_empty_slices: true
+`;