Fix typo

make dependencies

Makefile

@@ -7,12 +7,13 @@ SYSCONFDIR := $(PREFIX)/etc
 GO ?= go
 
 # Build-time variables
+VERSION ?= $(shell git describe --tags --dirty)
 ROOT_COMPILATION_UID ?= 65534
 ROOT_COMPILATION_GID ?= 65534
 
 build:
 	mkdir -p build
-	cd src/bpm; $(GO) build -ldflags "-w -X 'git.enumerated.dev/bubble-package-manager/bpm/src/bpmlib.rootCompilationUID=$(ROOT_COMPILATION_UID)' -X 'git.enumerated.dev/bubble-package-manager/bpm/src/bpmlib.rootCompilationGID=$(ROOT_COMPILATION_GID)'" -o ../../build/bpm git.enumerated.dev/bubble-package-manager/bpm/src/bpm
+	cd src/bpm; $(GO) build $(GOFLAGS) -ldflags "-w -X 'main.BpmVersion=$(VERSION)' -X 'github.com/EnumeratedDev/bpm/src/bpmlib.rootCompilationUID=$(ROOT_COMPILATION_UID)' -X 'github.com/EnumeratedDev/bpm/src/bpmlib.rootCompilationGID=$(ROOT_COMPILATION_GID)'" -o ../../build/bpm bpm
 
 install: build/bpm config/
 	# Create directory

config/bpm.conf

@@ -1,4 +1,5 @@
 ignore_packages: []
+show_source_package_contents: always
 cleanup_make_dependencies: true
 databases:
   - name: example-database

src/bpm/go.mod

@@ -1,14 +1,23 @@
-module git.enumerated.dev/bubble-package-manager/bpm/src/bpm
+module bpm
 
-go 1.23
+go 1.24.0
-
-toolchain go1.23.7
-
-require git.enumerated.dev/bubble-package-manager/bpm/src/bpmlib v0.5.0
-
-replace git.enumerated.dev/bubble-package-manager/bpm/src/bpmlib => ../bpmlib
 
 require (
+	github.com/EnumeratedDev/bpm/src/bpmlib v0.0.0
+	github.com/lithammer/fuzzysearch v1.1.8
+	github.com/spf13/pflag v1.0.10
+)
+
+replace github.com/EnumeratedDev/bpm/src/bpmlib => ../bpmlib
+
+require (
+	github.com/drone/envsubst v1.0.3 // indirect
 	github.com/knqyf263/go-rpm-version v0.0.0-20240918084003-2afd7dc6a38f // indirect
+	github.com/mitchellh/colorstring v0.0.0-20190213212951-d06e56a500db // indirect
+	github.com/rivo/uniseg v0.4.7 // indirect
+	github.com/schollz/progressbar/v3 v3.18.0 // indirect
+	golang.org/x/sys v0.37.0 // indirect
+	golang.org/x/term v0.36.0 // indirect
+	golang.org/x/text v0.9.0 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )

src/bpm/go.sum

@@ -1,5 +1,65 @@
+github.com/chengxilo/virtualterm v1.0.4 h1:Z6IpERbRVlfB8WkOmtbHiDbBANU7cimRIof7mk9/PwM=
+github.com/chengxilo/virtualterm v1.0.4/go.mod h1:DyxxBZz/x1iqJjFxTFcr6/x+jSpqN0iwWCOK1q10rlY=
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/drone/envsubst v1.0.3 h1:PCIBwNDYjs50AsLZPYdfhSATKaRg/FJmDc2D6+C2x8g=
+github.com/drone/envsubst v1.0.3/go.mod h1:N2jZmlMufstn1KEqvbHjw40h1KyTmnVzHcSc9bFiJ2g=
+github.com/google/go-cmp v0.2.0 h1:+dTQ8DZQJz0Mb/HjFlkptS1FeQ4cWSnN941F8aEG4SQ=
+github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M=
 github.com/knqyf263/go-rpm-version v0.0.0-20240918084003-2afd7dc6a38f h1:xt29M2T6STgldg+WEP51gGePQCsQvklmP2eIhPIBK3g=
 github.com/knqyf263/go-rpm-version v0.0.0-20240918084003-2afd7dc6a38f/go.mod h1:i4sF0l1fFnY1aiw08QQSwVAFxHEm311Me3WsU/X7nL0=
+github.com/lithammer/fuzzysearch v1.1.8 h1:/HIuJnjHuXS8bKaiTMeeDlW2/AyIWk2brx1V8LFgLN4=
+github.com/lithammer/fuzzysearch v1.1.8/go.mod h1:IdqeyBClc3FFqSzYq/MXESsS4S0FsZ5ajtkr5xPLts4=
+github.com/mattn/go-runewidth v0.0.16 h1:E5ScNMtiwvlvB5paMFdw9p4kSQzbXFikJ5SQO6TULQc=
+github.com/mattn/go-runewidth v0.0.16/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
+github.com/mitchellh/colorstring v0.0.0-20190213212951-d06e56a500db h1:62I3jR2EmQ4l5rM/4FEfDWcRD+abF5XlKShorW5LRoQ=
+github.com/mitchellh/colorstring v0.0.0-20190213212951-d06e56a500db/go.mod h1:l0dey0ia/Uv7NcFFVbCLtqEBQbrT4OCwCSKTEv6enCw=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=
+github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
+github.com/schollz/progressbar/v3 v3.18.0 h1:uXdoHABRFmNIjUfte/Ex7WtuyVslrw2wVPQmCN62HpA=
+github.com/schollz/progressbar/v3 v3.18.0/go.mod h1:IsO3lpbaGuzh8zIMzgY3+J8l4C8GjO0Y9S69eFvNsec=
+github.com/spf13/pflag v1.0.10 h1:4EBh2KAYBwaONj6b2Ye1GiHfwjqyROoF4RwYO+vPwFk=
+github.com/spf13/pflag v1.0.10/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
+github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
+github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
+golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
+golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
+golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
+golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
+golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
+golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
+golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=
+golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.37.0 h1:fdNQudmxPjkdUTPnLn5mdQv7Zwvbvpaxqs831goi9kQ=
+golang.org/x/sys v0.37.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
+golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
+golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
+golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k=
+golang.org/x/term v0.36.0 h1:zMPR+aF8gfksFprF/Nc/rd1wRS1EI6nDBGyWAvDzx2Q=
+golang.org/x/term v0.36.0/go.mod h1:Qu394IJq6V6dCBRgwqshf3mPF85AqzYEzofzRdZkWss=
+golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
+golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
+golang.org/x/text v0.9.0 h1:2sjJmO8cDvYveuX97RDLsxlyUxLl+GHoLxBiRdHllBE=
+golang.org/x/text v0.9.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8=
+golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
+golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU=
+golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=

src/bpmlib/compilation.go

@@ -1,22 +1,29 @@
 package bpmlib
 
 import (
+	"crypto/sha256"
+	"encoding/hex"
 	"errors"
 	"fmt"
+	"io"
+	"io/fs"
 	"os"
 	"os/exec"
 	"path"
+	"path/filepath"
+	"slices"
 	"strconv"
 	"strings"
 	"syscall"
 
+	"github.com/drone/envsubst"
 	"gopkg.in/yaml.v3"
 )
 
 var rootCompilationUID = "65534"
 var rootCompilationGID = "65534"
 
-func CompileSourcePackage(archiveFilename, outputDirectory string, skipChecks bool) (outputBpmPackages map[string]string, err error) {
+func CompileSourcePackage(archiveFilename, outputDirectory string, skipChecks, keepCompilationFiles, verbose bool) (outputBpmPackages map[string]string, err error) {
 	// Initialize map
 	outputBpmPackages = make(map[string]string)
 
@@ -31,12 +38,6 @@ func CompileSourcePackage(archiveFilename, outputDirectory string, skipChecks bo
 		return nil, errors.New("cannot compile a non-source package")
 	}
 
-	// Read compilation options file in current directory
-	compilationOptions, err := readCompilationOptionsFile()
-	if err != nil {
-		return nil, err
-	}
-
 	// Get HOME directory
 	homeDir, err := os.UserHomeDir()
 	if err != nil {
@@ -122,21 +123,22 @@ func CompileSourcePackage(archiveFilename, outputDirectory string, skipChecks bo
 		return nil, err
 	}
 
+	// Download files
+	err = downloadPackageFiles(bpmpkg.PkgInfo, tempDirectory, verbose)
+	if err != nil {
+		return nil, err
+	}
+
 	// Setup environment for commands
 	env := os.Environ()
 	env = append(env, "HOME="+tempDirectory)
 	env = append(env, "BPM_WORKDIR="+tempDirectory)
 	env = append(env, "BPM_SOURCE="+path.Join(tempDirectory, "source"))
-	env = append(env, "BPM_OUTPUT="+path.Join(tempDirectory, "output"))
 	env = append(env, "BPM_PKG_NAME="+bpmpkg.PkgInfo.Name)
 	env = append(env, "BPM_PKG_VERSION="+bpmpkg.PkgInfo.Version)
 	env = append(env, "BPM_PKG_REVISION="+strconv.Itoa(bpmpkg.PkgInfo.Revision))
-	// Check for architecture override in compilation options
+	env = append(env, "BPM_PKG_URL="+bpmpkg.PkgInfo.Url)
-	if val, ok := compilationOptions["ARCH"]; ok {
+	env = append(env, "BPM_PKG_ARCH="+bpmpkg.PkgInfo.OutputArch)
-		env = append(env, "BPM_PKG_ARCH="+val)
-	} else {
-		env = append(env, "BPM_PKG_ARCH="+GetArch())
-	}
 	env = append(env, CompilationBPMConfig.CompilationEnvironment...)
 
 	// Execute prepare and build functions in source.sh script
@@ -144,8 +146,8 @@ func CompileSourcePackage(archiveFilename, outputDirectory string, skipChecks bo
 		"set -a\n"+ // Source and export functions and variables in source.sh script
 			". \"${BPM_WORKDIR}\"/source.sh\n"+
 			"set +a\n"+
-			"[[ $(type -t prepare) == \"function\" ]] && { echo \"Running prepare() function\"; bash -e -c 'cd \"$BPM_WORKDIR\" && prepare' || exit 1; }\n"+ // Run prepare() function if it exists
+			"[[ $(type -t prepare) == \"function\" ]] && { echo \"Running prepare() function...\"; bash -e -c 'cd \"$BPM_WORKDIR\" && prepare' || exit 1; }\n"+ // Run prepare() function if it exists
-			"[[ $(type -t build) == \"function\" ]] && { echo \"Running build() function\"; bash -e -c 'cd \"$BPM_SOURCE\" && build'  || exit 1; }\n"+ // Run build() function if it exists
+			"[[ $(type -t build) == \"function\" ]] && { echo \"Running build() function...\"; bash -e -c 'cd \"$BPM_SOURCE\" && build'  || exit 1; }\n"+ // Run build() function if it exists
 			"exit 0")
 	cmd.Dir = tempDirectory
 	cmd.Stdout = os.Stdout
@@ -166,7 +168,7 @@ func CompileSourcePackage(archiveFilename, outputDirectory string, skipChecks bo
 			"set -a\n"+ // Source and export functions and variables in source.sh script
 				". \"${BPM_WORKDIR}\"/source.sh\n"+
 				"set +a\n"+
-				"[[ $(type -t check) == \"function\" ]] && { echo \"Running check() function\"; bash -e -c 'cd \"$BPM_SOURCE\" && check' || exit 1; }\n"+ // Run check() function if it exists
+				"[[ $(type -t check) == \"function\" ]] && { echo \"Running check() function...\"; bash -e -c 'cd \"$BPM_SOURCE\" && check' || exit 1; }\n"+ // Run check() function if it exists
 				"exit 0")
 		cmd.Dir = tempDirectory
 		cmd.Stdout = os.Stdout
@@ -188,6 +190,21 @@ func CompileSourcePackage(archiveFilename, outputDirectory string, skipChecks bo
 		packagesToCompile = append(packagesToCompile, bpmpkg.PkgInfo)
 	}
 
+	// Create output directories for each package
+	for _, pkg := range packagesToCompile {
+		// Create new output directory
+		err = os.Mkdir(path.Join(tempDirectory, "output_"+pkg.Name), 0755)
+		if err != nil {
+			return nil, err
+		}
+
+		// Change output directory owner
+		err = os.Chown(path.Join(tempDirectory, "output_"+pkg.Name), uid, gid)
+		if err != nil {
+			return nil, err
+		}
+	}
+
 	// Compile each package
 	for _, pkg := range packagesToCompile {
 		// Get package function name
@@ -196,38 +213,102 @@ func CompileSourcePackage(archiveFilename, outputDirectory string, skipChecks bo
 			packageFunctionName = "package_" + pkg.Name
 		}
 
-		// Remove output directory if it already exists
-		if _, err := os.Stat(path.Join(tempDirectory, "output")); err == nil {
-			err := os.RemoveAll(path.Join(tempDirectory, "output"))
-			if err != nil {
-				return nil, err
-			}
-		}
-
-		// Create new output directory
-		err = os.Mkdir(path.Join(tempDirectory, "output"), 0755)
-		if err != nil {
-			return nil, err
-		}
-
-		// Change output directory owner
-		err = os.Chown(path.Join(tempDirectory, "output"), uid, gid)
-		if err != nil {
-			return nil, err
-		}
-
 		// Execute package function in source.sh script and generate package file list
 		cmd = exec.Command("bash", "-c",
 			"set -a\n"+ // Source and export functions and variables in source.sh script
 				". \"${BPM_WORKDIR}\"/source.sh\n"+
 				"set +a\n"+
-				"echo \"Running "+packageFunctionName+"() function\"\n"+
+				"echo \"Running "+packageFunctionName+"() function...\"\n"+
-				"( cd \"$BPM_SOURCE\" && fakeroot -s \"$BPM_WORKDIR\"/fakeroot_file bash -e -c '"+packageFunctionName+"' ) || exit 1\n"+ // Run package() function
+				"( cd \"$BPM_SOURCE\" && fakeroot -s \"$BPM_WORKDIR\"/fakeroot_file bash -e -c '"+packageFunctionName+"' ) || exit 1\n") // Run package() function
-				"fakeroot -i \"$BPM_WORKDIR\"/fakeroot_file find \"$BPM_OUTPUT\" -mindepth 1 -printf \"%P %#m %U %G %s\\n\" > \"$BPM_WORKDIR\"/pkg.files") // Create package file list
+
 		cmd.Dir = tempDirectory
 		cmd.Stdout = os.Stdout
 		cmd.Stderr = os.Stderr
-		cmd.Env = env
+		cmd.Env = append(env, "BPM_OUTPUT="+path.Join(tempDirectory, "output_"+pkg.Name))
+		if os.Getuid() == 0 {
+			cmd.SysProcAttr = &syscall.SysProcAttr{}
+			cmd.SysProcAttr.Credential = &syscall.Credential{Uid: uint32(uid), Gid: uint32(gid)}
+		}
+		err = cmd.Run()
+		if err != nil {
+			return nil, err
+		}
+
+		// Strip all ELF binaries
+		if !slices.Contains(pkg.Options, "nostrip") {
+			if _, err := exec.LookPath("strip"); err != nil {
+				fmt.Println("Skip stripping ELF binaries. 'strip' not in path")
+			} else {
+				fmt.Println("Stripping ELF binaries...")
+
+				err = filepath.WalkDir(path.Join(tempDirectory, "output_"+pkg.Name), func(path string, d fs.DirEntry, err error) error {
+					cmd = exec.Command("file", "-bi", path)
+					cmd.Stderr = os.Stderr
+					output, err := cmd.Output()
+					if err != nil {
+						return err
+					}
+
+					mimetype := strings.Split(string(output), ";")[0]
+
+					if strings.HasPrefix(mimetype, "application/x-executable") {
+						cmd := exec.Command("strip", path)
+						cmd.Stderr = os.Stderr
+						err = cmd.Run()
+						if err != nil {
+							return err
+						}
+						if verbose {
+							fmt.Printf("Stripped %s (%s)\n", path, mimetype)
+						}
+					} else if strings.HasPrefix(mimetype, "application/x-pie-executable") || strings.HasPrefix(mimetype, "application/x-sharedlib") {
+						cmd = exec.Command("file", "-b", path)
+						cmd.Stderr = os.Stderr
+						output, err = cmd.Output()
+						if err != nil {
+							return err
+						}
+						// Skip files that use ELF as a container format
+						if strings.Contains(string(output), "no machine") {
+							return nil
+						}
+
+						cmd := exec.Command("strip", "--strip-unneeded", path)
+						cmd.Stderr = os.Stderr
+						err = cmd.Run()
+						if err != nil {
+							return err
+						}
+						if verbose {
+							fmt.Printf("Stripped %s (%s)\n", path, mimetype)
+						}
+					} else if strings.HasPrefix(mimetype, "application/x-archive") {
+						cmd := exec.Command("strip", "--strip-debug", path)
+						cmd.Stderr = os.Stderr
+						err = cmd.Run()
+						if err != nil {
+							return err
+						}
+						if verbose {
+							fmt.Printf("Stripped %s (%s)\n", path, mimetype)
+						}
+					}
+
+					return nil
+				})
+				if err != nil {
+					return nil, err
+				}
+			}
+		}
+
+		// Generate package file list
+		fmt.Println("Generating package file list...")
+		cmd = exec.Command("bash", "-c", "fakeroot -i \"$BPM_WORKDIR\"/fakeroot_file find \"$BPM_OUTPUT\" -mindepth 1 -printf \"%P %#m %U %G %s\\n\" > \"$BPM_WORKDIR\"/pkg.files")
+		cmd.Dir = tempDirectory
+		cmd.Stdout = os.Stdout
+		cmd.Stderr = os.Stderr
+		cmd.Env = append(env, "BPM_OUTPUT="+path.Join(tempDirectory, "output_"+pkg.Name))
 		if os.Getuid() == 0 {
 			cmd.SysProcAttr = &syscall.SysProcAttr{}
 			cmd.SysProcAttr.Credential = &syscall.Credential{Uid: uint32(uid), Gid: uint32(gid)}
@@ -238,7 +319,8 @@ func CompileSourcePackage(archiveFilename, outputDirectory string, skipChecks bo
 		}
 
 		// Create gzip-compressed archive for the package files
-		cmd = exec.Command("bash", "-c", "find output -printf \"%P\\n\" | fakeroot -i \"$BPM_WORKDIR\"/fakeroot_file tar -czf files.tar.gz --no-recursion -C output -T -")
+		fmt.Println("Generating compressed file archive...")
+		cmd = exec.Command("bash", "-c", fmt.Sprintf("find %s -printf \"%%P\\n\" | fakeroot -i %s/fakeroot_file tar -czf files.tar.gz --no-recursion -C %s -T -", "output_"+pkg.Name, tempDirectory, "output_"+pkg.Name))
 		cmd.Dir = tempDirectory
 		cmd.Stdout = os.Stdout
 		cmd.Stderr = os.Stderr
@@ -259,14 +341,12 @@ func CompileSourcePackage(archiveFilename, outputDirectory string, skipChecks bo
 		pkgInfo.Type = "binary"
 
 		// Set package architecture
-		if val, ok := compilationOptions["ARCH"]; ok {
+		pkgInfo.Arch = pkg.OutputArch
-			pkgInfo.Arch = val
+		pkgInfo.OutputArch = ""
-		} else {
-			pkgInfo.Arch = GetArch()
-		}
 
-		// Remove split package field
+		// Remove split package and downloads fields
 		pkgInfo.SplitPackages = nil
+		pkgInfo.Downloads = nil
 
 		// Marshal package info
 		pkgInfoBytes, err := yaml.Marshal(pkgInfo)
@@ -293,6 +373,7 @@ func CompileSourcePackage(archiveFilename, outputDirectory string, skipChecks bo
 		bpmArchiveFiles = append(bpmArchiveFiles, packageScripts...)                       // Package scripts
 
 		// Create final BPM archive
+		fmt.Println("Generating final BPM archive...")
 		cmd = exec.Command("bash", "-c", "tar -cf final-archive.bpm --owner=0 --group=0 -C \"$BPM_WORKDIR\" "+strings.Join(bpmArchiveFiles, " "))
 		cmd.Dir = tempDirectory
 		cmd.Stdout = os.Stdout
@@ -332,52 +413,284 @@ func CompileSourcePackage(archiveFilename, outputDirectory string, skipChecks bo
 			return nil, err
 		}
 
+		// Remove output directory
+		err = os.RemoveAll(path.Join(tempDirectory, "output_"+pkg.Name))
+		if err != nil {
+			return nil, err
+		}
+
 		outputBpmPackages[pkgInfo.Name] = outputFilename
 	}
 
+	// Delete temporary directory
+	if !keepCompilationFiles {
+		os.RemoveAll(tempDirectory)
+	}
+
 	return outputBpmPackages, nil
 }
 
-func readCompilationOptionsFile() (options map[string]string, err error) {
+func downloadPackageFiles(pkgInfo *PackageInfo, tempDirectory string, verbose bool) error {
-	// Initialize options map
+	for _, download := range pkgInfo.Downloads {
-	options = make(map[string]string)
+		// Replace variables
+		replaceVars := func(s string) string {
+			switch s {
+			case "BPM_PKG_NAME":
+				return pkgInfo.Name
+			case "BPM_PKG_VERSION":
+				return pkgInfo.Version
+			case "BPM_PKG_URL":
+				return pkgInfo.Url
+			case "BPM_SOURCE":
+				return path.Join(tempDirectory, "source/")
+			default:
+				return ""
+			}
+		}
 
-	// Check if file compilation options file exists
+		downloadUrl, err := envsubst.Eval(strings.TrimSpace(download.Url), replaceVars)
-	stat, err := os.Stat(".compilation-options")
 		if err != nil {
-		return nil, nil
+			return err
 		}
-
+		filepath, err := envsubst.Eval(strings.TrimSpace(download.Filepath), replaceVars)
-	// Ensure it is a regular file
-	if !stat.Mode().IsRegular() {
-		return nil, fmt.Errorf("%s is not a regular file", stat.Name())
-	}
-
-	// Read file data
-	data, err := os.ReadFile(stat.Name())
 		if err != nil {
-		return nil, err
+			return err
+		}
+		extractTo, err := envsubst.Eval(strings.TrimSpace(download.ExtractTo), replaceVars)
+		if err != nil {
+			return err
+		}
+		cloneTo, err := envsubst.Eval(strings.TrimSpace(download.CloneTo), replaceVars)
+		if err != nil {
+			return err
 		}
 
-	for _, line := range strings.Split(string(data), "\n") {
+		// Make relative paths absolute
-		// Trim line
+		if extractTo != "" && extractTo[0] != '/' {
-		line = strings.TrimSpace(line)
+			extractTo = path.Join(tempDirectory, extractTo)
+		}
+		// Make relative paths absolute
+		if cloneTo != "" && cloneTo[0] != '/' {
+			cloneTo = path.Join(tempDirectory, cloneTo)
+		}
 
-		// Skip empty lines
+		switch download.Type {
-		if line == "" {
+		case "", "file":
+			if filepath == "" {
+				filepath = path.Join(tempDirectory, path.Base(downloadUrl))
+			}
+			if filepath[0] != '/' {
+				filepath = path.Join(tempDirectory, filepath)
+			}
+
+			err := downloadFile("Downloading file "+path.Base(filepath), downloadUrl, filepath, 0644)
+			if err != nil {
+				return err
+			}
+
+			if download.Checksum != "skip" {
+				f, err := os.Open(filepath)
+				if err != nil {
+					return err
+				}
+				defer f.Close()
+
+				h := sha256.New()
+				_, err = io.Copy(h, f)
+				if err != nil {
+					return err
+				}
+
+				if hex.EncodeToString(h.Sum(nil)) != download.Checksum {
+					fmt.Printf("Downloaded file checksum: %x\n", h.Sum(nil))
+					return fmt.Errorf("downloaded file checksums did not match")
+				}
+			} else {
+				fmt.Println("Skipping checksum checking...")
+			}
+
+			if !download.NoExtract && (strings.Contains(filepath, ".tar") || strings.HasSuffix(filepath, ".tgz")) {
+				cmd := exec.Command("tar", "xf", filepath, "--strip-components="+strconv.Itoa(download.ExtractStripComponents))
+				if verbose {
+					cmd.Args[1] = "xvf"
+				}
+				cmd.Dir = tempDirectory
+				if extractTo != "" {
+					err := os.MkdirAll(extractTo, 0755)
+					if err != nil {
+						return err
+					}
+					cmd.Args = append(cmd.Args, "-C", extractTo)
+				}
+
+				cmd.Stdout = os.Stdout
+				cmd.Stderr = os.Stderr
+
+				err := cmd.Run()
+				if err != nil {
+					return err
+				}
+			} else if !download.NoExtract && strings.HasSuffix(filepath, ".zip") {
+				cmd := exec.Command("unzip", filepath)
+				if extractTo != "" {
+					err := os.MkdirAll(extractTo, 0755)
+					if err != nil {
+						return err
+					}
+					cmd.Args = append(cmd.Args, "-d", extractTo)
+				} else {
+					err := os.Mkdir(path.Join(tempDirectory, strings.TrimSuffix(path.Base(filepath), ".zip")), 0755)
+					if err != nil {
+						return err
+					}
+
+					cmd.Args = append(cmd.Args, "-d", path.Join(tempDirectory, strings.TrimSuffix(path.Base(filepath), ".zip")))
+				}
+
+				cmd.Stdout = os.Stdout
+				cmd.Stderr = os.Stderr
+
+				err := cmd.Run()
+				if err != nil {
+					return err
+				}
+			}
+		case "git":
+			// Replace variables in git branch
+			gitBranch := download.GitBranch
+			gitBranch, err := envsubst.Eval(gitBranch, func(s string) string {
+				switch s {
+				case "BPM_PKG_NAME":
+					return pkgInfo.Name
+				case "BPM_PKG_VERSION":
+					return pkgInfo.Version
+				case "BPM_PKG_URL":
+					return pkgInfo.Url
+				default:
+					return ""
+				}
+			})
+			if err != nil {
+				return err
+			}
+
+			cmd := exec.Command("git", "clone", "--depth=1", downloadUrl)
+			cmd.Dir = tempDirectory
+			if gitBranch != "" {
+				cmd.Args = slices.Insert(cmd.Args, len(cmd.Args)-1, "--branch="+gitBranch)
+			}
+			if cloneTo != "" {
+				err := os.MkdirAll(cloneTo, 0755)
+				if err != nil {
+					return err
+				}
+				cmd.Args = append(cmd.Args, cloneTo)
+			}
+
+			cmd.Stdout = os.Stdout
+			cmd.Stderr = os.Stderr
+
+			err = cmd.Run()
+			if err != nil {
+				return err
+			}
+
+			if download.Checksum != "skip" {
+				cmd := exec.Command("git", "rev-parse", "HEAD")
+				if cloneTo != "" {
+					cmd.Dir = cloneTo
+				} else {
+					cmd.Dir = path.Join(tempDirectory, strings.TrimSuffix(path.Base(downloadUrl), ".git"))
+				}
+
+				branchChecksum, err := cmd.Output()
+				if err != nil {
+					return err
+				}
+
+				if strings.TrimSpace(string(branchChecksum)) != download.Checksum {
+					fmt.Printf("Git branch checksum: %s\n", strings.TrimSpace(string(branchChecksum)))
+					return fmt.Errorf("Cloned git repository checksum did not match")
+				}
+			} else {
+				fmt.Println("Skipping checksum checking...")
+			}
+		default:
+			return fmt.Errorf("unknown download type (%s)", download.Type)
+		}
+	}
+
+	return nil
+}
+
+func showPackageFiles(archiveFilename string) error {
+	// Read BPM archive
+	bpmpkg, err := ReadPackage(archiveFilename)
+	if err != nil {
+		return err
+	}
+
+	// Ensure package type is 'source'
+	if bpmpkg.PkgInfo.Type != "source" {
+		return fmt.Errorf("cannot compile a non-source package")
+	}
+
+	printTarballContent := func(filename string) error {
+		// Get tarball reader for file
+		reader, err := readTarballFile(archiveFilename, filename)
+		if err != nil {
+			return err
+		}
+
+		// Read file content
+		data, err := io.ReadAll(reader.tarReader)
+		if err != nil {
+			return err
+		}
+
+		// Print file name and content
+		fmt.Println("==============================")
+		fmt.Printf("%s: %s\n", bpmpkg.PkgInfo.Name, filename)
+		fmt.Println("==============================")
+		fmt.Printf("%s\n", data)
+
+		// Close reader
+		err = reader.file.Close()
+		if err != nil {
+			return err
+		}
+
+		return nil
+	}
+
+	// Print pkg.info content
+	err = printTarballContent("pkg.info")
+	if err != nil {
+		return err
+	}
+
+	// Print source files contents
+	files, err := listTarballContent(archiveFilename)
+	if err != nil {
+		return err
+	}
+	for _, file := range files {
+		if !strings.HasPrefix(file, "source-files/") {
 			continue
 		}
 
-		// Split line
+		// Print source file content
-		split := strings.SplitN(line, "=", 2)
+		err = printTarballContent(file)
-
+		if err != nil {
-		// Throw error if line isn't valid
+			return err
-		if len(split) < 2 {
+		}
-			return nil, fmt.Errorf("invalid line in compilation-options file: '%s'", line)
 	}
 
-		options[split[0]] = split[1]
+	// Print source.sh content
+	err = printTarballContent("source.sh")
+	if err != nil {
+		return err
 	}
 
-	return options, nil
+	return nil
 }

src/bpmlib/config.go

@@ -8,8 +8,15 @@ import (
 
 type MainBPMConfigStruct struct {
 	IgnorePackages            []string         `yaml:"ignore_packages"`
+	ShowSourcePackageContents string           `yaml:"show_source_package_contents"`
 	CleanupMakeDependencies   bool             `yaml:"cleanup_make_dependencies"`
-	Databases               []*BPMDatabase `yaml:"databases"`
+	Databases                 []configDatabase `yaml:"databases"`
+}
+
+type configDatabase struct {
+	Name     string `yaml:"name"`
+	Source   string `yaml:"source"`
+	Disabled *bool  `yaml:"disabled"`
 }
 
 type CompilationBPMConfigStruct struct {
@@ -25,6 +32,7 @@ func ReadConfig() (err error) {
 
 	// Set default config options
 	MainBPMConfig = MainBPMConfigStruct{
+		ShowSourcePackageContents: "always",
 		CleanupMakeDependencies:   true,
 	}
 

src/bpmlib/databases.go

@@ -1,40 +1,46 @@
 package bpmlib
 
 import (
+	"bytes"
 	"errors"
 	"fmt"
 	"io"
+	"maps"
 	"net/http"
 	"net/url"
 	"os"
 	"path"
+	"slices"
+	"strconv"
 	"strings"
 
 	"gopkg.in/yaml.v3"
 )
 
 type BPMDatabase struct {
-	Name            string `yaml:"name"`
+	DatabaseVersion int                          `yaml:"database_version"`
-	Source          string `yaml:"source"`
+	Entries         map[string]*BPMDatabaseEntry `yaml:"entries"`
-	Disabled        *bool  `yaml:"disabled"`
-	Entries         map[string]*BPMDatabaseEntry
 	VirtualPackages map[string][]string
+	Name            string
+	Source          string
 }
 
 type BPMDatabaseEntry struct {
 	Info          *PackageInfo `yaml:"info"`
-	Download      string       `yaml:"download"`
+	Filepath      string       `yaml:"filepath"`
-	DownloadSize  uint64       `yaml:"download_size"`
+	DownloadSize  int64        `yaml:"download_size"`
-	InstalledSize uint64       `yaml:"installed_size"`
+	InstalledSize int64        `yaml:"installed_size"`
 	Database      *BPMDatabase
 }
 
+var BPMDatabases = make(map[string]*BPMDatabase)
+
 func (db *BPMDatabase) ContainsPackage(pkg string) bool {
 	_, ok := db.Entries[pkg]
 	return ok
 }
 
-func (db *BPMDatabase) ReadLocalDatabase() error {
+func (db *configDatabase) ReadLocalDatabase() error {
 	dbFile := "/var/lib/bpm/databases/" + db.Name + ".bpmdb"
 	if _, err := os.Stat(dbFile); err != nil {
 		return nil
@@ -45,37 +51,25 @@ func (db *BPMDatabase) ReadLocalDatabase() error {
 		return err
 	}
 
-	data := string(bytes)
+	// Unmarshal yaml
-	for _, b := range strings.Split(data, "---") {
+	database := &BPMDatabase{}
-		entry := BPMDatabaseEntry{
+	err = yaml.Unmarshal(bytes, database)
-			Info: &PackageInfo{
-				Name:            "",
-				Description:     "",
-				Version:         "",
-				Revision:        1,
-				Url:             "",
-				License:         "",
-				Arch:            "",
-				Type:            "",
-				Keep:            make([]string, 0),
-				Depends:         make([]string, 0),
-				MakeDepends:     make([]string, 0),
-				OptionalDepends: make([]string, 0),
-				Conflicts:       make([]string, 0),
-				Provides:        make([]string, 0),
-			},
-			Download:      "",
-			DownloadSize:  0,
-			InstalledSize: 0,
-			Database:      db,
-		}
-		err := yaml.Unmarshal([]byte(b), &entry)
 	if err != nil {
 		return err
 	}
 
-		// Create database entries
+	// Initialize struct values
+	database.VirtualPackages = make(map[string][]string)
+	database.Name = db.Name
+	database.Source = db.Source
+
+	for entryName, entry := range database.Entries {
+		entry.Database = database
+
 		if entry.Info.IsSplitPackage() {
+			delete(database.Entries, entryName)
+
+			// Handle split packages
 			for _, splitPkg := range entry.Info.SplitPackages {
 				// Turn split package into json data
 				splitPkgJson, err := yaml.Marshal(splitPkg)
@@ -101,35 +95,33 @@ func (db *BPMDatabase) ReadLocalDatabase() error {
 				splitPkgClone.Url = entry.Info.Url
 
 				// Create entry for split package
-				db.Entries[splitPkg.Name] = &BPMDatabaseEntry{
+				database.Entries[splitPkg.Name] = &BPMDatabaseEntry{
 					Info:          &splitPkgClone,
-					Download:      entry.Download,
+					Filepath:      entry.Filepath,
 					DownloadSize:  entry.DownloadSize,
 					InstalledSize: 0,
-					Database:      db,
+					Database:      database,
 				}
 
 				// Add virtual packages to database
 				for _, p := range splitPkg.Provides {
-					db.VirtualPackages[p] = append(db.VirtualPackages[p], splitPkg.Name)
+					database.VirtualPackages[p] = append(database.VirtualPackages[p], splitPkg.Name)
 				}
 			}
 		} else {
-			// Create entry for package
-			db.Entries[entry.Info.Name] = &entry
-
 			// Add virtual packages to database
 			for _, p := range entry.Info.Provides {
-				db.VirtualPackages[p] = append(db.VirtualPackages[p], entry.Info.Name)
+				database.VirtualPackages[p] = append(database.VirtualPackages[p], entry.Info.Name)
+			}
 		}
 	}
 
-	}
+	BPMDatabases[db.Name] = database
 
 	return nil
 }
 
-func (db *BPMDatabase) SyncLocalDatabaseFile() error {
+func (db *configDatabase) SyncLocalDatabaseFile() error {
 	dbFile := "/var/lib/bpm/databases/" + db.Name + ".bpmdb"
 
 	// Get URL to database
@@ -139,17 +131,29 @@ func (db *BPMDatabase) SyncLocalDatabaseFile() error {
 	}
 
 	// Retrieve data from URL
-	resp, err := http.Get(u)
+	req, err := http.NewRequest("GET", u, nil)
+	if err != nil {
+		return err
+	}
+
+	resp, err := http.DefaultClient.Do(req)
 	if err != nil {
 		return err
 	}
 	defer resp.Body.Close()
 
-	// Load data into byte buffer
+	// Create progress bar
-	buffer, err := io.ReadAll(resp.Body)
+	bar := createProgressBar(resp.ContentLength, "Syncing "+db.Name, false)
+
+	// Copy data
+	var buffer bytes.Buffer
+	_, err = io.Copy(io.MultiWriter(&buffer, bar), resp.Body)
+	if err != nil {
+		return err
+	}
 
 	// Unmarshal data to ensure it is a valid BPM database
-	err = yaml.Unmarshal(buffer, &BPMDatabase{})
+	err = yaml.Unmarshal(buffer.Bytes(), &BPMDatabase{})
 	if err != nil {
 		return fmt.Errorf("could not decode database: %s", err)
 	}
@@ -167,17 +171,13 @@ func (db *BPMDatabase) SyncLocalDatabaseFile() error {
 	}
 	defer out.Close()
 
-	_, err = out.Write(buffer)
+	_, err = out.Write(buffer.Bytes())
 
 	return nil
 }
 
 func ReadLocalDatabaseFiles() (err error) {
 	for _, db := range MainBPMConfig.Databases {
-		// Initialize struct values
-		db.Entries = make(map[string]*BPMDatabaseEntry)
-		db.VirtualPackages = make(map[string][]string)
-
 		// Read database
 		err = db.ReadLocalDatabase()
 		if err != nil {
@@ -188,15 +188,6 @@ func ReadLocalDatabaseFiles() (err error) {
 	return nil
 }
 
-func GetDatabase(name string) *BPMDatabase {
-	for _, db := range MainBPMConfig.Databases {
-		if db.Name == name {
-			return db
-		}
-	}
-	return nil
-}
-
 func GetDatabaseEntry(str string) (*BPMDatabaseEntry, *BPMDatabase, error) {
 	split := strings.Split(str, "/")
 	if len(split) == 1 {
@@ -204,7 +195,7 @@ func GetDatabaseEntry(str string) (*BPMDatabaseEntry, *BPMDatabase, error) {
 		if pkgName == "" {
 			return nil, nil, errors.New("could not find database entry for this package")
 		}
-		for _, db := range MainBPMConfig.Databases {
+		for _, db := range BPMDatabases {
 			if db.ContainsPackage(pkgName) {
 				return db.Entries[pkgName], db, nil
 			}
@@ -216,7 +207,7 @@ func GetDatabaseEntry(str string) (*BPMDatabaseEntry, *BPMDatabase, error) {
 		if dbName == "" || pkgName == "" {
 			return nil, nil, errors.New("could not find database entry for this package")
 		}
-		db := GetDatabase(dbName)
+		db := BPMDatabases[dbName]
 		if db == nil || !db.ContainsPackage(pkgName) {
 			return nil, nil, errors.New("could not find database entry for this package")
 		}
@@ -227,7 +218,7 @@ func GetDatabaseEntry(str string) (*BPMDatabaseEntry, *BPMDatabase, error) {
 }
 
 func FindReplacement(pkg string) *BPMDatabaseEntry {
-	for _, db := range MainBPMConfig.Databases {
+	for _, db := range BPMDatabases {
 		for _, entry := range db.Entries {
 			for _, replaced := range entry.Info.Replaces {
 				if replaced == pkg {
@@ -241,11 +232,10 @@ func FindReplacement(pkg string) *BPMDatabaseEntry {
 }
 
 func ResolveVirtualPackage(vpkg string) *BPMDatabaseEntry {
-	for _, db := range MainBPMConfig.Databases {
+	for _, db := range BPMDatabases {
 		if v, ok := db.VirtualPackages[vpkg]; ok {
-			for _, pkg := range v {
+			slices.Sort(v)
-				return db.Entries[pkg]
+			return db.Entries[v[0]]
-			}
 		}
 	}
 
@@ -253,30 +243,164 @@ func ResolveVirtualPackage(vpkg string) *BPMDatabaseEntry {
 }
 
 func (db *BPMDatabase) FetchPackage(pkg string) (string, error) {
+	// Check if package exists in database
 	if !db.ContainsPackage(pkg) {
 		return "", errors.New("could not fetch package '" + pkg + "'")
 	}
+
+	// Get package url from database
 	entry := db.Entries[pkg]
-	URL, err := url.JoinPath(db.Source, entry.Download)
+	u, err := url.JoinPath(db.Source, entry.Filepath)
 	if err != nil {
 		return "", err
 	}
-	resp, err := http.Get(URL)
-	if err != nil {
-		return "", err
-	}
-	defer resp.Body.Close()
 
-	err = os.MkdirAll("/var/cache/bpm/fetched/", 0755)
+	// Download package from url
+	err = downloadFile("Downloading "+entry.Info.Name, u, path.Join("/var/cache/bpm/fetched/", path.Base(entry.Filepath)), 0644)
 	if err != nil {
 		return "", err
 	}
-	out, err := os.Create("/var/cache/bpm/fetched/" + path.Base(entry.Download))
-	if err != nil {
-		return "", err
-	}
-	defer out.Close()
 
-	_, err = io.Copy(out, resp.Body)
+	return path.Join("/var/cache/bpm/fetched/", path.Base(entry.Filepath)), nil
-	return "/var/cache/bpm/fetched/" + path.Base(entry.Download), nil
+}
+
+func (entry *BPMDatabaseEntry) GetEntryDependants() (dependants []string) {
+	dependantsMap := make(map[string][]string)
+	for _, db := range BPMDatabases {
+		for _, e := range db.Entries {
+			if slices.Contains(e.Info.Depends, entry.Info.Name) {
+				dependantsMap[e.Info.Name] = append(dependantsMap[e.Info.Name], e.Database.Name)
+			}
+		}
+	}
+
+	// Get keys
+	keySlice := slices.Collect(maps.Keys(dependantsMap))
+	slices.Sort(keySlice)
+
+	// Add all dependant entries to slice in alphabetical order
+	for _, entryName := range keySlice {
+		dbs := dependantsMap[entryName]
+		if len(dbs) > 1 {
+			for _, db := range dbs {
+				dependants = append(dependants, db+"/"+entryName)
+			}
+		} else {
+			dependants = append(dependants, entryName)
+		}
+	}
+
+	return dependants
+}
+
+func (entry *BPMDatabaseEntry) GetEntryOptionalDependants() (dependants []string) {
+	dependantsMap := make(map[string][]string)
+	for _, db := range BPMDatabases {
+		for _, e := range db.Entries {
+			if slices.Contains(e.Info.OptionalDepends, entry.Info.Name) {
+				dependantsMap[e.Info.Name] = append(dependantsMap[e.Info.Name], e.Database.Name)
+			}
+		}
+	}
+
+	// Get keys
+	keySlice := slices.Collect(maps.Keys(dependantsMap))
+	slices.Sort(keySlice)
+
+	// Add all dependant entries to slice in alphabetical order
+	for _, entryName := range keySlice {
+		dbs := dependantsMap[entryName]
+		if len(dbs) > 1 {
+			for _, db := range dbs {
+				dependants = append(dependants, db+"/"+entryName)
+			}
+		} else {
+			dependants = append(dependants, entryName)
+		}
+	}
+
+	return dependants
+}
+
+func (entry *BPMDatabaseEntry) CreateReadableInfo(rootDir string, humanReadableSize bool) string {
+	ret := make([]string, 0)
+	appendArray := func(label string, array []string, sort bool) {
+		if len(array) == 0 {
+			return
+		}
+
+		if sort {
+			// Sort array
+			slices.Sort(array)
+		}
+
+		ret = append(ret, fmt.Sprintf("%s: %s", label, strings.Join(array, ", ")))
+	}
+
+	ret = append(ret, "Name: "+entry.Info.Name)
+	ret = append(ret, "Database: "+entry.Database.Name)
+	ret = append(ret, "Description: "+entry.Info.Description)
+	ret = append(ret, "Version: "+entry.Info.GetFullVersion())
+	if entry.Info.Url != "" {
+		ret = append(ret, "URL: "+entry.Info.Url)
+	}
+	if entry.Info.License != "" {
+		ret = append(ret, "License: "+entry.Info.License)
+	}
+	ret = append(ret, "Architecture: "+entry.Info.Arch)
+	if entry.Info.Type == "source" && entry.Info.OutputArch != "" && entry.Info.OutputArch != GetArch() {
+		ret = append(ret, "Output architecture: "+entry.Info.OutputArch)
+	}
+	ret = append(ret, "Type: "+entry.Info.Type)
+	appendArray("Dependencies", entry.Info.Depends, true)
+	if entry.Info.Type == "source" {
+		appendArray("Make Dependencies", entry.Info.MakeDepends, true)
+	}
+	appendArray("Optional dependencies", entry.Info.OptionalDepends, true)
+	dependants := entry.GetEntryDependants()
+	if len(dependants) > 0 {
+		appendArray("Dependant packages", dependants, false)
+	}
+	optionalDependants := entry.GetEntryOptionalDependants()
+	if len(optionalDependants) > 0 {
+		appendArray("Optionally dependant packages", optionalDependants, false)
+	}
+	appendArray("Conflicting packages", entry.Info.Conflicts, true)
+	appendArray("Provided packages", entry.Info.Provides, true)
+	appendArray("Replaces packages", entry.Info.Replaces, true)
+
+	if entry.Info.Type == "source" && len(entry.Info.SplitPackages) != 0 {
+		splitPkgs := make([]string, len(entry.Info.SplitPackages))
+		for i, splitPkgInfo := range entry.Info.SplitPackages {
+			splitPkgs[i] = splitPkgInfo.Name
+		}
+		appendArray("Split Packages", splitPkgs, true)
+	}
+
+	if rootDir != "" && IsPackageInstalled(entry.Info.Name, rootDir) {
+		installationReason := GetInstallationReason(entry.Info.Name, rootDir)
+		var installationReasonString string
+		switch installationReason {
+		case InstallationReasonManual:
+			installationReasonString = "Manual"
+		case InstallationReasonDependency:
+			installationReasonString = "Dependency"
+		case InstallationReasonMakeDependency:
+			installationReasonString = "Make dependency"
+		default:
+			installationReasonString = "Unknown"
+		}
+		ret = append(ret, "Installation Reason: "+installationReasonString)
+	}
+	if entry.Info.Type == "binary" {
+		installedSize := entry.InstalledSize
+		var installedSizeStr string
+		if humanReadableSize {
+			installedSizeStr = BytesToHumanReadable(installedSize)
+		} else {
+			installedSizeStr = strconv.FormatInt(installedSize, 10)
+		}
+		ret = append(ret, "Installed size: "+installedSizeStr)
+	}
+	return strings.Join(ret, "\n")
 }

src/bpmlib/dependencies.go

@@ -1,7 +1,6 @@
 package bpmlib
 
 import (
-	"errors"
 	"fmt"
 	"slices"
 )
@@ -31,7 +30,7 @@ func (pkgInfo *PackageInfo) GetDependencies(includeMakeDepends, includeOptionalD
 			}) {
 				allDepends = append(allDepends, pkgInstallationReason{
 					PkgName:            depend,
-					InstallationReason: InstallationReasonDependency,
+					InstallationReason: InstallationReasonManual,
 				})
 			}
 		}
@@ -48,26 +47,32 @@ func (pkgInfo *PackageInfo) GetDependencies(includeMakeDepends, includeOptionalD
 			}
 		}
 	}
+
+	// Skip ignored packages
+	allDepends = slices.DeleteFunc(allDepends, func(depend pkgInstallationReason) bool {
+		return slices.Contains(MainBPMConfig.IgnorePackages, depend.PkgName)
+	})
+
 	return allDepends
 }
 
-func (pkgInfo *PackageInfo) GetAllDependencies(includeMakeDepends, includeOptionalDepends bool, rootDir string) (resolved []string) {
+func (pkgInfo *PackageInfo) GetDependenciesRecursive(includeMakeDepends bool, rootDir string) (resolved []string) {
 	// Initialize slices
 	resolved = make([]string, 0)
 	unresolved := make([]string, 0)
 
 	// Call unexported function
-	pkgInfo.getAllDependencies(&resolved, &unresolved, includeMakeDepends, includeOptionalDepends, rootDir)
+	pkgInfo.getDependenciesRecursive(&resolved, &unresolved, includeMakeDepends, rootDir)
 
 	return resolved
 }
 
-func (pkgInfo *PackageInfo) getAllDependencies(resolved *[]string, unresolved *[]string, includeMakeDepends, includeOptionalDepends bool, rootDir string) {
+func (pkgInfo *PackageInfo) getDependenciesRecursive(resolved *[]string, unresolved *[]string, includeMakeDepends bool, rootDir string) {
 	// Add current package name to unresolved slice
 	*unresolved = append(*unresolved, pkgInfo.Name)
 
 	// Loop through all dependencies
-	for _, pkgIR := range pkgInfo.GetDependencies(includeMakeDepends, includeOptionalDepends) {
+	for _, pkgIR := range pkgInfo.GetDependencies(includeMakeDepends, false) {
 		depend := pkgIR.PkgName
 
 		if isVirtual, p := IsVirtualPackage(depend, rootDir); isVirtual {
@@ -86,7 +91,7 @@ func (pkgInfo *PackageInfo) getAllDependencies(resolved *[]string, unresolved *[
 			dependInfo := GetPackageInfo(depend, rootDir)
 
 			if dependInfo != nil {
-				dependInfo.getAllDependencies(resolved, unresolved, includeMakeDepends, includeOptionalDepends, rootDir)
+				dependInfo.getDependenciesRecursive(resolved, unresolved, includeMakeDepends, rootDir)
 			}
 		}
 	}
@@ -155,7 +160,7 @@ func resolvePackageDependenciesFromDatabase(resolved *[]pkgInstallationReason, u
 		}
 
 		// Resolve the dependencies of this dependency
-		resolvePackageDependenciesFromDatabase(resolved, unresolved, entry.Info, checkMake, checkOptional, ignoreInstalled, verbose, rootDir)
+		resolvePackageDependenciesFromDatabase(resolved, unresolved, entry.Info, checkMake, false, ignoreInstalled, verbose, rootDir)
 
 		// Move dependency from the unresolved slice to the resolved slice
 		if !slices.ContainsFunc(*resolved, func(p pkgInstallationReason) bool {
@@ -170,56 +175,76 @@ func resolvePackageDependenciesFromDatabase(resolved *[]pkgInstallationReason, u
 	}
 }
 
-func GetPackageDependants(pkgName string, rootDir string) ([]string, error) {
+func (pkgInfo *PackageInfo) GetPackageDependants(rootDir string) (dependants []string) {
-	ret := make([]string, 0)
-
-	// Get BPM package
-	pkg := GetPackage(pkgName, rootDir)
-	if pkg == nil {
-		return nil, errors.New("package not found: " + pkgName)
-	}
-
 	// Get installed package names
-	pkgs, err := GetInstalledPackages(rootDir)
+	pkgs, ok := localPackageInformation[rootDir]
-	if err != nil {
+	if !ok {
-		return nil, errors.New("could not get installed packages")
+		return nil
 	}
 
 	// Loop through all installed packages
-	for _, installedPkgName := range pkgs {
+	for _, installedPkg := range pkgs {
-		// Get installed BPM package
-		installedPkg := GetPackage(installedPkgName, rootDir)
-		if installedPkg == nil {
-			return nil, errors.New("package not found: " + installedPkgName)
-		}
-
 		// Skip iteration if comparing the same packages
-		if installedPkg.PkgInfo.Name == pkgName {
+		if installedPkg.Name == pkgInfo.Name {
 			continue
 		}
 
-		// Get installed package dependencies
-		dependencies := installedPkg.PkgInfo.GetDependencies(false, true)
-
 		// Add installed package to list if its dependencies include pkgName
-		if slices.ContainsFunc(dependencies, func(p pkgInstallationReason) bool {
+		if slices.ContainsFunc(installedPkg.Depends, func(n string) bool {
-			return p.PkgName == pkgName
+			return n == pkgInfo.Name
 		}) {
-			ret = append(ret, installedPkgName)
+			dependants = append(dependants, installedPkg.Name)
 			continue
 		}
 
 		// Loop through each virtual package
-		for _, vpkg := range pkg.PkgInfo.Provides {
+		for _, vpkg := range pkgInfo.Provides {
 			// Add installed package to list if its dependencies contain a provided virtual package
-			if slices.ContainsFunc(dependencies, func(p pkgInstallationReason) bool {
+			if slices.ContainsFunc(installedPkg.Depends, func(n string) bool {
-				return p.PkgName == vpkg
+				return n == vpkg
 			}) {
-				ret = append(ret, installedPkgName)
+				dependants = append(dependants, installedPkg.Name)
 				break
 			}
 		}
 	}
 
-	return ret, nil
+	return dependants
+}
+
+func (pkgInfo *PackageInfo) GetPackageOptionalDependants(rootDir string) (dependants []string) {
+	// Get installed package names
+	pkgs, ok := localPackageInformation[rootDir]
+	if !ok {
+		return nil
+	}
+
+	// Loop through all installed packages
+	for _, installedPkg := range pkgs {
+		// Skip iteration if comparing the same packages
+		if installedPkg.Name == pkgInfo.Name {
+			continue
+		}
+
+		// Add installed package to list if its optional dependencies include pkgName
+		if slices.ContainsFunc(installedPkg.OptionalDepends, func(n string) bool {
+			return n == pkgInfo.Name
+		}) {
+			dependants = append(dependants, installedPkg.Name)
+			continue
+		}
+
+		// Loop through each virtual package
+		for _, vpkg := range pkgInfo.Provides {
+			// Add installed package to list if its optional dependencies contain a provided virtual package
+			if slices.ContainsFunc(installedPkg.OptionalDepends, func(n string) bool {
+				return n == vpkg
+			}) {
+				dependants = append(dependants, installedPkg.Name)
+				break
+			}
+		}
+	}
+
+	return dependants
 }

src/bpmlib/errors.go

@@ -40,3 +40,11 @@ type PackageScriptErr struct {
 func (e PackageScriptErr) Error() string {
 	return fmt.Sprintf("could not execute package script (%s) for package (%s): %s", e.packageScript, e.packageName, e.err)
 }
+
+type PackageRemovalDependencyErr struct {
+	RequiredPackages map[string][]string
+}
+
+func (e PackageRemovalDependencyErr) Error() string {
+	return "removing these package would break other installed packages"
+}

src/bpmlib/general.go

@@ -4,6 +4,7 @@ import (
 	"errors"
 	"fmt"
 	"log"
+	"maps"
 	"os"
 	"path"
 	"slices"
@@ -20,7 +21,6 @@ const (
 
 // InstallPackages installs the specified packages into the given root directory by fetching them from databases or directly from local bpm archives
 func InstallPackages(rootDir string, forceInstallationReason InstallationReason, reinstallMethod ReinstallMethod, installOptionalDependencies, forceInstallation, verbose bool, packages ...string) (operation *BPMOperation, err error) {
-
 	// Setup operation struct
 	operation = &BPMOperation{
 		Actions:           make([]OperationAction, 0),
@@ -30,6 +30,9 @@ func InstallPackages(rootDir string, forceInstallationReason InstallationReason,
 		compiledPackages:  make(map[string]string),
 	}
 
+	// Remove duplicates from packages
+	packages = removeDuplicates(packages)
+
 	// Resolve packages
 	pkgsNotFound := make([]string, 0)
 	for _, pkg := range packages {
@@ -144,12 +147,9 @@ func InstallPackages(rootDir string, forceInstallationReason InstallationReason,
 	operation.ReplaceObsoletePackages()
 
 	// Check for conflicts
-	conflicts, err := operation.CheckForConflicts()
+	conflicts := operation.CheckForConflicts()
-	if err != nil {
-		return nil, fmt.Errorf("could not complete package conflict check: %s", err)
-	}
 	if len(conflicts) > 0 {
-		err = nil
+		err = fmt.Errorf("conflicts detected")
 		for pkg, conflict := range conflicts {
 			err = errors.Join(err, PackageConflictErr{pkg, conflict})
 		}
@@ -164,14 +164,14 @@ func InstallPackages(rootDir string, forceInstallationReason InstallationReason,
 	if rootDir != "/" {
 		sourcePackages := make([]string, 0)
 		for _, action := range operation.Actions {
-			switch action.(type) {
+			switch action := action.(type) {
 			case *InstallPackageAction:
-				if action.(*InstallPackageAction).BpmPackage.PkgInfo.Type == "source" {
+				if action.BpmPackage.PkgInfo.Type == "source" {
-					sourcePackages = append(sourcePackages, action.(*InstallPackageAction).BpmPackage.PkgInfo.Name)
+					sourcePackages = append(sourcePackages, action.BpmPackage.PkgInfo.Name)
 				}
 			case *FetchPackageAction:
-				if action.(*FetchPackageAction).DatabaseEntry.Info.Type == "source" {
+				if action.DatabaseEntry.Info.Type == "source" {
-					sourcePackages = append(sourcePackages, action.(*FetchPackageAction).DatabaseEntry.Info.Name)
+					sourcePackages = append(sourcePackages, action.DatabaseEntry.Info.Name)
 				}
 			}
 		}
@@ -186,7 +186,7 @@ func InstallPackages(rootDir string, forceInstallationReason InstallationReason,
 }
 
 // RemovePackages removes the specified packages from the given root directory
-func RemovePackages(rootDir string, removeUnusedPackagesOnly, cleanupDependencies bool, packages ...string) (operation *BPMOperation, err error) {
+func RemovePackages(rootDir string, force, cleanupDependencies bool, packages ...string) (operation *BPMOperation, err error) {
 	operation = &BPMOperation{
 		Actions:           make([]OperationAction, 0),
 		UnresolvedDepends: make([]string, 0),
@@ -195,30 +195,71 @@ func RemovePackages(rootDir string, removeUnusedPackagesOnly, cleanupDependencie
 		compiledPackages:  make(map[string]string),
 	}
 
+	// Remove duplicates from packages
+	packages = removeDuplicates(packages)
+
 	// Search for packages
 	for _, pkg := range packages {
 		bpmpkg := GetPackage(pkg, rootDir)
+		if isVirutal, vpkg := IsVirtualPackage(pkg, rootDir); isVirutal {
+			bpmpkg = GetPackage(vpkg, rootDir)
+		}
 		if bpmpkg == nil {
 			continue
 		}
 		operation.AppendAction(&RemovePackageAction{BpmPackage: bpmpkg})
 	}
 
-	// Do not remove packages which other packages depend on
-	if removeUnusedPackagesOnly {
-		err := operation.RemoveNeededPackages()
-		if err != nil {
-			return nil, fmt.Errorf("could not skip needed packages: %s", err)
-		}
-	}
-
 	// Do package cleanup
 	if cleanupDependencies {
-		err := operation.Cleanup(true)
+		err := operation.Cleanup(MainBPMConfig.CleanupMakeDependencies)
 		if err != nil {
 			return nil, fmt.Errorf("could not perform cleanup for operation: %s", err)
 		}
 	}
+
+	// Return error if other packages depend on removed ones
+	if !force {
+		// Get packages and their dependants
+		packageDepndants := make(map[string][]string, 0)
+		for _, action := range operation.Actions {
+			// Skip package if ignored
+			if slices.Contains(MainBPMConfig.IgnorePackages, action.(*RemovePackageAction).BpmPackage.PkgInfo.Name) {
+				continue
+			}
+
+			dependants := action.(*RemovePackageAction).BpmPackage.PkgInfo.GetPackageDependants(rootDir)
+			packageDepndants[action.(*RemovePackageAction).BpmPackage.PkgInfo.Name] = dependants
+		}
+
+		// Remove dependant packages from map if they are to be removed by this operation
+		for pkg, required := range packageDepndants {
+			required = slices.DeleteFunc(required, func(pkgName string) bool {
+				_, ok := packageDepndants[pkgName]
+				return ok
+			})
+			packageDepndants[pkg] = required
+		}
+
+		// Remove dependant packages if ignored
+		for pkg, required := range packageDepndants {
+			required = slices.DeleteFunc(required, func(pkgName string) bool {
+				return slices.Contains(MainBPMConfig.IgnorePackages, pkgName)
+			})
+			packageDepndants[pkg] = required
+		}
+
+		// Remove empty keys from map
+		maps.DeleteFunc(packageDepndants, func(pkg string, required []string) bool {
+			return len(required) == 0
+		})
+
+		// Return error
+		if len(packageDepndants) != 0 {
+			return nil, PackageRemovalDependencyErr{RequiredPackages: packageDepndants}
+		}
+	}
+
 	return operation, nil
 }
 
@@ -324,7 +365,7 @@ func CleanupCache(rootDir string, cleanupCompilationFiles, cleanupCompiledPackag
 }
 
 // UpdatePackages fetches the newest versions of all installed packages from
-func UpdatePackages(rootDir string, syncDatabase bool, installOptionalDependencies, forceInstallation, verbose bool) (operation *BPMOperation, err error) {
+func UpdatePackages(rootDir string, syncDatabase bool, allowDowngrades bool, installOptionalDependencies, forceInstallation, verbose bool) (operation *BPMOperation, err error) {
 	// Sync databases
 	if syncDatabase {
 		err := SyncDatabase(verbose)
@@ -377,8 +418,8 @@ func UpdatePackages(rootDir string, syncDatabase bool, installOptionalDependenci
 		if installedInfo == nil {
 			return nil, fmt.Errorf("could not get package info for package (%s)", pkg)
 		} else {
-			comparison := ComparePackageVersions(*entry.Info, *installedInfo)
+			comparison := CompareVersions(entry.Info.GetFullVersion(), installedInfo.GetFullVersion())
-			if comparison > 0 {
+			if (!allowDowngrades && comparison > 0) || (allowDowngrades && comparison != 0) {
 				operation.AppendAction(&FetchPackageAction{
 					InstallationReason: GetInstallationReason(pkg, rootDir),
 					DatabaseEntry:      entry,
@@ -402,6 +443,21 @@ func UpdatePackages(rootDir string, syncDatabase bool, installOptionalDependenci
 
 	// Replace obsolete packages
 	operation.ReplaceObsoletePackages()
+
+	// Check for conflicts
+	conflicts := operation.CheckForConflicts()
+	if len(conflicts) > 0 {
+		err = fmt.Errorf("conflicts detected")
+		for pkg, conflict := range conflicts {
+			err = errors.Join(err, PackageConflictErr{pkg, conflict})
+		}
+		if !forceInstallation {
+			return nil, err
+		} else {
+			log.Printf("Warning: %s", err)
+		}
+	}
+
 	return operation, nil
 }
 

src/bpmlib/go.mod

@@ -1,8 +1,17 @@
-module git.enumerated.dev/bubble-package-manager/bpm/src/bpmlib
+module github.com/EnumeratedDev/bpm/src/bpmlib
 
-go 1.23
+go 1.24.0
 
 require (
+	github.com/drone/envsubst v1.0.3
 	github.com/knqyf263/go-rpm-version v0.0.0-20240918084003-2afd7dc6a38f
+	github.com/schollz/progressbar/v3 v3.18.0
 	gopkg.in/yaml.v3 v3.0.1
 )
+
+require (
+	github.com/mitchellh/colorstring v0.0.0-20190213212951-d06e56a500db // indirect
+	github.com/rivo/uniseg v0.4.7 // indirect
+	golang.org/x/sys v0.37.0 // indirect
+	golang.org/x/term v0.36.0 // indirect
+)

src/bpmlib/go.sum

@@ -1,5 +1,29 @@
+github.com/chengxilo/virtualterm v1.0.4 h1:Z6IpERbRVlfB8WkOmtbHiDbBANU7cimRIof7mk9/PwM=
+github.com/chengxilo/virtualterm v1.0.4/go.mod h1:DyxxBZz/x1iqJjFxTFcr6/x+jSpqN0iwWCOK1q10rlY=
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/drone/envsubst v1.0.3 h1:PCIBwNDYjs50AsLZPYdfhSATKaRg/FJmDc2D6+C2x8g=
+github.com/drone/envsubst v1.0.3/go.mod h1:N2jZmlMufstn1KEqvbHjw40h1KyTmnVzHcSc9bFiJ2g=
+github.com/google/go-cmp v0.2.0 h1:+dTQ8DZQJz0Mb/HjFlkptS1FeQ4cWSnN941F8aEG4SQ=
+github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M=
 github.com/knqyf263/go-rpm-version v0.0.0-20240918084003-2afd7dc6a38f h1:xt29M2T6STgldg+WEP51gGePQCsQvklmP2eIhPIBK3g=
 github.com/knqyf263/go-rpm-version v0.0.0-20240918084003-2afd7dc6a38f/go.mod h1:i4sF0l1fFnY1aiw08QQSwVAFxHEm311Me3WsU/X7nL0=
+github.com/mattn/go-runewidth v0.0.16 h1:E5ScNMtiwvlvB5paMFdw9p4kSQzbXFikJ5SQO6TULQc=
+github.com/mattn/go-runewidth v0.0.16/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
+github.com/mitchellh/colorstring v0.0.0-20190213212951-d06e56a500db h1:62I3jR2EmQ4l5rM/4FEfDWcRD+abF5XlKShorW5LRoQ=
+github.com/mitchellh/colorstring v0.0.0-20190213212951-d06e56a500db/go.mod h1:l0dey0ia/Uv7NcFFVbCLtqEBQbrT4OCwCSKTEv6enCw=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=
+github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
+github.com/schollz/progressbar/v3 v3.18.0 h1:uXdoHABRFmNIjUfte/Ex7WtuyVslrw2wVPQmCN62HpA=
+github.com/schollz/progressbar/v3 v3.18.0/go.mod h1:IsO3lpbaGuzh8zIMzgY3+J8l4C8GjO0Y9S69eFvNsec=
+github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
+github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+golang.org/x/sys v0.37.0 h1:fdNQudmxPjkdUTPnLn5mdQv7Zwvbvpaxqs831goi9kQ=
+golang.org/x/sys v0.37.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
+golang.org/x/term v0.36.0 h1:zMPR+aF8gfksFprF/Nc/rd1wRS1EI6nDBGyWAvDzx2Q=
+golang.org/x/term v0.36.0/go.mod h1:Qu394IJq6V6dCBRgwqshf3mPF85AqzYEzofzRdZkWss=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=

src/bpmlib/installed_packages.go

@@ -1,7 +1,6 @@
 package bpmlib
 
 import (
-	"errors"
 	"fmt"
 	"os"
 	"path"
@@ -10,7 +9,7 @@ import (
 	"strings"
 )
 
-var localPackageInformation map[string]map[string]*BPMPackage = make(map[string]map[string]*BPMPackage)
+var localPackageInformation map[string]map[string]*PackageInfo = make(map[string]map[string]*PackageInfo)
 
 func initializeLocalPackageInformation(rootDir string) (err error) {
 	// Return if information is already initialized
@@ -18,7 +17,7 @@ func initializeLocalPackageInformation(rootDir string) (err error) {
 		return nil
 	}
 
-	tempPackageInformation := make(map[string]*BPMPackage)
+	tempPackageInformation := make(map[string]*PackageInfo)
 
 	// Get path to installed package information directory
 	installedDir := path.Join(rootDir, "var/lib/bpm/installed/")
@@ -26,7 +25,7 @@ func initializeLocalPackageInformation(rootDir string) (err error) {
 	// Get directory content
 	items, err := os.ReadDir(installedDir)
 	if os.IsNotExist(err) {
-		localPackageInformation[rootDir] = make(map[string]*BPMPackage)
+		localPackageInformation[rootDir] = make(map[string]*PackageInfo)
 		return nil
 	}
 	if err != nil {
@@ -50,14 +49,8 @@ func initializeLocalPackageInformation(rootDir string) (err error) {
 			return err
 		}
 
-		// Read package files
-		files := getPackageFiles(info.Name, rootDir)
-
 		// Add package to slice
-		tempPackageInformation[info.Name] = &BPMPackage{
+		tempPackageInformation[info.Name] = info
-			PkgInfo:  info,
-			PkgFiles: files,
-		}
 	}
 
 	localPackageInformation[rootDir] = tempPackageInformation
@@ -72,10 +65,13 @@ func GetInstalledPackages(rootDir string) (ret []string, err error) {
 	}
 
 	// Loop through each package and add it to slice
-	for _, bpmpkg := range localPackageInformation[rootDir] {
+	for _, pkgInfo := range localPackageInformation[rootDir] {
-		ret = append(ret, bpmpkg.PkgInfo.Name)
+		ret = append(ret, pkgInfo.Name)
 	}
 
+	// Sort packages
+	slices.Sort(ret)
+
 	return ret, nil
 }
 
@@ -92,18 +88,6 @@ func IsPackageInstalled(pkg, rootDir string) bool {
 	return true
 }
 
-func GetPackageInfo(pkg string, rootDir string) *PackageInfo {
-	// Get BPM package
-	bpmpkg := GetPackage(pkg, rootDir)
-
-	// Return nil if not found
-	if bpmpkg == nil {
-		return nil
-	}
-
-	return bpmpkg.PkgInfo
-}
-
 func IsVirtualPackage(pkg, rootDir string) (bool, string) {
 	pkgs, err := GetInstalledPackages(rootDir)
 	if err != nil {
@@ -144,15 +128,27 @@ func IsPackageProvided(pkg, rootDir string) bool {
 	return false
 }
 
-func GetPackage(pkg, rootDir string) *BPMPackage {
+func GetPackageInfo(pkg string, rootDir string) *PackageInfo {
 	err := initializeLocalPackageInformation(rootDir)
 	if err != nil {
 		return nil
 	}
 
-	bpmpkg := localPackageInformation[rootDir][pkg]
+	return localPackageInformation[rootDir][pkg]
+}
 
-	return bpmpkg
+func GetPackage(pkg, rootDir string) *BPMPackage {
+	pkgInfo := GetPackageInfo(pkg, rootDir)
+	if pkgInfo == nil {
+		return nil
+	}
+
+	files := getPackageFiles(pkgInfo.Name, rootDir)
+
+	return &BPMPackage{
+		PkgInfo:  pkgInfo,
+		PkgFiles: files,
+	}
 }
 
 func GetAllPackageFiles(rootDir string, excludePackages ...string) (map[string][]*BPMPackage, error) {
@@ -169,14 +165,11 @@ func GetAllPackageFiles(rootDir string, excludePackages ...string) (map[string][
 		}
 		bpmpkg := GetPackage(pkgName, rootDir)
 		if bpmpkg == nil {
-			return nil, errors.New(fmt.Sprintf("could not get BPM package (%s)", pkgName))
+			return nil, fmt.Errorf("could not get BPM package (%s)", pkgName)
 		}
 		for _, entry := range bpmpkg.PkgFiles {
-			if _, ok := ret[entry.Path]; ok {
 			ret[entry.Path] = append(ret[entry.Path], bpmpkg)
-			} else {
+
-				ret[entry.Path] = []*BPMPackage{bpmpkg}
-			}
 		}
 	}
 
@@ -226,7 +219,7 @@ func getPackageFiles(pkg, rootDir string) []*PackageFileEntry {
 		if err != nil {
 			return nil
 		}
-		size, err := strconv.ParseUint(stringEntry[len(stringEntry)-1], 0, 64)
+		size, err := strconv.ParseInt(stringEntry[len(stringEntry)-1], 0, 64)
 		if err != nil {
 			return nil
 		}

src/bpmlib/net.go

@@ -0,0 +1,58 @@
+package bpmlib
+
+import (
+	"fmt"
+	"io"
+	"net/http"
+	"os"
+	"path"
+	"strings"
+)
+
+func downloadFile(barText, u, filepath string, perm os.FileMode) error {
+	if strings.HasSuffix(filepath, "/") {
+		return fmt.Errorf("Filepath must not end in '/'")
+	}
+
+	req, err := http.NewRequest("GET", u, nil)
+	if err != nil {
+		return err
+	}
+
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+
+	// Create parent directories
+	err = os.MkdirAll(path.Dir(filepath), 0755)
+	if err != nil {
+		return err
+	}
+
+	// Create file
+	file, err := os.Create(filepath)
+	if err != nil {
+		return err
+	}
+	defer file.Close()
+
+	// Create progress bar
+	bar := createProgressBar(resp.ContentLength, barText, false)
+	defer bar.Close()
+
+	// Copy data
+	_, err = io.Copy(io.MultiWriter(file, bar), resp.Body)
+	if err != nil {
+		return err
+	}
+
+	// Set file permissions
+	err = file.Chmod(perm)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}

src/bpmlib/operations.go

@@ -8,6 +8,7 @@ import (
 	"path"
 	"slices"
 	"strings"
+	"text/tabwriter"
 )
 
 type BPMOperation struct {
@@ -15,7 +16,9 @@ type BPMOperation struct {
 	UnresolvedDepends []string
 	Changes           map[string]string
 	RootDir           string
+
 	compiledPackages   map[string]string
+	hasFetchedPackages bool
 }
 
 func (operation *BPMOperation) ActionsContainPackage(pkg string) bool {
@@ -84,8 +87,8 @@ func (operation *BPMOperation) RemoveAction(pkg, actionType string) {
 	})
 }
 
-func (operation *BPMOperation) GetTotalDownloadSize() uint64 {
+func (operation *BPMOperation) GetTotalDownloadSize() int64 {
-	var ret uint64 = 0
+	var ret int64 = 0
 	for _, action := range operation.Actions {
 		if action.GetActionType() == "fetch" {
 			ret += action.(*FetchPackageAction).DatabaseEntry.DownloadSize
@@ -94,8 +97,8 @@ func (operation *BPMOperation) GetTotalDownloadSize() uint64 {
 	return ret
 }
 
-func (operation *BPMOperation) GetTotalInstalledSize() uint64 {
+func (operation *BPMOperation) GetTotalInstalledSize() int64 {
-	var ret uint64 = 0
+	var ret int64 = 0
 	for _, action := range operation.Actions {
 		if action.GetActionType() == "install" {
 			ret += action.(*InstallPackageAction).BpmPackage.GetInstalledSize()
@@ -110,14 +113,17 @@ func (operation *BPMOperation) GetFinalActionSize(rootDir string) int64 {
 	var ret int64 = 0
 	for _, action := range operation.Actions {
 		if action.GetActionType() == "install" {
-			ret += int64(action.(*InstallPackageAction).BpmPackage.GetInstalledSize())
+			ret += action.(*InstallPackageAction).BpmPackage.GetInstalledSize()
 			if IsPackageInstalled(action.(*InstallPackageAction).BpmPackage.PkgInfo.Name, rootDir) {
-				ret -= int64(GetPackage(action.(*InstallPackageAction).BpmPackage.PkgInfo.Name, rootDir).GetInstalledSize())
+				ret -= GetPackage(action.(*InstallPackageAction).BpmPackage.PkgInfo.Name, rootDir).GetInstalledSize()
 			}
 		} else if action.GetActionType() == "fetch" {
-			ret += int64(action.(*FetchPackageAction).DatabaseEntry.InstalledSize)
+			ret += action.(*FetchPackageAction).DatabaseEntry.InstalledSize
+			if IsPackageInstalled(action.(*FetchPackageAction).DatabaseEntry.Info.Name, rootDir) {
+				ret -= action.(*FetchPackageAction).DatabaseEntry.InstalledSize
+			}
 		} else if action.GetActionType() == "remove" {
-			ret -= int64(action.(*RemovePackageAction).BpmPackage.GetInstalledSize())
+			ret -= action.(*RemovePackageAction).BpmPackage.GetInstalledSize()
 		}
 	}
 	return ret
@@ -173,10 +179,7 @@ func (operation *BPMOperation) RemoveNeededPackages() error {
 	}
 
 	for pkg, action := range removeActions {
-		dependants, err := GetPackageDependants(action.BpmPackage.PkgInfo.Name, operation.RootDir)
+		dependants := action.BpmPackage.PkgInfo.GetPackageDependants(operation.RootDir)
-		if err != nil {
-			return errors.New("could not get dependant packages for package (" + pkg + ")")
-		}
 		dependants = slices.DeleteFunc(dependants, func(d string) bool {
 			if _, ok := removeActions[d]; ok {
 				return true
@@ -227,9 +230,9 @@ func (operation *BPMOperation) Cleanup(cleanupMakeDepends bool) error {
 		}
 
 		keepPackages = append(keepPackages, pkg.Name)
-		resolved := pkg.GetAllDependencies(!cleanupMakeDepends, true, operation.RootDir)
+		resolved := pkg.GetDependenciesRecursive(!cleanupMakeDepends, operation.RootDir)
 		for _, value := range resolved {
-			if !slices.Contains(keepPackages, value) {
+			if !slices.Contains(keepPackages, value) && !slices.Contains(MainBPMConfig.IgnorePackages, value) {
 				keepPackages = append(keepPackages, value)
 			}
 		}
@@ -277,54 +280,92 @@ func (operation *BPMOperation) ReplaceObsoletePackages() {
 	}
 }
 
-func (operation *BPMOperation) CheckForConflicts() (map[string][]string, error) {
+func (operation *BPMOperation) CheckForConflicts() map[string][]string {
 	conflicts := make(map[string][]string)
-	installedPackages, err := GetInstalledPackages(operation.RootDir)
-	if err != nil {
-		return nil, err
-	}
-	allPackages := make([]*PackageInfo, len(installedPackages))
-	for i, value := range installedPackages {
-		bpmpkg := GetPackage(value, operation.RootDir)
-		if bpmpkg == nil {
-			return nil, fmt.Errorf("could not find installed package (%s)", value)
-		}
-		allPackages[i] = bpmpkg.PkgInfo
-	}
 
-	// Add all new packages to the allPackages slice
+	// Get installed packages
+	installedPackages := localPackageInformation[operation.RootDir]
+
+	// Get packages to be removed
+	removedPackages := make([]string, 0)
 	for _, value := range slices.Clone(operation.Actions) {
+		if value.GetActionType() != "remove" {
+			continue
+		}
+
+		removedPackages = append(removedPackages, value.(*RemovePackageAction).BpmPackage.PkgInfo.Name)
+	}
+
+	// Check for conflicts
+	for _, value := range slices.Clone(operation.Actions) {
+		var pkgInfo *PackageInfo
 		if value.GetActionType() == "install" {
-			action := value.(*InstallPackageAction)
+			pkgInfo = value.(*InstallPackageAction).BpmPackage.PkgInfo
-			pkgInfo := action.BpmPackage.PkgInfo
-			allPackages = append(allPackages, pkgInfo)
 		} else if value.GetActionType() == "fetch" {
-			action := value.(*FetchPackageAction)
+			pkgInfo = value.(*FetchPackageAction).DatabaseEntry.Info
-			pkgInfo := action.DatabaseEntry.Info
+		} else {
-			allPackages = append(allPackages, pkgInfo)
+			continue
-		} else if value.GetActionType() == "remove" {
+		}
-			action := value.(*RemovePackageAction)
+
-			pkgInfo := action.BpmPackage.PkgInfo
+		// Check for conflicts with installed packages
-			for i := len(allPackages) - 1; i >= 0; i-- {
+		for _, installedPkg := range installedPackages {
-				info := allPackages[i]
+			// Skip if package is to be removed
-				if info.Name == pkgInfo.Name {
+			if slices.Contains(removedPackages, installedPkg.Name) {
-					allPackages = append(allPackages[:i], allPackages[i+1:]...)
+				continue
+			}
+
+			// Skip if same package
+			if pkgInfo.Name == installedPkg.Name {
+				continue
+			}
+
+			// Check for new package conflicts
+			if slices.Contains(pkgInfo.Conflicts, installedPkg.Name) {
+				conflicts[pkgInfo.Name] = append(conflicts[pkgInfo.Name], installedPkg.Name)
+			}
+			for _, vpkg := range installedPkg.Provides {
+				if slices.Contains(pkgInfo.Conflicts, vpkg) {
+					conflicts[pkgInfo.Name] = append(conflicts[pkgInfo.Name], vpkg+" ("+installedPkg.Name+")")
+				}
+			}
+
+			// Check for installed package conflicts
+			for _, vpkg := range pkgInfo.Provides {
+				if slices.Contains(installedPkg.Conflicts, vpkg) {
+					conflicts[installedPkg.Name] = append(conflicts[installedPkg.Name], vpkg+" ("+pkgInfo.Name+")")
+				}
+			}
+		}
+
+		// Check for conflicts with other new packages
+		for _, value := range slices.Clone(operation.Actions) {
+			var pkgInfo2 *PackageInfo
+			if value.GetActionType() == "install" {
+				pkgInfo2 = value.(*InstallPackageAction).BpmPackage.PkgInfo
+			} else if value.GetActionType() == "fetch" {
+				pkgInfo2 = value.(*FetchPackageAction).DatabaseEntry.Info
+			} else {
+				continue
+			}
+
+			// Skip if same package
+			if pkgInfo.Name == pkgInfo2.Name {
+				continue
+			}
+
+			// Check for other package conflicts
+			if slices.Contains(pkgInfo.Conflicts, pkgInfo2.Name) {
+				conflicts[pkgInfo.Name] = append(conflicts[pkgInfo.Name], pkgInfo2.Name)
+			}
+			for _, vpkg := range pkgInfo2.Provides {
+				if slices.Contains(pkgInfo.Conflicts, vpkg) {
+					conflicts[pkgInfo.Name] = append(conflicts[pkgInfo.Name], vpkg+" ("+pkgInfo2.Name+")")
 				}
 			}
 		}
 	}
 
-	for _, value := range allPackages {
+	return conflicts
-		for _, conflict := range value.Conflicts {
-			if slices.ContainsFunc(allPackages, func(info *PackageInfo) bool {
-				return info.Name == conflict
-			}) {
-				conflicts[value.Name] = append(conflicts[value.Name], conflict)
-			}
-		}
-	}
-
-	return conflicts, nil
 }
 
 func (operation *BPMOperation) ShowOperationSummary() {
@@ -333,6 +374,9 @@ func (operation *BPMOperation) ShowOperationSummary() {
 		return
 	}
 
+	writer := tabwriter.NewWriter(os.Stdout, 6, 4, 6, ' ', 0)
+	fmt.Fprintln(writer, "Name\tVersion\tAction\tInstallation Reason\tFrom Source")
+
 	for _, value := range operation.Actions {
 		var pkgInfo *PackageInfo
 		var installationReason = InstallationReasonUnknown
@@ -347,54 +391,115 @@ func (operation *BPMOperation) ShowOperationSummary() {
 			pkgInfo = value.(*FetchPackageAction).DatabaseEntry.Info
 		} else {
 			pkgInfo = value.(*RemovePackageAction).BpmPackage.PkgInfo
-			fmt.Printf("%s: %s (Remove)\n", pkgInfo.Name, pkgInfo.GetFullVersion())
+			fmt.Fprintf(writer, "%s\t%s\t%s\t%s\t%s\n", pkgInfo.Name, pkgInfo.GetFullVersion(), "Remove", "-", "-")
 			continue
 		}
 
-		installedInfo := GetPackageInfo(pkgInfo.Name, operation.RootDir)
+		installationReasonStr := ""
-		additionalInfo := ""
 		switch installationReason {
 		case InstallationReasonManual:
-			additionalInfo = "(Manual)"
+			installationReasonStr = "Manual"
 		case InstallationReasonDependency:
-			additionalInfo = "(Dependency)"
+			installationReasonStr = "Dependency"
 		case InstallationReasonMakeDependency:
-			additionalInfo = "(Make dependency)"
+			installationReasonStr = "Make dependency"
 		default:
-			additionalInfo = "(Unknown)"
+			installationReasonStr = "Unknown"
-		}
-
-		if pkgInfo.Type == "source" {
-			additionalInfo += " (From Source)"
 		}
 
+		installedInfo := GetPackageInfo(pkgInfo.Name, operation.RootDir)
 		if installedInfo == nil {
-			fmt.Printf("%s: %s (Install) %s\n", pkgInfo.Name, pkgInfo.GetFullVersion(), additionalInfo)
+			fmt.Fprintf(writer, "%s\t%s\t%s\t%s\t%t\n", pkgInfo.Name, pkgInfo.GetFullVersion(), "Install", installationReasonStr, pkgInfo.Type == "source")
 		} else {
-			comparison := ComparePackageVersions(*pkgInfo, *installedInfo)
+			comparison := CompareVersions(pkgInfo.GetFullVersion(), installedInfo.GetFullVersion())
 			if comparison < 0 {
-				fmt.Printf("%s: %s -> %s (Downgrade) %s\n", pkgInfo.Name, installedInfo.GetFullVersion(), pkgInfo.GetFullVersion(), additionalInfo)
+				fmt.Fprintf(writer, "%s\t%s -> %s\t%s\t%s\t%t\n", pkgInfo.Name, installedInfo.GetFullVersion(), pkgInfo.GetFullVersion(), "Downgrade", installationReasonStr, pkgInfo.Type == "source")
 			} else if comparison > 0 {
-				fmt.Printf("%s: %s -> %s (Upgrade) %s\n", pkgInfo.Name, installedInfo.GetFullVersion(), pkgInfo.GetFullVersion(), additionalInfo)
+				fmt.Fprintf(writer, "%s\t%s -> %s\t%s\t%s\t%t\n", pkgInfo.Name, installedInfo.GetFullVersion(), pkgInfo.GetFullVersion(), "Upgrade", installationReasonStr, pkgInfo.Type == "source")
 			} else {
-				fmt.Printf("%s: %s (Reinstall) %s\n", pkgInfo.Name, pkgInfo.GetFullVersion(), additionalInfo)
+				fmt.Fprintf(writer, "%s\t%s\t%s\t%s\t%t\n", pkgInfo.Name, pkgInfo.GetFullVersion(), "Reinstall", installationReasonStr, pkgInfo.Type == "source")
 			}
 		}
 	}
 
+	writer.Flush()
+	fmt.Println()
+
 	if operation.RootDir != "/" {
 		fmt.Println("Warning: Operating in " + operation.RootDir)
 	}
 	if operation.GetTotalDownloadSize() > 0 {
-		fmt.Printf("%s will be downloaded to complete this operation\n", unsignedBytesToHumanReadable(operation.GetTotalDownloadSize()))
+		fmt.Printf("%s will be downloaded to complete this operation\n", BytesToHumanReadable(operation.GetTotalDownloadSize()))
 	}
 	if operation.GetFinalActionSize(operation.RootDir) > 0 {
-		fmt.Printf("A total of %s will be installed after the operation finishes\n", bytesToHumanReadable(operation.GetFinalActionSize(operation.RootDir)))
+		fmt.Printf("A total of %s will be installed after the operation finishes\n", BytesToHumanReadable(operation.GetFinalActionSize(operation.RootDir)))
 	} else if operation.GetFinalActionSize(operation.RootDir) < 0 {
-		fmt.Printf("A total of %s will be freed after the operation finishes\n", strings.TrimPrefix(bytesToHumanReadable(operation.GetFinalActionSize(operation.RootDir)), "-"))
+		fmt.Printf("A total of %s will be freed after the operation finishes\n", strings.TrimPrefix(BytesToHumanReadable(operation.GetFinalActionSize(operation.RootDir)), "-"))
 	}
 }
 
+func (operation *BPMOperation) ShowSourcePackageContent() (sourcePackagesShown int, err error) {
+	// Fetch packages
+	if !operation.hasFetchedPackages {
+		err = operation.FetchPackages()
+		if err != nil {
+			return 0, err
+		}
+	}
+
+	for _, action := range operation.Actions {
+		if action.GetActionType() != "install" {
+			continue
+		}
+		if action.(*InstallPackageAction).BpmPackage.PkgInfo.Type != "source" {
+			continue
+		}
+
+		err = showPackageFiles(action.(*InstallPackageAction).File)
+		if err != nil {
+			return 0, err
+		}
+
+		sourcePackagesShown++
+	}
+
+	return sourcePackagesShown, nil
+}
+
+func (operation *BPMOperation) GetOptionalDependencies() (optionalDepends map[string][]string) {
+	optionalDepends = make(map[string][]string)
+
+	// Find all optional dependencies
+	for _, value := range slices.Clone(operation.Actions) {
+		var pkgInfo *PackageInfo
+		if value.GetActionType() == "install" {
+			action := value.(*InstallPackageAction)
+			pkgInfo = action.BpmPackage.PkgInfo
+		} else if value.GetActionType() == "fetch" {
+			action := value.(*FetchPackageAction)
+			pkgInfo = action.DatabaseEntry.Info
+		} else {
+			continue
+		}
+
+		for _, depend := range pkgInfo.OptionalDepends {
+			// Skip if dependency is already installed
+			if IsPackageInstalled(depend, operation.RootDir) {
+				continue
+			}
+
+			// Skip if not a new dependency of the package
+			if installedPkg := GetPackage(pkgInfo.Name, operation.RootDir); installedPkg != nil && slices.Contains(installedPkg.PkgInfo.OptionalDepends, depend) {
+				continue
+			}
+
+			optionalDepends[pkgInfo.Name] = append(optionalDepends[pkgInfo.Name], depend)
+		}
+	}
+
+	return
+}
+
 func (operation *BPMOperation) RunHooks(verbose bool) error {
 	// Return if hooks directory does not exist
 	if stat, err := os.Stat(path.Join(operation.RootDir, "var/lib/bpm/hooks")); err != nil || !stat.IsDir() {
@@ -426,7 +531,7 @@ func (operation *BPMOperation) RunHooks(verbose bool) error {
 	return nil
 }
 
-func (operation *BPMOperation) Execute(verbose, force bool) (err error) {
+func (operation *BPMOperation) FetchPackages() (err error) {
 	// Fetch packages from databases
 	if slices.ContainsFunc(operation.Actions, func(action OperationAction) bool {
 		return action.GetActionType() == "fetch"
@@ -448,7 +553,7 @@ func (operation *BPMOperation) Execute(verbose, force bool) (err error) {
 			var bpmpkg *BPMPackage
 
 			// Check if package has already been fetched from download link
-			if _, ok := fetchedPackages[entry.Download]; !ok {
+			if fetchedFilepath, ok := fetchedPackages[entry.Filepath]; !ok {
 				// Fetch package from database
 				fetchedPackage, err := entry.Database.FetchPackage(entry.Info.Name)
 				if err != nil {
@@ -462,29 +567,35 @@ func (operation *BPMOperation) Execute(verbose, force bool) (err error) {
 				}
 
 				// Add fetched package to map
-				fetchedPackages[entry.Download] = fetchedPackage
+				fetchedPackages[entry.Filepath] = fetchedPackage
-
-				fmt.Printf("Package (%s) was successfully fetched!\n", entry.Info.Name)
 			} else {
 				// Read fetched package
-				bpmpkg, err = ReadPackage(fetchedPackages[entry.Download])
+				bpmpkg, err = ReadPackage(fetchedFilepath)
 				if err != nil {
 					return fmt.Errorf("could not read package (%s): %s\n", entry.Info.Name, err)
 				}
 
-				fmt.Printf("Package (%s) was successfully fetched!\n", entry.Info.Name)
+				// Get size of fetched archive
+				stat, err := os.Stat(fetchedFilepath)
+				if err != nil {
+					return err
+				}
+
+				bar := createProgressBar(stat.Size(), "Downloading "+entry.Info.Name, false)
+				bar.Set64(stat.Size())
+				bar.Close()
 			}
 
 			if bpmpkg.PkgInfo.IsSplitPackage() {
 				operation.Actions[i] = &InstallPackageAction{
-					File:                  fetchedPackages[entry.Download],
+					File:                  fetchedPackages[entry.Filepath],
 					InstallationReason:    action.(*FetchPackageAction).InstallationReason,
 					BpmPackage:            bpmpkg,
 					SplitPackageToInstall: entry.Info.Name,
 				}
 			} else {
 				operation.Actions[i] = &InstallPackageAction{
-					File:               fetchedPackages[entry.Download],
+					File:               fetchedPackages[entry.Filepath],
 					InstallationReason: action.(*FetchPackageAction).InstallationReason,
 					BpmPackage:         bpmpkg,
 				}
@@ -492,6 +603,19 @@ func (operation *BPMOperation) Execute(verbose, force bool) (err error) {
 		}
 	}
 
+	operation.hasFetchedPackages = true
+	return nil
+}
+
+func (operation *BPMOperation) Execute(verbose, force bool) (err error) {
+	// Fetch packages
+	if !operation.hasFetchedPackages {
+		err = operation.FetchPackages()
+		if err != nil {
+			return err
+		}
+	}
+
 	// Determine words to be used for the following message
 	words := make([]string, 0)
 	if slices.ContainsFunc(operation.Actions, func(action OperationAction) bool {
@@ -546,7 +670,7 @@ func (operation *BPMOperation) Execute(verbose, force bool) (err error) {
 
 				// Compile source package if not compiled already
 				if _, ok := operation.compiledPackages[pkgNameToInstall]; !ok {
-					outputBpmPackages, err := CompileSourcePackage(value.File, compiledDir, false)
+					outputBpmPackages, err := CompileSourcePackage(value.File, compiledDir, false, false, verbose)
 					if err != nil {
 						return fmt.Errorf("could not compile source package (%s): %s\n", value.File, err)
 					}
@@ -579,8 +703,6 @@ func (operation *BPMOperation) Execute(verbose, force bool) (err error) {
 			if err != nil {
 				return fmt.Errorf("could not set installation reason for package (%s): %s\n", value.BpmPackage.PkgInfo.Name, err)
 			}
-
-			fmt.Printf("Package (%s) was successfully installed\n", bpmpkg.PkgInfo.Name)
 		}
 	}
 	fmt.Println("Operation complete!")

src/bpmlib/packages.go

@@ -10,13 +10,13 @@ import (
 	"os"
 	"os/exec"
 	"path"
+	"regexp"
 	"slices"
 	"sort"
 	"strconv"
 	"strings"
 	"syscall"
 
-	version "github.com/knqyf263/go-rpm-version"
 	"gopkg.in/yaml.v3"
 )
 
@@ -26,34 +26,54 @@ type BPMPackage struct {
 }
 
 type PackageInfo struct {
-	Name            string         `yaml:"name,omitempty"`
+	Name            string            `yaml:"name"`
 	Description     string            `yaml:"description,omitempty"`
 	Version         string            `yaml:"version,omitempty"`
 	Revision        int               `yaml:"revision,omitempty"`
 	Url             string            `yaml:"url,omitempty"`
 	License         string            `yaml:"license,omitempty"`
 	Arch            string            `yaml:"architecture,omitempty"`
+	OutputArch      string            `yaml:"output_architecture,omitempty"`
 	Type            string            `yaml:"type,omitempty"`
 	Keep            []string          `yaml:"keep,omitempty"`
 	Depends         []string          `yaml:"depends,omitempty"`
-	MakeDepends     []string       `yaml:"make_depends,omitempty"`
 	OptionalDepends []string          `yaml:"optional_depends,omitempty"`
+	MakeDepends     []string          `yaml:"make_depends,omitempty"`
 	Conflicts       []string          `yaml:"conflicts,omitempty"`
 	Replaces        []string          `yaml:"replaces,omitempty"`
 	Provides        []string          `yaml:"provides,omitempty"`
+	Options         []string          `yaml:"options,omitempty"`
+	Downloads       []PackageDownload `yaml:"downloads,omitempty"`
 	SplitPackages   []*PackageInfo    `yaml:"split_packages,omitempty"`
 }
 
+type PackageDownload struct {
+	Url      string `yaml:"url"`
+	Type     string `yaml:"type,omitempty"`
+	Filepath string `yaml:"filepath,omitempty"`
+
+	// Archive options
+	NoExtract              bool   `yaml:"no_extract,omitempty"`
+	ExtractTo              string `yaml:"extract_to,omitempty"`
+	ExtractStripComponents int    `yaml:"extract_strip_components,omitempty"`
+
+	// Git options
+	CloneTo   string `yaml:"clone_to,omitempty"`
+	GitBranch string `yaml:"git_branch,omitempty"`
+
+	Checksum string `yaml:"checksum,omitempty"`
+}
+
 type PackageFileEntry struct {
 	Path        string
 	OctalPerms  uint32
 	UserID      int
 	GroupID     int
-	SizeInBytes uint64
+	SizeInBytes int64
 }
 
-func (pkg *BPMPackage) GetInstalledSize() uint64 {
+func (pkg *BPMPackage) GetInstalledSize() int64 {
-	var totalSize uint64 = 0
+	var totalSize int64 = 0
 	for _, entry := range pkg.PkgFiles {
 		totalSize += entry.SizeInBytes
 	}
@@ -100,13 +120,6 @@ const (
 	InstallationReasonUnknown        InstallationReason = "unknown"
 )
 
-func ComparePackageVersions(info1, info2 PackageInfo) int {
-	v1 := version.NewVersion(info1.GetFullVersion())
-	v2 := version.NewVersion(info2.GetFullVersion())
-
-	return v1.Compare(v2)
-}
-
 func GetInstallationReason(pkg, rootDir string) InstallationReason {
 	installedDir := path.Join(rootDir, "var/lib/bpm/installed/")
 	pkgDir := path.Join(installedDir, pkg)
@@ -177,10 +190,10 @@ func ReadPackage(filename string) (*BPMPackage, error) {
 	}
 
 	file, err := os.Open(filename)
-	defer file.Close()
 	if err != nil {
 		return nil, err
 	}
+	defer file.Close()
 
 	tr := tar.NewReader(file)
 	for {
@@ -219,7 +232,7 @@ func ReadPackage(filename string) (*BPMPackage, error) {
 				if err != nil {
 					return nil, err
 				}
-				size, err := strconv.ParseUint(stringEntry[len(stringEntry)-1], 0, 64)
+				size, err := strconv.ParseInt(stringEntry[len(stringEntry)-1], 0, 64)
 				if err != nil {
 					return nil, err
 				}
@@ -303,14 +316,6 @@ func ReadPackageScripts(filename string) (map[string]string, error) {
 	return ret, nil
 }
 
-type packageOperation uint8
-
-const (
-	packageOperationInstall packageOperation = 0
-	packageOperationUpdate                   = 1
-	packageOperationRemove                   = 2
-)
-
 func executePackageScript(pkg, rootDir string, verbose bool, packageScript string) error {
 	var bpmpkg *BPMPackage
 	var err error
@@ -363,9 +368,44 @@ func executePackageScript(pkg, rootDir string, verbose bool, packageScript strin
 	cmd := exec.Command("/bin/bash", "-c", content)
 	// Setup subprocess environment
 	cmd.Dir = "/"
-	// Run hook in chroot if using the -R flag
+	// Run package script in chroot if using the -R flag
 	if rootDir != "/" {
 		cmd.SysProcAttr = &syscall.SysProcAttr{Chroot: rootDir}
+
+		// Bind mount /etc/resolv.conf
+		mounted, err := func() (bool, error) {
+			if _, err := os.Stat("/etc/resolv.conf"); err != nil {
+				return false, nil
+			}
+
+			if _, err := os.Stat(path.Join(rootDir, "etc/resolv.conf")); os.IsNotExist(err) {
+				err = os.WriteFile(path.Join(rootDir, "/etc/resolv.conf"), nil, 0644)
+				if err != nil {
+					return false, nil
+				}
+			} else if err != nil {
+				return false, err
+			}
+
+			mntCmd := exec.Command("mount", "-o", "ro,bind", "/etc/resolv.conf", path.Join(rootDir, "/etc/resolv.conf"))
+			if verbose {
+				mntCmd.Stdout = os.Stdout
+				mntCmd.Stderr = os.Stderr
+			}
+			err = mntCmd.Run()
+			if err != nil {
+				return false, err
+			}
+
+			return true, nil
+		}()
+		if err != nil {
+			return err
+		}
+
+		if mounted {
+			defer exec.Command("umount", "-f", path.Join(rootDir, "/etc/resolv.conf")).Run()
+		}
 	}
 	// Show output if verbose
 	if verbose {
@@ -413,14 +453,8 @@ func executePackageScript(pkg, rootDir string, verbose bool, packageScript strin
 
 func ReadPackageInfo(contents string) (*PackageInfo, error) {
 	pkgInfo := &PackageInfo{
-		Name:            "",
-		Description:     "",
-		Version:         "",
 		Revision:        1,
-		Url:             "",
+		OutputArch:      GetArch(),
-		License:         "",
-		Arch:            "",
-		Type:            "",
 		Keep:            make([]string, 0),
 		Depends:         make([]string, 0),
 		MakeDepends:     make([]string, 0),
@@ -428,6 +462,8 @@ func ReadPackageInfo(contents string) (*PackageInfo, error) {
 		Conflicts:       make([]string, 0),
 		Replaces:        make([]string, 0),
 		Provides:        make([]string, 0),
+		Options:         make([]string, 0),
+		Downloads:       make([]PackageDownload, 0),
 		SplitPackages:   make([]*PackageInfo, 0),
 	}
 	err := yaml.Unmarshal([]byte(contents), &pkgInfo)
@@ -455,73 +491,92 @@ func ReadPackageInfo(contents string) (*PackageInfo, error) {
 		}
 	}
 
+	// Ensure package name is valid
+	if match, _ := regexp.MatchString("^[a-zA-Z0-9._-]+$", pkgInfo.Name); !match {
+		return nil, fmt.Errorf("package name (%s) is invalid", pkgInfo.Name)
+	}
+
 	// Setup split package information
 	for i, splitPkg := range pkgInfo.SplitPackages {
 		// Ensure split package contains a name
 		if splitPkg.Name == "" {
-			return nil, fmt.Errorf("invalid split package name: %s", splitPkg.Name)
+			return nil, fmt.Errorf("package name (%s) is invalid", splitPkg.Name)
 		}
 
-		// Turn split package into json data
+		// Ensure split package name is valid
-		splitPkgJson, err := yaml.Marshal(splitPkg)
+		if match, _ := regexp.MatchString("^[a-zA-Z0-9._-]+$", splitPkg.Name); !match {
+			return nil, fmt.Errorf("package name (%s) is invalid", splitPkg.Name)
+		}
+
+		// Turn split package into yaml data
+		splitPkgYaml, err := yaml.Marshal(splitPkg)
 		if err != nil {
 			return nil, err
 		}
 
 		// Clone all main package fields onto split package
-		pkgInfoClone := *pkgInfo
+		*splitPkg = *pkgInfo
-		pkgInfo.SplitPackages[i] = &pkgInfoClone
 
 		// Set split package field of split package to nil
-		pkgInfo.SplitPackages[i].SplitPackages = nil
+		splitPkg.SplitPackages = nil
 
 		// Unmarshal json data back to struct
-		err = yaml.Unmarshal(splitPkgJson, &pkgInfo.SplitPackages[i])
+		err = yaml.Unmarshal(splitPkgYaml, splitPkg)
 		if err != nil {
 			return nil, err
 		}
 
 		// Force set split package version, revision
-		pkgInfo.SplitPackages[i].Version = pkgInfo.Version
+		splitPkg.Version = pkgInfo.Version
-		pkgInfo.SplitPackages[i].Revision = pkgInfo.Revision
+		splitPkg.Revision = pkgInfo.Revision
+
+		pkgInfo.SplitPackages[i] = splitPkg
 	}
 
 	return pkgInfo, nil
 }
 
-func CreateReadableInfo(showArchitecture, showType, showPackageRelations, showInstallationReason bool, pkgInfo *PackageInfo, rootDir string) string {
+func (pkgInfo *PackageInfo) CreateReadableInfo(rootDir string) string {
 	ret := make([]string, 0)
 	appendArray := func(label string, array []string) {
 		if len(array) == 0 {
 			return
 		}
+
 		ret = append(ret, fmt.Sprintf("%s: %s", label, strings.Join(array, ", ")))
 	}
+
 	ret = append(ret, "Name: "+pkgInfo.Name)
 	ret = append(ret, "Description: "+pkgInfo.Description)
 	ret = append(ret, "Version: "+pkgInfo.GetFullVersion())
+	if pkgInfo.Url != "" {
 		ret = append(ret, "URL: "+pkgInfo.Url)
+	}
+	if pkgInfo.License != "" {
 		ret = append(ret, "License: "+pkgInfo.License)
-	if showArchitecture {
+	}
 	ret = append(ret, "Architecture: "+pkgInfo.Arch)
+	if pkgInfo.Type == "source" && pkgInfo.OutputArch != "" && pkgInfo.OutputArch != GetArch() {
+		ret = append(ret, "Output architecture: "+pkgInfo.Arch)
 	}
-	if showType {
 	ret = append(ret, "Type: "+pkgInfo.Type)
-	}
-	if showPackageRelations {
 	appendArray("Dependencies", pkgInfo.Depends)
 	if pkgInfo.Type == "source" {
 		appendArray("Make Dependencies", pkgInfo.MakeDepends)
 	}
 	appendArray("Optional dependencies", pkgInfo.OptionalDepends)
-		dependants, err := GetPackageDependants(pkgInfo.Name, rootDir)
+	dependants := pkgInfo.GetPackageDependants(rootDir)
-		if err == nil {
+	if len(dependants) > 0 {
 		appendArray("Dependant packages", dependants)
 	}
+	optionalDependants := pkgInfo.GetPackageOptionalDependants(rootDir)
+	if len(optionalDependants) > 0 {
+		appendArray("Optionally dependant packages", optionalDependants)
+	}
 	appendArray("Conflicting packages", pkgInfo.Conflicts)
 	appendArray("Provided packages", pkgInfo.Provides)
 	appendArray("Replaces packages", pkgInfo.Replaces)
-	}
+
 	if pkgInfo.Type == "source" && len(pkgInfo.SplitPackages) != 0 {
 		splitPkgs := make([]string, len(pkgInfo.SplitPackages))
 		for i, splitPkgInfo := range pkgInfo.SplitPackages {
@@ -529,7 +584,8 @@ func CreateReadableInfo(showArchitecture, showType, showPackageRelations, showIn
 		}
 		appendArray("Split Packages", splitPkgs)
 	}
-	if IsPackageInstalled(pkgInfo.Name, rootDir) && showInstallationReason {
+
+	if rootDir != "" && IsPackageInstalled(pkgInfo.Name, rootDir) {
 		installationReason := GetInstallationReason(pkgInfo.Name, rootDir)
 		var installationReasonString string
 		switch installationReason {
@@ -544,27 +600,21 @@ func CreateReadableInfo(showArchitecture, showType, showPackageRelations, showIn
 		}
 		ret = append(ret, "Installation Reason: "+installationReasonString)
 	}
+
 	return strings.Join(ret, "\n")
 }
 
 func extractPackage(bpmpkg *BPMPackage, verbose bool, filename, rootDir string) error {
-	if !IsPackageInstalled(bpmpkg.PkgInfo.Name, rootDir) {
-		err := executePackageScript(filename, rootDir, verbose, "pre_install.sh")
-		if err != nil {
-			log.Printf("Warning: %s\n", err)
-		}
-	} else {
-		err := executePackageScript(filename, rootDir, verbose, "pre_update.sh")
-		if err != nil {
-			log.Printf("Warning: %s\n", err)
-		}
-	}
 	seenHardlinks := make(map[string]string)
 	file, err := os.Open(filename)
 	if err != nil {
 		return err
 	}
 
+	// Initialize progress bar
+	bar := createProgressBar(bpmpkg.GetInstalledSize(), "Installing "+bpmpkg.PkgInfo.Name, verbose)
+	defer bar.Close()
+
 	tarballFile, err := readTarballFile(filename, "files.tar.gz")
 	if err != nil {
 		return err
@@ -576,6 +626,7 @@ func extractPackage(bpmpkg *BPMPackage, verbose bool, filename, rootDir string)
 		return err
 	}
 	packageFilesReader := tar.NewReader(archive)
+
 	for {
 		header, err := packageFilesReader.Next()
 		if err == io.EOF {
@@ -612,6 +663,7 @@ func extractPackage(bpmpkg *BPMPackage, verbose bool, filename, rootDir string)
 			if verbose {
 				fmt.Printf("Created directory %s (%o)\n", extractFilename, header.Mode)
 			}
+			bar.Add64(header.Size)
 		case tar.TypeReg:
 			skip := false
 			if _, err := os.Stat(extractFilename); err == nil {
@@ -668,6 +720,7 @@ func extractPackage(bpmpkg *BPMPackage, verbose bool, filename, rootDir string)
 			if verbose {
 				fmt.Printf("Created File: %s (%o)\n", extractFilename, header.Mode)
 			}
+			bar.Add64(header.Size)
 		case tar.TypeSymlink:
 			err := os.Remove(extractFilename)
 			if err != nil && !os.IsNotExist(err) {
@@ -682,6 +735,7 @@ func extractPackage(bpmpkg *BPMPackage, verbose bool, filename, rootDir string)
 			if verbose {
 				fmt.Println("Created Symlink: " + extractFilename + " -> " + header.Linkname)
 			}
+			bar.Add64(header.Size)
 		case tar.TypeLink:
 			if verbose {
 				fmt.Println("Detected Hard Link: " + extractFilename + " -> " + path.Join(rootDir, strings.TrimPrefix(header.Linkname, "files/")))
@@ -691,6 +745,7 @@ func extractPackage(bpmpkg *BPMPackage, verbose bool, filename, rootDir string)
 			if err != nil && !os.IsNotExist(err) {
 				return err
 			}
+			bar.Add64(header.Size)
 		default:
 			return errors.New("unknown type (" + strconv.Itoa(int(header.Typeflag)) + ") in " + extractFilename)
 		}
@@ -725,6 +780,20 @@ func installPackage(filename, rootDir string, verbose, force bool) error {
 	}
 
 	packageInstalled := IsPackageInstalled(bpmpkg.PkgInfo.Name, rootDir)
+
+	// Run pre-* package scripts
+	if !packageInstalled {
+		err := executePackageScript(filename, rootDir, verbose, "pre_install.sh")
+		if err != nil {
+			log.Printf("Warning: %s\n", err)
+		}
+	} else {
+		err := executePackageScript(filename, rootDir, verbose, "pre_update.sh")
+		if err != nil {
+			log.Printf("Warning: %s\n", err)
+		}
+	}
+
 	// Check if package is installed and remove current files
 	if packageInstalled {
 		// Fetching and reversing package file entry list
@@ -906,6 +975,7 @@ func installPackage(filename, rootDir string, verbose, force bool) error {
 		f.Close()
 	}
 
+	// Run post-* package scripts
 	if !packageInstalled {
 		err = executePackageScript(filename, rootDir, verbose, "post_install.sh")
 		if err != nil {
@@ -925,7 +995,7 @@ func installPackage(filename, rootDir string, verbose, force bool) error {
 	}
 
 	// Add or update package information for rootDir
-	localPackageInformation[rootDir][bpmpkg.PkgInfo.Name] = bpmpkg
+	localPackageInformation[rootDir][bpmpkg.PkgInfo.Name] = bpmpkg.PkgInfo
 
 	return nil
 }
@@ -943,8 +1013,11 @@ func removePackage(pkg string, verbose bool, rootDir string) error {
 		log.Printf("Warning: %s\n", err)
 	}
 
+	// Get BPM package
+	bpmpkg := GetPackage(pkg, rootDir)
+
 	// Fetching and reversing package file entry list
-	fileEntries := GetPackage(pkg, rootDir).PkgFiles
+	fileEntries := bpmpkg.PkgFiles
 	sort.Slice(fileEntries, func(i, j int) bool {
 		return fileEntries[i].Path < fileEntries[j].Path
 	})
@@ -954,8 +1027,12 @@ func removePackage(pkg string, verbose bool, rootDir string) error {
 		return err
 	}
 
+	bar := createProgressBar(bpmpkg.GetInstalledSize(), "Removing "+bpmpkg.PkgInfo.Name, verbose)
+	defer bar.Close()
+
 	// Removing package files
 	for _, entry := range fileEntries {
+		bar.Add64(entry.SizeInBytes)
 		file := path.Join(rootDir, entry.Path)
 		lstat, err := os.Lstat(file)
 		if os.IsNotExist(err) {

src/bpmlib/utils.go

@@ -2,10 +2,58 @@ package bpmlib
 
 import (
 	"fmt"
+	"io"
 	"math"
+	"os"
+	"path"
 	"syscall"
+	"time"
+
+	version "github.com/knqyf263/go-rpm-version"
+	"github.com/schollz/progressbar/v3"
 )
 
+type BPMLock struct {
+	file *os.File
+	path string
+}
+
+func LockBPM(rootDir string) (*BPMLock, error) {
+	// Create parent directories if they don't already exist
+	err := os.MkdirAll(path.Join(rootDir, "/var/lib/bpm"), 0755)
+	if err != nil {
+		return nil, err
+	}
+
+	// Create file
+	f, err := os.Create(path.Join(rootDir, "var/lib/bpm/bpm.lock"))
+	if err != nil {
+		return nil, err
+	}
+
+	// Get exclusive file lock on file
+	err = syscall.Flock(int(f.Fd()), syscall.LOCK_EX|syscall.LOCK_NB)
+	if err != nil {
+		return nil, err
+	}
+
+	return &BPMLock{f, path.Join(rootDir, "var/lib/bpm/bpm.lock")}, nil
+}
+
+func (lock *BPMLock) Unlock() error {
+	err := lock.file.Close()
+	if err != nil {
+		return err
+	}
+
+	err = os.Remove(lock.path)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
 func GetArch() string {
 	uname := syscall.Utsname{}
 	err := syscall.Uname(&uname)
@@ -21,6 +69,47 @@ func GetArch() string {
 	return string(byteString[:indexLength])
 }
 
+func CompareVersions(version1, version2 string) int {
+	v1 := version.NewVersion(version1)
+	v2 := version.NewVersion(version2)
+
+	return v1.Compare(v2)
+}
+
+func createProgressBar(max int64, description string, hideBar bool) *progressbar.ProgressBar {
+	var output io.Writer
+	if hideBar {
+		output = io.Discard
+	} else {
+		output = os.Stderr
+	}
+
+	if len(description) < 40 {
+		for i := len(description); i < 40; i++ {
+			description += " "
+		}
+	}
+	if len(description) > 40 {
+		overflow := len(description) - 37
+		description = description[:len(description)-overflow] + "..."
+	}
+
+	return progressbar.NewOptions64(max,
+		progressbar.OptionSetDescription(description),
+		progressbar.OptionSetWriter(output),
+		progressbar.OptionShowBytes(true),
+		progressbar.OptionShowTotalBytes(true),
+		progressbar.OptionSetWidth(20),
+		progressbar.OptionThrottle(65*time.Millisecond),
+		progressbar.OptionShowCount(),
+		progressbar.OptionOnCompletion(func() {
+			fmt.Fprint(output, "\n")
+		}),
+		progressbar.OptionSpinnerType(14),
+		progressbar.OptionSetRenderBlankState(true),
+		progressbar.OptionSetTheme(progressbar.ThemeASCII))
+}
+
 func stringSliceRemove(s []string, r string) []string {
 	for i, v := range s {
 		if v == r {
@@ -30,7 +119,7 @@ func stringSliceRemove(s []string, r string) []string {
 	return s
 }
 
-func unsignedBytesToHumanReadable(b uint64) string {
+func BytesToHumanReadable(b int64) string {
 	bf := float64(b)
 	for _, unit := range []string{"", "Ki", "Mi", "Gi", "Ti", "Pi", "Ei", "Zi"} {
 		if math.Abs(bf) < 1024.0 {
@@ -41,13 +130,14 @@ func unsignedBytesToHumanReadable(b uint64) string {
 	return fmt.Sprintf("%.1fYiB", bf)
 }
 
-func bytesToHumanReadable(b int64) string {
+func removeDuplicates[T comparable](sliceList []T) []T {
-	bf := float64(b)
+	allKeys := make(map[T]bool)
-	for _, unit := range []string{"", "Ki", "Mi", "Gi", "Ti", "Pi", "Ei", "Zi"} {
+	list := []T{}
-		if math.Abs(bf) < 1024.0 {
+	for _, item := range sliceList {
-			return fmt.Sprintf("%3.1f%sB", bf, unit)
+		if _, value := allKeys[item]; !value {
+			allKeys[item] = true
+			list = append(list, item)
 		}
-		bf /= 1024.0
 	}
-	return fmt.Sprintf("%.1fYiB", bf)
+	return list
 }