Add local monitor bridge service

internal/bridge/bridge.go

@@ -0,0 +1,130 @@
+// Package bridge provides a local HTTP server on MONITOR_PORT for
+// communication between the HarborForge OpenClaw plugin and Monitor.
+//
+// The plugin queries this endpoint to enrich its telemetry with
+// host/hardware data. The bridge is optional: if monitorPort is 0
+// or not set, the bridge is not started and Monitor operates normally.
+package bridge
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"log"
+	"net"
+	"net/http"
+	"sync"
+	"time"
+
+	"git.hangman-lab.top/zhi/HarborForge.Monitor/internal/config"
+	"git.hangman-lab.top/zhi/HarborForge.Monitor/internal/telemetry"
+)
+
+// Server is the local bridge HTTP server.
+type Server struct {
+	cfg    config.Config
+	logger *log.Logger
+	srv    *http.Server
+
+	mu          sync.RWMutex
+	lastPayload *telemetry.Payload
+	lastUpdated time.Time
+}
+
+// New creates a bridge server. It does not start listening.
+func New(cfg config.Config, logger *log.Logger) *Server {
+	return &Server{
+		cfg:    cfg,
+		logger: logger,
+	}
+}
+
+// UpdatePayload stores the latest telemetry payload so the bridge can
+// serve it to plugin queries without re-collecting.
+func (s *Server) UpdatePayload(p telemetry.Payload) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	s.lastPayload = &p
+	s.lastUpdated = time.Now()
+}
+
+// bridgeResponse is the JSON structure served to the plugin.
+type bridgeResponse struct {
+	Status      string             `json:"status"`
+	MonitorVer  string             `json:"monitor_version"`
+	Identifier  string             `json:"identifier"`
+	Telemetry   *telemetry.Payload `json:"telemetry,omitempty"`
+	LastUpdated *time.Time         `json:"last_updated,omitempty"`
+}
+
+func (s *Server) handler() http.Handler {
+	mux := http.NewServeMux()
+
+	// Health / discovery endpoint
+	mux.HandleFunc("/health", func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Content-Type", "application/json")
+		json.NewEncoder(w).Encode(map[string]string{
+			"status":          "ok",
+			"monitor_version": telemetry.Version,
+			"identifier":      s.cfg.Identifier,
+		})
+	})
+
+	// Telemetry endpoint — returns the latest cached payload
+	mux.HandleFunc("/telemetry", func(w http.ResponseWriter, r *http.Request) {
+		s.mu.RLock()
+		payload := s.lastPayload
+		updated := s.lastUpdated
+		s.mu.RUnlock()
+
+		resp := bridgeResponse{
+			Status:     "ok",
+			MonitorVer: telemetry.Version,
+			Identifier: s.cfg.Identifier,
+		}
+		if payload != nil {
+			resp.Telemetry = payload
+			resp.LastUpdated = &updated
+		}
+
+		w.Header().Set("Content-Type", "application/json")
+		json.NewEncoder(w).Encode(resp)
+	})
+
+	return mux
+}
+
+// Start begins listening on 127.0.0.1:<monitorPort>. It blocks until
+// the context is cancelled or an error occurs.
+func (s *Server) Start(ctx context.Context) error {
+	if s.cfg.MonitorPort <= 0 {
+		return nil // bridge disabled
+	}
+
+	addr := fmt.Sprintf("127.0.0.1:%d", s.cfg.MonitorPort)
+	listener, err := net.Listen("tcp", addr)
+	if err != nil {
+		return fmt.Errorf("bridge listen on %s: %w", addr, err)
+	}
+
+	s.srv = &http.Server{
+		Handler:      s.handler(),
+		ReadTimeout:  5 * time.Second,
+		WriteTimeout: 5 * time.Second,
+		IdleTimeout:  30 * time.Second,
+	}
+
+	s.logger.Printf("bridge listening on %s", addr)
+
+	go func() {
+		<-ctx.Done()
+		shutCtx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
+		defer cancel()
+		s.srv.Shutdown(shutCtx)
+	}()
+
+	if err := s.srv.Serve(listener); err != nil && err != http.ErrServerClosed {
+		return fmt.Errorf("bridge serve: %w", err)
+	}
+	return nil
+}