Fix run.go

Signed-off-by: xplshn <xplshn@murena.io>

Author: xplshn

config.go

@@ -31,11 +31,11 @@ type Hooks struct {
 }
 
 type HookCommands struct {
-	IntegrationCommands   []string `yaml:"integration_commands"`
-	DeintegrationCommands []string `yaml:"deintegration_commands"`
-	IntegrationErrorMsg   string   `yaml:"integration_error_msg"`
-	DeintegrationErrorMsg string   `yaml:"deintegration_error_msg"`
-	UseRunFromCache       bool     `yaml:"use_run_from_cache"`
+	IntegrationCommands   []string `yaml:"integrationCommands"`
+	DeintegrationCommands []string `yaml:"deintegrationCommands"`
+	IntegrationErrorMsg   string   `yaml:"integrationErrorMsg"`
+	DeintegrationErrorMsg string   `yaml:"deintegrationErrorMsg"`
+	UseRunFromCache       bool     `yaml:"RunFromCache"`
 	NoOp                  bool     `yaml:"nop"`
 }
 
@@ -59,7 +59,7 @@ func executeHookCommand(config *Config, cmdTemplate, bEntryPath, extension strin
 	args := commandParts[1:]
 
 	if hookCommands.UseRunFromCache {
-		return runFromCache(config, stringToBinaryEntry(command), args, true, verbosityLevel, uRepoIndex)
+		return runFromCache(config, stringToBinaryEntry(command), args, true, verbosityLevel)
 	}
 
 	cmdExec := exec.Command(command, args...)

findURL.go

@@ -108,7 +108,7 @@ func findURL(config *Config, bEntries []binaryEntry, verbosityLevel Verbosity, u
 		for _, e := range allErrors {
 			errorMessages = append(errorMessages, e.Error())
 		}
-		return nil, nil, fmt.Errorf("error: no valid download URLs found for any of the requested binaries.\n%s\n", strings.Join(errorMessages, "\n"))
+		return nil, nil, fmt.Errorf(ternary(len(bEntries) != 1, "error: no valid download URLs found for any of the requested binaries.\n%s\n", "%s\n"), strings.Join(errorMessages, "\n"))
 	}
 
 	return foundURLs, foundB3sum, nil

run.go

@@ -1,27 +1,28 @@
 package main
 
 import (
+	"context"
 	"fmt"
 	"os"
 	"os/exec"
 	"path/filepath"
 	"sort"
 	"time"
-	"context"
 
 	"github.com/urfave/cli/v3"
 )
 
 func runCommand() *cli.Command {
 	return &cli.Command{
-		Name:  "run",
-		Usage: "Run a specified binary from cache",
+		Name:            "run",
+		Usage:           "Run a specified binary from cache",
 		Flags: []cli.Flag{
 			&cli.BoolFlag{
 				Name:  "transparent",
 				Usage: "Run the binary from PATH if found",
 			},
 		},
+		SkipFlagParsing: true,
 		Action: func(ctx context.Context, c *cli.Command) error {
 			if c.NArg() == 0 {
 				return fmt.Errorf("no binary name provided for run command")
@@ -31,93 +32,60 @@ func runCommand() *cli.Command {
 			if err != nil {
 				return err
 			}
-			uRepoIndex := fetchRepoIndex(config)
-
-			// The first argument is the binary name
-			binaryName := c.Args().First()
-			bEntry := stringToBinaryEntry(binaryName)
-
-			// The rest of the arguments are passed to the binary
-			args := c.Args().Tail()
-
-			return runFromCache(config, bEntry, args, c.Bool("transparent"), getVerbosityLevel(c), uRepoIndex)
+			
+			bEntry := stringToBinaryEntry(c.Args().First())
+			return runFromCache(config, bEntry, c.Args().Tail(), c.Bool("transparent"), getVerbosityLevel(c))
 		},
 	}
 }
 
-func returnCachedFile(config *Config, binaryName string) (cachedBinary string, trackedBEntry binaryEntry, err error) {
-	cachedBinary = filepath.Join(config.CacheDir, filepath.Base(binaryName))
-
-	trackedBEntry, err = readEmbeddedBEntry(cachedBinary)
-	if err != nil {
-		return "", trackedBEntry, err
-	}
-
-	if !fileExists(cachedBinary) {
-		return "", trackedBEntry, fmt.Errorf("cached binary not found")
-	}
-
-	return cachedBinary, trackedBEntry, nil
-}
-
-func runFromCache(config *Config, bEntry binaryEntry, args []string, transparentMode bool, verbosityLevel Verbosity, uRepoIndex []binaryEntry) error {
-	binaryPath, err := exec.LookPath(bEntry.Name)
-	if err == nil && transparentMode {
-		if verbosityLevel >= normalVerbosity {
-			fmt.Printf("Running '%s' from PATH...\n", bEntry.Name)
+func runFromCache(config *Config, bEntry binaryEntry, args []string, transparentMode bool, verbosityLevel Verbosity) error {
+	// Try running from PATH if transparent mode is enabled
+	if transparentMode {
+		binaryPath, err := exec.LookPath(bEntry.Name)
+		if err == nil {
+			if verbosityLevel >= normalVerbosity {
+				fmt.Printf("Running '%s' from PATH...\n", bEntry.Name)
+			}
+			return runBinary(binaryPath, args, verbosityLevel)
 		}
-		return runBinary(binaryPath, args, verbosityLevel)
 	}
 
+	// Check if the binary exists in cache and matches the requested version
 	baseName := filepath.Base(bEntry.Name)
 	cachedFile := filepath.Join(config.CacheDir, baseName)
+	
 	if fileExists(cachedFile) && isExecutable(cachedFile) {
 		trackedBEntry, err := readEmbeddedBEntry(cachedFile)
-		if err != nil || trackedBEntry.PkgId != bEntry.PkgId {
+		if err == nil && (trackedBEntry.PkgId == bEntry.PkgId || bEntry.PkgId == "") {
 			if verbosityLevel >= normalVerbosity {
-				if trackedBEntry.Name != "" {
-					fmt.Printf("Cached binary '%s' does not match requested binary '%s'. Fetching a new one...\n", parseBinaryEntry(trackedBEntry, false), parseBinaryEntry(bEntry, false))
-				}
+				fmt.Printf("Running '%s' from cache...\n", bEntry.Name)
 			}
-
-			config.UseIntegrationHooks = false
-			config.InstallDir = config.CacheDir
-			if err := installBinaries(context.Background(), config, []binaryEntry{bEntry}, silentVerbosityWithErrors, uRepoIndex); err != nil {
-				if verbosityLevel >= silentVerbosityWithErrors {
-					fmt.Fprintf(os.Stderr, "Error: could not fetch and cache the binary: %v\n", err)
-				}
-				return err
-			}
-
-			if err := runBinary(filepath.Join(config.CacheDir, baseName), args, verbosityLevel); err != nil {
+			if err := runBinary(cachedFile, args, verbosityLevel); err != nil {
 				return err
 			}
 			return cleanCache(config.CacheDir, verbosityLevel)
 		}
-
+		
 		if verbosityLevel >= normalVerbosity {
-			fmt.Printf("Running '%s' from cache...\n", bEntry.Name)
+			fmt.Printf("Cached binary '%s' does not match requested binary '%s'. Fetching a new one...\n", 
+				parseBinaryEntry(trackedBEntry, false), parseBinaryEntry(bEntry, false))
 		}
-		if err := runBinary(filepath.Join(config.CacheDir, baseName), args, verbosityLevel); err != nil {
-			return err
-		}
-		return cleanCache(config.CacheDir, verbosityLevel)
-	}
-
-	if verbosityLevel >= normalVerbosity {
+	} else if verbosityLevel >= normalVerbosity {
 		fmt.Printf("Couldn't find '%s' in the cache. Fetching a new one...\n", bEntry.Name)
 	}
 
-	config.UseIntegrationHooks = false
-	config.InstallDir = config.CacheDir
-	if err := installBinaries(context.Background(), config, []binaryEntry{bEntry}, silentVerbosityWithErrors, uRepoIndex); err != nil {
-		if verbosityLevel >= silentVerbosityWithErrors {
-			fmt.Fprintf(os.Stderr, "error: could not cache the binary: %v\n", err)
-		}
+	// Fetch and install the binary
+	cacheConfig := *config
+	cacheConfig.UseIntegrationHooks = false
+	cacheConfig.InstallDir = config.CacheDir
+	
+	uRepoIndex := fetchRepoIndex(&cacheConfig)
+	if err := installBinaries(context.Background(), &cacheConfig, []binaryEntry{bEntry}, silentVerbosityWithErrors, uRepoIndex); err != nil {
 		return err
 	}
 
-	if err := runBinary(filepath.Join(config.CacheDir, baseName), args, verbosityLevel); err != nil {
+	if err := runBinary(cachedFile, args, verbosityLevel); err != nil {
 		return err
 	}
 	return cleanCache(config.CacheDir, verbosityLevel)
@@ -167,9 +135,7 @@ func cleanCache(cacheDir string, verbosityLevel Verbosity) error {
 			continue
 		}
 
-		atime := fileInfo.ModTime()
-
-		filesWithAtime = append(filesWithAtime, fileWithAtime{info: entry, atime: atime})
+		filesWithAtime = append(filesWithAtime, fileWithAtime{info: entry, atime: fileInfo.ModTime()})
 	}
 
 	sort.Slice(filesWithAtime, func(i, j int) bool {
@@ -182,10 +148,8 @@ func cleanCache(cacheDir string, verbosityLevel Verbosity) error {
 			if verbosityLevel >= silentVerbosityWithErrors {
 				fmt.Fprintf(os.Stderr, "error removing old cached binary: %v\n", err)
 			}
-		} else {
-			if verbosityLevel >= extraVerbose {
-				fmt.Printf("Removed old cached binary: %s\n", filePath)
-			}
+		} else if verbosityLevel >= extraVerbose {
+			fmt.Printf("Removed old cached binary: %s\n", filePath)
 		}
 	}
 

utility.go

@@ -208,13 +208,13 @@ func truncateSprintf(indicator, format string, a ...interface{}) string {
 		return text
 	}
 
-	width := getTerminalWidth() - len(indicator)
+	width := uint(getTerminalWidth() - len(indicator))
 	if width <= 0 {
 		return text
 	}
 
 	var out bytes.Buffer
-	var visibleCount int
+	var visibleCount uint
 	var inEscape bool
 	var escBuf bytes.Buffer
 
@@ -418,16 +418,6 @@ func isSymlink(filePath string) bool {
 	return err == nil && fileInfo.Mode()&os.ModeSymlink != 0
 }
 
-func sanitizeString(input string) string {
-	var sanitized strings.Builder
-	for _, ch := range input {
-		if ch >= 32 && ch <= 126 {
-			sanitized.WriteRune(ch)
-		}
-	}
-	return sanitized.String()
-}
-
 func ternary[T any](cond bool, vtrue, vfalse T) T {
 	if cond {
 		return vtrue