@mmmbuto/masix 0.4.0 → 0.4.2

package/packages/plugin-base/codex-backend/source/src/patch.rs

@@ -0,0 +1,767 @@
+//! Patch preview and apply with backup/rollback safety
+//!
+//! Provides secure patch operations:
+//! - Preview diff without applying
+//! - Apply with automatic backup
+//! - Rollback capability
+
+use crate::{CodingError, ResolvedWorkspace};
+use std::collections::HashMap;
+use std::path::{Path, PathBuf};
+use std::time::{SystemTime, UNIX_EPOCH};
+
+/// Backup metadata for rollback
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+pub struct BackupManifest {
+    /// Unique backup ID
+    pub id: String,
+    /// Timestamp of backup creation
+    pub timestamp: u64,
+    /// Original files with their backup paths
+    pub files: HashMap<String, BackupEntry>,
+    /// Workspace root at time of backup
+    pub workspace_root: String,
+}
+
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+pub struct BackupEntry {
+    /// Relative path from workspace root
+    pub original_path: String,
+    /// Absolute path to backup file
+    pub backup_path: String,
+    /// Hash of original content (for verification)
+    pub content_hash: String,
+    /// Whether the file existed before
+    pub existed: bool,
+}
+
+/// Patch preview result
+#[derive(Debug, Clone, serde::Serialize, Default)]
+pub struct PatchPreview {
+    /// Files that would be modified
+    pub files_modified: Vec<String>,
+    /// Files that would be created
+    pub files_created: Vec<String>,
+    /// Files that would be deleted
+    pub files_deleted: Vec<String>,
+    /// Estimated lines changed
+    pub lines_added: usize,
+    pub lines_removed: usize,
+    /// Warnings (e.g., binary files, large changes)
+    pub warnings: Vec<String>,
+    /// Whether the patch appears valid
+    pub valid: bool,
+    /// Parse errors if invalid
+    pub errors: Vec<String>,
+}
+
+/// Patch apply result
+#[derive(Debug, Clone, serde::Serialize)]
+pub struct PatchApplyResult {
+    /// Whether the patch was applied successfully
+    pub success: bool,
+    /// Backup ID for rollback
+    pub backup_id: Option<String>,
+    /// Files actually modified
+    pub files_modified: Vec<String>,
+    /// Files actually created
+    pub files_created: Vec<String>,
+    /// Errors encountered
+    pub errors: Vec<String>,
+}
+
+/// Patch preview tool
+pub fn preview_patch(
+    diff: &str,
+    workspace: &ResolvedWorkspace,
+) -> Result<PatchPreview, CodingError> {
+    let mut preview = PatchPreview::default();
+
+    // Parse unified diff format
+    let hunks = parse_diff_hunks(diff);
+
+    for hunk in hunks {
+        // Build full path and validate it's within workspace
+        let full_path = if hunk.file_path.is_absolute() {
+            hunk.file_path.clone()
+        } else {
+            workspace.root.join(&hunk.file_path)
+        };
+
+        if let Err(e) = workspace.is_path_allowed(&full_path) {
+            preview.errors.push(format!(
+                "Path '{}' violates workspace bounds: {}",
+                hunk.file_path.display(),
+                e
+            ));
+            preview.valid = false;
+            continue;
+        }
+
+        // Categorize the change
+        let relative = hunk
+            .file_path
+            .strip_prefix(&workspace.root)
+            .unwrap_or(&hunk.file_path)
+            .to_string_lossy()
+            .to_string();
+
+        if hunk.is_creation {
+            if !preview.files_created.contains(&relative) {
+                preview.files_created.push(relative);
+            }
+        } else if hunk.is_deletion {
+            if !preview.files_deleted.contains(&relative) {
+                preview.files_deleted.push(relative);
+            }
+        } else {
+            if !preview.files_modified.contains(&relative) {
+                preview.files_modified.push(relative);
+            }
+        }
+
+        preview.lines_added += hunk.lines_added;
+        preview.lines_removed += hunk.lines_removed;
+    }
+
+    // Add warnings for large changes
+    if preview.lines_added + preview.lines_removed > 1000 {
+        preview
+            .warnings
+            .push("Large patch: more than 1000 lines changed".into());
+    }
+
+    if preview.files_modified.len() + preview.files_created.len() + preview.files_deleted.len() > 50
+    {
+        preview
+            .warnings
+            .push("Many files affected: more than 50 files".into());
+    }
+
+    preview.valid = preview.errors.is_empty();
+    Ok(preview)
+}
+
+/// Apply a patch with backup
+pub fn apply_patch(
+    diff: &str,
+    workspace: &ResolvedWorkspace,
+    create_backup: bool,
+) -> Result<PatchApplyResult, CodingError> {
+    // First preview to validate
+    let preview = preview_patch(diff, workspace)?;
+    if !preview.valid {
+        return Ok(PatchApplyResult {
+            success: false,
+            backup_id: None,
+            files_modified: Vec::new(),
+            files_created: Vec::new(),
+            errors: preview.errors,
+        });
+    }
+
+    // Create backup manifest if requested
+    let backup_id = if create_backup {
+        let id = generate_backup_id();
+        let manifest = create_backup_manifest(&preview, workspace)?;
+        save_backup_manifest(&id, manifest, workspace)?;
+        Some(id)
+    } else {
+        None
+    };
+
+    let mut result = PatchApplyResult {
+        success: true,
+        backup_id,
+        files_modified: Vec::new(),
+        files_created: Vec::new(),
+        errors: Vec::new(),
+    };
+
+    // Parse and apply hunks
+    let hunks = parse_diff_hunks(diff);
+
+    for hunk in hunks {
+        if let Err(e) = apply_hunk(&hunk, workspace) {
+            result.errors.push(format!(
+                "Failed to apply to {}: {}",
+                hunk.file_path.display(),
+                e
+            ));
+            result.success = false;
+        } else {
+            let relative = hunk
+                .file_path
+                .strip_prefix(&workspace.root)
+                .unwrap_or(&hunk.file_path)
+                .to_string_lossy()
+                .to_string();
+
+            if hunk.is_creation {
+                if !result.files_created.contains(&relative) {
+                    result.files_created.push(relative);
+                }
+            } else if !hunk.is_deletion && !result.files_modified.contains(&relative) {
+                result.files_modified.push(relative);
+            }
+        }
+    }
+
+    Ok(result)
+}
+
+/// Rollback a patch using backup
+pub fn rollback_patch(
+    backup_id: &str,
+    workspace: &ResolvedWorkspace,
+) -> Result<Vec<String>, CodingError> {
+    let manifest = load_backup_manifest(backup_id, workspace)?;
+    let mut restored = Vec::new();
+
+    for (relative, entry) in &manifest.files {
+        let original_path = workspace.root.join(relative);
+
+        if entry.existed {
+            // Validate backup path is not empty
+            if entry.backup_path.is_empty() {
+                return Err(CodingError::IoError(format!(
+                    "Backup path is empty for file '{}' — manifest may be corrupted",
+                    relative
+                )));
+            }
+            // Restore from backup
+            if Path::new(&entry.backup_path).exists() {
+                std::fs::copy(&entry.backup_path, &original_path).map_err(|e| {
+                    CodingError::IoError(format!("Failed to restore {}: {}", relative, e))
+                })?;
+                restored.push(relative.clone());
+            } else {
+                return Err(CodingError::IoError(format!(
+                    "Backup file not found at '{}' for '{}'",
+                    entry.backup_path, relative
+                )));
+            }
+        } else {
+            // File was created by patch, remove it
+            if original_path.exists() {
+                std::fs::remove_file(&original_path).map_err(|e| {
+                    CodingError::IoError(format!("Failed to remove {}: {}", relative, e))
+                })?;
+            }
+            restored.push(format!("{} (removed)", relative));
+        }
+    }
+
+    // Clean up backup directory
+    let backup_dir = workspace
+        .root
+        .join(".masix")
+        .join("backups")
+        .join(backup_id);
+    if backup_dir.exists() {
+        let _ = std::fs::remove_dir_all(&backup_dir);
+    }
+
+    Ok(restored)
+}
+
+// Internal types and functions
+
+struct DiffHunk {
+    file_path: PathBuf,
+    is_creation: bool,
+    is_deletion: bool,
+    lines_added: usize,
+    lines_removed: usize,
+    content: String,
+}
+
+fn parse_diff_hunks(diff: &str) -> Vec<DiffHunk> {
+    let mut hunks = Vec::new();
+    let mut current_file: Option<PathBuf> = None;
+    let mut current_is_creation = false;
+    let mut current_is_deletion = false;
+    let mut current_lines_added = 0;
+    let mut current_lines_removed = 0;
+    let mut current_content = String::new();
+    let mut saw_dev_null_in_old = false;
+
+    for line in diff.lines() {
+        if line.starts_with("--- ") {
+            // Old file header
+            let path_part = line.split_once(' ').map(|(_, p)| p.trim()).unwrap_or("");
+            saw_dev_null_in_old = path_part.contains("/dev/null");
+        } else if line.starts_with("+++ ") {
+            // New file header - finalize previous file if any
+            if let Some(file) = current_file.take() {
+                hunks.push(DiffHunk {
+                    file_path: file,
+                    is_creation: current_is_creation,
+                    is_deletion: current_is_deletion,
+                    lines_added: current_lines_added,
+                    lines_removed: current_lines_removed,
+                    content: current_content.clone(),
+                });
+            }
+
+            let path_part = line.split_once(' ').map(|(_, p)| p.trim()).unwrap_or("");
+            let path = path_part
+                .strip_prefix("b/")
+                .or_else(|| path_part.strip_prefix("a/"))
+                .unwrap_or(path_part);
+
+            if path != "/dev/null" && !path.is_empty() {
+                current_file = Some(PathBuf::from(path));
+                current_is_creation = saw_dev_null_in_old;
+                current_is_deletion = path_part.contains("/dev/null");
+            }
+
+            current_lines_added = 0;
+            current_lines_removed = 0;
+            current_content.clear();
+            saw_dev_null_in_old = false;
+        } else if line.starts_with('+') && !line.starts_with("+++") {
+            current_lines_added += 1;
+            current_content.push_str(line);
+            current_content.push('\n');
+        } else if line.starts_with('-') && !line.starts_with("---") {
+            current_lines_removed += 1;
+            current_content.push_str(line);
+            current_content.push('\n');
+        } else if line.starts_with("@@ ") {
+            // Hunk header - continue with current file
+            current_content.push_str(line);
+            current_content.push('\n');
+        } else if line.starts_with(' ') {
+            // Context line — needed for apply_line_patch positioning
+            current_content.push_str(line);
+            current_content.push('\n');
+        }
+    }
+
+    // Don't forget the last file
+    if let Some(file) = current_file {
+        hunks.push(DiffHunk {
+            file_path: file,
+            is_creation: current_is_creation,
+            is_deletion: current_is_deletion,
+            lines_added: current_lines_added,
+            lines_removed: current_lines_removed,
+            content: current_content,
+        });
+    }
+
+    hunks
+}
+
+fn apply_hunk(hunk: &DiffHunk, workspace: &ResolvedWorkspace) -> Result<(), CodingError> {
+    let target_path = workspace.root.join(&hunk.file_path);
+
+    if hunk.is_creation {
+        // Create new file
+        if let Some(parent) = target_path.parent() {
+            std::fs::create_dir_all(parent)
+                .map_err(|e| CodingError::IoError(format!("Failed to create dir: {}", e)))?;
+        }
+
+        // Extract content from diff (lines starting with +)
+        let content: String = hunk
+            .content
+            .lines()
+            .filter(|l| l.starts_with('+') && !l.starts_with("+++"))
+            .map(|l| l.strip_prefix('+').unwrap_or(l))
+            .collect::<Vec<_>>()
+            .join("\n");
+
+        std::fs::write(&target_path, content).map_err(|e| {
+            CodingError::IoError(format!("Failed to write {}: {}", target_path.display(), e))
+        })?;
+    } else if hunk.is_deletion {
+        // Delete file
+        if target_path.exists() {
+            std::fs::remove_file(&target_path).map_err(|e| {
+                CodingError::IoError(format!("Failed to delete {}: {}", target_path.display(), e))
+            })?;
+        }
+    } else {
+        // Apply patch to existing file
+        if !target_path.exists() {
+            return Err(CodingError::ToolError(format!(
+                "File {} does not exist",
+                hunk.file_path.display()
+            )));
+        }
+
+        let existing = std::fs::read_to_string(&target_path).map_err(|e| {
+            CodingError::IoError(format!("Failed to read {}: {}", target_path.display(), e))
+        })?;
+
+        // Simple line-based patch application
+        let result = apply_line_patch(&existing, &hunk.content)?;
+
+        std::fs::write(&target_path, result).map_err(|e| {
+            CodingError::IoError(format!("Failed to write {}: {}", target_path.display(), e))
+        })?;
+    }
+
+    Ok(())
+}
+
+fn apply_line_patch(original: &str, patch: &str) -> Result<String, CodingError> {
+    let original_lines: Vec<&str> = original.lines().collect();
+    let mut result_lines: Vec<String> = Vec::new();
+    let mut current_pos: usize = 0;
+
+    for line in patch.lines() {
+        if line.starts_with("@@ ") {
+            if let Some(old_start) = parse_hunk_old_start(line) {
+                let target = if old_start > 0 { old_start - 1 } else { 0 };
+                // Copy unchanged lines up to the hunk start
+                while current_pos < target && current_pos < original_lines.len() {
+                    result_lines.push(original_lines[current_pos].to_string());
+                    current_pos += 1;
+                }
+            }
+        } else if line.starts_with('+') && !line.starts_with("+++") {
+            result_lines.push(line.strip_prefix('+').unwrap_or(line).to_string());
+        } else if line.starts_with('-') && !line.starts_with("---") {
+            current_pos += 1;
+        } else if line.starts_with(' ') {
+            if current_pos < original_lines.len() {
+                result_lines.push(original_lines[current_pos].to_string());
+                current_pos += 1;
+            }
+        }
+    }
+
+    // Append remaining original lines after last hunk
+    while current_pos < original_lines.len() {
+        result_lines.push(original_lines[current_pos].to_string());
+        current_pos += 1;
+    }
+
+    let mut result = result_lines.join("\n");
+    if original.ends_with('\n') {
+        result.push('\n');
+    }
+    Ok(result)
+}
+
+fn parse_hunk_old_start(header: &str) -> Option<usize> {
+    let after = header.strip_prefix("@@ -")?;
+    let num = after.split(|c: char| c == ',' || c == ' ').next()?;
+    num.parse().ok()
+}
+
+fn generate_backup_id() -> String {
+    let now = SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .unwrap_or_default();
+    format!("backup_{}", now.as_millis())
+}
+
+fn create_backup_manifest(
+    preview: &PatchPreview,
+    workspace: &ResolvedWorkspace,
+) -> Result<BackupManifest, CodingError> {
+    let now = SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .unwrap_or_default()
+        .as_secs();
+
+    let mut files = HashMap::new();
+
+    // Backup files that will be modified
+    for relative in preview
+        .files_modified
+        .iter()
+        .chain(preview.files_deleted.iter())
+    {
+        let path = workspace.root.join(relative);
+        if path.exists() {
+            let content = std::fs::read(&path)
+                .map_err(|e| CodingError::IoError(format!("Failed to read {}: {}", relative, e)))?;
+            let hash = sha256_hash(&content);
+
+            files.insert(
+                relative.clone(),
+                BackupEntry {
+                    original_path: relative.clone(),
+                    backup_path: String::new(), // Will be set when saving
+                    content_hash: hash,
+                    existed: true,
+                },
+            );
+        }
+    }
+
+    // Mark files that will be created (no backup needed, but track for rollback)
+    for relative in &preview.files_created {
+        files.insert(
+            relative.clone(),
+            BackupEntry {
+                original_path: relative.clone(),
+                backup_path: String::new(),
+                content_hash: String::new(),
+                existed: false,
+            },
+        );
+    }
+
+    Ok(BackupManifest {
+        id: String::new(), // Will be set when saving
+        timestamp: now,
+        files,
+        workspace_root: workspace.root.to_string_lossy().to_string(),
+    })
+}
+
+fn save_backup_manifest(
+    id: &str,
+    mut manifest: BackupManifest,
+    workspace: &ResolvedWorkspace,
+) -> Result<(), CodingError> {
+    let backup_dir = workspace.root.join(".masix").join("backups").join(id);
+    std::fs::create_dir_all(&backup_dir)
+        .map_err(|e| CodingError::IoError(format!("Failed to create backup dir: {}", e)))?;
+
+    manifest.id = id.to_string();
+
+    // Save backup files
+    for (relative, entry) in manifest.files.iter_mut() {
+        if entry.existed {
+            let original_path = workspace.root.join(relative);
+            let backup_path = backup_dir.join(relative.replace('/', "_"));
+
+            if original_path.exists() {
+                std::fs::copy(&original_path, &backup_path).map_err(|e| {
+                    CodingError::IoError(format!("Failed to backup {}: {}", relative, e))
+                })?;
+                entry.backup_path = backup_path.to_string_lossy().to_string();
+            }
+        }
+    }
+
+    // Save manifest
+    let manifest_path = backup_dir.join("manifest.json");
+    let manifest_json = serde_json::to_string_pretty(&manifest)
+        .map_err(|e| CodingError::IoError(format!("Failed to serialize manifest: {}", e)))?;
+
+    std::fs::write(&manifest_path, manifest_json)
+        .map_err(|e| CodingError::IoError(format!("Failed to write manifest: {}", e)))?;
+
+    Ok(())
+}
+
+fn load_backup_manifest(
+    id: &str,
+    workspace: &ResolvedWorkspace,
+) -> Result<BackupManifest, CodingError> {
+    let manifest_path = workspace
+        .root
+        .join(".masix")
+        .join("backups")
+        .join(id)
+        .join("manifest.json");
+
+    if !manifest_path.exists() {
+        return Err(CodingError::IoError(format!("Backup {} not found", id)));
+    }
+
+    let content = std::fs::read_to_string(&manifest_path)
+        .map_err(|e| CodingError::IoError(format!("Failed to read manifest: {}", e)))?;
+
+    serde_json::from_str(&content)
+        .map_err(|e| CodingError::IoError(format!("Failed to parse manifest: {}", e)))
+}
+
+fn sha256_hash(data: &[u8]) -> String {
+    use sha2::{Digest, Sha256};
+    let mut hasher = Sha256::new();
+    hasher.update(data);
+    format!("{:x}", hasher.finalize())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{ExecutionProfile, WorkspaceSource};
+    use std::fs;
+
+    fn test_workspace() -> ResolvedWorkspace {
+        let temp = std::env::temp_dir().join("masix_patch_test");
+        let _ = fs::create_dir_all(&temp);
+        ResolvedWorkspace {
+            root: temp,
+            source: WorkspaceSource::DefaultRoot,
+            profile: ExecutionProfile::WorkspaceLocked,
+            allowed_roots: Vec::new(),
+        }
+    }
+
+    #[test]
+    fn test_preview_simple_diff() {
+        let diff = r#"--- a/test.txt
++++ b/test.txt
+@@ -1 +1 @@
+-hello
++world
+"#;
+        let workspace = test_workspace();
+        let preview = preview_patch(diff, &workspace).unwrap();
+
+        assert!(preview.valid, "Errors: {:?}", preview.errors);
+        assert_eq!(preview.files_modified.len(), 1);
+        assert_eq!(preview.lines_added, 1);
+        assert_eq!(preview.lines_removed, 1);
+    }
+
+    #[test]
+    fn test_preview_new_file() {
+        let diff = r#"--- /dev/null
++++ b/new_file.txt
+@@ -0,0 +1,3 @@
++line1
++line2
++line3
+"#;
+        let workspace = test_workspace();
+        let preview = preview_patch(diff, &workspace).unwrap();
+
+        assert!(preview.valid, "Errors: {:?}", preview.errors);
+        assert_eq!(preview.files_created.len(), 1);
+        assert_eq!(preview.lines_added, 3);
+        assert_eq!(preview.lines_removed, 0);
+    }
+
+    #[test]
+    fn test_preview_empty_diff() {
+        let diff = "";
+        let workspace = test_workspace();
+        let preview = preview_patch(diff, &workspace).unwrap();
+
+        assert!(preview.valid);
+        assert!(preview.files_modified.is_empty());
+        assert!(preview.files_created.is_empty());
+    }
+
+    #[test]
+    fn test_apply_patch_with_hunk_offset() {
+        // 10-line file, patch modifies lines 5-7
+        let original = "line1\nline2\nline3\nline4\nline5\nline6\nline7\nline8\nline9\nline10\n";
+        let patch = "@@ -5,3 +5,3 @@\n-line5\n-line6\n-line7\n+LINE5\n+LINE6\n+LINE7\n";
+
+        let result = apply_line_patch(original, patch).unwrap();
+        let lines: Vec<&str> = result.lines().collect();
+        assert_eq!(lines[0], "line1");
+        assert_eq!(lines[3], "line4");
+        assert_eq!(lines[4], "LINE5");
+        assert_eq!(lines[5], "LINE6");
+        assert_eq!(lines[6], "LINE7");
+        assert_eq!(lines[7], "line8");
+        assert_eq!(lines[9], "line10");
+        assert_eq!(lines.len(), 10);
+    }
+
+    #[test]
+    fn test_apply_patch_with_context_lines() {
+        let original = "aaa\nbbb\nccc\nddd\n";
+        let patch = "@@ -1,4 +1,4 @@\n aaa\n-bbb\n+BBB\n ccc\n ddd\n";
+
+        let result = apply_line_patch(original, patch).unwrap();
+        let lines: Vec<&str> = result.lines().collect();
+        assert_eq!(lines[0], "aaa");
+        assert_eq!(lines[1], "BBB");
+        assert_eq!(lines[2], "ccc");
+        assert_eq!(lines[3], "ddd");
+    }
+
+    #[test]
+    fn test_apply_patch_multiple_hunks() {
+        let original = "a\nb\nc\nd\ne\nf\ng\nh\ni\nj\n";
+        let patch = "@@ -2,1 +2,1 @@\n-b\n+B\n@@ -8,1 +8,1 @@\n-h\n+H\n";
+
+        let result = apply_line_patch(original, patch).unwrap();
+        let lines: Vec<&str> = result.lines().collect();
+        assert_eq!(lines[0], "a");
+        assert_eq!(lines[1], "B"); // replaced
+        assert_eq!(lines[2], "c");
+        assert_eq!(lines[7], "H"); // replaced
+        assert_eq!(lines[9], "j");
+        assert_eq!(lines.len(), 10);
+    }
+
+    #[test]
+    fn test_apply_patch_new_file_e2e() {
+        let workspace = test_workspace();
+        let test_subdir = workspace.root.join("e2e_new_file_test");
+        let _ = fs::create_dir_all(&test_subdir);
+
+        let diff = format!(
+            "--- /dev/null\n+++ b/e2e_new_file_test/newfile.txt\n@@ -0,0 +1,3 @@\n+hello\n+world\n+end\n"
+        );
+
+        let result = apply_patch(&diff, &workspace, false).unwrap();
+        assert!(result.success, "Errors: {:?}", result.errors);
+        assert_eq!(result.files_created.len(), 1);
+
+        let content = fs::read_to_string(test_subdir.join("newfile.txt")).unwrap();
+        assert!(content.contains("hello"));
+        assert!(content.contains("world"));
+        assert!(content.contains("end"));
+
+        // Cleanup
+        let _ = fs::remove_dir_all(&test_subdir);
+    }
+
+    #[test]
+    fn test_parse_hunk_old_start() {
+        assert_eq!(parse_hunk_old_start("@@ -1,4 +1,5 @@"), Some(1));
+        assert_eq!(parse_hunk_old_start("@@ -25,3 +26,4 @@"), Some(25));
+        assert_eq!(parse_hunk_old_start("@@ -100 +100 @@"), Some(100));
+        assert_eq!(parse_hunk_old_start("not a hunk header"), None);
+    }
+
+    #[test]
+    fn test_rollback_empty_backup_path() {
+        let workspace = test_workspace();
+        let backup_dir = workspace
+            .root
+            .join(".masix")
+            .join("backups")
+            .join("test_empty_bp");
+        let _ = fs::create_dir_all(&backup_dir);
+
+        // Create a manifest with an empty backup_path for an existing file
+        let mut files = HashMap::new();
+        files.insert(
+            "some_file.txt".to_string(),
+            BackupEntry {
+                original_path: "some_file.txt".to_string(),
+                backup_path: String::new(), // BUG-8: empty backup_path
+                content_hash: "abc".to_string(),
+                existed: true,
+            },
+        );
+        let manifest = BackupManifest {
+            id: "test_empty_bp".to_string(),
+            timestamp: 0,
+            files,
+            workspace_root: workspace.root.to_string_lossy().to_string(),
+        };
+        let manifest_json = serde_json::to_string_pretty(&manifest).unwrap();
+        fs::write(backup_dir.join("manifest.json"), manifest_json).unwrap();
+
+        let result = rollback_patch("test_empty_bp", &workspace);
+        assert!(result.is_err(), "Expected error for empty backup_path");
+        let err_msg = format!("{}", result.unwrap_err());
+        assert!(
+            err_msg.contains("empty") || err_msg.contains("Backup path"),
+            "Error should mention empty backup: {}",
+            err_msg
+        );
+
+        // Cleanup
+        let _ = fs::remove_dir_all(&backup_dir);
+    }
+}