Added new ZeuZ Node update mechanism with version check and progress reporting

Author: mdshakib007

Apps/node_runner/main.go

@@ -2,6 +2,8 @@ package main
 
 import (
 	"archive/zip"
+	"encoding/json"
+	"errors"
 	"flag"
 	"fmt"
 	"io"
@@ -11,16 +13,141 @@ import (
 	"path/filepath"
 	"runtime"
 	"strings"
+	"time"
 
 	"github.com/automationsolutionz/Zeuz_Python_Node/Apps/node_runner/uv_installer"
 )
 
 var (
-	version   = "dev"
-	branch    = flag.String("branch", "", "Branch to download (defaults to tagged version)")
-	cleanFlag = flag.Bool("clean", false, "Remove ZeuZ Node directory and $HOME/.zeuz and exit")
+	version       = "dev"
+	targetVersion string // runtime override; empty = use build-time version
+	branch        = flag.String("branch", "", "Branch to download (defaults to tagged version)")
+	cleanFlag     = flag.Bool("clean", false, "Remove ZeuZ Node directory and $HOME/.zeuz and exit")
+	updateFlag    = flag.Bool("update", false, "Download and install the latest ZeuZ Node version")
 )
 
+const (
+	colorReset  = "\033[0m"
+	colorGreen  = "\033[32m"
+	colorYellow = "\033[33m"
+	colorBold   = "\033[1m"
+)
+
+type zeuzRelease struct {
+	TagName string `json:"tag_name"`
+}
+
+var errRateLimited = errors.New("GitHub API rate limited — try again later")
+
+func effectiveVersion() string {
+	if targetVersion != "" {
+		return targetVersion
+	}
+	return version
+}
+
+// fetchLatestVersion fetches the latest ZeuZ Node release tag from GitHub
+func fetchLatestVersion() (string, error) {
+	client := &http.Client{Timeout: 5 * time.Second}
+	req, err := http.NewRequest("GET",
+		"https://api.github.com/repos/AutomationSolutionz/Zeuz_Python_Node/releases/latest",
+		nil)
+	if err != nil {
+		return "", err
+	}
+	req.Header.Set("User-Agent", "zeuz-node-runner/"+version)
+	resp, err := client.Do(req)
+	if err != nil {
+		return "", err
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode == 403 {
+		return "", errRateLimited
+	}
+	if resp.StatusCode != 200 {
+		return "", fmt.Errorf("HTTP %d", resp.StatusCode)
+	}
+	var r zeuzRelease
+	json.NewDecoder(resp.Body).Decode(&r)
+	return r.TagName, nil
+}
+
+// printUpdateBanner prints a styled update available notice
+func printUpdateBanner(current, latest string) {
+	width := 52
+	line1 := fmt.Sprintf("  Update available: %s → %s", current, latest)
+	line2 := "  Run with --update to upgrade"
+	pad := func(s string) string {
+		spaces := width - len(s) - 1
+		if spaces < 0 {
+			spaces = 0
+		}
+		return s + strings.Repeat(" ", spaces) + "║"
+	}
+	border := "╔" + strings.Repeat("═", width) + "╗"
+	bottom := "╚" + strings.Repeat("═", width) + "╝"
+	fmt.Println(colorYellow + border)
+	fmt.Println("║" + pad(line1))
+	fmt.Println("║" + pad(line2))
+	fmt.Println(bottom + colorReset)
+}
+
+// runUpdate fetches the latest release and replaces the current ZeuZ Node directory
+func runUpdate() error {
+	if *branch != "" {
+		return fmt.Errorf("--update is not compatible with --branch")
+	}
+	if version == "dev" || strings.HasPrefix(version, "dev-") {
+		fmt.Println("  Dev build — skipping update check")
+		return nil
+	}
+
+	fmt.Println("  Checking for updates...")
+	latest, err := fetchLatestVersion()
+	if err != nil {
+		return fmt.Errorf("could not check for updates: %w", err)
+	}
+
+	if effectiveVersion() == latest {
+		fmt.Printf(colorGreen+"  Already up to date (%s)"+colorReset+"\n", latest)
+		return nil
+	}
+
+	fmt.Printf("  Updating %s → %s\n", effectiveVersion(), latest)
+	oldDir := getZeuZNodeDir()
+	os.RemoveAll(oldDir)
+
+	targetVersion = latest
+	if err := setupZeuzNode(); err != nil {
+		return fmt.Errorf("update failed: %w", err)
+	}
+
+	fmt.Printf(colorGreen+"  Update complete (%s)"+colorReset+"\n", latest)
+	return nil
+}
+
+// progressReader wraps an io.Reader and prints download progress
+type progressReader struct {
+	reader io.Reader
+	total  int64
+	read   int64
+}
+
+func (p *progressReader) Read(buf []byte) (int, error) {
+	n, err := p.reader.Read(buf)
+	p.read += int64(n)
+	if p.total > 0 {
+		pct := (p.read * 100) / p.total
+		fmt.Printf("\r  Downloading... %d%%  ", pct)
+	} else {
+		fmt.Printf("\r  Downloading... %.1f MB", float64(p.read)/1e6)
+	}
+	if err == io.EOF {
+		fmt.Println()
+	}
+	return n, err
+}
+
 func downloadFile(url, destPath string) error {
 	resp, err := http.Get(url)
 	if err != nil {
@@ -38,7 +165,8 @@ func downloadFile(url, destPath string) error {
 	}
 	defer os.Remove(out.Name())
 
-	_, err = io.Copy(out, resp.Body)
+	pr := &progressReader{reader: resp.Body, total: resp.ContentLength}
+	_, err = io.Copy(out, pr)
 	if err != nil {
 		out.Close()
 		return fmt.Errorf("failed to write file: %v", err)
@@ -125,8 +253,9 @@ func getZeuZNodeURL() string {
 	if *branch != "" {
 		return fmt.Sprintf("https://github.com/AutomationSolutionz/Zeuz_Python_Node/archive/refs/heads/%s.zip", *branch)
 	}
-	if version != "dev" && !strings.HasPrefix(version, "dev-") {
-		return fmt.Sprintf("https://github.com/AutomationSolutionz/Zeuz_Python_Node/archive/refs/tags/%s.zip", version)
+	ev := effectiveVersion()
+	if ev != "dev" && !strings.HasPrefix(ev, "dev-") {
+		return fmt.Sprintf("https://github.com/AutomationSolutionz/Zeuz_Python_Node/archive/refs/tags/%s.zip", ev)
 	}
 	return "https://github.com/AutomationSolutionz/Zeuz_Python_Node/archive/refs/heads/dev.zip"
 }
@@ -135,9 +264,11 @@ func getZeuZNodeDir() string {
 	selectedVersion := ""
 	if *branch != "" {
 		selectedVersion = *branch
-	}
-	if version != "dev" && !strings.HasPrefix(version, "dev-") {
-		selectedVersion = version
+	} else {
+		ev := effectiveVersion()
+		if ev != "dev" && !strings.HasPrefix(ev, "dev-") {
+			selectedVersion = ev
+		}
 	}
 
 	return fmt.Sprintf("ZeuZ_Node-%s", selectedVersion)
@@ -159,7 +290,7 @@ func setupZeuzNode() error {
 		}
 	}
 
-	fmt.Println("Setting up ZeuZ Node...")
+	fmt.Println("  Setting up ZeuZ Node...")
 
 	// Create temporary directory for zip file
 	tempDir, err := os.MkdirTemp("", "zeuz-download")
@@ -171,7 +302,7 @@ func setupZeuzNode() error {
 	// Download zip file
 	zipPath := filepath.Join(tempDir, "zeuz.zip")
 	zeuzURL := getZeuZNodeURL()
-	fmt.Printf("Downloading ZeuZ Node repository from: %s\n", zeuzURL)
+	fmt.Printf("  Fetching from: %s\n", zeuzURL)
 	if err := downloadFile(zeuzURL, zipPath); err != nil {
 		return err
 	}
@@ -182,7 +313,7 @@ func setupZeuzNode() error {
 	}
 
 	// Extract zip file
-	fmt.Println("Extracting ZeuZ Node repository...")
+	fmt.Println("  Extracting...")
 	if err := unzip(zipPath, zeuzDir); err != nil {
 		return err
 	}
@@ -272,73 +403,102 @@ func runUVCommands(args []string) error {
 func main() {
 	flag.Parse()
 
-	fmt.Printf("✅ ZeuZ Node %s\n", version)
+	fmt.Printf(colorGreen+colorBold+"  ZeuZ Node %s"+colorReset+"\n", version)
+
+	// Launch background version check (non-blocking)
+	updateCh := make(chan string, 1)
+	go func() {
+		latest, err := fetchLatestVersion()
+		if err != nil {
+			updateCh <- ""
+			return
+		}
+		updateCh <- latest
+	}()
 
 	zeuzDir := getZeuZNodeDir()
 
 	if *cleanFlag {
 		var removedAny bool
 		if err := os.RemoveAll(zeuzDir); err == nil {
-			fmt.Printf("Removed %s\n", zeuzDir)
+			fmt.Printf(colorYellow+"  Removed %s"+colorReset+"\n", zeuzDir)
 			removedAny = true
 		} else if !os.IsNotExist(err) {
-			fmt.Printf("Failed to remove %s: %v\n", zeuzDir, err)
+			fmt.Printf("  Failed to remove %s: %v\n", zeuzDir, err)
 		}
 
 		home, err := os.UserHomeDir()
 		if err == nil {
 			zeuzHome := filepath.Join(home, ".zeuz")
 			if err := os.RemoveAll(zeuzHome); err == nil {
-				fmt.Printf("Removed %s\n", zeuzHome)
+				fmt.Printf(colorYellow+"  Removed %s"+colorReset+"\n", zeuzHome)
 				removedAny = true
 			} else if !os.IsNotExist(err) {
-				fmt.Printf("Failed to remove %s: %v\n", zeuzHome, err)
+				fmt.Printf("  Failed to remove %s: %v\n", zeuzHome, err)
 			}
 		} else {
-			fmt.Printf("Could not determine user home dir: %v\n", err)
+			fmt.Printf("  Could not determine user home dir: %v\n", err)
 		}
 
 		if !removedAny {
-			fmt.Println("Nothing removed. No matching directories found.")
+			fmt.Println("  Nothing removed. No matching directories found.")
 		} else {
-			fmt.Println("Cleanup complete — proceeding to download & install a fresh copy.")
+			fmt.Println(colorGreen + "  Cleanup complete — downloading fresh copy." + colorReset)
+		}
+	}
+
+	if *updateFlag {
+		if err := runUpdate(); err != nil {
+			fmt.Printf(colorYellow+"  Warning: %v"+colorReset+"\n", err)
+			os.Exit(1)
 		}
 	}
 
 	// Setup ZeuZ Node directory and change into it
 	if err := setupZeuzNode(); err != nil {
-		fmt.Printf("Error setting up ZeuZ Node: %v\n", err)
+		fmt.Printf("  Error setting up ZeuZ Node: %v\n", err)
 		os.Exit(1)
 	}
 
-	// Change directory to ZeuZ Node
+	// Change directory to ZeuZ Node (re-evaluate after potential targetVersion change)
+	zeuzDir = getZeuZNodeDir()
 	if err := os.Chdir(zeuzDir); err != nil {
-		fmt.Printf("Error changing to ZeuZ Node directory: %v\n", err)
+		fmt.Printf("  Error changing to ZeuZ Node directory: %v\n", err)
 		os.Exit(1)
 	}
 
+	// Drain the background update check (non-blocking)
+	select {
+	case latest := <-updateCh:
+		if latest != "" && latest != effectiveVersion() {
+			printUpdateBanner(effectiveVersion(), latest)
+		}
+	default:
+		// check still in flight or failed — continue silently
+	}
+
 	// Update PATH before checking if UV is installed
 	if err := updatePath(); err != nil {
-		fmt.Printf("Error updating path: %v\n", err)
+		fmt.Printf("  Error updating path: %v\n", err)
 	}
 
 	// Install UV if needed
 	if err := installUV(); err != nil {
-		fmt.Printf("Error installing UV: %v\n", err)
+		fmt.Printf("  Error installing UV: %v\n", err)
 		os.Exit(1)
 	}
 
 	// Update PATH to ensure UV is available after installation
 	if err := updatePath(); err != nil {
-		fmt.Printf("Error updating path: %v\n", err)
+		fmt.Printf("  Error updating path: %v\n", err)
 	}
 
 	// Get remaining command line arguments after flag parsing
 	args := flag.Args()
 
 	// Run UV commands with arguments
 	if err := runUVCommands(args); err != nil {
-		fmt.Printf("Error running UV commands: %v\n", err)
+		fmt.Printf("  Error running UV commands: %v\n", err)
 		os.Exit(1)
 	}
 }