server

func (*Server) handleHMR(w http.ResponseWriter, r *http.Request)
{
	flusher, ok := w.(http.Flusher)
	if !ok {
		http.Error(w, "stream unsupported", http.StatusInternalServerError)
		return
	}

	w.Header().Set("Content-Type", "text/event-stream")
	w.Header().Set("Cache-Control", "no-cache")
	w.Header().Set("Connection", "keep-alive")

	client := make(chan []byte, 8)

	s.hmrMu.Lock()
	s.hmrClients[client] = struct{}{}
	s.hmrMu.Unlock()

	utils.Debug("hmr client connected")

	fmt.Fprintf(w, ": connected\n\n")
	flusher.Flush()

	defer func() {
		s.hmrMu.Lock()
		delete(s.hmrClients, client)
		s.hmrMu.Unlock()
		utils.Debug("hmr client disconnected")
	}()

	ping := time.NewTicker(30 * time.Second)
	defer ping.Stop()

	for {
		select {
		case msg, ok := <-client:
			if !ok {
				return
			}
			fmt.Fprintf(w, "data: %s\n\n", msg)
			flusher.Flush()
		case <-ping.C:
			fmt.Fprintf(w, ": ping\n\n")
			flusher.Flush()
		case <-r.Context().Done():
			return
		}
	}
}

func (*Server) broadcast(msg devMessage) error
{
	data, err := json.Marshal(msg)
	if err != nil {
		return err
	}

	s.hmrMu.Lock()
	defer s.hmrMu.Unlock()
	if len(s.hmrClients) == 0 {
		return nil
	}
	for ch := range s.hmrClients {
		select {
		case ch <- data:
		default:
			// Drop slow clients to avoid blocking rebuilds.
			delete(s.hmrClients, ch)
			close(ch)
		}
	}
	return nil
}

func (*Server) broadcastReload(path string) error
{
	rel := path
	if abs, err := filepath.Abs(path); err == nil {
		if cwd, err := filepath.Abs("."); err == nil {
			if r, err := filepath.Rel(cwd, abs); err == nil {
				rel = filepath.ToSlash(r)
			}
		}
	}
	utils.Debug(fmt.Sprintf("broadcasting reload for %s", rel))
	return s.broadcast(devMessage{Type: "reload", Path: rel})
}

func (*Server) broadcastTemplateUpdate(path, component, markup string) error
{
	rel := path
	if abs, err := filepath.Abs(path); err == nil {
		if cwd, err := filepath.Abs("."); err == nil {
			if r, err := filepath.Rel(cwd, abs); err == nil {
				rel = filepath.ToSlash(r)
			}
		}
	}
	utils.Debug(fmt.Sprintf("streaming template update for %s (%s)", rel, component))
	return s.broadcast(devMessage{Type: "rtml", Path: rel, Component: component, Markup: markup})
}

func (*Server) Start() error
{
	if err := build.Build(); err != nil {
		return err
	}

	// Detect build type from manifest to know if host components are enabled.
	s.buildType = readBuildType()
	var mux *http.ServeMux
	httpsPort := incrementPort(s.Port)
	if s.buildType == "ssc" {
		s.hostPort = incrementPort(httpsPort)
		if err := s.startHost(); err != nil {
			return err
		}
		target := &url.URL{Scheme: "http", Host: fmt.Sprintf("localhost:%s", s.hostPort)}
		proxy := httputil.NewSingleHostReverseProxy(target)
		mux = http.NewServeMux()
		mux.HandleFunc("/__rfw/hmr", s.handleHMR)
		mux.Handle("/", proxy)
		go func() {
			if err := http.ListenAndServe(":"+s.Port, mux); err != nil {
				utils.Fatal("Server failed: ", err)
			}
		}()
		go func() {
			if err := hostpkg.ListenAndServeTLSWithMux(":"+httpsPort, mux); err != nil {
				utils.Fatal("HTTPS server failed: ", err)
			}
		}()
	} else {
		root := filepath.Join("build", "client")
		mux = hostpkg.NewMux(root)
		mux.HandleFunc("/__rfw/hmr", s.handleHMR)
		go func() {
			if err := http.ListenAndServe(":"+s.Port, mux); err != nil {
				utils.Fatal("Server failed: ", err)
			}
		}()
		go func() {
			if err := hostpkg.ListenAndServeTLSWithMux(":"+httpsPort, mux); err != nil {
				utils.Fatal("HTTPS server failed: ", err)
			}
		}()
	}
	watcher, err := fsnotify.NewWatcher()
	if err != nil {
		return err
	}
	s.watcher = watcher
	if err := s.addWatchers("."); err != nil {
		return err
	}
	go s.watchFiles()

	signal.Notify(s.stopCh, syscall.SIGINT, syscall.SIGTERM)

	localIP := ""
	if s.Host {
		localIP, err = utils.GetLocalIP()
		if err != nil {
			return err
		}
	}

	utils.ClearScreen()
	utils.PrintStartupInfo(s.Port, httpsPort, localIP, s.Host)

	go s.listenForCommands()

	<-s.stopCh
	utils.Info("Server stopped.")
	s.stopHost()
	return nil
}

func (*Server) listenForCommands()
{
	reader := bufio.NewReader(os.Stdin)
	for {
		input, _ := reader.ReadString('\n')
		input = strings.TrimSpace(input)

		switch strings.ToLower(input) {
		case "h":
			utils.PrintHelp()
		case "u":
			utils.ClearScreen()
			localIP, err := utils.GetLocalIP()
			if err != nil {
				utils.Fatal("Failed to get local IP address: ", err)
			}
			httpsPort := incrementPort(s.Port)
			utils.PrintStartupInfo(s.Port, httpsPort, localIP, s.Host)
		case "c", "q":
			utils.Info("Closing the server...")
			s.stopCh <- syscall.SIGINT
			return
		case "o":
			utils.Info("Opening the browser...")
			url := fmt.Sprintf("http://localhost:%s/", s.Port)
			if err := utils.OpenBrowser(url); err != nil {
				utils.Info(fmt.Sprintf("Failed to open browser: %v", err))
			}
		default:
			utils.Info("Unknown command. Press 'h' for help.")
		}
	}
}

func (*Server) addWatchers(root string) error
{
	return filepath.WalkDir(root, func(path string, d os.DirEntry, err error) error {
		if err != nil {
			return err
		}
		if d.IsDir() {
			name := d.Name()
			if name != "." && (name == "build" || strings.HasPrefix(name, ".")) {
				return filepath.SkipDir
			}
			return s.watcher.Add(path)
		}
		return nil
	})
}

func (*Server) watchFiles()
{
	for {
		select {
		case event, ok := <-s.watcher.Events:
			if !ok {
				return
			}
			if s.shouldIgnore(time.Now()) {
				continue
			}
			utils.Debug(fmt.Sprintf("event: %s", event))
			if event.Op&fsnotify.Create != 0 {
				if fi, err := os.Stat(event.Name); err == nil && fi.IsDir() {
					name := filepath.Base(event.Name)
					if name == "build" || strings.HasPrefix(name, ".") {
						continue
					}
					utils.Debug(fmt.Sprintf("watching new directory: %s", event.Name))
					_ = s.watcher.Add(event.Name)
					continue
				}
			}
			if event.Op&(fsnotify.Write|fsnotify.Create|fsnotify.Remove|fsnotify.Rename) != 0 {
				if isGenerated(event.Name) {
					continue
				}
				if strings.HasSuffix(event.Name, ".go") ||
					strings.HasSuffix(event.Name, ".rtml") ||
					strings.HasSuffix(event.Name, ".md") ||
					plugins.NeedsRebuild(event.Name) {
					rebuilds.Add(1)
					utils.Info("Changes detected, rebuilding...")
					if err := build.Build(); err != nil {
						if emitErr := signalbus.Emit(context.Background(), RebuildBus, RebuildEvent{Path: event.Name, Success: false, Error: err.Error()}); emitErr != nil {
							utils.Debug(fmt.Sprintf("rebuild event emit failed: %v", emitErr))
						}
						utils.Fatal("Failed to rebuild project: ", err)
					}
					if emitErr := signalbus.Emit(context.Background(), RebuildBus, RebuildEvent{Path: event.Name, Success: true}); emitErr != nil {
						utils.Debug(fmt.Sprintf("rebuild event emit failed: %v", emitErr))
					}
					if strings.HasSuffix(event.Name, ".rtml") {
						markup, err := os.ReadFile(event.Name)
						if err == nil {
							if comps := componentNamesForTemplate(event.Name); len(comps) > 0 {
								for _, name := range comps {
									if err := s.broadcastTemplateUpdate(event.Name, name, string(markup)); err != nil {
										utils.Debug(fmt.Sprintf("template broadcast failed: %v", err))
									}
								}
							} else {
								if err := s.broadcastReload(event.Name); err != nil {
									utils.Debug(fmt.Sprintf("hmr broadcast skipped: %v", err))
								}
							}
						} else {
							utils.Debug(fmt.Sprintf("failed reading template %s: %v", event.Name, err))
							if err := s.broadcastReload(event.Name); err != nil {
								utils.Debug(fmt.Sprintf("hmr broadcast skipped: %v", err))
							}
						}
					} else {
						if err := s.broadcastReload(event.Name); err != nil {
							utils.Debug(fmt.Sprintf("hmr broadcast skipped: %v", err))
						}
					}
					if s.buildType == "ssc" {
						s.stopHost()
						if err := s.startHost(); err != nil {
							utils.Fatal("Failed to restart host server: ", err)
						}
					}
					s.ignoreUntil = time.Now().Add(ignoreDelay)
					drainWatcher(s.watcher)
				}
			}
		case err, ok := <-s.watcher.Errors:
			if !ok {
				return
			}
			utils.Info(fmt.Sprintf("Watcher error: %v", err))
		case <-s.stopCh:
			s.watcher.Close()
			s.stopHost()
			return
		}
	}
}

func (*Server) startHost() error
{
	path := filepath.Join("build", "host", "host")
	s.hostCmd = exec.Command(path)
	s.hostCmd.Stdout = os.Stdout
	s.hostCmd.Stderr = os.Stderr
	if s.hostPort != "" {
		env := os.Environ()
		env = append(env, fmt.Sprintf("RFW_HOST_PORT=%s", s.hostPort))
		s.hostCmd.Env = env
	}
	return s.hostCmd.Start()
}