feat(dotfile): adds dotfiles backup and integration

Author: Vinayak-RZ

go.mod

@@ -1,7 +1,7 @@
-module github.com/mdgspace/sysreplicate
-
-go 1.24.3
-
-require golang.org/x/term v0.32.0
-
-require golang.org/x/sys v0.33.0 // indirect
+module github.com/mdgspace/sysreplicate
+
+go 1.24.3
+
+require golang.org/x/term v0.32.0
+
+require golang.org/x/sys v0.33.0 // indirect

go.sum

@@ -1,4 +1,4 @@
-golang.org/x/sys v0.33.0 h1:q3i8TbbEz+JRD9ywIRlyRAQbM0qF7hu24q3teo2hbuw=
-golang.org/x/sys v0.33.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
-golang.org/x/term v0.32.0 h1:DR4lr0TjUs3epypdhTOkMmuF5CDFJ/8pOnbzMZPQ7bg=
-golang.org/x/term v0.32.0/go.mod h1:uZG1FhGx848Sqfsq4/DlJr3xGGsYMu/L5GW4abiaEPQ=
+golang.org/x/sys v0.33.0 h1:q3i8TbbEz+JRD9ywIRlyRAQbM0qF7hu24q3teo2hbuw=
+golang.org/x/sys v0.33.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
+golang.org/x/term v0.32.0 h1:DR4lr0TjUs3epypdhTOkMmuF5CDFJ/8pOnbzMZPQ7bg=
+golang.org/x/term v0.32.0/go.mod h1:uZG1FhGx848Sqfsq4/DlJr3xGGsYMu/L5GW4abiaEPQ=

main.go

@@ -1,8 +1,9 @@
-package main
-
-import "github.com/mdgspace/sysreplicate/system"
-
-// main is the entry point for the program.
-func main() {
-	system.Run()
-}
+package main
+
+import (
+	"github.com/mdgspace/sysreplicate/system"
+)
+// main is the entry point for the program.
+func main() {
+	system.Run()
+}

system/backup/dotfile_scanner.go

@@ -0,0 +1,88 @@
+package backup
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+)
+
+var DotfilePaths = []string{
+	"~/.bashrc",
+	"~/.zshrc",
+	"~/.vimrc",
+	"~/.config",
+	"~/.bash_history",
+	"~/.zsh_history",
+	"~/.gitconfig",
+	"~/.profile",
+	"~/.npmrc",
+}
+
+type Dotfile struct {
+	Path     string
+	RelPath  string
+	IsDir    bool
+	IsBinary bool
+	Mode     os.FileMode
+	Content  string // ignore for the binary files
+}
+
+// expand ~ to home dir
+func expandHome(path string) string {
+	if strings.HasPrefix(path, "~") {
+		home, err := os.UserHomeDir()
+		if err == nil {
+			return filepath.Join(home, path[2:])
+		}
+	}
+	return path
+}
+
+// check for binary files
+func containsNullByte(data []byte) bool {
+	for _, b := range data {
+		if b == 0 {
+			return true
+		}
+	}
+	return false
+}
+
+// ScanDotfiles scans all dotfiles and returns their metadata + content
+func ScanDotfiles() ([]Dotfile, error) {
+	var results []Dotfile
+	home, _ := os.UserHomeDir()
+
+	for _, raw := range DotfilePaths {
+		full := expandHome(raw)
+
+		info, err := os.Stat(full)
+		if err != nil {
+			continue
+		}
+
+		relPath, _ := filepath.Rel(home, full)
+		entry := Dotfile{
+			Path:    full,
+			RelPath: relPath,
+			IsDir:   info.IsDir(),
+			Mode:    info.Mode(),
+		}
+
+		if !info.IsDir() {
+			data, err := os.ReadFile(full)
+			if err != nil {
+				continue
+			}
+			if containsNullByte(data) {
+				entry.IsBinary = true
+			} else {
+				entry.Content = string(data)
+			}
+		}
+
+		results = append(results, entry)
+	}
+
+	return results, nil
+}

system/backup/dotfiles_backup.go

@@ -0,0 +1,79 @@
+package backup
+
+import (
+	"archive/tar"
+	"compress/gzip"
+	"encoding/json"
+	"fmt"
+	"io"
+	"os"
+	"time"
+)
+
+type BackupMetadata struct {
+	Timestamp time.Time `json:"timestamp"`
+	Hostname  string    `json:"hostname"`
+	Files     []Dotfile `json:"files"`
+}
+
+type DotfileBackupManager struct{}
+
+func NewDotfileBackupManager() *DotfileBackupManager {
+	return &DotfileBackupManager{}
+}
+
+func (db *DotfileBackupManager) CreateDotfileBackup(outputTar string) error {
+	files, err := ScanDotfiles()
+	if err != nil {
+		return fmt.Errorf("error scanning dotfiles: %w", err)
+	}
+
+	hostname, _ := os.Hostname()
+
+	meta := BackupMetadata{
+		Timestamp: time.Now(),
+		Hostname:  hostname,
+		Files:     files,
+	}
+
+	tarFile, err := os.Create(outputTar)
+	if err != nil {
+		return fmt.Errorf("failed to create tar file: %w", err)
+	}
+	defer tarFile.Close()
+
+	gzipWriter := gzip.NewWriter(tarFile)
+	defer gzipWriter.Close()
+	tarWriter := tar.NewWriter(gzipWriter)
+	defer tarWriter.Close()
+
+	// Write metadata JSON
+	metaBytes, _ := json.MarshalIndent(meta, "", "  ")
+	tarWriter.WriteHeader(&tar.Header{
+		Name: "backup.json",
+		Mode: 0644,
+		Size: int64(len(metaBytes)),
+	})
+	tarWriter.Write(metaBytes)
+
+	// Add dotfiles
+	for _, f := range files {
+		if f.IsDir {
+			continue
+		}
+		file, err := os.Open(f.Path)
+		if err != nil {
+			continue
+		}
+		defer file.Close()
+
+		info, _ := file.Stat()
+		hdr, _ := tar.FileInfoHeader(info, "")
+		hdr.Name = f.RelPath
+		tarWriter.WriteHeader(hdr)
+		io.Copy(tarWriter, file)
+	}
+
+	fmt.Println("Backup complete:", outputTar)
+	return nil
+}

system/backup/encrypt.go

@@ -1,56 +1,56 @@
-package backup
-
-import (
-    "crypto/aes"
-    "crypto/cipher"
-    "crypto/rand"
-    "encoding/base64"
-    "fmt"
-    "io"
-    "os"
-)
-
-//simplified encryption config without password
-type EncryptionConfig struct {
-    Key []byte // Direct 32-byte key instead of password+salt
-}
-
-//AES-GCM encryption with direct key (no password derivation)
-func EncryptFile(filePath string, config *EncryptionConfig) (string, error) {
-    data, err := os.ReadFile(filePath)
-    if err != nil {
-        return "", fmt.Errorf("failed to read file %s: %w", filePath, err)
-    }
-
-    //use direct key (no password derivation)
-    block, err := aes.NewCipher(config.Key)
-    if err != nil {
-        return "", fmt.Errorf("failed to create cipher: %w", err)
-    }
-
-    // GCM mode from AES block
-    gcm, err := cipher.NewGCM(block)
-    if err != nil {
-        return "", fmt.Errorf("failed to create GCM: %w", err)
-    }
-
-    // Generate nonce
-    nonce := make([]byte, gcm.NonceSize())
-    if _, err := io.ReadFull(rand.Reader, nonce); err != nil {
-        return "", fmt.Errorf("failed to generate nonce: %w", err)
-    }
-
-    //encrypt data with nonce
-    ciphertext := gcm.Seal(nonce, nonce, data, nil)
-
-    //encode to base64
-    encoded := base64.StdEncoding.EncodeToString(ciphertext)
-    return encoded, nil
-}
-
-//generate a random 32-byte key for AES-256
-func GenerateKey() ([]byte, error) {
-    key := make([]byte, 32) // 32 bytes for AES-256
-    _, err := rand.Read(key)
-    return key, err
-}
+package backup
+
+import (
+    "crypto/aes"
+    "crypto/cipher"
+    "crypto/rand"
+    "encoding/base64"
+    "fmt"
+    "io"
+    "os"
+)
+
+//simplified encryption config without password
+type EncryptionConfig struct {
+    Key []byte // Direct 32-byte key instead of password+salt
+}
+
+//AES-GCM encryption with direct key (no password derivation)
+func EncryptFile(filePath string, config *EncryptionConfig) (string, error) {
+    data, err := os.ReadFile(filePath)
+    if err != nil {
+        return "", fmt.Errorf("failed to read file %s: %w", filePath, err)
+    }
+
+    //use direct key (no password derivation)
+    block, err := aes.NewCipher(config.Key)
+    if err != nil {
+        return "", fmt.Errorf("failed to create cipher: %w", err)
+    }
+
+    // GCM mode from AES block
+    gcm, err := cipher.NewGCM(block)
+    if err != nil {
+        return "", fmt.Errorf("failed to create GCM: %w", err)
+    }
+
+    // Generate nonce
+    nonce := make([]byte, gcm.NonceSize())
+    if _, err := io.ReadFull(rand.Reader, nonce); err != nil {
+        return "", fmt.Errorf("failed to generate nonce: %w", err)
+    }
+
+    //encrypt data with nonce
+    ciphertext := gcm.Seal(nonce, nonce, data, nil)
+
+    //encode to base64
+    encoded := base64.StdEncoding.EncodeToString(ciphertext)
+    return encoded, nil
+}
+
+//generate a random 32-byte key for AES-256
+func GenerateKey() ([]byte, error) {
+    key := make([]byte, 32) // 32 bytes for AES-256
+    _, err := rand.Read(key)
+    return key, err
+}