feat: wip update checker

app/cmd/client.go

@@ -367,6 +367,9 @@ func runClient(cmd *cobra.Command, args []string) {
 	}
 	defer c.Close()
 
+	// TODO: add option to disable update checking
+	go runCheckUpdateClient(c) // TODO: fix lazy mode
+
 	uri := config.URI()
 	logger.Info("use this URI to share your server", zap.String("uri", uri))
 	if showQR {

app/cmd/root.go

@@ -28,11 +28,20 @@ var (
 	// These values will be injected by the build system
 	appVersion  = "Unknown"
 	appDate     = "Unknown"
-	appType    = "Unknown"
+	appType     = "Unknown" // aka channel
 	appCommit   = "Unknown"
+	appPlatform = "Unknown"
+	appArch     = "Unknown"
 
-	appVersionLong = fmt.Sprintf("Version:\t%s\nBuildDate:\t%s\nBuildType:\t%s\nCommitHash:\t%s",
-		appVersion, appDate, appType, appCommit)
+	appVersionLong = fmt.Sprintf("Version:\t%s\n"+
+		"BuildDate:\t%s\n"+
+		"BuildType:\t%s\n"+
+		"CommitHash:\t%s\n"+
+		"Platform:\t%s\n"+
+		"Architecture:\t%s",
+		appVersion, appDate, appType, appCommit, appPlatform, appArch)
+
+	appAboutLong = fmt.Sprintf("%s\n%s\n%s\n\n%s", appLogo, appDesc, appAuthors, appVersionLong)
 )
 
 var logger *zap.Logger
@@ -47,7 +56,7 @@ var (
 var rootCmd = &cobra.Command{
 	Use:   "hysteria",
 	Short: appDesc,
-	Long:  fmt.Sprintf("%s\n%s\n%s\n\n%s", appLogo, appDesc, appAuthors, appVersionLong),
+	Long:  appAboutLong,
 	Run:   runClient, // Default to client mode
 }
 

app/cmd/server.go

@@ -606,6 +606,8 @@ func runServer(cmd *cobra.Command, args []string) {
 	}
 	logger.Info("server up and running")
 
+	go runCheckUpdateServer()
+
 	if err := s.Serve(); err != nil {
 		logger.Fatal("failed to serve", zap.Error(err))
 	}

app/cmd/update.go

@@ -0,0 +1,88 @@
+package cmd
+
+import (
+	"time"
+
+	"github.com/spf13/cobra"
+	"go.uber.org/zap"
+
+	"github.com/apernet/hysteria/app/internal/utils"
+	"github.com/apernet/hysteria/core/client"
+)
+
+const (
+	updateCheckInterval = 24 * time.Hour
+)
+
+// checkUpdateCmd represents the checkUpdate command
+var checkUpdateCmd = &cobra.Command{
+	Use:   "check-update",
+	Short: "Check for updates",
+	Long:  "Check for updates.",
+	Run:   runCheckUpdate,
+}
+
+func init() {
+	rootCmd.AddCommand(checkUpdateCmd)
+}
+
+func runCheckUpdate(cmd *cobra.Command, args []string) {
+	logger.Info("checking for updates",
+		zap.String("version", appVersion),
+		zap.String("platform", appPlatform),
+		zap.String("arch", appArch),
+		zap.String("channel", appType),
+	)
+
+	checker := utils.NewServerUpdateChecker(appVersion, appPlatform, appArch, appType)
+	resp, err := checker.Check()
+	if err != nil {
+		logger.Fatal("failed to check for updates", zap.Error(err))
+	}
+	if resp.HasUpdate {
+		logger.Info("update available",
+			zap.String("version", resp.LatestVersion),
+			zap.String("url", resp.URL),
+			zap.Bool("urgent", resp.Urgent),
+		)
+	} else {
+		logger.Info("no update available")
+	}
+}
+
+// runCheckUpdateServer is the background update checking routine for server mode
+func runCheckUpdateServer() {
+	checker := utils.NewServerUpdateChecker(appVersion, appPlatform, appArch, appType)
+	checkUpdateRoutine(checker)
+}
+
+// runCheckUpdateClient is the background update checking routine for client mode
+func runCheckUpdateClient(hyClient client.Client) {
+	checker := utils.NewClientUpdateChecker(appVersion, appPlatform, appArch, appType, hyClient)
+	checkUpdateRoutine(checker)
+}
+
+func checkUpdateRoutine(checker *utils.UpdateChecker) {
+	ticker := time.NewTicker(updateCheckInterval)
+	for {
+		logger.Debug("checking for updates",
+			zap.String("version", appVersion),
+			zap.String("platform", appPlatform),
+			zap.String("arch", appArch),
+			zap.String("channel", appType),
+		)
+		resp, err := checker.Check()
+		if err != nil {
+			logger.Debug("failed to check for updates", zap.Error(err))
+		} else if resp.HasUpdate {
+			logger.Info("update available",
+				zap.String("version", resp.LatestVersion),
+				zap.String("url", resp.URL),
+				zap.Bool("urgent", resp.Urgent),
+			)
+		} else {
+			logger.Debug("no update available")
+		}
+		<-ticker.C
+	}
+}

app/cmd/version.go

@@ -0,0 +1,23 @@
+package cmd
+
+import (
+	"fmt"
+
+	"github.com/spf13/cobra"
+)
+
+// versionCmd represents the version command
+var versionCmd = &cobra.Command{
+	Use:   "version",
+	Short: "Show version",
+	Long:  "Show version.",
+	Run:   runVersion,
+}
+
+func init() {
+	rootCmd.AddCommand(versionCmd)
+}
+
+func runVersion(cmd *cobra.Command, args []string) {
+	fmt.Println(appAboutLong)
+}

app/internal/utils/update.go

@@ -0,0 +1,92 @@
+package utils
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"net"
+	"net/http"
+	"time"
+
+	"github.com/apernet/hysteria/core/client"
+)
+
+const (
+	updateCheckEndpoint = "https://api.hy2.io/v1/update"
+	updateCheckTimeout  = 10 * time.Second
+)
+
+type UpdateChecker struct {
+	CurrentVersion string
+	Platform       string
+	Architecture   string
+	Channel        string
+	Client         *http.Client
+}
+
+func NewServerUpdateChecker(currentVersion, platform, architecture, channel string) *UpdateChecker {
+	return &UpdateChecker{
+		CurrentVersion: currentVersion,
+		Platform:       platform,
+		Architecture:   architecture,
+		Channel:        channel,
+		Client: &http.Client{
+			Timeout: updateCheckTimeout,
+		},
+	}
+}
+
+// NewClientUpdateChecker ensures that update checks are routed through a HyClient,
+// not being sent directly. This safeguard is CRITICAL, especially in scenarios where
+// users use Hysteria to bypass censorship. Making direct HTTPS requests to the API
+// endpoint could be easily spotted by censors (through SNI, for example), and could
+// serve as a signal to identify and penalize Hysteria users.
+func NewClientUpdateChecker(currentVersion, platform, architecture, channel string, hyClient client.Client) *UpdateChecker {
+	return &UpdateChecker{
+		CurrentVersion: currentVersion,
+		Platform:       platform,
+		Architecture:   architecture,
+		Channel:        channel,
+		Client: &http.Client{
+			Timeout: updateCheckTimeout,
+			Transport: &http.Transport{
+				DialContext: func(_ context.Context, network, addr string) (net.Conn, error) {
+					// Unfortunately HyClient doesn't support context for now
+					return hyClient.TCP(addr)
+				},
+			},
+		},
+	}
+}
+
+type UpdateResponse struct {
+	HasUpdate     bool   `json:"update"`
+	LatestVersion string `json:"lver"`
+	URL           string `json:"url"`
+	Urgent        bool   `json:"urgent"`
+}
+
+func (uc *UpdateChecker) Check() (*UpdateResponse, error) {
+	url := fmt.Sprintf("%s?cver=%s&plat=%s&arch=%s&chan=%s",
+		updateCheckEndpoint,
+		uc.CurrentVersion,
+		uc.Platform,
+		uc.Architecture,
+		uc.Channel,
+	)
+	resp, err := uc.Client.Get(url)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		return nil, fmt.Errorf("unexpected status code: %d", resp.StatusCode)
+	}
+	var uResp UpdateResponse
+	decoder := json.NewDecoder(resp.Body)
+	if err := decoder.Decode(&uResp); err != nil {
+		return nil, err
+	}
+	return &uResp, nil
+}

hyperbole.py

@@ -128,11 +128,16 @@ def get_app_commit():
     return app_commit
 
 
+def get_current_os_arch():
+    d_os = subprocess.check_output(["go", "env", "GOOS"]).decode().strip()
+    d_arch = subprocess.check_output(["go", "env", "GOARCH"]).decode().strip()
+    return (d_os, d_arch)
+
+
 def get_app_platforms():
     platforms = os.environ.get("HY_APP_PLATFORMS")
     if not platforms:
-        d_os = subprocess.check_output(["go", "env", "GOOS"]).decode().strip()
-        d_arch = subprocess.check_output(["go", "env", "GOARCH"]).decode().strip()
+        d_os, d_arch = get_current_os_arch()
         return [(d_os, d_arch)]
 
     result = []
@@ -190,13 +195,19 @@ def cmd_build(pprof=False, release=False):
         else:
             env["GOARCH"] = arch
 
+        plat_ldflags = ldflags.copy()
+        plat_ldflags.append("-X")
+        plat_ldflags.append(APP_SRC_CMD_PKG + ".appPlatform=" + os_name)
+        plat_ldflags.append("-X")
+        plat_ldflags.append(APP_SRC_CMD_PKG + ".appArch=" + arch)
+
         cmd = [
             "go",
             "build",
             "-o",
             os.path.join(BUILD_DIR, out_name),
             "-ldflags",
-            " ".join(ldflags),
+            " ".join(plat_ldflags),
         ]
         if pprof:
             cmd.append("-tags")
@@ -222,6 +233,8 @@ def cmd_run(args, pprof=False):
     app_date = datetime.datetime.utcnow().strftime("%Y-%m-%dT%H:%M:%SZ")
     app_commit = get_app_commit()
 
+    current_os, current_arch = get_current_os_arch()
+
     ldflags = [
         "-X",
         APP_SRC_CMD_PKG + ".appVersion=" + app_version,
@@ -231,6 +244,10 @@ def cmd_run(args, pprof=False):
         APP_SRC_CMD_PKG + ".appType=dev-run",
         "-X",
         APP_SRC_CMD_PKG + ".appCommit=" + app_commit,
+        "-X",
+        APP_SRC_CMD_PKG + ".appPlatform=" + current_os,
+        "-X",
+        APP_SRC_CMD_PKG + ".appArch=" + current_arch,
     ]
 
     cmd = ["go", "run", "-ldflags", " ".join(ldflags)]