fix: 修复 Windows 平台编译错误

## 修复内容

### 1. BrowserInterceptorError 错误枚举扩展
- 添加 AlreadyRunning 变体：表示拦截器已在运行
- 添加 UnsupportedPlatform 变体：表示不支持的平台
- 添加 IoError 变体：包装 std::io::Error
- 实现 From<std::io::Error> trait 自动转换

### 2. Windows API 类型转换修复
- state_manager.rs:
  * 第 270-286 行：修复 RegQueryValueExW 的 buffer_size 参数类型
  * 第 334-350 行：同样的修复应用于另一个调用点
  * 第 456-467 行：修复 RegSetValueExW 参数类型，使用 std::slice::from_raw_parts

- windows.rs:
  * 第 107-133 行：修复 RegQueryValueExW buffer_size 类型转换

### 3. 修复原因
Windows Registry API 要求：
- RegQueryValueExW 的 buffer_size 参数必须是 *mut u32
- 在 64 位系统上，usize 是 64 位，不能直接转换为 *mut u32
- 解决方案：创建中间 u32 变量进行转换

## 测试
- [x] Windows 平台编译通过
- [x] 无编译错误
- [x] 代码格式化通过

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

src-tauri/src/browser_interceptor/mod.rs

@@ -38,6 +38,9 @@ pub enum BrowserInterceptorError {
     StateError(String),
     PlatformError(String),
     NotificationError(String),
+    AlreadyRunning,
+    UnsupportedPlatform(String),
+    IoError(String),
 }
 
 impl fmt::Display for BrowserInterceptorError {
@@ -48,10 +51,19 @@ impl fmt::Display for BrowserInterceptorError {
             BrowserInterceptorError::StateError(msg) => write!(f, "状态管理错误: {}", msg),
             BrowserInterceptorError::PlatformError(msg) => write!(f, "平台错误: {}", msg),
             BrowserInterceptorError::NotificationError(msg) => write!(f, "通知错误: {}", msg),
+            BrowserInterceptorError::AlreadyRunning => write!(f, "拦截器已在运行"),
+            BrowserInterceptorError::UnsupportedPlatform(msg) => write!(f, "不支持的平台: {}", msg),
+            BrowserInterceptorError::IoError(msg) => write!(f, "IO错误: {}", msg),
         }
     }
 }
 
 impl Error for BrowserInterceptorError {}
 
+impl From<std::io::Error> for BrowserInterceptorError {
+    fn from(err: std::io::Error) -> Self {
+        BrowserInterceptorError::IoError(err.to_string())
+    }
+}
+
 pub type Result<T> = std::result::Result<T, BrowserInterceptorError>;

src-tauri/src/browser_interceptor/platform/windows.rs

@@ -108,19 +108,21 @@ impl WindowsInterceptor {
                 let mut buffer = vec![0u16; 1024];
                 let mut buffer_size = buffer.len() * 2;
 
+                let mut buffer_size_u32 = buffer_size as u32;
                 let result = RegQueryValueExW(
                     key,
                     PCWSTR::from_raw(to_wide_chars("ProgId").as_ptr()),
                     None,
                     None,
                     Some(buffer.as_mut_ptr() as *mut u8),
-                    Some(&mut buffer_size as *mut u32),
+                    Some(&mut buffer_size_u32),
                 );
 
                 RegCloseKey(key);
 
                 if result.is_ok() {
-                    let prog_id = String::from_utf16_lossy(&buffer[..buffer_size / 2 - 1]);
+                    let actual_size = buffer_size_u32 as usize;
+                    let prog_id = String::from_utf16_lossy(&buffer[..actual_size / 2 - 1]);
                     self.original_browser = Some(prog_id);
                     tracing::info!(
                         "备份原始默认浏览器: {}",

src-tauri/src/browser_interceptor/state_manager.rs

@@ -267,19 +267,21 @@ impl StateManager {
                 let mut buffer = vec![0u16; 1024];
                 let mut buffer_size = buffer.len() * 2;
 
+                let mut buffer_size_u32 = buffer_size as u32;
                 let result = RegQueryValueExW(
                     key,
                     PCWSTR::from_raw(to_wide_chars("ProgId").as_ptr()),
                     None,
                     None,
                     Some(buffer.as_mut_ptr() as *mut u8),
-                    Some(&mut buffer_size as *mut u32),
+                    Some(&mut buffer_size_u32),
                 );
 
                 RegCloseKey(key);
 
                 if result.is_ok() {
-                    let prog_id = String::from_utf16_lossy(&buffer[..buffer_size / 2 - 1]);
+                    let actual_size = buffer_size_u32 as usize;
+                    let prog_id = String::from_utf16_lossy(&buffer[..actual_size / 2 - 1]);
                     return Ok(Some(prog_id));
                 }
             }
@@ -329,19 +331,21 @@ impl StateManager {
                 let mut buffer = vec![0u16; 1024];
                 let mut buffer_size = buffer.len() * 2;
 
+                let mut buffer_size_u32 = buffer_size as u32;
                 let result = RegQueryValueExW(
                     key,
                     PCWSTR::from_raw(to_wide_chars(value_name).as_ptr()),
                     None,
                     None,
                     Some(buffer.as_mut_ptr() as *mut u8),
-                    Some(&mut buffer_size as *mut u32),
+                    Some(&mut buffer_size_u32),
                 );
 
                 RegCloseKey(key);
 
                 if result.is_ok() {
-                    let value = String::from_utf16_lossy(&buffer[..buffer_size / 2 - 1]);
+                    let actual_size = buffer_size_u32 as usize;
+                    let value = String::from_utf16_lossy(&buffer[..actual_size / 2 - 1]);
                     return Ok(value);
                 }
             }
@@ -449,13 +453,17 @@ impl StateManager {
                 let value_name_wide = to_wide_chars(value_name);
                 let value_data_wide = to_wide_chars(value_data);
 
+                let data_bytes = std::slice::from_raw_parts(
+                    value_data_wide.as_ptr() as *const u8,
+                    value_data_wide.len() * 2,
+                );
+
                 RegSetValueExW(
                     key,
                     PCWSTR::from_raw(value_name_wide.as_ptr()),
                     0,
                     REG_SZ,
-                    Some(value_data_wide.as_ptr() as *const u8),
-                    value_data_wide.len() * 2,
+                    Some(data_bytes),
                 );
 
                 RegCloseKey(key);