refactor(runtime): Build runtime after cmdargs parsing (#1965)

* extract runtime building from cfg

* respect AURRPCURL

* use -Syu if there are no targets, allows to pass extra options

* one more step towards removing runtime from cfg

clean.go

@@ -41,7 +41,7 @@ func cleanRemove(ctx context.Context, config *settings.Configuration, cmdArgs *p
 
 	return config.Runtime.CmdBuilder.Show(
 		config.Runtime.CmdBuilder.BuildPacmanCmd(ctx,
-			arguments, config.Runtime.Mode, settings.NoConfirm))
+			arguments, config.Mode, settings.NoConfirm))
 }
 
 func syncClean(ctx context.Context, cfg *settings.Configuration, cmdArgs *parser.Arguments, dbExecutor db.Executor) error {
@@ -58,14 +58,14 @@ func syncClean(ctx context.Context, cfg *settings.Configuration, cmdArgs *parser
 		}
 	}
 
-	if cfg.Runtime.Mode.AtLeastRepo() {
+	if cfg.Mode.AtLeastRepo() {
 		if err := cfg.Runtime.CmdBuilder.Show(cfg.Runtime.CmdBuilder.BuildPacmanCmd(ctx,
-			cmdArgs, cfg.Runtime.Mode, settings.NoConfirm)); err != nil {
+			cmdArgs, cfg.Mode, settings.NoConfirm)); err != nil {
 			return err
 		}
 	}
 
-	if !cfg.Runtime.Mode.AtLeastAUR() {
+	if !cfg.Mode.AtLeastAUR() {
 		return nil
 	}
 

cmd.go

@@ -154,7 +154,7 @@ func handleCmd(ctx context.Context, cfg *settings.Configuration, cmdArgs *parser
 		return handleHelp(ctx, cfg, cmdArgs)
 	}
 
-	if cfg.SudoLoop && cmdArgs.NeedRoot(cfg.Runtime.Mode) {
+	if cfg.SudoLoop && cmdArgs.NeedRoot(cfg.Mode) {
 		cfg.Runtime.CmdBuilder.SudoLoop()
 	}
 
@@ -165,10 +165,10 @@ func handleCmd(ctx context.Context, cfg *settings.Configuration, cmdArgs *parser
 		return nil
 	case "D", "database":
 		return cfg.Runtime.CmdBuilder.Show(cfg.Runtime.CmdBuilder.BuildPacmanCmd(ctx,
-			cmdArgs, cfg.Runtime.Mode, settings.NoConfirm))
+			cmdArgs, cfg.Mode, settings.NoConfirm))
 	case "F", "files":
 		return cfg.Runtime.CmdBuilder.Show(cfg.Runtime.CmdBuilder.BuildPacmanCmd(ctx,
-			cmdArgs, cfg.Runtime.Mode, settings.NoConfirm))
+			cmdArgs, cfg.Mode, settings.NoConfirm))
 	case "Q", "query":
 		return handleQuery(ctx, cfg, cmdArgs, dbExecutor)
 	case "R", "remove":
@@ -177,7 +177,7 @@ func handleCmd(ctx context.Context, cfg *settings.Configuration, cmdArgs *parser
 		return handleSync(ctx, cfg, cmdArgs, dbExecutor)
 	case "T", "deptest":
 		return cfg.Runtime.CmdBuilder.Show(cfg.Runtime.CmdBuilder.BuildPacmanCmd(ctx,
-			cmdArgs, cfg.Runtime.Mode, settings.NoConfirm))
+			cmdArgs, cfg.Mode, settings.NoConfirm))
 	case "U", "upgrade":
 		return handleUpgrade(ctx, cfg, cmdArgs)
 	case "B", "build":
@@ -231,7 +231,7 @@ func handleQuery(ctx context.Context, cfg *settings.Configuration, cmdArgs *pars
 	}
 
 	if err := cfg.Runtime.CmdBuilder.Show(cfg.Runtime.CmdBuilder.BuildPacmanCmd(ctx,
-		cmdArgs, cfg.Runtime.Mode, settings.NoConfirm)); err != nil {
+		cmdArgs, cfg.Mode, settings.NoConfirm)); err != nil {
 		if str := err.Error(); strings.Contains(str, "exit status") {
 			// yay -Qdt should not output anything in case of error
 			return fmt.Errorf("")
@@ -251,7 +251,7 @@ func handleHelp(ctx context.Context, cfg *settings.Configuration, cmdArgs *parse
 	}
 
 	return cfg.Runtime.CmdBuilder.Show(cfg.Runtime.CmdBuilder.BuildPacmanCmd(ctx,
-		cmdArgs, cfg.Runtime.Mode, settings.NoConfirm))
+		cmdArgs, cfg.Mode, settings.NoConfirm))
 }
 
 func handleVersion() {
@@ -276,7 +276,7 @@ func handlePrint(ctx context.Context, cfg *settings.Configuration, cmdArgs *pars
 		return news.PrintNewsFeed(ctx, cfg.Runtime.HTTPClient, dbExecutor.LastBuildTime(), cfg.BottomUp, double, quiet)
 	case cmdArgs.ExistsArg("c", "complete"):
 		return completion.Show(ctx, cfg.Runtime.HTTPClient, dbExecutor,
-			cfg.AURURL, cfg.Runtime.CompletionPath, cfg.CompletionInterval, cmdArgs.ExistsDouble("c", "complete"))
+			cfg.AURURL, cfg.CompletionPath, cfg.CompletionInterval, cmdArgs.ExistsDouble("c", "complete"))
 	case cmdArgs.ExistsArg("s", "stats"):
 		return localStatistics(ctx, cfg, dbExecutor)
 	}
@@ -317,7 +317,7 @@ func handleWeb(ctx context.Context, cfg *settings.Configuration, cmdArgs *parser
 func handleGetpkgbuild(ctx context.Context, cfg *settings.Configuration, cmdArgs *parser.Arguments, dbExecutor download.DBSearcher) error {
 	if cmdArgs.ExistsArg("p", "print") {
 		return printPkgbuilds(dbExecutor, cfg.Runtime.AURCache,
-			cfg.Runtime.HTTPClient, cmdArgs.Targets, cfg.Runtime.Mode, cfg.AURURL)
+			cfg.Runtime.HTTPClient, cmdArgs.Targets, cfg.Mode, cfg.AURURL)
 	}
 
 	return getPkgbuilds(ctx, dbExecutor, cfg.Runtime.AURCache, cfg,
@@ -328,7 +328,7 @@ func handleUpgrade(ctx context.Context,
 	config *settings.Configuration, cmdArgs *parser.Arguments,
 ) error {
 	return config.Runtime.CmdBuilder.Show(config.Runtime.CmdBuilder.BuildPacmanCmd(ctx,
-		cmdArgs, config.Runtime.Mode, settings.NoConfirm))
+		cmdArgs, config.Mode, settings.NoConfirm))
 }
 
 // -B* options
@@ -350,14 +350,14 @@ func handleSync(ctx context.Context, cfg *settings.Configuration, cmdArgs *parse
 		return syncSearch(ctx, targets, dbExecutor, cfg.Runtime.QueryBuilder, !cmdArgs.ExistsArg("q", "quiet"))
 	case cmdArgs.ExistsArg("p", "print", "print-format"):
 		return cfg.Runtime.CmdBuilder.Show(cfg.Runtime.CmdBuilder.BuildPacmanCmd(ctx,
-			cmdArgs, cfg.Runtime.Mode, settings.NoConfirm))
+			cmdArgs, cfg.Mode, settings.NoConfirm))
 	case cmdArgs.ExistsArg("c", "clean"):
 		return syncClean(ctx, cfg, cmdArgs, dbExecutor)
 	case cmdArgs.ExistsArg("l", "list"):
 		return syncList(ctx, cfg, cfg.Runtime.HTTPClient, cmdArgs, dbExecutor)
 	case cmdArgs.ExistsArg("g", "groups"):
 		return cfg.Runtime.CmdBuilder.Show(cfg.Runtime.CmdBuilder.BuildPacmanCmd(ctx,
-			cmdArgs, cfg.Runtime.Mode, settings.NoConfirm))
+			cmdArgs, cfg.Mode, settings.NoConfirm))
 	case cmdArgs.ExistsArg("i", "info"):
 		return syncInfo(ctx, cfg, cmdArgs, targets, dbExecutor)
 	case cmdArgs.ExistsArg("u", "sysupgrade") || len(cmdArgs.Targets) > 0:
@@ -368,7 +368,7 @@ func handleSync(ctx context.Context, cfg *settings.Configuration, cmdArgs *parse
 		return install(ctx, cfg, cmdArgs, dbExecutor, false)
 	case cmdArgs.ExistsArg("y", "refresh"):
 		return cfg.Runtime.CmdBuilder.Show(cfg.Runtime.CmdBuilder.BuildPacmanCmd(ctx,
-			cmdArgs, cfg.Runtime.Mode, settings.NoConfirm))
+			cmdArgs, cfg.Mode, settings.NoConfirm))
 	}
 
 	return nil
@@ -376,7 +376,7 @@ func handleSync(ctx context.Context, cfg *settings.Configuration, cmdArgs *parse
 
 func handleRemove(ctx context.Context, cfg *settings.Configuration, cmdArgs *parser.Arguments, localCache vcs.Store) error {
 	err := cfg.Runtime.CmdBuilder.Show(cfg.Runtime.CmdBuilder.BuildPacmanCmd(ctx,
-		cmdArgs, cfg.Runtime.Mode, settings.NoConfirm))
+		cmdArgs, cfg.Mode, settings.NoConfirm))
 	if err == nil {
 		localCache.RemovePackages(cmdArgs.Targets)
 	}
@@ -435,13 +435,13 @@ func syncList(ctx context.Context, cfg *settings.Configuration,
 	aur := false
 
 	for i := len(cmdArgs.Targets) - 1; i >= 0; i-- {
-		if cmdArgs.Targets[i] == "aur" && cfg.Runtime.Mode.AtLeastAUR() {
+		if cmdArgs.Targets[i] == "aur" && cfg.Mode.AtLeastAUR() {
 			cmdArgs.Targets = append(cmdArgs.Targets[:i], cmdArgs.Targets[i+1:]...)
 			aur = true
 		}
 	}
 
-	if cfg.Runtime.Mode.AtLeastAUR() && (len(cmdArgs.Targets) == 0 || aur) {
+	if cfg.Mode.AtLeastAUR() && (len(cmdArgs.Targets) == 0 || aur) {
 		req, err := http.NewRequestWithContext(ctx, http.MethodGet, cfg.AURURL+"/packages.gz", http.NoBody)
 		if err != nil {
 			return err
@@ -473,9 +473,9 @@ func syncList(ctx context.Context, cfg *settings.Configuration,
 		}
 	}
 
-	if cfg.Runtime.Mode.AtLeastRepo() && (len(cmdArgs.Targets) != 0 || !aur) {
+	if cfg.Mode.AtLeastRepo() && (len(cmdArgs.Targets) != 0 || !aur) {
 		return cfg.Runtime.CmdBuilder.Show(cfg.Runtime.CmdBuilder.BuildPacmanCmd(ctx,
-			cmdArgs, cfg.Runtime.Mode, settings.NoConfirm))
+			cmdArgs, cfg.Mode, settings.NoConfirm))
 	}
 
 	return nil

get.go

@@ -59,7 +59,7 @@ func getPkgbuilds(ctx context.Context, dbExecutor download.DBSearcher, aurClient
 	}
 
 	cloned, errD := download.PKGBUILDRepos(ctx, dbExecutor, aurClient,
-		config.Runtime.CmdBuilder, targets, config.Runtime.Mode, config.AURURL, wd, force)
+		config.Runtime.CmdBuilder, targets, config.Mode, config.AURURL, wd, force)
 	if errD != nil {
 		text.Errorln(errD)
 	}

install.go

@@ -103,7 +103,7 @@ func install(ctx context.Context, cfg *settings.Configuration,
 		cfg.Runtime.CmdBuilder.AddMakepkgFlag("-d")
 	}
 
-	if cfg.Runtime.Mode.AtLeastRepo() {
+	if cfg.Mode.AtLeastRepo() {
 		if cfg.CombinedUpgrade {
 			if refreshArg {
 				if errR := earlyRefresh(ctx, cfg, cfg.Runtime.CmdBuilder, cmdArgs); errR != nil {
@@ -139,7 +139,7 @@ func install(ctx context.Context, cfg *settings.Configuration,
 	arguments.Op = "S"
 	arguments.ClearTargets()
 
-	if cfg.Runtime.Mode == parser.ModeAUR {
+	if cfg.Mode == parser.ModeAUR {
 		arguments.DelArg("u", "sysupgrade")
 	}
 
@@ -156,7 +156,7 @@ func install(ctx context.Context, cfg *settings.Configuration,
 	targets := stringset.FromSlice(cmdArgs.Targets)
 
 	dp, err := dep.GetPool(ctx, requestTargets,
-		warnings, dbExecutor, cfg.Runtime.AURClient, cfg.Runtime.Mode,
+		warnings, dbExecutor, cfg.Runtime.AURClient, cfg.Mode,
 		ignoreProviders, settings.NoConfirm, cfg.Provides, cfg.ReBuild, cfg.RequestSplitN, noDeps, noCheck, assumeInstalled)
 	if err != nil {
 		return err
@@ -183,7 +183,7 @@ func install(ctx context.Context, cfg *settings.Configuration,
 		}
 
 		return cfg.Runtime.CmdBuilder.Show(cfg.Runtime.CmdBuilder.BuildPacmanCmd(ctx,
-			cmdArgs, cfg.Runtime.Mode, settings.NoConfirm))
+			cmdArgs, cfg.Mode, settings.NoConfirm))
 	}
 
 	conflicts, errCC := dp.CheckConflicts(cfg.UseAsk, settings.NoConfirm, noDeps)
@@ -202,7 +202,7 @@ func install(ctx context.Context, cfg *settings.Configuration,
 	}
 
 	if len(do.Aur) == 0 && len(arguments.Targets) == 0 &&
-		(!cmdArgs.ExistsArg("u", "sysupgrade") || cfg.Runtime.Mode == parser.ModeAUR) {
+		(!cmdArgs.ExistsArg("u", "sysupgrade") || cfg.Mode == parser.ModeAUR) {
 		fmt.Println(gotext.Get(" there is nothing to do"))
 		return nil
 	}
@@ -317,7 +317,7 @@ func install(ctx context.Context, cfg *settings.Configuration,
 
 	if len(arguments.Targets) > 0 || arguments.ExistsArg("u") {
 		if errShow := cfg.Runtime.CmdBuilder.Show(cfg.Runtime.CmdBuilder.BuildPacmanCmd(ctx,
-			arguments, cfg.Runtime.Mode, settings.NoConfirm)); errShow != nil {
+			arguments, cfg.Mode, settings.NoConfirm)); errShow != nil {
 			return errors.New(gotext.Get("error installing repo packages"))
 		}
 
@@ -338,18 +338,18 @@ func install(ctx context.Context, cfg *settings.Configuration,
 			}
 		}
 
-		if errDeps := asdeps(ctx, cfg.Runtime.CmdBuilder, cfg.Runtime.Mode, cmdArgs, deps); errDeps != nil {
+		if errDeps := asdeps(ctx, cfg.Runtime.CmdBuilder, cfg.Mode, cmdArgs, deps); errDeps != nil {
 			return errDeps
 		}
 
-		if errExp := asexp(ctx, cfg.Runtime.CmdBuilder, cfg.Runtime.Mode, cmdArgs, exp); errExp != nil {
+		if errExp := asexp(ctx, cfg.Runtime.CmdBuilder, cfg.Mode, cmdArgs, exp); errExp != nil {
 			return errExp
 		}
 	}
 
 	go func() {
 		_ = completion.Update(ctx, cfg.Runtime.HTTPClient, dbExecutor,
-			cfg.AURURL, cfg.Runtime.CompletionPath, cfg.CompletionInterval, false)
+			cfg.AURURL, cfg.CompletionPath, cfg.CompletionInterval, false)
 	}()
 
 	if errP := downloadPKGBUILDSourceFanout(ctx,
@@ -404,7 +404,7 @@ func removeMake(ctx context.Context, config *settings.Configuration,
 	oldValue := settings.NoConfirm
 	settings.NoConfirm = true
 	err = cmdBuilder.Show(cmdBuilder.BuildPacmanCmd(ctx,
-		removeArguments, config.Runtime.Mode, settings.NoConfirm))
+		removeArguments, config.Mode, settings.NoConfirm))
 	settings.NoConfirm = oldValue
 
 	return err
@@ -436,7 +436,7 @@ func earlyPacmanCall(ctx context.Context, cfg *settings.Configuration,
 	cmdArgs.ClearTargets()
 	arguments.ClearTargets()
 
-	if cfg.Runtime.Mode == parser.ModeRepo {
+	if cfg.Mode == parser.ModeRepo {
 		arguments.Targets = targets
 	} else {
 		// separate aur and repo targets
@@ -451,7 +451,7 @@ func earlyPacmanCall(ctx context.Context, cfg *settings.Configuration,
 
 	if cmdArgs.ExistsArg("y", "refresh") || cmdArgs.ExistsArg("u", "sysupgrade") || len(arguments.Targets) > 0 {
 		if err := cfg.Runtime.CmdBuilder.Show(cfg.Runtime.CmdBuilder.BuildPacmanCmd(ctx,
-			arguments, cfg.Runtime.Mode, settings.NoConfirm)); err != nil {
+			arguments, cfg.Mode, settings.NoConfirm)); err != nil {
 			return errors.New(gotext.Get("error installing repo packages"))
 		}
 	}
@@ -468,7 +468,7 @@ func earlyRefresh(ctx context.Context, cfg *settings.Configuration, cmdBuilder e
 	arguments.ClearTargets()
 
 	return cmdBuilder.Show(cmdBuilder.BuildPacmanCmd(ctx,
-		arguments, cfg.Runtime.Mode, settings.NoConfirm))
+		arguments, cfg.Mode, settings.NoConfirm))
 }
 
 func confirmIncompatibleInstall(srcinfos map[string]*gosrc.Srcinfo, dbExecutor db.Executor) error {
@@ -647,8 +647,8 @@ func buildInstallPkgbuilds(
 		if !satisfied || !cfg.BatchInstall {
 			text.Debugln("non batch installing archives:", pkgArchives)
 			errArchive := installPkgArchive(ctx, cfg.Runtime.CmdBuilder,
-				cfg.Runtime.Mode, cfg.Runtime.VCSStore, cmdArgs, pkgArchives)
-			errReason := setInstallReason(ctx, cfg.Runtime.CmdBuilder, cfg.Runtime.Mode, cmdArgs, deps, exp)
+				cfg.Mode, cfg.Runtime.VCSStore, cmdArgs, pkgArchives)
+			errReason := setInstallReason(ctx, cfg.Runtime.CmdBuilder, cfg.Mode, cmdArgs, deps, exp)
 
 			deps = make([]string, 0)
 			exp = make([]string, 0)
@@ -800,12 +800,12 @@ func buildInstallPkgbuilds(
 	}
 
 	text.Debugln("installing archives:", pkgArchives)
-	errArchive := installPkgArchive(ctx, cfg.Runtime.CmdBuilder, cfg.Runtime.Mode, cfg.Runtime.VCSStore, cmdArgs, pkgArchives)
+	errArchive := installPkgArchive(ctx, cfg.Runtime.CmdBuilder, cfg.Mode, cfg.Runtime.VCSStore, cmdArgs, pkgArchives)
 	if errArchive != nil {
 		go cfg.Runtime.VCSStore.RemovePackages([]string{do.Aur[len(do.Aur)-1].String()})
 	}
 
-	errReason := setInstallReason(ctx, cfg.Runtime.CmdBuilder, cfg.Runtime.Mode, cmdArgs, deps, exp)
+	errReason := setInstallReason(ctx, cfg.Runtime.CmdBuilder, cfg.Mode, cmdArgs, deps, exp)
 	if errReason != nil {
 		go cfg.Runtime.VCSStore.RemovePackages([]string{do.Aur[len(do.Aur)-1].String()})
 	}

main.go

@@ -60,7 +60,9 @@ func main() {
 		text.Warnln(gotext.Get("Avoid running yay as root/sudo."))
 	}
 
-	cfg, err := settings.NewConfig(yayVersion)
+	configPath := settings.GetConfigPath()
+	// Parse config
+	cfg, err := settings.NewConfig(configPath, yayVersion)
 	if err != nil {
 		if str := err.Error(); str != "" {
 			text.Errorln(str)
@@ -76,12 +78,13 @@ func main() {
 	}
 
 	if errS := cfg.RunMigrations(
-		settings.DefaultMigrations(), cfg.Runtime.ConfigPath); errS != nil {
+		settings.DefaultMigrations(), configPath, yayVersion); errS != nil {
 		text.Errorln(errS)
 	}
 
 	cmdArgs := parser.MakeArguments()
 
+	// Parse command line
 	if err = cfg.ParseCommandLine(cmdArgs); err != nil {
 		if str := err.Error(); str != "" {
 			text.Errorln(str)
@@ -92,23 +95,37 @@ func main() {
 		return
 	}
 
-	if cfg.Runtime.SaveConfig {
-		if errS := cfg.Save(cfg.Runtime.ConfigPath); errS != nil {
+	if cfg.SaveConfig {
+		if errS := cfg.Save(configPath, yayVersion); errS != nil {
 			text.Errorln(errS)
 		}
 	}
 
+	// Build runtime
+	runtime, err := settings.BuildRuntime(cfg, cmdArgs, yayVersion)
+	if err != nil {
+		if str := err.Error(); str != "" {
+			text.Errorln(str)
+		}
+
+		ret = 1
+
+		return
+	}
+
+	cfg.Runtime = runtime
+
 	if cfg.SeparateSources {
 		cfg.Runtime.QueryBuilder = query.NewSourceQueryBuilder(
 			cfg.Runtime.AURClient, cfg.Runtime.AURCache,
 			cfg.Runtime.Logger.Child("querybuilder"), cfg.SortBy,
-			cfg.Runtime.Mode, cfg.SearchBy, cfg.BottomUp,
+			cfg.Mode, cfg.SearchBy, cfg.BottomUp,
 			cfg.SingleLineResults, cfg.NewInstallEngine)
 	} else {
 		cfg.Runtime.QueryBuilder = query.NewMixedSourceQueryBuilder(
 			cfg.Runtime.AURClient, cfg.Runtime.AURCache,
 			cfg.Runtime.Logger.Child("mixed.querybuilder"), cfg.SortBy,
-			cfg.Runtime.Mode, cfg.SearchBy,
+			cfg.Mode, cfg.SearchBy,
 			cfg.BottomUp, cfg.SingleLineResults, cfg.NewInstallEngine)
 	}
 

pkg/cmd/graph/main.go

@@ -18,7 +18,7 @@ import (
 )
 
 func handleCmd() error {
-	config, err := settings.NewConfig("")
+	config, err := settings.NewConfig(settings.GetConfigPath(), "")
 	if err != nil {
 		return err
 	}

pkg/settings/args.go

@@ -29,19 +29,19 @@ func (c *Configuration) extractYayOptions(a *parser.Arguments) {
 	}
 
 	c.AURURL = strings.TrimRight(c.AURURL, "/")
-	c.Runtime.AURClient.BaseURL = c.AURURL + "/rpc?"
 
 	// if AurRPCURL is set, use that for /rpc calls
-	if c.AURRPCURL != "" {
-		if !strings.HasSuffix(c.AURRPCURL, "?") {
-			if strings.HasSuffix(c.AURRPCURL, "/rpc") {
-				c.AURRPCURL += "?"
-			} else {
-				c.AURRPCURL = strings.TrimRight(c.AURRPCURL, "/") + "/rpc?"
-			}
-		}
+	if c.AURRPCURL == "" {
+		c.AURRPCURL = c.AURURL + "/rpc?"
+		return
+	}
 
-		c.Runtime.AURClient.BaseURL = c.AURRPCURL
+	if !strings.HasSuffix(c.AURRPCURL, "?") {
+		if strings.HasSuffix(c.AURRPCURL, "/rpc") {
+			c.AURRPCURL += "?"
+		} else {
+			c.AURRPCURL = strings.TrimRight(c.AURRPCURL, "/") + "/rpc?"
+		}
 	}
 }
 
@@ -52,15 +52,15 @@ func (c *Configuration) handleOption(option, value string) bool {
 	case "aurrpcurl":
 		c.AURRPCURL = value
 	case "save":
-		c.Runtime.SaveConfig = true
+		c.SaveConfig = true
 	case "afterclean", "cleanafter":
 		c.CleanAfter = true
 	case "noafterclean", "nocleanafter":
 		c.CleanAfter = false
 	case "debug":
 		c.Debug = true
-		c.Runtime.Logger.Debug = true
 		text.GlobalLogger.Debug = true
+		return false
 	case "devel":
 		c.Devel = true
 	case "nodevel":
@@ -194,9 +194,9 @@ func (c *Configuration) handleOption(option, value string) bool {
 	case "nocombinedupgrade":
 		c.CombinedUpgrade = false
 	case "a", "aur":
-		c.Runtime.Mode = parser.ModeAUR
+		c.Mode = parser.ModeAUR
 	case "repo":
-		c.Runtime.Mode = parser.ModeRepo
+		c.Mode = parser.ModeRepo
 	case "removemake":
 		c.RemoveMake = "yes"
 	case "noremovemake":

pkg/settings/config.go

@@ -2,10 +2,8 @@ package settings
 
 import (
 	"bytes"
-	"context"
 	"encoding/json"
 	"fmt"
-	"net/http"
 	"os"
 	"os/exec"
 	"path/filepath"
@@ -14,11 +12,7 @@ import (
 	"github.com/Jguer/yay/v12/pkg/settings/exe"
 	"github.com/Jguer/yay/v12/pkg/settings/parser"
 	"github.com/Jguer/yay/v12/pkg/text"
-	"github.com/Jguer/yay/v12/pkg/vcs"
 
-	"github.com/Jguer/aur/metadata"
-	"github.com/Jguer/aur/rpc"
-	"github.com/Jguer/votar/pkg/vote"
 	"github.com/leonelquinteros/gotext"
 )
 
@@ -79,11 +73,17 @@ type Configuration struct {
 	NewInstallEngine       bool     `json:"newinstallengine"`
 	Debug                  bool     `json:"debug"`
 	UseRPC                 bool     `json:"rpc"`
+
+	CompletionPath string `json:"-"`
+	VCSFilePath    string `json:"-"`
+	// ConfigPath     string `json:"-"`
+	SaveConfig bool              `json:"-"`
+	Mode       parser.TargetMode `json:"-"`
 }
 
 // SaveConfig writes yay config to file.
-func (c *Configuration) Save(configPath string) error {
-	c.Version = c.Runtime.Version
+func (c *Configuration) Save(configPath, version string) error {
+	c.Version = version
 
 	marshalledinfo, err := json.MarshalIndent(c, "", "\t")
 	if err != nil {
@@ -242,10 +242,11 @@ func DefaultConfig(version string) *Configuration {
 		Runtime: &Runtime{
 			Logger: text.GlobalLogger,
 		},
+		Mode: parser.ModeAny,
 	}
 }
 
-func NewConfig(version string) (*Configuration, error) {
+func NewConfig(configPath, version string) (*Configuration, error) {
 	newConfig := DefaultConfig(version)
 
 	cacheHome, errCache := getCacheHome()
@@ -254,8 +255,8 @@ func NewConfig(version string) (*Configuration, error) {
 	}
 
 	newConfig.BuildDir = cacheHome
-
-	configPath := getConfigPath()
+	newConfig.CompletionPath = filepath.Join(cacheHome, completionFileName)
+	newConfig.VCSFilePath = filepath.Join(cacheHome, vcsFileName)
 	newConfig.load(configPath)
 
 	if aurdest := os.Getenv("AURDEST"); aurdest != "" {
@@ -275,71 +276,7 @@ func NewConfig(version string) (*Configuration, error) {
 		return nil, errPE
 	}
 
-	userAgent := fmt.Sprintf("Yay/%s", version)
-
-	voteClient, errVote := vote.NewClient(vote.WithUserAgent(userAgent))
-	if errVote != nil {
-		return nil, errVote
-	}
-
-	voteClient.SetCredentials(
-		os.Getenv("AUR_USERNAME"),
-		os.Getenv("AUR_PASSWORD"))
-
-	newConfig.Runtime = &Runtime{
-		ConfigPath:     configPath,
-		Version:        version,
-		Mode:           parser.ModeAny,
-		SaveConfig:     false,
-		CompletionPath: filepath.Join(cacheHome, completionFileName),
-		CmdBuilder:     newConfig.CmdBuilder(nil),
-		PacmanConf:     nil,
-		VCSStore:       nil,
-		HTTPClient:     &http.Client{},
-		AURClient:      nil,
-		VoteClient:     voteClient,
-		QueryBuilder:   nil,
-		Logger:         text.NewLogger(os.Stdout, os.Stdin, newConfig.Debug, "runtime"),
-	}
-
-	var errAURCache error
-
-	userAgentFn := func(ctx context.Context, req *http.Request) error {
-		req.Header.Set("User-Agent", userAgent)
-		return nil
-	}
-
-	newConfig.Runtime.AURCache, errAURCache = metadata.New(
-		metadata.WithHTTPClient(newConfig.Runtime.HTTPClient),
-		metadata.WithCacheFilePath(filepath.Join(newConfig.BuildDir, "aur.json")),
-		metadata.WithRequestEditorFn(userAgentFn),
-		metadata.WithBaseURL(newConfig.AURURL),
-		metadata.WithDebugLogger(newConfig.Runtime.Logger.Debugln),
-	)
-	if errAURCache != nil {
-		return nil, fmt.Errorf(gotext.Get("failed to retrieve aur Cache")+": %w", errAURCache)
-	}
-
-	var errAUR error
-	newConfig.Runtime.AURClient, errAUR = rpc.NewClient(
-		rpc.WithHTTPClient(newConfig.Runtime.HTTPClient),
-		rpc.WithRequestEditorFn(userAgentFn),
-		rpc.WithLogFn(newConfig.Runtime.Logger.Debugln))
-	if errAUR != nil {
-		return nil, errAUR
-	}
-
-	if newConfig.UseRPC {
-		newConfig.Runtime.AURCache = newConfig.Runtime.AURClient
-	}
-
-	newConfig.Runtime.VCSStore = vcs.NewInfoStore(
-		filepath.Join(cacheHome, vcsFileName), newConfig.Runtime.CmdBuilder,
-		newConfig.Runtime.Logger.Child("vcs"))
-
-	err := newConfig.Runtime.VCSStore.Load()
-
-	return newConfig, err
+	return newConfig, nil
 }
 
 func (c *Configuration) load(configPath string) {

pkg/settings/config_test.go

@@ -33,7 +33,7 @@ func TestNewConfig(t *testing.T) {
 	_, err = f.WriteString(string(configJSON))
 	assert.NoError(t, err)
 
-	newConfig, err := NewConfig("v1.0.0")
+	newConfig, err := NewConfig(GetConfigPath(), "v1.0.0")
 	assert.NoError(t, err)
 
 	assert.Equal(t, filepath.Join(cacheDir, "test-build-dir"), newConfig.BuildDir)
@@ -66,7 +66,7 @@ func TestNewConfigAURDEST(t *testing.T) {
 	_, err = f.WriteString(string(configJSON))
 	assert.NoError(t, err)
 
-	newConfig, err := NewConfig("v1.0.0")
+	newConfig, err := NewConfig(GetConfigPath(), "v1.0.0")
 	assert.NoError(t, err)
 
 	assert.Equal(t, filepath.Join(cacheDir, "test-build-dir"), newConfig.BuildDir)
@@ -99,7 +99,7 @@ func TestNewConfigAURDESTTildeExpansion(t *testing.T) {
 	_, err = f.WriteString(string(configJSON))
 	assert.NoError(t, err)
 
-	newConfig, err := NewConfig("v1.0.0")
+	newConfig, err := NewConfig(GetConfigPath(), "v1.0.0")
 	assert.NoError(t, err)
 
 	assert.Equal(t, filepath.Join(homeDir, "test-build-dir"), newConfig.BuildDir)

pkg/settings/dirs.go

@@ -12,7 +12,7 @@ const (
 	systemdCache       string = "/var/cache/yay" // systemd should handle cache creation
 )
 
-func getConfigPath() string {
+func GetConfigPath() string {
 	if configHome := os.Getenv("XDG_CONFIG_HOME"); configHome != "" {
 		configDir := filepath.Join(configHome, "yay")
 		if err := initDir(configDir); err == nil {

pkg/settings/migrations.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 
 	"github.com/Jguer/yay/v12/pkg/db"
+	"github.com/Jguer/yay/v12/pkg/text"
 
 	"github.com/leonelquinteros/gotext"
 )
@@ -44,13 +45,15 @@ func DefaultMigrations() []configMigration {
 	}
 }
 
-func (c *Configuration) RunMigrations(migrations []configMigration, configPath string) error {
+func (c *Configuration) RunMigrations(migrations []configMigration,
+	configPath, newVersion string,
+) error {
 	saveConfig := false
 
 	for _, migration := range migrations {
 		if db.VerCmp(migration.TargetVersion(), c.Version) > 0 {
 			if migration.Do(c) {
-				c.Runtime.Logger.Infoln("Config migration executed (",
+				text.Infoln("Config migration executed (",
 					migration.TargetVersion(), "):", migration)
 
 				saveConfig = true
@@ -59,7 +62,7 @@ func (c *Configuration) RunMigrations(migrations []configMigration, configPath s
 	}
 
 	if saveConfig {
-		return c.Save(configPath)
+		return c.Save(configPath, newVersion)
 	}
 
 	return nil

pkg/settings/migrations_test.go

@@ -26,13 +26,12 @@ func TestMigrationNothingToDo(t *testing.T) {
 		Version: "99.0.0",
 		// Create runtime with runtimeVersion
 		Runtime: &Runtime{
-			Version: "20.0.0",
-			Logger:  text.NewLogger(io.Discard, strings.NewReader(""), false, "test"),
+			Logger: text.NewLogger(io.Discard, strings.NewReader(""), false, "test"),
 		},
 	}
 
 	// Run Migration
-	err = config.RunMigrations(DefaultMigrations(), testFilePath)
+	err = config.RunMigrations(DefaultMigrations(), testFilePath, "20.0.0")
 	require.NoError(t, err)
 
 	// Check file contents if wantSave otherwise check file empty
@@ -68,6 +67,7 @@ func TestProvidesMigration(t *testing.T) {
 	type testCase struct {
 		desc       string
 		testConfig *Configuration
+		newVersion string
 		wantSave   bool
 	}
 
@@ -76,46 +76,46 @@ func TestProvidesMigration(t *testing.T) {
 			desc: "to upgrade",
 			testConfig: &Configuration{
 				Version:  "11.0.1",
-				Runtime:  &Runtime{Version: "11.2.1"},
 				Provides: true,
 			},
-			wantSave: true,
+			newVersion: "11.2.1",
+			wantSave:   true,
 		},
 		{
 			desc: "to upgrade-git",
 			testConfig: &Configuration{
 				Version:  "11.2.0.r7.g6f60892",
-				Runtime:  &Runtime{Version: "11.2.1"},
 				Provides: true,
 			},
-			wantSave: true,
+			newVersion: "11.2.1",
+			wantSave:   true,
 		},
 		{
 			desc: "to not upgrade",
 			testConfig: &Configuration{
 				Version:  "11.2.0",
-				Runtime:  &Runtime{Version: "11.2.1"},
 				Provides: false,
 			},
-			wantSave: false,
+			newVersion: "11.2.1",
+			wantSave:   false,
 		},
 		{
 			desc: "to not upgrade - target version",
 			testConfig: &Configuration{
 				Version:  "11.2.1",
-				Runtime:  &Runtime{Version: "11.2.1"},
 				Provides: true,
 			},
-			wantSave: false,
+			newVersion: "11.2.1",
+			wantSave:   false,
 		},
 		{
 			desc: "to not upgrade - new version",
 			testConfig: &Configuration{
 				Version:  "11.3.0",
-				Runtime:  &Runtime{Version: "11.3.0"},
 				Provides: true,
 			},
-			wantSave: false,
+			newVersion: "11.3.0",
+			wantSave:   false,
 		},
 	}
 
@@ -133,15 +133,14 @@ func TestProvidesMigration(t *testing.T) {
 				Provides: tc.testConfig.Provides,
 				// Create runtime with runtimeVersion
 				Runtime: &Runtime{
-					Logger:  text.NewLogger(io.Discard, strings.NewReader(""), false, "test"),
-					Version: tc.testConfig.Runtime.Version,
+					Logger: text.NewLogger(io.Discard, strings.NewReader(""), false, "test"),
 				},
 			}
 
 			// Run Migration
 			err = tcConfig.RunMigrations(
 				[]configMigration{&configProviderMigration{}},
-				testFilePath)
+				testFilePath, tc.newVersion)
 
 			require.NoError(t, err)
 
@@ -155,7 +154,7 @@ func TestProvidesMigration(t *testing.T) {
 			err = decoder.Decode(&newConfig)
 			if tc.wantSave {
 				require.NoError(t, err)
-				assert.Equal(t, tc.testConfig.Runtime.Version, newConfig.Version)
+				assert.Equal(t, tc.newVersion, newConfig.Version)
 				assert.Equal(t, false, newConfig.Provides)
 			} else {
 				require.Error(t, err)

pkg/settings/parser/parser.go

@@ -634,43 +634,43 @@ func (a *Arguments) Parse() error {
 	args := os.Args[1:]
 	usedNext := false
 
-	if len(args) < 1 {
-		if _, err := a.parseShortOption("-Syu", ""); err != nil {
-			return err
-		}
-	} else {
-		for k, arg := range args {
-			var nextArg string
+	for k, arg := range args {
+		var nextArg string
 
-			if usedNext {
-				usedNext = false
-				continue
-			}
+		if usedNext {
+			usedNext = false
+			continue
+		}
 
-			if k+1 < len(args) {
-				nextArg = args[k+1]
-			}
+		if k+1 < len(args) {
+			nextArg = args[k+1]
+		}
 
-			var err error
-			switch {
-			case a.ExistsArg("--"):
-				a.AddTarget(arg)
-			case strings.HasPrefix(arg, "--"):
-				usedNext, err = a.parseLongOption(arg, nextArg)
-			case strings.HasPrefix(arg, "-"):
-				usedNext, err = a.parseShortOption(arg, nextArg)
-			default:
-				a.AddTarget(arg)
-			}
+		var err error
+		switch {
+		case a.ExistsArg("--"):
+			a.AddTarget(arg)
+		case strings.HasPrefix(arg, "--"):
+			usedNext, err = a.parseLongOption(arg, nextArg)
+		case strings.HasPrefix(arg, "-"):
+			usedNext, err = a.parseShortOption(arg, nextArg)
+		default:
+			a.AddTarget(arg)
+		}
 
-			if err != nil {
-				return err
-			}
+		if err != nil {
+			return err
 		}
 	}
 
 	if a.Op == "" {
-		a.Op = "Y"
+		if len(a.Targets) > 0 {
+			a.Op = "Y"
+		} else {
+			if _, err := a.parseShortOption("-Syu", ""); err != nil {
+				return err
+			}
+		}
 	}
 
 	if a.ExistsArg("-") {

pkg/settings/runtime.go

@@ -1,7 +1,13 @@
 package settings
 
 import (
+	"context"
+	"fmt"
 	"net/http"
+	"os"
+	"path/filepath"
+
+	"github.com/leonelquinteros/gotext"
 
 	"github.com/Jguer/yay/v12/pkg/db"
 	"github.com/Jguer/yay/v12/pkg/query"
@@ -11,25 +17,96 @@ import (
 	"github.com/Jguer/yay/v12/pkg/vcs"
 
 	"github.com/Jguer/aur"
+	"github.com/Jguer/aur/metadata"
 	"github.com/Jguer/aur/rpc"
 	"github.com/Jguer/votar/pkg/vote"
 	"github.com/Morganamilo/go-pacmanconf"
 )
 
 type Runtime struct {
-	Mode           parser.TargetMode
-	QueryBuilder   query.Builder
-	Version        string // current version of yay
-	SaveConfig     bool
-	CompletionPath string
-	ConfigPath     string
-	PacmanConf     *pacmanconf.Config
-	VCSStore       vcs.Store
-	CmdBuilder     exe.ICmdBuilder
-	HTTPClient     *http.Client
-	AURClient      *rpc.Client
-	VoteClient     *vote.Client
-	AURCache       aur.QueryClient
-	DBExecutor     db.Executor
-	Logger         *text.Logger
+	QueryBuilder query.Builder
+	PacmanConf   *pacmanconf.Config
+	VCSStore     vcs.Store
+	CmdBuilder   exe.ICmdBuilder
+	HTTPClient   *http.Client
+	AURClient    *rpc.Client
+	VoteClient   *vote.Client
+	AURCache     aur.QueryClient
+	DBExecutor   db.Executor
+	Logger       *text.Logger
+}
+
+func BuildRuntime(cfg *Configuration, cmdArgs *parser.Arguments, version string) (*Runtime, error) {
+	logger := text.NewLogger(os.Stdout, os.Stdin, cfg.Debug, "runtime")
+	cmdBuilder := cfg.CmdBuilder(nil)
+
+	httpClient := &http.Client{
+		CheckRedirect: func(req *http.Request, via []*http.Request) error {
+			return http.ErrUseLastResponse
+		},
+	}
+
+	userAgent := fmt.Sprintf("Yay/%s", version)
+	voteClient, errVote := vote.NewClient(vote.WithUserAgent(userAgent),
+		vote.WithHTTPClient(httpClient))
+	if errVote != nil {
+		return nil, errVote
+	}
+
+	voteClient.SetCredentials(
+		os.Getenv("AUR_USERNAME"),
+		os.Getenv("AUR_PASSWORD"))
+
+	userAgentFn := func(ctx context.Context, req *http.Request) error {
+		req.Header.Set("User-Agent", userAgent)
+		return nil
+	}
+
+	var aurCache aur.QueryClient
+	aurCache, errAURCache := metadata.New(
+		metadata.WithHTTPClient(httpClient),
+		metadata.WithCacheFilePath(filepath.Join(cfg.BuildDir, "aur.json")),
+		metadata.WithRequestEditorFn(userAgentFn),
+		metadata.WithBaseURL(cfg.AURURL),
+		metadata.WithDebugLogger(logger.Debugln),
+	)
+	if errAURCache != nil {
+		return nil, fmt.Errorf(gotext.Get("failed to retrieve aur Cache")+": %w", errAURCache)
+	}
+
+	aurClient, errAUR := rpc.NewClient(
+		rpc.WithHTTPClient(httpClient),
+		rpc.WithBaseURL(cfg.AURRPCURL),
+		rpc.WithRequestEditorFn(userAgentFn),
+		rpc.WithLogFn(logger.Debugln))
+	if errAUR != nil {
+		return nil, errAUR
+	}
+
+	if cfg.UseRPC {
+		aurCache = aurClient
+	}
+
+	vcsStore := vcs.NewInfoStore(
+		cfg.VCSFilePath, cmdBuilder,
+		logger.Child("vcs"))
+
+	if err := vcsStore.Load(); err != nil {
+		return nil, err
+	}
+
+	runtime := &Runtime{
+		QueryBuilder: nil,
+		PacmanConf:   nil,
+		VCSStore:     vcsStore,
+		CmdBuilder:   cmdBuilder,
+		HTTPClient:   &http.Client{},
+		AURClient:    aurClient,
+		VoteClient:   voteClient,
+		AURCache:     aurCache,
+		DBExecutor:   nil,
+		Logger:       text.NewLogger(os.Stdout, os.Stdin, cfg.Debug, "runtime"),
+	}
+
+	return runtime, nil
 }

pkg/upgrade/service.go

@@ -24,14 +24,13 @@ type UpgradeService struct {
 	aurCache   aur.QueryClient
 	dbExecutor db.Executor
 	vcsStore   vcs.Store
-	runtime    *settings.Runtime
 	cfg        *settings.Configuration
 	log        *text.Logger
 	noConfirm  bool
 }
 
 func NewUpgradeService(grapher *dep.Grapher, aurCache aur.QueryClient,
-	dbExecutor db.Executor, vcsStore vcs.Store, runtime *settings.Runtime,
+	dbExecutor db.Executor, vcsStore vcs.Store,
 	cfg *settings.Configuration, noConfirm bool, logger *text.Logger,
 ) *UpgradeService {
 	return &UpgradeService{
@@ -39,7 +38,6 @@ func NewUpgradeService(grapher *dep.Grapher, aurCache aur.QueryClient,
 		aurCache:   aurCache,
 		dbExecutor: dbExecutor,
 		vcsStore:   vcsStore,
-		runtime:    runtime,
 		cfg:        cfg,
 		noConfirm:  noConfirm,
 		log:        logger,
@@ -61,7 +59,7 @@ func (u *UpgradeService) upGraph(ctx context.Context, graph *topo.Graph[string,
 	remote := u.dbExecutor.InstalledRemotePackages()
 	remoteNames := u.dbExecutor.InstalledRemotePackageNames()
 
-	if u.runtime.Mode.AtLeastAUR() {
+	if u.cfg.Mode.AtLeastAUR() {
 		u.log.OperationInfoln(gotext.Get("Searching AUR for updates..."))
 
 		_aurdata, err := u.aurCache.Get(ctx, &aur.Query{Needles: remoteNames, By: aur.Name})
@@ -140,7 +138,7 @@ func (u *UpgradeService) upGraph(ctx context.Context, graph *topo.Graph[string,
 		})
 	}
 
-	if u.cfg.Runtime.Mode.AtLeastRepo() {
+	if u.cfg.Mode.AtLeastRepo() {
 		u.log.OperationInfoln(gotext.Get("Searching databases for updates..."))
 
 		syncUpgrades, err := u.dbExecutor.SyncUpgrades(enableDowngrade)

pkg/upgrade/service_test.go

@@ -262,8 +262,7 @@ func TestUpgradeService_GraphUpgrades(t *testing.T) {
 					tt.fields.input, true, "test"))
 
 			cfg := &settings.Configuration{
-				Runtime: &settings.Runtime{Mode: parser.ModeAny},
-				Devel:   tt.fields.devel,
+				Devel: tt.fields.devel, Mode: parser.ModeAny,
 			}
 
 			u := &UpgradeService{
@@ -273,7 +272,6 @@ func TestUpgradeService_GraphUpgrades(t *testing.T) {
 				aurCache:   mockAUR,
 				dbExecutor: dbExe,
 				vcsStore:   vcsStore,
-				runtime:    cfg.Runtime,
 				cfg:        cfg,
 				noConfirm:  tt.fields.noConfirm,
 			}
@@ -383,8 +381,8 @@ func TestUpgradeService_GraphUpgradesNoUpdates(t *testing.T) {
 					tt.fields.input, true, "test"))
 
 			cfg := &settings.Configuration{
-				Runtime: &settings.Runtime{Mode: parser.ModeAny},
-				Devel:   tt.fields.devel,
+				Devel: tt.fields.devel,
+				Mode:  parser.ModeAny,
 			}
 
 			u := &UpgradeService{
@@ -394,7 +392,6 @@ func TestUpgradeService_GraphUpgradesNoUpdates(t *testing.T) {
 				aurCache:   mockAUR,
 				dbExecutor: dbExe,
 				vcsStore:   vcsStore,
-				runtime:    cfg.Runtime,
 				cfg:        cfg,
 				noConfirm:  tt.fields.noConfirm,
 			}

print.go

@@ -114,7 +114,7 @@ func printUpdateList(ctx context.Context, cfg *settings.Configuration, cmdArgs *
 
 	upService := upgrade.NewUpgradeService(
 		grapher, cfg.Runtime.AURCache, dbExecutor, cfg.Runtime.VCSStore,
-		cfg.Runtime, cfg, settings.NoConfirm, logger.Child("upgrade"))
+		cfg, settings.NoConfirm, logger.Child("upgrade"))
 
 	graph, errSysUp := upService.GraphUpgrades(ctx, nil,
 		enableDowngrade, filter)

query.go

@@ -42,7 +42,7 @@ func syncInfo(ctx context.Context, cfg *settings.Configuration,
 		missing = false
 	)
 
-	pkgS = query.RemoveInvalidTargets(pkgS, cfg.Runtime.Mode)
+	pkgS = query.RemoveInvalidTargets(pkgS, cfg.Mode)
 	aurS, repoS := packageSlices(pkgS, cfg, dbExecutor)
 
 	if len(aurS) != 0 {
@@ -68,7 +68,7 @@ func syncInfo(ctx context.Context, cfg *settings.Configuration,
 		arguments.AddTarget(repoS...)
 
 		err = cfg.Runtime.CmdBuilder.Show(cfg.Runtime.CmdBuilder.BuildPacmanCmd(ctx,
-			arguments, cfg.Runtime.Mode, settings.NoConfirm))
+			arguments, cfg.Mode, settings.NoConfirm))
 		if err != nil {
 			return err
 		}
@@ -96,10 +96,10 @@ func packageSlices(toCheck []string, config *settings.Configuration, dbExecutor
 	for _, _pkg := range toCheck {
 		dbName, name := text.SplitDBFromName(_pkg)
 
-		if dbName == "aur" || config.Runtime.Mode == parser.ModeAUR {
+		if dbName == "aur" || config.Mode == parser.ModeAUR {
 			aurNames = append(aurNames, _pkg)
 			continue
-		} else if dbName != "" || config.Runtime.Mode == parser.ModeRepo {
+		} else if dbName != "" || config.Mode == parser.ModeRepo {
 			repoNames = append(repoNames, _pkg)
 			continue
 		}

sync.go

@@ -32,7 +32,7 @@ func syncInstall(ctx context.Context,
 		cfg.Runtime.CmdBuilder.AddMakepkgFlag("-d")
 	}
 
-	if refreshArg && cfg.Runtime.Mode.AtLeastRepo() {
+	if refreshArg && cfg.Mode.AtLeastRepo() {
 		if errR := earlyRefresh(ctx, cfg, cfg.Runtime.CmdBuilder, cmdArgs); errR != nil {
 			return fmt.Errorf("%s - %w", gotext.Get("error refreshing databases"), errR)
 		}
@@ -58,7 +58,7 @@ func syncInstall(ctx context.Context,
 
 		upService := upgrade.NewUpgradeService(
 			grapher, aurCache, dbExecutor, cfg.Runtime.VCSStore,
-			cfg.Runtime, cfg, settings.NoConfirm, cfg.Runtime.Logger.Child("upgrade"))
+			cfg, settings.NoConfirm, cfg.Runtime.Logger.Child("upgrade"))
 
 		graph, errSysUp = upService.GraphUpgrades(ctx,
 			graph, cmdArgs.ExistsDouble("u", "sysupgrade"),
@@ -112,7 +112,7 @@ func (o *OperationService) Run(ctx context.Context,
 	}
 	preparer := NewPreparer(o.dbExecutor, o.cfg.Runtime.CmdBuilder, o.cfg)
 	installer := NewInstaller(o.dbExecutor, o.cfg.Runtime.CmdBuilder,
-		o.cfg.Runtime.VCSStore, o.cfg.Runtime.Mode,
+		o.cfg.Runtime.VCSStore, o.cfg.Mode,
 		cmdArgs.ExistsArg("w", "downloadonly"), o.cfg.Runtime.Logger.Child("installer"))
 
 	pkgBuildDirs, errInstall := preparer.Run(ctx, os.Stdout, targets)
@@ -131,7 +131,7 @@ func (o *OperationService) Run(ctx context.Context,
 
 	go func() {
 		errComp := completion.Update(ctx, o.cfg.Runtime.HTTPClient, o.dbExecutor,
-			o.cfg.AURURL, o.cfg.Runtime.CompletionPath, o.cfg.CompletionInterval, false)
+			o.cfg.AURURL, o.cfg.CompletionPath, o.cfg.CompletionInterval, false)
 		if errComp != nil {
 			text.Warnln(errComp)
 		}

upgrade.go

@@ -58,7 +58,7 @@ func upList(ctx context.Context, cfg *settings.Configuration,
 		}
 	}
 
-	if cfg.Runtime.Mode.AtLeastRepo() {
+	if cfg.Mode.AtLeastRepo() {
 		text.OperationInfoln(gotext.Get("Searching databases for updates..."))
 		wg.Add(1)
 
@@ -69,7 +69,7 @@ func upList(ctx context.Context, cfg *settings.Configuration,
 		}()
 	}
 
-	if cfg.Runtime.Mode.AtLeastAUR() {
+	if cfg.Mode.AtLeastAUR() {
 		text.OperationInfoln(gotext.Get("Searching AUR for updates..."))
 
 		var _aurdata []aur.Pkg