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")

	if _, err := fmt.Fprint(w, ": connected\n\n"); err != nil {
		return
	}
	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
			}
			if _, err := fmt.Fprintf(w, "data: %s\n\n", msg); err != nil {
				return
			}
			flusher.Flush()
		case <-ping.C:
			if _, err := fmt.Fprint(w, ": ping\n\n"); err != nil {
				return
			}
			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)
	} else {
		root := filepath.Join("build", "client")
		mux = hostpkg.NewMux(root)
		mux.HandleFunc("/__rfw/hmr", s.handleHMR)
	}
	server := &http.Server{
		Addr:              ":" + s.Port,
		Handler:           mux,
		ReadHeaderTimeout: 5 * time.Second,
	}
	go func() {
		if err := server.ListenAndServe(); 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()
{
	var (
		deb         debouncer
		pendingPath string
		pendingSwap bool
	)
	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) {
					// Template edits stream to the browser immediately: the
					// hot swap does not depend on the wasm rebuild, which
					// then runs to keep dist consistent for full reloads.
					if strings.HasSuffix(event.Name, ".rtml") {
						if markup, err := os.ReadFile(event.Name); err == nil {
							if comps := componentNamesForTemplate(event.Name); len(comps) > 0 {
								pendingSwap = true
								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 {
							utils.Debug(fmt.Sprintf("failed reading template %s: %v", event.Name, err))
						}
					}
					// Coalesce bursts of events into a single rebuild.
					pendingPath = event.Name
					deb.trigger(rebuildDebounce)
				}
			}
		case <-deb.C:
			deb.fired()
			s.rebuild(pendingPath, pendingSwap)
			pendingSwap = false
		case err, ok := <-s.watcher.Errors:
			if !ok {
				return
			}
			utils.Info(fmt.Sprintf("Watcher error: %v", err))
		case <-s.stopCh:
			if err := s.watcher.Close(); err != nil {
				utils.Debug(fmt.Sprintf("watcher close failed: %v", err))
			}
			s.stopHost()
			return
		}
	}
}

func (*Server) rebuild(path string, templateSwapped bool)
{
	rebuilds.Add(1)
	utils.Info("Changes detected, rebuilding...")
	start := time.Now()
	if err := build.Build(); err != nil {
		if emitErr := signalbus.Emit(context.Background(), RebuildBus, RebuildEvent{Path: path, Success: false, Error: err.Error()}); emitErr != nil {
			utils.Debug(fmt.Sprintf("rebuild event emit failed: %v", emitErr))
		}
		// A compile error must not kill the dev server: keep
		// watching so the next save can succeed.
		utils.Error("Failed to rebuild project: ", err)
		return
	}
	if emitErr := signalbus.Emit(context.Background(), RebuildBus, RebuildEvent{Path: path, Success: true}); emitErr != nil {
		utils.Debug(fmt.Sprintf("rebuild event emit failed: %v", emitErr))
	}
	utils.Info(fmt.Sprintf("Rebuilt in %s", time.Since(start).Round(time.Millisecond)))
	if !templateSwapped {
		if err := s.broadcastReload(path); 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)
}

func (*Server) startHost() error
{
	path := filepath.Join("build", "host", "host")
	absPath, err := filepath.Abs(path)
	if err != nil {
		return err
	}
	info, err := os.Lstat(absPath)
	if err != nil {
		return err
	}
	if !info.Mode().IsRegular() {
		return fmt.Errorf("host binary is not a regular file: %s", absPath)
	}
	s.hostCmd = exec.Command("./build/host/host")
	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()
}

func (*Server) stopHost()
{
	if s.hostCmd == nil || s.hostCmd.Process == nil {
		s.hostCmd = nil
		return
	}
	proc := s.hostCmd.Process
	if err := proc.Signal(syscall.SIGTERM); err == nil {
		done := make(chan struct{})
		go func() {
			_, _ = proc.Wait()
			close(done)
		}()
		select {
		case <-done:
			s.hostCmd = nil
			return
		case <-time.After(hostStopTimeout):
			utils.Debug("host did not exit after SIGTERM, killing")
		}
	}
	_ = proc.Kill()
	_, _ = proc.Wait()
	s.hostCmd = nil
}

func (*debouncer) trigger(delay time.Duration)
{
	if d.timer == nil {
		d.timer = time.NewTimer(delay)
		d.C = d.timer.C
		return
	}
	if !d.timer.Stop() {
		select {
		case <-d.timer.C:
		default:
		}
	}
	d.timer.Reset(delay)
}