refactor(edge): 抽取边缘运行时共享包并完成 Phase 3 重构

- 新增 internal/apps/edge/，三组件改为薄包装，删除 3000+ 行重复代码
- Agent 心跳周期下沉至 heartbeat/cycle.go
- 协议类型迁入 pkg/protocol/agent.go
- 补充设计文档与 changelog

internal/apps/relay/config/config.go

@@ -1,49 +1,18 @@
 package config
 
 import (
-	"context"
 	"encoding/json"
 	"errors"
-	"net"
 	"os"
 	"path/filepath"
 	"strings"
 	"time"
 
-	"github.com/Rain-kl/Wavelet/pkg/geoip"
-	"github.com/Rain-kl/Wavelet/pkg/geoip/iputil"
+	edgeconfig "github.com/Rain-kl/Wavelet/internal/apps/edge/config"
+	"github.com/Rain-kl/Wavelet/internal/apps/edge/nodeip"
 )
 
-type MillisecondDuration time.Duration
-
-func (d *MillisecondDuration) UnmarshalJSON(b []byte) error {
-	var v interface{}
-	if err := json.Unmarshal(b, &v); err != nil {
-		return err
-	}
-	switch value := v.(type) {
-	case float64:
-		*d = MillisecondDuration(time.Duration(value) * time.Millisecond)
-		return nil
-	case string:
-		duration, err := time.ParseDuration(value)
-		if err != nil {
-			return err
-		}
-		*d = MillisecondDuration(duration)
-		return nil
-	default:
-		return errors.New("invalid duration format")
-	}
-}
-
-func (d MillisecondDuration) Duration() time.Duration {
-	return time.Duration(d)
-}
-
-func (d MillisecondDuration) String() string {
-	return time.Duration(d).String()
-}
+type MillisecondDuration = edgeconfig.MillisecondDuration
 
 type Config struct {
 	ServerURL         string              `json:"server_url"`
@@ -130,7 +99,7 @@ func applyDefaults(cfg *Config, baseDir string) {
 		cfg.NodeName = strings.TrimSpace(host)
 	}
 	if cfg.NodeIP == "" {
-		cfg.NodeIP = detectNodeIP()
+		cfg.NodeIP = nodeip.Detect()
 	}
 	if cfg.StatePath == "" {
 		cfg.StatePath = filepath.Join(cfg.DataDir, "relay-state.json")
@@ -180,56 +149,4 @@ func (cfg *Config) Save() error {
 	return os.WriteFile(cfg.configPath, data, 0o644)
 }
 
-func detectNodeIP() string {
-	if ip := detectOutboundNodeIP(); ip != "" {
-		return ip
-	}
-	return detectLocalNodeIP()
-}
 
-func detectOutboundNodeIP() string {
-	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
-	defer cancel()
-	ip, err := geoip.GetOutboundIP(ctx)
-	if err != nil || ip == nil {
-		return ""
-	}
-	return ip.String()
-}
-
-func detectLocalNodeIP() string {
-	interfaces, err := net.Interfaces()
-	if err != nil {
-		return ""
-	}
-	bestIP := ""
-	bestPriority := -1
-	for _, iface := range interfaces {
-		if iface.Flags&net.FlagUp == 0 || iface.Flags&net.FlagLoopback != 0 {
-			continue
-		}
-		addrs, err := iface.Addrs()
-		if err != nil {
-			continue
-		}
-		for _, addr := range addrs {
-			ipNet, ok := addr.(*net.IPNet)
-			if !ok || ipNet.IP == nil || ipNet.IP.IsLoopback() {
-				continue
-			}
-			ipv4 := ipNet.IP.To4()
-			if ipv4 == nil {
-				continue
-			}
-			priority := iputil.Score(ipv4)
-			if priority > bestPriority {
-				bestIP = ipv4.String()
-				bestPriority = priority
-			}
-			if bestPriority == 2 {
-				return bestIP
-			}
-		}
-	}
-	return bestIP
-}

internal/apps/relay/heartbeat/service.go

@@ -3,13 +3,13 @@ package heartbeat
 import (
 	"context"
 	"log/slog"
-	"time"
 
 	"github.com/Rain-kl/Wavelet/internal/apps/relay/config"
 	"github.com/Rain-kl/Wavelet/internal/apps/relay/frps"
 	"github.com/Rain-kl/Wavelet/internal/apps/relay/httpclient"
 	"github.com/Rain-kl/Wavelet/internal/apps/relay/observability"
 	"github.com/Rain-kl/Wavelet/internal/apps/relay/state"
+	edgeheartbeat "github.com/Rain-kl/Wavelet/internal/apps/edge/heartbeat"
 	"github.com/Rain-kl/Wavelet/internal/apps/relay/updater"
 	service "github.com/Rain-kl/Wavelet/pkg/protocol"
 )
@@ -33,20 +33,7 @@ func New(client *httpclient.Client, manager *frps.Manager, cfg *config.Config, s
 }
 
 func (s *Service) Run(ctx context.Context) {
-	ticker := time.NewTicker(s.config.HeartbeatInterval.Duration())
-	defer ticker.Stop()
-
-	// initial heartbeat
-	s.doHeartbeat(ctx)
-
-	for {
-		select {
-		case <-ctx.Done():
-			return
-		case <-ticker.C:
-			s.doHeartbeat(ctx)
-		}
-	}
+	edgeheartbeat.RunLoop(ctx, s.config.HeartbeatInterval.Duration(), s.doHeartbeat)
 }
 
 func (s *Service) doHeartbeat(ctx context.Context) {
@@ -79,30 +66,19 @@ func (s *Service) doHeartbeat(ctx context.Context) {
 	s.frpsManager.UpdateConfig(resp.RelayConfig)
 
 	if resp != nil && resp.RelaySettings != nil {
-		s.tryAutoUpdate(ctx, resp.RelaySettings)
+		edgeheartbeat.TryAutoUpdate(ctx, s.updater, relaySettingsToAutoUpdate(resp.RelaySettings), "relay")
 	}
 }
 
-func (s *Service) tryAutoUpdate(ctx context.Context, settings *service.RelaySettings) {
-	if settings == nil || s.updater == nil {
-		return
+func relaySettingsToAutoUpdate(settings *service.RelaySettings) *edgeheartbeat.AutoUpdateSettings {
+	if settings == nil {
+		return nil
 	}
-	force := settings.UpdateNow
-	shouldCheck := settings.AutoUpdate || force
-	if !shouldCheck || settings.UpdateRepo == "" {
-		return
-	}
-	channel := "stable"
-	if force && settings.UpdateChannel != "" {
-		channel = settings.UpdateChannel
-	}
-	slog.Info("checking for relay updates", "repo", settings.UpdateRepo, "channel", channel, "force", force)
-	err := s.updater.CheckAndUpdate(ctx, settings.UpdateRepo, updater.UpdateOptions{
-		Channel: channel,
-		TagName: settings.UpdateTag,
-		Force:   force,
-	})
-	if err != nil {
-		slog.Error("relay update check failed", "error", err)
+	return &edgeheartbeat.AutoUpdateSettings{
+		AutoUpdate:    settings.AutoUpdate,
+		UpdateNow:     settings.UpdateNow,
+		UpdateRepo:    settings.UpdateRepo,
+		UpdateChannel: settings.UpdateChannel,
+		UpdateTag:     settings.UpdateTag,
 	}
 }

internal/apps/relay/httpclient/client.go

@@ -1,16 +1,10 @@
 package httpclient
 
 import (
-	"bytes"
 	"context"
-	"encoding/json"
-	"errors"
-	"io"
-	"log/slog"
-	"net/http"
-	"strings"
 	"time"
 
+	edgehttp "github.com/Rain-kl/Wavelet/internal/apps/edge/httpclient"
 	service "github.com/Rain-kl/Wavelet/pkg/protocol"
 )
 
@@ -20,105 +14,26 @@ type APIResponse[T any] struct {
 }
 
 type Client struct {
-	baseURL    string
-	token      string
-	httpClient *http.Client
+	base *edgehttp.Client
 }
 
 func New(baseURL string, token string, timeout time.Duration) *Client {
 	return &Client{
-		baseURL: strings.TrimRight(baseURL, "/"),
-		token:   token,
-		httpClient: &http.Client{
-			Timeout: timeout,
-		},
+		base: edgehttp.New(baseURL, token, timeout, "X-Agent-Token"),
 	}
 }
 
 func (c *Client) Heartbeat(ctx context.Context, payload service.RelayHeartbeatPayload) (*service.RelayHeartbeatResponse, error) {
 	resp := APIResponse[service.RelayHeartbeatResponse]{}
-	if err := c.postJSON(ctx, "/api/v1/relay/heartbeat", payload, &resp); err != nil {
+	if err := c.base.PostJSON(ctx, "/api/v1/relay/heartbeat", payload, &resp); err != nil {
 		return nil, err
 	}
-	if err := apiError(resp.ErrorMsg); err != nil {
+	if err := edgehttp.APIError(resp.ErrorMsg); err != nil {
 		return nil, err
 	}
 	return &resp.Data, nil
 }
 
 func (c *Client) SetToken(token string) {
-	c.token = strings.TrimSpace(token)
-	slog.Debug("http client token updated")
-}
-
-func (c *Client) getJSON(ctx context.Context, path string, target any) error {
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, c.baseURL+path, nil)
-	if err != nil {
-		return err
-	}
-	req.Header.Set("X-Agent-Token", c.token)
-	return c.do(req, target)
-}
-
-func (c *Client) postJSON(ctx context.Context, path string, body any, target any) error {
-	data, err := json.Marshal(body)
-	if err != nil {
-		return err
-	}
-	req, err := http.NewRequestWithContext(ctx, http.MethodPost, c.baseURL+path, bytes.NewReader(data))
-	if err != nil {
-		return err
-	}
-	req.Header.Set("Content-Type", "application/json")
-	req.Header.Set("X-Agent-Token", c.token)
-	return c.do(req, target)
-}
-
-func (c *Client) do(req *http.Request, target any) error {
-	res, err := c.httpClient.Do(req)
-	if err != nil {
-		slog.Error("http request failed", "method", req.Method, "path", req.URL.Path, "error", err)
-		return err
-	}
-	defer func(Body io.ReadCloser) {
-		err := Body.Close()
-		if err != nil {
-			slog.Error("failed to close response body", "error", err)
-		}
-	}(res.Body)
-
-	body, err := io.ReadAll(res.Body)
-	if err != nil {
-		slog.Error("http response read failed", "method", req.Method, "path", req.URL.Path, "error", err)
-		return err
-	}
-	if res.StatusCode != http.StatusOK {
-		slog.Warn("http request returned non-200", "method", req.Method, "path", req.URL.Path, "status", res.Status)
-		return readBodyError(body, res.Status)
-	}
-	if target == nil {
-		return nil
-	}
-	if err = json.Unmarshal(body, target); err != nil {
-		slog.Error("http response decode failed", "method", req.Method, "path", req.URL.Path, "error", err)
-		return err
-	}
-	return nil
-}
-
-func apiError(msg string) error {
-	if strings.TrimSpace(msg) == "" {
-		return nil
-	}
-	return errors.New(msg)
-}
-
-func readBodyError(body []byte, fallback string) error {
-	var errBody struct {
-		ErrorMsg string `json:"error_msg"`
-	}
-	if err := json.Unmarshal(body, &errBody); err == nil && strings.TrimSpace(errBody.ErrorMsg) != "" {
-		return errors.New(errBody.ErrorMsg)
-	}
-	return errors.New(fallback)
-}
+	c.base.SetToken(token)
+}

internal/apps/relay/observability/collector.go

@@ -1,18 +1,15 @@
 package observability
 
 import (
-	"bufio"
 	"crypto/sha256"
 	"encoding/hex"
 	"encoding/json"
 	"os"
-	"path/filepath"
 	"runtime"
-	"strconv"
 	"strings"
-	"syscall"
 	"time"
 
+	edgeobs "github.com/Rain-kl/Wavelet/internal/apps/edge/observability"
 	"github.com/Rain-kl/Wavelet/internal/apps/relay/config"
 	"github.com/Rain-kl/Wavelet/internal/apps/relay/frps"
 	"github.com/Rain-kl/Wavelet/internal/apps/relay/state"
@@ -43,15 +40,15 @@ func BuildSnapshot(cfg *config.Config, stateStore *state.Store) *service.AgentNo
 	now := time.Now().UTC()
 	metric := &service.AgentNodeMetricSnapshot{CapturedAtUnix: now.Unix()}
 
-	metric.MemoryTotalBytes, metric.MemoryUsedBytes = readMemInfo()
-	metric.StorageTotalBytes, metric.StorageUsedBytes = statFilesystem(cfg.DataDir)
-	metric.NetworkRxBytes, metric.NetworkTxBytes = readLinuxNetworkTotals()
-	metric.DiskReadBytes, metric.DiskWriteBytes = readLinuxDiskTotals()
+	metric.MemoryTotalBytes, metric.MemoryUsedBytes = edgeobs.ReadMemInfo()
+	metric.StorageTotalBytes, metric.StorageUsedBytes = edgeobs.StatFilesystem(cfg.DataDir)
+	metric.NetworkRxBytes, metric.NetworkTxBytes = edgeobs.ReadLinuxNetworkTotals()
+	metric.DiskReadBytes, metric.DiskWriteBytes = edgeobs.ReadLinuxDiskTotals()
 
 	if stateStore == nil {
 		return metric
 	}
-	totalCPU, idleCPU := readLinuxCPUStat()
+	totalCPU, idleCPU := edgeobs.ReadLinuxCPUStat()
 	snapshot, err := stateStore.Load()
 	if err != nil {
 		return metric
@@ -88,20 +85,20 @@ func BuildHealthEvents(status frps.RuntimeStatus) []service.AgentNodeHealthEvent
 
 func collectProfile(cfg *config.Config) *service.AgentNodeSystemProfile {
 	hostname, _ := os.Hostname()
-	osName, osVersion := readLinuxOSRelease()
-	totalMemory, _ := readMemInfo()
-	totalDisk, _ := statFilesystem(cfg.DataDir)
+	osName, osVersion := edgeobs.ReadLinuxOSRelease()
+	totalMemory, _ := edgeobs.ReadMemInfo()
+	totalDisk, _ := edgeobs.StatFilesystem(cfg.DataDir)
 	return &service.AgentNodeSystemProfile{
 		Hostname:         strings.TrimSpace(hostname),
 		OSName:           osName,
 		OSVersion:        osVersion,
-		KernelVersion:    readFirstLine("/proc/sys/kernel/osrelease"),
+		KernelVersion:    edgeobs.ReadFirstLine("/proc/sys/kernel/osrelease"),
 		Architecture:     runtime.GOARCH,
-		CPUModel:         readLinuxCPUModel(),
+		CPUModel:         edgeobs.ReadLinuxCPUModel(),
 		CPUCores:         runtime.NumCPU(),
 		TotalMemoryBytes: totalMemory,
 		TotalDiskBytes:   totalDisk,
-		UptimeSeconds:    readLinuxUptimeSeconds(),
+		UptimeSeconds:    edgeobs.ReadLinuxUptimeSeconds(),
 		ReportedAtUnix:   time.Now().UTC().Unix(),
 	}
 }
@@ -113,213 +110,4 @@ func fingerprintProfile(profile *service.AgentNodeSystemProfile) string {
 	}
 	sum := sha256.Sum256(raw)
 	return hex.EncodeToString(sum[:])
-}
-
-func readLinuxOSRelease() (string, string) {
-	file, err := os.Open("/etc/os-release")
-	if err != nil {
-		return runtime.GOOS, ""
-	}
-	defer file.Close()
-
-	values := make(map[string]string)
-	scanner := bufio.NewScanner(file)
-	for scanner.Scan() {
-		key, value, ok := strings.Cut(strings.TrimSpace(scanner.Text()), "=")
-		if !ok {
-			continue
-		}
-		values[key] = strings.Trim(value, `"`)
-	}
-	if pretty := strings.TrimSpace(values["PRETTY_NAME"]); pretty != "" {
-		return pretty, strings.TrimSpace(values["VERSION_ID"])
-	}
-	if name := strings.TrimSpace(values["NAME"]); name != "" {
-		return name, strings.TrimSpace(values["VERSION_ID"])
-	}
-	return runtime.GOOS, ""
-}
-
-func readLinuxCPUModel() string {
-	file, err := os.Open("/proc/cpuinfo")
-	if err != nil {
-		return ""
-	}
-	defer file.Close()
-
-	scanner := bufio.NewScanner(file)
-	for scanner.Scan() {
-		line := scanner.Text()
-		if strings.HasPrefix(strings.ToLower(line), "model name") {
-			_, value, ok := strings.Cut(line, ":")
-			if ok {
-				return strings.TrimSpace(value)
-			}
-		}
-	}
-	return ""
-}
-
-func readMemInfo() (int64, int64) {
-	file, err := os.Open("/proc/meminfo")
-	if err != nil {
-		return 0, 0
-	}
-	defer file.Close()
-
-	var totalKB, availableKB int64
-	scanner := bufio.NewScanner(file)
-	for scanner.Scan() {
-		line := scanner.Text()
-		if strings.HasPrefix(line, "MemTotal:") {
-			totalKB = parseMemInfoValue(line)
-		}
-		if strings.HasPrefix(line, "MemAvailable:") {
-			availableKB = parseMemInfoValue(line)
-		}
-	}
-	total := totalKB * 1024
-	used := total - availableKB*1024
-	if used < 0 {
-		used = 0
-	}
-	return total, used
-}
-
-func parseMemInfoValue(line string) int64 {
-	fields := strings.Fields(line)
-	if len(fields) < 2 {
-		return 0
-	}
-	value, err := strconv.ParseInt(fields[1], 10, 64)
-	if err != nil {
-		return 0
-	}
-	return value
-}
-
-func readLinuxUptimeSeconds() int64 {
-	content, err := os.ReadFile("/proc/uptime")
-	if err != nil {
-		return 0
-	}
-	fields := strings.Fields(string(content))
-	if len(fields) == 0 {
-		return 0
-	}
-	value, err := strconv.ParseFloat(fields[0], 64)
-	if err != nil {
-		return 0
-	}
-	return int64(value)
-}
-
-func readLinuxCPUStat() (uint64, uint64) {
-	content, err := os.ReadFile("/proc/stat")
-	if err != nil {
-		return 0, 0
-	}
-	for _, line := range strings.Split(string(content), "\n") {
-		if !strings.HasPrefix(line, "cpu ") {
-			continue
-		}
-		fields := strings.Fields(line)
-		if len(fields) < 5 {
-			return 0, 0
-		}
-		var total uint64
-		for index := 1; index < len(fields); index++ {
-			value, err := strconv.ParseUint(fields[index], 10, 64)
-			if err != nil {
-				return 0, 0
-			}
-			total += value
-		}
-		idle, err := strconv.ParseUint(fields[4], 10, 64)
-		if err != nil {
-			return 0, 0
-		}
-		return total, idle
-	}
-	return 0, 0
-}
-
-func readLinuxNetworkTotals() (int64, int64) {
-	file, err := os.Open("/proc/net/dev")
-	if err != nil {
-		return 0, 0
-	}
-	defer file.Close()
-
-	var rx, tx int64
-	scanner := bufio.NewScanner(file)
-	for scanner.Scan() {
-		name, data, ok := strings.Cut(strings.TrimSpace(scanner.Text()), ":")
-		if !ok || strings.TrimSpace(name) == "lo" {
-			continue
-		}
-		fields := strings.Fields(data)
-		if len(fields) < 16 {
-			continue
-		}
-		if value, err := strconv.ParseInt(fields[0], 10, 64); err == nil {
-			rx += value
-		}
-		if value, err := strconv.ParseInt(fields[8], 10, 64); err == nil {
-			tx += value
-		}
-	}
-	return rx, tx
-}
-
-func readLinuxDiskTotals() (int64, int64) {
-	file, err := os.Open("/proc/diskstats")
-	if err != nil {
-		return 0, 0
-	}
-	defer file.Close()
-
-	var readBytes, writeBytes int64
-	scanner := bufio.NewScanner(file)
-	for scanner.Scan() {
-		fields := strings.Fields(scanner.Text())
-		if len(fields) < 14 || shouldSkipDiskDevice(fields[2]) {
-			continue
-		}
-		if value, err := strconv.ParseInt(fields[5], 10, 64); err == nil {
-			readBytes += value * 512
-		}
-		if value, err := strconv.ParseInt(fields[9], 10, 64); err == nil {
-			writeBytes += value * 512
-		}
-	}
-	return readBytes, writeBytes
-}
-
-func shouldSkipDiskDevice(device string) bool {
-	return device == "" || strings.HasPrefix(device, "loop") || strings.HasPrefix(device, "ram") || strings.HasPrefix(device, "dm-")
-}
-
-func statFilesystem(path string) (int64, int64) {
-	if strings.TrimSpace(path) == "" {
-		path = string(os.PathSeparator)
-	}
-	var stat syscall.Statfs_t
-	if err := syscall.Statfs(filepath.Clean(path), &stat); err != nil {
-		return 0, 0
-	}
-	total := int64(stat.Blocks) * int64(stat.Bsize)
-	used := total - int64(stat.Bavail)*int64(stat.Bsize)
-	if used < 0 {
-		used = 0
-	}
-	return total, used
-}
-
-func readFirstLine(path string) string {
-	content, err := os.ReadFile(path)
-	if err != nil {
-		return ""
-	}
-	return strings.TrimSpace(string(content))
-}
+}

internal/apps/relay/relay/runner.go

@@ -4,8 +4,8 @@ import (
 	"context"
 	"encoding/json"
 	"log/slog"
-	"time"
 
+	edgerunner "github.com/Rain-kl/Wavelet/internal/apps/edge/runner"
 	"github.com/Rain-kl/Wavelet/internal/apps/relay/config"
 	"github.com/Rain-kl/Wavelet/internal/apps/relay/frps"
 	"github.com/Rain-kl/Wavelet/internal/apps/relay/heartbeat"
@@ -25,30 +25,16 @@ type Runner struct {
 }
 
 func (r *Runner) Run(ctx context.Context) error {
-	// Start heartbeat loop in background
 	go r.HeartbeatService.Run(ctx)
 
-	// WebSocket reconnection loop
-	for {
-		select {
-		case <-ctx.Done():
-			r.FrpsManager.Stop()
-			return ctx.Err()
-		default:
-		}
-
-		conn, err := r.WebSocketService.Connect(ctx)
-		if err != nil {
-			slog.Error("relay ws connect failed, will retry", "error", err)
-			r.sleepContext(ctx, 5*time.Second)
-			continue
-		}
-
+	return edgerunner.RunWSReconnectLoop(ctx, edgerunner.WSReconnectConfig{
+		ComponentName: "relay",
+		OnShutdown:    r.FrpsManager.Stop,
+	}, func(ctx context.Context) (edgerunner.WSConnection, error) {
+		return r.WebSocketService.Connect(ctx)
+	}, func(ctx context.Context, conn edgerunner.WSConnection) {
 		r.handleConnection(ctx, conn)
-		_ = conn.Close()
-		slog.Info("relay ws connection closed, reconnecting...")
-		r.sleepContext(ctx, 2*time.Second)
-	}
+	})
 }
 
 type relayWSHandler struct {
@@ -78,13 +64,11 @@ func (h *relayWSHandler) OnClose(err error) {
 	slog.Error("relay ws receive failed", "error", err)
 }
 
-func (r *Runner) handleConnection(ctx context.Context, conn *wsclient.Connection) {
-	_ = conn.RunReceiveLoop(ctx, &relayWSHandler{runner: r})
-}
-
-func (r *Runner) sleepContext(ctx context.Context, d time.Duration) {
-	select {
-	case <-ctx.Done():
-	case <-time.After(d):
+func (r *Runner) handleConnection(ctx context.Context, conn edgerunner.WSConnection) {
+	wsConn, ok := conn.(*wsclient.Connection)
+	if !ok {
+		slog.Error("relay ws connection has unexpected type")
+		return
 	}
-}
+	_ = wsConn.RunReceiveLoop(ctx, &relayWSHandler{runner: r})
+}

internal/apps/relay/updater/restart_unix.go

@@ -1,51 +0,0 @@
-//go:build !windows
-
-package updater
-
-import (
-	"fmt"
-	"log/slog"
-	"os"
-	"syscall"
-)
-
-func replaceAndRestart(execPath string, tmpPath string) error {
-	backupPath := execPath + ".bak"
-	if err := removeBackupBinary(backupPath); err != nil {
-		return err
-	}
-	if err := os.Rename(execPath, backupPath); err != nil {
-		renameErr := err
-		if err := os.Remove(tmpPath); err != nil && !os.IsNotExist(err) {
-			slog.Error("remove tmp binary failed", "path", tmpPath, "error", err)
-			return fmt.Errorf("backup current binary: %w; remove tmp binary: %v", renameErr, err)
-		}
-		return fmt.Errorf("backup current binary: %w", renameErr)
-	}
-	if err := os.Rename(tmpPath, execPath); err != nil {
-		replaceErr := err
-		if err := os.Rename(backupPath, execPath); err != nil {
-			slog.Error("restore backup binary failed", "path", backupPath, "error", err)
-			return fmt.Errorf("replace binary: %w; restore backup binary: %v", replaceErr, err)
-		}
-		return fmt.Errorf("replace binary: %w", replaceErr)
-	}
-	if err := removeBackupBinary(backupPath); err != nil {
-		return err
-	}
-	if err := syscall.Exec(execPath, os.Args, os.Environ()); err != nil {
-		return fmt.Errorf("exec restart: %w", err)
-	}
-	return fmt.Errorf("unreachable after exec")
-}
-
-func removeBackupBinary(path string) error {
-	if err := os.Remove(path); err != nil {
-		if os.IsNotExist(err) {
-			return nil
-		}
-		slog.Error("remove backup binary failed", "path", path, "error", err)
-		return err
-	}
-	return nil
-}

internal/apps/relay/updater/restart_windows.go

@@ -1,53 +0,0 @@
-//go:build windows
-
-package updater
-
-import (
-	"fmt"
-	"os"
-	"os/exec"
-	"strings"
-)
-
-func replaceAndRestart(execPath string, tmpPath string) error {
-	backupPath := execPath + ".bak"
-	scriptPath := execPath + ".update.cmd"
-	script := fmt.Sprintf(`@echo off
-setlocal
-:waitloop
-move /Y "%s" "%s" >nul 2>nul
-if errorlevel 1 (
-  ping 127.0.0.1 -n 2 >nul
-  goto waitloop
-)
-move /Y "%s" "%s" >nul 2>nul
-if errorlevel 1 exit /b 1
-start "" %s
-del /Q "%s" >nul 2>nul
-del /Q "%%~f0" >nul 2>nul
-`, execPath, backupPath, tmpPath, execPath, buildWindowsCommandLine(execPath, os.Args[1:]), backupPath)
-	if err := os.WriteFile(scriptPath, []byte(script), 0o700); err != nil {
-		os.Remove(tmpPath)
-		return fmt.Errorf("write restart script: %w", err)
-	}
-	cmd := exec.Command("cmd", "/C", "start", "", scriptPath)
-	if err := cmd.Start(); err != nil {
-		os.Remove(scriptPath)
-		os.Remove(tmpPath)
-		return fmt.Errorf("schedule restart: %w", err)
-	}
-	os.Exit(0)
-	return nil
-}
-
-func buildWindowsCommandLine(execPath string, args []string) string {
-	parts := []string{quoteWindowsArg(execPath)}
-	for _, arg := range args {
-		parts = append(parts, quoteWindowsArg(arg))
-	}
-	return strings.Join(parts, " ")
-}
-
-func quoteWindowsArg(value string) string {
-	return `"` + strings.ReplaceAll(value, `"`, `""`) + `"`
-}

internal/apps/relay/updater/updater.go

@@ -1,371 +1,17 @@
 package updater
 
 import (
-	"context"
-	"crypto/sha256"
-	"encoding/hex"
-	"encoding/json"
-	"fmt"
-	"io"
-	"log/slog"
-	"net/http"
-	"os"
-	"runtime"
-	"strings"
-	"time"
-
-	"github.com/Rain-kl/Wavelet/pkg/utils"
-
+	edgeupdater "github.com/Rain-kl/Wavelet/internal/apps/edge/updater"
 	"github.com/Rain-kl/Wavelet/internal/apps/relay/config"
 )
 
-const maxChecksumAssetSize = 64 * 1024
-
-var replaceAndRestartFunc = replaceAndRestart
-
-type Service struct {
-	httpClient   *http.Client
-	lastCheckKey string
-}
+type Service = edgeupdater.Service
+type UpdateOptions = edgeupdater.UpdateOptions
 
 func New() *Service {
-	return &Service{
-		httpClient: &http.Client{Timeout: 30 * time.Second},
-	}
-}
-
-type githubRelease struct {
-	TagName    string        `json:"tag_name"`
-	Prerelease bool          `json:"prerelease"`
-	Draft      bool          `json:"draft"`
-	Assets     []githubAsset `json:"assets"`
-}
-
-type githubAsset struct {
-	Name               string `json:"name"`
-	BrowserDownloadURL string `json:"browser_download_url"`
-}
-
-type UpdateOptions struct {
-	Channel string
-	TagName string
-	Force   bool
-}
-
-func (s *Service) CheckAndUpdate(ctx context.Context, repo string, options UpdateOptions) error {
-	release, err := s.getRelease(ctx, repo, options)
-	if err != nil {
-		return fmt.Errorf("check latest release: %w", err)
-	}
-	if release == nil || release.TagName == "" {
-		return nil
-	}
-
-	remoteVersion := normalizeVersion(release.TagName)
-	localVersion := normalizeVersion(config.Version)
-	checkKey := buildReleaseCheckKey(options, remoteVersion)
-
-	if remoteVersion == localVersion {
-		return nil
-	}
-	if !options.Force && checkKey != "" && checkKey == s.lastCheckKey {
-		return nil
-	}
-	if !isNewer(localVersion, remoteVersion) {
-		s.lastCheckKey = checkKey
-		return nil
-	}
-
-	slog.Info("relay update available", "from", localVersion, "to", remoteVersion)
-	assetName := assetNameForGOOSGOARCH(runtime.GOOS, runtime.GOARCH)
-	checksumAssetName := assetName + ".sha256"
-
-	var downloadURL string
-	var checksumURL string
-	for _, asset := range release.Assets {
-		switch asset.Name {
-		case assetName:
-			downloadURL = asset.BrowserDownloadURL
-		case checksumAssetName:
-			checksumURL = asset.BrowserDownloadURL
-		}
-	}
-	if downloadURL == "" {
-		s.lastCheckKey = checkKey
-		return fmt.Errorf("no matching asset %q in release %s", assetName, release.TagName)
-	}
-	if checksumURL == "" {
-		return fmt.Errorf("no matching checksum asset %q in release %s", checksumAssetName, release.TagName)
-	}
-
-	expectedChecksum, err := s.downloadChecksum(ctx, checksumURL, assetName)
-	if err != nil {
-		return fmt.Errorf("download checksum: %w", err)
-	}
-
-	execPath, err := os.Executable()
-	if err != nil {
-		return fmt.Errorf("get executable path: %w", err)
-	}
-	if err = s.downloadAndRestart(ctx, downloadURL, expectedChecksum, execPath); err != nil {
-		return fmt.Errorf("download and restart: %w", err)
-	}
-	s.lastCheckKey = checkKey
-	return nil
-}
-
-func (s *Service) getRelease(ctx context.Context, repo string, options UpdateOptions) (*githubRelease, error) {
-	tagName := strings.TrimSpace(options.TagName)
-	if tagName != "" {
-		return s.getReleaseByTag(ctx, repo, tagName)
-	}
-	if strings.EqualFold(strings.TrimSpace(options.Channel), "preview") {
-		return s.getLatestPreviewRelease(ctx, repo)
-	}
-	return s.getLatestStableRelease(ctx, repo)
-}
-
-func (s *Service) getLatestStableRelease(ctx context.Context, repo string) (*githubRelease, error) {
-	url := fmt.Sprintf("https://api.github.com/repos/%s/releases/latest", repo)
-	return s.fetchReleaseFromURL(ctx, url)
-}
-
-func (s *Service) getLatestPreviewRelease(ctx context.Context, repo string) (*githubRelease, error) {
-	url := fmt.Sprintf("https://api.github.com/repos/%s/releases?per_page=20", repo)
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
-	if err != nil {
-		return nil, err
-	}
-	req.Header.Set("Accept", "application/vnd.github+json")
-
-	resp, err := s.httpClient.Do(req)
-	if err != nil {
-		return nil, err
-	}
-	defer resp.Body.Close()
-
-	if resp.StatusCode != http.StatusOK {
-		return nil, fmt.Errorf("github api returned %s", resp.Status)
-	}
-
-	var releases []githubRelease
-	if err = json.NewDecoder(resp.Body).Decode(&releases); err != nil {
-		return nil, err
-	}
-	for _, release := range releases {
-		if release.Draft || !release.Prerelease {
-			continue
-		}
-		releaseCopy := release
-		return &releaseCopy, nil
-	}
-	return nil, nil
-}
-
-func (s *Service) getReleaseByTag(ctx context.Context, repo string, tag string) (*githubRelease, error) {
-	url := fmt.Sprintf("https://api.github.com/repos/%s/releases/tags/%s", repo, strings.TrimSpace(tag))
-	return s.fetchReleaseFromURL(ctx, url)
-}
-
-func (s *Service) fetchReleaseFromURL(ctx context.Context, url string) (*githubRelease, error) {
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
-	if err != nil {
-		return nil, err
-	}
-	req.Header.Set("Accept", "application/vnd.github+json")
-
-	resp, err := s.httpClient.Do(req)
-	if err != nil {
-		return nil, err
-	}
-	defer func(Body io.ReadCloser) {
-		err := Body.Close()
-		if err != nil {
-			slog.Error("failed to close response body", "error", err)
-		}
-	}(resp.Body)
-
-	if resp.StatusCode == http.StatusNotFound {
-		return nil, nil
-	}
-	if resp.StatusCode != http.StatusOK {
-		return nil, fmt.Errorf("github api returned %s", resp.Status)
-	}
-
-	return decodeRelease(resp.Body)
-}
-
-func decodeRelease(reader io.Reader) (*githubRelease, error) {
-	var release githubRelease
-	if err := json.NewDecoder(reader).Decode(&release); err != nil {
-		return nil, err
-	}
-	return &release, nil
-}
-
-func (s *Service) downloadChecksum(ctx context.Context, url string, assetName string) (string, error) {
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
-	if err != nil {
-		return "", err
-	}
-	resp, err := s.httpClient.Do(req)
-	if err != nil {
-		return "", err
-	}
-	defer resp.Body.Close()
-
-	if resp.StatusCode != http.StatusOK {
-		return "", fmt.Errorf("checksum download returned %s", resp.Status)
-	}
-
-	content, err := io.ReadAll(io.LimitReader(resp.Body, maxChecksumAssetSize+1))
-	if err != nil {
-		return "", err
-	}
-	if len(content) > maxChecksumAssetSize {
-		return "", fmt.Errorf("checksum asset exceeds %d bytes", maxChecksumAssetSize)
-	}
-	checksum, err := parseSHA256Checksum(string(content), assetName)
-	if err != nil {
-		return "", err
-	}
-	return checksum, nil
-}
-
-func parseSHA256Checksum(content string, assetName string) (string, error) {
-	assetName = strings.TrimSpace(assetName)
-	for _, line := range strings.Split(content, "\n") {
-		line = strings.TrimSpace(line)
-		if line == "" || strings.HasPrefix(line, "#") {
-			continue
-		}
-		if checksum, ok := parseSHA256Line(line, assetName); ok {
-			return checksum, nil
-		}
-	}
-	if assetName == "" {
-		return "", fmt.Errorf("checksum asset does not contain a valid sha256 digest")
-	}
-	return "", fmt.Errorf("checksum asset does not contain a sha256 digest for %q", assetName)
-}
-
-func parseSHA256Line(line string, assetName string) (string, bool) {
-	fields := strings.Fields(line)
-	if len(fields) == 1 && isSHA256Hex(fields[0]) {
-		return strings.ToLower(fields[0]), true
-	}
-	if len(fields) >= 2 && isSHA256Hex(fields[0]) {
-		fileName := strings.TrimPrefix(strings.TrimSpace(fields[1]), "*")
-		if assetName == "" || fileName == assetName {
-			return strings.ToLower(fields[0]), true
-		}
-	}
-
-	prefix := "SHA256("
-	if strings.HasPrefix(line, prefix) {
-		closing := strings.Index(line, ")")
-		if closing > len(prefix) && closing+1 < len(line) {
-			fileName := strings.TrimSpace(line[len(prefix):closing])
-			rest := strings.TrimSpace(line[closing+1:])
-			rest = strings.TrimPrefix(rest, "=")
-			rest = strings.TrimSpace(rest)
-			if isSHA256Hex(rest) && (assetName == "" || fileName == assetName) {
-				return strings.ToLower(rest), true
-			}
-		}
-	}
-	return "", false
-}
-
-func isSHA256Hex(value string) bool {
-	value = strings.TrimSpace(value)
-	if len(value) != sha256.Size*2 {
-		return false
-	}
-	_, err := hex.DecodeString(value)
-	return err == nil
-}
-
-func (s *Service) downloadAndRestart(ctx context.Context, url string, expectedChecksum string, targetPath string) error {
-	expectedChecksum = strings.ToLower(strings.TrimSpace(expectedChecksum))
-	if !isSHA256Hex(expectedChecksum) {
-		return fmt.Errorf("invalid expected sha256 checksum")
-	}
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
-	if err != nil {
-		return err
-	}
-	resp, err := s.httpClient.Do(req)
-	if err != nil {
-		return err
-	}
-	defer resp.Body.Close()
-
-	if resp.StatusCode != http.StatusOK {
-		return fmt.Errorf("download returned %s", resp.Status)
-	}
-
-	tmpPath := targetPath + ".update"
-	if runtime.GOOS == "windows" && !strings.HasSuffix(strings.ToLower(tmpPath), ".exe") {
-		tmpPath += ".exe"
-	}
-	tmpFile, err := os.OpenFile(tmpPath, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, 0o600)
-	if err != nil {
-		return err
-	}
-	hasher := sha256.New()
-	if _, err = io.Copy(io.MultiWriter(tmpFile, hasher), resp.Body); err != nil {
-		tmpFile.Close()
-		os.Remove(tmpPath)
-		return err
-	}
-	if err = tmpFile.Close(); err != nil {
-		os.Remove(tmpPath)
-		return err
-	}
-	actualChecksum := hex.EncodeToString(hasher.Sum(nil))
-	if actualChecksum != expectedChecksum {
-		os.Remove(tmpPath)
-		return fmt.Errorf("sha256 checksum mismatch: expected %s, got %s", expectedChecksum, actualChecksum)
-	}
-	if err = os.Chmod(tmpPath, 0o755); err != nil && runtime.GOOS != "windows" {
-		os.Remove(tmpPath)
-		return fmt.Errorf("set executable permission: %w", err)
-	}
-
-	slog.Info("relay binary updated, restarting")
-	return replaceAndRestartFunc(targetPath, tmpPath)
-}
-
-func assetNameForGOOSGOARCH(goos string, goarch string) string {
-	name := fmt.Sprintf("openflare-relay-%s-%s", goos, goarch)
-	if goos == "windows" {
-		return name + ".exe"
-	}
-	return name
-}
-
-func normalizeVersion(v string) string {
-	v = strings.TrimSpace(v)
-	v = strings.TrimPrefix(v, "v")
-	return v
-}
-
-func isNewer(local, remote string) bool {
-	return compareVersions(local, remote) < 0
-}
-
-func buildReleaseCheckKey(options UpdateOptions, remoteVersion string) string {
-	channel := strings.TrimSpace(options.Channel)
-	if channel == "" {
-		channel = "stable"
-	}
-	if tagName := strings.TrimSpace(options.TagName); tagName != "" {
-		return channel + ":" + tagName
-	}
-	return channel + ":" + remoteVersion
-}
-
-func compareVersions(local string, remote string) int {
-	return utils.CompareVersions(local, remote)
-}
+	return edgeupdater.New(edgeupdater.Config{
+		LocalVersion: config.Version,
+		AssetPrefix:  "openflare-relay",
+		LogLabel:     "relay",
+	})
+}