pkg

Documentation

Index

• Variables

Variables

var AddCmd = &cobra.Command{
	Use:     "add",
	Aliases: []string{"a"},
	Short:   "Add packages",
	Long: `Add an arbitrary number of packages.
Packages are specified in the form <package-name>[@<version>], where the version is optional.

Usage: scfg pkg add <package-name>@<version> <package-name> ...`,
	Args: cobra.MinimumNArgs(1),
	RunE: func(cmd *cobra.Command, args []string) error {
		pkgsToAdd := make([]*model.Package, 0, len(args))
		for _, pkgStr := range args {
			pkg, err := model.ParsePackage(pkgStr)
			if err != nil {
				return err
			}

			pkgsToAdd = append(pkgsToAdd, pkg)
		}

		var cfg *store.Configuration
		if mode.ManageConfig() {
			var err error
			if cfg, err = store.LoadConfiguration(); err != nil {
				return fmt.Errorf("Unable to load configuration: %w", err)
			}
		}

		var manager pkgmanager.PacakgeManager
		if mode.ManageSystem() {
			var err error
			if manager, err = pkgmanager.FindPackageManager(); err != nil {
				return fmt.Errorf("Failed to resolve a package manager: %w", err)
			}
		}

		for _, pkg := range pkgsToAdd {
			if err := addPackage(cfg, manager, pkg); err != nil {
				return fmt.Errorf("Failed to add package `%s`: %v\n", pkg, err)
			}
		}

		if cfg != nil {
			if err := store.WriteConfiguration(cfg); err != nil {
				return fmt.Errorf("Failed to write configuration: %w", err)
			}
		}

		termio.Printf("Successfully added %d packages\n", len(pkgsToAdd))
		return nil
	},
}

var ListCmd = &cobra.Command{
	Use:     "list",
	Aliases: []string{"ls"},
	Short:   "List packages",
	Long: `List packages. Has different behavior based on the current mode:
- Configuration: List packages in the configuration only.
- System: List packages in the system only.
- Hybrid: List packages in both the configuration and system, with a + or - sign indicating if the package is in the configuration or system, respectively.

Usage: scfg pkg list`,
	RunE: func(cmd *cobra.Command, args []string) error {
		var configPackages []*model.Package
		if mode.ManageConfig() {
			cfg, err := store.LoadConfiguration()
			if err != nil {
				return fmt.Errorf("Unable to load configuration: %w", err)
			}

			configPackages, err = cfg.ResolvedPkgs()
			if err != nil {
				termio.Warn("Unable to resolve packages for host manager, showing base configuration\n")
				configPackages = cfg.Packages
			}
		}

		var sysPackages []*model.Package
		if mode.ManageSystem() {
			manager, err := pkgmanager.FindPackageManager()
			if err != nil {
				return fmt.Errorf("Unable to load configuration: %w", err)
			}

			sysPackages, err = manager.ListPackages()
			if err != nil {
				return fmt.Errorf("Unable to read system packages: %w", err)
			}
		}

		slices.SortFunc(configPackages, func(x *model.Package, y *model.Package) int {
			return comparePackage(x, y)
		})

		slices.SortFunc(sysPackages, func(x *model.Package, y *model.Package) int {
			return comparePackage(x, y)
		})

		cfgIdx := 0
		sysIdx := 0
		for cfgIdx < len(configPackages) || sysIdx < len(sysPackages) {
			var cfgPkg, sysPkg *model.Package

			if cfgIdx < len(configPackages) {
				cfgPkg = configPackages[cfgIdx]
			}

			if sysIdx < len(sysPackages) {
				sysPkg = sysPackages[sysIdx]
			}

			cmp := comparePackage(cfgPkg, sysPkg)
			var pkgName, diffSign string

			switch cmp {
			case 0:
				pkgName = cfgPkg.String()
				diffSign = " "
				cfgIdx++
				sysIdx++
			case -1:
				pkgName = cfgPkg.String()
				diffSign = "+"
				cfgIdx++
			case 1:
				pkgName = sysPkg.String()
				diffSign = "-"
				sysIdx++
			}

			sfmt := "%s\n"
			printValues := []any{pkgName}
			if mode.Current() == mode.ModeHybrid {
				sfmt = "%s %s\n"
				printValues = []any{diffSign, pkgName}
			}

			termio.Printf(sfmt, printValues...)
		}

		return nil
	},
}

var PkgCmd = &cobra.Command{
	Use:     "package",
	Aliases: []string{"pkg"},
	Short:   "Manage configuration and system packages",
	Long:    "Manage configuration and system packages.",
}

var RemoveCmd = &cobra.Command{
	Use:     "remove",
	Aliases: []string{"rm"},
	Short:   `Remove packages`,
	Long: `Remove an arbitrary number of packages.
	Packages are specified in the form <package-name>.

	Usage: scfg pkg rm <package-name>...`,
	Args: cobra.MinimumNArgs(1),
	RunE: func(cmd *cobra.Command, args []string) error {
		var cfg *store.Configuration
		if mode.ManageConfig() {
			var err error
			if cfg, err = store.LoadConfiguration(); err != nil {
				return fmt.Errorf("Unable to load configuration: %w", err)
			}
		}

		var manager pkgmanager.PacakgeManager
		if mode.ManageSystem() {
			var err error
			if manager, err = pkgmanager.FindPackageManager(); err != nil {
				return fmt.Errorf("Failed to resolve a package manager: %w", err)
			}
		}

		for _, pkgName := range args {
			if err := removePackage(cfg, manager, pkgName); err != nil {
				return fmt.Errorf("Failed to remove package `%s`: %s\n", pkgName, err)
			}
		}

		if err := store.WriteConfiguration(cfg); err != nil {
			return fmt.Errorf("Failed to write configuration: %w", err)
		}

		termio.Printf("Successfully removed %d packages\n", len(args))
		return nil
	},
}

var SyncCmd = &cobra.Command{
	Use:   "sync",
	Short: "Sync packages between configuration and system",
	Long: `Sync packages between configuration and system. Has different behavior based on the current mode:
- Configuration: Add packages to the system that are present only in the configuration.
- System: Add packages to the configuration that are present only on the system.
- Hybrid: Two-way sync packages between the configuration and system, only adding packages that are present in one but not the other.

Usage: scfg pkg sync`,
	RunE: func(cmd *cobra.Command, args []string) error {
		configPackages := make(map[string]*model.Package)
		cfg, err := store.LoadConfiguration()
		if err != nil {
			return fmt.Errorf("Unable to load configuration: %w", err)
		}

		cfgPkgList, err := cfg.ResolvedPkgs()
		if err != nil {
			termio.Warn("Unable to resolve packages for host manager, showing base configuration\n")
			cfgPkgList = cfg.Packages
		}

		for _, pkg := range cfgPkgList {
			configPackages[pkg.Name] = pkg
		}

		sysPackages := make(map[string]*model.Package)
		manager, err := pkgmanager.FindPackageManager()
		if err != nil {
			return fmt.Errorf("Failed to find the package manager: %w", err)
		}

		sysPkgList, err := manager.ListPackages()
		if err != nil {
			return fmt.Errorf("Unable to read system packages: %w", err)
		}

		for _, pkg := range sysPkgList {
			sysPackages[pkg.Name] = pkg
		}

		if mode.ManageConfig() {
			for name, pkg := range configPackages {
				if _, ok := sysPackages[name]; !ok {
					managerPackageName := manager.FmtPackageVersion(pkg)
					termio.Printf("[System] Adding package `%s`\n", managerPackageName)
					if err := manager.AddPackage(pkg); err != nil {
						termio.Warnf("[System] Failed to add package `%s`: %v\n", managerPackageName, err)
					}
				}
			}
		}

		if mode.ManageSystem() {
			for name, pkg := range sysPackages {
				if _, ok := configPackages[name]; !ok {
					termio.Printf("[Configuration] Adding package `%s`\n", pkg)
					if err := cfg.AddPackage(pkg); err != nil {
						termio.Warnf("[Configuration] Failed to add package `%s`: %v\n", pkg, err)
					}
				}
			}

			if err := store.WriteConfiguration(cfg); err != nil {
				return fmt.Errorf("Failed to write configuration: %w", err)
			}
		}

		return nil
	},
}