feat(updater): refactor installer logic and implement automatic daemon background updates (#33)

EXTENDED DESCRIPTION:
Refactors the installer and updater for smarter, self-contained operation:

- Installer download-on-demand: auto-downloads latest release if files are missing
- Graceful shutdown via PID file (SIGTERM + SIGKILL safety check), replaces pkill -f
- Updater delegates entirely to rag-code-install via --upgrade handoff
- AutoUpdate background worker in daemon (goroutine, 10s after boot)
- Shared DownloadVerifyAndApply helper eliminates code duplication
- Checksum-verified downloads (supply-chain security)
- Proper tempDir cleanup on all error paths
- Dependency fix: golang.org/x/tools downgraded to v0.33.0 for Go 1.24 compat

Author: doITmagic

cmd/rag-code-install/main.go

@@ -1,6 +1,7 @@
 package main
 
 import (
+	"context"
 	"encoding/json"
 	"flag"
 	"fmt"
@@ -10,12 +11,16 @@ import (
 	"os/exec"
 	"path/filepath"
 	"runtime"
+	"strconv"
 	"strings"
+	"syscall"
 	"time"
 
+	"github.com/codeclysm/extract/v3"
 	"github.com/doITmagic/rag-code-mcp/internal/config"
 	"github.com/doITmagic/rag-code-mcp/internal/healthcheck"
 	"github.com/doITmagic/rag-code-mcp/internal/uninstall"
+	"github.com/doITmagic/rag-code-mcp/internal/updater"
 )
 
 var (
@@ -70,24 +75,41 @@ func main() {
 		fail(fmt.Sprintf("Failed to create directories: %v", err))
 	}
 
-	// 2. Determine current location
+	// 2. Determine current location strictly
 	execPath, _ := os.Executable()
 	sourceDir := filepath.Dir(execPath)
-	resourceDir := sourceDir
 
-	// If we are running from bin/, resources might be in the parent dir
-	if _, err := os.Stat(filepath.Join(resourceDir, "README.md")); os.IsNotExist(err) {
-		parentDir := filepath.Dir(resourceDir)
-		if _, err := os.Stat(filepath.Join(parentDir, "README.md")); err == nil {
-			resourceDir = parentDir
-		}
-	}
-
-	// 3. Define files to install
 	binaries := []string{"rag-code-mcp", "rag-code-install"}
 	resources := []string{"README.md", "llms.txt", "LICENSE", "config.yaml"}
 
-	log("Copying files from: " + sourceDir)
+	// Fast Check: Are files present?
+	missingFiles := false
+	for _, f := range append(binaries, resources...) {
+		name := f
+		if runtime.GOOS == "windows" && (f == "rag-code-mcp" || f == "rag-code-install") {
+			name += ".exe"
+		}
+		if _, err := os.Stat(filepath.Join(sourceDir, name)); os.IsNotExist(err) {
+			missingFiles = true
+			break
+		}
+	}
+
+	// If files are missing, we must download the latest release and use its contents as source
+	tempDir := ""
+	if missingFiles {
+		log("Required files missing in current directory. Downloading latest release...")
+		var err error
+		tempDir, err = downloadAndExtractLatest()
+		if err != nil {
+			fail(fmt.Sprintf("Failed to download and extract release: %v", err))
+		}
+		defer os.RemoveAll(tempDir)
+		sourceDir = tempDir
+		log("Files extracted successfully from release.")
+	} else {
+		log("Copying files from: " + sourceDir)
+	}
 
 	// Copy Binaries to bin/
 	for _, b := range binaries {
@@ -110,7 +132,7 @@ func main() {
 
 	// Copy Resources to bin/
 	for _, r := range resources {
-		src := filepath.Join(resourceDir, r)
+		src := filepath.Join(sourceDir, r)
 		dst := filepath.Join(binPath, r)
 
 		if r == "config.yaml" {
@@ -373,29 +395,67 @@ func stopRunningProcess(binPath string) {
 		return
 	}
 
-	log("Stopping existing process running: " + binPath)
+	log("Stopping existing process gracefully: " + binPath)
+
+	// Attempt Graceful Shutdown using PID file
+	home, err := os.UserHomeDir()
+	if err == nil {
+		pidPath := filepath.Join(home, ".ragcode", "daemon.pid")
+		if data, err := os.ReadFile(pidPath); err == nil {
+			pidStr := strings.TrimSpace(string(data))
+			if pid, err := strconv.Atoi(pidStr); err == nil {
+				log(fmt.Sprintf("Found daemon PID: %d. Sending termination signal...", pid))
+
+				// For Windows
+				if runtime.GOOS == "windows" {
+					_ = exec.Command("taskkill", "/PID", pidStr).Run()
+					time.Sleep(2 * time.Second)
+					_ = exec.Command("taskkill", "/F", "/PID", pidStr).Run()
+					return
+				}
+
+				// For Unix
+				process, err := os.FindProcess(pid)
+				if err == nil {
+					// Send SIGTERM
+					_ = process.Signal(syscall.SIGTERM)
+
+					// Wait up to 5 seconds for it to exit gracefully
+					for i := 0; i < 50; i++ {
+						if err := process.Signal(syscall.Signal(0)); err != nil {
+							// Process is gone
+							break
+						}
+						time.Sleep(100 * time.Millisecond)
+					}
+
+					// After grace period, only SIGKILL if process still appears alive
+					if err := process.Signal(syscall.Signal(0)); err == nil {
+						_ = process.Signal(syscall.SIGKILL)
+						time.Sleep(200 * time.Millisecond)
+					}
+					return
+				}
+			}
+		}
+	}
+
+	log("PID file not found or process untrackable. Using fallback termination...")
 
 	if runtime.GOOS == "windows" {
+		_ = exec.Command("taskkill", "/IM", filepath.Base(binPath)).Run()
+		time.Sleep(1 * time.Second)
 		_ = exec.Command("taskkill", "/F", "/IM", filepath.Base(binPath)).Run()
-		time.Sleep(500 * time.Millisecond)
 		return
 	}
 
-	// 1. Precise kill using full path
-	_ = exec.Command("pkill", "-f", binPath).Run()
+	// 1. Soft kill (SIGTERM)
+	_ = exec.Command("pkill", "-15", "-f", binPath).Run()
+	time.Sleep(1 * time.Second)
 
-	// 2. Fallback using lsof to find PIDs mapping this binary
-	if _, err := exec.LookPath("lsof"); err == nil {
-		cmd := exec.Command("lsof", "-t", binPath)
-		if output, err := cmd.Output(); err == nil {
-			pids := strings.Fields(string(output))
-			for _, pid := range pids {
-				_ = exec.Command("kill", "-9", pid).Run()
-			}
-		}
-	}
+	// 2. Hard kill (SIGKILL) fallback
+	_ = exec.Command("pkill", "-9", "-f", binPath).Run()
 
-	// Give it a moment to release file handles
 	time.Sleep(500 * time.Millisecond)
 }
 
@@ -810,6 +870,56 @@ func updateZedConfig(displayName, path, binPath, transport string, ssePort int)
 	return false
 }
 
+func downloadAndExtractLatest() (string, error) {
+	// Pass "v0.0.0" to force a network check to get the absolute latest if we're a naked installer
+	ctx := context.Background()
+	info, err := updater.CheckForUpdates(ctx, "v0.0.0", true)
+	if err != nil {
+		return "", fmt.Errorf("failed to check for updates: %w", err)
+	}
+	if info == nil || info.AssetURL == "" {
+		return "", fmt.Errorf("no update asset found")
+	}
+
+	tempDir, err := os.MkdirTemp("", "ragcode-install-*")
+	if err != nil {
+		return "", err
+	}
+	cleanup := true
+	defer func() {
+		if cleanup {
+			os.RemoveAll(tempDir)
+		}
+	}()
+
+	archivePath := filepath.Join(tempDir, "release-archive")
+	log("Downloading " + info.AssetURL)
+
+	// Use DownloadAndVerify for checksum-verified downloads (supply-chain security)
+	if err := info.DownloadAndVerify(ctx, archivePath); err != nil {
+		return "", fmt.Errorf("failed to download and verify release: %w", err)
+	}
+
+	log("Extracting archive...")
+	f, err := os.Open(archivePath)
+	if err != nil {
+		return "", err
+	}
+	defer f.Close()
+
+	extractDir := filepath.Join(tempDir, "extracted")
+	if err := os.MkdirAll(extractDir, 0755); err != nil {
+		return "", err
+	}
+
+	if err := extract.Archive(ctx, f, extractDir, nil); err != nil {
+		return "", err
+	}
+
+	cleanup = false // success — caller is responsible for cleanup
+	return extractDir, nil
+}
+
 // buildMCPServerEntry builds the stdio (binary) MCP server entry.
 func buildMCPServerEntry(ideKey, binPath string) map[string]interface{} {
 	entry := map[string]interface{}{

cmd/rag-code-mcp/main.go

@@ -17,7 +17,7 @@ import (
 )
 
 var (
-	Version = "2.1.56"
+	Version = "2.1.58"
 	Commit  = "none"
 	Date    = "24.10.2025"
 )