Added progress bars to all actions

Author: Auchrio

utils/delete.go

@@ -20,6 +20,7 @@ func DeletePath(vaultPath string, session *Session) error {
 	repoURL := fmt.Sprintf("git@github.com:%s/.zephyrus.git", session.Username)
 
 	// 1. Navigate to the target
+	PrintProgressStep(1, 4, "Locating path in vault...")
 	parts := strings.Split(strings.Trim(vaultPath, "/"), "/")
 	currentMap := session.Index
 	var targetName = parts[len(parts)-1]
@@ -37,8 +38,10 @@ func DeletePath(vaultPath string, session *Session) error {
 	if !exists {
 		return fmt.Errorf("path '%s' not found in vault", vaultPath)
 	}
+	PrintCompletionLine("Path located")
 
 	// 2. Identify all storage IDs to be removed
+	PrintProgressStep(2, 4, "Preparing deletion...")
 	var idsToDelete []string
 	if targetEntry.Type == "file" {
 		idsToDelete = append(idsToDelete, targetEntry.RealName)
@@ -57,8 +60,10 @@ func DeletePath(vaultPath string, session *Session) error {
 		collectIDs(targetEntry)
 		fmt.Printf("Preparing to recursively delete folder '%s' (%d files)...\n", vaultPath, len(idsToDelete))
 	}
+	PrintCompletionLine("Deletion prepared")
 
 	// 3. Git Setup
+	PrintProgressStep(3, 4, "Updating vault index...")
 	storer := memory.NewStorage()
 	fs := memfs.New()
 	publicKeys, _ := ssh.NewPublicKeys("git", session.RawKey, "")
@@ -95,6 +100,7 @@ func DeletePath(vaultPath string, session *Session) error {
 	w.Add(".config/index")
 
 	// 7. Commit the changes
+	PrintProgressStep(4, 4, "Uploading to GitHub...")
 	// Ensure you are passing *git.CommitOptions, not just the Signature
 	commit, err := w.Commit(session.Settings.CommitMessage, &git.CommitOptions{
 		Author: &object.Signature{
@@ -114,6 +120,7 @@ func DeletePath(vaultPath string, session *Session) error {
 	if err != nil {
 		return err
 	}
+	PrintCompletionLine("Deletion completed")
 
 	return nil
 }

utils/download.go

@@ -7,10 +7,12 @@ import (
 	"fmt"
 	"os"
 	"strings"
+	"time"
 )
 
 func DownloadFile(vaultPath string, outputPath string, session *Session) error {
 	// 1. Use your custom FindEntry logic to navigate the nested maps
+	PrintProgressStep(1, 5, "Locating file in vault...")
 	entry, err := session.Index.FindEntry(vaultPath)
 	if err != nil {
 		return fmt.Errorf("could not find file in vault: %w", err)
@@ -20,16 +22,20 @@ func DownloadFile(vaultPath string, outputPath string, session *Session) error {
 	if entry.Type == "folder" {
 		return fmt.Errorf("'%s' is a directory, you can only download individual files", vaultPath)
 	}
+	PrintCompletionLine("File located: " + entry.RealName)
 
 	fmt.Printf("Downloading %s (Storage ID: %s)...\n", vaultPath, entry.RealName)
 
 	// 3. Fetch the encrypted hex-named file from GitHub
+	PrintProgressStep(2, 5, "Fetching encrypted file from GitHub...")
 	encryptedData, err := FetchRaw(session.Username, entry.RealName)
 	if err != nil {
 		return fmt.Errorf("failed to fetch storage file from remote: %w", err)
 	}
+	PrintCompletionLine("File fetched from GitHub")
 
 	// 4. Decrypt the file key from the index
+	PrintProgressStep(3, 5, "Decrypting file key...")
 	encryptedKey, err := hex.DecodeString(entry.FileKey)
 	if err != nil {
 		return fmt.Errorf("invalid file key in index: %w", err)
@@ -38,15 +44,25 @@ func DownloadFile(vaultPath string, outputPath string, session *Session) error {
 	if err != nil {
 		return fmt.Errorf("failed to decrypt file key: check your password")
 	}
+	PrintCompletionLine("File key decrypted")
 
 	// 5. Decrypt the file data with the file key
+	PrintProgressStep(4, 5, "Decrypting file contents...")
+	time.Sleep(time.Millisecond * 100) // Simulate work for visibility
 	decryptedData, err := DecryptWithKey(encryptedData, fileKey)
 	if err != nil {
 		return fmt.Errorf("decryption failed: %w", err)
 	}
+	PrintCompletionLine("File contents decrypted")
 
 	// 6. Save to the local output path
-	return os.WriteFile(outputPath, decryptedData, 0644)
+	PrintProgressStep(5, 5, "Saving file to "+outputPath+"...")
+	err = os.WriteFile(outputPath, decryptedData, 0644)
+	if err != nil {
+		return err
+	}
+	PrintCompletionLine("File saved successfully")
+	return nil
 }
 
 // DownloadSharedFile downloads a file using a share string (username:reference:sharepassword:base64filename)

utils/progress.go

@@ -0,0 +1,75 @@
+package utils
+
+import (
+	"fmt"
+	"strings"
+	"time"
+)
+
+const (
+	spinnerFrames = `⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏`
+	barLength     = 30
+)
+
+var spinnerIdx = 0
+
+// PrintProgress displays a formatted progress message with optional spinner
+func PrintProgress(message string, withSpinner bool) {
+	if withSpinner {
+		frame := string(spinnerFrames[spinnerIdx%len(spinnerFrames)])
+		spinnerIdx++
+		fmt.Printf("\r%s %s ", frame, message)
+	} else {
+		fmt.Printf("\r%s", message)
+	}
+}
+
+// PrintProgressBar displays a progress bar with percentage
+func PrintProgressBar(message string, current, total int) {
+	if total <= 0 {
+		total = 1
+	}
+	percent := (current * 100) / total
+	filled := (current * barLength) / total
+
+	bar := "["
+	for i := 0; i < barLength; i++ {
+		if i < filled {
+			bar += "="
+		} else if i == filled {
+			bar += ">"
+		} else {
+			bar += " "
+		}
+	}
+	bar += "]"
+
+	fmt.Printf("\r%s %s %3d%%", message, bar, percent)
+}
+
+// PrintProgressStep displays a step in a multi-step process
+func PrintProgressStep(step, totalSteps int, message string) {
+	fmt.Printf("\r[%d/%d] %s", step, totalSteps, message)
+}
+
+// ClearProgress clears the progress line
+func ClearProgress() {
+	fmt.Print("\r" + strings.Repeat(" ", 100) + "\r")
+}
+
+// PrintCompletionLine prints a completion message and clears progress
+func PrintCompletionLine(message string) {
+	ClearProgress()
+	fmt.Printf("✓ %s\n", message)
+}
+
+// PrintErrorLine prints an error message
+func PrintErrorLine(message string) {
+	ClearProgress()
+	fmt.Printf("✗ %s\n", message)
+}
+
+// SpinnerDelay returns a duration for smooth spinner animation
+func SpinnerDelay() time.Duration {
+	return 80 * time.Millisecond
+}

utils/purge.go

@@ -18,6 +18,7 @@ func PurgeVault(session *Session) error {
 	repoURL := fmt.Sprintf("git@github.com:%s/.zephyrus.git", session.Username)
 
 	// 1. Prepare an entirely new, empty Git environment in memory
+	PrintProgressStep(1, 3, "Initializing purge...")
 	storer := memory.NewStorage()
 	fs := memfs.New()
 
@@ -26,8 +27,10 @@ func PurgeVault(session *Session) error {
 		return fmt.Errorf("failed to load private key: %w", err)
 	}
 	publicKeys.HostKeyCallback = cryptossh.InsecureIgnoreHostKey()
+	PrintCompletionLine("Purge initialized")
 
 	// 2. Initialize a fresh repo and create a "Wipe" commit
+	PrintProgressStep(2, 3, "Creating purge commit...")
 	r, _ := git.Init(storer, fs)
 	w, _ := r.Worktree()
 
@@ -42,8 +45,10 @@ func PurgeVault(session *Session) error {
 	if err != nil {
 		return fmt.Errorf("failed to create purge commit: %w", err)
 	}
+	PrintCompletionLine("Purge commit created")
 
 	// 3. Force push this empty state to GitHub to overwrite everything
+	PrintProgressStep(3, 3, "Force pushing to GitHub (wiping remote vault)...")
 	_, _ = r.CreateRemote(&config.RemoteConfig{Name: "origin", URLs: []string{repoURL}})
 
 	err = r.Push(&git.PushOptions{
@@ -55,6 +60,7 @@ func PurgeVault(session *Session) error {
 	if err != nil {
 		return fmt.Errorf("failed to push purge: %w", err)
 	}
+	PrintCompletionLine("Vault purged successfully")
 
 	// 4. Update the session index in memory to be empty
 	session.Index = NewIndex()

utils/share.go

@@ -33,6 +33,7 @@ func GenerateShareReferenceWithLength(length int) (string, error) {
 // The shared file stores only a pointer (storage ID + encrypted file key) instead of a copy
 func ShareFile(vaultPath string, sharePassword string, session *Session) (string, error) {
 	// 1. Find the file entry in the index
+	PrintProgressStep(1, 5, "Locating file in vault...")
 	entry, err := session.Index.FindEntry(vaultPath)
 	if err != nil {
 		return "", fmt.Errorf("could not find file in vault: %w", err)
@@ -42,14 +43,18 @@ func ShareFile(vaultPath string, sharePassword string, session *Session) (string
 	if entry.Type == "folder" {
 		return "", fmt.Errorf("'%s' is a directory, you can only share individual files", vaultPath)
 	}
+	PrintCompletionLine("File located")
 
 	// 3. Generate a new reference with configurable length from settings
+	PrintProgressStep(2, 5, "Generating share reference...")
 	ref, err := GenerateShareReferenceWithLength(session.Settings.ShareHashLength)
 	if err != nil {
 		return "", fmt.Errorf("failed to generate share reference: %w", err)
 	}
+	PrintCompletionLine("Share reference generated: " + ref)
 
 	// 4. Decrypt the file key with vault password to get raw 32-byte key
+	PrintProgressStep(3, 5, "Preparing file key...")
 	fileKeyBytes, err := DecryptHexToBytes(entry.FileKey, session.Password)
 	if err != nil {
 		return "", fmt.Errorf("failed to decrypt file key: %w", err)
@@ -66,12 +71,15 @@ func ShareFile(vaultPath string, sharePassword string, session *Session) (string
 	}
 
 	// 6. Encrypt the pointer with the share password
+	PrintProgressStep(4, 5, "Encrypting share pointer...")
 	pointerEncrypted, err := Encrypt(pointerJSON, sharePassword)
 	if err != nil {
 		return "", fmt.Errorf("failed to encrypt share pointer: %w", err)
 	}
+	PrintCompletionLine("Share pointer encrypted")
 
 	// 7. Upload pointer to /shared/{ref}
+	PrintProgressStep(5, 5, "Uploading to GitHub...")
 	sharedPath := fmt.Sprintf("shared/%s", ref)
 	filesToPush := map[string][]byte{
 		sharedPath: pointerEncrypted,
@@ -88,6 +96,7 @@ func ShareFile(vaultPath string, sharePassword string, session *Session) (string
 	if err != nil {
 		return "", fmt.Errorf("failed to upload share pointer: %w", err)
 	}
+	PrintCompletionLine("Share pointer uploaded to GitHub")
 
 	// 8. Add entry to shared index
 	if session.SharedIndex == nil {

utils/upload.go

@@ -4,18 +4,22 @@ import (
 	"encoding/hex"
 	"fmt"
 	"os"
+	"time"
 )
 
 func UploadFile(sourcePath string, vaultPath string, session *Session) error {
 	repoURL := fmt.Sprintf("git@github.com:%s/.zephyrus.git", session.Username)
 
 	// 1. Read source
+	PrintProgressStep(1, 5, "Reading file...")
 	data, err := os.ReadFile(sourcePath)
 	if err != nil {
 		return err
 	}
+	PrintCompletionLine("File read successfully")
 
 	// 2. Determine Storage Name and File Key
+	PrintProgressStep(2, 5, "Validating vault...")
 	var realName string
 	var fileKey []byte
 
@@ -48,20 +52,27 @@ func UploadFile(sourcePath string, vaultPath string, session *Session) error {
 		session.Index.AddFile(vaultPath, realName, encryptedKeyHex)
 		fmt.Printf("Uploading new file: %s as %s\n", vaultPath, realName)
 	}
+	PrintCompletionLine("File validated")
 
 	// 3. Encrypt file data with the per-file key
+	PrintProgressStep(3, 5, "Encrypting file...")
+	time.Sleep(time.Millisecond * 100) // Simulate work for visibility
 	encryptedData, err := EncryptWithKey(data, fileKey)
 	if err != nil {
 		return err
 	}
+	PrintCompletionLine("File encrypted")
 
 	// 4. Encrypt updated index
+	PrintProgressStep(4, 5, "Updating vault index...")
 	indexBytes, err := session.Index.ToBytes(session.Password)
 	if err != nil {
 		return err
 	}
+	PrintCompletionLine("Vault index updated")
 
 	// 5. Push to Git
+	PrintProgressStep(5, 5, "Uploading to GitHub...")
 	filesToPush := map[string][]byte{
 		realName:        encryptedData,
 		".config/index": indexBytes,
@@ -71,6 +82,7 @@ func UploadFile(sourcePath string, vaultPath string, session *Session) error {
 	if err != nil {
 		return err
 	}
+	PrintCompletionLine("Upload to GitHub completed")
 
 	// 6. Save updated index to local session to bypass cache
 	return nil