Add cross-drive compatible Rename function and replace os.Rename in plugin operations

Co-authored-by: aooohan <40265686+aooohan@users.noreply.github.com>

Author: Copilot

internal/manager.go

@@ -344,7 +344,7 @@ func (m *Manager) Update(pluginName string) error {
 	success := false
 	backupPath := sdkMetadata.PluginInstalledPath + "-bak"
 	logger.Debugf("Backup %s plugin to %s \n", sdkMetadata.PluginInstalledPath, backupPath)
-	if err = os.Rename(sdkMetadata.PluginInstalledPath, backupPath); err != nil {
+	if err = util.Rename(sdkMetadata.PluginInstalledPath, backupPath); err != nil {
 		return fmt.Errorf("backup %s plugin failed, err: %w", sdkMetadata.PluginInstalledPath, err)
 	}
 	defer func() {
@@ -353,11 +353,11 @@ func (m *Manager) Update(pluginName string) error {
 			_ = os.RemoveAll(backupPath)
 		} else {
 			logger.Debugf("Restoring from backup: %s\n", backupPath)
-			_ = os.Rename(backupPath, sdkMetadata.PluginInstalledPath)
+			_ = util.Rename(backupPath, sdkMetadata.PluginInstalledPath)
 		}
 	}()
 	logger.Debugf("Moving updated plugin from %s to %s\n", tempPlugin.InstalledPath, sdkMetadata.PluginInstalledPath)
-	if err = os.Rename(tempPlugin.InstalledPath, sdkMetadata.PluginInstalledPath); err != nil {
+	if err = util.Rename(tempPlugin.InstalledPath, sdkMetadata.PluginInstalledPath); err != nil {
 		return fmt.Errorf("update %s plugin failed, err: %w", pluginName, err)
 	}
 
@@ -539,7 +539,7 @@ func (m *Manager) Add(pluginName, url, alias string) error {
 		}
 	}
 	logger.Debugf("Moving plugin from %s to %s\n", tempPlugin.InstalledPath, installPath)
-	if err = os.Rename(tempPlugin.InstalledPath, installPath); err != nil {
+	if err = util.Rename(tempPlugin.InstalledPath, installPath); err != nil {
 		logger.Debugf("Failed to move plugin: %v\n", err)
 		return fmt.Errorf("install plugin error: %w", err)
 	}
@@ -611,7 +611,7 @@ func (m *Manager) installPluginToTemp(path string) (*plugin.Wrapper, error) {
 	// make a directory to store the wrapper and rename the wrapper file to main.lua
 	if ext == ".lua" {
 		logger.Debugf("Moving wrapper %s to %s \n", localPath, tempInstallPath)
-		if err = os.Rename(localPath, filepath.Join(tempInstallPath, "main.lua")); err != nil {
+		if err = util.Rename(localPath, filepath.Join(tempInstallPath, "main.lua")); err != nil {
 			logger.Debugf("Failed to move lua plugin: %v\n", err)
 			return nil, fmt.Errorf("install wrapper error: %w", err)
 		}

internal/shared/util/file.go

@@ -57,6 +57,80 @@ func CopyFile(src, dst string) error {
 	return nil
 }
 
+// copyDir recursively copies a directory tree
+func copyDir(src, dst string) error {
+	srcInfo, err := os.Stat(src)
+	if err != nil {
+		return err
+	}
+
+	// Create destination directory with same permissions
+	if err := os.MkdirAll(dst, srcInfo.Mode()); err != nil {
+		return err
+	}
+
+	entries, err := os.ReadDir(src)
+	if err != nil {
+		return err
+	}
+
+	for _, entry := range entries {
+		srcPath := filepath.Join(src, entry.Name())
+		dstPath := filepath.Join(dst, entry.Name())
+
+		if entry.IsDir() {
+			if err := copyDir(srcPath, dstPath); err != nil {
+				return err
+			}
+		} else {
+			if err := CopyFile(srcPath, dstPath); err != nil {
+				return err
+			}
+			// Preserve file permissions
+			if info, err := os.Stat(srcPath); err == nil {
+				os.Chmod(dstPath, info.Mode())
+			}
+		}
+	}
+
+	return nil
+}
+
+// Rename renames (moves) a file or directory, handling cross-drive operations on Windows.
+// It first attempts a direct rename using os.Rename. If that fails (e.g., cross-drive on Windows),
+// it falls back to copy-and-delete.
+func Rename(src, dst string) error {
+	// First try a direct rename (fast, works on same filesystem)
+	err := os.Rename(src, dst)
+	if err == nil {
+		return nil
+	}
+
+	// If rename failed, check if source exists
+	srcInfo, statErr := os.Stat(src)
+	if statErr != nil {
+		return statErr
+	}
+
+	// Copy source to destination
+	if srcInfo.IsDir() {
+		if err := copyDir(src, dst); err != nil {
+			return err
+		}
+	} else {
+		if err := CopyFile(src, dst); err != nil {
+			return err
+		}
+		// Preserve file permissions
+		if err := os.Chmod(dst, srcInfo.Mode()); err != nil {
+			return err
+		}
+	}
+
+	// Remove source after successful copy
+	return os.RemoveAll(src)
+}
+
 // MoveFiles Move a folder or file to a specified directory
 func MoveFiles(src, targetDir string) error {
 	info, err := os.Stat(src)

internal/shared/util/file_test.go

@@ -0,0 +1,155 @@
+/*
+ *    Copyright 2026 Han Li and contributors
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+
+package util
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestRenameFile(t *testing.T) {
+	// Create temp directory for testing
+	tmpDir, err := os.MkdirTemp("", "vfox-rename-test-")
+	if err != nil {
+		t.Fatalf("Failed to create temp dir: %v", err)
+	}
+	defer os.RemoveAll(tmpDir)
+
+	// Create a test file
+	srcFile := filepath.Join(tmpDir, "test-src.txt")
+	content := "test content"
+	if err := os.WriteFile(srcFile, []byte(content), 0644); err != nil {
+		t.Fatalf("Failed to create test file: %v", err)
+	}
+
+	// Test renaming file
+	dstFile := filepath.Join(tmpDir, "test-dst.txt")
+	if err := Rename(srcFile, dstFile); err != nil {
+		t.Fatalf("Rename failed: %v", err)
+	}
+
+	// Verify source no longer exists
+	if FileExists(srcFile) {
+		t.Error("Source file still exists after rename")
+	}
+
+	// Verify destination exists with correct content
+	if !FileExists(dstFile) {
+		t.Error("Destination file does not exist")
+	}
+	readContent, err := os.ReadFile(dstFile)
+	if err != nil {
+		t.Fatalf("Failed to read destination file: %v", err)
+	}
+	if string(readContent) != content {
+		t.Errorf("Content mismatch: expected %q, got %q", content, string(readContent))
+	}
+}
+
+func TestRenameDirectory(t *testing.T) {
+	// Create temp directory for testing
+	tmpDir, err := os.MkdirTemp("", "vfox-rename-test-")
+	if err != nil {
+		t.Fatalf("Failed to create temp dir: %v", err)
+	}
+	defer os.RemoveAll(tmpDir)
+
+	// Create a test directory structure
+	srcDir := filepath.Join(tmpDir, "test-src-dir")
+	if err := os.Mkdir(srcDir, 0755); err != nil {
+		t.Fatalf("Failed to create test directory: %v", err)
+	}
+
+	// Create nested structure
+	subDir := filepath.Join(srcDir, "subdir")
+	if err := os.Mkdir(subDir, 0755); err != nil {
+		t.Fatalf("Failed to create subdirectory: %v", err)
+	}
+
+	file1 := filepath.Join(srcDir, "file1.txt")
+	file2 := filepath.Join(subDir, "file2.txt")
+	content1 := "content1"
+	content2 := "content2"
+
+	if err := os.WriteFile(file1, []byte(content1), 0644); err != nil {
+		t.Fatalf("Failed to create file1: %v", err)
+	}
+	if err := os.WriteFile(file2, []byte(content2), 0644); err != nil {
+		t.Fatalf("Failed to create file2: %v", err)
+	}
+
+	// Test renaming directory
+	dstDir := filepath.Join(tmpDir, "test-dst-dir")
+	if err := Rename(srcDir, dstDir); err != nil {
+		t.Fatalf("Rename directory failed: %v", err)
+	}
+
+	// Verify source no longer exists
+	if FileExists(srcDir) {
+		t.Error("Source directory still exists after rename")
+	}
+
+	// Verify destination exists with correct structure
+	if !FileExists(dstDir) {
+		t.Error("Destination directory does not exist")
+	}
+
+	// Check file1
+	dstFile1 := filepath.Join(dstDir, "file1.txt")
+	if !FileExists(dstFile1) {
+		t.Error("file1.txt does not exist in destination")
+	}
+	readContent1, err := os.ReadFile(dstFile1)
+	if err != nil {
+		t.Fatalf("Failed to read file1: %v", err)
+	}
+	if string(readContent1) != content1 {
+		t.Errorf("Content mismatch in file1: expected %q, got %q", content1, string(readContent1))
+	}
+
+	// Check file2 in subdirectory
+	dstFile2 := filepath.Join(dstDir, "subdir", "file2.txt")
+	if !FileExists(dstFile2) {
+		t.Error("file2.txt does not exist in destination subdirectory")
+	}
+	readContent2, err := os.ReadFile(dstFile2)
+	if err != nil {
+		t.Fatalf("Failed to read file2: %v", err)
+	}
+	if string(readContent2) != content2 {
+		t.Errorf("Content mismatch in file2: expected %q, got %q", content2, string(readContent2))
+	}
+}
+
+func TestRenameNonExistent(t *testing.T) {
+	// Create temp directory for testing
+	tmpDir, err := os.MkdirTemp("", "vfox-rename-test-")
+	if err != nil {
+		t.Fatalf("Failed to create temp dir: %v", err)
+	}
+	defer os.RemoveAll(tmpDir)
+
+	srcFile := filepath.Join(tmpDir, "nonexistent.txt")
+	dstFile := filepath.Join(tmpDir, "destination.txt")
+
+	// Test renaming non-existent file should fail
+	err = Rename(srcFile, dstFile)
+	if err == nil {
+		t.Error("Expected error when renaming non-existent file, got nil")
+	}
+}