Added Rollback Functionality

Author: skssmd

COMMANDS.md

@@ -445,6 +445,59 @@ graft sync compose -h           # Upload only (no restart)
 
 ---
 
+## Rollback Commands
+
+Manage project versioning and rollbacks. Graft automatically creates a backup of your configuration and images during every `sync`.
+
+### `graft rollback`
+Roll back the entire project to a previous backup version.
+
+```bash
+graft rollback
+```
+
+**What it does:**
+1. Lists available backups with timestamps.
+2. Interactively prompts you to select a version.
+3. Restores `docker-compose.yml` and environment files.
+4. Stops current services and clearing images to prevent tag conflicts.
+5. Loads and re-tags compressed images from the backup.
+6. Restarts all services using the restored versions with `--pull never`.
+
+---
+
+### `graft rollback service <name>`
+Roll back only a specific service to a previous version.
+
+```bash
+graft rollback service backend
+```
+
+**What it does:**
+1. Lists available backups.
+2. Extracts the specific service configuration from the selected backup.
+3. Updates the remote `docker-compose.yml` for only that service.
+4. Stops the service and restores its specific image.
+5. Restarts the targeted service without affecting others using `--pull never`.
+
+---
+
+### `graft rollback config`
+Configure how many rollback versions Graft should keep on the server.
+
+```bash
+graft rollback config
+```
+
+**Interactive Options:**
+- **Change Limit**: Set how many historical versions to retain (default: 3).
+- **Disable Rollbacks**: Set limit to `0` to stop creating backups.
+- **Remove Config**: Delete the rollback configuration from the project.
+
+**Note:** Changes are synced to both your local `.graft/project.json` and the remote `graft-hook` configuration.
+
+---
+
 ## DNS Mapping Commands
 
 ### `graft map`

README.md

@@ -30,10 +30,10 @@ Built for the solo developer rotating between cloud free tiers and the small tea
 **Graft's approach:**
 ```bash
 # Local development
-docker compose logs backend
+docker compose up -d --pull always
 
 # Production with Graft (same commands)
-graft logs backend
+graft up -d --pull always
 ```
 
 Same workflow. Different server. That's it.
@@ -93,6 +93,16 @@ graft exec backend cat /app/config.yml # Read files
 graft run alpine echo "hello"          # Quick throwaway commands
 ```
 
+**Automatic Dns Mapping for Cloudflare based DNSs:**
+```bash
+graft map  #Automatically detects domains by service and sets DNS 
+```
+**Easy Rollback to previous deployments:**
+```bash
+graft rollback  #Display previous deployments and allow you to rollback to any of them
+graft rollback config #Set up how many versions to keep
+``` 
+
 **Important caveat:** Interactive sessions (like `graft exec -it backend bash`) don't work due to SSH-in-SSH limitations. For that, use `graft -sh` to drop into a proper SSH session first, then run your Docker commands there.
 
 **All your muscle memory still works.** If you know Docker Compose, you know Graft. The only difference is your services are running on a server in some datacenter instead of melting your laptop's CPU.
@@ -180,6 +190,8 @@ graft sync
 graft ps                    # Check status
 graft logs backend          # View logs
 graft restart frontend      # Restart service
+graft map #automatically updates cloudflare dns records
+graft rollback #roll back to previous versions
 ```
 
 **That's it.** Your project is running on the server, managed via familiar commands.
@@ -231,18 +243,11 @@ graft exec backend cat /app/log.txt # One-liner commands work
 
 **Not for:**
 - Multi-region deployments
-- Auto-scaling based on load (yet)
-- Complex microservice meshes
-- Teams that need Kubernetes features
-
-If you need Kubernetes, use Kubernetes. Graft is for everyone else who just wants to deploy Docker Compose projects and get back to building features.
-
+- Multi-server deployments
 ---
 
 ## 🏷️ What Makes This Different
 
-**vs Kubernetes:** Simpler. Uses Docker Compose instead of new abstractions. For when you need to deploy services, not manage a cluster.
-
 **vs Dokku/CapRover:** No web UI, pure CLI. More flexible deployment modes. Better for managing multiple projects across multiple servers.
 
 **vs Railway/Render:** Self-hosted. No vendor lock-in. Works anywhere you have SSH. No monthly bills that scale with your success.
@@ -255,8 +260,6 @@ If you need Kubernetes, use Kubernetes. Graft is for everyone else who just want
 
 Planned features:
 - Dev/prod environment separation
-- Database backup automation (with S3/R2) [Added-Experimental]
-- Rollback mechanism
 - Slack/Discord notifications
 - Health checks and monitoring
 

cmd/graft/main.go

@@ -30,7 +30,7 @@ func main() {
 	if len(args) > 0 {
 		arg := args[0]
 		if arg == "-v" || arg == "--version" {
-			fmt.Println("v2.1.3")
+			fmt.Println("v2.2.0")
 			return
 		}
 		if arg == "--help" {
@@ -140,7 +140,17 @@ func main() {
 			runSync(args[1:])
 		}
 	case "rollback":
-		runRollback()
+		if len(args) > 1 && args[1] == "config" {
+			runRollbackConfig()
+		} else if len(args) > 1 && args[1] == "service" {
+			if len(args) < 3 {
+				fmt.Println("Usage: graft rollback service <service-name>")
+				return
+			}
+			runServiceRollback(args[2])
+		} else {
+			runRollback()
+		}
 	case "registry":
 		if len(args) < 2 {
 			fmt.Println("Usage: graft registry [ls|add|del]")
@@ -233,6 +243,8 @@ func printUsage() {
 	fmt.Println("  db/redis <name> init      Initialize shared infrastructure")
 	fmt.Println("  sync [service] [-h]       Deploy project to server")
 	fmt.Println("  rollback                  Restore project to a previous backup")
+	fmt.Println("  rollback service <name>   Restore specific service from a backup")
+	fmt.Println("  rollback config           Configure rollback versions to keep")
 	fmt.Println("  logs <service>            Stream service logs")
 	fmt.Println("  mode                      Change project deployment mode")
 	fmt.Println("  map                       Map all service domains to Cloudflare DNS")
@@ -1889,7 +1901,7 @@ func runRollback() {
 	}
 
 	if meta.RollbackBackups <= 0 {
-		fmt.Println("❌ Rollback is not configured for this project. Setup rollbacks during 'graft init' or update your project configuration.")
+		fmt.Println("❌ Rollback is not configured for this project. Setup rollbacks during 'graft init' or update your project configuration with 'graft rollback config'.")
 		return
 	}
 
@@ -1954,6 +1966,179 @@ func runRollback() {
 	}
 }
 
+func runRollbackConfig() {
+	meta, err := config.LoadProjectMetadata()
+	if err != nil {
+		fmt.Println("Error: Could not load project metadata. Run 'graft init' first.")
+		return
+	}
+
+	cfg, err := config.LoadConfig()
+	if err != nil {
+		fmt.Println("Error: No config found.")
+		return
+	}
+
+	fmt.Printf("🔄 Rollback Configuration for project: %s\n", meta.Name)
+	fmt.Printf("Current versions to keep: %d\n", meta.RollbackBackups)
+
+	reader := bufio.NewReader(os.Stdin)
+	fmt.Print("\nDo you want to change or remove rollback configuration? (y: change, n: remove, enter: skip): ")
+	input, _ := reader.ReadString('\n')
+	input = strings.ToLower(strings.TrimSpace(input))
+
+	var newVersionToKeep int
+	var action string
+
+	if input == "y" || input == "yes" {
+		fmt.Print("Enter the new number of versions to keep: ")
+		rollInput, _ := reader.ReadString('\n')
+		newVersionToKeep, err = strconv.Atoi(strings.TrimSpace(rollInput))
+		if err != nil || newVersionToKeep < 0 {
+			fmt.Println("❌ Invalid input. Number must be 0 or greater.")
+			return
+		}
+		action = "updated"
+	} else if input == "n" || input == "no" {
+		newVersionToKeep = 0
+		action = "removed"
+	} else {
+		fmt.Println("⏭️  Skipping configuration.")
+		return
+	}
+
+	fmt.Printf("🔍 Connecting to %s (%s) to update remote configuration...\n", cfg.Server.RegistryName, cfg.Server.Host)
+	client, err := ssh.NewClient(cfg.Server.Host, cfg.Server.Port, cfg.Server.User, cfg.Server.KeyPath)
+	if err != nil {
+		fmt.Printf("Error: %v\n", err)
+		return
+	}
+	defer client.Close()
+
+	// 1. Update remote projects registry
+	tmpFile := filepath.Join(os.TempDir(), "remote_projects.json")
+	remoteProjects := make(map[string]interface{})
+	if err := client.DownloadFile(config.RemoteProjectsPath, tmpFile); err == nil {
+		data, _ := os.ReadFile(tmpFile)
+		json.Unmarshal(data, &remoteProjects)
+		os.Remove(tmpFile)
+	}
+
+	if entry, exists := remoteProjects[meta.Name]; exists {
+		if m, ok := entry.(map[string]interface{}); ok {
+			if newVersionToKeep > 0 {
+				m["rollback_backups"] = newVersionToKeep
+			} else {
+				delete(m, "rollback_backups")
+			}
+			remoteProjects[meta.Name] = m
+		}
+	} else {
+		// If it doesn't exist for some reason, create it
+		remoteProjects[meta.Name] = map[string]interface{}{
+			"path":             meta.RemotePath,
+			"rollback_backups": newVersionToKeep,
+		}
+	}
+
+	data, _ := json.MarshalIndent(remoteProjects, "", "  ")
+	os.WriteFile(tmpFile, data, 0644)
+	if err := client.UploadFile(tmpFile, config.RemoteProjectsPath); err != nil {
+		fmt.Printf("❌ Failed to update remote registry: %v\n", err)
+		return
+	}
+	os.Remove(tmpFile)
+
+	// 2. Update local metadata
+	meta.RollbackBackups = newVersionToKeep
+	if err := config.SaveProjectMetadata(meta); err != nil {
+		fmt.Printf("⚠️  Warning: Could not save local metadata: %v\n", err)
+	}
+
+	fmt.Printf("✅ Rollback configuration %s successfully.\n", action)
+
+	// 3. Restart Webhook
+	fmt.Println("🔄 Restarting graft-hook to apply changes...")
+	if err := client.RunCommand("cd /opt/graft/webhook && sudo docker compose down && sudo docker compose up -d", os.Stdout, os.Stderr); err != nil {
+		fmt.Printf("⚠️  Warning: Failed to restart graft-hook: %v\n", err)
+	} else {
+		fmt.Println("✅ graft-hook restarted successfully.")
+	}
+}
+
+func runServiceRollback(serviceName string) {
+	meta, err := config.LoadProjectMetadata()
+	if err != nil {
+		fmt.Println("Error: Could not load project metadata. Run 'graft init' first.")
+		return
+	}
+
+	if meta.RollbackBackups <= 0 {
+		fmt.Println("❌ Rollback is not configured for this project. Setup rollbacks during 'graft init' or update your project configuration with 'graft rollback config'.")
+		return
+	}
+
+	cfg, err := config.LoadConfig()
+	if err != nil {
+		fmt.Println("Error: No config found.")
+		return
+	}
+
+	fmt.Printf("🔍 Connecting to %s (%s)...\n", cfg.Server.RegistryName, cfg.Server.Host)
+	client, err := ssh.NewClient(cfg.Server.Host, cfg.Server.Port, cfg.Server.User, cfg.Server.KeyPath)
+	if err != nil {
+		fmt.Printf("Error: %v\n", err)
+		return
+	}
+	defer client.Close()
+
+	backupBase := fmt.Sprintf("/opt/graft/backup/%s", meta.Name)
+	// List directories in backup path, newest first
+	out, err := client.GetCommandOutput(fmt.Sprintf("sudo ls -1dt %s/* 2>/dev/null", backupBase))
+	if err != nil || strings.TrimSpace(out) == "" {
+		fmt.Println("❌ No backups found on server.")
+		return
+	}
+
+	backups := strings.Split(strings.TrimSpace(out), "\n")
+	fmt.Println("\n📦 Available Backups (Newest First):")
+	var choices []string
+	for i, p := range backups {
+		timestamp := filepath.Base(p)
+		formatted := formatTimestamp(timestamp)
+		fmt.Printf("  [%d] %s\n", i+1, formatted)
+		choices = append(choices, timestamp)
+	}
+
+	fmt.Printf("\nSelect a version to rollback service '%s' to [1-%d] (or enter to cancel): ", serviceName, len(choices))
+	reader := bufio.NewReader(os.Stdin)
+	input, _ := reader.ReadString('\n')
+	input = strings.TrimSpace(input)
+	if input == "" {
+		fmt.Println("❌ Rollback cancelled.")
+		return
+	}
+
+	choice, err := strconv.Atoi(input)
+	if err != nil || choice < 1 || choice > len(choices) {
+		fmt.Println("❌ Invalid selection.")
+		return
+	}
+
+	selected := choices[choice-1]
+
+	p := &deploy.Project{
+		Name:            meta.Name,
+		RollbackBackups: meta.RollbackBackups,
+	}
+
+	if err := deploy.RestoreServiceRollback(client, p, selected, serviceName, os.Stdout, os.Stderr); err != nil {
+		fmt.Printf("❌ Rollback failed: %v\n", err)
+	} else {
+		fmt.Printf("\n✅ Service '%s' rollback successful!\n", serviceName)
+	}
+}
+
 func formatTimestamp(ts string) string {
 	if len(ts) != 14 {
 		return ts