feat: auto updater (#933)

cmd/host/main.go

@@ -55,6 +55,8 @@ var apiMap = map[string]func(params json.RawMessage) (data any, err error){
 	},
 }
 
+// go build -ldflags="-s -w" -o ui/flutter/assets/exec/ github.com/GopeedLab/gopeed/cmd/host
+
 func main() {
 	for {
 		// Read message length (first 4 bytes)

cmd/updater/main.go

@@ -0,0 +1,116 @@
+package main
+
+import (
+	"flag"
+	"fmt"
+	"log"
+	"os"
+	"path/filepath"
+	"syscall"
+	"time"
+
+	"github.com/pkg/browser"
+	"github.com/pkg/errors"
+)
+
+// go build -ldflags="-s -w" -o ui/flutter/assets/exec/ github.com/GopeedLab/gopeed/cmd/updater
+
+func main() {
+	pid := flag.Int("pid", 0, "PID of the process to update")
+	updateChannel := flag.String("channel", "", "Update channel")
+	packagePath := flag.String("asset", "", "Path to the package asset")
+	logPath := flag.String("log", "", "Log file path")
+	flag.Parse()
+
+	if *pid == 0 {
+		log.Println("Invalid PID")
+		os.Exit(1)
+	}
+	if *updateChannel == "" {
+		log.Println("Invalid update channel")
+		os.Exit(1)
+	}
+
+	if *logPath != "" {
+		logFile, err := os.OpenFile(*logPath, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, 0666)
+		if err == nil {
+			defer logFile.Close()
+			log.SetOutput(logFile)
+		}
+	}
+
+	var (
+		restart bool
+		err     error
+	)
+	if restart, err = update(*pid, *updateChannel, *packagePath); err != nil {
+		log.Printf("Update failed: %v\n", err)
+		os.Exit(1)
+	}
+
+	// Restart the application
+	if restart {
+		browser.OpenURL("gopeed:///")
+	}
+
+	// Delete package asset
+	if *packagePath != "" {
+		os.Remove(*packagePath)
+	}
+
+	os.Exit(0)
+}
+
+func update(pid int, updateChannel, packagePath string) (restart bool, err error) {
+	killSignalChan := make(chan any, 1)
+
+	go func() {
+		<-killSignalChan
+
+		if err = killProcess(pid); err != nil {
+			log.Printf("Failed to kill process: %v\n", err)
+		}
+
+		if err = waitForProcessExit(pid); err != nil {
+			log.Printf("Failed to wait for process exit: %v\n", err)
+		}
+	}()
+
+	appDir := filepath.Dir(os.Args[0])
+	log.Printf("Updating process updateChannel=%s packagePath=%s appDir=%s\n", updateChannel, packagePath, appDir)
+	if restart, err = install(killSignalChan, updateChannel, packagePath, appDir); err != nil {
+		return false, errors.Wrap(err, "failed to install package")
+	}
+
+	return
+}
+
+func waitForProcessExit(pid int) error {
+	deadline := time.Now().Add(10 * time.Second)
+	for time.Now().Before(deadline) {
+		process, err := os.FindProcess(pid)
+		if err != nil {
+			// On some systems, error is returned if process doesn't exist
+			return nil
+		}
+
+		// Send null signal to test if process exists
+		err = process.Signal(syscall.Signal(0))
+		if err != nil {
+			// If error occurs, the process no longer exists
+			return nil
+		}
+
+		time.Sleep(100 * time.Millisecond)
+	}
+	return fmt.Errorf("process %d still running after timeout", pid)
+}
+
+func killProcess(pid int) error {
+	process, err := os.FindProcess(pid)
+	if err != nil {
+		return err
+	}
+
+	return process.Kill()
+}

cmd/updater/updater_darwin.go

@@ -0,0 +1,68 @@
+//go:build darwin
+
+package main
+
+import (
+	"fmt"
+	"os/exec"
+	"path/filepath"
+	"strings"
+)
+
+func install(killSignalChan chan<- any, updateChannel, packagePath, destDir string) (bool, error) {
+	return true, installByDmg(killSignalChan, packagePath, destDir)
+}
+
+// installByDmg handles macOS dmg package installation
+func installByDmg(killSignalChan chan<- any, packagePath, destDir string) error {
+	// /Applications/Gopeed.app/Contents/MacOS -> /Applications
+	appPath := getParentDir(getParentDir(getParentDir(destDir)))
+	output, err := exec.Command("hdiutil", "attach", packagePath, "-nobrowse").Output()
+	if err != nil {
+		return err
+	}
+
+	mountPoint := ""
+	for _, line := range strings.Split(string(output), "\n") {
+		if strings.Contains(line, "/Volumes/") {
+			fields := strings.Fields(line)
+			if len(fields) > 2 {
+				mountPoint = fields[len(fields)-1]
+				break
+			}
+		}
+	}
+
+	if mountPoint == "" {
+		return fmt.Errorf("failed to get mount point")
+	}
+
+	// Detach the mounted DMG
+	defer exec.Command("hdiutil", "detach", mountPoint, "-quiet").Run()
+
+	matches, err := filepath.Glob(filepath.Join(mountPoint, "*.app"))
+	if err != nil {
+		return err
+	}
+	if len(matches) == 0 {
+		return fmt.Errorf("no .app found in dmg")
+	}
+
+	killSignalChan <- nil
+
+	// Copy the new app to the destination
+	// cp -Rf /Volumes/GoPeed/GoPeed.app /Applications
+	if err := exec.Command("cp", "-Rf", matches[0], appPath).Run(); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// Get parent directory safely, handling trailing separators
+func getParentDir(path string) string {
+	// Remove trailing separators if they exist
+	path = strings.TrimRight(path, string(filepath.Separator))
+	// Now get the parent directory
+	return filepath.Dir(path)
+}

cmd/updater/updater_linux.go

@@ -0,0 +1,72 @@
+//go:build linux
+
+package main
+
+import (
+	"fmt"
+	"os/exec"
+)
+
+func install(killSignalChan chan<- any, updateChannel, packagePath, destDir string) (bool, error) {
+	killSignalChan <- nil
+	switch updateChannel {
+	case "linuxDeb":
+		return true, installByDeb(packagePath)
+	case "linuxFlathub":
+		return true, installByFlathub()
+	case "linuxSnap":
+		return true, installBySnap()
+	default:
+		return false, fmt.Errorf("unsupported update channel for Linux: %s", updateChannel)
+	}
+}
+
+// executeInTerminal tries to execute a command in one of several common terminal emulators
+func executeInTerminal(command string) error {
+	terminals := []string{
+		"gnome-terminal", // GNOME
+		"konsole",        // KDE
+		"xfce4-terminal", // XFCE
+		"xterm",          // X11
+	}
+
+	command = fmt.Sprintf(`echo "Starting update..." && echo "[CMD] %s" && %s`, command, command)
+
+	for _, term := range terminals {
+		if _, err := exec.LookPath(term); err == nil {
+			var cmd *exec.Cmd
+			switch term {
+			case "gnome-terminal", "xfce4-terminal":
+				cmd = exec.Command(term, "--", "bash", "-c", command)
+			case "konsole":
+				cmd = exec.Command(term, "-e", "bash", "-c", command)
+			case "xterm":
+				cmd = exec.Command(term, "-e", command)
+			}
+
+			if err := cmd.Start(); err == nil {
+				return nil
+			}
+		}
+	}
+
+	return fmt.Errorf("no suitable terminal emulator found. Please install gnome-terminal, konsole, xfce4-terminal or xterm")
+}
+
+// installByDeb installs the .deb package
+func installByDeb(packagePath string) error {
+	command := fmt.Sprintf(`sudo dpkg -i "%s"`, packagePath)
+	return executeInTerminal(command)
+}
+
+// installByFlathub updates the application via Flathub
+func installByFlathub() error {
+	command := "flatpak update com.gopeed.Gopeed -y"
+	return executeInTerminal(command)
+}
+
+// installBySnap updates the application via Snap
+func installBySnap() error {
+	command := "sudo snap refresh gopeed"
+	return executeInTerminal(command)
+}

cmd/updater/updater_windows.go

@@ -0,0 +1,134 @@
+//go:build windows
+
+package main
+
+import (
+	"archive/zip"
+	"fmt"
+	"io"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+)
+
+func install(killSignalChan chan<- any, updateChannel, packagePath, destDir string) (bool, error) {
+	switch updateChannel {
+	case "windowsInstaller":
+		return false, installByInstaller(killSignalChan, packagePath, destDir)
+	default:
+		return true, installByPortable(killSignalChan, packagePath, destDir)
+	}
+}
+
+// installByInstaller extracts the installer from the zip file and runs it
+func installByInstaller(killSignalChan chan<- any, packagePath, destDir string) error {
+	// Create a temp directory for extraction
+	tempDir, err := os.MkdirTemp("", "gopeed_update")
+	if err != nil {
+		return err
+	}
+	defer os.RemoveAll(tempDir)
+
+	// Extract the zip file
+	reader, err := zip.OpenReader(packagePath)
+	if err != nil {
+		return err
+	}
+	defer reader.Close()
+
+	// Find the installer file
+	var installerPath string
+	for _, file := range reader.File {
+		if file.FileInfo().IsDir() {
+			continue
+		}
+
+		// Extract file
+		path := filepath.Join(tempDir, file.Name)
+
+		if err := os.MkdirAll(filepath.Dir(path), os.ModePerm); err != nil {
+			return err
+		}
+
+		dstFile, err := os.OpenFile(path, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, file.Mode())
+		if err != nil {
+			return err
+		}
+
+		srcFile, err := file.Open()
+		if err != nil {
+			dstFile.Close()
+			return err
+		}
+
+		_, err = io.Copy(dstFile, srcFile)
+		srcFile.Close()
+		dstFile.Close()
+		if err != nil {
+			return err
+		}
+
+		// If this is likely an installer (.exe, .msi), save its path
+		ext := strings.ToLower(filepath.Ext(file.Name))
+		if ext == ".exe" || ext == ".msi" {
+			installerPath = path
+		}
+	}
+
+	if installerPath == "" {
+		return fmt.Errorf("no installer found in the update package")
+	}
+
+	// Run the installer
+	cmd := exec.Command(installerPath)
+	if err := cmd.Start(); err != nil {
+		return err
+	}
+
+	killSignalChan <- nil
+	return nil
+}
+
+// installByPortable extracts the portable version to the destination directory
+func installByPortable(killSignalChan chan<- any, packagePath, destDir string) error {
+	killSignalChan <- nil
+
+	reader, err := zip.OpenReader(packagePath)
+	if err != nil {
+		return err
+	}
+	defer reader.Close()
+
+	for _, file := range reader.File {
+		path := filepath.Join(destDir, file.Name)
+
+		if file.FileInfo().IsDir() {
+			os.MkdirAll(path, file.Mode())
+			continue
+		}
+
+		if err := os.MkdirAll(filepath.Dir(path), os.ModePerm); err != nil {
+			return err
+		}
+
+		dstFile, err := os.OpenFile(path, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, file.Mode())
+		if err != nil {
+			return err
+		}
+
+		srcFile, err := file.Open()
+		if err != nil {
+			dstFile.Close()
+			return err
+		}
+
+		_, err = io.Copy(dstFile, srcFile)
+		srcFile.Close()
+		dstFile.Close()
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}