发布：v0.3.3 版本历史模块 + 域名迁移 + 站点版本信息修正

- 版本号更新至 0.3.3（version.go/wails.json/README.md）
- 更新检查域名迁移 img.1216.top → c.1216.top
- 新增 views/version 版本历史 Tab 页面（时间线 UI）
- 设置面板新增版本历史入口按钮
- CHANGELOG 补全 0.3.3 全部 17 个提交记录
- 站点 HTML 修正（删除错误 v0.4.0，v0.3.3 为最新）
- 生成 last-version.json / versions.json 发布数据

.gitignore

@@ -4,8 +4,12 @@ web/src/wailsjs/
 
 # 构建产物
 build/bin/
+build/*.log
 web/dist/
 
+# 临时文件
+*.tmp
+
 # 依赖目录
 web/node_modules/
 web/bun.lock
@@ -23,6 +27,7 @@ go.work
 # IDE
 .idea/
 .vscode/
+.claude/
 *.swp
 *.swo
 *~
@@ -34,3 +39,5 @@ Thumbs.db
 # 日志文件
 *.log
 
+# 其他
+docs/

CHANGELOG.internal.md

@@ -0,0 +1,503 @@
+# 内部更新日志
+
+> 本文档记录所有技术细节，包括代码重构、构建优化等内部改动
+
+## [0.3.3] - 2026-04-13
+
+### 架构新增 🏗️
+
+#### PDF 导出模块
+新增 `internal/api/pdf_api.go`，提供两种导出方式：
+- **chromedp**: 无头浏览器渲染 HTML → PDF，支持完整 CSS 样式
+- **gofpdf** (`app.go:ExportMarkdownToPDF`): 纯 Go 实现，解析 Markdown 标题/列表/代码块写入 PDF
+- 前端 `PdfExportButton.vue` 使用 `window.open` + `print()` 浏览器打印方式
+
+#### Markdown 编辑器
+新增 `web/src/components/MarkdownEditor.vue` 组件：
+- textarea 编辑 + MarkdownPreview 实时预览（左右分栏）
+- 字符/行数统计、Ctrl+S 保存、5 秒防抖自动保存
+- 支持 `content` prop 和 `v-model:content` 双向绑定
+- 独立页面 `web/src/views/markdown-editor/index.vue` 和 `web/src/views/MarkdownViewer.vue`
+
+---
+
+### 数据库层重构 🗄️
+
+#### MySQL 连接池 (`internal/dbclient/pool.go`, `pool_config.go`)
+- 动态扩缩容: `adaptiveScaling()` 基于使用率自动 scaleUp/scaleDown
+- 健康检查: `enhancedHealthCheck()` 定期 Ping，使用中连接带 100ms 超时
+- 性能权重: `adaptiveWeights` 基于 Ping 延迟计算，`getOptimalConnection()` 优选
+- **注意**: `warmUp()` 为空壳实现，未被调用；`OptimizeQuery` 等方法未接入 `sql_exec_service.go` 业务调用
+
+#### 查询优化器 (`internal/dbclient/query_optimizer.go`, `cache.go`)
+- 查询缓存: SHA-256 key hash + LRU/LFU 混合驱逐，100MB 内存限制，RLock 读锁优化
+- 慢查询日志: 超过 100ms 自动记录，最多 1000 条，维护协程定期分析
+- 正则预编译: 5 个正则从方法内移到包级别 `var` 声明
+- **注意**: 索引建议框架在但 `analyzeQueryForIndexes` 分析逻辑为占位实现；`extractIndexUsed` 始终返回 `"unknown"`
+
+#### Redis Pipeline (`internal/dbclient/redis_pipeline.go`)
+- `RedisPipeline`: 批量命令，使用 go-redis 原生 `Pipeline()` 一次性发送
+- `RedisTransaction`: 事务支持，使用 `TxPipeline()` 自动 MULTI/EXEC
+- **注意**: 未被业务代码调用，仅 `pool.go` 中定义了桥接方法
+
+---
+
+### 前端变更 🖥️
+
+#### App.vue
+- 新增窗口置顶按钮，调用 `WindowToggleAlwaysOnTop` Wails runtime API
+- 新增 Markdown 编辑器 tab
+- 禁止 Ctrl+滚轮缩放（`wheel` 事件 passive: false）
+- 移除 `preloadCommonLanguages()` 预加载（改按需加载）
+- `lang="ts"` 迁移
+
+#### 文件系统
+- `ContextMenu.vue`: 新增新建文件/文件夹菜单项
+- `FileEditorPanel.vue`: 集成 PDF 导出按钮、Markdown 预览/编辑模式切换
+- `useFavorites.ts`: 收藏夹置顶功能（`togglePin`/`isPinned`/排序）
+- `useFilePreview.ts`: Office/CSV 改用本地文件服务器 `fetch` 获取内容
+- HTML 预览改用 `iframe src` 替代 `srcdoc`（`f28fd70`, `7004c6e`）
+
+#### 安全修复
+- `PdfExportButton.vue`: `escapeHtml()` 转义标题、`stripScripts()` 清除 script/iframe/事件处理器
+- `MarkdownPreview.vue`: `sanitizeHtml()` 清除 script/iframe/form/事件处理器/javascript: 协议
+- `pdf_api.go`: `filepath.Base()` 防路径穿越、`html.EscapeString()` 防标题 HTML 注入
+
+#### 配置层
+- `config.ts`: Wails 绑定加载增加超时保护（最多 30 次重试，约 30 秒）
+- `config_service.go`: `TestConnection` 简化为直接传 id
+- `connection_api.go`: 依赖从 `storage` 改为 `service` 包
+
+#### 样式
+- `style.css`: 新增 GitHub 风格 `.markdown-body` 样式、Highlight.js 代码高亮样式、`@media print` 打印优化
+- Tooltip 全局样式覆盖
+
+---
+
+### 后端变更 ⚙️
+
+#### app.go
+- 新增 `pdfAPI`、`isAlwaysOnTop` 字段
+- 新增 PDF 导出方法: `ExportPDF`、`ExportMarkdownToPDF`、`SelectPDFSaveDirectory`
+- `startAutoUpdateCheck` 修复 `config["success"].(bool)` 类型断言，改为 ok 检查
+- `WindowToggleAlwaysOnTop`: Wails runtime 置顶切换
+
+#### 其他
+- `aes.go`: AES 加密模块扩展
+- `pool.go`: 桥接查询优化器和缓存方法
+- `connection_service.go`: 增强 `GetConnection` 和 `TestConnection`
+
+---
+
+### 依赖变更 📦
+
+```diff
++ github.com/chromedp/cdproto
++ github.com/chromedp/chromedp v0.14.2
++ github.com/jung-kurt/gofpdf v1.16.2
++ github.com/yuin/goldmark v1.8.2
++ (间接) chromedp/sysutil, go-json-experiment/json, gobwas/ws, gobwas/pool, gobwas/httphead
+```
+
+---
+
+### 删除文件 🗑️
+
+- `claude-progress.txt`, `project-status-analysis.md` — 临时文件
+- `docs/代码审查/README.md` — 过期文档
+- `web/src/composables/useLocalStorage.ts` — 未使用
+- `web/src/utils/fileHelpers.js` — 合并到 fileUtils.js
+- `web/src/utils/pathHelpers.js` — 合并到 fileUtils.js
+
+---
+
+### 死代码清理 🧹
+
+- `cache.go`: 移除 `CacheStrategy` 枚举、`warmupQueries`/`warmupEnabled` 字段
+- `redis_pipeline.go`: 移除 `RedisError` 冗余类型
+- `query_optimizer.go`: 移除 `go analyzeQuery()` 空操作 goroutine、清空 `generateJoinSuggestions`/`generateGroupSuggestions`/`generateInsertSuggestions` 硬编码
+- `openclaw/api.go`: 清理空 `import ()`
+- `openclaw/manager.go`: `*context.Context` 指针存储改为空结构体
+- `markdown-editor/index.vue`: 移除 `console.log('Content changed:', content)`
+
+---
+
+### 核心文件变更
+
+| 文件 | 类型 | 说明 |
+|------|------|------|
+| `app.go` | 重构 | +208 行，新增 PDF/OpenClaw/置顶 API |
+| `internal/api/pdf_api.go` | 新增 | chromedp PDF 导出 |
+| `internal/dbclient/pool_config.go` | 重构 | +395 行，动态连接池 |
+| `internal/dbclient/query_optimizer.go` | 新增 | 查询优化器 |
+| `internal/dbclient/cache.go` | 新增 | 查询缓存 |
+| `internal/dbclient/redis_pipeline.go` | 新增 | Redis Pipeline/事务 |
+| `web/src/components/MarkdownEditor.vue` | 新增 | Markdown 编辑器组件 |
+| `web/src/components/PdfExportButton.vue` | 新增 | PDF 导出按钮 |
+| `web/src/components/MarkdownPreview.vue` | 新增 | Markdown 预览组件 |
+| `web/src/views/markdown-editor/` | 新增 | Markdown 编辑器页面 |
+| `web/src/style.css` | 扩展 | +316 行，Markdown/打印样式 |
+
+---
+
+## [0.3.2] - 2026-02-05
+
+### 核心架构重构 🏗️
+
+#### CodeMirror 统一导出机制
+**问题**: 多处直接从 `@codemirror/*` 导入导致多实例问题，影响状态共享和主题切换
+
+**解决方案**:
+- 新增 `web/src/utils/codemirrorExports.js` 统一导出层
+- 所有 CodeMirror 模块通过此文件导出，确保单实例
+- 包括核心、语言包、主题等 27+ 个模块
+
+```javascript
+// 核心模块
+export { EditorView, lineNumbers, ... } from '@codemirror/view'
+export { EditorState, Compartment, Facet, ... } from '@codemirror/state'
+
+// 语言包
+export { javascript } from '@codemirror/lang-javascript'
+export { sql } from '@codemirror/lang-sql'
+// ... 13 个语言包
+```
+
+**影响组件**:
+- `web/src/components/CodeEditor.vue`
+- `web/src/views/db-cli/components/SqlEditor.vue`
+- `web/src/views/db-cli/components/SqlPreviewDialog.vue`
+
+#### 语言加载器简化
+**优化前** - 异步动态导入:
+```javascript
+export async function loadLanguageExtension(language) {
+  const [path, method] = modernLangs[language]
+  const mod = await import(path)  // 异步加载
+  return mod[method]()
+}
+```
+
+**优化后** - 同步静态导入:
+```javascript
+import { javascript, json, sql, ... } from './codemirrorExports'
+
+export function loadLanguageExtension(language) {
+  switch (language) {
+    case 'javascript': return javascript({ jsx: true })
+    case 'sql': return sql()
+    // ... 同步返回
+  }
+}
+```
+
+**收益**:
+- ✅ 消除异步加载失败风险
+- ✅ 代码逻辑简化 70%
+- ✅ 类型提示更完善
+- ✅ 移除 13 种 legacy 语言支持（ruby, shell, kotlin 等）
+
+---
+
+### 动态主题切换优化 ⚡
+
+#### 使用 Compartment 实现无损切换
+**优化前** - 销毁重建方式:
+```javascript
+watch([isDark, fileExtension], async () => {
+  await nextTick()
+  const currentDoc = view.state.doc.toString()
+  view.destroy()
+  await createEditor(currentDoc)  // 丢失光标、选择、历史
+})
+```
+
+**优化后** - Compartment 动态重配置:
+```javascript
+const themeCompartment = new Compartment()
+const languageCompartment = new Compartment()
+
+// 主题切换
+watch(() => themeStore.isDark, () => {
+  view.dispatch({
+    effects: themeCompartment.reconfigure(getThemeExtension())
+  })
+})
+
+// 语言切换
+watch(() => props.fileExtension, () => {
+  initLanguage()  // 使用 languageCompartment.reconfigure
+})
+```
+
+**保留状态**:
+- ✅ 光标位置
+- ✅ 选择内容
+- ✅ 撤销/重做历史
+- ✅ 滚动位置
+
+**性能提升**:
+- 切换耗时: 150ms → 15ms（90% 提升）
+- 无需重新解析文档
+
+#### 亮色主题改进
+**新增专用亮色主题定义**:
+```javascript
+const lightTheme = EditorView.theme({
+  '&': { backgroundColor: '#ffffff' },
+  '.cm-gutters': { backgroundColor: '#f7f7f7', color: '#999', border: 'none' },
+  '.cm-activeLineGutter': { backgroundColor: '#e8e8e8', color: '#333' },
+  '.cm-line': { caretColor: '#000' },
+  '.cm-selection': { backgroundColor: '#d9d9d9' },
+  '.cm-cursor': { borderLeftColor: '#000' }
+})
+```
+
+结合 `defaultHighlightStyle` 提供完整语法高亮
+
+---
+
+### 性能优化 🚀
+
+#### 内容更新防抖
+**问题**: 每次按键都触发 `emit('update:modelValue')`，导致频繁的 Vue 响应式更新
+
+**解决方案**:
+```javascript
+let emitTimeout = null
+const debouncedEmit = (value) => {
+  if (emitTimeout) clearTimeout(emitTimeout)
+  emitTimeout = setTimeout(() => {
+    emit('update:modelValue', value)
+  }, 150)
+}
+
+EditorView.updateListener.of((update) => {
+  if (update.docChanged) {
+    debouncedEmit(update.state.doc.toString())
+  }
+})
+```
+
+**收益**:
+- ✅ 减少 85% 的 emit 调用
+- ✅ 输入流畅度显著提升
+- ✅ 组件更新压力降低
+
+---
+
+### 依赖和构建优化 📦
+
+#### 移除废弃依赖
+```diff
+- "@codemirror/highlight": "^0.19.8"    // 已废弃
+- "@codemirror/legacy-modes": "^6.5.2"  // 不需要
+```
+
+**原因**:
+- `@codemirror/highlight` v0.19.8 已废弃，功能整合到 `@codemirror/language@6.12.1`
+- `@codemirror/legacy-modes` 支持的语言项目不需要
+
+#### Vite 配置简化
+**移除 manualChunks 配置**:
+```diff
+- rollupOptions: {
+-   output: {
+-     manualChunks: (id) => {
+-       if (id.includes('@codemirror')) return 'vendor-codemirror'
+-       if (id.includes('@arco-design')) return 'vendor-arco'
+-       ...
+-     }
+-   }
+- }
+```
+
+**简化 optimizeDeps 配置**:
+```diff
+- optimizeDeps: {
+-   include: [
+-     'vue', 'pinia', '@arco-design/web-vue',
+-     '@codemirror/view', '@codemirror/state',
+-     '@codemirror/language', '@codemirror/commands',
+-     ... 20+ 个 CodeMirror 包
+-   ]
+- }
++ optimizeDeps: {
++   include: ['vue', 'pinia', '@arco-design/web-vue', 'marked', 'highlight.js']
++ }
+```
+
+**收益**:
+- ✅ 配置行数减少 40+
+- ✅ Vite 自动依赖预构建更高效
+- ✅ 构建速度提升 15%
+
+---
+
+### 代码清理 🧹
+
+#### 删除过期文档
+移除 9 个代码审查相关文档（2026-01-29/30 时期的临时文档）
+
+#### 删除冗余代码
+- `web/src/components/FileSystem/components/FileEditor/CodeEditor.vue` - 旧编辑器实现
+- `web/src/components/FileSystem/components/FileEditorPanel.new.vue` - 未使用的原型文件
+
+---
+
+### 技术细节
+
+#### 核心文件变更
+
+| 文件 | 类型 | 行数变化 | 说明 |
+|------|------|----------|------|
+| `web/src/utils/codemirrorExports.js` | 新增 | +27 | 统一导出 |
+| `web/src/utils/codeMirrorLoader.js` | 重构 | -50 | 简化语言加载 |
+| `web/src/components/CodeEditor.vue` | 重构 | +80/-40 | Compartment + 防抖 |
+| `web/package.json` | 优化 | -2 | 移除废弃包 |
+| `web/vite.config.js` | 优化 | -40 | 简化配置 |
+| `internal/service/version.go` | 更新 | ±1 | 版本号 0.3.0 → 0.3.2 |
+
+#### 依赖变化
+```diff
+dependencies:
+- @codemirror/highlight: ^0.19.8
+- @codemirror/legacy-modes: ^6.5.2
+
+(共移除 2 个包，减少约 80KB 打包体积)
+```
+
+---
+
+### 构建验证
+
+```bash
+✓ 依赖安装: npm install (无警告)
+✓ 开发构建: npm run dev (正常启动)
+✓ 生产构建: npm run build (10.2s)
+✓ 类型检查: 无错误
+✓ 运行测试: 编辑器功能正常，主题切换流畅
+```
+
+---
+
+### 相关文档
+- [详细 changelog](docs/项目管理/版本管理/changelog-2026-02-05.md)
+- [CodeMirror 配置优化总结](docs/CodeMirror-配置优化总结.md)
+- [CodeEditor 优化报告](docs/CodeEditor-优化报告.md)
+
+---
+
+## [0.3.0] - 2026-02-04
+
+### 新增功能 ✨
+- **Markdown 渲染增强**
+  - 集成 Mermaid.js v11，支持流程图、时序图、类图、甘特图等 10+ 种图表类型
+  - 集成 CodeMirror + Highlight.js，支持 27 种常用编程语言语法高亮
+  - 实现编辑/预览模式切换时的图表自动重渲染机制
+- **TypeScript 类型系统**
+  - 新增 `web/src/types/file-system.ts` 完整类型定义
+  - 所有 Vue 组件迁移到 TypeScript
+  - 新增 `vue-tsc` 类型检查
+
+### 代码重构 🔧
+- **文件系统模块化**
+  - 拆分 FileSystem/index.vue (2100+ 行) 为模块化架构
+  - 提取 6 个 Composables：useFileOperations、useFavorites、usePathNavigation、useFilePreview、useFileEdit、useCommonPaths
+  - 拆分为 5 个子组件：Toolbar、Sidebar、FileListPanel、FileEditorPanel、ContextMenu
+- **公共函数提取**
+  - 提取 `sortFileList` 公共函数，统一文件列表排序逻辑
+  - 应用到 FileSystem/index.vue、index-simple.vue、DeviceTest.vue
+  - 优化 `fileUtils.js`，新增 8 个工具函数
+
+### 构建优化 📦
+- **Source Map 优化**
+  - 生产环境禁用 source map 生成
+  - 配置 `sourcemap: false` in vite.config.js
+- **依赖优化**
+  - CodeMirror 语言包按需加载配置
+  - Vite optimizeDeps 预构建优化
+
+### Bug 修复 🐛
+- 修复 Mermaid 图表在编辑/预览切换时不渲染的问题（添加 watch + nextTick）
+- 修复亮色模式下代码高亮对比度不足（添加自定义 CSS 变量）
+- 修复暗色模式下 Mermaid 图表显示异常（样式适配）
+
+### 文件变更统计
+- 130 个文件修改
+- +11,655 / -12,233 行代码
+- 主要变更：`web/src/components/FileSystem/` 目录重构
+
+---
+
+## [0.1.5] - 2026-01-22
+
+### 新增功能 ✨
+- **文件管理模块**
+  - 创建 FileSystem.vue 单体组件（559 行）
+  - 支持文件浏览、编辑、重命名、删除等基础操作
+  - 智能文件类型图标识别
+- **版本更新管理**
+  - 集成版本检查 API
+  - 支持自动下载更新包
+  - 新增 UpdatePanel 更新面板组件（427 行）
+- **系统信息查询**
+  - CPU 信息（核心数、使用率、型号）
+  - 内存信息（总量、可用量、使用率）
+  - 磁盘信息（分区、使用量、使用率）
+
+### 技术实现 🔧
+- 使用 gopsutil/v3 库获取系统信息
+- SQLite 存储连接和查询历史
+- 文件操作使用 Go runtime/os 包
+
+---
+
+## [0.2.0] - 2026-01-28
+
+### 新增功能 ✨
+- **应用配置管理**
+  - 新增 ConfigAPI 和 ConfigService
+  - 新增设置面板组件
+  - 支持自定义显示模块和默认启动页
+- **智能更新提醒**
+  - 新增版本更新通知组件
+  - 版本检查和下载机制
+
+### 代码重构 🔧
+- **模块重命名** - 项目重命名为 u-desk
+- **依赖更新** - 所有依赖更新到最新版本
+- **代码架构优化** - 提取公共函数，消除重复代码
+- **启动流程优化** - 按需加载模块
+
+---
+
+## [0.1.0] - 2026-01-18
+
+### 新增功能 ✨
+- **数据库管理**
+  - 支持 MySQL、MongoDB、Redis 连接
+  - SQL 查询执行和结果展示
+  - 连接池管理（467 行 sql_exec_service.go）
+  - 多标签页查询结果管理
+
+### 技术实现 🔧
+- MySQL：使用 go-sql-driver/mysql
+- MongoDB：使用 mongo-driver
+- Redis：使用 go-redis/v9
+- 连接池：自定义实现（236 行 pool.go）
+- SQLite：存储查询历史和连接配置
+
+### 文件变更
+- 15 个文件新增
+- +3,700+ 行代码
+
+---
+
+## 版本规范
+
+版本号格式：`主版本号.次版本号.修订号` (MAJOR.MINOR.PATCH)
+
+- **主版本号** - 不兼容的 API 修改
+- **次版本号** - 向下兼容的功能性新增
+- **修订号** - 向下兼容的问题修复

CHANGELOG.md

@@ -1,24 +1,105 @@
 # 更新日志
 
+## [0.3.3] - 2026-04-13
+
+### 新增 ✨
+- **Markdown 编辑器**: 独立编辑页面、实时预览、字符/行数统计、Ctrl+S 保存、自动保存
+- **Markdown 文件页面**: 独立的 Markdown 文件查看与编辑界面 (`views/markdown-editor/`)
+- **PDF 导出**: 浏览器打印 + 后端 gofpdf/chromedp 多种导出方式
+- **窗口置顶**: 支持窗口始终置顶
+- **收藏夹置顶**: 收藏项支持置顶排序
+- **文件预览**: Excel/Word 文件预览支持
+- **数据库 UI 大幅改进**: 查询历史面板、查询模板面板、SQL 工具栏、结果导出(CSV)、SQL 格式化器
+- **数据库可见性过滤**: 连接管理增强、ConnectionForm 重写、统一错误处理模块 (`database-error.ts`)
+
+### 优化 🚀
+- MySQL 动态连接池重构 — 健康检查、性能权重、自适应扩缩容
+- SQL 查询优化器 — 查询缓存、慢查询日志 (762 行)
+- Redis Pipeline — 批量命令、事务 MULTI/EXEC 支持
+- Office/CSV 预览增强 — 本地文件服务器获取文件
+- Markdown 增强 — 本地文件链接支持、Shell 语法高亮
+- HTML 预览 — 改用 iframe src 替代 srcdoc
+- Wails 框架升级 + Mermaid 主题切换 + 代码高亮修复
+- FileListPanel 重写 (+511 行) — 删除 FileItemRow，统一列表渲染逻辑
+- CSV 编辑模式优化 + PDF 导出重构
+- 拷贝功能优化 — 新增 ClipboardCopy composable
+
+### 修复 🐛
+- Office 文件预览：修复类型检测与二进制误判
+- 本地文件服务器 CORS 跨域问题
+- 大文件点击卡死问题
+- 收藏夹 bug 修复
+- FileEditorPanel 语法错误
+
+### 安全修复 🔒
+- XSS 防护（PdfExportButton、MarkdownPreview HTML 消毒）
+- PDF 导出路径穿越防护
+- PDF 导出标题 HTML 注入防护
+
+### 重构 🔧
+- CodeMirror 架构优化 — 统一导出避免多实例问题
+- 消除代码重复 — storage/connection_service 重构、useVisibleDatabases 抽取
+- **大规模死代码清理 (-1306 行)**: 删除废弃 storage 层(connection_service 279行)、audit_log、file_lock、recycle_bin、zip_helper、useFileEdit.js(-369行)、useFilePreview.js(-603行)、errorHandler.js(-63行)、DeviceTest 清理等
+- 配置加载超时保护（最多重试 30 次）
+- 正则表达式预编译（query_optimizer）
+- 缓存读锁优化 + SHA-256 key hash
+- 禁止 Ctrl+滚轮缩放
+- Dockerfile 语法高亮支持
+- 滚动条样式修复
+
+### 文件系统 📁
+- 右键菜单新增新建文件/文件夹
+- FileEditorPanel 集成 PDF 导出按钮
+- Markdown 文件自动预览与编辑/预览模式切换
+- 面包屑导航组件
+
+---
+
+## [0.3.2] - 2026-02-05
+
+### 重构 🔧
+- **CodeMirror 架构优化** - 统一导出避免多实例问题
+- **语言加载器优化** - 从动态 import 改为静态导入，提升稳定性
+- **动态主题切换** - 使用 Compartment 实现无损切换
+
+### 优化 🚀
+- **编辑器性能** - 添加内容更新防抖，减少不必要的渲染
+- **亮色主题** - 改进代码编辑器亮色模式样式
+- **构建配置** - 简化 Vite 配置，优化打包效率
+
+### 依赖清理 🧹
+- 移除废弃的 `@codemirror/highlight` 包
+- 移除不再使用的 `@codemirror/legacy-modes` 包
+
+---
+
+## [0.3.0] - 2026-02-04
+
+### 新增 ✨
+- **Markdown 图表支持** - 支持 Mermaid 流程图、时序图、类图等多种图表渲染
+- **代码语法高亮** - 支持 20+ 种常用编程语言的语法高亮
+- **文件列表优化** - 文件夹优先显示，同类型按名称排序
+
+### 修复 🐛
+- 修复编辑/预览模式切换时图表不渲染的问题
+- 修复不同主题下代码高亮显示问题
+
+---
+
 ## [0.2.0] - 2026-01-28
 
 ### 新增 ✨
 - **应用配置管理** - 全新设置面板，支持自定义显示模块和默认启动页
-- **智能更新提醒** - 新增版本更新通知组件，第一时间获取新版本信息
+- **智能更新提醒** - 新增版本更新通知组件
-- **配置服务层** - 新增 ConfigAPI 和 ConfigService 实现统一配置管理
+- **模块重命名** - 应用更名为 u-desk
-
-### 优化 ⚡
-- **文件系统模块化重构** - 提升代码质量和可维护性
-- **代码架构优化** - 提取公共函数，消除重复代码
-- **启动流程优化** - 按需加载模块，提升启动性能
 
 ---
 
 ## [0.1.5] - 2026-01-22
 
 ### 新增 ✨
-- **文件管理模块** - 完整的文件浏览、编辑、操作功能
+- **文件管理模块** - 文件浏览、编辑、操作功能
-- **版本更新管理** - 自动检查和应用更新
+- **版本更新管理** - 自动检查和下载更新
 - **系统信息查询** - CPU、内存、磁盘等硬件信息
 
 ---
@@ -37,5 +118,3 @@
 - **主版本号** - 不兼容的 API 修改
 - **次版本号** - 向下兼容的功能性新增
 - **修订号** - 向下兼容的问题修复
-
-

README.md

@@ -1,155 +1,10 @@
-# U-Desk
+# U-Desk v0.3.3
 
-基于 Wails 的桌面应用程序，集成数据库客户端、文件管理、设备测试等功能。
+## 功能
-
+- 数据库客户端
-## 技术栈
+- Markdown编辑器
-
+- PDF导出
-- **后端**：Go 1.25+、Wails v2
-- **前端**：Vue 3、Arco Design Vue、Vite
-- **存储**：SQLite、MySQL、Redis、MongoDB
-
-## 核心功能
-
-### 1. 数据库客户端
-- 支持 MySQL、Redis、MongoDB 多种数据库连接
-- 连接管理（保存、编辑、删除连接配置）
-- SQL 执行与结果展示
-- 数据表结构查看
-
-### 2. 文件管理
-- 本地文件系统浏览（支持多盘符）
-- 文件预览（图片、文本、代码）
-- 文件操作（复制、移动、删除、重命名）
-- 常用路径快捷访问（桌面、文档、下载等）
-- 搜索与筛选功能
-
-### 3. 设备测试
-- 系统设备信息查询
-- 硬件状态检测
-
-### 4. 更新管理
-- 应用版本检查与自动更新
-- 更新日志展示
-
-## 项目结构
-
-```
-go-desk/
-├── app.go                  # 应用入口，API 方法绑定
-├── main.go                 # 程序启动
-├── wails.json              # Wails 配置
-├── go.mod                  # Go 模块依赖
-├── internal/
-│   ├── api/                # API 层（数据库、标签页、更新等）
-│   ├── common/             # 通用工具（超时、工具函数）
-│   ├── dbclient/           # 数据库客户端（MySQL、Redis、MongoDB）
-│   ├── filesystem/         # 文件系统管理（模块化架构）
-│   ├── service/            # 服务层（SQL 执行等）
-│   ├── storage/            # 本地存储（SQLite）
-│   └── system/             # 系统信息获取
-└── web/                    # 前端代码
-    ├── package.json
-    ├── vite.config.js
-    ├── index.html
-    └── src/
-        ├── components/     # Vue 组件
-        │   ├── FileSystem.vue      # 文件管理
-        │   ├── DeviceTest.vue      # 设备测试
-        │   ├── UpdatePanel.vue     # 更新面板
-        │   └── CodeEditor.vue      # 代码编辑器
-        ├── composables/   # 组合式函数
-        │   ├── useFileOperations.js
-        │   ├── useFavoriteFiles.js
-        │   └── useLocalStorage.js
-        ├── utils/         # 工具函数
-        ├── api/           # API 调用
-        └── App.vue        # 主应用
-```
-
-## 开发
-
-### 1. 安装依赖
-
-```bash
-# Go 依赖
-go mod tidy
-
-# 前端依赖
-cd web
-npm install
-```
-
-### 2. 构建前端（必须）
-
-```bash
-cd web
-npm run build
-```
-
-**重要**：每次修改前端代码后都需要重新构建，Wails 使用 `web/dist` 目录中的构建产物。
-
-### 3. 开发模式运行
-
-```bash
-# 在项目根目录
-wails dev
-```
-
-**注意**：如果 `wails` 命令找不到，使用完整路径：
-```bash
-# 获取 GOPATH
-go env GOPATH
-
-# 使用完整路径（根据你的 GOPATH 调整）
-D:\Go\go-workspace\bin\wails.exe dev
-```
-
-### 4. 构建应用
-
-```bash
-# 确保前端已构建
-cd web
-npm run build
-cd ..
-
-# 构建当前平台
-wails build
-
-# 构建 Windows（明确指定平台）
-wails build -platform windows/amd64
-```
-
-**构建产物位置**：`build/bin/go-desk.exe`
-
-**注意**：
-- 构建前确保前端已构建（`web/dist` 目录存在）
-- 构建产物是独立的可执行文件，包含前端资源
-
-## 数据库配置
-
-应用使用 SQLite 本地存储连接配置和用户数据。
-
-可选连接外部数据库：
-- **MySQL**：支持连接、查询、表结构查看
-- **Redis**：支持连接、基础操作
-- **MongoDB**：支持连接、基础操作
-
-## 架构特点
-
-- **模块化文件系统**：文件管理功能采用模块化设计，职责分离
-- **异步启动优化**：应用启动流程优化，核心功能快速初始化
-- **本地文件服务器**：支持本地文件预览和访问
-- **SQLite 持久化**：连接配置和用户数据本地存储
-
-## 文档
-
-详细文档请查看 `docs/` 目录：
-- 架构设计文档
-- 功能迭代记录
-- 技术决策记录（ADR）
-- 测试用例和检查报告
-
-## 许可
-
-本项目用于学习和测试目的。
 
+## 更新
+- ✅ MD编辑器完成
+- ✅ PDF导出优化中

app.go

@@ -6,14 +6,15 @@ import (
 	"net/http"
 	"os"
 	"path/filepath"
-	"strings"
 	stdruntime "runtime"
+	"strings"
 	"time"
 
+	"golang.org/x/sys/windows/registry"
 	"u-desk/internal/api"
 	"u-desk/internal/common"
-	"u-desk/internal/database"
 	"u-desk/internal/filesystem"
+	"u-desk/internal/service"
 	"u-desk/internal/storage"
 	"u-desk/internal/system"
 
@@ -22,17 +23,22 @@ import (
 
 // App 应用结构体
 type App struct {
-	ctx              context.Context
+	ctx             context.Context
-	db               *database.DB
+	connectionAPI   *api.ConnectionAPI
-	connectionAPI    *api.ConnectionAPI
+	sqlAPI          *api.SqlAPI
-	sqlAPI           *api.SqlAPI
+	tabAPI          *api.TabAPI
-	tabAPI           *api.TabAPI
+	updateAPI       *api.UpdateAPI
-	updateAPI        *api.UpdateAPI
+	configAPI       *api.ConfigAPI
-	configAPI        *api.ConfigAPI
+	pdfAPI          *api.PdfAPI
-	fileServer       *http.Server
+	fileServer      *http.Server
-	filesystem       *filesystem.FileSystemService
+	filesystem      *filesystem.FileSystemService
+	isAlwaysOnTop   bool
 }
 
+// App 方法命名约定：
+// - 多参数操作 → XxxRequest 结构体（Wails 自动生成 TS 类型）
+// - 单参数查询/简单操作 → 直接参数
+
 // NewApp 创建新的应用实例
 func NewApp() *App {
 	return &App{}
@@ -49,14 +55,32 @@ func (a *App) Startup(ctx context.Context) {
 	}
 	_ = sqliteDB // 全局 DB 已由 InitFast() 设置
 
-	// 2. 初始化配置服务（必需，用于读取模块启用状态）
+	// 2. 初始化配置服务
 	configService, err := api.NewConfigAPI()
 	if err != nil {
 		panic(fmt.Sprintf("配置服务初始化失败: %v", err))
 	}
 	a.configAPI = configService
 
-	// 3. 读取配置，获取可见的 Tabs
+	// 2.5. 迁移旧配置
+	_ = a.configAPI.MigrateTabConfig()
+
+	// 2.6. 初始化PDF导出API
+	fmt.Println("[启动] 初始化PDF导出模块...")
+	pdfAPI, err := api.NewPdfAPI()
+	if err != nil {
+		fmt.Printf("[启动] PDF导出API初始化失败: %v\n", err)
+		// PDF导出失败不应影响应用启动，所以只警告不panic
+	} else {
+		a.pdfAPI = pdfAPI
+		fmt.Println("[启动] PDF导出模块初始化完成")
+	}
+
+	// 3. 初始化版本号（提前触发缓存，避免后续重复计算）
+	version := service.GetCurrentVersion()
+	fmt.Printf("[启动] 当前版本: %s\n", version)
+
+	// 4. 读取配置，获取可见的 Tabs
 	visibleTabs := a.getVisibleTabs()
 	fmt.Printf("[启动] 可用的模块: %v\n", visibleTabs)
 
@@ -67,7 +91,7 @@ func (a *App) Startup(ctx context.Context) {
 
 	// 5. 异步初始化：UpdateAPI（涉及网络请求，完全异步）
 	go func() {
-		if updateAPI, err := api.NewUpdateAPI("https://img.1216.top/u-desk/last-version.json"); err == nil {
+		if updateAPI, err := api.NewUpdateAPI("https://c.1216.top/last-version.json"); err == nil {
 			a.updateAPI = updateAPI
 			a.updateAPI.SetContext(ctx)
 			a.startAutoUpdateCheck()
@@ -170,61 +194,34 @@ func (a *App) startFileServer() {
 		return
 	}
 
-	// 创建一个占位服务器用于保持引用（实际服务器由 StartLocalFileServer 管理）
-	a.fileServer = &http.Server{
-		Addr: "localhost:18765",
-	}
-
 	fmt.Println("[文件服务器] 启动在 http://localhost:18765")
 }
 
 // Shutdown 应用关闭时调用
 func (a *App) Shutdown(ctx context.Context) {
-	// 关闭文件系统服务（优雅关闭，释放资源）
+	// 创建带超时的上下文（5秒超时）
+	shutdownCtx, cancel := context.WithTimeout(ctx, 5*time.Second)
+	defer cancel()
+
+	// 1. 关闭文件系统服务（优雅关闭，释放资源）
 	if a.filesystem != nil {
 		fmt.Println("[文件系统服务] 正在关闭...")
-		if err := a.filesystem.Close(ctx); err != nil {
+		if err := a.filesystem.Close(shutdownCtx); err != nil {
 			fmt.Printf("[文件系统服务] 关闭失败: %v\n", err)
+		} else {
+			fmt.Println("[文件系统服务] 已关闭")
 		}
 	}
 
-	// 停止文件服务器
+	// 2. 停止文件服务器（使用全局服务器的关闭方法）
-	if a.fileServer != nil {
+	fmt.Println("[文件服务器] 正在关闭...")
-		fmt.Println("[文件服务器] 正在关闭...")
+	if err := filesystem.ShutdownLocalFileServer(); err != nil {
-		a.fileServer.Shutdown(ctx)
+		fmt.Printf("[文件服务器] 关闭失败: %v\n", err)
+	} else {
+		fmt.Println("[文件服务器] 已关闭")
 	}
 }
 
-// QueryUsers 查询用户列表
-func (a *App) QueryUsers(keyword string, status int, role int, organid int, page int, pageSize int, sortField string, sortOrder string) (map[string]interface{}, error) {
-	db, err := a.getDB()
-	if err != nil {
-		return nil, err
-	}
-	return db.QueryUsers(keyword, status, role, organid, page, pageSize, sortField, sortOrder)
-}
-
-// getDB 获取数据库连接（延迟加载，按需初始化）
-func (a *App) getDB() (*database.DB, error) {
-	if a.db != nil {
-		return a.db, nil
-	}
-
-	// 首次调用时才连接数据库
-	db, err := database.Init()
-	if err != nil {
-		return nil, fmt.Errorf("数据库连接失败: %v", err)
-	}
-
-	a.db = db
-	return db, nil
-}
-
-// Greet 测试方法
-func (a *App) Greet(name string) string {
-	return "Hello " + name + ", It's show time!"
-}
-
 // GetSystemInfo 获取系统信息
 func (a *App) GetSystemInfo() (map[string]interface{}, error) {
 	return system.GetSystemInfo()
@@ -261,23 +258,34 @@ func (a *App) WriteFile(req WriteFileRequest) error {
 	return a.filesystem.WriteFile(req.Path, req.Content)
 }
 
+// SaveBase64FileRequest 保存 Base64 编码的二进制文件
+type SaveBase64FileRequest struct {
+	Path    string `json:"path"`
+	Content string `json:"content"` // base64 编码的文件内容
+}
+
+// SaveBase64File 将 base64 内容解码后写入文件（用于图片等二进制数据）
+func (a *App) SaveBase64File(req SaveBase64FileRequest) error {
+	return a.filesystem.SaveBase64File(req.Path, req.Content)
+}
+
 // ListDir 列出目录
 func (a *App) ListDir(path string) ([]map[string]interface{}, error) {
 	return a.filesystem.ListDir(path)
 }
 
 // CreateDir 创建目录
-func (a *App) CreateDir(path string) error {
+func (a *App) CreateDir(path string) (*filesystem.FileOperationResult, error) {
 	return a.filesystem.CreateDir(path)
 }
 
 // CreateFile 创建文件
-func (a *App) CreateFile(path string) error {
+func (a *App) CreateFile(path string) (*filesystem.FileOperationResult, error) {
 	return a.filesystem.CreateFile(path)
 }
 
 // DeletePath 删除文件或目录
-func (a *App) DeletePath(path string) error {
+func (a *App) DeletePath(path string) (*filesystem.FileOperationResult, error) {
 	return a.filesystem.DeletePath(path)
 }
 
@@ -288,7 +296,7 @@ type RenamePathRequest struct {
 }
 
 // RenamePath 重命名文件或目录
-func (a *App) RenamePath(req RenamePathRequest) error {
+func (a *App) RenamePath(req RenamePathRequest) (*filesystem.FileOperationResult, error) {
 	return a.filesystem.RenamePath(req.OldPath, req.NewPath)
 }
 
@@ -351,9 +359,9 @@ func (a *App) ResolveShortcut(lnkPath string) (map[string]interface{}, error) {
 	if err != nil {
 		// 目标文件不存在或无法访问
 		return map[string]interface{}{
-			"success":        true,
+			"success":          true,
-			"targetPath":     targetPath,
+			"targetPath":       targetPath,
-			"targetExists":   false,
+			"targetExists":     false,
 			"targetAccessible": false,
 		}, nil
 	}
@@ -368,6 +376,31 @@ func (a *App) ResolveShortcut(lnkPath string) (map[string]interface{}, error) {
 	}, nil
 }
 
+// getWindowsSpecialFolder 从注册表读取 Windows 特殊文件夹的真实路径
+// 用户可通过系统设置修改下载/桌面/文档等目录位置，注册表记录实际路径
+func getWindowsSpecialFolder(guid string, fallbackName string) string {
+	key, err := registry.OpenKey(registry.CURRENT_USER,
+		`Software\Microsoft\Windows\CurrentVersion\Explorer\User Shell Folders`,
+	registry.READ)
+	if err != nil {
+		return ""
+	}
+	defer key.Close()
+
+	val, _, err := key.GetStringValue(guid)
+	if err != nil || val == "" {
+		return ""
+	}
+
+	// 展开 %USERPROFILE% 等环境变量
+	path := os.ExpandEnv(val)
+	// 验证路径存在
+	if _, err := os.Stat(path); err != nil {
+		return ""
+	}
+	return path
+}
+
 // GetCommonPaths 获取常用系统路径
 func (a *App) GetCommonPaths() (map[string]string, error) {
 	homeDir, err := os.UserHomeDir()
@@ -376,10 +409,22 @@ func (a *App) GetCommonPaths() (map[string]string, error) {
 	}
 
 	paths := map[string]string{
-		"home":      homeDir,
+		"home": homeDir,
-		"desktop":   filepath.Join(homeDir, "Desktop"),
+	}
-		"documents": filepath.Join(homeDir, "Documents"),
+
-		"downloads": filepath.Join(homeDir, "Downloads"),
+	// Windows: 从注册表读取特殊文件夹真实路径（用户可能已修改位置）
+	folderGUIDs := map[string]string{
+		"desktop":   "{B4BFCC3A-DB2C-424C-B029-7FE99A87C641}",
+		"documents": "{D20B4C7F-5EA7-40D4B25E-039F6F1FCC8A}",
+		"downloads": "{374DE290-123F-4565-9164-39C4925E467B}",
+	}
+	for name, guid := range folderGUIDs {
+		if p := getWindowsSpecialFolder(guid, name); p != "" {
+			paths[name] = p
+		} else {
+			// folderGUIDs 的 key 均为 ASCII，无需 Unicode 处理
+			paths[name] = filepath.Join(homeDir, strings.ToUpper(name[:1])+name[1:])
+		}
 	}
 
 	// Windows: 动态添加所有盘符
@@ -423,6 +468,11 @@ func (a *App) TestDbConnectionWithParams(req api.TestConnectionRequest) error {
 	return a.connectionAPI.TestDbConnectionWithParams(req)
 }
 
+// LoadAllDatabases 加载全部数据库列表
+func (a *App) LoadAllDatabases(req api.LoadAllDatabasesRequest) ([]string, error) {
+	return a.connectionAPI.LoadAllDatabases(req)
+}
+
 // ExecuteSQL 执行 SQL 语句
 // 注意：SQL 语句应该已经包含分页信息（LIMIT 和 OFFSET），由客户端添加
 func (a *App) ExecuteSQL(connectionId uint, sqlStr string, database string) (map[string]interface{}, error) {
@@ -529,6 +579,16 @@ func (a *App) WindowIsMaximized() bool {
 	return false
 }
 
+// WindowToggleAlwaysOnTop 切换窗口置顶
+func (a *App) WindowToggleAlwaysOnTop() bool {
+	if a.ctx == nil {
+		return false
+	}
+	a.isAlwaysOnTop = !a.isAlwaysOnTop
+	runtime.WindowSetAlwaysOnTop(a.ctx, a.isAlwaysOnTop)
+	return a.isAlwaysOnTop
+}
+
 // ========== SQL 标签页管理接口 ==========
 
 // SaveSqlTabs 保存 SQL 标签页列表
@@ -614,7 +674,11 @@ func (a *App) startAutoUpdateCheck() {
 	}
 
 	config, err := a.updateAPI.GetUpdateConfig()
-	if err != nil || !config["success"].(bool) {
+	if err != nil {
+		return
+	}
+	success, ok := config["success"].(bool)
+	if !ok || !success {
 		return
 	}
 
@@ -692,6 +756,11 @@ func (a *App) GetFileServerURL() string {
 	return "http://localhost:18765"
 }
 
+// DetectFileTypeByContent 通过文件内容检测文件类型（用于小文件）
+func (a *App) DetectFileTypeByContent(path string) (map[string]interface{}, error) {
+	return filesystem.DetectFileTypeByContentSimple(path)
+}
+
 // ========== 回收站接口 ==========
 
 // GetRecycleBinEntries 获取回收站条目
@@ -842,3 +911,47 @@ func (a *App) initFilesystemModule() {
 
 	fmt.Println("[模块] 文件系统模块初始化完成")
 }
+
+// ExportPDF 导出PDF文件
+func (a *App) ExportPDF(content string, title string, fileName string, fontSize int, pageWidth int, pageHeight int) (map[string]interface{}, error) {
+	if a.pdfAPI == nil {
+		return map[string]interface{}{
+			"success": false,
+			"message": "PDF导出功能未初始化",
+		}, fmt.Errorf("PDF导出功能未初始化")
+	}
+
+	req := api.PdfExportRequest{
+		Content:    content,
+		Title:      title,
+		FileName:   fileName,
+		FontSize:   fontSize,
+		PageWidth:  pageWidth,
+		PageHeight: pageHeight,
+	}
+
+	result, err := a.pdfAPI.ExportMarkdownToPDF(req)
+	if err != nil {
+		return map[string]interface{}{
+			"success": false,
+			"message": err.Error(),
+		}, err
+	}
+
+	return map[string]interface{}{
+		"success": result.Success,
+		"message": result.Message,
+		"path":    result.Path,
+		"size":    result.Size,
+	}, nil
+}
+
+// SelectPDFSaveDirectory 选择PDF保存目录
+func (a *App) SelectPDFSaveDirectory() (string, error) {
+	if a.pdfAPI == nil {
+		return "", fmt.Errorf("PDF导出功能未初始化")
+	}
+
+	return a.pdfAPI.SelectDirectory()
+}
+

build/publish/last-version.json

@@ -0,0 +1 @@
+{"version": "0.3.3", "release_date": "2026-04-13", "changelog": "### 新增 ✨\n- Markdown 编辑器: 独立编辑页面、实时预览、字符/行数统计、Ctrl+S 保存、自动保存\n- PDF 导出: 浏览器打印 + 后端 gofpdf/chromedp 多种导出方式\n- 窗口置顶 + 收藏夹置顶\n- Excel/Word 文件预览支持\n- 数据库 UI 大幅改进: 查询历史、查询模板、SQL 工具栏、结果导出\n- 数据库可见性过滤与连接管理增强\n\n### 优化 🚀\n- MySQL 动态连接池重构（健康检查、性能权重、自适应扩缩容）\n- SQL 查询优化器（查询缓存、慢查询日志）\n- Redis Pipeline 支持\n- Wails 框架升级 + FileListPanel 重写\n- CSV 编辑模式优化 + 拷贝功能优化\n\n### 修复 🐛\n- Office 类型检测修复、CORS 跨域修复、大文件卡死修复\n\n### 安全修复 🔒\n- XSS 防护、PDF 路径穿越防护、HTML 注入防护\n\n### 重构 🔧\n- CodeMirror 架构优化、大规模死代码清理(-1306行)", "download_url": "https://c.1216.top/download/u-desk-0.3.3.exe", "file_size": 18396672, "sha256": "f0bdf8954b276f4bb45a69336f171bb2a481f7a7125fc3309aae5de2fbf0cf15", "force_update": false}

build/publish/versions.json

@@ -0,0 +1 @@
+{"updated_at": "2026-04-13T23:45:00+08:00", "versions": [{"version": "0.3.3", "release_date": "2026-04-13", "changelog": "### 新增 ✨\n- **Markdown 编辑器**: 独立编辑页面、实时预览、字符/行数统计、Ctrl+S 保存、自动保存\n- **Markdown 文件页面**: 独立的 Markdown 文件查看与编辑界面\n- **PDF 导出**: 浏览器打印 + 后端 gofpdf/chromedp 多种导出方式\n- **窗口置顶**: 支持窗口始终置顶\n- **收藏夹置顶**: 收藏项支持置顶排序\n- **文件预览**: Excel/Word 文件预览支持\n- **数据库 UI 大幅改进**: 查询历史面板、查询模板面板、SQL 工具栏、结果导出(CSV)、SQL 格式化器\n- **数据库可见性过滤**: 连接管理增强、ConnectionForm 重写、统一错误处理模块\n\n### 优化 🚀\n- MySQL 动态连接池重构 — 健康检查、性能权重、自适应扩缩容\n- SQL 查询优化器 — 查询缓存、慢查询日志 (762 行)\n- Redis Pipeline — 批量命令、事务 MULTI/EXEC 支持\n- Wails 框架升级 + Mermaid 主题切换 + 代码高亮修复\n- FileListPanel 重写 (+511 行) — 删除 FileItemRow，统一列表渲染逻辑\n- CSV 编辑模式优化 + PDF 导出重构\n- 拷贝功能优化 — 新增 ClipboardCopy composable\n\n### 修复 🐛\n- Office 文件预览：修复类型检测与二进制误判\n- 本地文件服务器 CORS 跨域问题\n- 大文件点击卡死问题\n- 收藏夹 bug 修复\n\n### 安全修复 🔒\n- XSS 防护（PdfExportButton、MarkdownPreview HTML 消毒）\n- PDF 导出路径穿越防护\n- PDF 导出标题 HTML 注入防护\n\n### 重构 🔧\n- CodeMirror 架构优化 — 统一导出避免多实例问题\n- 消除代码重复 — storage/connection_service 重构\n- **大规模死代码清理 (-1306 行)**: 删除废弃 storage 层、audit_log、file_lock、recycle_bin、useFileEdit.js(-369行)、useFilePreview.js(-603行) 等\n- 配置加载超时保护、正则表达式预编译、禁止 Ctrl+滚轮缩放", "download_url": "https://c.1216.top/download/u-desk-0.3.3.exe", "file_size": 18396672, "sha256": "f0bdf8954b276f4bb45a69336f171bb2a481f7a7125fc3309aae5de2fbf0cf15"}, {"version": "0.3.2", "release_date": "2026-02-05", "changelog": "### 重构 🔧\n- CodeMirror 架构优化 - 统一导出避免多实例问题\n- 语言加载器优化 - 从动态 import 改为静态导入\n- 动态主题切换 - 使用 Compartment 实现无损切换\n\n### 优化 🚀\n- 编辑器性能 - 添加内容更新防抖\n- 亮色主题 - 改进代码编辑器亮色模式样式", "download_url": "", "file_size": 0, "sha256": ""}, {"version": "0.3.0", "release_date": "2026-02-04", "changelog": "### 新增 ✨\n- Markdown 图表支持 - Mermaid 流程图、时序图、类图等\n- 代码语法高亮 - 支持 20+ 种常用编程语言\n- 文件列表优化 - 文件夹优先显示，同类型按名称排序", "download_url": "", "file_size": 0, "sha256": ""}, {"version": "0.2.0", "release_date": "2026-01-28", "changelog": "### 新增 ✨\n- 应用配置管理 - 全新设置面板，支持自定义显示模块和默认启动页\n- 智能更新提醒 - 新增版本更新通知组件\n- 模块重命名 - 应用更名为 u-desk", "download_url": "", "file_size": 0, "sha256": ""}, {"version": "0.1.5", "release_date": "2026-01-22", "changelog": "### 新增 ✨\n- 文件管理模块 - 文件浏览、编辑、操作功能\n- 版本更新管理 - 自动检查和下载更新\n- 系统信息查询 - CPU、内存、磁盘等硬件信息", "download_url": "", "file_size": 0, "sha256": ""}, {"version": "0.1.0", "release_date": "2026-01-18", "changelog": "### 新增 ✨\n- 数据库管理 - 支持多种数据库连接和查询功能", "download_url": "", "file_size": 0, "sha256": ""}]}

cmd/debug_db/main.go

@@ -0,0 +1,73 @@
+package main
+
+import (
+	"fmt"
+	"log"
+
+	"u-desk/internal/storage"
+	"u-desk/internal/storage/models"
+)
+
+func main() {
+	// 初始化数据库
+	db, err := storage.Init()
+	if err != nil {
+		log.Fatalf("数据库初始化失败: %v", err)
+	}
+
+	fmt.Println("=== 数据库连接配置调试工具 ===")
+	fmt.Println()
+
+	// 列出所有连接
+	var connections []models.DbConnection
+	result := db.Order("id").Find(&connections)
+	if result.Error != nil {
+		log.Fatalf("查询失败: %v", result.Error)
+	}
+
+	fmt.Printf("当前有 %d 个连接配置:\n", len(connections))
+	fmt.Println()
+
+	for _, conn := range connections {
+		fmt.Printf("ID: %d\n", conn.ID)
+		fmt.Printf("  名称: %s\n", conn.Name)
+		fmt.Printf("  类型: %s\n", conn.Type)
+		fmt.Printf("  主机: %s:%d\n", conn.Host, conn.Port)
+		fmt.Printf("  用户名: %s\n", conn.Username)
+		fmt.Printf("  创建时间: %s\n", conn.CreatedAt.Format("2006-01-02 15:04:05"))
+		fmt.Println()
+	}
+
+	// 询问用户操作
+	var choice int
+	fmt.Print("请选择操作:\n")
+	fmt.Print("1. 删除指定 ID 的连接\n")
+	fmt.Print("2. 列出连接详情\n")
+	fmt.Print("0. 退出\n")
+	fmt.Print("请输入: ")
+	fmt.Scanln(&choice)
+
+	if choice == 1 {
+		var id uint
+		fmt.Print("请输入要删除的连接 ID: ")
+		fmt.Scanln(&id)
+
+		// 确认
+		var confirm string
+		fmt.Printf("确认删除 ID=%d 的连接吗？(y/N): ", id)
+		fmt.Scanln(&confirm)
+
+		if confirm == "y" || confirm == "Y" {
+			result := db.Delete(&models.DbConnection{}, id)
+			if result.Error != nil {
+				log.Printf("删除失败: %v", result.Error)
+			} else {
+				fmt.Printf("删除成功！影响行数: %d\n", result.RowsAffected)
+			}
+		} else {
+			fmt.Println("已取消删除")
+		}
+	}
+
+	fmt.Println("\n工具退出")
+}

docs/04-功能迭代/GO-DESK-1.尝试/更新升级功能设计.md

@@ -1,7 +1,7 @@
 # Go Desk 更新升级功能设计
 
-> **文档版本**：v1.0  
+> **文档版本**：v0.1.0
-> **创建时间**：2025-01-XX  
+> **创建时间**：2026-01-20
 > **维护者**：JueChen
 > **状态**：设计阶段
 

docs/04-功能迭代/GO-DESK-1.尝试/设备调用测试功能设计.md

@@ -1,7 +1,7 @@
 # Go Desk 设备调用测试功能设计
 
-> **文档版本**：v1.0  
+> **文档版本**：v0.1.0
-> **创建时间**：2025-01-XX  
+> **创建时间**：2026-01-20
 > **维护者**：JueChen
 > **状态**：设计阶段
 

docs/04-功能迭代/GO-DESK-1.尝试/需求.md

@@ -1,7 +1,7 @@
 # Go Desk 需求文档
 
-> **文档版本**：v1.0  
+> **文档版本**：v0.1.0
-> **创建时间**：2025-12-29  
+> **创建时间**：2026-01-20
 > **维护者**：JueChen
 > **状态**：已确定
 

docs/04-功能迭代/GO-DESK-2.数据库客户端/README.md

@@ -1,7 +1,7 @@
 # 数据库客户端模块
 
 **模块状态**：开发中  
-**最后更新**：2025-01-28
+**最后更新**：2026-01-28
 
 ---
 
@@ -19,7 +19,7 @@
 
 ## 🚀 MVP状态
 
-**✅ 当前版本已达到MVP标准，可以发布MVP v1.0版本**
+**🔄 当前版本处于试验阶段，正在开发中**
 
 详细状态和检查结果请参考：
 - [MVP规划.md](./设计文档/MVP规划.md) - MVP功能规划

docs/04-功能迭代/GO-DESK-2.数据库客户端/任务规划.md

@@ -1,6 +1,6 @@
 # 数据库客户端任务规划
 
-**更新日期**：2025-01-28  
+**更新日期**：2026-01-28  
 **状态**：进行中
 
 ---

docs/04-功能迭代/GO-DESK-2.数据库客户端/决策记录/ADR-001-事件系统设计.md

@@ -1,7 +1,7 @@
 # ADR-001: 事件系统设计
 
 **状态**：已采纳  
-**日期**：2025-01-28  
+**日期**：2026-01-28  
 **决策者**：开发团队
 
 ## 上下文

docs/04-功能迭代/GO-DESK-2.数据库客户端/决策记录/ADR-002-表结构Tab显示策略.md

@@ -1,7 +1,7 @@
 # ADR-002: 表结构Tab显示策略
 
 **状态**：已采纳  
-**日期**：2025-01-28  
+**日期**：2026-01-28  
 **决策者**：开发团队
 
 ## 上下文

docs/04-功能迭代/GO-DESK-2.数据库客户端/决策记录/ADR-003-右键菜单实现方案.md

@@ -1,7 +1,7 @@
 # ADR-003: 右键菜单实现方案
 
 **状态**：已采纳  
-**日期**：2025-01-28  
+**日期**：2026-01-28  
 **决策者**：开发团队
 
 ## 上下文

docs/04-功能迭代/GO-DESK-2.数据库客户端/文档结构说明.md

@@ -1,6 +1,6 @@
 # 文档结构说明
 
-**创建日期**：2025-01-28  
+**创建日期**：2026-01-28  
 **目的**：说明文档结构如何支持现代化AI人机协同模式
 
 ---

docs/04-功能迭代/GO-DESK-2.数据库客户端/核对报告/BUG报告.md

@@ -1,6 +1,6 @@
 # 数据库客户端 BUG 报告
 
-**检查日期**：2025-01-28  
+**检查日期**：2026-01-28  
 **检查人**：JueChen
 
 ---

docs/04-功能迭代/GO-DESK-2.数据库客户端/核对报告/MVP发布检查.md

@@ -1,7 +1,8 @@
 # MVP发布检查报告
 
-**检查日期**：2025-01-28  
+**检查日期**：2026-01-28
-**目标版本**：MVP v1.0  
+**目标版本**：数据库客户端（试验阶段）
+**状态**：🔄 开发中
 **检查人**：JueChen
 
 ---
@@ -64,7 +65,7 @@
 
 ## 七、发布决策 ✅
 
-**✅ 建议发布MVP v1.0版本**
+**⚠️ 当前处于试验阶段，暂不建议发布**
 
 **理由**：
 1. 核心功能和重要功能全部完成（表结构编辑可延后）

docs/04-功能迭代/GO-DESK-2.数据库客户端/核对报告/前端样式重构报告.md

@@ -1,6 +1,6 @@
 # 前端样式重构报告
 
-**重构日期**：2025-01-28  
+**重构日期**：2026-01-28  
 **重构范围**：数据库客户端前端布局和样式系统  
 **重构依据**：[前端布局样式系统设计.md](../设计文档/前端布局样式系统设计.md)
 

docs/04-功能迭代/GO-DESK-2.数据库客户端/核对报告/功能实现检查报告.md

@@ -1,6 +1,6 @@
 # 功能实现检查报告
 
-**检查日期**：2025-01-28  
+**检查日期**：2026-01-28  
 **检查范围**：各功能模块实现情况检查  
 **状态**：✅ 核心功能已完成
 

docs/04-功能迭代/GO-DESK-2.数据库客户端/核对报告/完善性检查报告.md

@@ -1,6 +1,6 @@
 # 数据库客户端完善性检查报告
 
-**检查日期**：2025-01-28  
+**检查日期**：2026-01-28  
 **检查人**：JueChen
 
 > **注意**：本文档内容已合并到[综合检查报告.md](./综合检查报告.md)，请优先查看综合检查报告。本文档保留作为历史记录。

docs/04-功能迭代/GO-DESK-2.数据库客户端/核对报告/综合检查报告.md

@@ -1,6 +1,6 @@
 # 数据库客户端综合检查报告
 
-**检查日期**：2025-01-28  
+**检查日期**：2026-01-28  
 **检查人**：JueChen  
 **检查范围**：架构、代码、编译、完善性全面检查
 

docs/04-功能迭代/GO-DESK-2.数据库客户端/核对报告/表结构功能实现说明.md

@@ -700,7 +700,7 @@ Redis: GetKeyInfo → 命令查询
 
 ---
 
-**实现时间**: 2025-01-XX
+**实现时间**: 2026-01-XX
 **状态**: ✅ 已完成
 **测试状态**: ⏳ 待用户测试
 

docs/04-功能迭代/GO-DESK-2.数据库客户端/核对报告/超级工程师推进总结.md

@@ -1,6 +1,6 @@
 # 超级工程师推进总结
 
-**日期**：2025-01-28  
+**日期**：2026-01-28  
 **推进范围**：代码质量检查、问题修复、表结构编辑功能实现
 
 ---

docs/04-功能迭代/GO-DESK-2.数据库客户端/测试用例/功能测试用例.md

@@ -1,6 +1,6 @@
 # 功能测试用例
 
-**创建日期**：2025-01-28  
+**创建日期**：2026-01-28  
 **测试范围**：数据库客户端核心功能
 
 ---

docs/04-功能迭代/GO-DESK-2.数据库客户端/知识库/参考/技术栈.md

@@ -1,7 +1,7 @@
 # 技术栈参考
 
 **状态**：已确定  
-**最后更新**：2025-01-28
+**最后更新**：2026-01-28
 
 ---
 

docs/04-功能迭代/GO-DESK-2.数据库客户端/知识库/规范/AI协作检查清单.md

@@ -1,7 +1,7 @@
 # AI协作检查清单
 
 **状态**：已确定  
-**最后更新**：2025-01-28
+**最后更新**：2026-01-28
 
 ---
 

docs/04-功能迭代/GO-DESK-2.数据库客户端/知识库/规范/文档编写规范.md

@@ -1,7 +1,7 @@
 # 文档编写规范
 
 **状态**：已确定  
-**最后更新**：2025-01-28
+**最后更新**：2026-01-28
 
 ---
 

docs/04-功能迭代/GO-DESK-2.数据库客户端/知识库/规范/架构规范.md

@@ -1,7 +1,7 @@
 # 架构规范
 
 **状态**：已确定  
-**最后更新**：2025-01-28
+**最后更新**：2026-01-28
 
 ---
 

docs/04-功能迭代/GO-DESK-2.数据库客户端/知识库/规范/编码规范.md

@@ -1,7 +1,7 @@
 # 编码规范
 
 **状态**：已确定  
-**最后更新**：2025-01-28
+**最后更新**：2026-01-28
 
 ---
 

docs/04-功能迭代/GO-DESK-2.数据库客户端/行动建议.md

@@ -1,6 +1,6 @@
 # 下一步行动建议
 
-**更新日期**：2025-01-28  
+**更新日期**：2026-01-28  
 **MVP状态**：✅ 已达到发布标准  
 **优先级**：按P0 → P1 → P2顺序
 
@@ -196,7 +196,7 @@
 
 **MVP完成度**：约90%（核心功能100%，重要功能100%）
 
-**MVP状态**：✅ **已达到发布标准，可以发布MVP v1.0版本**
+**MVP状态**：🔄 **试验阶段，功能开发中**
 
 详细检查结果请参考：[MVP发布检查.md](./核对报告/MVP发布检查.md)
 

docs/04-功能迭代/GO-DESK-2.数据库客户端/设计文档/MVP开发路线图.md

@@ -1,6 +1,6 @@
 # MVP开发路线图
 
-**创建日期**：2025-01-28  
+**创建日期**：2026-01-28  
 **基于**：[MVP规划.md](./MVP规划.md)  
 **目标**：以MVP为方向指引任务推进
 
@@ -26,7 +26,7 @@
 
 ## 二、MVP开发路线图
 
-### 阶段1：核心功能 ✅ 已完成（2025-01-28）
+### 阶段1：核心功能 ✅ 已完成（2026-01-28）
 - ✅ 连接管理、SQL执行、表结构查看、右键菜单
 
 ### 阶段2：重要功能 ✅ 已完成

docs/04-功能迭代/GO-DESK-2.数据库客户端/设计文档/MVP规划.md

@@ -1,6 +1,6 @@
 # 数据库客户端 MVP（最小可用产品）规划
 
-**创建日期**：2025-01-28  
+**创建日期**：2026-01-28  
 **目标**：定义最小可用产品范围，指导开发优先级  
 **原则**：核心功能优先，快速验证，迭代优化
 
@@ -145,14 +145,14 @@
 - ✅ 表结构查看
 - ✅ 右键菜单
 
-**完成时间**：2025-01-28
+**完成时间**：2026-01-28
 
 ### 阶段2：重要功能 ⚠️ 进行中
 - ✅ 书签管理（基本完成）
 - ✅ 模板管理（基本完成）
 - ⚠️ 表结构编辑（基础框架完成，待完善）
 
-**预计完成时间**：2025-01-29
+**预计完成时间**：2026-01-29
 
 ### 阶段3：优化功能 ⬜ 待开始
 - ⬜ 性能优化

docs/04-功能迭代/GO-DESK-2.数据库客户端/设计文档/功能设计/书签模板历史功能定位设计.md

@@ -1,6 +1,6 @@
 # SQL历史功能设计
 
-**设计日期**：2025-01-28  
+**设计日期**：2026-01-28  
 **设计目标**：明确SQL历史功能的设计，SQL由SQL编辑区保存得到
 
 ---

docs/04-功能迭代/GO-DESK-2.数据库客户端/设计文档/功能设计/多表结构查看方案分析.md

@@ -1,6 +1,6 @@
 # 多表结构查看方案分析
 
-**分析日期**：2025-01-28  
+**分析日期**：2026-01-28  
 **分析范围**：多表结构查看的不同实现方案  
 **状态**：方案分析
 

docs/04-功能迭代/GO-DESK-2.数据库客户端/设计文档/功能设计/左侧资源管理面板设计.md

@@ -1,6 +1,6 @@
 # 左侧资源管理面板设计
 
-**设计日期**：2025-01-28  
+**设计日期**：2026-01-28  
 **设计目标**：在左侧功能区下方增加资源管理面板，统一管理SQL编辑器历史、书签和SQL模板
 
 ---

docs/04-功能迭代/GO-DESK-2.数据库客户端/设计文档/功能设计/新表创建功能设计.md

@@ -1,6 +1,6 @@
 # 新表创建功能设计
 
-**设计日期**：2025-01-28  
+**设计日期**：2026-01-28  
 **设计范围**：MySQL、MongoDB、Redis 新表/集合/Key创建功能设计  
 **状态**：设计阶段
 

docs/04-功能迭代/GO-DESK-2.数据库客户端/设计文档/功能设计/表结构查看功能设计-待讨论问题.md

@@ -1,6 +1,6 @@
 # 表结构查看功能 - 待讨论问题
 
-**创建日期**：2025-01-28  
+**创建日期**：2026-01-28  
 **目的**：整理设计文档中需要进一步讨论和明确的问题
 
 ---

docs/04-功能迭代/GO-DESK-2.数据库客户端/设计文档/功能设计/表结构查看功能设计.md

@@ -1,6 +1,6 @@
 # 表结构查看功能设计
 
-**设计日期**：2025-01-28  
+**设计日期**：2026-01-28  
 **设计范围**：MySQL、Redis、MongoDB 表结构查看界面设计  
 **状态**：设计阶段
 
@@ -152,7 +152,7 @@
 │   "name": "John",                                           │
 │   "email": "john@example.com",                              │
 │   "age": 30,                                                │
-│   "created_at": ISODate("2025-01-01T00:00:00Z")            │
+│   "created_at": ISODate("2026-01-01T00:00:00Z")            │
 │ }                                                            │
 └─────────────────────────────────────────────────────────────┘
 [显示最多 5 个文档示例，JSON 格式，可折叠展开]

docs/04-功能迭代/GO-DESK-2.数据库客户端/设计文档/架构设计/事件系统设计.md

@@ -1,6 +1,6 @@
 # 事件系统设计
 
-**设计日期**：2025-01-28  
+**设计日期**：2026-01-28  
 **设计范围**：数据库客户端全局事件系统  
 **状态**：设计阶段
 

docs/04-功能迭代/GO-DESK-2.数据库客户端/设计文档/架构设计/前端架构设计.md

@@ -3,7 +3,7 @@
 
 **文档版本**：v2.0  
 **维护者**：JueChen  
-**更新日期**：2025-01-28  
+**更新日期**：2026-01-28  
 **源码路径**：`go-desk/web/src/views/db-cli/`
 
 ---

docs/04-功能迭代/GO-DESK-2.数据库客户端/设计文档/架构设计/右键菜单系统设计.md

@@ -1,6 +1,6 @@
 # 右键菜单系统设计
 
-**设计日期**：2025-01-28  
+**设计日期**：2026-01-28  
 **设计范围**：数据库客户端全局右键菜单系统  
 **状态**：设计阶段
 

docs/04-功能迭代/GO-DESK-2.数据库客户端/设计文档/架构设计/后端架构设计.md

@@ -2,7 +2,7 @@
 
 **文档版本**：v2.0  
 **维护者**：JueChen  
-**更新日期**：2025-01-28  
+**更新日期**：2026-01-28  
 **源码路径**：`go-desk/`
 
 ---

docs/04-功能迭代/GO-DESK-2.数据库客户端/设计文档/需求设计/前端布局样式系统设计.md

@@ -1,7 +1,7 @@
 # 前端布局样式系统设计
 
 **创建日期**：2026-01-01  
-**最后更新**：2025-01-09  
+**最后更新**：2026-01-09  
 **目标**：建立系统化的前端布局和样式规范，确保一致性和可维护性  
 **原则**：统一规范、可扩展、易维护、主题兼容  
 **状态**：✅ 已完成 Arco Design 规范优化  

docs/04-功能迭代/GO-DESK-2.数据库客户端/设计文档/需求设计/数据库类型功能差异分析.md

@@ -1,6 +1,6 @@
 # 数据库类型功能差异分析
 
-**分析日期**：2025-01-28  
+**分析日期**：2026-01-28  
 **分析范围**：MySQL、Redis、MongoDB 功能支持差异
 
 ---

docs/04-功能迭代/GO-DESK-2.数据库客户端/问题追踪/待实现/功能-001-右键菜单系统实现.md

@@ -2,7 +2,7 @@
 
 **状态**：✅ 基本实现完成（待测试验证）  
 **优先级**：P0  
-**创建日期**：2025-01-28  
+**创建日期**：2026-01-28  
 **关联设计**：[设计文档/架构设计/右键菜单系统设计.md](../../设计文档/架构设计/右键菜单系统设计.md)
 
 ## 功能描述

docs/04-功能迭代/GO-DESK-2.数据库客户端/问题追踪/待讨论/问题-001-右键菜单实现方式.md

@@ -2,7 +2,7 @@
 
 **状态**：已解决  
 **优先级**：P0  
-**提出日期**：2025-01-28  
+**提出日期**：2026-01-28  
 **提出人**：开发团队
 
 ## 问题描述
@@ -47,7 +47,7 @@
 
 ## 讨论记录
 
-- 2025-01-28：已创建设计文档 [设计文档/架构设计/右键菜单系统设计.md](../../设计文档/架构设计/右键菜单系统设计.md)
+- 2026-01-28：已创建设计文档 [设计文档/架构设计/右键菜单系统设计.md](../../设计文档/架构设计/右键菜单系统设计.md)
 
 ## 决策
 
@@ -55,7 +55,7 @@
 
 **决策记录**：[ADR-003: 右键菜单实现方案](../../决策记录/ADR-003-右键菜单实现方案.md)
 
-**决策日期**：2025-01-28
+**决策日期**：2026-01-28
 
 **理由**：
 1. 符合Arco Design设计规范

docs/FINAL-SUMMARY.md

@@ -1,527 +0,0 @@
-# 🎉 代码审查与优化完整总结报告
-
-## 执行时间
-2026-01-27
-
-## 项目概览
-**项目名称**：go-desk (U-Desk 数据库客户端)
-**技术栈**：Go + Wails + Vue 3
-**审查范围**：全代码库（后端 + 前端）
-
----
-
-## 📊 总体改进统计
-
-### 代码质量提升
-
-| 维度 | 初始评分 | 最终评分 | 提升幅度 |
-|------|---------|---------|---------|
-| **整体质量** | ⭐⭐⭐☆☆ | ⭐⭐⭐⭐⭐ | +40% |
-| **DRY 原则** | ⭐⭐⭐☆☆ | ⭐⭐⭐⭐⭐ | +40% |
-| **配置管理** | ⭐⭐☆☆☆ | ⭐⭐⭐⭐☆ | +60% |
-| **代码简洁** | ⭐⭐⭐☆☆ | ⭐⭐⭐⭐☆ | +40% |
-| **可维护性** | ⭐⭐⭐☆☆ | ⭐⭐⭐⭐⭐ | +40% |
-| **安全意识** | ⭐⭐☆☆☆ | ⭐⭐⭐⭐☆ | +60% |
-
-### 代码改进量化
-
-```
-✅ 消除重复代码：     ~100 行
-✅ 消除硬编码配置：   20+ 处
-✅ 优化日志记录：     18 个
-✅ 简化注释：         -150 行
-✅ 删除过度封装：     1 个文件
-✅ 新增工具函数：     2 个
-```
-
----
-
-## ✅ 已完成的优化（按级别）
-
-### P0 级别（严重问题）
-- ✅ 无严重问题
-
-### P1 级别（重要）- 3项全部完成
-
-#### 1. 重复的 formatBytes 函数 ✅
-**问题**：3处重复实现
-**解决**：提取到 `internal/common/utils.go`
-**效果**：消除重复，统一维护
-
-#### 2. 前端文件类型判断硬编码 ✅
-**问题**：硬编码扩展名列表
-**解决**：使用 FILE_EXTENSIONS 常量
-**效果**：配置集中化
-
-#### 3. FileSystem.vue 组件过大 ⚠️
-**问题**：2365行单一文件
-**状态**：已记录，建议单独重构项目
-
-### P2 级别（中等）- 3项全部完成
-
-#### 4. ZIP 文件过度日志 ✅
-**问题**：18个无条件调试日志
-**解决**：改为条件日志（UDESK_ZIP_DEBUG=1）
-**效果**：生产环境安静，开发时可调试
-
-#### 5. 重复的错误处理模式 ✅
-**问题**：200+ 处重复错误处理
-**解决**：创建错误处理辅助函数（后删除过度封装）
-**效果**：保持简单，不过度抽象
-
-#### 6. ZIP 路径验证重复 ✅
-**问题**：4个函数重复验证
-**解决**：提取 validateZipPath 函数
-**效果**：代码减少20行
-
-### P3 级别（轻微）- 2项完成
-
-#### 7. 超时配置统一 ✅
-**问题**：14处硬编码超时
-**解决**：创建 timeout.go 配置
-**效果**：统一管理，分级策略
-
-#### 8. 文档注释完善 → 简化 ✅
-**初始**：过度详细的文档（170行注释）
-**优化**：简化为适度注释（20行注释）
-**效果**：更简洁，避免过度
-
-### 深度优化 - 2项完成
-
-#### 9. 避免过度封装 ✅
-**问题**：创建了未被使用的 WrapError
-**解决**：删除 errors.go，简化注释
-**效果**：符合 YAGNI 和 KISS 原则
-
-#### 10. 代码质量和安全检查 ✅
-**发现**：
-- 🔴 硬编码数据库密码（安全隐患）
-- 🟠 40个 console.log
-- 🟡 未处理的 TODO
-
----
-
-## 📁 创建和修改的文件
-
-### 新增文件（2个）
-1. ✅ `internal/common/utils.go` - 格式化工具（21行）
-2. ✅ `internal/common/timeout.go` - 超时配置（12行）
-
-### 修改文件（6个）
-1. ✅ `internal/system/system.go` - 使用共享 FormatBytes
-2. ✅ `internal/filesystem/zip.go` - 提取验证函数 + 条件日志
-3. ✅ `internal/service/sql_exec_service.go` - 使用统一超时
-4. ✅ `internal/dbclient/pool.go` - 使用统一超时
-5. ✅ `internal/dbclient/redis.go` - 使用统一超时
-6. ✅ `internal/dbclient/mongo.go` - 使用统一超时
-
-### 前端修改（1个）
-7. ✅ `web/src/utils/fileUtils.js` - 使用 FILE_EXTENSIONS 常量
-
-### 生成的文档（4个）
-1. ✅ `docs/code-review-p3-report.md` - P3 优化报告
-2. ✅ `docs/code-review-deep-optimization-report.md` - 深度优化报告
-3. ✅ `docs/anti-over-engineering-report.md` - 避免过度封装报告
-4. ✅ `docs/code-quality-security-report.md` - 质量和安全检查
-
----
-
-## 🎯 核心改进亮点
-
-### 1. 建立了 common 工具包 ✨
-
-```
-internal/common/
-├── utils.go    # FormatBytes - 消除重复
-└── timeout.go  # 超时常量 - 统一配置
-```
-
-**特点**：
-- ✅ 简洁实用（2个文件，33行代码）
-- ✅ 每个函数都有实际使用
-- ✅ 避免过度封装
-- ✅ 注释适度
-
-### 2. 超时分级策略 ✨
-
-| 级别 | 超时 | 用途 |
-|------|------|------|
-| Ping | 2秒 | 连接测试 |
-| Connect | 5秒 | 建立连接 |
-| FastQuery | 10秒 | 元数据查询 |
-| Query | 30秒 | 普通查询 |
-| LongOp | 60秒 | 复杂操作 |
-
-**价值**：
-- 14处硬编码 → 统一配置
-- 平衡用户体验和系统资源
-- 支持环境差异化
-
-### 3. 条件日志机制 ✨
-
-```go
-var zipDebugMode = os.Getenv("UDESK_ZIP_DEBUG") == "1"
-
-func debugLog(format string, args ...interface{}) {
-    if zipDebugMode {
-        log.Printf(format, args...)
-    }
-}
-```
-
-**使用**：
-```bash
-# 生产环境：无调试日志
-./go-desk
-
-# 开发环境：启用详细日志
-UDESK_ZIP_DEBUG=1 ./go-desk
-```
-
-### 4. 前端配置常量化 ✨
-
-```javascript
-// 修改前：硬编码
-return ['jpg', 'jpeg', 'png', 'gif'].includes(ext)
-
-// 修改后：使用常量
-return FILE_EXTENSIONS.IMAGE.includes(ext)
-```
-
-**价值**：
-- 修改一处，全局生效
-- 便于扩展新类型
-- 配置集中管理
-
----
-
-## 🔍 发现的待修复问题
-
-### 🔴 紧急（安全）
-
-#### 硬编码数据库凭证
-**位置**：`internal/database/db.go:36-37`
-**风险**：代码泄露导致数据库被攻击
-**建议**：使用环境变量或配置文件
-
-```go
-// 建议修改
-config := mysqldriver.Config{
-    User:   os.Getenv("DB_USER"),
-    Passwd: os.Getenv("DB_PASSWORD"),
-    ...
-}
-```
-
-### 🟠 重要（代码质量）
-
-#### 1. 过多的 console.log
-**位置**：`web/src/components/FileSystem.vue`
-**数量**：40个
-**建议**：创建条件日志工具
-
-#### 2. FileSystem.vue 组件过大
-**大小**：2365行
-**建议**：拆分为多个小组件和 composables
-
----
-
-## 📈 最终代码质量评分
-
-### 总体评分：⭐⭐⭐⭐☆ (4.5/5)
-
-| 评分维度 | 得分 | 说明 |
-|---------|------|------|
-| **DRY 原则** | ⭐⭐⭐⭐⭐ | 无重复代码 |
-| **配置管理** | ⭐⭐⭐⭐☆ | 统一配置管理 |
-| **代码简洁** | ⭐⭐⭐⭐☆ | 简洁易读 |
-| **可维护性** | ⭐⭐⭐⭐⭐ | 结构清晰 |
-| **日志管理** | ⭐⭐⭐⭐☆ | 可控可调 |
-| **安全意识** | ⭐⭐⭐☆☆ | 有保护，需改进 |
-
-**说明**：
-- ✅ 代码质量优秀，结构清晰
-- ⚠️ 需要修复硬编码凭证（安全）
-- ⚠️ 建议重构大组件（可维护性）
-
----
-
-## 🛡️ 安全检查结果
-
-### ✅ 已有的安全措施
-
-1. **路径遍历保护** ✅
-   ```go
-   func isSafePath(path string) bool {
-       if strings.Contains(cleanPath, "..") {
-           return false  // ✅ 防止 ../ 攻击
-       }
-       ...
-   }
-   ```
-
-2. **SQL 注入防护** ✅
-   ```go
-   query.Where("membername LIKE ?", keyword)  // ✅ 参数化查询
-   ```
-
-3. **系统目录保护** ✅
-   ```go
-   forbidden := []string{
-       `c:\windows`,
-       `c:\program files`,
-       ...
-   }
-   ```
-
-### ⚠️ 发现的安全隐患
-
-1. **硬编码凭证** 🔴
-   - 数据库密码：123456
-   - 建议：使用环境变量
-
-2. **调试日志过多** 🟠
-   - 40个 console.log
-   - 建议：条件日志
-
----
-
-## 💡 最佳实践应用
-
-### ✅ 成功应用的原则
-
-1. **DRY（Don't Repeat Yourself）**
-   - ✅ 提取 FormatBytes
-   - ✅ 提取 validateZipPath
-   - ✅ 统一超时配置
-
-2. **YAGNI（You Aren't Gonna Need It）**
-   - ✅ 删除未使用的 WrapError
-   - ✅ 删除过度封装
-   - ✅ 简化冗长注释
-
-3. **KISS（Keep It Simple, Stupid）**
-   - ✅ 优先使用标准库
-   - ✅ 避免过度抽象
-   - ✅ 代码简洁明了
-
-4. **防御性编程（适度）**
-   - ✅ 路径安全检查
-   - ✅ SQL 参数化查询
-   - ⚠️ 避免过度防御
-
----
-
-## 📊 优化前后对比
-
-### 代码重复
-
-| 类型 | 优化前 | 优化后 | 改善 |
-|------|--------|--------|------|
-| formatBytes | 3处重复 | 1处共享 | -67% |
-| ZIP验证 | 4处重复 | 1处共享 | -75% |
-| 文件扩展名 | 7处重复 | 1处常量 | -86% |
-
-### 配置管理
-
-| 类型 | 优化前 | 优化后 | 改善 |
-|------|--------|--------|------|
-| 超时时间 | 14处硬编码 | 5个常量 | 集中化 |
-| 文件类型 | 7处硬编码 | 1个常量 | 集中化 |
-| 日志输出 | 18个无条件 | 条件控制 | 可配置 |
-
-### 文档注释
-
-| 类型 | 优化前 | 优化后 | 改善 |
-|------|--------|--------|------|
-| 注释总量 | ~200行 | ~30行 | -85% |
-| 注释质量 | 过度详细 | 适度精简 | 更实用 |
-
----
-
-## 🚀 后续建议
-
-### 🔴 紧急（本周内）
-
-1. **修复硬编码凭证**
-   ```bash
-   # 使用环境变量
-   export DB_USER=root
-   export DB_PASSWORD=your_secure_password
-   ```
-
-2. **创建 .gitignore**
-   ```
-   .env
-   config.local.json
-   *.log
-   ```
-
-### 🟠 重要（本月内）
-
-3. **重构 FileSystem.vue**
-   - 拆分为多个小组件
-   - 提取 composables
-   - 减少到 <500 行
-
-4. **清理 console.log**
-   - 创建条件日志工具
-   - 仅开发环境输出
-
-### 🟢 优化（下个迭代）
-
-5. **添加单元测试**
-   - common 包测试
-   - 关键函数测试
-   - 集成测试
-
-6. **性能优化**
-   - 大文件处理
-   - ZIP 读取优化
-   - 内存使用优化
-
----
-
-## ✅ 验证状态
-
-### 编译验证
-```bash
-$ go build -v
-go-desk/internal/common
-go-desk/internal/system
-go-desk/internal/dbclient
-go-desk/internal/service
-go-desk/internal/api
-go-desk
-✅ 编译成功
-```
-
-### 代码检查
-```bash
-$ go vet ./...
-✅ 无问题
-
-$ go fmt ./...
-✅ 格式正确
-```
-
-### 兼容性
-- ✅ 无破坏性修改
-- ✅ 向后兼容
-- ✅ API 未改变
-
----
-
-## 📚 生成的文档
-
-### 审查报告
-1. ✅ **code-review-p3-report.md** - P3 级别优化报告
-2. ✅ **code-review-deep-optimization-report.md** - 深度优化报告
-3. ✅ **anti-over-engineering-report.md** - 避免过度封装报告
-4. ✅ **code-quality-security-report.md** - 质量和安全检查
-
-### 内容涵盖
-- ✅ 问题分析
-- ✅ 解决方案
-- ✅ 代码示例
-- ✅ 使用指南
-- ✅ 后续建议
-- ✅ 最佳实践
-
----
-
-## 🎓 经验总结
-
-### 成功经验
-
-1. **小步快跑，持续优化**
-   - 分 P0/P1/P2/P3 优先级处理
-   - 每次改进后立即验证
-   - 避免大爆炸式重构
-
-2. **审查过度封装**
-   - 删除了未使用的 WrapError
-   - 简化了冗长的注释
-   - 保持了代码简洁性
-
-3. **统一配置管理**
-   - 超时配置集中化
-   - 文件类型常量化
-   - 便于维护和修改
-
-4. **条件化调试输出**
-   - 日志可配置
-   - 生产环境安静
-   - 开发环境详细
-
-### 需要改进
-
-1. **凭证管理**
-   - 避免硬编码
-   - 使用环境变量
-   - 密钥管理最佳实践
-
-2. **组件拆分**
-   - 避免超大组件
-   - 单一职责原则
-   - 提高可测试性
-
-3. **测试覆盖**
-   - 添加单元测试
-   - 集成测试
-   - 自动化测试
-
----
-
-## 🎊 最终评价
-
-### 代码现状：⭐⭐⭐⭐☆ (4.5/5)
-
-**优势**：
-- ✅ 代码质量优秀
-- ✅ 结构清晰合理
-- ✅ 无重复代码
-- ✅ 配置集中管理
-- ✅ 日志可控可调
-- ✅ 有安全防护措施
-
-**待改进**：
-- ⚠️ 需修复硬编码凭证（安全）
-- ⚠️ 建议重构大组件（可维护性）
-- ⚠️ 添加单元测试（质量保证）
-
----
-
-## 📝 附录
-
-### 修改文件统计
-- 新增文件：2个
-- 修改文件：7个
-- 删除文件：1个（过度封装）
-- 生成文档：4个
-
-### 代码行数变化
-- 删除重复代码：~100行
-- 新增工具代码：~30行
-- 简化注释：-150行
-- 净减少：~220行
-
-### 编译验证
-- ✅ Go 编译通过
-- ✅ go vet 无问题
-- ✅ go fmt 已格式化
-- ✅ 无语法错误
-
----
-
-**报告生成时间**：2026-01-27
-**审查类型**：全面代码审查与优化
-**审查范围**：全代码库（Go + Vue）
-**最终状态**：✅ 全部完成
-**代码质量**：⭐⭐⭐⭐☆ 优秀
-
----
-
-**感谢您的耐心！代码审查和优化工作已圆满完成。** 🎉
-
-如有任何问题或需要进一步的优化，请随时告知！

docs/PROJECT_STATUS.md

@@ -1,157 +0,0 @@
-# U-Desk 项目状态
-
-**更新日期**：2025-01-28
-**版本**：v0.2.0 (开发中)
-**状态**：🚧 开发版本
-
----
-
-## 📊 项目概览
-
-U-Desk 是基于 Wails 的桌面应用程序，集成了数据库客户端、文件管理、设备测试等功能。
-
-### 核心模块
-
-| 模块 | 状态 | 说明 |
-|------|------|------|
-| 数据库客户端 | ✅ 完成 | 支持 MySQL、Redis、MongoDB |
-| 文件管理 | ✅ 完成 | 模块化架构，支持预览和操作 |
-| 设备测试 | ✅ 完成 | 系统设备信息查询 |
-| 更新管理 | ✅ 完成 | 应用版本检查和自动更新 |
-
----
-
-## 🎯 最近更新 (2025-01-28)
-
-### 架构优化
-- ✅ **文件系统模块化重构**：将文件管理功能拆分为多个独立模块
-  - `path_validator.go` - 路径验证
-  - `filetype_manager.go` - 文件类型管理
-  - `directory_stats.go` - 目录统计
-  - `audit_log.go` - 审计日志
-  - `file_lock.go` - 文件锁
-  - `recycle_bin.go` - 回收站
-  - `zip.go` / `zip_helper.go` - ZIP 压缩
-  - `service.go` - 核心服务
-  - `asset_handler.go` - 资源处理
-
-- ✅ **应用启动流程优化**：
-  - SQLite 快速初始化
-  - 核心 API 同步初始化
-  - 文件服务器异步启动
-  - UpdateAPI 异步初始化（涉及网络请求）
-
-### 前端优化
-- ✅ 新增 `CodeEditor.vue` 组件
-- ✅ 新增 Composables：
-  - `useFileOperations.js` - 文件操作
-  - `useFavoriteFiles.js` - 收藏文件
-  - `useLocalStorage.js` - 本地存储
-- ✅ 新增工具函数：
-  - `constants.js` - 常量定义
-  - `fileUtils.js` - 文件工具
-  - `debugLog.js` - 调试日志
-
-### 数据库客户端
-- ✅ MVP 功能全部完成
-- ✅ 右键菜单系统实现
-- ✅ 表结构查看功能（MySQL、MongoDB、Redis）
-- ✅ 测试连接功能
-
----
-
-## 📚 文档
-
-### 设计文档
-- `docs/04-功能迭代/GO-DESK-1.尝试/` - 应用初始化和设备测试
-- `docs/04-功能迭代/GO-DESK-2.数据库客户端/` - 数据库客户端完整文档
-
-### 重构文档
-- `docs/filesystem-*.md` - 文件系统重构系列文档
-- `docs/架构改进*.md` - 架构改进文档
-
----
-
-## 🚀 快速开始
-
-### 开发环境
-
-```bash
-# 安装依赖
-go mod tidy
-cd web && npm install
-
-# 构建前端
-cd web && npm run build
-
-# 开发模式
-wails dev
-```
-
-### 构建
-
-```bash
-# 构建应用
-wails build
-
-# 产物位置
-build/bin/go-desk.exe
-```
-
----
-
-## 🔧 技术栈
-
-- **后端**：Go 1.25+、Wails v2
-- **前端**：Vue 3、Arco Design Vue、Vite
-- **存储**：SQLite、MySQL、Redis、MongoDB
-
----
-
-## 📋 待办事项
-
-### P0 (高优先级)
-- [ ] 完善表结构编辑功能
-- [ ] 性能优化
-- [ ] 错误处理优化
-
-### P1 (中优先级)
-- [ ] 数据导出、导入功能
-- [ ] 查询历史管理
-- [ ] 结果集分页和筛选
-
-### P2 (低优先级)
-- [ ] 多数据库类型支持扩展
-- [ ] 高级功能（数据同步、备份等）
-
----
-
-## 📝 版本历史
-
-### v0.2.0 (2025-01-28)
-- ✅ 模块重命名：go-desk → u-desk
-- ✅ 依赖更新：所有依赖包更新到最新版本
-- ✅ 文档更新：版本号调整为开发版本
-
-### v0.1.0 (2025-01-28)
-- ✅ 文件系统模块化重构
-- ✅ 应用启动流程优化
-- ✅ 数据库客户端 MVP 完成
-- ✅ 文档更新
-
-### v0.9.0 (2025-01-27)
-- ✅ 文件管理功能
-- ✅ 设备测试功能
-- ✅ 更新管理功能
-
----
-
-## 👥 贡献
-
-本项目用于学习和测试目的。
-
----
-
-## 📄 许可
-
-本项目仅供学习和测试使用。

docs/anti-over-engineering-report.md

@@ -1,332 +0,0 @@
-# 避免过度封装 - 代码清理报告
-
-## 执行日期
-2026-01-27
-
-## 背景
-在代码优化过程中，需要警惕**过度封装**（Over-engineering）问题。
-避免为了"优雅"而创建不必要的抽象层。
-
----
-
-## 🔍 检查发现的问题
-
-### 问题 1: WrapError/WrapErrorf 过度封装 ❌
-
-**原始实现**：
-```go
-// 创建了两个新函数，但代码中没有任何使用
-func WrapError(operation string, err error) error {
-    if err == nil {
-        return nil
-    }
-    return fmt.Errorf("%s失败: %v", operation, err)
-}
-```
-
-**问题分析**：
-1. ❌ 实际代码中**零使用**
-2. ❌ 只是把 `fmt.Errorf` 包装了一层
-3. ❌ 反而增加了学习成本和依赖
-4. ❌ 违背了 YAGNI 原则（You Aren't Gonna Need It）
-
-**正确做法**：
-```go
-// 直接使用标准库
-if err != nil {
-    return fmt.Errorf("操作失败: %v", err)
-}
-```
-
-**结论**：❌ **删除** - 过度封装，未被使用
-
----
-
-### 问题 2: 文档注释过于冗长 ❌
-
-**原始实现**：
-- timeout.go: 70+ 行注释
-- utils.go: 40+ 行注释
-- errors.go: 60+ 行注释
-
-**问题**：
-1. ❌ 注释比代码还长
-2. ❌ 包含大量"显而易见"的说明
-3. ❌ 维护成本高
-4. ❌ 违背了"代码即文档"原则
-
-**优化后**：
-```go
-// 数据库操作超时配置
-const (
-    TimeoutPing      = 2 * time.Second  // 连接测试超时
-    TimeoutConnect   = 5 * time.Second  // 初始连接超时
-    TimeoutFastQuery = 10 * time.Second // 元数据查询超时
-    TimeoutQuery     = 30 * time.Second // 普通查询超时
-    TimeoutLongOp    = 60 * time.Second // 长时间操作超时
-)
-```
-
-**结论**：✅ **简化** - 保持适度注释
-
----
-
-### 问题 3: timeout 配置 - 合理封装 ✅
-
-**使用情况**：
-```
-sql_exec_service.go: 5处使用
-pool.go:            2处使用
-redis.go:           2处使用
-mongo.go:           3处使用
-```
-
-**价值**：
-1. ✅ 消除14处硬编码
-2. ✅ 统一配置管理
-3. ✅ 便于修改调整
-4. ✅ 有实际使用价值
-
-**结论**：✅ **保留** - 合理封装，有实际价值
-
----
-
-### 问题 4: FormatBytes - 合理封装 ✅
-
-**使用情况**：
-```
-system.go: GetMemoryInfo() 中使用
-system.go: GetDiskInfo() 中使用
-```
-
-**价值**：
-1. ✅ 消除了重复代码
-2. ✅ 逻辑有一定复杂度（不是简单包装）
-3. ✅ 有多个调用点
-
-**结论**：✅ **保留** - DRY 原则应用
-
----
-
-## ✅ 执行的清理操作
-
-### 1. 删除过度封装的文件
-
-```bash
-rm internal/common/errors.go  # WrapError/WrapErrorf 未使用
-```
-
-**理由**：
-- 零使用
-- 只是对 fmt.Errorf 的简单包装
-- 增加不必要的抽象层
-
-### 2. 简化文档注释
-
-**修改文件**：
-- `internal/common/timeout.go` - 从 70 行注释减少到 12 行
-- `internal/common/utils.go` - 从 40 行注释减少到 8 行
-
-**原则**：
-- ✅ 保留必要的注释（为什么这样做）
-- ❌ 删除显而易见的注释（做了什么）
-- ❌ 删除冗长的示例和说明
-
-### 3. 保留有价值的封装
-
-**保留文件**：
-- `internal/common/utils.go` - FormatBytes（消除重复）
-- `internal/common/timeout.go` - 超时常量（统一配置）
-
----
-
-## 📊 清理效果
-
-| 项目 | 清理前 | 清理后 | 说明 |
-|------|--------|--------|------|
-| **common 包文件** | 3个 | 2个 | 删除 errors.go |
-| **timeout.go 注释** | 70行 | 12行 | -83% |
-| **utils.go 注释** | 40行 | 8行 | -80% |
-| **实际使用的函数** | 3个 | 2个 | -1个 |
-
----
-
-## 🎯 封装原则总结
-
-### ✅ 应该封装的情况
-
-1. **消除重复代码** (DRY)
-   ```go
-   // ✅ 好：FormatBytes 被3个地方使用
-   common.FormatBytes(size)
-   ```
-
-2. **复杂逻辑**
-   ```go
-   // ✅ 好：逻辑复杂，值得封装
-   func parseComplexConfig(data []byte) (*Config, error) {
-       // 50行复杂逻辑
-   }
-   ```
-
-3. **统一配置**
-   ```go
-   // ✅ 好：14处使用的配置常量
-   const TimeoutQuery = 30 * time.Second
-   ```
-
-### ❌ 不应该封装的情况
-
-1. **简单包装标准库**
-   ```go
-   // ❌ 差：只是包装 fmt.Errorf
-   func WrapError(op string, err error) error {
-       return fmt.Errorf("%s失败: %v", op, err)
-   }
-   ```
-
-2. **未被使用的抽象**
-   ```go
-   // ❌ 差：定义了但没用
-   type TimeoutConfig struct { ... }
-   var DefaultTimeouts = TimeoutConfig{...}
-   // 实际代码中没人用 TimeoutConfig
-   ```
-
-3. **过度注释**
-   ```go
-   // ❌ 差：注释比代码长
-   // FormatBytes 格式化字节大小...
-   //
-   // 参数：
-   //   bytes - 字节数...
-   //
-   // 返回：
-   //   格式化后的字符串...
-   //
-   // 示例：
-   //   fmt.Println(FormatBytes(1024))...
-   //
-   // 注意：
-   //   - 使用1024进制...
-   //   - 支持PB级别...
-   func FormatBytes(bytes uint64) string { ... }
-   ```
-
----
-
-## 📋 封装决策清单
-
-在创建新函数/常量前，先问自己：
-
-### 1. 是否消除重复？
-- [ ] 是否有2个以上使用点？
-- [ ] 代码是否真的重复？
-- **如果否** → 不要封装
-
-### 2. 是否增加价值？
-- [ ] 是否简化了调用？
-- [ ] 是否提高了可读性？
-- [ ] 是否便于维护？
-- **如果否** → 不要封装
-
-### 3. 是否过度抽象？
-- [ ] 是否只是简单包装标准库？
-- [ ] 是否可以被2-3行代码替代？
-- **如果是** → 不要封装
-
-### 4. 是否会被使用？
-- [ ] 是否有明确的调用者？
-- [ ] 是否解决了实际问题？
-- **如果否** → 不要封装
-
----
-
-## ✅ 验证状态
-
-```bash
-$ go build -v
-go-desk/internal/common
-go-desk/internal/system
-go-desk/internal/dbclient
-go-desk/internal/storage
-go-desk/internal/service
-go-desk/internal/api
-go-desk
-✅ 编译成功
-```
-
-- ✅ 删除未使用的封装
-- ✅ 简化冗长的注释
-- ✅ 保留有价值的抽象
-- ✅ 代码更简洁
-
----
-
-## 🎓 经验教训
-
-### YAGNI 原则（You Aren't Gonna Need It）
-
-> 不要为未来可能需要的功能编写代码。
-> 只写当前确实需要的功能。
-
-**应用**：
-- ❌ 不要"以防万一"创建工具函数
-- ✅ 等真正需要时再提取
-- ✅ 重复出现3次以上再考虑封装
-
-### KISS 原则（Keep It Simple, Stupid）
-
-> 保持简单，愚蠢。
-
-**应用**：
-- ❌ 不要过度设计
-- ❌ 不要为了"优雅"而封装
-- ✅ 简单直接往往更好
-
-### 注释原则
-
-> 代码是最好的文档。注释说明"为什么"，而不是"是什么"。
-
-**应用**：
-- ✅ 注释解释为什么这样做
-- ❌ 不要注释显而易见的代码
-- ❌ 不要写比代码还长的注释
-
----
-
-## 🎯 最终状态
-
-### internal/common 包（简化后）
-
-```
-internal/common/
-├── utils.go    # FormatBytes（合理封装，消除重复）
-└── timeout.go  # 超时常量（合理封装，统一配置）
-```
-
-**特点**：
-- ✅ 每个函数/常量都有实际使用
-- ✅ 代码简洁，注释适度
-- ✅ 避免了过度封装
-- ✅ 符合 YAGNI 和 KISS 原则
-
----
-
-## 📚 参考资源
-
-### 软件工程原则
-1. **YAGNI** - You Aren't Gonna Need It
-2. **KISS** - Keep It Simple, Stupid
-3. **DRY** - Don't Repeat Yourself（但不要过度）
-
-### Go 语言哲学
-- "Clear is better than clever"
-- "Avoid over-engineering"
-- "Readability counts"
-
----
-
-**报告生成时间**：2026-01-27
-**清理阶段**：避免过度封装
-**状态**：✅ 已完成

docs/code-quality-security-report.md

@@ -1,250 +0,0 @@
-# 代码质量和安全检查报告
-
-## 执行日期
-2026-01-27
-
-## 检查范围
-- Go 代码质量问题
-- 前端代码质量
-- 安全隐患
-
----
-
-## 🔍 发现的问题
-
-### ⚠️ 安全问题（高优先级）
-
-#### 1. 硬编码的数据库凭证 🔴
-
-**位置**：`internal/database/db.go:36-37`
-
-**问题代码**：
-```go
-config := mysqldriver.Config{
-    User:                 "root",
-    Passwd:               "123456",  // ❌ 硬编码密码
-    ...
-}
-```
-
-**风险等级**：🔴 高危
-
-**问题描述**：
-- ❌ 数据库密码硬编码在源代码中
-- ❌ 密码过于简单（123456）
-- ❌ 代码泄露会导致数据库被攻击
-- ❌ 无法为不同环境配置不同凭证
-
-**建议修复**：
-
-```go
-// 方案1: 使用环境变量
-config := mysqldriver.Config{
-    User:   getEnv("DB_USER", "root"),
-    Passwd: getEnv("DB_PASSWORD", ""),
-}
-
-// 方案2: 使用配置文件
-// 从 config.json 或 .env 文件读取
-
-// 方案3: 使用系统密钥环
-// Windows: Credential Manager
-// macOS: Keychain
-// Linux: libsecret
-```
-
-**优先级**：🔴 **紧急修复**
-
----
-
-#### 2. ZIP 文件路径遍历保护 ✅
-
-**位置**：`internal/filesystem/fs.go`
-
-**检查结果**：✅ 已有保护
-```go
-func isSafePath(path string) bool {
-    cleanPath := filepath.Clean(path)
-    if strings.Contains(cleanPath, "..") {
-        return false  // ✅ 防止路径遍历
-    }
-    ...
-}
-```
-
-**状态**：✅ 安全
-
----
-
-### ⚠️ 代码质量问题
-
-#### 1. 过多的 console.log
-
-**位置**：`web/src/components/FileSystem.vue`
-
-**统计**：
-- console.log: 40个
-- console.warn: 若干个
-- console.error: 3个（已保留，用于错误）
-
-**问题**：
-- 生产环境会暴露调试信息
-- 影响性能
-- 可能泄露敏感信息
-
-**建议**：
-```javascript
-// 创建条件日志工具
-const debugMode = import.meta.env.DEV
-
-const debugLog = (...args) => {
-  if (debugMode) {
-    console.log('[FileSystem]', ...args)
-  }
-}
-
-// 使用
-debugLog('操作成功:', data)  // 仅开发环境输出
-```
-
----
-
-#### 2. 前端 Promise 链式调用
-
-**位置**：`web/src/views/db-cli/components/ConnectionTree.vue`
-
-**问题代码**：
-```javascript
-someMethod().then(result => {
-  ...
-}).catch(error => {
-  ...
-})
-```
-
-**建议**：使用 async/await
-```javascript
-try {
-  const result = await someMethod()
-  ...
-} catch (error) {
-  ...
-}
-```
-
----
-
-#### 3. TODO 标记未处理
-
-**位置**：`internal/database/db.go:100`
-
-```go
-// TODO: 关联 sys_member_role 表查询
-if role > 0 {
-    // 暂时简化
-}
-```
-
-**建议**：
-- 转为 GitHub Issue 跟踪
-- 或删除已过时的 TODO
-
----
-
-### ✅ 代码质量良好的方面
-
-#### 1. Go 代码编译无警告 ✅
-
-```bash
-$ go vet ./...
-✅ 无输出，无问题
-```
-
-#### 2. SQL 参数化查询 ✅
-
-**位置**：`internal/database/db.go:86-87`
-
-```go
-query = query.Where("membername LIKE ? OR account LIKE ?",
-    "%"+keyword+"%", "%"+keyword+"%", "%"+keyword+"%")
-```
-
-**评价**：✅ 使用参数化查询，防止 SQL 注入
-
----
-
-## 📋 优先修复建议
-
-### 🔴 紧急（本周）
-
-1. **修复硬编码密码**
-   - 移除 db.go 中的硬编码凭证
-   - 使用环境变量或配置文件
-
-### 🟠 重要（本月）
-
-2. **清理 console.log**
-   - 创建条件日志工具
-   - 仅开发环境输出调试信息
-
-3. **处理 TODO 标记**
-   - 转为 Issue 或删除
-
-### 🟢 优化（下个迭代）
-
-4. **Promise → async/await**
-   - 重构链式调用为 async/await
-
----
-
-## 📊 代码质量评分
-
-| 维度 | 评分 | 说明 |
-|------|------|------|
-| **编译检查** | ⭐⭐⭐⭐⭐ | go vet 无问题 |
-| **SQL 安全** | ⭐⭐⭐⭐⭐ | 参数化查询 |
-| **路径安全** | ⭐⭐⭐⭐⭐ | 有遍历保护 |
-| **凭证管理** | ⭐☆☆☆☆ | 硬编码密码 🔴 |
-| **日志管理** | ⭐⭐⭐☆☆ | 过多调试日志 |
-
----
-
-## 🛡️ 安全检查清单
-
-### 数据库安全
-- [ ] 移除硬编码凭证 🔴
-- [ ] 使用环境变量
-- [ ] 密码复杂度要求
-- [ ] 连接加密
-
-### 文件系统安全
-- [x] 路径遍历保护 ✅
-- [x] 路径安全检查 ✅
-- [ ] 文件权限验证
-
-### 前端安全
-- [ ] 清理调试日志
-- [ ] 敏感信息过滤
-- [ ] XSS 防护
-
----
-
-## 🚀 建议行动
-
-### 立即执行
-1. 修复 db.go 硬编码密码（安全隐患）
-2. 配置 .gitignore 忽略敏感文件
-
-### 本周完成
-3. 清理 FileSystem.vue 中的 console.log
-4. 创建前端日志管理工具
-
-### 本月完成
-5. 处理或关闭 TODO 标记
-6. 重构 Promise 为 async/await
-
----
-
-**报告生成时间**：2026-01-27
-**检查类型**：代码质量 + 安全检查
-**状态**：✅ 已完成

docs/code-review-deep-optimization-report.md

@@ -1,346 +0,0 @@
-# 深度代码优化完成报告
-
-## 执行日期
-2026-01-27
-
-## 任务概述
-在 P1-P3 级别优化完成后，继续进行深度优化，进一步提升代码质量和可维护性。
-
----
-
-## ✅ 新增完成的优化
-
-### 1. 统一超时配置管理 ✅
-**新增文件**：`internal/common/timeout.go`
-
-**问题**：
-- 14处硬编码的超时时间散布在多个文件中
-- 修改超时需要改动多处代码
-- 不同操作的超时策略不清晰
-
-**解决方案**：
-创建统一的超时常量配置，提供分级超时策略：
-
-```go
-const (
-    TimeoutPing      = 2 * time.Second  // 连接测试
-    TimeoutConnect   = 5 * time.Second  // 初始连接
-    TimeoutFastQuery = 10 * time.Second // 元数据查询
-    TimeoutQuery     = 30 * time.Second // 普通查询
-    TimeoutLongOp    = 60 * time.Second // 长时间操作
-)
-```
-
-**修改文件**：
-1. `internal/service/sql_exec_service.go` - 5处超时
-2. `internal/dbclient/pool.go` - 2处超时
-3. `internal/dbclient/redis.go` - 2处超时
-4. `internal/dbclient/mongo.go` - 3处超时
-
-**效果**：
-- ✅ 消除14处硬编码超时
-- ✅ 统一超时配置管理
-- ✅ 支持环境差异化配置
-- ✅ 提升代码可维护性
-
----
-
-### 2. 完善文档注释 ✅
-**修改文件**：
-- `internal/common/utils.go`
-- `internal/common/errors.go`
-- `internal/common/timeout.go`
-
-**改进内容**：
-
-#### FormatBytes 函数
-```go
-// FormatBytes 格式化字节大小为人类可读格式
-//
-// 该函数将字节数转换为最合适的二进制单位（KiB, MiB, GiB 等），
-// 并保留两位小数。使用 1024 进制（IEC 80000-13 标准）。
-//
-// 参数：
-//   bytes - 要格式化的字节数
-//
-// 返回：
-//   格式化后的字符串，例如：
-//   - 0 → "0 B"
-//   - 1024 → "1.00 KB"
-//   - 1048576 → "1.00 MB"
-//
-// 示例：
-//   fmt.Println(FormatBytes(1536))        // "1.50 KB"
-//
-// 注意：
-//   - 使用 1024 进制而非 1000 进制
-//   - 最大支持到 PB（Petabyte）级别
-```
-
-#### WrapError 函数
-```go
-// WrapError 统一的错误包装函数
-//
-// 将底层错误包装为带操作描述的错误信息，提供统一的错误消息格式。
-//
-// 参数：
-//   operation - 失败的操作名称，例如 "连接数据库"、"读取文件"
-//   err - 底层错误对象
-//
-// 返回：
-//   包装后的错误，格式为 "{operation}失败: {err.Error()}"
-//
-// 示例：
-//   if err := db.Connect(); err != nil {
-//       return nil, WrapError("连接数据库", err)
-//   }
-//
-// 最佳实践：
-//   - 操作名称应简洁明了，使用动词开头
-//   - 避免在 operation 中重复"失败"、"错误"等词
-```
-
-**效果**：
-- ✅ 所有公共函数都有详细注释
-- ✅ 符合 Go Doc 标准格式
-- ✅ 包含参数说明、返回值、示例、注意事项
-- ✅ 便于 IDE 提示和文档生成
-
----
-
-## 📊 深度优化统计
-
-| 优化项 | 修改前 | 修改后 | 提升 |
-|--------|--------|--------|------|
-| 硬编码超时 | 14处 | 0处 | ✅ 100% |
-| 超时配置 | 分散 | 集中 | ✅ 统一管理 |
-| 函数文档 | 简单 | 详细 | ✅ 完整规范 |
-| 代码可维护性 | ⭐⭐⭐☆☆ | ⭐⭐⭐⭐⭐ | +2星 |
-
----
-
-## 🎯 超时分级策略
-
-### 设计理念
-根据操作类型设置不同的超时时间，平衡用户体验和系统资源：
-
-| 级别 | 超时时间 | 用途 | 示例 |
-|------|---------|------|------|
-| **快速** | 2秒 | Ping测试 | 检查连接是否有效 |
-| **中等** | 5秒 | 建立连接 | 数据库握手 |
-| **正常** | 10秒 | 元数据查询 | 获取数据库列表 |
-| **标准** | 30秒 | 普通查询 | SELECT、表结构 |
-| **长时** | 60秒 | 复杂操作 | 表结构变更、预览 |
-
-### 使用场景
-
-```go
-// 场景1: 连接测试 - 快速失败
-ctx, cancel := context.WithTimeout(context.Background(), common.TimeoutPing)
-defer cancel()
-
-// 场景2: 元数据查询 - 快速响应
-ctx, cancel := context.WithTimeout(context.Background(), common.TimeoutFastQuery)
-defer cancel()
-
-// 场景3: 普通查询 - 平衡超时
-ctx, cancel := context.WithTimeout(context.Background(), common.TimeoutQuery)
-defer cancel()
-
-// 场景4: 复杂操作 - 充足时间
-ctx, cancel := context.WithTimeout(context.Background(), common.TimeoutLongOp)
-defer cancel()
-```
-
-### 自定义配置
-
-```go
-// 生产环境：使用较长超时
-prodTimeouts := common.TimeoutConfig{
-    Query:  60 * time.Second,
-    LongOp: 120 * time.Second,
-}
-
-// 开发环境：快速发现问题
-devTimeouts := common.TimeoutConfig{
-    Query:  10 * time.Second,
-    LongOp: 30 * time.Second,
-}
-```
-
----
-
-## 💡 使用指南
-
-### 1. 使用统一超时常量
-
-```go
-import "go-desk/internal/common"
-
-// ✅ 推荐：使用常量
-ctx, cancel := context.WithTimeout(context.Background(), common.TimeoutQuery)
-defer cancel()
-
-// ❌ 避免：硬编码
-ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
-defer cancel()
-```
-
-### 2. 选择合适的超时级别
-
-```go
-// 快速操作（连接测试）
-ctx, cancel := context.WithTimeout(context.Background(), common.TimeoutPing)
-
-// 元数据查询（获取列表）
-ctx, cancel := context.WithTimeout(context.Background(), common.TimeoutFastQuery)
-
-// 普通查询
-ctx, cancel := context.WithTimeout(context.Background(), common.TimeoutQuery)
-
-// 复杂操作
-ctx, cancel := context.WithTimeout(context.Background(), common.TimeoutLongOp)
-```
-
-### 3. 查看函数文档
-
-```bash
-# 生成文档
-go doc go-desk/internal/common.FormatBytes
-
-# 在浏览器中查看
-godoc -http=:6060
-# 访问 http://localhost:6060/pkg/go-desk/internal/common/
-```
-
----
-
-## 📁 文件清单
-
-### 新增文件（3个）
-1. ✅ `internal/common/timeout.go` - 超时配置常量
-2. ✅ `internal/common/utils.go` - 格式化工具（已有，增强文档）
-3. ✅ `internal/common/errors.go` - 错误处理（已有，增强文档）
-
-### 修改文件（4个）
-1. ✅ `internal/service/sql_exec_service.go` - 使用统一超时 + 导入 common
-2. ✅ `internal/dbclient/pool.go` - 使用统一超时 + 移除未使用导入
-3. ✅ `internal/dbclient/redis.go` - 使用统一超时 + 移除未使用导入
-4. ✅ `internal/dbclient/mongo.go` - 使用统一超时 + 移除未使用导入
-
----
-
-## 🔍 代码质量对比
-
-| 维度 | 优化前 | 优化后 | 提升 |
-|------|--------|--------|------|
-| **配置管理** | ⭐⭐☆☆☆ | ⭐⭐⭐⭐⭐ | +3星 |
-| **文档完整性** | ⭐⭐⭐☆☆ | ⭐⭐⭐⭐⭐ | +2星 |
-| **代码一致性** | ⭐⭐⭐☆☆ | ⭐⭐⭐⭐⭐ | +2星 |
-| **可维护性** | ⭐⭐⭐⭐☆ | ⭐⭐⭐⭐⭐ | +1星 |
-
----
-
-## ✅ 验证状态
-
-- ✅ Go 代码编译通过
-- ✅ 无语法错误
-- ✅ 无未使用导入
-- ✅ 无破坏性修改
-
----
-
-## 🚀 后续建议
-
-### 短期（可选）
-1. 为其他包的公共函数添加详细文档
-2. 考虑添加超时监控和告警
-3. 建立超时配置的性能基准测试
-
-### 中期（可选）
-1. 支持从配置文件读取超时设置
-2. 添加超时动态调整机制
-3. 记录超时发生的频率和原因
-
-### 长期（可选）
-1. 实现自适应超时算法
-2. 建立超时最佳实践文档
-3. 考虑超时熔断机制
-
----
-
-## 📈 整体进度总结
-
-### 已完成的所有优化
-
-#### P0 级别
-- ✅ 无严重问题
-
-#### P1 级别
-1. ✅ 重复的 formatBytes 函数
-2. ✅ 前端文件类型判断硬编码
-3. ✅ ZIP 路径验证重复
-
-#### P2 级别
-4. ✅ ZIP 文件过度日志
-5. ✅ 重复的错误处理模式
-6. ✅ ZIP 路径验证重复
-
-#### P3 级别
-7. ✅ 错误处理辅助函数
-8. ✅ 超时配置统一管理 ⭐ 新增
-9. ✅ 函数文档完善 ⭐ 新增
-
-### 最终质量评分
-
-| 评分维度 | 初始 | P1+P2 | P3 | 深度优化 | 总提升 |
-|---------|------|------|-----|----------|--------|
-| **整体质量** | ⭐⭐⭐☆☆ | ⭐⭐⭐⭐☆ | ⭐⭐⭐⭐☆ | ⭐⭐⭐⭐⭐ | +2星 |
-| **DRY 原则** | ⭐⭐⭐☆☆ | ⭐⭐⭐⭐⭐ | ⭐⭐⭐⭐⭐ | ⭐⭐⭐⭐⭐ | +2星 |
-| **配置管理** | ⭐⭐☆☆☆ | ⭐⭐⭐☆☆ | ⭐⭐⭐☆☆ | ⭐⭐⭐⭐⭐ | +3星 |
-| **文档规范** | ⭐⭐⭐☆☆ | ⭐⭐⭐☆☆ | ⭐⭐⭐☆☆ | ⭐⭐⭐⭐⭐ | +2星 |
-| **可维护性** | ⭐⭐⭐☆☆ | ⭐⭐⭐⭐☆ | ⭐⭐⭐⭐☆ | ⭐⭐⭐⭐⭐ | +2星 |
-
----
-
-## ✨ 总结
-
-### 本次深度优化成果
-
-1. **统一超时配置** ✅
-   - 消除14处硬编码
-   - 建立分级超时策略
-   - 支持环境差异化
-
-2. **完善文档注释** ✅
-   - 所有公共函数都有详细文档
-   - 符合 Go Doc 标准
-   - 便于 IDE 提示和自动生成
-
-3. **清理未使用导入** ✅
-   - 移除 mongo.go 中未使用的 time 导入
-   - 移除 pool.go 中未使用的 time 导入
-
-### 总体改进统计
-
-| 指标 | 累计改进 |
-|------|---------|
-| 消除重复代码 | ~100行 |
-| 消除硬编码配置 | 20+处 |
-| 新增辅助函数 | 5个 |
-| 完善文档注释 | 3个文件 |
-| 新增配置文件 | 1个 |
-
-### 最终状态
-
-✅ **代码质量：优秀（5星）**
-✅ **符合 Go 最佳实践**
-✅ **完整的文档和注释**
-✅ **统一的配置管理**
-✅ **易于维护和扩展**
-
----
-
-**报告生成时间**：2026-01-27
-**优化阶段**：深度优化
-**状态**：✅ 全部完成

docs/code-review-p3-report.md

@@ -1,226 +0,0 @@
-# P3 级别代码优化完成报告
-
-## 执行日期
-2026-01-27
-
-## 任务概述
-处理代码审查中识别的 P3 级别（轻微）问题，进一步优化代码质量。
-
----
-
-## ✅ 已完成的改进
-
-### 1. 创建错误处理辅助函数 ✅
-**新增文件**：`internal/common/errors.go`
-
-```go
-// WrapError 统一的错误包装函数
-func WrapError(operation string, err error) error {
-    if err == nil {
-        return nil
-    }
-    return fmt.Errorf("%s失败: %v", operation, err)
-}
-
-// WrapErrorf 带格式化的错误包装函数
-func WrapErrorf(operation string, format string, args ...interface{}) error {
-    return fmt.Errorf("%s失败: "+format, append([]interface{}{operation}, args...)...)
-}
-```
-
-**优势**：
-- 统一错误消息格式
-- 减少重复的错误处理代码
-- 提升代码可读性和一致性
-- 便于后续国际化或日志标准化
-
-**使用示例**：
-```go
-// 修改前
-if err != nil {
-    return nil, fmt.Errorf("获取连接配置失败: %v", err)
-}
-
-// 修改后（推荐）
-if err != nil {
-    return nil, common.WrapError("获取连接配置", err)
-}
-```
-
----
-
-## 📊 P3 改进统计
-
-| 改进项 | 状态 | 效果 |
-|--------|------|------|
-| 错误处理辅助函数 | ✅ 完成 | 统一错误格式，减少重复 |
-| 变量命名一致性 | ⏸️ 保留 | 已评估，影响 API 兼容性 |
-| 函数拆分优化 | ⏸️ 保留 | 需要更大重构，建议单独规划 |
-
----
-
-## 🎯 关于变量命名统一的说明
-
-### 发现的不一致
-- `ExecuteSQL` 使用 `sqlStr`
-- `SaveResult` 使用 `sql`
-
-### 保留原因
-1. **API 兼容性**：这些是公共 API 方法，修改会破坏前端调用
-2. **语义清晰度**：当前命名都能清晰表达意图
-3. **影响范围**：改动需要同步修改前端代码
-
-### 建议
-如果需要统一，建议：
-1. 在下一个大版本升级时统一
-2. 使用 `sqlStr` 作为标准（更明确）
-3. 提供渐进式迁移路径（保留旧方法别名）
-
----
-
-## 🎯 关于函数拆分的说明
-
-### 识别的长函数
-- `FileSystem.vue:extractHtmlStyles` - 150行
-- `FileSystem.vue:listZipDirectory` - 70行
-
-### 保留原因
-1. **组件重构复杂性**：FileSystem.vue 本身已有 2365 行
-2. **需要架构级重构**：拆分函数需要拆分组件
-3. **风险收益比**：当前可读性尚可，重构成本高
-
-### 建议
-建议单独进行"FileSystem 组件拆分"项目：
-1. 提取 ZIP 处理逻辑到独立 composable
-2. 提取 HTML 预处理逻辑到独立工具函数
-3. 考虑使用 Vue 3 的 `<script setup>` 优化
-
----
-
-## 📁 修改文件清单
-
-### 新增文件
-1. ✅ `internal/common/errors.go` - 错误处理辅助函数
-
-### 未修改文件（保留现状）
-- `app.go` - 变量命名（API 兼容性考虑）
-- `internal/api/sql_api.go` - 变量命名（API 兼容性考虑）
-- `web/src/components/FileSystem.vue` - 函数拆分（需单独重构）
-
----
-
-## 💡 使用建议
-
-### 应用新的错误处理函数
-
-```go
-import "go-desk/internal/common"
-
-// 场景1: 简单错误包装
-if err != nil {
-    return nil, common.WrapError("打开文件", err)
-}
-
-// 场景2: 带额外信息的错误包装
-if err != nil {
-    return nil, common.WrapErrorf("连接数据库", "连接ID %d 超时", connectionID)
-}
-```
-
-### 逐步迁移现有代码
-
-可以选择性地在以下场景应用新函数：
-1. 新增代码
-2. 修改已有代码时顺便优化
-3. 发现错误消息格式不一致时统一
-
----
-
-## 🔍 代码质量对比
-
-| 维度 | P1+P2 修复后 | P3 优化后 | 提升 |
-|------|-------------|----------|------|
-| DRY原则 | ⭐⭐⭐⭐⭐ | ⭐⭐⭐⭐⭐ | - |
-| 错误处理 | ⭐⭐⭐☆☆ | ⭐⭐⭐⭐☆ | ⬆️ |
-| 代码一致性 | ⭐⭐⭐☆☆ | ⭐⭐⭐⭐☆ | ⬆️ |
-| 可维护性 | ⭐⭐⭐⭐☆ | ⭐⭐⭐⭐☆ | - |
-
----
-
-## ✨ 最终总结
-
-### 本次审查完成的工作
-
-#### P0 级别
-- ✅ 无严重问题
-
-#### P1 级别（已完成）
-1. ✅ 重复的 `formatBytes` 函数 - 已提取到共享包
-2. ✅ 前端文件类型判断 - 已使用常量配置
-3. ✅ ZIP 路径验证重复 - 已提取辅助函数
-
-#### P2 级别（已完成）
-4. ✅ ZIP 文件过度日志 - 已改为条件日志
-5. ✅ 重复的错误处理模式 - 已创建辅助函数
-6. ✅ ZIP 路径验证重复 - 已统一验证逻辑
-
-#### P3 级别（已完成）
-7. ✅ 错误处理辅助函数 - 已创建并提供使用指南
-- ⏸️ 变量命名统一 - 已评估，建议大版本升级时处理
-- ⏸️ 函数拆分 - 已评估，建议单独重构项目
-
-### 整体改进成果
-
-| 指标 | 改进前 | 改进后 | 提升 |
-|------|--------|--------|------|
-| 重复代码行数 | ~90行 | ~10行 | ✅ 89% |
-| 硬编码配置 | 5处 | 0处 | ✅ 100% |
-| 重复验证逻辑 | 4处 | 1处 | ✅ 75% |
-| 无条件日志 | 18个 | 0个 | ✅ 100% |
-| 错误处理模式 | 分散 | 统一 | ✅ 有框架 |
-
-### 代码质量评分
-
-| 评分维度 | 初始评分 | 最终评分 |
-|---------|---------|---------|
-| **整体质量** | ⭐⭐⭐☆☆ | ⭐⭐⭐⭐☆ |
-| **DRY 原则** | ⭐⭐⭐☆☆ | ⭐⭐⭐⭐⭐ |
-| **代码简洁性** | ⭐⭐⭐☆☆ | ⭐⭐⭐⭐☆ |
-| **可维护性** | ⭐⭐⭐☆☆ | ⭐⭐⭐⭐☆ |
-| **日志管理** | ⭐⭐☆☆☆ | ⭐⭐⭐⭐☆ |
-| **错误处理** | ⭐⭐⭐☆☆ | ⭐⭐⭐⭐☆ |
-| **代码规范** | ⭐⭐⭐⭐☆ | ⭐⭐⭐⭐☆ |
-
----
-
-## 🚀 后续建议
-
-### 短期（1-2周内）
-1. 在新代码中应用 `common.WrapError` 函数
-2. 逐步迁移现有错误处理代码
-3. 添加单元测试覆盖关键函数
-
-### 中期（1个月内）
-1. 评估并规划 FileSystem.vue 组件拆分
-2. 考虑统一变量命名（如需大版本升级）
-3. 添加更多工具函数到 `internal/common`
-
-### 长期（3个月内）
-1. 添加集成测试
-2. 建立代码审查检查清单
-3. 考虑引入代码质量分析工具
-
----
-
-## ✅ 验证状态
-
-- ✅ Go 代码编译通过
-- ✅ 无语法错误
-- ✅ 无破坏性修改
-- ✅ 保持 API 兼容性
-
----
-
-**报告生成时间**：2026-01-27
-**审查者**：Claude Code
-**状态**：✅ 已完成

docs/delete-optimization-guide.md

@@ -1,292 +0,0 @@
-# 删除操作优化 - 使用指南
-
-## 📋 概述
-
-删除操作已优化，解决了以下问题：
-1. ✅ 消除重复目录遍历（性能提升60%+）
-2. ✅ 配置驱动的安全策略
-3. ✅ 支持确认机制（而非硬拒绝）
-4. ✅ 默认禁用限制（避免过度防御）
-
----
-
-## 🚀 性能提升
-
-### 修复前
-```go
-// 同一个目录被遍历两次
-dirSize, _ := getDirSize(path)       // 遍历1：获取大小
-fileCount, _ := countFilesInDir(path) // 遍历2：获取数量
-// 结果：大目录需要2倍时间
-```
-
-### 修复后
-```go
-// 一次遍历获取所有统计
-stats, _ := GetDirectoryStats(path)
-// stats.Size      // 大小
-// stats.FileCount // 数量
-// stats.Depth     // 深度
-// 结果：性能提升60%+
-```
-
----
-
-## 🔧 基本使用
-
-### 1. 默认删除（推荐）
-```go
-err := filesystem.DeletePath(path)
-if err != nil {
-    // 处理错误
-}
-```
-
-### 2. 使用自定义配置删除
-```go
-config := &filesystem.Config{
-    Security: filesystem.SecurityConfig{
-        DeleteRestrictions: filesystem.DeleteRestrictionsConfig{
-            Enabled:        true,  // 启用限制
-            MaxFileSizeGB:  1.0,    // 文件最大1GB
-            MaxDirSizeGB:   2.0,    // 目录最大2GB
-            MaxDepth:       10,     // 最大深度10层
-            MaxFileCount:   500,    // 最多500个文件
-            RequireConfirm: true,   // 超过限制时需要确认
-        },
-    },
-}
-
-err := filesystem.DeletePathWithConfig(path, config)
-```
-
----
-
-## ⚙️ 配置说明
-
-### DeleteRestrictionsConfig 配置项
-
-| 字段 | 类型 | 默认值 | 说明 |
-|------|------|--------|------|
-| `Enabled` | bool | false | 是否启用删除限制 |
-| `MaxFileSizeGB` | float64 | 1.0 | 单个文件最大大小（GB）|
-| `MaxDirSizeGB` | float64 | 1.0 | 目录最大大小（GB）|
-| `MaxDepth` | int | 15 | 最大目录深度 |
-| `MaxFileCount` | int | 1000 | 最大文件数量 |
-| `RequireConfirm` | bool | true | 超过限制时确认而非拒绝 |
-| `ForbiddenPaths` | []string | - | 禁止删除的路径 |
-
-### 默认配置
-
-```go
-DeleteRestrictions: DeleteRestrictionsConfig{
-    Enabled:        false, // 默认禁用（避免过度防御）
-    MaxFileSizeGB:  1.0,
-    MaxDirSizeGB:   1.0,
-    MaxDepth:       15,
-    MaxFileCount:   1000,
-    RequireConfirm: true, // 确认机制
-    ForbiddenPaths: []string{
-        "node_modules", ".git", ".github",
-        ".vscode", ".idea", "src", "dist",
-        "database", "db", "backup",
-    },
-}
-```
-
----
-
-## 🎯 确认机制
-
-### 工作原理
-
-当 `RequireConfirm = true` 时，超过限制会返回警告而非错误：
-
-```go
-err := DeletePath(path)
-
-// 检查是否为限制警告
-if warning, ok := err.(*filesystem.DeleteRestrictionWarning); ok {
-    // 显示确认对话框
-    confirmed := ShowConfirmDialog(
-        "删除确认",
-        fmt.Sprintf("该操作存在风险：\n%s\n\n是否继续？", warning.Details),
-    )
-
-    if confirmed {
-        // 用户确认，强制删除
-        return DeletePathWithConfig(path, configWithoutRestrictions)
-    }
-    return err
-}
-```
-
-### DeleteRestrictionWarning 结构
-
-```go
-type DeleteRestrictionWarning struct {
-    Path    string      // 文件路径
-    Details string      // 警告详情
-    Info    os.FileInfo // 文件信息
-}
-```
-
----
-
-## 📊 使用场景
-
-### 场景1：开发环境（宽松）
-```go
-// 默认配置，禁用所有限制
-config := DefaultConfig()
-err := DeletePathWithConfig(path, config)
-```
-
-### 场景2：生产环境（严格）
-```go
-config := DefaultConfig()
-config.Security.DeleteRestrictions.Enabled = true
-config.Security.DeleteRestrictions.RequireConfirm = false // 直接拒绝
-
-err := DeletePathWithConfig(path, config)
-if err != nil {
-    // 显示错误，不允许删除
-}
-```
-
-### 场景3：用户友好（推荐）
-```go
-config := DefaultConfig()
-config.Security.DeleteRestrictions.Enabled = true
-config.Security.DeleteRestrictions.RequireConfirm = true // 需要确认
-
-err := DeletePathWithConfig(path, config)
-if warning, ok := err.(*DeleteRestrictionWarning); ok {
-    // 显示确认对话框，让用户决定
-    if UserConfirmed(warning.Details) {
-        // 继续删除
-    }
-}
-```
-
----
-
-## 🔍 安全检查
-
-### 核心安全检查（始终启用）
-1. ✅ 路径遍历检查（`..`）
-2. ✅ 符号链接检查
-3. ✅ UNC路径检查（Windows）
-4. ✅ 系统关键目录检查
-5. ✅ 敏感配置目录检查
-
-### 可选限制（默认禁用）
-- ⚠️ 文件大小限制
-- ⚠️ 目录大小限制
-- ⚠️ 目录深度限制
-- ⚠️ 文件数量限制
-
----
-
-## 📈 性能对比
-
-### 测试场景：删除包含10000个文件的目录
-
-| 实现方式 | 遍历次数 | 耗时 | 性能 |
-|----------|----------|------|------|
-| 修复前 | 2次（大小+数量） | ~200ms | 100% |
-| 修复后 | 1次（合并统计） | ~80ms | **60%↑** |
-
-### 内存占用
-- 修复前：2次遍历，峰值内存较高
-- 修复后：1次遍历，内存占用稳定
-
----
-
-## 🛠️ API 参考
-
-### DeletePath
-```go
-func DeletePath(path string) error
-```
-使用默认配置删除文件或目录。
-
-### DeletePathWithConfig
-```go
-func DeletePathWithConfig(path string, config *Config) error
-```
-使用指定配置删除文件或目录。
-
-### GetDirectoryStats
-```go
-func GetDirectoryStats(path string) (*DirectoryStats, error)
-```
-获取目录统计信息（一次遍历）。
-
-### CheckDeleteRestrictions
-```go
-func CheckDeleteRestrictions(path string, info os.FileInfo, config *Config) (exceeds bool, details string, err error)
-```
-检查是否超过删除限制。
-
----
-
-## 💡 最佳实践
-
-### 1. 默认使用 `DeletePath`
-```go
-// 简单场景，使用默认配置
-err := filesystem.DeletePath(path)
-```
-
-### 2. 前端处理确认对话框
-```go
-err := filesystem.DeletePath(path)
-if warning, ok := err.(*filesystem.DeleteRestrictionWarning); ok {
-    if !frontend.ShowConfirm(warning.Details) {
-        return errors.New("用户取消")
-    }
-    // 用户确认，继续删除
-}
-```
-
-### 3. 根据环境调整配置
-```go
-var config *filesystem.Config
-
-if IsProduction() {
-    // 生产环境：启用限制
-    config = filesystem.DefaultConfig()
-    config.Security.DeleteRestrictions.Enabled = true
-    config.Security.DeleteRestrictions.RequireConfirm = false
-} else {
-    // 开发环境：禁用限制
-    config = filesystem.DefaultConfig()
-}
-```
-
----
-
-## ⚠️ 注意事项
-
-1. **默认禁用限制**: `Enabled = false`，避免影响正常使用
-2. **确认机制**: `RequireConfirm = true` 时会返回警告而非错误
-3. **向后兼容**: 保留 `DeletePath()` 函数，使用默认配置
-4. **性能优化**: 大目录删除前会进行统计，有一定开销
-
----
-
-## 🎉 总结
-
-| 优化项 | 修复前 | 修复后 |
-|--------|--------|--------|
-| 目录遍历 | 2次 | 1次 |
-| 性能 | 基准 | 60%↑ |
-| 配置化 | 硬编码 | 可配置 |
-| 用户体验 | 硬拒绝 | 可确认 |
-| 灵活性 | 低 | 高 |
-
----
-
-*文档版本: 1.0*
-*最后更新: 2026-01-27*

docs/file-security-implementation.md

@@ -1,346 +0,0 @@
-# 文件管理安全功能实现总结
-
-## ✅ 已完成的功能
-
-### 1. 操作审计日志 (Audit Log)
-
-**实现位置**: `internal/filesystem/audit_log.go`
-
-**功能特性**:
-- ✅ 记录所有文件操作（读取、写入、删除、创建等）
-- ✅ 每条日志包含：时间戳、操作类型、文件路径、文件大小、操作结果
-- ✅ 使用缓冲区批量写入（每100条或每5秒刷新一次）
-- ✅ 按日期自动轮转日志文件（`audit_2006-01-02.log`）
-- ✅ JSON格式存储，易于解析和分析
-- ✅ 应用关闭时自动刷新缓冲区
-
-**日志存储位置**:
-- Windows: `%LOCALAPPDATA%\u-desk\logs\`
-- macOS: `~/Library/Application Support/u-desk/logs/`
-- Linux: `~/.config/u-desk/logs/`
-
-**集成方式**:
-```go
-// 在main.go中初始化
-logDir := filepath.Join(userDataDir, "logs")
-filesystem.InitAudit(logDir)
-
-// 在文件操作中自动记录
-filesystem.ReadFile(path)    // 自动记录读取操作
-filesystem.WriteFile(path, content)  // 自动记录写入操作
-filesystem.DeletePath(path)  // 自动记录删除操作
-```
-
-**API接口**:
-```go
-// 获取最近的审计日志
-func (a *App) GetAuditLogs(limit int) ([]map[string]interface{}, error)
-```
-
----
-
-### 2. 回收站功能 (Recycle Bin)
-
-**实现位置**: `internal/filesystem/recycle_bin.go`
-
-**功能特性**:
-- ✅ 删除文件时移动到回收站而非永久删除
-- ✅ 保留原始路径、删除时间、文件大小等元数据
-- ✅ 支持跨设备移动（复制+删除）
-- ✅ 自动清理超过30天的文件
-- ✅ 支持恢复文件到原位置
-- ✅ 支持永久删除（清空回收站）
-- ✅ JSON元数据存储（`metadata.json`）
-
-**回收站存储位置**:
-- Windows: `%LOCALAPPDATA%\u-desk\recycle_bin\`
-- macOS: `~/Library/Application Support/u-desk/recycle_bin/`
-- Linux: `~/.config/u-desk/recycle_bin/`
-
-**文件命名规则**:
-```
-20060102_150405_随机6位_原文件名.扩展名
-例如: 20250127_143022_a3b4c5_config.json
-```
-
-**使用示例**:
-```go
-// 删除到回收站
-bin := filesystem.GetRecycleBin()
-bin.MoveToRecycleBin("C:\\test.txt")
-
-// 恢复文件
-bin.RestoreFromRecycleBin("回收站路径")
-
-// 永久删除
-bin.DeletePermanently("回收站路径")
-
-// 清空回收站
-bin.Empty()
-```
-
-**API接口**:
-```go
-// 获取回收站条目列表
-func (a *App) GetRecycleBinEntries() ([]map[string]interface{}, error)
-
-// 恢复文件
-func (a *App) RestoreFromRecycleBin(recyclePath string) error
-
-// 永久删除
-func (a *App) DeletePermanently(recyclePath string) error
-
-// 清空回收站
-func (a *App) EmptyRecycleBin() error
-```
-
----
-
-### 3. 文件锁检查 (File Lock Checker)
-
-**实现位置**: `internal/filesystem/file_lock.go`
-
-**功能特性**:
-- ✅ 检测文件是否被其他程序占用
-- ✅ 尝试独占打开文件以检测锁定状态
-- ✅ 提供重试机制（可配置重试次数和间隔）
-- ✅ Windows平台专用实现（使用Windows API）
-- ✅ 友好的错误提示信息
-
-**检查方式**:
-1. 尝试以独占写模式打开文件
-2. 尝试重命名文件（更彻底的检查）
-3. 检查错误类型是否为锁定相关错误
-4. 提供占用进程信息
-
-**使用示例**:
-```go
-checker := filesystem.GetFileLockChecker()
-
-// 简单检查
-locked, processInfo, err := checker.IsFileLocked("C:\\test.txt")
-
-// 带重试的检查
-err := checker.CheckFileWithRetry("C:\\test.txt", 3, 1*time.Second)
-
-// 安全删除（带锁检查）
-err := checker.SafeDeleteWithLockCheck("C:\\test.txt")
-```
-
-**错误提示示例**:
-```
-无法删除文件：文件正被其他程序使用
-
-提示：文件正被其他程序使用
-
-请关闭相关程序后重试
-```
-
----
-
-## 📂 新增文件清单
-
-1. **internal/filesystem/audit_log.go** - 审计日志实现
-   - `AuditLogger` 结构体
-   - `AuditLogEntry` 日志条目
-   - 日志记录、缓冲、轮转功能
-
-2. **internal/filesystem/recycle_bin.go** - 回收站实现
-   - `RecycleBin` 管理器
-   - `RecycleBinEntry` 回收站条目
-   - 文件移动、恢复、清理功能
-
-3. **internal/filesystem/file_lock.go** - 文件锁检查实现
-   - `FileLockChecker` 检查器
-   - Windows API集成
-   - 错误检测和重试机制
-
----
-
-## 🔧 修改的文件
-
-### 1. main.go
-- 添加 `initFileSystemSecurity()` 初始化函数
-- 添加 `getUserDataDir()` 辅助函数
-- 配置 `OnShutdown` 回调
-
-### 2. app.go
-- 添加 `shutdown()` 方法
-- 添加审计日志API: `GetAuditLogs()`
-- 添加回收站API:
-  - `GetRecycleBinEntries()`
-  - `RestoreFromRecycleBin()`
-  - `DeletePermanently()`
-  - `EmptyRecycleBin()`
-
-### 3. internal/filesystem/fs.go
-- 添加全局审计日志记录器
-- 添加 `InitAudit()` 和 `CloseAudit()` 函数
-- 在 `ReadFile`、`WriteFile`、`DeletePath` 中集成审计日志
-
----
-
-## 🎯 安全层级
-
-系统现在具有**多层安全防护**：
-
-### 第1层：前端确认
-- ✅ 用户必须确认删除操作
-- ✅ 红色危险按钮提醒
-- ✅ 防止并发删除
-
-### 第2层：后端验证
-- ✅ 路径安全检查
-- ✅ 敏感路径保护
-- ✅ 文件大小限制
-- ✅ 目录深度限制
-
-### 第3层：文件锁检查
-- ✅ 检测文件占用
-- ✅ 防止删除正在使用的文件
-- ✅ 提供重试机制
-
-### 第4层：回收站
-- ✅ 删除先移到回收站
-- ✅ 30天恢复期
-- ✅ 自动清理过期文件
-
-### 第5层：审计日志
-- ✅ 记录所有操作
-- ✅ 便于追踪和审计
-- ✅ 永久保存操作历史
-
----
-
-## 📊 使用流程
-
-### 删除文件流程（带所有安全措施）：
-
-```
-用户点击删除
-    ↓
-前端确认对话框
-    ↓
-[后端] 文件锁检查 ← 文件被占用？
-    ↓                ↓
-   通过              提示关闭程序
-    ↓
-[后端] 移动到回收站 ← 删除失败？
-    ↓                ↓
-   成功              记录审计日志
-    ↓
-记录审计日志（成功）
-    ↓
-返回前端显示成功
-```
-
----
-
-## 🚀 前端集成建议
-
-虽然后端API已实现，但前端仍需添加UI：
-
-### 1. 回收站界面
-```javascript
-// 获取回收站条目
-const entries = await app.GetRecycleBinEntries()
-
-// 显示列表
-// - 原始路径
-// - 删除时间
-// - 文件大小
-// - 操作按钮（恢复/永久删除）
-
-// 清空回收站
-await app.EmptyRecycleBin()
-```
-
-### 2. 审计日志界面
-```javascript
-// 获取审计日志
-const logs = await app.GetAuditLogs(100) // 最近100条
-
-// 显示日志表格
-// - 时间戳
-// - 操作类型（read/write/delete）
-// - 文件路径
-// - 成功/失败状态
-```
-
-### 3. 文件锁错误处理
-```javascript
-try {
-  await deletePathApi(path)
-} catch (error) {
-  if (error.message.includes('文件被占用')) {
-    // 显示友好提示，建议用户关闭相关程序
-    Message.error({
-      content: error.message,
-      duration: 0, // 不自动关闭
-      closable: true
-    })
-  }
-}
-```
-
----
-
-## 📝 配置项
-
-所有配置都在代码中定义，可根据需要调整：
-
-### 审计日志配置
-```go
-const bufferSize = 100        // 缓冲区大小
-const flushInterval = 5 * time.Second  // 刷新间隔
-```
-
-### 回收站配置
-```go
-const retentionDays = 30      // 保留天数
-const autoCleanupInterval = 24 * time.Hour  // 自动清理间隔
-```
-
-### 文件锁配置
-```go
-const defaultMaxRetries = 3   // 默认重试次数
-const defaultRetryInterval = 1 * time.Second  // 默认重试间隔
-```
-
----
-
-## 🧪 测试建议
-
-### 1. 审计日志测试
-- 删除文件，检查日志文件是否生成
-- 检查日志格式是否正确（JSON）
-- 关闭应用，检查缓冲区是否正确刷新
-
-### 2. 回收站测试
-- 删除文件，检查回收站目录
-- 恢复文件，检查原位置是否有文件
-- 删除同名文件，检查是否正确处理
-- 清空回收站，检查所有文件是否删除
-
-### 3. 文件锁测试
-- 用文本编辑器打开文件
-- 尝试删除，应该提示文件被占用
-- 关闭编辑器后，应该可以删除
-
----
-
-## ✨ 总结
-
-所有安全功能已成功实现并集成到应用中：
-
-1. ✅ **操作审计日志** - 完整追踪所有文件操作
-2. ✅ **回收站功能** - 30天恢复期，自动清理
-3. ✅ **文件锁检查** - 防止删除占用文件
-
-系统现在具有**企业级的安全性和可靠性**，可以有效防止误删和恶意操作，同时提供完整的操作审计能力。
-
----
-
-**实现日期**: 2025-01-27
-**版本**: v1.0.0
-**作者**: Claude Sonnet 4.5

docs/filesystem-architecture.md

@@ -1,370 +0,0 @@
-# 文件管理模块架构升级方案
-
-## 📋 目录
-- [现状分析](#现状分析)
-- [架构目标](#架构目标)
-- [核心设计](#核心设计)
-- [模块划分](#模块划分)
-- [实施路线图](#实施路线图)
-
----
-
-## 🔍 现状分析
-
-### 当前问题
-1. **全局变量泛滥**：4个全局单例（auditLogger, recycleBin, lockChecker, fileServer）
-2. **代码重复严重**：路径验证、文件类型检查、错误处理模式重复
-3. **魔法数字遍布**：至少15处硬编码常量
-4. **过度防御性**：删除操作有3层硬限制
-5. **性能隐患**：重复目录遍历、随机字符串生成低效
-6. **可测试性差**：依赖全局状态，难以编写单元测试
-
-### 技术债务评估
-| 类别 | 债务量 | 优先级 | 影响范围 |
-|------|--------|--------|----------|
-| 重复代码 | 高 | P1 | 可维护性 |
-| 性能问题 | 高 | P0 | 用户体验 |
-| 架构问题 | 高 | P1 | 可扩展性 |
-| 代码风格 | 中 | P2 | 可读性 |
-
----
-
-## 🎯 架构目标
-
-### 设计原则
-1. **单一职责**：每个模块只负责一个功能领域
-2. **依赖倒置**：面向接口编程，降低耦合
-3. **开放封闭**：对扩展开放，对修改封闭
-4. **配置驱动**：安全策略可配置，不硬编码
-
-### 质量目标
-- ✅ 零代码重复（DRY原则）
-- ✅ 零全局变量（依赖注入）
-- ✅ 零魔法数字（命名常量）
-- ✅ 零性能隐患（优化热点）
-- ✅ 100% 可测试（支持mock）
-
----
-
-## 🏗️ 核心设计
-
-### 1. 分层架构
-
-```
-┌─────────────────────────────────────────┐
-│         Application Layer (app.go)       │
-│     - 对外接口（Bindings）                │
-└────────────────┬────────────────────────┘
-                 │
-┌────────────────▼────────────────────────┐
-│      Service Layer (FileSystemService)   │
-│     - 编排业务逻辑                         │
-│     - 事务管理                            │
-└────────────────┬────────────────────────┘
-                 │
-┌────────────────▼────────────────────────┐
-│         Component Layer                  │
-│  ┌────────────┬────────────┬──────────┐ │
-│  │Validator   │Manager     │Handler   │ │
-│  │路径验证     │文件管理     │文件服务   │ │
-│  └────────────┴────────────┴──────────┘ │
-└────────────────┬────────────────────────┘
-                 │
-┌────────────────▼────────────────────────┐
-│         Infrastructure Layer             │
-│  ┌──────────┬──────────┬──────────────┐ │
-│  │Audit     │Recycle   │Lock          │ │
-│  │审计日志    │回收站     │文件锁         │ │
-│  └──────────┴──────────┴──────────────┘ │
-└──────────────────────────────────────────┘
-```
-
-### 2. 核心接口设计
-
-```go
-// FileService 文件操作核心接口
-type FileService interface {
-    Read(path string) (string, error)
-    Write(path, content string) error
-    Delete(path string) error
-    List(path string) ([]FileInfo, error)
-    Create(path string, isDir bool) error
-    Move(src, dst string) error
-    GetInfo(path string) (*FileInfo, error)
-}
-
-// PathValidator 路径验证接口
-type PathValidator interface {
-    Validate(path string) *ValidationError
-    IsSafe(path string) bool
-    IsSensitive(path string) bool
-}
-
-// FileTypeManager 文件类型管理接口
-type FileTypeManager interface {
-    GetMIMEType(ext string) string
-    IsAllowed(ext string) bool
-    GetMaxSize(ext string) int64
-}
-
-// SecurityGuard 安全策略接口
-type SecurityGuard interface {
-    CheckDelete(path string) error
-    CheckAccess(path string) error
-}
-```
-
-### 3. 配置驱动设计
-
-```go
-// Config 文件系统配置
-type Config struct {
-    // 安全配置
-    Security SecurityConfig
-    // 性能配置
-    Performance PerformanceConfig
-    // 功能开关
-    Features FeatureConfig
-}
-
-// SecurityConfig 安全策略配置
-type SecurityConfig struct {
-    // 路径验证
-    PathValidation PathValidationConfig
-    // 删除限制
-    DeleteRestrictions DeleteRestrictionsConfig
-    // 文件类型
-    FileTypes FileTypeConfig
-}
-
-// DeleteRestrictionsConfig 删除限制配置
-type DeleteRestrictionsConfig struct {
-    Enabled          bool    // 是否启用限制
-    MaxSizeGB        float64 // 最大文件大小（GB）
-    MaxDepth         int     // 最大目录深度
-    MaxFileCount     int     // 最大文件数量
-    RequireConfirm   bool    // 超过限制是否需要确认
-    ForbiddenPaths   []string // 禁止删除的路径
-}
-```
-
----
-
-## 📦 模块划分
-
-### 模块1: 核心文件操作 (fs_core)
-```
-fs_core/
-├── service.go          # FileService 实现
-├── file_info.go        # FileInfo 结构
-└── errors.go           # 错误定义
-```
-
-### 模块2: 路径验证 (validator)
-```
-validator/
-├── path_validator.go   # PathValidator 接口和实现
-├── config.go           # 验证配置
-└── errors.go           # 验证错误
-```
-
-### 模块3: 文件类型管理 (filetype)
-```
-filetype/
-├── manager.go          # FileTypeManager 实现
-├── types.go            # 文件类型配置
-└── mime.go             # MIME 类型映射
-```
-
-### 模块4: 基础设施 (infra)
-```
-infra/
-├── audit/
-│   └── logger.go       # 审计日志
-├── recycle/
-│   └── bin.go          # 回收站
-├── lock/
-│   └── checker.go      # 文件锁检查
-└── server/
-    └── handler.go      # HTTP 文件服务
-```
-
-### 模块5: ZIP 操作 (zip)
-```
-zip/
-├── reader.go           # ZIP 读取
-├── writer.go           # ZIP 写入
-├── security.go         # ZIP 安全检查
-└── temp.go             # 临时文件管理
-```
-
-### 模块6: 配置管理 (config)
-```
-config/
-├── constants.go        # 常量定义
-├── config.go           # 配置结构
-└── defaults.go         # 默认配置
-```
-
----
-
-## 🗺️ 实施路线图
-
-### 阶段1: 紧急修复（P0）- 1天
-**目标**: 修复严重性能和稳定性问题
-
-- [x] 任务1: 修复 `generateRandomString` 的 `time.Sleep`
-- [x] 任务2: 修复文件锁检查的破坏性 rename
-
-**影响**: 立即提升性能和稳定性
-
----
-
-### 阶段2: 基础建设（P1）- 2天
-**目标**: 统一配置和常量，消除技术债务
-
-- [x] 任务3: 创建 constants.go，定义所有命名常量
-- [x] 任务4: 创建 config.go，统一配置管理
-- [x] 任务5: 定义核心接口（FileService, PathValidator, FileTypeManager）
-
-**影响**: 提升代码质量，为重构打基础
-
----
-
-### 阶段3: DRY重构（P1）- 3天
-**目标**: 消除代码重复，提升可维护性
-
-- [x] 任务6: 重构路径验证逻辑（PathValidator）
-- [x] 任务7: 重构文件类型管理（FileTypeManager）
-- [x] 任务8: 重构 ZIP 操作（withZipReader）
-
-**影响**: 减少30%+代码量，提升可维护性
-
----
-
-### 阶段4: 安全优化（P1）- 2天
-**目标**: 优化过度防御，改善用户体验
-
-- [x] 任务9: 重构 DeletePath 安全检查
-- [x] 任务10: 配置化安全策略
-
-**影响**: 提升用户体验，保留安全性
-
----
-
-### 阶段5: 架构升级（P1）- 3天
-**目标**: 引入依赖注入，消除全局变量
-
-- [x] 任务11: 创建 FileSystemService
-- [x] 任务12: 重构各组件为独立模块
-- [x] 任务13: 消除全局变量
-
-**影响**: 提升可测试性和可扩展性
-
----
-
-### 阶段6: 代码质量（P2）- 2天
-**目标**: 统一代码风格，完善文档
-
-- [x] 任务14: 统一错误处理
-- [x] 任务15: 添加结构化日志
-- [x] 任务16: 统一注释风格
-- [x] 任务17: 编写单元测试
-
-**影响**: 提升代码可读性和可维护性
-
----
-
-### 阶段7: 测试验证（P2）- 2天
-**目标**: 确保重构质量，回归测试
-
-- [x] 任务18: 编写集成测试
-- [x] 任务19: 性能基准测试
-- [x] 任务20: 安全测试
-
-**影响**: 确保重构质量，无回归问题
-
----
-
-## 📊 预期收益
-
-### 代码质量
-- **代码量**: 预计减少 30-40%
-- **重复率**: 从 25% 降至 < 5%
-- **圈复杂度**: 平均降低 40%
-
-### 性能提升
-- **删除操作**: 性能提升 60%（消除重复遍历）
-- **回收站**: 性能提升 99%（修复 time.Sleep）
-- **文件锁**: 安全性提升 100%（消除破坏性操作）
-
-### 可维护性
-- **测试覆盖率**: 从 0% 提升至 80%+
-- **可测试性**: 从困难变为简单（依赖注入）
-- **扩展性**: 新增功能无需修改核心代码
-
----
-
-## 🔧 技术选型
-
-### 依赖注入
-- 考虑 Uber Fx 或 Google Wire
-- 或者手动 DI（更简单，适合当前规模）
-
-### 配置管理
-- 使用结构体配置
-- 支持 JSON/YAML 导入导出
-- 环境变量覆盖
-
-### 日志
-- 结构化日志（logrus 或 zap）
-- 可配置日志级别
-- 支持日志轮转
-
-### 测试
-- 单元测试：testify/assert
-- Mock：gomock
-- 基准测试：内置 testing/benchmark
-
----
-
-## 📝 注意事项
-
-### 兼容性
-- 保持对外接口（app.go 的方法）不变
-- 内部重构对前端透明
-
-### 渐进式重构
-- 不重写，只重构
-- 一次只改一个模块
-- 每次重构后运行测试
-
-### 回滚计划
-- 使用 Git 分支管理
-- 每个阶段完成后打 tag
-- 出现问题可快速回滚
-
----
-
-## 🎯 成功标准
-
-### 功能完整性
-- ✅ 所有现有功能正常工作
-- ✅ 无新增 bug
-- ✅ 性能不下降
-
-### 代码质量
-- ✅ 代码重复率 < 5%
-- ✅ 测试覆盖率 > 80%
-- ✅ 代码审查通过
-
-### 文档完整性
-- ✅ 架构文档完整
-- ✅ API 文档完整
-- ✅ 配置文档完整
-
----
-
-*文档版本: 1.0*
-*创建日期: 2026-01-27*
-*作者: Claude Code*

docs/filesystem-code-style-guide.md

@@ -1,429 +0,0 @@
-# 文件管理模块代码风格规范
-
-## 概述
-
-本文档定义了文件管理模块的代码风格规范，确保代码一致性、可读性和可维护性。
-
----
-
-## 1. 注释规范
-
-### 1.1 包注释
-每个包应该有一个简短的包注释，说明包的用途。
-
-```go
-// Package filesystem 提供文件系统操作功能
-//
-// 核心功能：
-// - 文件读写、删除、列表
-// - 路径验证和安全检查
-// - ZIP文件操作
-// - 审计日志和回收站
-package filesystem
-```
-
-### 1.2 函数注释
-使用标准Go文档注释风格：
-
-```go
-// DeletePath 删除文件或目录
-//
-// 参数:
-//   path - 文件或目录路径
-//
-// 返回:
-//   error - 错误信息，nil表示成功
-//
-// 示例:
-//   err := fs.DeletePath("/path/to/file")
-func (s *FileSystemService) DeletePath(path string) error {
-    // 实现...
-}
-```
-
-### 1.3 禁止的注释风格
-```go
-// 禁止使用emoji
-// 🔒 安全检查
-// ✅ 优化
-// ⚠️ 警告
-
-// 应使用纯文本
-// 安全检查
-// 性能优化
-// 警告
-```
-
----
-
-## 2. 错误处理规范
-
-### 2.1 错误包装
-使用 WrapError 添加上下文：
-
-```go
-// 推荐做法
-data, err := os.ReadFile(path)
-if err != nil {
-    return "", WrapError("读取文件", path, err)
-}
-
-// 避免裸错误
-return "", err // ❌ 不推荐
-return "", fmt.Errorf("失败: %w", err) // ✅ 推荐
-```
-
-### 2.2 错误消息
-使用中文描述（面向中文用户）：
-
-```go
-// 推荐
-return fmt.Errorf("文件不存在: %s", path)
-
-// 避免使用英文
-return fmt.Errorf("file not found: %s", path) // ❌
-```
-
-### 2.3 错误忽略
-必须注释说明原因：
-
-```go
-// 推荐：注释说明原因
-if err := logger.Close(); err != nil {
-    // 日志关闭失败，程序即将退出，忽略错误
-}
-
-// 禁止：无注释忽略
-_ = logger.Close() // ❌
-```
-
----
-
-## 3. 命名规范
-
-### 3.1 常量命名
-使用大驼峰命名法：
-
-```go
-const (
-    MaxZipSize        = 100 * 1024 * 1024
-    DefaultDirPermissions = 0755
-    AuditFlushInterval  = 5 * time.Second
-)
-```
-
-### 3.2 变量命名
-使用小驼峰命名法：
-
-```go
-var (
-    globalService     *FileSystemService
-    defaultConfig      *Config
-    defaultPermissions os.FileMode = 0644
-)
-```
-
-### 3.3 接口命名
-接口名应该是动作或能力的描述，通常以 -er 结尾：
-
-```go
-type Reader interface {
-    Read(p []byte) (n int, err error)
-}
-
-type Validator interface {
-    Validate(path string) error
-}
-```
-
----
-
-## 4. 函数设计规范
-
-### 4.1 函数长度
-推荐单个函数不超过50行。如果超过，考虑拆分子函数：
-
-```go
-// 推荐：拆分子函数
-func DeletePath(path string) error {
-    if err := validatePath(path); err != nil {
-        return err
-    }
-
-    if err := checkPermissions(path); err != nil {
-        return err
-    }
-
-    return performDelete(path)
-}
-
-// 避免：长函数
-func DeletePath(path string) error {
-    // 100行代码...
-}
-```
-
-### 4.2 参数数量
-函数参数不超过5个。如果超过，使用结构体：
-
-```go
-// 推荐：使用结构体
-type DeleteOptions struct {
-    Path          string
-    Force         bool
-    SkipRecycle   bool
-    IgnoreLock    bool
-    Reason        string
-}
-
-func DeleteWithOptions(opts DeleteOptions) error {
-    // 实现...
-}
-
-// 避免：过多参数
-func DeleteWithOptions(path string, force bool, skipRecycle bool, ignoreLock bool, reason string, timeout int) error {
-    // 参数过多
-}
-```
-
-### 4.3 返回值
-函数返回值遵循以下顺序：
-1. 结果
-2. 错误
-
-```go
-// 推荐
-func ReadFile(path string) ([]byte, error)
-
-// 避免多个返回值
-func ReadFile(path string) ([]byte, bool, error, int)
-```
-
----
-
-## 5. 代码组织
-
-### 5.1 文件组织
-每个文件应该有单一的职责：
-
-```
-filesystem/
-├── fs.go              # 核心文件操作
-├── service.go         # 文件系统服务
-├── path_validator.go  # 路径验证
-├── filetype_manager.go # 文件类型管理
-├── zip.go             # ZIP操作
-├── errors.go          # 错误定义
-├── logger.go          # 日志记录
-└── constants.go       # 常量定义
-```
-
-### 5.2 导入顺序
-标准库 → 第三方库 → 项目内部：
-
-```go
-import (
-    // 标准库
-    "context"
-    "fmt"
-    "os"
-
-    // 第三方库
-    "github.com/google/uuid"
-
-    // 项目内部
-    "go-desk/internal/common"
-)
-```
-
----
-
-## 6. 性能规范
-
-### 6.1 避免重复计算
-使用缓存或预计算：
-
-```go
-// 推荐：缓存结果
-type statsCache struct {
-    mu    sync.RWMutex
-    cache map[string]*DirectoryStats
-}
-
-func (c *statsCache) Get(path string) (*DirectoryStats, error) {
-    c.mu.RLock()
-    if stats, ok := c.cache[path]; ok {
-        c.mu.RUnlock()
-        return stats, nil
-    }
-    c.mu.RUnlock()
-
-    // 计算并缓存
-    stats, err := GetDirectoryStats(path)
-    if err != nil {
-        return nil, err
-    }
-
-    c.mu.Lock()
-    c.cache[path] = stats
-    c.mu.Unlock()
-
-    return stats, nil
-}
-
-// 避免：重复计算
-func processData(path string) {
-    stats1, _ := GetDirectoryStats(path)
-    stats2, _ := GetDirectoryStats(path) // 重复计算
-}
-```
-
-### 6.2 资源释放
-使用 defer 确保资源释放：
-
-```go
-// 推荐
-func ReadFile(path string) ([]byte, error) {
-    file, err := os.Open(path)
-    if err != nil {
-        return nil, err
-    }
-    defer file.Close() // 确保关闭
-
-    return io.ReadAll(file)
-}
-```
-
----
-
-## 7. 并发安全
-
-### 7.1 共享状态
-使用互斥锁保护共享状态：
-
-```go
-type SafeCounter struct {
-    mu    sync.RWMutex
-    count int
-}
-
-func (c *SafeCounter) Increment() {
-    c.mu.Lock()
-    defer c.mu.Unlock()
-    c.count++
-}
-
-func (c *SafeCounter) Get() int {
-    c.mu.RLock()
-    defer c.mu.RUnlock()
-    return c.count
-}
-```
-
-### 7.2 避免数据竞争
-不要在goroutine中直接共享变量：
-
-```go
-// 推荐：传递参数
-for i := 0; i < 10; i++ {
-    go func(n int) {
-        fmt.Println(n)
-    }(i)
-}
-
-// 避免：闭包捕获
-for i := 0; i < 10; i++ {
-    go func() {
-        fmt.Println(i) // 数据竞争
-    }()
-}
-```
-
----
-
-## 8. 测试规范
-
-### 8.1 测试文件命名
-测试文件命名为 `xxx_test.go`：
-
-```go
-// fs_test.go
-package filesystem
-
-import "testing"
-
-func TestDeletePath(t *testing.T) {
-    // 测试代码
-}
-```
-
-### 8.2 表格驱动测试
-使用表格驱动测试多种场景：
-
-```go
-func TestValidatePath(t *testing.T) {
-    tests := []struct {
-        name    string
-        path    string
-        wantErr bool
-    }{
-        {"正常路径", "/tmp/test.txt", false},
-        {"路径遍历", "/tmp/../etc/passwd", true},
-        {"空路径", "", true},
-    }
-
-    for _, tt := range tests {
-        t.Run(tt.name, func(t *testing.T) {
-            err := ValidatePath(tt.path)
-            if (err != nil) != tt.wantErr {
-                t.Errorf("ValidatePath() error = %v, wantErr %v", err, tt.wantErr)
-            }
-        })
-    }
-}
-```
-
----
-
-## 9. 文档规范
-
-### 9.1 README
-每个模块应该有README说明：
-
-```markdown
-# 文件系统模块
-
-## 功能
-- 文件读写
-- 路径验证
-- ZIP操作
-
-## 使用示例
-...
-
-## 配置
-...
-```
-
-### 9.2 API文档
-导出的函数和类型必须有文档注释。
-
----
-
-## 10. 代码审查清单
-
-提交代码前，确保：
-
-- [ ] 移除所有emoji注释
-- [ ] 函数有文档注释
-- [ ] 错误处理完善（无忽略错误）
-- [ ] 命名符合规范
-- [ ] 无魔法数字（使用常量）
-- [ ] 无重复代码（遵循DRY）
-- [ ] 导入顺序正确
-- [ ] 资源正确释放（defer）
-
----
-
-*版本: 1.0*
-*最后更新: 2026-01-27*

docs/filesystem-complete-summary.md

@@ -1,468 +0,0 @@
-# 文件管理模块升级 - 完整总结报告
-
-**项目**: go-desk 文件管理模块
-**升级周期**: 2026-01-27
-**状态**: ✅ 全部完成
-
----
-
-## 📊 执行摘要
-
-### 完成情况
-```
-✅ P0 任务 (严重问题)    [████████████████████] 100% (2/2)
-✅ P1 任务 (核心功能)    [████████████████████] 100% (7/7)
-✅ P2 任务 (代码质量)    [████████████████████] 100% (2/2)
-
-总体完成度: 100% (11/11 任务)
-```
-
-### 关键指标
-- **代码重复减少**: 60% (从 ~25% 降至 <10%)
-- **魔法数字消除**: 100% (15+ → 0)
-- **性能提升**: 60%+ (删除操作优化)
-- **全局变量消除**: 100% (4个 → 可DI)
-- **新增文件**: 10个
-- **新增代码**: ~1,700行
-- **删除重复**: 330+行
-
----
-
-## 📋 任务清单
-
-### ✅ P0 任务 (2个)
-
-#### 任务2: 修复严重性能问题
-**状态**: ✅ 完成
-**耗时**: 约30分钟
-
-**成果**:
-1. 修复 `generateRandomString` 性能灾难
-   - 问题: 使用 `time.Sleep(time.Nanosecond)`
-   - 解决: 使用 `crypto/rand`
-   - 提升: 99%+
-
-2. 修复文件锁检查的破坏性操作
-   - 问题: 使用 `os.Rename` 测试
-   - 解决: 使用 `os.OpenFile`
-   - 提升: 消除文件损坏风险
-
----
-
-### ✅ P1 任务 (7个)
-
-#### 任务3: 重构路径验证逻辑 (DRY)
-**状态**: ✅ 完成
-**文件**: `path_validator.go` (~210行)
-
-**成果**:
-- 统一 `PathValidator` 接口
-- 消除4处重复验证逻辑
-- 配置驱动安全策略
-
-**代码减少**: 107行
-
-#### 任务4: 重构文件类型管理 (DRY)
-**状态**: ✅ 完成
-**文件**: `filetype_manager.go` (~180行)
-
-**成果**:
-- 统一 `FileTypeManager` 接口
-- 消除2处MIME类型映射
-- 统一白名单/黑名单管理
-
-**代码减少**: 104行
-
-#### 任务5: 优化删除操作安全检查
-**状态**: ✅ 完成
-**文件**: `directory_stats.go` (~115行)
-
-**成果**:
-- 合并目录遍历（性能60%↑）
-- 配置驱动删除限制
-- 确认机制替代硬拒绝
-
-**代码减少**: 28行
-
-#### 任务6: 重构ZIP操作 (DRY + 性能)
-**状态**: ✅ 完成
-**文件**: `zip_helper.go` (~130行)
-
-**成果**:
-- `withZipReader` 通用包装器
-- 消除4处 `zip.OpenReader` 重复
-- 简化操作函数
-
-**代码减少**: 85行
-
-#### 任务7: 引入依赖注入架构
-**状态**: ✅ 完成
-**文件**: `service.go` (~480行)
-
-**成果**:
-- `FileSystemService` 统一服务
-- 消除4个全局变量依赖
-- 提升可测试性
-
-**架构升级**: 依赖注入
-
-#### 任务8: 统一常量和配置管理
-**状态**: ✅ 完成
-**文件**:
-- `constants.go` (~90行)
-- `config.go` (~350行)
-
-**成果**:
-- 40+个命名常量
-- 配置驱动架构
-- 功能开关支持
-
-**魔法数字**: 100%消除
-
----
-
-### ✅ P2 任务 (2个)
-
-#### 任务9: 改进错误处理和日志
-**状态**: ✅ 完成
-**文件**:
-- `errors.go` (~100行)
-- `logger.go` (~160行)
-
-**成果**:
-- 统一错误类型定义
-- 结构化日志记录器
-- 错误包装和上下文
-
-#### 任务10: 统一代码风格和注释
-**状态**: ✅ 完成
-**文件**: `code-style-guide.md`
-
-**成果**:
-- 代码风格规范文档
-- 移除emoji注释
-- 统一注释风格
-- 函数长度限制
-
----
-
-## 📁 文件清单
-
-### 新增文件 (10个)
-
-| 文件 | 行数 | 说明 |
-|------|------|------|
-| `constants.go` | 90 | 统一常量定义 |
-| `config.go` | 350 | 配置管理架构 |
-| `path_validator.go` | 210 | 路径验证器 |
-| `filetype_manager.go` | 180 | 文件类型管理器 |
-| `directory_stats.go` | 115 | 目录统计优化 |
-| `zip_helper.go` | 130 | ZIP操作辅助 |
-| `service.go` | 480 | 文件系统服务 |
-| `service_interfaces.go` | 30 | 核心接口定义 |
-| `errors.go` | 100 | 错误类型定义 |
-| `logger.go` | 160 | 日志记录器 |
-
-**总计**: ~1,845行新代码
-
-### 文档文件 (5个)
-
-| 文件 | 说明 |
-|------|------|
-| `filesystem-architecture.md` | 架构设计方案 |
-| `filesystem-progress.md` | 进度跟踪报告 |
-| `filesystem-phase2-report.md` | 任务3&4报告 |
-| `delete-optimization-guide.md` | 删除优化指南 |
-| `filesystem-code-style-guide.md` | 代码风格规范 |
-
----
-
-## 🏆 核心改进
-
-### 1. 架构设计
-
-#### 设计模式应用
-- ✅ **依赖注入**: FileSystemService
-- ✅ **策略模式**: PathValidator, FileTypeManager
-- ✅ **门面模式**: 统一服务入口
-- ✅ **单例模式**: 全局服务（兼容）
-- ✅ **模板方法**: withZipReader
-
-#### 分层架构
-```
-应用层 (app.go)
-    ↓
-服务层 (FileSystemService)
-    ↓
-组件层 (Validator, Manager, Handler)
-    ↓
-基础设施层 (Audit, RecycleBin, Lock)
-```
-
-### 2. 代码质量
-
-#### DRY原则
-| 模块 | 重复次数 | 统一后 | 改善 |
-|------|---------|--------|------|
-| 路径验证 | 4处 | 1处 | 75%↓ |
-| 文件类型 | 2处 | 1处 | 50%↓ |
-| ZIP打开 | 4处 | 1处 | 75%↓ |
-| 目录遍历 | 2次 | 1次 | 50%↓ |
-
-**总体**: 代码重复率从 ~25% 降至 <10%
-
-#### 可测试性
-- ✅ 接口可mock
-- ✅ 依赖可注入
-- ✅ 无全局状态
-- ✅ 纯函数设计
-
-**可测试性**: 从 困难 → 简单
-
-### 3. 性能优化
-
-| 操作 | 优化前 | 优化后 | 提升 |
-|------|--------|--------|------|
-| 删除大目录 | 2次遍历 | 1次遍历 | **60%↑** |
-| 随机字符串 | 慢 | 快 | **99%↑** |
-| 文件锁检查 | 破坏性 | 非破坏性 | **100%↑** |
-
-### 4. 配置化
-
-#### 可配置项
-- ✅ 安全策略（路径验证、删除限制）
-- ✅ 性能参数（缓冲区、超时）
-- ✅ 功能开关（审计、回收站、文件锁）
-- ✅ 文件类型（MIME、权限、大小）
-
-**配置化程度**: 0% → 90%
-
----
-
-## 📈 对比分析
-
-### 修复前的问题
-
-#### 1. 代码重复
-```go
-// fs.go
-func isSafePath(path string) bool {
-    // 67行验证逻辑
-}
-
-// asset_handler.go
-if strings.Contains(path, "..") {
-    http.Error(w, "Path traversal detected", http.StatusForbidden)
-}
-
-// zip.go
-func validateZipPath(zipPath string) error {
-    // 10行验证逻辑
-}
-```
-
-#### 2. 全局变量
-```go
-var globalAuditLogger *AuditLogger
-var globalRecycleBin *RecycleBin
-var globalLockChecker *FileLockChecker
-var defaultFileTypeManager = ...
-```
-
-#### 3. 魔法数字
-```go
-if size > 1024*1024*1024 { // ❌
-if depth > 15 {               // ❌
-if fileCount > 1000 {         // ❌
-```
-
-#### 4. 性能问题
-```go
-// generateRandomString
-time.Sleep(time.Nanosecond) // ❌ 性能灾难
-
-// 文件锁检查
-os.Rename(path, testPath)    // ❌ 破坏性操作
-```
-
----
-
-### 修复后的改进
-
-#### 1. 统一验证
-```go
-// 使用统一验证器
-validator := NewPathValidator(config)
-if err := validator.Validate(path); err != nil {
-    return err
-}
-```
-
-#### 2. 依赖注入
-```go
-// 注入所有依赖
-service, err := NewFileSystemService(config)
-service.ReadFile(path)
-service.Close(context.Background())
-```
-
-#### 3. 命名常量
-```go
-if size > MaxDeleteSizeGB {    // ✅
-if depth > MaxDirectoryDepth {  // ✅
-if fileCount > MaxFileCount {   // ✅
-```
-
-#### 4. 性能优化
-```go
-// 使用加密随机数
-n, _ := rand.Int(rand.Reader, big.NewInt(100))
-
-// 非破坏性检查
-file, _ := os.OpenFile(path, os.O_RDWR, 0666)
-```
-
----
-
-## 💡 技术亮点
-
-### 1. 向后兼容性
-```go
-// 旧代码继续工作
-func DeletePath(path string) error {
-    return DeletePathWithConfig(path, DefaultConfig())
-}
-
-// 新代码使用依赖注入
-service.DeletePath(path)
-```
-
-### 2. 渐进式升级
-- 阶段1: 修复严重问题 ✅
-- 阶段2: 基础建设 ✅
-- 阶段3: DRY重构 ✅
-- 阶段4: 代码质量 ✅
-
-### 3. 配置驱动
-```go
-// 开发环境
-config := DefaultConfig()
-
-// 生产环境
-config := DefaultConfig()
-config.Security.DeleteRestrictions.Enabled = true
-```
-
----
-
-## 🎯 最终收益
-
-### 代码质量指标
-
-| 指标 | 初始 | 最终 | 改善 |
-|------|------|------|------|
-| **代码重复率** | ~25% | <10% | **60%↓** |
-| **魔法数字** | 15+ | 0 | **100%↓** |
-| **全局变量** | 4个 | 可DI | **100%↓** |
-| **性能问题** | 2个P0 | 0 | **100%↓** |
-| **可测试性** | 困难 | 简单 | **∞** |
-| **配置化** | 0% | 90% | **∞** |
-
-### 代码统计
-
-#### 新增代码
-- **文件**: 10个
-- **代码**: ~1,845行
-- **接口**: 3个
-- **辅助函数**: 25+个
-
-#### 删除重复
-- **路径验证**: 107行
-- **文件类型**: 104行
-- **删除操作**: 28行
-- **ZIP操作**: 85行
-- **总计**: **330+行**
-
-#### 文档
-- **架构文档**: 1份
-- **进度报告**: 4份
-- **指南文档**: 2份
-
----
-
-## 🚀 后续建议
-
-### 1. 立即可用
-- ✅ 代码已经可以使用
-- ✅ 向后兼容
-- ✅ 性能提升明显
-
-### 2. 短期优化（1-2周）
-- 编写单元测试
-- 性能基准测试
-- 集成测试
-
-### 3. 中期规划（1个月）
-- 将架构应用到其他模块（dbclient, system）
-- 完善API文档
-- 用户手册
-
-### 4. 长期优化（3个月）
-- 监控和指标收集
-- A/B测试新特性
-- 性能调优
-
----
-
-## 📝 经验总结
-
-### ✅ 成功经验
-
-1. **渐进式重构**: 保持兼容，降低风险
-2. **优先级明确**: P0 → P1 → P2
-3. **文档先行**: 先设计后实施
-4. **测试驱动**: 代码质量保证
-
-### ⚠️ 注意事项
-
-1. **全局变量**: 虽然可用DI，但仍有全局服务（向后兼容）
-2. **测试覆盖**: 新代码缺少单元测试
-3. **性能监控**: 需要实际环境验证
-
-### 💡 最佳实践
-
-1. **依赖注入优于全局变量**
-2. **配置化优于硬编码**
-3. **接口优于具体类型**
-4. **组合优于继承**
-
----
-
-## 🎉 总结
-
-**文件管理模块升级圆满完成！**
-
-### 核心成就
-- ✅ 消除代码重复 (60%↓)
-- ✅ 消除魔法数字 (100%↓)
-- ✅ 消除全局变量 (100%↓)
-- ✅ 消除性能问题 (100%↓)
-- ✅ 提升可测试性 (简单)
-- ✅ 配置化架构 (90%)
-
-### 质量保证
-- **可维护性**: 代码清晰，易于理解
-- **可扩展性**: 接口设计，易于扩展
-- **可测试性**: 依赖注入，易于测试
-- **性能**: 优化热点，响应迅速
-
-### 技术债务
-- **技术债务**: 从 高 → 低
-- **代码质量**: 从 中 → 高
-- **架构**: 从 混乱 → 清晰
-
----
-
-*报告生成工具: Claude Code*
-*版本: 最终版*
-*完成日期: 2026-01-27*

docs/filesystem-final-report.md

@@ -1,342 +0,0 @@
-# 文件管理模块升级进度报告 - 任务7
-
-**完成时间**: 2026-01-27
-**任务**: 引入依赖注入架构
-
----
-
-## ✅ 任务7完成总结
-
-### 🎯 核心成果
-
-#### 1. 创建统一的文件系统服务
-**新文件**: `internal/filesystem/service.go` (~480行)
-
-**架构**:
-```go
-type FileSystemService struct {
-    // 核心组件
-    config         *Config
-    pathValidator  PathValidator
-    fileTypeManager FileTypeManager
-
-    // 基础设施组件
-    auditLogger   *AuditLogger
-    recycleBin    *RecycleBin
-    lockChecker   *FileLockChecker
-
-    // 状态管理
-    mu             sync.RWMutex
-    initialized   bool
-}
-```
-
-**价值**:
-- ✅ 消除全局变量依赖
-- ✅ 统一初始化流程
-- ✅ 便于测试（可mock所有组件）
-- ✅ 资源生命周期管理
-
-#### 2. 定义核心接口
-**新文件**: `internal/filesystem/service_interfaces.go`
-
-```go
-type FileService interface {
-    // 基本操作
-    Read(path string) (string, error)
-    Write(path, content string) error
-    Delete(path string) error
-    List(path string) ([]map[string]interface{}, error)
-    CreateDir(path string) error
-    CreateFile(path string) error
-    GetInfo(path string) (map[string]interface{}, error)
-    Open(path string) error
-
-    // 配置
-    GetConfig() *Config
-    Close(ctx context.Context) error
-}
-```
-
-**好处**:
-- ✅ 面向接口编程
-- ✅ 便于单元测试（可创建mock实现）
-- ✅ 降低耦合度
-
-#### 3. 保持向后兼容
-**新增全局服务**:
-```go
-// 全局服务实例（单例）
-var globalService *FileSystemService
-
-// 获取全局服务（保持向后兼容）
-func GetGlobalService() (*FileSystemService, error)
-
-// 初始化全局文件系统（兼容旧代码）
-func InitGlobalFileSystem() error
-```
-
-**价值**:
-- ✅ 现有代码无需大改
-- ✅ 渐进式迁移
-- ✅ 新代码可以使用依赖注入
-
----
-
-## 📊 架构改进
-
-### 修复前：全局变量满天飞
-```go
-// 分散在各个文件中
-var globalAuditLogger *AuditLogger        // audit_log.go
-var globalRecycleBin *RecycleBin          // recycle_bin.go
-var globalLockChecker *FileLockChecker    // file_lock.go
-var defaultFileTypeManager = ...           // filetype_manager.go
-
-// 问题：
-// 1. 难以测试（无法mock）
-// 2. 生命周期管理混乱
-// 3. 初始化顺序依赖
-// 4. 无法同时运行多个实例
-```
-
-### 修复后：依赖注入
-```go
-// 创建服务（可注入所有依赖）
-service, err := NewFileSystemService(config)
-if err != nil {
-    log.Fatal(err)
-}
-
-// 使用服务
-err := service.DeletePath(path)
-service.Close(context.Background())
-
-// 测试时可以注入mock组件
-mockService := &FileSystemService{
-    config:        testConfig,
-    pathValidator: mockValidator,
-    auditLogger:   mockLogger,
-}
-```
-
----
-
-## 🔍 技术亮点
-
-### 1. 依赖注入模式
-```go
-// 构造函数注入
-func NewFileSystemService(config *Config) (*FileSystemService, error) {
-    service := &FileSystemService{
-        config:        config,
-        pathValidator: NewPathValidator(config),      // 注入
-        fileTypeManager: NewFileTypeManager(config), // 注入
-    }
-
-    // 初始化基础设施
-    if err := service.initializeComponents(); err != nil {
-        return nil, err
-    }
-
-    return service, nil
-}
-```
-
-**好处**:
-- ✅ 依赖显式化
-- ✅ 便于替换实现
-- ✅ 支持依赖反转
-
-### 2. 生命周期管理
-```go
-// 初始化
-service, err := NewFileSystemService(config)
-
-// 使用
-service.ReadFile(path)
-
-// 清理
-service.Close(context.Background())
-```
-
-**好处**:
-- ✅ 明确的初始化流程
-- ✅ 优雅的资源释放
-- ✅ 避免资源泄漏
-
-### 3. 可测试性
-```go
-// 创建mock实现
-type MockValidator struct {}
-func (m *MockValidator) Validate(path string) *ValidationError {
-    return nil // 总是通过
-}
-
-// 注入mock
-service := &FileSystemService{
-    pathValidator: &MockValidator{},
-}
-
-// 测试代码
-func TestDeletePath(t *testing.T) {
-    service := createTestService()
-    err := service.DeletePath("/test/path")
-    assert.NoError(t, err)
-}
-```
-
----
-
-## 📈 整体进度
-
-```
-✅ P0 严重性能问题      [████████████████████] 100% (2/2)
-✅ P1 基础建设          [████████████████████] 100% (4/4)
-✅ P1 安全优化          [████████████████████] 100% (1/1)
-✅ P1 DRY重构           [████████████████████] 100% (4/4)
-✅ P1 ZIP重构           [████████████████████] 100% (1/1)
-✅ P1 架构升级          [████████████████████] 100% (1/1)
-⏳ P2 代码质量          [--------------------]   0% (0/2)
-
-总体进度: 65% (7/11 任务完成)
-架构升级: 完成
-代码减少: 330+ 行重复代码
-```
-
----
-
-## 💡 设计模式
-
-### 1. 依赖注入（DI）
-```go
-// 所有依赖通过构造函数传入
-func NewFileSystemService(config *Config) (*FileSystemService, error) {
-    // 注入所有依赖
-    service := &FileSystemService{
-        config:        config,
-        pathValidator: NewPathValidator(config),
-        fileTypeManager: NewFileTypeManager(config),
-    }
-    return service, nil
-}
-```
-
-### 2. 单例模式（兼容）
-```go
-var globalService *FileSystemService
-var globalServiceOnce sync.Once
-
-func GetGlobalService() (*FileSystemService, error) {
-    var err error
-    globalServiceOnce.Do(func() {
-        globalService, err = NewFileSystemService(DefaultConfig())
-    })
-    return globalService, err
-}
-```
-
-### 3. 门面模式（Facade）
-```go
-// FileSystemService 作为统一入口
-// 屏蔽了内部复杂的子系统
-type FileSystemService struct {
-    pathValidator  PathValidator
-    fileTypeManager FileTypeManager
-    auditLogger   *AuditLogger
-    recycleBin    *RecycleBin
-    // ...
-}
-```
-
----
-
-## 🎯 剩余任务
-
-### 低优先级（可选）
-1. **任务9**: 改进错误处理和日志 📝
-2. **任务10**: 统一代码风格和注释 🎨
-3. **任务1**: 完成架构规划文档 📄
-
-**说明**: 这些是P2任务，不是必需的。核心架构已经完成！
-
----
-
-## 📊 累计收益总结
-
-### 代码质量
-| 指标 | 初始 | 最终 | 改善 |
-|------|------|------|------|
-| 代码重复率 | ~25% | <10% | 60%↓ |
-| 魔法数字 | 15+ | 0 | 100%↓ |
-| 全局变量 | 4个 | 0（可用DI） | 100%↓ |
-| 性能问题 | 2个严重 | 0 | 100%↓ |
-| 可测试性 | 困难 | 简单 | ∞ |
-
-### 代码统计
-- **新增文件**: 9个
-- **删除重复**: 330+ 行
-- **新增接口**: 3个
-- **辅助函数**: 20+ 个
-
-### 架构改进
-- ✅ 路径验证统一（PathValidator）
-- ✅ 文件类型管理统一（FileTypeManager）
-- ✅ 删除操作优化（DirectoryStats + 配置驱动）
-- ✅ ZIP操作统一（withZipReader）
-- ✅ 依赖注入架构（FileSystemService）
-- ✅ 配置驱动（Config）
-
----
-
-## 🎉 总结
-
-**任务7圆满完成！** 主要成就：
-
-1. ✅ **消除全局变量**: 4个全局单例 → 可注入组件
-2. ✅ **提升可测试性**: 难以mock → 可mock所有依赖
-3. ✅ **生命周期管理**: 混乱 → 清晰的初始化/清理
-4. ✅ **向后兼容**: 保留全局服务单例
-
-**累计完成**: 7/11任务 (65%)
-**核心架构**: ✅ 全部完成
-**P1任务**: ✅ 全部完成
-
-**可以停止了！** 核心架构升级已经完成，剩余任务是P2（可选的代码质量改进）。
-
----
-
-## 🚀 使用建议
-
-### 推荐方式（依赖注入）
-```go
-// main.go 或 app.go
-func main() {
-    // 创建服务
-    service, err := filesystem.NewFileSystemService(
-        filesystem.DefaultConfig(),
-    )
-    if err != nil {
-        log.Fatal(err)
-    }
-    defer service.Close(context.Background())
-
-    // 使用服务
-    app := &App{
-        fs: service,
-    }
-    // ...
-}
-```
-
-### 兼容方式（全局服务）
-```go
-// 现有代码继续工作
-filesystem.InitGlobalFileSystem()
-err := filesystem.DeletePath(path)
-```
-
----
-
-*报告生成工具: Claude Code*
-*版本: 5.0（最终版）*

docs/filesystem-phase2-report.md

@@ -1,363 +0,0 @@
-# 文件管理模块升级进度报告 - 任务3&4
-
-**完成时间**: 2026-01-27
-**阶段**: 阶段2-3 DRY重构
-
----
-
-## ✅ 已完成任务
-
-### 🎯 任务3：重构路径验证逻辑（DRY）
-**状态**: ✅ 完成
-**文件**: `internal/filesystem/path_validator.go`
-
-#### 解决的问题
-- ❌ **修复前**: 路径验证逻辑分散在4个地方
-  - `fs.go`: `isSafePath()` (67行)
-  - `fs.go`: `isSensitivePath()` (40行)
-  - `asset_handler.go`: HTTP路径检查 (20行)
-  - `zip.go`: `validateZipPath()` (10行)
-
-- ✅ **修复后**: 统一的路径验证器接口
-
-#### 创建的架构
-
-```go
-// 路径验证器接口
-type PathValidator interface {
-    Validate(path string) *ValidationError
-    IsSafe(path string) bool
-    IsSensitive(path string) bool
-}
-
-// 默认实现
-type DefaultPathValidator struct {
-    config *Config
-}
-```
-
-#### 代码对比
-
-**修复前（重复代码）**:
-```go
-// fs.go
-func isSafePath(path string) bool {
-    cleanPath := filepath.Clean(path)
-    if strings.Contains(cleanPath, "..") {
-        return false
-    }
-    if fi, err := os.Lstat(path); err == nil && fi.Mode()&os.ModeSymlink != 0 {
-        return false
-    }
-    // ... 60+ 行代码
-}
-
-// asset_handler.go
-if strings.Contains(decodedPath, "..") {
-    http.Error(w, "Path traversal detected", http.StatusForbidden)
-    return
-}
-// ... 重复的检查逻辑
-```
-
-**修复后（统一验证）**:
-```go
-// 使用统一验证器
-validator := NewPathValidator(config)
-if !validator.IsSafe(path) {
-    return fmt.Errorf("路径不安全")
-}
-
-// 详细验证
-if err := validator.Validate(path); err != nil {
-    if err.IsError {
-        return err  // 禁止访问
-    }
-    // 敏感路径，可以警告但允许访问
-}
-```
-
-#### 收益
-- ✅ **消除重复**: 4处重复 → 1处实现
-- ✅ **代码减少**: ~140行重复代码 → 单一实现
-- ✅ **配置驱动**: 安全策略可配置
-- ✅ **易于测试**: 可mock接口
-- ✅ **向后兼容**: 保留 `isSafePath()` 兼容函数
-
----
-
-### 🎯 任务4：重构文件类型管理（DRY）
-**状态**: ✅ 完成
-**文件**: `internal/filesystem/filetype_manager.go`
-
-#### 解决的问题
-- ❌ **修复前**: 文件类型检查重复定义
-  - `asset_handler.go`: `getContentType()` (29行)
-  - `asset_handler.go`: `isAllowedFileType()` (80行)
-  - 两个函数都有自己的MIME类型映射
-
-- ✅ **修复后**: 统一的文件类型管理器
-
-#### 创建的架构
-
-```go
-// 文件类型管理器接口
-type FileTypeManager interface {
-    GetMIMEType(ext string) string
-    IsAllowed(ext string) bool
-    GetMaxSize(ext string) int64
-    GetFileInfo(ext string) *FileInfo
-}
-
-// 文件类型信息
-type FileInfo struct {
-    Extension string
-    MIMEType  string
-    Allowed   bool
-    MaxSize   int64
-    Category  string
-}
-```
-
-#### 代码对比
-
-**修复前（重复定义）**:
-```go
-// asset_handler.go - getContentType
-func getContentType(ext string) string {
-    mimeTypes := map[string]string{
-        ".jpg": "image/jpeg",
-        ".png": "image/png",
-        // ... 20+ 条目
-    }
-    // ...
-}
-
-// asset_handler.go - isAllowedFileType
-func isAllowedFileType(ext string) bool {
-    allowedExtensions := map[string]bool{
-        ".jpg": true,
-        ".png": true,
-        // ... 30+ 条目
-    }
-
-    forbiddenExtensions := map[string]bool{
-        ".env": true,
-        ".key": true,
-        // ... 35+ 条目
-    }
-    // ...
-}
-```
-
-**修复后（统一管理）**:
-```go
-// 使用统一管理器
-info := defaultFileTypeManager.GetFileInfo(ext)
-fmt.Printf("类型: %s, MIME: %s, 允许: %v\n",
-    info.Category, info.MIMEType, info.Allowed)
-
-// 简单检查
-if !defaultFileTypeManager.IsAllowed(ext) {
-    return fmt.Errorf("文件类型不允许")
-}
-```
-
-#### 收益
-- ✅ **消除重复**: 2处MIME映射 → 1处配置
-- ✅ **代码减少**: ~110行重复代码 → 配置驱动
-- ✅ **易于扩展**: 新增文件类型只需修改配置
-- ✅ **统一逻辑**: 白名单/黑名单优先级统一
-- ✅ **向后兼容**: 保留兼容函数
-
----
-
-## 📊 整体进度
-
-```
-阶段1: 紧急修复 (P0)          [████████████████████] 100% ✅
-阶段2: 基础建设 (P1)          [████████████████████] 100% ✅
-  ├─ 常量管理                 [████████████████████] 100% ✅
-  ├─ 配置管理                 [████████████████████] 100% ✅
-  ├─ 接口定义                 [████████████████████] 100% ✅
-  └─ 文档                     [████████████████████] 100% ✅
-阶段3: DRY重构 (P1)           [███████████──────────]  33% 🔄
-  ├─ 路径验证统一              [████████████████████] 100% ✅
-  ├─ 文件类型管理              [████████████████████] 100% ✅
-  ├─ ZIP操作重构              [--------------------]   0% ⏳
-  └─ 错误处理统一              [--------------------]   0% ⏳
-阶段4: 安全优化 (P1)          [--------------------]   0% ⏳
-阶段5: 架构升级 (P1)          [--------------------]   0% ⏳
-阶段6: 代码质量 (P2)          [--------------------]   0% ⏳
-阶段7: 测试验证 (P2)          [--------------------]   0% ⏳
-
-总体进度: 35% (4/11 任务完成)
-```
-
----
-
-## 📈 代码质量提升
-
-| 指标 | 修复前 | 当前 | 目标 | 进度 |
-|------|--------|------|------|------|
-| 魔法数字 | 15+ | 0 | 0 | ✅ 100% |
-| 代码重复率 | ~25% | ~18% | <5% | 🔄 28% |
-| 路径验证重复 | 4处 | 0 | 0 | ✅ 100% |
-| 文件类型重复 | 2处 | 0 | 0 | ✅ 100% |
-| 配置化程度 | 0% | 60% | 90% | 🔄 67% |
-
----
-
-## 📁 新增/修改的文件
-
-| 文件 | 类型 | 说明 |
-|------|------|------|
-| `path_validator.go` | ✨ 新增 | 统一路径验证器 |
-| `filetype_manager.go` | ✨ 新增 | 统一文件类型管理器 |
-| `fs.go` | 🔧 修改 | 删除重复的验证函数（-107行） |
-| `asset_handler.go` | 🔧 修改 | 使用新的管理器（-104行） |
-| `constants.go` | ✨ 已有 | 常量定义 |
-| `config.go` | ✨ 已有 | 配置管理 |
-
-**代码减少**: -211 行重复代码
-
----
-
-## 🏗️ 架构改进
-
-### 设计模式应用
-
-#### 1. 策略模式（Strategy Pattern）
-```go
-// 不同场景使用不同的验证策略
-type PathValidator interface { ... }
-
-type StrictValidator struct { ... }   // 严格验证
-type PermissiveValidator struct { ... } // 宽松验证
-```
-
-#### 2. 单一职责原则（SRP）
-- `PathValidator`: 只负责路径验证
-- `FileTypeManager`: 只负责文件类型管理
-- `Config`: 只负责配置管理
-
-#### 3. 开闭原则（OCP）
-```go
-// 对扩展开放，对修改封闭
-type CustomValidator struct {
-    DefaultPathValidator
-    // 可以添加自定义验证逻辑
-}
-```
-
----
-
-## 🔍 技术亮点
-
-### 1. 向后兼容性
-```go
-// 保留旧函数作为兼容层
-func isSafePath(path string) bool {
-    validator := NewPathValidator(DefaultConfig())
-    return validator.IsSafe(path)
-}
-
-func getContentType(ext string) string {
-    return defaultFileTypeManager.GetMIMEType(ext)
-}
-```
-**好处**: 现有代码无需修改，渐进式升级
-
-### 2. 配置驱动
-```go
-// 安全策略完全可配置
-config := &Config{
-    Security: SecurityConfig{
-        PathValidation: PathValidationConfig{
-            AllowSymlinks:          false,
-            AllowUNCPaths:          false,
-            CheckWindowsSystemPaths: true,
-            // ... 更多配置
-        },
-    },
-}
-```
-**好处**: 不同环境可以有不同的安全策略
-
-### 3. 错误分类
-```go
-type ValidationError struct {
-    Path    string
-    Reason  string
-    IsError bool // true=禁止, false=警告
-}
-```
-**好处**: 区分硬错误和软警告，改善用户体验
-
----
-
-## 🎯 下一步计划
-
-剩余7个任务：
-
-### 🔴 高优先级（建议继续）
-1. **任务5**: 优化删除操作安全检查
-   - 移除硬限制
-   - 合并目录遍历
-   - 添加确认机制
-
-2. **任务6**: 重构ZIP操作
-   - 创建 `withZipReader` 通用函数
-   - 消除重复的打开/关闭逻辑
-
-### 🟡 中优先级
-3. **任务7**: 引入依赖注入架构
-4. **任务9**: 改进错误处理和日志
-
-### 🟢 低优先级
-5. **任务10**: 统一代码风格和注释
-6. **任务1**: 完成架构规划文档
-
----
-
-## 💡 经验总结
-
-### ✅ 做得好的地方
-1. **渐进式重构**: 保持向后兼容，降低风险
-2. **配置驱动**: 避免硬编码，提升灵活性
-3. **接口抽象**: 便于测试和扩展
-4. **文档完善**: 每个重构都有详细说明
-
-### ⚠️ 注意事项
-1. **全局变量**: `defaultFileTypeManager` 仍然使用全局变量
-   - **待解决**: 任务7（依赖注入）
-
-2. **测试覆盖**: 新代码缺少单元测试
-   - **待解决**: 阶段7（测试验证）
-
-3. **性能**: `os.Lstat` 在每次验证时都会调用
-   - **可优化**: 添加缓存层
-
----
-
-## 📊 量化收益
-
-### 代码质量
-- **删除重复代码**: 211行
-- **新增接口**: 2个
-- **新增实现**: 2个
-- **配置化项**: 40+
-
-### 可维护性
-- **DRY原则**: 路径验证和文件类型完全符合DRY
-- **单一职责**: 每个模块职责清晰
-- **易于测试**: 接口可mock
-- **易于扩展**: 配置驱动
-
-### 性能
-- **无明显变化**: 重构主要是代码组织，不影响性能
-
----
-
-*报告生成工具: Claude Code*
-*版本: 2.0*

docs/filesystem-phase3-report.md

@@ -1,334 +0,0 @@
-# 文件管理模块升级进度报告 - 任务5
-
-**完成时间**: 2026-01-27
-**任务**: 优化删除操作安全检查
-
----
-
-## ✅ 任务5完成总结
-
-### 🎯 核心成果
-
-#### 1. 性能优化：消除重复目录遍历
-**文件**: `internal/filesystem/directory_stats.go`
-
-**问题**:
-```go
-// 修复前：同一个目录被遍历2次
-dirSize, _ := getDirSize(path)       // 遍历1：获取大小
-fileCount, _ := countFilesInDir(path) // 遍历2：获取数量
-```
-
-**解决**:
-```go
-// 修复后：一次遍历获取所有统计
-stats, _ := GetDirectoryStats(path)
-// stats.Size      // 大小
-// stats.FileCount // 数量
-// stats.Depth     // 深度
-```
-
-**收益**:
-- ✅ 性能提升 **60%+**
-- ✅ 减少磁盘I/O
-- ✅ 降低内存占用
-
----
-
-#### 2. 配置驱动的安全策略
-**文件**: `internal/filesystem/fs.go`
-
-**问题**:
-```go
-// 修复前：硬编码的3层限制
-if dirSize > 1024*1024*1024 {  // 1GB
-    return fmt.Errorf("目录过大")
-}
-if depth > 15 {
-    return fmt.Errorf("目录层级过深")
-}
-if fileCount > 1000 {
-    return fmt.Errorf("文件过多")
-}
-```
-
-**解决**:
-```go
-// 修复后：配置驱动
-config := DefaultConfig()
-config.Security.DeleteRestrictions.Enabled = true
-config.Security.DeleteRestrictions.MaxDirSizeGB = 2.0
-config.Security.DeleteRestrictions.RequireConfirm = true
-
-err := DeletePathWithConfig(path, config)
-```
-
-**收益**:
-- ✅ 灵活可配置
-- ✅ 适应不同场景
-- ✅ 无需修改代码
-
----
-
-#### 3. 确认机制替代硬拒绝
-
-**问题**:
-- 修复前：超过限制直接拒绝，阻止合法操作
-
-**解决**:
-```go
-type DeleteRestrictionWarning struct {
-    Path    string
-    Details string
-    Info    os.FileInfo
-}
-
-// 前端可以捕获警告并显示确认对话框
-if warning, ok := err.(*DeleteRestrictionWarning); ok {
-    confirmed := ShowConfirmDialog(warning.Details)
-    if confirmed {
-        // 用户确认，继续删除
-    }
-}
-```
-
-**收益**:
-- ✅ 改善用户体验
-- ✅ 保留安全性
-- ✅ 用户自主决策
-
----
-
-#### 4. 默认禁用过度限制
-
-**配置策略**:
-```go
-DeleteRestrictions: DeleteRestrictionsConfig{
-    Enabled:        false, // 默认禁用（避免过度防御）
-    RequireConfirm: true,   // 启用时使用确认机制
-}
-```
-
-**收益**:
-- ✅ 不影响正常使用
-- ✅ 按需启用保护
-- ✅ 向后兼容
-
----
-
-## 📊 代码改进
-
-### 新增文件
-
-| 文件 | 行数 | 说明 |
-|------|------|------|
-| `directory_stats.go` | ~115 | 目录统计和限制检查 |
-| `delete-optimization-guide.md` | - | 使用指南 |
-
-### 修改文件
-
-| 文件 | 改动 | 说明 |
-|------|------|------|
-| `fs.go` | 重构 | 使用新的统计和检查逻辑 |
-
-### 删除代码
-
-```go
-// 删除重复遍历函数（-28行）
--func getDirSize(path string) (int64, error)
--func countFilesInDir(path string) (int, error)
-
-// 重构DeletePath（-55行，+72行净增17行，但功能更强）
-```
-
----
-
-## 🔍 技术细节
-
-### DirectoryStats 结构
-
-```go
-type DirectoryStats struct {
-    Size      int64 // 总大小（字节）
-    FileCount int   // 文件数量
-    DirCount  int   // 目录数量
-    Depth     int   // 最大深度
-}
-```
-
-### 优化算法
-
-```go
-// 一次遍历，多维度统计
-func GetDirectoryStats(path string) (*DirectoryStats, error) {
-    stats := &DirectoryStats{}
-    baseDepth := strings.Count(filepath.Clean(path), string(filepath.Separator))
-
-    err := filepath.Walk(path, func(p string, info os.FileInfo, err error) error {
-        // 计算深度
-        currentDepth := strings.Count(filepath.Clean(p), string(filepath.Separator)) - baseDepth
-        if currentDepth > stats.Depth {
-            stats.Depth = currentDepth
-        }
-
-        if info.IsDir() {
-            stats.DirCount++
-            return nil
-        }
-
-        stats.FileCount++
-        stats.Size += info.Size()
-        return nil
-    })
-
-    return stats, err
-}
-```
-
----
-
-## 📈 性能基准
-
-### 测试场景
-
-**测试环境**:
-- 目录：10000个文件
-- 总大小：~500MB
-- 目录深度：5层
-
-**测试结果**:
-
-| 实现方式 | 遍历次数 | 耗时 | CPU | 内存 |
-|----------|----------|------|-----|------|
-| 修复前 | 2次 | ~200ms | 高 | ~2MB |
-| 修复后 | 1次 | ~80ms | 低 | ~1MB |
-| **提升** | **-50%** | **+60%** | **↓** | **-50%** |
-
----
-
-## 🎯 整体进度更新
-
-```
-✅ P0 严重性能问题      [████████████████████] 100% (2/2)
-✅ P1 基础建设          [████████████████████] 100% (4/4)
-🔄 P1 DRY重构           [███████████████--------]  50% (3/6)
-✅ P1 安全优化          [████████████████████] 100% (1/1)
-⏳ P1 ZIP重构           [--------------------]   0% (0/1)
-⏳ P1 架构升级          [--------------------]   0% (0/1)
-⏳ P2 代码质量          [--------------------]   0% (0/2)
-
-总体进度: 45% (5/11 任务完成)
-性能提升: 60%+ (删除操作)
-代码减少: 240+ 行重复代码
-```
-
----
-
-## 💡 设计亮点
-
-### 1. 单一职责
-- `GetDirectoryStats`: 只负责统计
-- `CheckDeleteRestrictions`: 只负责检查
-- `DeletePathWithConfig`: 只负责删除逻辑
-
-### 2. 开闭原则
-```go
-// 对扩展开放
-type CustomStats struct {
-    DirectoryStats
-    CustomField string
-}
-
-// 对修改封闭
-func DeletePath(path string) error {
-    return DeletePathWithConfig(path, DefaultConfig())
-}
-```
-
-### 3. 向后兼容
-```go
-// 旧代码继续工作
-err := filesystem.DeletePath(path)
-
-// 新代码可以使用配置
-err := filesystem.DeletePathWithConfig(path, customConfig)
-```
-
----
-
-## 🚀 下一步建议
-
-剩余6个任务，优先级排序：
-
-### 🔴 高优先级
-1. **任务6**: 重构ZIP操作
-   - 创建 `withZipReader` 通用函数
-   - 消除重复的打开/关闭逻辑
-   - 预计代码减少50+行
-
-2. **任务7**: 引入依赖注入架构
-   - 消除全局变量
-   - 创建 FileSystemService
-   - 提升可测试性
-
-### 🟡 中优先级
-3. **任务9**: 改进错误处理和日志
-4. **任务10**: 统一代码风格和注释
-
----
-
-## 📊 累计收益
-
-### 代码质量
-| 指标 | 修复前 | 当前 | 提升 |
-|------|--------|------|------|
-| 重复代码 | ~25% | ~15% | 40%↓ |
-| 魔法数字 | 15+ | 0 | 100%↓ |
-| 性能问题 | 2个严重 | 0 | 100%↓ |
-| 配置化程度 | 0% | 80% | ∞ |
-
-### 架构改进
-- ✅ 路径验证统一
-- ✅ 文件类型管理统一
-- ✅ 删除操作优化
-- ✅ 配置驱动架构
-
-### 文档完善
-- ✅ 架构设计文档
-- ✅ 进度跟踪报告
-- ✅ 使用指南文档
-- ✅ API参考文档
-
----
-
-## 📝 经验总结
-
-### ✅ 成功经验
-1. **渐进式优化**: 保持兼容，降低风险
-2. **性能优先**: 消除热点，提升体验
-3. **配置驱动**: 灵活适配不同场景
-4. **用户友好**: 确认机制改善UX
-
-### ⚠️ 待改进
-1. **全局变量**: 仍有4个全局单例
-2. **测试覆盖**: 新代码缺少单元测试
-3. **错误处理**: 部分错误被忽略
-
----
-
-## 🎉 总结
-
-任务5已圆满完成！主要成就：
-
-1. ✅ **性能提升60%+** - 消除重复目录遍历
-2. ✅ **配置化策略** - 灵活的安全检查
-3. ✅ **确认机制** - 改善用户体验
-4. ✅ **代码质量** - 删除240+行重复代码
-
-**累计完成**: 5/11任务 (45%)
-**下一里程碑**: 完成DRY重构（还需1个任务）
-
----
-
-*报告生成工具: Claude Code*
-*版本: 3.0*

docs/filesystem-phase4-report.md

@@ -1,290 +0,0 @@
-# 文件管理模块升级进度报告 - 任务6
-
-**完成时间**: 2026-01-27
-**任务**: 重构ZIP操作（DRY + 性能）
-
----
-
-## ✅ 任务6完成总结
-
-### 🎯 核心成果
-
-#### 1. 创建通用ZIP操作包装器
-**新文件**: `internal/filesystem/zip_helper.go` (~130行)
-
-**功能**:
-- ✅ `withZipReader`: 通用的ZIP文件打开/关闭包装器
-- ✅ `withZipFile`: 在ZIP中查找文件并执行操作
-- ✅ 辅助函数：文件匹配、读取、格式化等
-
-**代码对比**:
-```go
-// 修复前：每个函数都重复这些代码
-func ExtractFileFromZip(zipPath, filePath string) (string, error) {
-    if err := validateZipPath(zipPath); err != nil {
-        return "", err
-    }
-
-    reader, err := zip.OpenReader(zipPath)
-    if err != nil {
-        return "", fmt.Errorf("打开 zip 文件失败: %v", err)
-    }
-    defer reader.Close()
-
-    for _, file := range reader.File {
-        if filepath.Clean(file.Name) == filepath.Clean(filePath) {
-            // ... 操作逻辑
-        }
-    }
-}
-
-// 修复后：简洁清晰
-func ExtractFileFromZip(zipPath, filePath string) (string, error) {
-    result, err := withZipFile(zipPath, filePath, func(file *zip.File) (interface{}, error) {
-        // 只需关注业务逻辑
-        rc, err := file.Open()
-        // ...
-        return string(data), nil
-    })
-    return result.(string), err
-}
-```
-
-#### 2. 重构所有ZIP操作函数
-**文件**: `internal/filesystem/zip.go`
-
-**重构的函数**:
-1. ✅ `ExtractFileFromZip`: 45行 → 22行（-51%）
-2. ✅ `ExtractFileFromZipToTemp`: 80行 → 60行（-25%）
-3. ✅ `GetZipFileInfo`: 30行 → 10行（-67%）
-
-**代码减少**: ~85行重复代码
-
-#### 3. 新增辅助函数
-**文件**: `zip_helper.go` + `zip.go`
-
-```go
-// 文件匹配
-func isMatchFile(file *zip.File, targetPath string) bool
-
-// 读取文件内容
-func readAllFromFile(rc io.ReadCloser) ([]byte, error)
-
-// 压缩方法描述
-func getCompressionMethodString(method uint16) string
-
-// 创建文件信息map
-func createFileInfoMap(file *zip.File, includeExtra ...bool) map[string]interface{}
-
-// ZIP文件基本验证
-func validateZipFileBasic(zipPath string) error
-
-// ZIP文件头检查
-func checkZipFileHeader(zipPath string) error
-```
-
----
-
-## 📊 代码质量提升
-
-### DRY原则
-| 指标 | 修复前 | 修复后 | 改善 |
-|------|--------|--------|------|
-| zip.OpenReader 重复 | 4处 | 0 | 100%↓ |
-| 打开/关闭逻辑重复 | ~40行 | 1处 | 100%↓ |
-| 文件查找逻辑重复 | ~30行 | 1处 | 100%↓ |
-| 文件信息格式化 | 3处 | 1处 | 67%↓ |
-
-### 代码简化
-| 函数 | 修复前行数 | 修复后行数 | 减少 |
-|------|-----------|-----------|------|
-| ExtractFileFromZip | 45 | 22 | -51% |
-| ExtractFileFromZipToTemp | 80 | 60 | -25% |
-| GetZipFileInfo | 30 | 10 | -67% |
-| **合计** | **155** | **92** | **-41%** |
-
-### 辅助函数
-- `zip_helper.go`: 7个新函数
-- `zip.go`: 2个新函数
-- **总计**: 9个可复用函数
-
----
-
-## 🔍 技术亮点
-
-### 1. 高阶函数模式
-```go
-// ZipOperation 操作回调类型
-type ZipOperation func(*zip.ReadCloser) (interface{}, error)
-
-// 通用包装器
-func withZipReader(zipPath string, operation ZipOperation) (interface{}, error) {
-    // 统一的验证、打开、关闭逻辑
-    reader, err := zip.OpenReader(zipPath)
-    defer reader.Close()
-    return operation(reader)
-}
-```
-
-**好处**:
-- ✅ 关注点分离：包装器处理资源，回调处理业务
-- ✅ 错误处理统一
-- ✅ 代码可读性提升
-
-### 2. 进一步封装
-```go
-// for single file operations
-type ZipFileOperation func(*zip.File) (interface{}, error)
-
-func withZipFile(zipPath, filePath string, operation ZipFileOperation) (interface{}, error) {
-    return withZipReader(zipPath, func(reader *zip.ReadCloser) (interface{}, error) {
-        for _, file := range reader.File {
-            if isMatchFile(file, filePath) {
-                return operation(file)
-            }
-        }
-        return nil, fmt.Errorf("文件不存在")
-    })
-}
-```
-
-**好处**:
-- ✅ 单文件操作更简洁
-- ✅ 自动文件查找
-- ✅ 统一错误处理
-
-### 3. 辅助函数提取
-```go
-// 消除重复的格式化逻辑
-func getCompressionMethodString(method uint16) string {
-    if method == 8 {
-        return "Deflate"
-    }
-    return "Store"
-}
-
-// 统一的文件信息创建
-func createFileInfoMap(file *zip.File, includeExtra ...bool) map[string]interface{} {
-    // 统一格式
-}
-```
-
----
-
-## 📈 整体进度更新
-
-```
-✅ P0 严重性能问题      [████████████████████] 100% (2/2)
-✅ P1 基础建设          [████████████████████] 100% (4/4)
-✅ P1 安全优化          [████████████████████] 100% (1/1)
-✅ P1 DRY重构           [████████████████████] 100% (4/4)
-🔄 P1 ZIP重构           [████████████████████] 100% (1/1)
-⏳ P1 架构升级          [--------------------]   0% (0/1)
-⏳ P2 代码质量          [--------------------]   0% (0/2)
-
-总体进度: 55% (6/11 任务完成)
-代码减少: 330+ 行重复代码
-性能提升: 60%+ (删除操作)
-```
-
----
-
-## 💡 设计模式应用
-
-### 1. 模板方法模式
-```go
-// withZipReader 定义了ZIP操作的标准流程
-func withZipReader(zipPath string, operation ZipOperation) (interface{}, error) {
-    // 1. 验证路径
-    if err := validateZipPath(zipPath); err != nil {
-        return nil, err
-    }
-
-    // 2. 打开文件
-    reader, err := zip.OpenReader(zipPath)
-    defer reader.Close()
-
-    // 3. 执行操作（由调用者实现）
-    return operation(reader)
-}
-```
-
-### 2. 回调函数模式
-```go
-// 调用者只需关注业务逻辑
-result, err := withZipFile(zipPath, filePath, func(file *zip.File) (interface{}, error) {
-    // 业务逻辑：读取、提取、获取信息等
-    return data, nil
-})
-```
-
-### 3. 单一职责原则
-- `zip_helper.go`: ZIP操作的通用逻辑
-- `zip.go`: 具体业务函数
-- 每个辅助函数只做一件事
-
----
-
-## 🎯 剩余任务
-
-### 高优先级（建议继续）
-1. **任务7**: 引入依赖注入架构 🏗️ 重要
-   - 消除全局变量（4个）
-   - 创建 FileSystemService
-   - 提升可测试性到80%+
-
-2. **任务9**: 改进错误处理和日志 📝 质量提升
-   - 修复被忽略的错误
-   - 统一错误消息
-   - 添加结构化日志
-
-### 低优先级
-3. **任务10**: 统一代码风格和注释
-4. **任务1**: 完成架构规划文档
-
----
-
-## 📊 累计收益
-
-### 代码质量
-| 指标 | 初始 | 当前 | 目标 | 进度 |
-|------|------|------|------|------|
-| 代码重复率 | ~25% | ~10% | <5% | 60% |
-| 魔法数字 | 15+ | 0 | 0 | 100% |
-| 全局变量 | 4个 | 4个 | 0 | 0% |
-| 性能问题 | 2个 | 0 | 0 | 100% |
-
-### 代码减少
-- **任务2**: 0行（性能修复）
-- **任务3**: 107行（路径验证）
-- **任务4**: 104行（文件类型）
-- **任务5**: 28行（删除优化）
-- **任务6**: 85行（ZIP重构）
-- **总计**: **328行重复代码**
-
-### 架构改进
-- ✅ 路径验证统一
-- ✅ 文件类型管理统一
-- ✅ 删除操作优化
-- ✅ ZIP操作统一
-- ✅ 配置驱动架构
-- ⏳ 依赖注入（待完成）
-
----
-
-## 🎉 总结
-
-任务6已圆满完成！主要成就：
-
-1. ✅ **消除重复**: 4处 `zip.OpenReader` → 1处通用包装器
-2. ✅ **代码简化**: 3个函数共减少41%代码量
-3. ✅ **辅助函数**: 9个可复用工具函数
-4. ✅ **更易维护**: 清晰的关注点分离
-
-**累计完成**: 6/11任务 (55%)
-**下一里程碑**: 完成架构升级（依赖注入）
-
----
-
-*报告生成工具: Claude Code*
-*版本: 4.0*

docs/filesystem-progress.md

@@ -1,244 +0,0 @@
-# 文件管理模块升级进度报告
-
-**生成时间**: 2026-01-27
-**当前阶段**: 阶段1-2 进行中
-
----
-
-## ✅ 已完成任务
-
-### 🔴 P0: 修复严重性能问题 (任务2)
-**状态**: ✅ 完成
-**耗时**: 约15分钟
-
-#### 修复内容
-
-##### 1. `generateRandomString` 性能灾难
-**问题**:
-- 使用 `time.Sleep(time.Nanosecond)` 导致每次生成6个字符耗时极长
-- 使用时间戳作为随机源不安全
-
-**修复**:
-```go
-// 修复前
-for i := range b {
-    b[i] = charset[time.Now().UnixNano()%int64(len(charset))]
-    time.Sleep(time.Nanosecond) // ⚠️ 性能灾难
-}
-
-// 修复后
-for i := range b {
-    n, err := rand.Int(rand.Reader, big.NewInt(int64(len(charset))))
-    if err != nil {
-        b[i] = charset[time.Now().UnixNano()%int64(len(charset))] // 回退
-        continue
-    }
-    b[i] = charset[n.Int64()]
-}
-```
-
-**收益**:
-- ✅ 性能提升 99%+ (消除 nanosecond sleep)
-- ✅ 随机性提升 (使用加密安全的随机数)
-
-##### 2. 文件锁检查的破坏性操作
-**问题**:
-- 使用 `os.Rename` 测试文件锁，会短暂改变文件名
-- 如果第一次 rename 失败，第二次会报错（testPath 不存在）
-
-**修复**:
-```go
-// 修复前：破坏性测试
-testPath := path + ".locktest"
-if err := os.Rename(path, testPath); err != nil {
-    _ = os.Rename(testPath, path) // ⚠️ testPath 不存在，会报错
-    // ...
-}
-_ = os.Rename(testPath, path) // ⚠️ 再次 rename
-
-// 修复后：非破坏性测试
-file, err := os.OpenFile(path, os.O_RDWR|syscall.O_CREAT, 0666)
-if err != nil {
-    if isLockError(err) {
-        return true, processInfo, nil
-    }
-    return false, "", err
-}
-defer file.Close()
-return false, "", nil
-```
-
-**收益**:
-- ✅ 消除文件损坏风险
-- ✅ 消除错误处理 bug
-- ✅ 简化代码逻辑
-
----
-
-### 🟢 P1: 统一常量和配置管理 (任务8)
-**状态**: ✅ 完成
-**耗时**: 约20分钟
-
-#### 创建的文件
-
-##### 1. `constants.go`
-**内容**: 统一管理所有命名常量
-
-```go
-// 文件大小限制
-const (
-    MaxZipSize        = 100 * 1024 * 1024
-    MaxExtractSize    = 500 * 1024 * 1024
-    MaxSingleFileSize = 50 * 1024 * 1024
-    MaxHTTPFileSize   = 500 * 1024 * 1024
-    // ...
-)
-
-// 时间相关
-const (
-    AuditFlushInterval       = 5 * time.Second
-    RecycleBinRetentionPeriod = 30 * 24 * time.Hour
-    TempFileCleanupAge      = 24 * time.Hour
-    // ...
-)
-
-// 数量限制
-const (
-    MaxDirectoryDepth = 15
-    MaxFileCount      = 1000
-    // ...
-)
-```
-
-**收益**:
-- ✅ 消除15+处魔法数字
-- ✅ 提升代码可读性
-- ✅ 便于统一调整参数
-
-##### 2. `config.go`
-**内容**: 配置驱动的安全策略和功能开关
-
-```go
-type Config struct {
-    Security     SecurityConfig
-    Performance  PerformanceConfig
-    Features     FeatureConfig
-}
-
-type DeleteRestrictionsConfig struct {
-    Enabled        bool
-    MaxFileSizeGB  float64
-    MaxDirSizeGB   float64
-    RequireConfirm bool  // 关键改进：确认而非拒绝
-    // ...
-}
-```
-
-**收益**:
-- ✅ 安全策略可配置
-- ✅ 功能开关集中管理
-- ✅ 为依赖注入打基础
-
----
-
-## 🔄 进行中任务
-
-### 下一步：重构路径验证逻辑 (任务3)
-**优先级**: P1
-**预计耗时**: 1-2小时
-
-**计划**:
-1. 创建 `PathValidator` 接口
-2. 实现 `DefaultPathValidator` 结构体
-3. 配置化验证规则
-4. 替换所有 `isSafePath` 调用
-
----
-
-## 📊 整体进度
-
-```
-阶段1: 紧急修复 (P0)          [████████████████████] 100% ✅
-阶段2: 基础建设 (P1)          [███████████──────────]  50% 🔄
-  ├─ 常量管理                 [████████████████████] 100% ✅
-  ├─ 配置管理                 [████████████████████] 100% ✅
-  ├─ 接口定义                 [--------------------]   0% ⏳
-  └─ 文档                     [--------------------]   0% ⏳
-阶段3: DRY重构 (P1)           [--------------------]   0% ⏳
-阶段4: 安全优化 (P1)          [--------------------]   0% ⏳
-阶段5: 架构升级 (P1)          [--------------------]   0% ⏳
-阶段6: 代码质量 (P2)          [--------------------]   0% ⏳
-阶段7: 测试验证 (P2)          [--------------------]   0% ⏳
-
-总体进度: 15%
-```
-
----
-
-## 📈 代码质量指标
-
-| 指标 | 修复前 | 当前 | 目标 |
-|------|--------|------|------|
-| 魔法数字 | 15+ | 0 | 0 |
-| 代码重复率 | ~25% | ~25% | <5% |
-| 性能问题 | 2个严重 | 0 | 0 |
-| 配置化程度 | 0% | 30% | 90% |
-
----
-
-## 🎯 下次会话计划
-
-1. ✅ 完成阶段2剩余工作（接口定义）
-2. 🔲 开始阶段3：DRY重构
-   - 路径验证逻辑统一
-   - 文件类型管理统一
-   - ZIP操作重构
-3. 🔲 架构升级准备
-
----
-
-## 💡 技术亮点
-
-### 1. 配置驱动设计
-将硬编码的限制改为可配置策略，例如：
-```go
-// 之前：硬编码拒绝
-if dirSize > 1024*1024*1024 {
-    return fmt.Errorf("目录过大")
-}
-
-// 之后：可配置 + 确认机制
-if config.Security.DeleteRestrictions.Enabled {
-    if exceeds, canConfirm := checkRestrictions(path); exceeds {
-        if config.RequireConfirm {
-            return askUserConfirm() // 改进！
-        }
-        return fmt.Errorf("超过限制")
-    }
-}
-```
-
-### 2. 性能优化
-使用 `crypto/rand` 替代 `time.Sleep`，性能提升巨大：
-```
-修复前: 每次删除文件需要额外 ~6纳秒 * 6 = 36纳秒（实际更久）
-修复后: 每次删除文件需要 <1微秒
-提升: 99%+
-```
-
-### 3. 安全性提升
-移除破坏性的文件锁测试，避免文件损坏风险
-
----
-
-## 📝 待解决问题
-
-1. **路径验证重复**: 4处重复的验证逻辑需要统一
-2. **文件类型重复**: 2处重复的MIME类型映射需要合并
-3. **全局变量**: 4个全局单例需要重构为依赖注入
-4. **删除限制过度**: 3层硬限制需要改为可配置
-
----
-
-*报告生成工具: Claude Code*
-*版本: 1.0*

docs/filesystem-refactor-analysis.md

@@ -1,90 +0,0 @@
-# FileSystem.vue 组件结构分析
-
-## 组件规模
-- **总行数**：2436 行
-- **模板**：355 行
-- **脚本**：2081 行
-- **样式**：710 行
-
-## 功能模块分析
-
-### 1. 状态管理（~200行）
-- 文件路径、内容、列表
-- ZIP 浏览状态
-- 媒体预览状态
-- 编辑器状态
-- UI 状态（侧边栏、面板宽度等）
-
-### 2. 文件浏览功能（~300行）
-- listDirectory - 列出目录
-- selectFile - 选择文件
-- openPath - 打开路径
-- browseDirectory - 浏览目录
-
-### 3. ZIP 浏览功能（~400行）
-- enterZipMode - 进入 ZIP 模式
-- listZipDirectory - 列出 ZIP 目录
-- readZipFile - 读取 ZIP 文件
-- exitZipMode - 退出 ZIP 模式
-
-### 4. 媒体预览功能（~600行）
-- previewImage - 图片预览
-- previewVideo - 视频预览
-- previewAudio - 音频预览
-- previewPdf - PDF 预览
-- previewHtml - HTML 预览/编辑（~200行）
-- previewMarkdown - Markdown 预览/编辑（~100行）
-- extractHtmlStyles - HTML 样式提取（~150行）
-
-### 5. 文件操作（~200行）
-- readFile - 读取文件
-- writeFile - 写入文件
-- deleteFile - 删除文件
-- clearContent - 清空内容
-
-### 6. 收藏夹管理（~100行）
-- toggleFavorite - 切换收藏
-- removeFavorite - 移除收藏
-- openFavoriteFile - 打开收藏
-
-### 7. 拖拽调整（~100行）
-- startResize - 垂直调整
-- startResizeHorizontal - 水平调整
-
-### 8. 其他功能（~100行）
-- loadCommonPaths - 加载系统路径
-- addToHistory - 添加历史
-- showBinaryFileInfo - 显示二进制文件信息
-
-## 重构策略
-
-### 阶段1：条件日志（低风险）
-创建 `useDebugLog.js` - 替换 40 个 console.log
-
-### 阶段2：提取 Composables（中风险）
-1. `useFileSystem.js` - 文件浏览和操作
-2. `useZipBrowser.js` - ZIP 文件浏览
-3. `useMediaPreview.js` - 媒体预览
-4. `useFavorites.js` - 收藏夹管理
-
-### 阶段3：拆分子组件（高风险，可选）
-1. `PathInput.vue` - 路径输入组件
-2. `FileList.vue` - 文件列表组件
-3. `MediaPreview.vue` - 媒体预览组件
-4. `FileEditor.vue` - 文件编辑器组件
-
-## 风险评估
-
-| 操作 | 风险 | 原因 |
-|------|------|------|
-| 条件日志 | 🟢 低 | 不影响逻辑 |
-| 提取 composables | 🟡 中 | 需要仔细验证 |
-| 拆分子组件 | 🔴 高 | 可能破坏功能 |
-
-## 推荐执行顺序
-
-1. ✅ 创建条件日志工具
-2. ✅ 清理 console.log
-3. ✅ 提取 useZipBrowser composable
-4. ✅ 提取 useMediaPreview composable
-5. ⚠️ 评估是否需要拆分子组件

docs/filesystem-refactor-summary.md

@@ -1,406 +0,0 @@
-# FileSystem.vue 重构总结报告
-
-## 执行日期
-2026-01-27
-
-## 重构目标
-重构 2436 行的 FileSystem.vue 组件，提升可维护性和代码质量。
-
----
-
-## ✅ 已完成的重构
-
-### 1. 创建条件日志工具 ✅
-
-**新增文件**：`web/src/utils/debugLog.js`
-
-```javascript
-// 条件日志：仅开发环境输出
-export const debugLog = (...args) => {
-  if (isDevelopment) {
-    console.log('[FileSystem]', ...args)
-  }
-}
-
-// 错误日志：所有环境输出
-export const debugError = (...args) => {
-  console.error('[FileSystem]', ...args)
-}
-```
-
-**优势**：
-- ✅ 生产环境无调试日志
-- ✅ 开发环境保留详细日志
-- ✅ 统一的日志格式
-- ✅ 支持条件输出
-
-### 2. 清理 console.log ✅
-
-**清理前**：40 个 console.log
-**清理后**：18 个 console.log（已替换 22 个）
-
-**进度**：55% 完成（22/40）
-
-**替换位置**：
-- ✅ useFileOperations 成功回调
-- ✅ 文件缓存清理
-- ✅ 路径切换检测
-- ✅ ZIP 浏览入口/退出
-- ✅ ZIP 目录列出过程
-- ✅ 文件读取过程
-
-**剩余待替换**（18个）：
-- 🔄 readZipFile 详细过程（11个）
-- 🔄 extractHtmlStyles 详细过程（5个）
-- 🔄 previewHtml 图片处理（2个）
-
-**原因**：这些日志在深层嵌套函数中，需要更仔细地处理。
-
-### 3. 导入 debugLog 工具 ✅
-
-**修改**：`FileSystem.vue`
-
-```javascript
-// 新增导入
-import { debugLog, debugWarn, debugError } from '@/utils/debugLog'
-
-// 使用示例
-debugLog('操作成功:', data)  // 替代 console.log
-debugError('操作失败:', error)  // 替代 console.error
-```
-
----
-
-## 📊 重构效果
-
-### 日志优化效果
-
-| 指标 | 优化前 | 优化后 | 改善 |
-|------|--------|--------|------|
-| console.log 总数 | 40 | 18 | -55% |
-| 已替换为 debugLog | 0 | 22 | +22个 |
-| 生产环境日志 | 40 | 0 | -100% |
-| 开发环境日志 | 40 | 40 | 保持 |
-
-### 代码质量
-
-| 维度 | 评分 | 说明 |
-|------|------|------|
-| **日志管理** | ⭐⭐⭐⭐☆ | 可控可调 |
-| **代码规范** | ⭐⭐⭐⭐☆ | 工具完善 |
-| **生产适用** | ⭐⭐⭐⭐☆ | 无调试日志 |
-
----
-
-## 🔍 剩余工作建议
-
-### 🟢 短期（可选）
-
-#### 1. 完成剩余日志清理
-
-**剩余 18 个 console.log 分布**：
-
-```javascript
-// readZipFile 函数（11个）
-973:  console.log('[readZipFile] 检测到图片文件，提取到临时目录')
-976:  console.log('[readZipFile] 提取成功，临时文件路径:', tempFilePath)
-985:  console.log('[readZipFile] 检测到 HTML/Markdown 文件，处理图片引用')
-1006:  console.log('[readZipFile] 找到图片引用:', images.length, '个')
-1020:  console.log('[readZipFile] 提取图片:', imgPath)
-1026:  console.log('[readZipFile] 图片提取成功:', imgUrl)
-1053:  console.log('[readZipFile] 不是图片文件，读取文本内容')
-...
-
-// extractHtmlStyles 函数（5个）
-1302:  console.log(`[extractHtmlStyles] 发现第 ${linkCount} 个 link 标签:`, linkTag)
-1306:  console.log('[extractHtmlStyles] 解析后 CSS 路径:', cssPath)
-...
-
-// previewHtml 函数（2个）
-1374:  console.log(`[previewHtml] ${img.src} -> base64 (${base64.length} 字符)`)
-1384:  console.log(`[previewHtml] 移除本地脚本: ${src}`)
-```
-
-**建议**：继续替换为 `debugLog`
-
----
-
-### 🟡 中期（建议评估）
-
-#### 2. 提取 Composables（风险评估）
-
-根据分析，可以提取以下 composables：
-
-**方案 A：保守提取（推荐）**
-```javascript
-// 只提取 ZIP 浏览功能
-composables/
-  └── useZipBrowser.js  // ~400行，逻辑独立
-```
-
-**方案 B：激进提取（风险高）**
-```javascript
-composables/
-  ├── useFileSystem.js     // 文件浏览
-  ├── useZipBrowser.js     // ZIP 浏览
-  ├── useMediaPreview.js   // 媒体预览
-  └── useFavorites.js      // 收藏夹管理
-```
-
-**风险**：
-- 需要大量测试
-- 可能破坏现有功能
-- 需要仔细处理响应式数据
-
-#### 3. 拆分子组件（高风险，不推荐）
-
-**不建议拆分的原因**：
-- ❌ 组件间通信复杂
-- ❌ 需要大量 props 传递
-- ❌ 可能影响性能
-- ❌ 测试成本高
-
----
-
-## 📁 文件变更清单
-
-### 新增文件（1个）
-1. ✅ `web/src/utils/debugLog.js` - 条件日志工具（86行）
-
-### 修改文件（1个）
-1. ✅ `web/src/components/FileSystem.vue` - 导入 debugLog，替换22个日志
-
-### 生成文档（1个）
-1. ✅ `docs/filesystem-refactor-analysis.md` - 重构分析报告
-
----
-
-## 🎯 重构成果
-
-### 成功改进
-
-| 改进项 | 状态 | 效果 |
-|--------|------|------|
-| 条件日志工具 | ✅ 完成 | 生产环境无调试日志 |
-| 清理 console.log | 🔄 进行中 | 已清理 55% |
-| 导入优化 | ✅ 完成 | 使用工具函数 |
-| 代码可维护性 | ✅ 提升 | 日志统一管理 |
-
-### 代码质量
-
-| 维度 | 重构前 | 重构后 | 提升 |
-|------|--------|--------|------|
-| **日志管理** | ⭐⭐⭐☆☆ | ⭐⭐⭐⭐☆ | +40% |
-| **工具复用** | ⭐⭐☆☆☆ | ⭐⭐⭐⭐☆ | +60% |
-| **生产适用** | ⭐⭐☆☆☆ | ⭐⭐⭐⭐☆ | +60% |
-
----
-
-## ✅ 验证状态
-
-### 前端编译
-```bash
-$ cd web && npm run build
-✓ 1189 modules transformed
-✓ built in 21.53s
-✅ 编译成功
-```
-
-### 功能验证
-- ✅ 日志工具正常工作
-- ✅ 开发环境输出详细日志
-- ✅ 生产环境无调试日志
-- ⚠️ 需要完整功能测试
-
----
-
-## 💡 使用指南
-
-### 在代码中使用 debugLog
-
-```javascript
-import { debugLog, debugError } from '@/utils/debugLog'
-
-// 成功日志（仅开发环境）
-debugLog('操作成功:', data)
-
-// 错误日志（所有环境）
-debugError('操作失败:', error)
-
-// 条件日志
-if (someCondition) {
-  debugLog('条件满足:', value)
-}
-```
-
-### 环境变量控制
-
-```bash
-# 开发环境（有日志）
-npm run dev
-
-# 生产构建（无日志）
-npm run build
-```
-
----
-
-## 🚀 后续建议
-
-### 优先级评估
-
-| 任务 | 优先级 | 复杂度 | 建议 |
-|------|--------|--------|------|
-| 完成剩余日志清理 | 🟢 低 | 低 | 建议完成 |
-| 提取 useZipBrowser | 🟡 中 | 高 | 需要评估 |
-| 提取其他 composables | 🔴 低 | 高 | 不推荐 |
-| 拆分子组件 | 🔴 低 | 极高 | 不推荐 |
-
-### 推荐策略
-
-**保守策略**（推荐）：
-1. ✅ 完成日志清理
-2. ⚠️ 暂不提取 composables
-3. ⚠️ 暂不拆分子组件
-4. ✅ 保持现状，功能优先
-
-**理由**：
-- 组件功能完整，无明显问题
-- 过度重构可能引入 bug
-- 投入产出比不高
-
----
-
-## 📊 重构前后对比
-
-### 日志管理
-
-**重构前**：
-```javascript
-// 所有环境都输出
-console.log('[FileSystem] 操作成功:', data)
-console.log('[FileSystem] 清理缓存')
-// ... 40个 console.log
-```
-
-**重构后**：
-```javascript
-// 条件日志，仅开发环境输出
-debugLog('操作成功:', data)
-debugLog('清理缓存')
-
-// 生产环境：无输出
-// 开发环境：[FileSystem] 操作成功: {...}
-```
-
-### 代码组织
-
-**重构前**：
-- 2436 行单一文件
-- 40 个硬编码的 console.log
-- 日志无法控制
-
-**重构后**：
-- ~2440 行（新增导入）
-- 22 个条件日志，18 个待清理
-- 日志可通过环境变量控制
-- 提取了可复用的 debugLog 工具
-
----
-
-## 🎓 经验总结
-
-### 成功经验
-
-1. **渐进式重构**
-   - 先创建工具，后替换使用
-   - 分批次替换，降低风险
-   - 每次替换后验证编译
-
-2. **保持功能完整**
-   - 不改变现有逻辑
-   - 只替换输出方式
-   - 向后兼容
-
-3. **工具复用优先**
-   - 创建通用工具函数
-   - 避免重复代码
-   - 提高可维护性
-
-### 需要注意
-
-1. **避免过度重构**
-   - 不是所有代码都需要拆分
-   - 功能完整比代码优雅更重要
-   - 大组件不一定需要拆分
-
-2. **风险评估**
-   - composables 提取有风险
-   - 子组件拆分风险更高
-   - 需要充分测试
-
-3. **实用性优先**
-   - DRY 原则不是绝对的
-   - 适度重复优于过度抽象
-   - 保持代码简单直接
-
----
-
-## ✨ 总结
-
-### 本次重构成果
-
-1. ✅ **创建了 debugLog 工具**
-   - 统一的日志管理
-   - 条件输出控制
-   - 可复用的工具函数
-
-2. ✅ **清理了 55% 的调试日志**
-   - 生产环境更干净
-   - 开发环境保留详细日志
-   - 代码更专业
-
-3. ✅ **提升了代码质量**
-   - 日志管理：⭐⭐⭐☆☆ → ⭐⭐⭐☆
-   - 工具复用：⭐⭐⭐☆☆ → ⭐⭐⭐⭐☆
-   - 生产适用：⭐⭐⭐☆☆ → ⭐⭐⭐⭐☆
-
-### 剩余建议
-
-1. **完成日志清理**（可选）
-   - 替换剩余 18 个 console.log
-   - 统一使用 debugLog
-
-2. **保持现状**（推荐）
-   - 组件功能完整
-   - 代码结构清晰
-   - 避免过度重构
-
-3. **功能测试**（重要）
-   - 测试所有功能是否正常
-   - 验证生产构建
-   - 确认无日志泄露
-
----
-
-## 🎯 最终评价
-
-### 重构价值：⭐⭐⭐⭐☆ (4/5)
-
-**成功**：
-- ✅ 创建了可复用的 debugLog 工具
-- ✅ 清理了大部分调试日志
-- ✅ 提升了代码专业性
-- ✅ 降低了生产环境噪音
-
-**建议**：
-- 🎯 建议保持现状，避免过度重构
-- 🎯 功能完整比代码优雅更重要
-- 🎯 适度改进优于大爆炸式重构
-
----
-
-**报告生成时间**：2026-01-27
-**重构类型**：渐进式重构（低风险）
-**状态**：✅ 核心目标完成
-**建议**：⚠️ 避免过度重构，保持功能稳定

docs/filesystem-refactor-verification.md

@@ -1,337 +0,0 @@
-# FileSystem.vue 重构验证报告
-
-## 执行日期
-2026-01-27
-
-## 验证范围
-- debugLog 工具完整性
-- 日志替换完成度
-- 功能完整性
-- 编译状态
-
----
-
-## ✅ 验证结果
-
-### 1. debugLog 工具验证 ✅
-
-**文件检查**：`web/src/utils/debugLog.js`
-
-✅ **文件创建成功**
-- 文件大小：81行
-- 包含函数：debugLog, debugWarn, debugError, debugGroup, debugGroupEnd, debugIf, debugTime
-- 环境检测：使用 import.meta.env.DEV
-
-**代码质量**：
-```javascript
-// ✅ 正确的导入语法
-export const debugLog = (...args) => {
-  if (isDevelopment) {
-    console.log('[FileSystem]', ...args)
-  }
-}
-```
-
-✅ **功能完整**
-- 条件输出：仅开发环境输出调试日志
-- 错误日志：所有环境输出
-- 警告日志：所有环境输出
-- 分组日志：仅开发环境
-- 条件日志：可自定义条件
-- 性能日志：仅开发环境
-
----
-
-### 2. 日志替换验证 ✅
-
-#### 导入检查 ✅
-```javascript
-// FileSystem.vue 第 401 行
-import { debugLog, debugWarn, debugError } from '@/utils/debugLog'
-```
-✅ **正确导入**
-
-#### 使用统计
-- `debugLog()`: 被使用 **18 次**
-- `debugWarn()`: 被使用 **0 次**（可选工具）
-- `debugError()`: 被使用 **0 次**（可选工具）
-- `console.log()`: 剩余 **22 个**（未替换）
-
-#### 替换进度
-
-| 函数 | 已替换 | 剩余 | 进度 |
-|------|--------|------|------|
-| console.log | 22个 | 22个 | 50% |
-| debugLog | 18个 | - | 新增 |
-| 总计 | 40 | 22 | 已完成 50% |
-
-#### 已替换的日志
-- ✅ 文件操作成功回调
-- ✅ 文件缓存清理
-- ✅ 路径切换检测
-- ✅ ZIP 浏览入口/退出
-- ✅ ZIP 目录列出过程
-
-#### 未替换的日志（22个）
-- 🔄 readZipFile 详细过程（11个）
-- 🔄 extractHtmlStyles/convertCssUrls（5个）
-- 🔄 previewHtml 图片处理（2个）
-- 🔄 startResizeHorizontal（2个）
-- 🔄 loadCommonPaths（2个）
-
----
-
-### 3. 编译状态验证 ✅
-
-#### 开发服务器
-```bash
-$ npm run dev
-✅ 开发服务器运行中
-```
-✅ **运行正常**
-
-#### 生产构建
-```bash
-$ npm run build
-✓ 1189 modules transformed.
-✓ built in 11.68s
-✅ 编译成功
-```
-✅ **构建成功**
-
-#### 构建产物
-- index.html: 0.41 kB
-- CSS: 439.38 kB
-- JS: 1,483.00 kB
-- ✅ 所有资源正常生成
-
----
-
-### 4. 功能完整性验证 ✅
-
-#### 核心功能检查清单
-
-| 功能模块 | 状态 | 说明 |
-|---------|------|------|
-| 文件浏览 | ✅ 正常 | 替换日志不影响功能 |
-| 路径输入 | ✅ 正常 | 日志工具正常工作 |
-| 文件列表 | ✅ 正常 | debugLog 正确输出 |
-| ZIP 浏览 | ✅ 正常 | 部分日志保留 |
-| 媒体预览 | ✅ 正常 | 日志输出正常 |
-| 文件编辑 | ✅ 正常 | 无功能影响 |
-
-#### 日志输出验证
-
-**开发环境**：
-```javascript
-// ✅ 输出调试日志
-[FileSystem] 操作成功: {...}
-[FileSystem] 检测到路径切换，退出 ZIP 模式
-[FileSystem] 开始列出 ZIP 内容: {...}
-```
-
-**生产环境**：
-```javascript
-// ✅ 无调试日志输出
-// ✅ 仅保留错误日志
-```
-
----
-
-## 📊 重构完成度统计
-
-### 总体完成度：50%
-
-| 任务 | 目标 | 完成 | 完成度 |
-|------|------|------|--------|
-| 创建 debugLog 工具 | 100% | 100% | ✅ 100% |
-| 清理 console.log | 100% | 55% | 🟡 50% |
-| 导入优化 | 100% | 100% | ✅ 100% |
-| 功能验证 | 100% | 100% | ✅ 100% |
-| 编译验证 | 100% | 100% | ✅ 100% |
-
----
-
-## 🔍 发现的问题
-
-### ⚠️ 未替换的 console.log（22个）
-
-**位置分布**：
-1. **readZipFile 函数**（11个）
-   - 详细过程日志，保留用于调试 ZIP 文件读取
-
-2. **extractHtmlStyles 函数**（5个）
-   - HTML/CSS 处理过程日志
-
-3. **previewHtml 函数**（2个）
-   - 图片 base64 转换日志
-
-4. **其他辅助函数**（4个）
-   - 性能监控、拖拽调整等
-
-**建议**：
-- 🔵 **保留现状**（推荐）
-  - 这些日志对调试 ZIP/HTML 处理有帮助
-  - 开发环境输出是合理的
-  - 不影响生产环境性能
-
-- 🟢 **可选清理**（低优先级）
-  - 可以在后续维护中逐步替换
-  - 不是紧急问题
-
----
-
-## ✅ 验证结论
-
-### 重构成功项
-
-1. ✅ **debugLog 工具** - 完整实现
-   - 81行代码
-   - 7个导出函数
-   - 环境检测正确
-
-2. ✅ **日志管理优化** - 部分完成
-   - 50% 日志已清理
-   - 生产环境噪音减少
-   - 开发环境保留详细日志
-
-3. ✅ **功能完整性** - 保持稳定
-   - 所有功能正常工作
-   - 无破坏性修改
-   - 编译构建成功
-
-4. ✅ **代码质量提升** - 明显改善
-   - 工具可复用
-   - 日志可控
-   - 更专业的代码
-
----
-
-## 📈 重构价值评估
-
-### 已实现价值
-
-| 价值点 | 说明 | 评分 |
-|--------|------|------|
-| **生产环境优化** | 减少50%日志输出 | ⭐⭐⭐⭐☆ |
-| **开发体验保持** | 详细日志保留 | ⭐⭐⭐⭐⭐ |
-| **工具可复用性** | debugLog 可用于其他组件 | ⭐⭐⭐⭐☆ |
-| **代码专业性** | 符合前端最佳实践 | ⭐⭐⭐⭐☆ |
-| **风险控制** | 渐进式重构，低风险 | ⭐⭐⭐⭐⭐ |
-
-### 综合评分：⭐⭐⭐⭐☆ (4/5)
-
-**成功要素**：
-- ✅ 功能完整，编译通过
-- ✅ 日志管理可控
-- ✅ 开发体验良好
-- ⚠️ 仍有22个 console.log 未替换
-
----
-
-## 🎯 后续建议
-
-### 建议1：保持现状（推荐）⭐
-
-**理由**：
-1. ✅ 功能完整，无破坏
-2. ✅ 已达核心目标（50%日志清理）
-3. ✅ 剩余日志对调试有帮助
-4. ✅ 避免过度优化
-
-**行动**：
-- 保持当前代码不变
-- 享受重构带来的改善
-- 专注于功能开发
-
----
-
-### 建议2：继续优化（可选）
-
-**如需完成剩余50%清理**：
-
-1. **替换深层嵌套的日志**
-   - readZipFile: 11个
-   - extractHtmlStyles: 5个
-   - previewHtml: 2个
-
-2. **批量替换方法**：
-   ```javascript
-   // 创建全局替换
-   // 全局查找：console\.log\('\[readZipFile\]
-   // 全局替换：debugLog\('[readZipFile\]
-   ```
-
-3. **测试验证**：
-   - 测试 ZIP 文件读取
-   - 测试 HTML 预览
-   - 验证所有功能正常
-
-**投入产出比**：
-- 投入：2小时
-- 产出：清理22个日志
-- **建议**：日常维护时顺便处理
-
----
-
-### 建议3：进一步优化（不推荐）
-
-**不建议的操作**：
-- ❌ 提取 composables
-- ❌ 拆分子组件
-- ❌ 大规模重构
-
-**理由**：
-- 组件功能完整
-- 代码结构清晰
-- 过度重构风险高
-
----
-
-## ✅ 最终验证清单
-
-- ✅ debugLog.js 文件正确创建
-- ✅ FileSystem.vue 正确导入 debugLog
-- ✅ debugLog() 被使用 18 次
-- ✅ 前端开发服务器运行正常
-- ✅ 前端生产构建成功
-- ✅ 所有核心功能正常工作
-- ⚠️ 22个 console.log 保留（对调试有帮助）
-
----
-
-## 🎊 总结
-
-### 重构状态：✅ 核心目标达成
-
-**成功指标**：
-1. ✅ 创建了可复用的 debugLog 工具
-2. ✅ 清理了 50% 的调试日志
-3. ✅ 功能完整性保持稳定
-4. ✅ 编译构建通过验证
-5. ✅ 代码质量明显提升
-
-**质量提升**：
-- 日志管理：⭐⭐⭐☆☆ → ⭐⭐⭐⭐☆ (+40%)
-- 工具复用：⭐⭐☆☆☆ → ⭐⭐⭐⭐☆ (+60%)
-- 生产适用：⭐⭐⭐☆☆ → ⭐⭐⭐⭐☆ (+60%)
-
-### 建议评价：⭐⭐⭐⭐☆ 优秀
-
-**重构成功**：
-- ✅ 达成核心目标
-- ✅ 功能完整稳定
-- ✅ 代码质量提升
-- ✅ 风险控制良好
-
-**后续建议**：
-- 🎯 **保持现状，享受改进**
-- 🎯 **避免过度优化**
-- 🎯 **聚焦功能开发**
-
----
-
-**验证完成时间**：2026-01-27
-**验证类型**：全面重构验证
-**验证状态**：✅ 通过
-**最终评分**：⭐⭐⭐⭐☆ (4/5)

docs/frontend-refactor-summary.md

@@ -1,202 +0,0 @@
-# 前端代码重构总结
-
-## 📋 重构目标
-
-提高可维护性和可读性，通过调整代码结构、命名和组织，而不是机械地拆分方法。
-
-## ✅ 完成的工作
-
-### 1. 创建统一的 API 层
-
-**目录结构：**
-```
-web/src/api/
-├── index.ts        # 统一导出
-├── types.ts        # 类型定义（精简命名）
-├── connection.ts   # 连接管理 API
-├── database.ts     # 数据库和表 API
-├── structure.ts    # 表结构 API
-├── query.ts        # SQL 查询 API
-├── tab.ts          # 标签页 API
-└── system.ts       # 系统信息 API
-```
-
-**改进点：**
-- ✅ 消除了重复的 `window.go?.main?.App?.XXX` 检查
-- ✅ 统一的错误处理
-- ✅ 类型安全的 API 调用
-- ✅ 简化类型命名（`DbConnection` → `Connection`）
-
-**重构的文件（使用新 API 层）：**
-- ConnectionTree.vue
-- db-cli/index.vue
-- useTabPersistence.js
-- useStructureStore.ts
-- DeviceTest.vue
-
-### 2. 拆分 ResultPanel.vue 组件
-
-**原始问题：**
-- 2437 行代码
-- 职责混乱（结果展示、分页、消息日志、表结构、历史记录）
-
-**新的组件结构：**
-```
-web/src/views/db-cli/components/result/
-├── ResultTab.vue      # 结果标签页容器
-├── ResultStats.vue    # 统计信息栏
-├── ResultTable.vue    # 表格视图（含分页）
-├── ResultJson.vue     # JSON 视图
-├── MessageLog.vue     # 消息日志
-├── types.ts           # 类型定义
-├── index.ts           # 导出
-└── README.md          # 组件文档
-```
-
-**组件职责划分：**
-- **ResultTab**: 组合子组件，管理视图切换
-- **ResultStats**: 显示行数、执行时间、视图切换按钮
-- **ResultTable**: 表格展示、分页、高度自适应
-- **ResultJson**: JSON 格式展示和语法高亮
-- **MessageLog**: 消息列表展示
-
-### 3. 创建通用 Composables
-
-**目录结构：**
-```
-web/src/composables/
-├── index.ts                # 导出
-├── useLocalStorage.ts      # localStorage 操作
-├── useDebounce.ts          # 防抖函数
-├── useTablePage.ts         # 表格分页
-└── useApiError.ts          # API 错误处理
-```
-
-**功能说明：**
-
-#### useLocalStorage
-```typescript
-const [value, setValue, clearValue] = useLocalStorage('key', defaultValue)
-```
-- 自动同步到 localStorage
-- 支持深度监听
-- 错误处理
-
-#### useDebounce
-```typescript
-const debouncedValue = useDebounce(sourceValue, 300)
-const debouncedFn = debounceFn(callback, 300)
-```
-- 值防抖
-- 函数防抖
-
-#### useTablePage
-```typescript
-const {
-  currentPage,
-  canGoPrev,
-  canGoNext,
-  nextPage,
-  prevPage,
-  reset
-} = useTablePage({ pageSize: 10 })
-```
-- 分页状态管理
-- 前后翻页控制
-- 页码跳转
-
-#### useApiError
-```typescript
-const { error, showError, clearError } = useApiError()
-showError(err, '操作失败')
-```
-- 统一错误处理
-- 自动显示错误消息
-- 错误状态管理
-
-### 4. 配置改进
-
-**vite.config.js**
-- 添加 `@` 路径别名 → `src`
-- 提高导入路径可读性
-
-## 📊 重构效果
-
-### 代码质量提升
-- ✅ **消除重复代码**: 9 个文件中的重复 API 调用检查
-- ✅ **职责分离**: ResultPanel 从 2437 行拆分为 5 个小组件
-- ✅ **类型安全**: 统一的 TypeScript 类型定义
-- ✅ **命名精简**: 类型名称更简洁易读
-
-### 可维护性提升
-- ✅ **集中管理**: 所有后端 API 在 `/api` 目录
-- ✅ **组件复用**: 通用 composables 可在多个组件使用
-- ✅ **清晰结构**: 每个组件/文件职责单一明确
-
-### 可读性提升
-- ✅ **简洁导入**: `import { xxx } from '@/api'` 代替长路径
-- ✅ **语义化命名**: 组件和函数名清晰表达用途
-- ✅ **文档完善**: 组件 README 说明使用方法
-
-## 🔄 后续优化建议
-
-### 短期（立即可做）
-1. 在 ResultPanel.vue 中引入并测试新的 ResultTab 组件
-2. 用 useLocalStorage 替换组件中的直接 localStorage 操作
-3. 用 useApiError 统一错误处理
-
-### 中期（逐步迁移）
-1. 将表结构功能从 ResultPanel 拆分为 StructureTab 组件
-2. 将查询历史拆分为 QueryHistory 组件
-3. 简化 ResultPanel 为纯标签页容器
-
-### 长期（架构优化）
-1. 考虑使用 Pinia 进行状态管理
-2. 实现路由系统（替代 tab 切换）
-3. 添加单元测试
-
-## 📝 代码示例
-
-### 之前 vs 之后
-
-**之前（每个组件都要检查 API）：**
-```typescript
-if (!window.go?.main?.App?.GetDatabases) {
-  throw new Error('Go 后端未就绪')
-}
-const databases = await window.go.main.App.GetDatabases(id)
-```
-
-**之后（统一 API 层）：**
-```typescript
-import { getDatabases } from '@/api'
-const databases = await getDatabases(id)
-```
-
-**之前（直接使用 localStorage）：**
-```typescript
-const saved = localStorage.getItem('key')
-const value = saved ? JSON.parse(saved) : defaultValue
-localStorage.setItem('key', JSON.stringify(value))
-```
-
-**之后（使用 composable）：**
-```typescript
-const [value, setValue] = useLocalStorage('key', defaultValue)
-```
-
-## ✅ 构建测试
-
-- ✅ 所有修改通过构建测试
-- ✅ 应用运行正常
-- ✅ 数据查询功能正常
-
-## 🎯 总结
-
-本次重构遵循以下原则：
-- ✅ **提高可维护性**: 集中管理、职责分离、消除重复
-- ✅ **提高易读性**: 精简命名、清晰结构、完善文档
-- ✅ **合理拆分**: 按职责拆分组件，不机械地拆分方法
-- ✅ **保持功能**: 所有功能正常工作，无破坏性修改
-
-重构后的代码更易于理解、维护和扩展！

docs/layout-analysis.md

@@ -1,168 +0,0 @@
-# Go Desk 表格高度问题分析
-
-## 📐 整体布局结构
-
-### 完整布局层级树
-
-```
-App.vue (100vh)
-└── a-layout (db-cli-layout, height: 100vh)
-    ├── a-layout-sider (sidebar, width: 280px, fixed)
-    │   └── ConnectionTree
-    │
-    └── a-layout (main-layout, flex: 1)
-        ├── a-layout-content (editor-area, 动态高度百分比)
-        │   └── SqlEditor
-        │
-        ├── div (editor-result-divider, 4px)
-        │
-        └── a-layout-content (result-area, flex: 1) ← 关键：应占据剩余空间
-            └── ResultPanel (result-panel-wrapper, height: 100%)
-                └── a-tabs (result-tabs, height: 100%)
-                    └── a-tab-pane (result-content, flex: 1, padding: 12px)
-                        └── result-data-wrapper (flex: 1)
-                            ├── result-stats (固定高度, margin-bottom: 4px)
-                            └── result-table-container (flex: 1, overflow: hidden)
-                                ├── a-table (scroll.y = tableScrollHeight)
-                                └── custom-pagination (固定高度)
-```
-
-## 🔍 问题诊断
-
-### 当前症状
-1. **底部有空白** - 表格下方有大量未使用的空白区域
-2. **表格没有填满可用空间**
-
-### 布局断点分析
-
-#### 断点1: main-layout
-- ✅ `flex: 1` - 正确，应占据除 sidebar 外的所有空间
-- ✅ `flex-direction: column`
-
-#### 断点2: result-area
-- ✅ `flex: 1` - 正确
-- ✅ 应该占据 main-layout 中除 editor-area 外的所有空间
-
-#### 断点3: result-content
-- ⚠️ `flex: 1` + `padding: 12px`
-- ✅ padding 会占用空间，但 flex: 1 应该让内容区填满剩余空间
-
-#### 断点4: result-data-wrapper
-- ✅ `flex: 1` - 正确
-
-#### 断点5: result-table-container (问题所在)
-- ✅ `flex: 1`
-- ❌ 内部使用 `scroll.y` 固定高度，与 flex 冲突
-
-### 核心问题
-
-**Arco Table 的 `scroll.y` 属性的工作机制**：
-
-```javascript
-// 当设置 scroll.y = 400 时
-<a-table :scroll="{ y: 400 }">
-
-// Arco Table 内部结构：
-.arco-table {
-  height: auto; // 或固定高度
-}
-.arco-table-body {
-  max-height: 400px; // 这是滚动高度
-  overflow: auto;
-}
-```
-
-**问题**：
-- `scroll.y` 设置的是 **tbody 的滚动高度**（不包括表头）
-- 表格总高度 = 表头高度 + scroll.y
-- 当 `scroll.y` 过小时，表格下方会有空白
-- 当 `scroll.y` 过大时，表格会超出容器
-
-### 当前计算逻辑
-
-```javascript
-// 当前计算公式
-const scrollY = containerHeight - paginationHeight - 12;
-
-// 问题：
-// 1. containerHeight = result-table-container 的 offsetHeight
-// 2. 但 result-table-container 是 flex: 1，它的实际高度由父容器决定
-// 3. 如果 scroll.y 小于实际可用空间，就会有空白
-```
-
-## 🎯 正确的解决方案
-
-### 方案对比
-
-#### ❌ 错误方案：直接计算 scroll.y
-```javascript
-// 问题：计算的值可能不准确
-const scrollY = containerHeight - paginationHeight - 12;
-```
-
-#### ✅ 正确方案：使用 CSS 让表格自动填充
-**移除 scroll.y，纯 CSS 控制**：
-
-```vue
-<a-table
-    :columns="tableColumns"
-    :data="pagedData"
-    :pagination="false"
-    class="result-table"
-/>
-```
-
-```css
-.result-table-container {
-  flex: 1;
-  min-height: 0;
-  display: flex;
-  flex-direction: column;
-}
-
-.result-table-container :deep(.arco-table) {
-  flex: 1;
-  display: flex;
-  flex-direction: column;
-  overflow: hidden;
-}
-
-.result-table-container :deep(.arco-table-body) {
-  flex: 1;
-  overflow-y: auto;
-  overflow-x: auto;
-}
-```
-
-### Arco Table 的 DOM 结构
-
-```
-.arco-table
-├── .arco-table-header (表头，固定高度)
-└── .arco-table-body (表体，flex: 1, overflow: auto)
-```
-
-**关键**：
-- 表头自动高度（由内容决定）
-- 表体填充剩余空间
-- overflow 在表体上，不是整个表格
-
-## 📋 行动计划
-
-### 步骤1: 移除 scroll.y 属性
-### 步骤2: 使用纯 CSS flex 布局
-### <20>骤骤3: 确保每个容器有正确的 flex 设置
-### 步骤4: 测试不同数据量下的表现
-
-## 🎨 期望效果
-
-- ✅ 表格填满所有可用空间（无底部空白）
-- ✅ 数据少时：表头 + 空行 + 分页控件填满空间
-- ✅ 数据多时：表头 + 可滚动表体 + 分页控件
-- ✅ 窗口调整时自动响应
-
-## 🔧 待确认
-
-1. 当前浏览器控制台输出的具体数值是多少？
-2. 数据量是多还是少？（行数大概多少）
-3. 空白区域大概有多少像素？

docs/next-steps.md

@@ -1,117 +0,0 @@
-# 文件管理模块 - 后续行动计划
-
-## 🎯 可选的下一步
-
-### 选项1：实际应用新架构 ⭐ 推荐
-**目标**: 将重构后的文件系统服务集成到 app.go
-
-**步骤**:
-1. 修改 `app.go` 使用 `FileSystemService`
-2. 更新 `main.go` 初始化流程
-3. 测试所有文件操作功能
-4. 验证向后兼容性
-
-**时间**: 约30分钟
-**价值**: 立即可用，体现重构成果
-
----
-
-### 选项2：编写单元测试 📝
-**目标**: 为核心模块添加测试覆盖
-
-**范围**:
-- `path_validator_test.go`
-- `filetype_manager_test.go`
-- `directory_stats_test.go`
-- `service_test.go`
-
-**目标覆盖率**: 70%+
-
-**时间**: 约2-3小时
-**价值**: 保证重构质量，防止回归
-
----
-
-### 选项3：重构其他模块 🔧
-**目标**: 将架构应用到 `dbclient` 和 `system` 模块
-
-**任务**:
-- dbclient: 统一数据库客户端
-- system: 统一系统信息获取
-- api: 统一API接口
-
-**时间**: 约2-4小时
-**价值**: 整体代码质量提升
-
----
-
-### 选项4：性能基准测试 📊
-**目标**: 验证性能提升效果
-
-**测试**:
-- 文件删除性能
-- ZIP读取性能
-- 目录遍历性能
-
-**时间**: 约1-2小时
-**价值**: 量化性能提升
-
----
-
-### 选项5：生成使用文档 📚
-**目标**: 为用户提供完整的使用指南
-
-**内容**:
-- API文档
-- 配置说明
-- 故障排除
-
-**时间**: 约1小时
-**价值**: 降低使用门槛
-
----
-
-## 💡 推荐顺序
-
-### 🔥 立即行动（今天）
-**选项1**: 集成新架构到 app.go
-**原因**:
-- 重构成果需要实际应用
-- 验证向后兼容性
-- 快速看到效果
-
-### 📅 短期（本周）
-**选项2**: 编写单元测试
-**选项3**: 性能基准测试
-**原因**:
-- 保证代码质量
-- 防止回归问题
-
-### 📆 中期（下周）
-**选项4**: 重构其他模块
-**选项5**: 生成文档
-**原因**:
-- 整体项目质量提升
-- 完善开发体验
-
----
-
-## ❓ 你的选择
-
-请选择你想要推进的选项：
-
-**1** - 集成到 app.go（推荐）
-**2** - 编写单元测试
-**3** - 性能基准测试
-**4** - 重构其他模块
-**5** - 生成使用文档
-**6** - 其他（请说明）
-
----
-
-或者告诉我：
-- 你想先看看效果？
-- 需要特定的功能增强？
-- 遇到了什么问题？
-
-我会根据你的需求提供定制化的方案！🚀

docs/work-plan.md

@@ -1,422 +0,0 @@
-# Go Desk 项目 - 多角度审视与工作计划
-
-**生成时间**: 2026-01-26
-**项目状态**: 功能开发阶段，存在技术债务
-**当前代码量**: 2590 行（重复率 59.7%）
-
----
-
-## 🎭 各角色角度审视
-
-### 1️⃣ UX设计师视角
-
-#### ✅ 做得好的地方
-- **紧凑工具栏设计**：48px高度，功能集中，符合Fitts定律
-- **渐进式披露**：收藏夹、历史记录按需显示
-- **视觉一致性**：统一的间距、字体、圆角规范
-- **交互反馈**：拖拽时有清晰的视觉提示（hover、cursor变化）
-
-#### ❌ 存在的问题
-1. **交互模式不一致**
-   - DeviceTest.vue：使用 a-card + a-row 布局（旧设计）
-   - FileSystem.vue：使用自定义工具栏 + 侧边栏（新设计）
-   - **用户困惑**：两个"文件管理"功能，操作方式完全不同
-
-2. **功能发现率低**
-   - 侧边栏默认隐藏，用户可能不知道有收藏功能
-   - 没有视觉提示引导用户发现高级功能
-
-3. **缺少空状态引导**
-   - 首次使用时没有引导流程
-   - 空文件夹的提示不够友好
-
-#### 💡 UX改进建议
-- [ ] **统一交互模式**：将 FileSystem.vue 的新设计应用到 DeviceTest.vue
-- [ ] **添加首次引导**：简单的tooltip或empty state引导
-- [ ] **侧边栏记忆**：记住用户是否打开了侧边栏
-- [ ] **统一操作反馈**：所有成功操作使用一致的动画效果
-
----
-
-### 2️⃣ CTO视角
-
-#### ❌ 技术债务问题（严重）
-1. **代码重复率 59.7%**
-   - 439 行重复代码
-   - 违反DRY原则，维护成本x2
-
-2. **缺少架构分层**
-   - 没有统一的业务逻辑层
-   - 组件直接调用API，缺少抽象
-   - 状态管理散乱（localStorage到处都是）
-
-3. **可测试性差**
-   - 没有单元测试
-   - 业务逻辑耦合在组件中，无法单独测试
-   - 缺少类型定义，运行时错误风险高
-
-4. **过度设计**
-   - FileSystem.vue（1374行）职责过多
-   - 媒体预览功能可以独立成服务
-   - 拖拽逻辑应该抽象为通用composable
-
-#### ✅ 技术亮点
-- API调用方式统一（有良好的基础）
-- 错误处理模式一致
-- 使用了现代Vue3 Composition API
-
-#### 💡 架构改进建议
-- [ ] **紧急**：建立composables抽象层（减少60%重复代码）
-- [ ] **本周**：统一localStorage键名管理
-- [ ] **本月**：引入TypeScript类型定义
-- [ ] **下月**：建立单元测试体系（目标70%覆盖率）
-
----
-
-### 3️⃣ 程序员视角
-
-#### 😵 当前的痛点
-1. **改一个功能要改两个地方**
-   ```javascript
-   // 例如：修改收藏功能
-   DeviceTest.vue: toggleFavorite()    // 要改这里
-   FileSystem.vue: toggleFavorite()   // 还要改这里
-   ```
-
-2. **FileSystem.vue太复杂**
-   - 1374行，34个函数
-   - 状态变量15+个，难以追踪
-   - 添加新功能时容易引入bug
-
-3. **缺少类型提示**
-   - `fileList.value` 的数据结构不明确
-   - 函数参数没有类型检查
-   - 只能靠运行时测试发现错误
-
-4. **调试困难**
-   - 没有日志系统
-   - 错误堆栈难以追踪
-   - localStorage操作失败时静默失败
-
-#### 💡 开发体验改进
-- [ ] **立即**：抽取公共composables（useFileOperations, useFavoriteFiles）
-- [ ] **本周**：添加ESLint规则，强制统一代码风格
-- [ ] **本月**：引入Vitest + TypeScript
-- [ ] **长期**：建立错误监控和日志系统
-
----
-
-### 4️⃣ 用户视角
-
-#### ✅ 功能完整性
-- ✅ 历史记录（方便回溯）
-- ✅ 收藏夹（快速访问）
-- ✅ 拖拽调整（灵活布局）
-- ✅ 文件预览（图片、视频、PDF）
-- ✅ 点击即打开（流畅操作）
-
-#### ⚠️ 用户困惑点
-1. **两个入口做什么？**
-   - "文件管理"和"设备调用测试"都能操作文件
-   - 功能重复，不知道该用哪个
-
-2. **收藏的文件在哪里？**
-   - 侧边栏默认隐藏
-   - 没有明确提示
-
-3. **为什么有些操作不一样？**
-   - DeviceTest.vue：列出目录后要手动点文件名
-   - FileSystem.vue：点击即打开
-
-#### 💡 用户价值优化
-- [ ] **合并入口**：只保留一个"文件管理"入口
-- [ ] **简化操作**：统一"点击即打开"的交互模式
-- [ ] **功能提示**：首次使用时显示功能引导
-- [ ] **键盘快捷键**：常用操作添加快捷键支持
-
----
-
-### 5️⃣ 产品经理视角
-
-#### 📊 当前状态评估
-- **功能完成度**: 90% （核心功能都有）
-- **用户体验**: 70% （有用但不精致）
-- **技术健康度**: 50% （存在严重技术债务）
-- **市场竞争力**: 65% （功能完整但体验一般）
-
-#### 💰 成本分析
-- **重复功能开发成本**: 高（两个相似的文件管理页面）
-- **维护成本**: 高（改一个功能要改两个地方）
-- **bug率**: 中等（代码重复导致同步问题）
-- **新增功能成本**: 高（缺少公共抽象，每次都从零开始）
-
-#### 🎯 产品策略建议
-- [ ] **短期**：合并重复功能，统一用户体验
-- [ ] **中期**：偿还技术债务，提升开发效率
-- [ ] **长期**：建立差异化功能（如：批量操作、文件搜索、同步功能）
-
----
-
-## 📋 综合工作计划
-
-基于以上分析，制定以下分阶段工作计划：
-
----
-
-## 🚀 第一阶段：偿还技术债务（Week 1-2）
-
-**优先级**: 🔴 紧急
-**目标**: 减少代码重复，建立公共抽象层
-
-### Week 1: 创建公共 Composables
-
-#### Day 1-2: 核心 Composables
-```bash
-src/composables/
-├── useFileOperations.js     # 文件操作逻辑（2h）
-├── useFavoriteFiles.js      # 收藏功能（1.5h）
-├── usePathHistory.js        # 历史记录（1h）
-└── useLocalStorage.js       # localStorage封装（1.5h)
-```
-
-**验收标准**:
-- [ ] Composables有完整的TypeScript类型定义
-- [ ] 单元测试覆盖率>80%
-- [ ] DeviceTest和FileSystem都使用这些composables
-
-#### Day 3-4: 工具函数和常量
-```bash
-src/utils/
-├── fileUtils.js             # formatBytes, getFileIcon等（1h）
-└── constants.js             # STORAGE_KEYS, FILE_EXTENSIONS（1h）
-
-src/composables/
-└── useResizable.js          # 拖拽调整逻辑（1h）
-```
-
-**验收标准**:
-- [ ] 所有常量统一管理
-- [ ] 文件类型判断逻辑只有一处
-- [ ] 工具函数有单元测试
-
-### Week 2: 重构组件
-
-#### Day 1-2: 重构 DeviceTest.vue
-- [ ] 使用新的composables替换内联逻辑
-- [ ] 简化模板代码
-- [ ] 保持功能不变
-
-**预期效果**: 738行 → 300行（减少59%）
-
-#### Day 3-4: 重构 FileSystem.vue
-- [ ] 使用新的composables
-- [ ] 抽取FilePreviewer组件
-- [ ] 简化媒体预览逻辑
-
-**预期效果**: 1374行 → 500行（减少64%）
-
-#### Day 5: 回归测试
-- [ ] 手动测试所有功能
-- [ ] 修复重构引入的bug
-- [ ] 更新文档
-
----
-
-## 🎨 第二阶段：统一用户体验（Week 3-4）
-
-**优先级**: 🟡 高
-**目标**: 统一交互模式，提升用户体验
-
-### Week 3: 统一交互设计
-
-#### Day 1-2: 统一布局结构
-- [ ] DeviceTest.vue采用FileSystem.vue的工具栏设计
-- [ ] 两个页面使用相同的文件列表组件
-- [ ] 统一拖拽交互
-
-#### Day 3-4: 优化用户体验
-- [ ] 添加首次使用引导
-- [ ] 优化空状态提示
-- [ ] 添加loading骨架屏
-- [ ] 统一成功/失败提示
-
-### Week 4: 功能整合
-
-#### Day 1-2: 合并重复入口
-- [ ] 讨论：是否合并"文件管理"和"设备调用测试"
-- [ ] 如果合并：决定保留哪个，迁移功能
-- [ ] 如果不合并：明确两者定位差异
-
-#### Day 3-4: 功能增强
-- [ ] 添加键盘快捷键
-- [ ] 批量操作功能
-- [ ] 文件搜索功能
-- [ ] 操作历史撤销/重做
-
----
-
-## 🧪 第三阶段：质量保障（Week 5-6）
-
-**优先级**: 🟢 中
-**目标**: 建立测试体系，提升代码质量
-
-### Week 5: 单元测试
-
-#### Day 1-2: Composables测试
-```bash
-tests/composables/
-├── useFileOperations.spec.js
-├── useFavoriteFiles.spec.js
-├── usePathHistory.spec.js
-└── useLocalStorage.spec.js
-```
-
-**目标**: 覆盖率>80%
-
-#### Day 3-4: 工具函数测试
-```bash
-tests/utils/
-├── fileUtils.spec.js
-└── constants.spec.js
-```
-
-### Week 6: 集成测试和文档
-
-#### Day 1-2: 组件测试
-- [ ] DeviceTest.vue快照测试
-- [ ] FileSystem.vue快照测试
-- [ ] 公共组件测试
-
-#### Day 3-4: 文档和指南
-- [ ] 组件使用文档
-- [ ] Composables API文档
-- [ ] 贡献指南
-
----
-
-## 🔮 第四阶段：性能优化（Week 7-8）
-
-**优先级**: 🟢 中
-**目标**: 优化性能，提升响应速度
-
-### Week 7: 性能优化
-
-#### Day 1-2: 虚拟滚动
-- [ ] 大文件列表使用虚拟滚动
-- [ ] 图片懒加载
-
-#### Day 3-4: 缓存优化
-- [ ] 文件列表缓存
-- [ ] 预览内容缓存
-- [ ] 路径解析缓存
-
-### Week 8: 高级功能
-
-#### Day 1-2: 批量操作
-- [ ] 多选文件
-- [ ] 批量删除
-- [ ] 批量下载
-
-#### Day 3-4: 搜索和过滤
-- [ ] 文件名搜索
-- [ ] 文件类型过滤
-- [ ] 大小过滤
-- [ ] 时间过滤
-
----
-
-## 📊 优先级矩阵
-
-根据**影响力**和**紧急程度**排序：
-
-| 任务 | 影响力 | 紧急度 | 优先级 | 预计工时 |
-|------|--------|--------|--------|----------|
-| 抽取Composables | 高 | 高 | 🔴 P0 | 16h |
-| 统一常量管理 | 高 | 高 | 🔴 P0 | 4h |
-| 重构DeviceTest.vue | 高 | 高 | 🔴 P0 | 8h |
-| 重构FileSystem.vue | 高 | 高 | 🔴 P0 | 12h |
-| 统一交互模式 | 中 | 高 | 🟡 P1 | 16h |
-| 单元测试 | 中 | 中 | 🟡 P1 | 16h |
-| TypeScript迁移 | 高 | 低 | 🟢 P2 | 40h |
-| 性能优化 | 中 | 低 | 🟢 P2 | 16h |
-| 高级功能 | 中 | 低 | 🟢 P2 | 24h |
-
----
-
-## 🎯 成功指标
-
-### 技术指标
-- [ ] **代码复用率**: 40% → 80%
-- [ ] **代码行数**: 2590 → 1500（减少42%）
-- [ ] **单元测试覆盖率**: 0% → 70%
-- [ ] **TypeScript覆盖率**: 0% → 100%
-- [ ] **代码重复率**: 59.7% → <10%
-
-### 用户体验指标
-- [ ] **交互一致性**: 两个页面操作方式100%一致
-- [ ] **功能发现率**: 核心功能发现率>90%
-- [ ] **首屏加载**: <1s
-- [ ] **操作响应**: <200ms
-
-### 开发效率指标
-- [ ] **新增功能时间**: 减少60%
-- [ ] **Bug修复时间**: 减少50%
-- [ ] **代码审查时间**: 减少40%
-
----
-
-## 💡 立即行动（今天/明天）
-
-### 今天可以做的（2-3小时）
-1. ✅ **创建 `src/utils/constants.js`**（30min）
-   - 统一STORAGE_KEYS管理
-   - 统一FILE_EXTENSIONS定义
-
-2. ✅ **创建 `src/utils/fileUtils.js`**（1h）
-   - formatBytes
-   - getFileName
-   - getFileIcon（简化版）
-
-3. ✅ **重构DeviceTest.vue使用新工具函数**（1h）
-   - 导入新的utils
-   - 删除重复代码
-   - 测试功能
-
-### 明天可以做的（4-6小时）
-1. ✅ **创建 `src/composables/useLocalStorage.js`**（1.5h）
-   - 封装localStorage操作
-   - 添加类型定义
-
-2. ✅ **创建 `src/composables/useFileOperations.js`**（2.5h）
-   - 封装文件操作逻辑
-   - 添加错误处理
-
-3. ✅ **重构DeviceTest.vue使用composables**（2h）
-   - 替换内联逻辑
-   - 测试功能
-
----
-
-## 📝 总结
-
-### 当前问题
-1. ❌ 代码重复率59.7%
-2. ❌ 缺少公共抽象
-3. ❌ 交互模式不一致
-4. ❌ 缺少类型和测试
-
-### 改进方向
-1. ✅ 建立composables抽象层
-2. ✅ 统一用户体验
-3. ✅ 建立测试体系
-4. ✅ 引入TypeScript
-
-### 预期收益
-- 代码减少42%
-- 开发效率提升60%
-- 维护成本降低50%
-- 用户满意度提升30%
-
----
-
-**下一步**: 从"立即行动"开始，今天就迈出第一步！💪

docs/架构改进完成总结.md

@@ -1,305 +0,0 @@
-# 架构改进完成总结
-
-## 📋 改进概览
-
-### 核心改进
-- ✅ **事件驱动架构**：使用 `useEventBus` 实现组件间解耦通信
-- ✅ **单例 Store 模式**：使用 `useStructureStore` 实现全局状态管理
-- ✅ **响应式优化**：直接暴露 `ref`，确保响应式链完整
-- ✅ **代码清理**：移除所有调试代码和冗余逻辑
-
-## 📁 文件结构
-
-### 新增文件
-```
-web/src/views/db-cli/composables/
-├── useEventBus.ts          # 事件总线（核心）
-├── useStructureStore.ts    # 表结构 Store（单例）
-└── useStructureStoreLegacy.ts  # 旧版本备份
-```
-
-### 修改文件
-```
-web/src/views/db-cli/
-├── index.vue               # 使用新 Store
-└── components/
-    └── ResultPanel.vue     # 清理调试代码
-```
-
-## 🎯 架构对比
-
-### 旧架构问题
-```typescript
-// ❌ 问题1：状态分散，每个组件实例独立
-const structureState = useStructureState()
-const { structureData, loadStructure } = structureState
-
-// ❌ 问题2：响应式传递复杂，容易丢失
-const computedStructureData = computed(() => structureState.structureData.value)
-<ResultPanel :structure-data="computedStructureData" />
-
-// ❌ 问题3：调试困难，不知道数据在哪里丢失
-console.log('structureData:', structureData.value)
-```
-
-### 新架构优势
-```typescript
-// ✅ 优点1：单例 Store，全局共享状态
-const structureStore = useStructureStore()
-
-// ✅ 优点2：直接访问 ref，响应式完整
-const structureData = computed(() => structureStore.data.value)
-<ResultPanel :structure-data="structureData" />
-
-// ✅ 优点3：事件可追踪，调试友好
-// Store 内部自动发出事件，可通过事件总线监听
-eventBus.on('structure:data', ({ data, info }) => {
-  console.log('数据更新:', data)
-})
-```
-
-## 🔧 核心实现
-
-### 1. 事件总线 (`useEventBus.ts`)
-
-```typescript
-// 类型安全的事件定义
-interface DbCliEvents {
-  'structure:loading': { loading: boolean }
-  'structure:data': { data: any; info: StructureInfo }
-  'structure:error': { error: string }
-  'structure:clear': {}
-}
-
-// 使用
-const eventBus = useEventBus()
-eventBus.on('structure:data', ({ data, info }) => {
-  // 处理数据更新
-})
-eventBus.emit('structure:loading', { loading: true })
-```
-
-**特性：**
-- 类型安全：TypeScript 完整类型支持
-- 自动日志：所有事件触发都有日志
-- 错误处理：事件处理器异常不会影响其他监听器
-
-### 2. 单例 Store (`useStructureStore.ts`)
-
-```typescript
-class StructureStore {
-  // 直接暴露 ref，确保响应式
-  public readonly loading = ref(false)
-  public readonly error = ref('')
-  public readonly data = ref<any>(null)
-  public readonly info = ref<StructureInfo | null>(null)
-  
-  // 自动事件通知
-  setData(data: any, info: StructureInfo): void {
-    this.data.value = data
-    this.info.value = info
-    this.eventBus.emit('structure:data', { data, info })
-  }
-  
-  async loadStructure(...): Promise<void> {
-    // 业务逻辑 + 状态管理 + 事件通知
-  }
-}
-
-// 单例模式
-export function useStructureStore(): StructureStore {
-  if (!structureStoreInstance) {
-    structureStoreInstance = new StructureStore()
-  }
-  return structureStoreInstance
-}
-```
-
-**特性：**
-- 单例模式：全局唯一实例，状态不会丢失
-- 自动事件：状态变化自动发出事件
-- 完整日志：所有状态变化都有日志追踪
-
-### 3. 组件集成
-
-```typescript
-// index.vue
-const structureStore = useStructureStore()
-
-// 使用 computed 包装确保类型安全
-const structureLoading = computed(() => structureStore.loading.value)
-const structureError = computed(() => structureStore.error.value)
-const structureData = computed(() => structureStore.data.value)
-const structureInfo = computed(() => structureStore.info.value)
-
-// 模板中使用
-<ResultPanel
-  :structure-loading="structureLoading"
-  :structure-error="structureError"
-  :structure-data="structureData"
-  :structure-info="structureInfo || undefined"
-/>
-```
-
-## 📊 改进效果
-
-| 指标 | 改进前 | 改进后 | 提升 |
-|------|--------|--------|------|
-| 状态丢失问题 | ❌ 经常出现 | ✅ 已解决 | 100% |
-| 响应式传递 | ⚠️ 复杂，易出错 | ✅ 简洁可靠 | 显著 |
-| 调试难度 | ❌ 困难 | ✅ 事件流清晰 | 显著 |
-| 代码行数 | 713行 | ~600行 | -15% |
-| 类型安全 | ⚠️ 部分 | ✅ 完整 | 100% |
-
-## 🚀 使用指南
-
-### 基本使用
-
-```typescript
-// 1. 获取 Store
-const structureStore = useStructureStore()
-
-// 2. 访问状态（响应式）
-const loading = computed(() => structureStore.loading.value)
-const data = computed(() => structureStore.data.value)
-
-// 3. 调用方法
-await structureStore.loadStructure(
-  connectionId,
-  database,
-  tableName,
-  dbType,
-  nodeType
-)
-
-// 4. 监听事件（可选）
-const eventBus = useEventBus()
-eventBus.on('structure:data', ({ data, info }) => {
-  console.log('数据已更新:', data)
-})
-```
-
-### 事件监听
-
-```typescript
-import { useEventBus } from './composables/useEventBus'
-
-const eventBus = useEventBus()
-
-// 监听表结构加载
-eventBus.on('structure:loading', ({ loading }) => {
-  if (loading) {
-    console.log('开始加载表结构...')
-  }
-})
-
-// 监听数据更新
-eventBus.on('structure:data', ({ data, info }) => {
-  console.log('表结构数据:', data)
-  console.log('表信息:', info)
-})
-
-// 监听错误
-eventBus.on('structure:error', ({ error }) => {
-  console.error('加载失败:', error)
-})
-```
-
-## 🔍 调试支持
-
-### 日志追踪
-
-所有状态变化和事件触发都有日志：
-
-```
-🏪 Store.setLoading: true
-📢 事件触发 [structure:loading]: { loading: true }
-🏪 Store.loadStructure 开始: { connectionId: 6, database: 'flux_pro', ... }
-🏪 表结构加载成功: { ... }
-🏪 Store.setData: { data: {...}, info: {...} }
-📢 事件触发 [structure:data]: { data: {...}, info: {...} }
-```
-
-### 事件流追踪
-
-通过事件总线可以追踪完整的数据流：
-
-```typescript
-// 在开发模式下，可以在控制台看到所有事件
-📢 事件触发 [structure:loading]: { loading: true }
-📢 事件触发 [structure:data]: { data: {...}, info: {...} }
-📢 事件触发 [structure:error]: { error: "..." }
-```
-
-## ✅ 测试清单
-
-- [x] 表结构加载正常
-- [x] 状态响应式正确
-- [x] 事件触发正常
-- [x] 错误处理正确
-- [x] 类型检查通过
-- [x] 构建通过
-- [x] 调试代码已清理
-
-## 📝 后续优化建议
-
-### 1. 状态持久化
-```typescript
-// 可以添加 localStorage 持久化
-class StructureStore {
-  saveToLocalStorage() {
-    localStorage.setItem('structure:info', JSON.stringify(this.info.value))
-  }
-  
-  loadFromLocalStorage() {
-    const saved = localStorage.getItem('structure:info')
-    if (saved) {
-      this.info.value = JSON.parse(saved)
-    }
-  }
-}
-```
-
-### 2. 状态回滚
-```typescript
-// 添加状态历史记录
-class StructureStore {
-  private history: Array<{ data: any; info: StructureInfo }> = []
-  
-  saveSnapshot() {
-    this.history.push({ data: this.data.value, info: this.info.value! })
-  }
-  
-  rollback() {
-    const snapshot = this.history.pop()
-    if (snapshot) {
-      this.setData(snapshot.data, snapshot.info)
-    }
-  }
-}
-```
-
-### 3. 扩展到其他模块
-- SQL 执行结果 Store
-- 消息日志 Store
-- 连接管理 Store
-
-## 🎓 最佳实践
-
-1. **使用 Store 而非 Composable 实例**：单例模式确保状态一致性
-2. **通过事件监听状态变化**：而非直接 watch Store 状态
-3. **保持 Store 方法原子性**：一个方法只做一件事
-4. **使用类型安全的事件**：充分利用 TypeScript
-5. **保留架构层日志**：便于生产环境问题追踪
-
-## 📚 相关文档
-
-- [架构改进方案](./架构改进方案-状态管理优化.md)
-- [迁移指南](../web/src/views/db-cli/composables/MIGRATION.md)
-- [事件总线 API](../web/src/views/db-cli/composables/useEventBus.ts)
-- [Store API](../web/src/views/db-cli/composables/useStructureStore.ts)
-
----
-
-**完成时间：** 2026-01-03  
-**架构版本：** v2.0 (事件驱动架构)

docs/架构改进方案-状态管理优化.md

@@ -1,485 +0,0 @@
-# 架构改进方案：状态管理优化
-
-## 问题分析
-
-当前遇到的问题属于"响应式状态同步灾难"，主要问题：
-
-1. **状态分散**：多个 Composables 各自管理状态，难以追踪数据流
-2. **响应式失效**：computed/watch 在复杂场景下失效，难以调试
-3. **数据传递复杂**：props/computed/provide 多层传递，容易丢失
-4. **缺乏状态快照**：无法回溯状态变化历史
-5. **调试困难**：大量 console.log 散布在代码中，难以系统化
-
-## 改进方案
-
-### 1. 引入 Pinia 统一状态管理
-
-#### 1.1 安装 Pinia
-
-```bash
-npm install pinia
-```
-
-#### 1.2 创建 Store 结构
-
-```
-stores/
-  ├── db-cli/
-  │   ├── index.ts          # 主 store
-  │   ├── connection.ts     # 连接状态
-  │   ├── structure.ts      # 表结构状态
-  │   ├── result.ts         # 查询结果状态
-  │   ├── editor.ts         # 编辑器状态
-  │   └── message.ts        # 消息日志状态
-  └── devtools.ts           # 开发工具（状态快照/回放）
-```
-
-#### 1.3 核心 Store 设计
-
-**stores/db-cli/structure.ts** - 表结构状态管理
-
-```typescript
-import { defineStore } from 'pinia'
-import { ref, computed } from 'vue'
-
-export interface StructureInfo {
-  connectionId: number
-  database: string
-  tableName: string
-  dbType: 'mysql' | 'mongo' | 'redis'
-  nodeType: string
-}
-
-export interface StructureData {
-  type: string
-  columns?: any[]
-  database?: string
-  table?: string
-  // ... 其他字段
-}
-
-export const useStructureStore = defineStore('structure', () => {
-  // 状态定义
-  const loading = ref(false)
-  const error = ref<string | null>(null)
-  const data = ref<StructureData | null>(null)
-  const info = ref<StructureInfo | null>(null)
-  
-  // 计算属性（自动响应式）
-  const hasData = computed(() => data.value !== null && info.value !== null)
-  const isReady = computed(() => !loading.value && hasData.value)
-  
-  // Actions（统一的数据变更入口）
-  async function loadStructure(params: {
-    connectionId: number
-    database: string
-    tableName: string
-    dbType: 'mysql' | 'mongo' | 'redis'
-    nodeType: string
-  }) {
-    // 防止重复加载
-    if (loading.value) {
-      console.warn('结构正在加载中，跳过重复请求')
-      return
-    }
-    
-    try {
-      loading.value = true
-      error.value = null
-      
-      // 验证参数
-      if (params.nodeType === 'connection' || params.nodeType === 'database') {
-        info.value = {
-          ...params,
-          tableName: ''
-        }
-        data.value = null
-        return
-      }
-      
-      if (!params.tableName) {
-        info.value = {
-          ...params,
-          tableName: ''
-        }
-        data.value = null
-        return
-      }
-      
-      // 调用后端
-      if (!window.go?.main?.App?.GetTableStructure) {
-        throw new Error('Go 后端未就绪')
-      }
-      
-      const result = await window.go.main.App.GetTableStructure(
-        params.connectionId,
-        params.database,
-        params.tableName
-      )
-      
-      // 原子性更新（确保数据一致性）
-      data.value = result
-      info.value = params
-      
-      // 状态变更日志（开发环境）
-      if (import.meta.env.DEV) {
-        console.log('[StructureStore] 数据加载成功', { info: params, data: result })
-      }
-    } catch (err) {
-      const errorMessage = err instanceof Error ? err.message : '加载表结构失败'
-      error.value = errorMessage
-      data.value = null
-      info.value = null
-      
-      if (import.meta.env.DEV) {
-        console.error('[StructureStore] 加载失败', err)
-      }
-    } finally {
-      loading.value = false
-    }
-  }
-  
-  function clear() {
-    data.value = null
-    info.value = null
-    error.value = null
-  }
-  
-  function reset() {
-    loading.value = false
-    error.value = null
-    data.value = null
-    info.value = null
-  }
-  
-  return {
-    // 状态
-    loading,
-    error,
-    data,
-    info,
-    // 计算属性
-    hasData,
-    isReady,
-    // 方法
-    loadStructure,
-    clear,
-    reset
-  }
-})
-```
-
-**stores/db-cli/index.ts** - 主 Store
-
-```typescript
-import { defineStore } from 'pinia'
-import { useStructureStore } from './structure'
-import { useConnectionStore } from './connection'
-// ... 其他 stores
-
-// 组合 Store，提供统一访问入口
-export const useDbCliStore = () => {
-  return {
-    structure: useStructureStore(),
-    connection: useConnectionStore(),
-    // ... 其他 stores
-  }
-}
-```
-
-### 2. 组件中使用 Store
-
-**views/db-cli/index.vue**
-
-```typescript
-<script setup lang="ts">
-import { useStructureStore } from '@/stores/db-cli/structure'
-
-// 使用 Store（自动响应式，无需 computed）
-const structureStore = useStructureStore()
-
-// 直接使用，Vue 会自动追踪
-const handleTableStructure = async (data: TableStructureEvent) => {
-  // 单一切口，清晰的数据流
-  await structureStore.loadStructure({
-    connectionId: data.connectionId,
-    database: data.database,
-    tableName: data.tableName,
-    dbType: data.dbType,
-    nodeType: data.nodeType
-  })
-  
-  // 切换到结构 Tab
-  if (resultPanelRef.value) {
-    resultPanelRef.value.switchToStructureTab()
-  }
-}
-</script>
-
-<template>
-  <ResultPanel
-    :structure-loading="structureStore.loading"
-    :structure-error="structureStore.error"
-    :structure-data="structureStore.data"
-    :structure-info="structureStore.info"
-  />
-</template>
-```
-
-### 3. 状态调试工具
-
-**stores/devtools.ts** - 开发工具
-
-```typescript
-import { watch } from 'vue'
-
-/**
- * 状态变更追踪器（仅开发环境）
- */
-export function setupStateDebugger() {
-  if (!import.meta.env.DEV) return
-  
-  // 追踪所有 store 的状态变更
-  const stateHistory: Array<{
-    timestamp: number
-    store: string
-    action: string
-    oldValue: any
-    newValue: any
-  }> = []
-  
-  return {
-    log(store: string, action: string, oldValue: any, newValue: any) {
-      stateHistory.push({
-        timestamp: Date.now(),
-        store,
-        action,
-        oldValue: JSON.parse(JSON.stringify(oldValue)),
-        newValue: JSON.parse(JSON.stringify(newValue))
-      })
-      
-      console.group(`[${store}] ${action}`)
-      console.log('旧值:', oldValue)
-      console.log('新值:', newValue)
-      console.log('历史记录:', stateHistory.slice(-10))
-      console.groupEnd()
-    },
-    
-    getHistory() {
-      return stateHistory
-    },
-    
-    clearHistory() {
-      stateHistory.length = 0
-    }
-  }
-}
-```
-
-### 4. 类型安全增强
-
-**types/db-cli.ts**
-
-```typescript
-// 统一类型定义
-export type DbType = 'mysql' | 'mongo' | 'redis'
-export type NodeType = 'connection' | 'database' | 'table' | 'collection' | 'key'
-
-export interface ConnectionInfo {
-  id: number
-  name: string
-  type: DbType
-  host: string
-  port: number
-  database?: string
-}
-
-export interface StructureInfo {
-  connectionId: number
-  database: string
-  tableName: string
-  dbType: DbType
-  nodeType: NodeType
-}
-
-// 严格类型检查
-export function assertStructureInfo(info: unknown): asserts info is StructureInfo {
-  if (!info || typeof info !== 'object') {
-    throw new Error('Invalid StructureInfo')
-  }
-  // ... 类型检查逻辑
-}
-```
-
-### 5. 状态持久化策略
-
-```typescript
-// stores/db-cli/structure.ts
-import { defineStore } from 'pinia'
-import { useStorage } from '@vueuse/core'
-
-export const useStructureStore = defineStore('structure', () => {
-  // 使用 localStorage 持久化（可选）
-  const lastStructureInfo = useStorage<StructureInfo | null>(
-    'db-cli-last-structure-info',
-    null
-  )
-  
-  // 恢复上次查看的结构
-  function restoreLastStructure() {
-    if (lastStructureInfo.value) {
-      loadStructure(lastStructureInfo.value)
-    }
-  }
-  
-  // 在 loadStructure 中保存
-  async function loadStructure(params: StructureInfo) {
-    // ... 加载逻辑
-    info.value = params
-    lastStructureInfo.value = params // 自动保存到 localStorage
-  }
-  
-  return { /* ... */ }
-})
-```
-
-### 6. 错误边界和恢复机制
-
-```typescript
-// stores/db-cli/structure.ts
-export const useStructureStore = defineStore('structure', () => {
-  const retryCount = ref(0)
-  const maxRetries = 3
-  
-  async function loadStructure(params: StructureInfo, retry = 0) {
-    try {
-      // ... 加载逻辑
-      retryCount.value = 0 // 成功后重置
-    } catch (err) {
-      if (retry < maxRetries) {
-        console.warn(`[StructureStore] 重试加载 (${retry + 1}/${maxRetries})`)
-        await new Promise(resolve => setTimeout(resolve, 1000 * (retry + 1)))
-        return loadStructure(params, retry + 1)
-      }
-      // 超过重试次数，记录错误
-      error.value = `加载失败（已重试 ${maxRetries} 次）: ${err}`
-    }
-  }
-  
-  return { /* ... */ }
-})
-```
-
-### 7. 组件级状态同步检查
-
-```typescript
-// composables/useStateSync.ts
-import { watch, nextTick } from 'vue'
-
-/**
- * 状态同步检查器
- * 确保 Store 状态和组件 props 保持同步
- */
-export function useStateSync<T>(
-  storeValue: () => T,
-  propValue: () => T,
-  name: string
-) {
-  if (!import.meta.env.DEV) return
-  
-  watch(
-    () => storeValue(),
-    (storeVal) => {
-      nextTick(() => {
-        const propVal = propValue()
-        if (storeVal !== propVal) {
-          console.error(
-            `[StateSync] ${name} 不同步！`,
-            `Store: ${JSON.stringify(storeVal)}`,
-            `Prop: ${JSON.stringify(propVal)}`
-          )
-        }
-      })
-    },
-    { deep: true }
-  )
-}
-```
-
-### 8. 测试策略
-
-```typescript
-// stores/db-cli/structure.test.ts
-import { setActivePinia, createPinia } from 'pinia'
-import { useStructureStore } from './structure'
-
-describe('StructureStore', () => {
-  beforeEach(() => {
-    setActivePinia(createPinia())
-  })
-  
-  it('应该正确加载结构数据', async () => {
-    const store = useStructureStore()
-    
-    await store.loadStructure({
-      connectionId: 1,
-      database: 'test',
-      tableName: 'users',
-      dbType: 'mysql',
-      nodeType: 'table'
-    })
-    
-    expect(store.loading).toBe(false)
-    expect(store.data).not.toBeNull()
-    expect(store.info).not.toBeNull()
-  })
-  
-  it('应该在加载失败时设置错误', async () => {
-    // ... 测试错误处理
-  })
-})
-```
-
-## 迁移步骤
-
-1. **阶段一：引入 Pinia**
-   - 安装依赖
-   - 创建基础 Store 结构
-   - 在主应用初始化 Pinia
-
-2. **阶段二：迁移状态**
-   - 先迁移 structure store（当前问题所在）
-   - 逐步迁移其他 stores
-   - 保持双写一段时间（Composable + Store）
-
-3. **阶段三：清理代码**
-   - 移除旧的 Composables
-   - 统一使用 Store
-   - 添加类型定义
-
-4. **阶段四：优化和测试**
-   - 添加状态调试工具
-   - 编写单元测试
-   - 性能优化
-
-## 优势总结
-
-1. **单一数据源**：所有状态集中在 Store，避免分散
-2. **自动响应式**：Pinia 自动处理响应式，无需手动 computed
-3. **开发工具**：Pinia DevTools 可以可视化状态变化
-4. **类型安全**：TypeScript 支持更好
-5. **易于测试**：Store 可以独立测试
-6. **状态持久化**：内置支持 localStorage/sessionStorage
-7. **调试友好**：可以回放状态变更历史
-
-## 注意事项
-
-1. **不要过度使用**：简单的局部状态仍可使用 ref/reactive
-2. **避免循环依赖**：Store 之间不要相互依赖
-3. **性能考虑**：大数据量使用 shallowRef
-4. **SSR 兼容**：如需 SSR，注意状态初始化
-
-## 参考资料
-
-- [Pinia 官方文档](https://pinia.vuejs.org/)
-- [Vue 3 Composition API 最佳实践](https://vuejs.org/guide/extras/composition-api-faq.html)

docs/架构迁移完成指南.md

@@ -1,350 +0,0 @@
-# 架构迁移完成指南 - 事件驱动架构
-
-## 当前状态
-
-已创建以下新文件：
-
-1. **`web/src/views/db-cli/composables/useEventBus.ts`** - 事件总线
-   - 类型安全的事件定义
-   - 支持事件订阅/取消/触发
-   - 自动错误处理和日志
-
-2. **`web/src/views/db-cli/composables/useStructureStore.ts`** - 新的表结构 Store
-   - 单例模式，全局共享状态
-   - 事件驱动的状态更新
-   - 清晰的日志追踪
-
-3. **`web/src/views/db-cli/composables/useStructureStoreLegacy.ts`** - 旧版本（已重命名）
-   - 原 `useStructureState.ts` 的副本
-   - 保留用于兼容和参考
-
-4. **`web/src/views/db-cli/composables/MIGRATION.md`** - 迁移文档
-   - 详细的对表和迁移步骤
-   - 使用示例和注意事项
-
-## 手动完成迁移步骤
-
-### 步骤 1：修改 `index.vue` 的导入
-
-**位置**：`web/src/views/db-cli/index.vue` 第 120 行
-
-**原代码**：
-```typescript
-import { useStructureState } from './composables/useStructureState'
-```
-
-**修改为**：
-```typescript
-import { useStructureStore } from './composables/useStructureStore'
-```
-
----
-
-### 步骤 2：替换状态初始化（第 166-219 行）
-
-**原代码**（删除第 166-219 行）：
-```typescript
-const structureState = useStructureState()
-const {
-  structureLoading,
-  structureError,
-  structureData,
-  structureInfo,
-  loadStructure,
-  clearStructure,
-  refreshStructure
-} = structureState
-
-// 使用计算属性确保响应式传递到子组件
-const computedStructureLoading = computed(() => {
-  const val = structureState.structureLoading.value
-  console.log('🔵 computedStructureLoading 计算:', val)
-  return val
-})
-const computedStructureError = computed(() => {
-  const val = structureState.structureError.value
-  console.log('🔵 computedStructureError 计算:', val)
-  return val
-})
-const computedStructureData = computed(() => {
-  const val = structureState.structureData.value
-  console.log('🔵 computedStructureData 计算:', val)
-  return val
-})
-const computedStructureInfo = computed(() => {
-  const val = structureState.structureInfo.value
-  console.log('🔵 computedStructureInfo 计算:', val)
-  return val
-})
-
-// 添加调试监听，检查响应式
-watch(() => structureState.structureInfo.value, (newVal, oldVal) => {
-  // ... 所有 watch 代码
-}, { deep: true, immediate: true })
-watch(() => structureState.structureData.value, (newVal, oldVal) => {
-  // ... 所有 watch 代码
-}, { deep: true, immediate: true })
-```
-
-**替换为**（在第 164 行之后添加）：
-```typescript
-// 新架构：使用单例 Store（事件驱动）
-const structureStore = useStructureStore()
-// 直接使用 Store 的状态（无需计算属性，无需 watch）
-// 状态是只读的，通过 Store 方法修改
-```
-
----
-
-### 步骤 3：修改组件传参（第 65-68 行）
-
-**原代码**：
-```vue
-<ResultPanel
-  :structure-loading="computedStructureLoading"
-  :structure-error="computedStructureError"
-  :structure-data="computedStructureData"
-  :structure-info="computedStructureInfo || undefined"
-  :edit-mode="structureEditMode"
-  @toggle-editor="toggleEditor"
-  @refresh-structure="refreshStructure"
-  @switch-to-edit-mode="handleSwitchToEditMode"
-  @switch-to-view-mode="handleSwitchToViewMode"
-  @save-structure="handleSaveStructure"
-  @cancel-edit="handleCancelEdit"
-/>
-```
-
-**修改为**：
-```vue
-<ResultPanel
-  :structure-loading="structureStore.loading"
-  :structure-error="structureStore.error"
-  :structure-data="structureStore.data"
-  :structure-info="structureStore.info"
-  :edit-mode="structureEditMode"
-  @toggle-editor="toggleEditor"
-  @refresh-structure="structureStore.refreshStructure"
-  @switch-to-edit-mode="handleSwitchToEditMode"
-  @switch-to-view-mode="handleSwitchToViewMode"
-  @save-structure="handleSaveStructure"
-  @cancel-edit="handleCancelEdit"
-/>
-```
-
----
-
-### 步骤 4：修改 `handleTableStructure` 函数（第 357-389 行）
-
-**原代码**：
-```typescript
-const handleTableStructure = async (data: TableStructureEvent) => {
-  console.log('handleTableStructure 被调用:', data)
-  
-  // ... Tab 切换代码 ...
-
-  // 加载表结构数据（在Tab切换后加载，确保用户能看到加载状态）
-  try {
-    await loadStructure(
-      data.connectionId,
-      data.database,
-      data.tableName,
-      data.dbType,
-      data.nodeType
-    )
-    // ... 大量调试日志 ...
-  } catch (error) {
-    console.error('handleTableStructure 出错:', error)
-  }
-}
-```
-
-**修改为**：
-```typescript
-const handleTableStructure = async (data: TableStructureEvent) => {
-  console.log('🚀 handleTableStructure 被调用:', data)
-  
-  // 如果结果面板隐藏，自动显示编辑器（这样结果面板也会显示）
-  if (!editorVisible.value) {
-    toggleEditor()
-  }
-  
-  // 先切换到结果面板的"结构"Tab（确保Tab可见）
-  if (resultPanelRef.value) {
-    (resultPanelRef.value as any).switchToStructureTab()
-  }
-  
-  // 等待一下确保Tab切换完成
-  await new Promise(resolve => setTimeout(resolve, 100))
-  
-  // 新架构：直接调用 Store 的 loadStructure 方法
-  // Store 会自动管理状态和事件通知，无需手动追踪
-  await structureStore.loadStructure(
-    data.connectionId,
-    data.database,
-    data.tableName,
-    data.dbType,
-    data.nodeType
-  )
-  
-  console.log('✅ 加载完成，Store 当前状态:', {
-    loading: structureStore.loading.value,
-    data: structureStore.data.value,
-    info: structureStore.info.value,
-    error: structureStore.error.value
-  })
-}
-```
-
----
-
-### 步骤 5：修改 `handleRefreshStructure` 函数（第 456-462 行）
-
-**原代码**：
-```typescript
-const handleRefreshStructure = async () => {
-  await refreshStructure()
-}
-```
-
-**修改为**：
-```typescript
-const handleRefreshStructure = async () => {
-  await structureStore.refreshStructure()
-}
-```
-
----
-
-### 步骤 6：删除未使用的导入
-
-检查是否有其他 `useStructureState` 的使用，全部替换为 `useStructureStore`
-
----
-
-## 验证迁移
-
-完成以上步骤后，验证以下内容：
-
-### 1. 检查日志输出
-
-运行应用，点击表结构，应该看到以下日志：
-
-```
-🚀 handleTableStructure 被调用: { connectionId: 6, database: 'flux_pro', tableName: 'clue_info', dbType: 'mysql', nodeType: 'table' }
-📢 事件触发 [structure:loading]: { loading: true }
-🏪 Store.loadStructure 开始: { connectionId: 6, database: 'flux_pro', tableName: 'clue_info', dbType: 'mysql', nodeType: 'table' }
-🏪 表结构加载成功: { connectionId: 6, database: 'flux_pro', tableName: 'clue_info', result: {...} }
-🏪 Store.setData: { data: {...}, info: {...} }
-📢 事件触发 [structure:data]: { data: {...}, info: {...} }
-📢 事件触发 [structure:loading]: { loading: false }
-✅ 加载完成，Store 当前状态: { loading: false, data: {...}, info: {...}, error: '' }
-```
-
-### 2. 检查界面
-
-切换到"结构"标签页，应该能看到：
-- ✅ 红色测试框（如果存在）
-- ✅ 调试信息块显示正确的数据
-- ✅ 表结构数据正常显示
-
-### 3. 删除调试代码
-
-确认功能正常后，删除：
-- `ResultPanel.vue` 中的红色调试框
-- `ResultPanel.vue` 中的全局调试信息
-- `index.vue` 中不必要的日志
-
----
-
-## 新架构的优势
-
-### 1. 单一数据源
-- 所有状态集中在 Store
-- 避免多个 Composable 实例
-- 全局共享，不会丢失
-
-### 2. 事件驱动
-- 所有状态变更自动通知
-- 可追踪完整的事件流
-- 易于调试和问题定位
-
-### 3. 自动响应式
-- Store 自动处理响应式
-- 无需手动计算属性
-- 无需 watch 监听
-
-### 4. 类型安全
-- 完整的 TypeScript 类型定义
-- 事件和状态都有类型约束
-- 编译时错误检查
-
-### 5. 清晰的日志
-- 所有关键操作都有日志
-- 使用 emoji 标识不同的日志来源
-- 易于过滤和搜索
-
----
-
-## 故障排除
-
-### 问题：Store 数据为 null
-
-**可能原因**：
-1. 组件未正确引用 Store
-2. 事件未正确触发
-3. Store 方法未正确调用
-
-**解决方法**：
-1. 检查控制台是否有 `🏪` 开头的日志
-2. 检查是否有 `📢` 开头的日志
-3. 确认 Store 是单例（只有一次 `useStructureStore` 调用）
-
-### 问题：Tab 内容不显示
-
-**可能原因**：
-1. Arco Tabs 配置问题
-2. CSS 样式冲突
-3. 数据未正确传递
-
-**解决方法**：
-1. 检查 props 是否正确传递
-2. 检查 CSS 中 `display: flex !important` 是否生效
-3. 检查浏览器开发工具中的元素状态
-
----
-
-## 后续改进
-
-1. **引入 Pinia**（可选）
-   - 更强大的状态管理
-   - 内置 DevTools 支持
-   - 持久化支持
-
-2. **添加单元测试**
-   - 测试 Store 的各种场景
-   - 测试事件总线的可靠性
-   - 提高代码质量
-
-3. **性能优化**
-   - 使用 `shallowRef` 处理大数据
-   - 添加防抖和节流
-   - 优化事件监听
-
-4. **错误边界**
-   - 全局错误捕获
-   - 错误恢复机制
-   - 用户友好的错误提示
-
----
-
-## 总结
-
-新的事件驱动架构解决了当前的核心问题：
-
-✅ **状态丢失问题** - 单例模式确保全局唯一实例
-✅ **响应式失效问题** - 自动事件通知，无需手动追踪
-✅ **调试困难问题** - 完整的日志体系，清晰的事件流
-✅ **组件通信问题** - 事件总线解耦，易于维护
-
-**下一步**：按照上述步骤手动完成代码迁移，然后测试验证。

go.mod

@@ -1,28 +1,37 @@
 module u-desk
 
-go 1.25.4
+go 1.25.6
 
 require (
+	github.com/chromedp/cdproto v0.0.0-20250724212937-08a3db8b4327
+	github.com/chromedp/chromedp v0.14.2
 	github.com/glebarez/sqlite v1.11.0
 	github.com/go-sql-driver/mysql v1.9.3
 	github.com/redis/go-redis/v9 v9.17.3
 	github.com/shirou/gopsutil/v3 v3.24.5
-	github.com/wailsapp/wails/v2 v2.11.0
+	github.com/wailsapp/wails/v2 v2.12.0
-	go.mongodb.org/mongo-driver v1.17.7
+	github.com/yuin/goldmark v1.8.2
+	go.mongodb.org/mongo-driver/v2 v2.5.0
+	golang.org/x/sys v0.40.0
 	gorm.io/driver/mysql v1.6.0
 	gorm.io/gorm v1.31.1
 )
 
 require (
 	filippo.io/edwards25519 v1.1.0 // indirect
+	git.sr.ht/~jackmordaunt/go-toast/v2 v2.0.3 // indirect
 	github.com/bep/debounce v1.2.1 // indirect
 	github.com/cespare/xxhash/v2 v2.3.0 // indirect
+	github.com/chromedp/sysutil v1.1.0 // indirect
 	github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f // indirect
 	github.com/dustin/go-humanize v1.0.1 // indirect
 	github.com/glebarez/go-sqlite v1.22.0 // indirect
+	github.com/go-json-experiment/json v0.0.0-20250725192818-e39067aee2d2 // indirect
 	github.com/go-ole/go-ole v1.3.0 // indirect
+	github.com/gobwas/httphead v0.1.0 // indirect
+	github.com/gobwas/pool v0.2.1 // indirect
+	github.com/gobwas/ws v1.4.0 // indirect
 	github.com/godbus/dbus/v5 v5.2.2 // indirect
-	github.com/golang/snappy v1.0.0 // indirect
 	github.com/google/uuid v1.6.0 // indirect
 	github.com/gorilla/websocket v1.5.3 // indirect
 	github.com/jchv/go-winloader v0.0.0-20250406163304-c1995be93bd1 // indirect
@@ -38,7 +47,6 @@ require (
 	github.com/lufia/plan9stats v0.0.0-20251013123823-9fd1530e3ec3 // indirect
 	github.com/mattn/go-colorable v0.1.14 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
-	github.com/montanaflynn/stats v0.7.1 // indirect
 	github.com/ncruces/go-strftime v1.0.0 // indirect
 	github.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c // indirect
 	github.com/pkg/errors v0.9.1 // indirect
@@ -63,7 +71,6 @@ require (
 	golang.org/x/exp v0.0.0-20260112195511-716be5621a96 // indirect
 	golang.org/x/net v0.49.0 // indirect
 	golang.org/x/sync v0.19.0 // indirect
-	golang.org/x/sys v0.40.0 // indirect
 	golang.org/x/text v0.33.0 // indirect
 	modernc.org/libc v1.67.7 // indirect
 	modernc.org/mathutil v1.7.1 // indirect

go.sum

@@ -1,5 +1,7 @@
 filippo.io/edwards25519 v1.1.0 h1:FNf4tywRC1HmFuKW5xopWpigGjJKiJSV0Cqo0cJWDaA=
 filippo.io/edwards25519 v1.1.0/go.mod h1:BxyFTGdWcka3PhytdK4V28tE5sGfRvvvRV7EaN4VDT4=
+git.sr.ht/~jackmordaunt/go-toast/v2 v2.0.3 h1:N3IGoHHp9pb6mj1cbXbuaSXV/UMKwmbKLf53nQmtqMA=
+git.sr.ht/~jackmordaunt/go-toast/v2 v2.0.3/go.mod h1:QtOLZGz8olr4qH2vWK0QH0w0O4T9fEIjMuWpKUsH7nc=
 github.com/bep/debounce v1.2.1 h1:v67fRdBA9UQu2NhLFXrSg0Brw7CexQekrBwDMM8bzeY=
 github.com/bep/debounce v1.2.1/go.mod h1:H8yggRPQKLUhUoqrJC1bO2xNya7vanpDl7xR3ISbCJ0=
 github.com/bsm/ginkgo/v2 v2.12.0 h1:Ny8MWAHyOepLGlLKYmXG4IEkioBysk6GpaRTLC8zwWs=
@@ -8,6 +10,12 @@ github.com/bsm/gomega v1.27.10 h1:yeMWxP2pV2fG3FgAODIY8EiRE3dy0aeFYt4l7wh6yKA=
 github.com/bsm/gomega v1.27.10/go.mod h1:JyEr/xRbxbtgWNi8tIEVPUYZ5Dzef52k01W3YH0H+O0=
 github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs=
 github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
+github.com/chromedp/cdproto v0.0.0-20250724212937-08a3db8b4327 h1:UQ4AU+BGti3Sy/aLU8KVseYKNALcX9UXY6DfpwQ6J8E=
+github.com/chromedp/cdproto v0.0.0-20250724212937-08a3db8b4327/go.mod h1:NItd7aLkcfOA/dcMXvl8p1u+lQqioRMq/SqDp71Pb/k=
+github.com/chromedp/chromedp v0.14.2 h1:r3b/WtwM50RsBZHMUm9fsNhhzRStTHrKdr2zmwbZSzM=
+github.com/chromedp/chromedp v0.14.2/go.mod h1:rHzAv60xDE7VNy/MYtTUrYreSc0ujt2O1/C3bzctYBo=
+github.com/chromedp/sysutil v1.1.0 h1:PUFNv5EcprjqXZD9nJb9b/c9ibAbxiYo4exNWZyipwM=
+github.com/chromedp/sysutil v1.1.0/go.mod h1:WiThHUdltqCNKGc4gaU50XgYjwjYIhKWoHGPTUfWTJ8=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f h1:lO4WD4F/rVNCu3HqELle0jiPLLBs70cWOduZpkS1E78=
@@ -18,15 +26,21 @@ github.com/glebarez/go-sqlite v1.22.0 h1:uAcMJhaA6r3LHMTFgP0SifzgXg46yJkgxqyuyec
 github.com/glebarez/go-sqlite v1.22.0/go.mod h1:PlBIdHe0+aUEFn+r2/uthrWq4FxbzugL0L8Li6yQJbc=
 github.com/glebarez/sqlite v1.11.0 h1:wSG0irqzP6VurnMEpFGer5Li19RpIRi2qvQz++w0GMw=
 github.com/glebarez/sqlite v1.11.0/go.mod h1:h8/o8j5wiAsqSPoWELDUdJXhjAhsVliSn7bWZjOhrgQ=
+github.com/go-json-experiment/json v0.0.0-20250725192818-e39067aee2d2 h1:iizUGZ9pEquQS5jTGkh4AqeeHCMbfbjeb0zMt0aEFzs=
+github.com/go-json-experiment/json v0.0.0-20250725192818-e39067aee2d2/go.mod h1:TiCD2a1pcmjd7YnhGH0f/zKNcCD06B029pHhzV23c2M=
 github.com/go-ole/go-ole v1.2.6/go.mod h1:pprOEPIfldk/42T2oK7lQ4v4JSDwmV0As9GaiUsvbm0=
 github.com/go-ole/go-ole v1.3.0 h1:Dt6ye7+vXGIKZ7Xtk4s6/xVdGDQynvom7xCFEdWr6uE=
 github.com/go-ole/go-ole v1.3.0/go.mod h1:5LS6F96DhAwUc7C+1HLexzMXY1xGRSryjyPPKW6zv78=
 github.com/go-sql-driver/mysql v1.9.3 h1:U/N249h2WzJ3Ukj8SowVFjdtZKfu9vlLZxjPXV1aweo=
 github.com/go-sql-driver/mysql v1.9.3/go.mod h1:qn46aNg1333BRMNU69Lq93t8du/dwxI64Gl8i5p1WMU=
+github.com/gobwas/httphead v0.1.0 h1:exrUm0f4YX0L7EBwZHuCF4GDp8aJfVeBrlLQrs6NqWU=
+github.com/gobwas/httphead v0.1.0/go.mod h1:O/RXo79gxV8G+RqlR/otEwx4Q36zl9rqC5u12GKvMCM=
+github.com/gobwas/pool v0.2.1 h1:xfeeEhW7pwmX8nuLVlqbzVc7udMDrwetjEv+TZIz1og=
+github.com/gobwas/pool v0.2.1/go.mod h1:q8bcK0KcYlCgd9e7WYLm9LpyS+YeLd8JVDW6WezmKEw=
+github.com/gobwas/ws v1.4.0 h1:CTaoG1tojrh4ucGPcoJFiAQUAsEWekEWvLy7GsVNqGs=
+github.com/gobwas/ws v1.4.0/go.mod h1:G3gNqMNtPppf5XUz7O4shetPpcZ1VJ7zt18dlUeakrc=
 github.com/godbus/dbus/v5 v5.2.2 h1:TUR3TgtSVDmjiXOgAAyaZbYmIeP3DPkld3jgKGV8mXQ=
 github.com/godbus/dbus/v5 v5.2.2/go.mod h1:3AAv2+hPq5rdnr5txxxRwiGjPXamgoIHgz9FPBfOp3c=
-github.com/golang/snappy v1.0.0 h1:Oy607GVXHs7RtbggtPBnr2RmDArIsAefDwvrdWvRhGs=
-github.com/golang/snappy v1.0.0/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
 github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
 github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
 github.com/google/pprof v0.0.0-20250317173921-a4b03ec1a45e h1:ijClszYn+mADRFY17kjQEVQ1XRhq2/JR1M3sGqeJoxs=
@@ -59,6 +73,8 @@ github.com/leaanthony/slicer v1.6.0 h1:1RFP5uiPJvT93TAHi+ipd3NACobkW53yUiBqZheE/
 github.com/leaanthony/slicer v1.6.0/go.mod h1:o/Iz29g7LN0GqH3aMjWAe90381nyZlDNquK+mtH2Fj8=
 github.com/leaanthony/u v1.1.1 h1:TUFjwDGlNX+WuwVEzDqQwC2lOv0P4uhTQw7CMFdiK7M=
 github.com/leaanthony/u v1.1.1/go.mod h1:9+o6hejoRljvZ3BzdYlVL0JYCwtnAsVuN9pVTQcaRfI=
+github.com/ledongthuc/pdf v0.0.0-20220302134840-0c2507a12d80 h1:6Yzfa6GP0rIo/kULo2bwGEkFvCePZ3qHDDTC3/J9Swo=
+github.com/ledongthuc/pdf v0.0.0-20220302134840-0c2507a12d80/go.mod h1:imJHygn/1yfhB7XSJJKlFZKl/J+dCPAknuiaGOshXAs=
 github.com/lufia/plan9stats v0.0.0-20251013123823-9fd1530e3ec3 h1:PwQumkgq4/acIiZhtifTV5OUqqiP82UAl0h87xj/l9k=
 github.com/lufia/plan9stats v0.0.0-20251013123823-9fd1530e3ec3/go.mod h1:autxFIvghDt3jPTLoqZ9OZ7s9qTGNAWmYCjVFWPX/zg=
 github.com/matryer/is v1.4.0/go.mod h1:8I/i5uYgLzgsgEloJE1U6xx5HkBQpAZvepWuujKwMRU=
@@ -68,10 +84,10 @@ github.com/mattn/go-colorable v0.1.14 h1:9A9LHSqF/7dyVVX6g0U9cwm9pG3kP9gSzcuIPHP
 github.com/mattn/go-colorable v0.1.14/go.mod h1:6LmQG8QLFO4G5z1gPvYEzlUgJ2wF+stgPZH1UqBm1s8=
 github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
 github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
-github.com/montanaflynn/stats v0.7.1 h1:etflOAAHORrCC44V+aR6Ftzort912ZU+YLiSTuV8eaE=
-github.com/montanaflynn/stats v0.7.1/go.mod h1:etXPPgVO6n31NxCd9KQUMvCM+ve0ruNzt6R8Bnaayow=
 github.com/ncruces/go-strftime v1.0.0 h1:HMFp8mLCTPp341M/ZnA4qaf7ZlsbTc+miZjCLOFAw7w=
 github.com/ncruces/go-strftime v1.0.0/go.mod h1:Fwc5htZGVVkseilnfgOVb9mKy6w1naJmn9CehxcKcls=
+github.com/orisano/pixelmatch v0.0.0-20220722002657-fb0b55479cde h1:x0TT0RDC7UhAVbbWWBzr41ElhJx5tXPWkIHA2HWPRuw=
+github.com/orisano/pixelmatch v0.0.0-20220722002657-fb0b55479cde/go.mod h1:nZgzbfBr3hhjoZnS66nKrHmduYNpc34ny7RK4z5/HM0=
 github.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c h1:+mdjkGKdHQG3305AYmdv1U2eRNDiU2ErMBj1gwrq8eQ=
 github.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c/go.mod h1:7rwL4CYBLnjLxUqIJNnCWiEdr3bn6IUYi15bNlnbCCU=
 github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
@@ -111,8 +127,8 @@ github.com/wailsapp/go-webview2 v1.0.23 h1:jmv8qhz1lHibCc79bMM/a/FqOnnzOGEisLav+
 github.com/wailsapp/go-webview2 v1.0.23/go.mod h1:qJmWAmAmaniuKGZPWwne+uor3AHMB5PFhqiK0Bbj8kc=
 github.com/wailsapp/mimetype v1.4.1 h1:pQN9ycO7uo4vsUUuPeHEYoUkLVkaRntMnHJxVwYhwHs=
 github.com/wailsapp/mimetype v1.4.1/go.mod h1:9aV5k31bBOv5z6u+QP8TltzvNGJPmNJD4XlAL3U+j3o=
-github.com/wailsapp/wails/v2 v2.11.0 h1:seLacV8pqupq32IjS4Y7V8ucab0WZwtK6VvUVxSBtqQ=
+github.com/wailsapp/wails/v2 v2.12.0 h1:BHO/kLNWFHYjCzucxbzAYZWUjub1Tvb4cSguQozHn5c=
-github.com/wailsapp/wails/v2 v2.11.0/go.mod h1:jrf0ZaM6+GBc1wRmXsM8cIvzlg0karYin3erahI4+0k=
+github.com/wailsapp/wails/v2 v2.12.0/go.mod h1:mo1bzK1DEJrobt7YrBjgxvb5Sihb1mhAY09hppbibQg=
 github.com/xdg-go/pbkdf2 v1.0.0 h1:Su7DPu48wXMwC3bs7MCNG+z4FhcyEuz5dlvchbq0B0c=
 github.com/xdg-go/pbkdf2 v1.0.0/go.mod h1:jrpuAogTd400dnrH08LKmI/xc1MbPOebTwRqcT5RDeI=
 github.com/xdg-go/scram v1.2.0 h1:bYKF2AEwG5rqd1BumT4gAnvwU/M9nBp2pTSxeZw7Wvs=
@@ -122,10 +138,12 @@ github.com/xdg-go/stringprep v1.0.4/go.mod h1:mPGuuIYwz7CmR2bT9j4GbQqutWS1zV24gi
 github.com/youmark/pkcs8 v0.0.0-20240726163527-a2c0da244d78 h1:ilQV1hzziu+LLM3zUTJ0trRztfwgjqKnBWNtSRkbmwM=
 github.com/youmark/pkcs8 v0.0.0-20240726163527-a2c0da244d78/go.mod h1:aL8wCCfTfSfmXjznFBSZNN13rSJjlIOI1fUNAtF7rmI=
 github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
+github.com/yuin/goldmark v1.8.2 h1:kEGpgqJXdgbkhcOgBxkC0X0PmoPG1ZyoZ117rDVp4zE=
+github.com/yuin/goldmark v1.8.2/go.mod h1:ip/1k0VRfGynBgxOz0yCqHrbZXhcjxyuS66Brc7iBKg=
 github.com/yusufpapurcu/wmi v1.2.4 h1:zFUKzehAFReQwLys1b/iSMl+JQGSCSjtVqQn9bBrPo0=
 github.com/yusufpapurcu/wmi v1.2.4/go.mod h1:SBZ9tNy3G9/m5Oi98Zks0QjeHVDvuK0qfxQmPyzfmi0=
-go.mongodb.org/mongo-driver v1.17.7 h1:a9w+U3Vt67eYzcfq3k/OAv284/uUUkL0uP75VE5rCOU=
+go.mongodb.org/mongo-driver/v2 v2.5.0 h1:yXUhImUjjAInNcpTcAlPHiT7bIXhshCTL3jVBkF3xaE=
-go.mongodb.org/mongo-driver v1.17.7/go.mod h1:Hy04i7O2kC4RS06ZrhPRqj/u4DTYkFDAAccj+rVKqgQ=
+go.mongodb.org/mongo-driver/v2 v2.5.0/go.mod h1:yOI9kBsufol30iFsl1slpdq1I0eHPzybRWdyYUs8K/0=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
 golang.org/x/crypto v0.47.0 h1:V6e3FRj+n4dbpw86FJ8Fv7XVOql7TEwpHapKoMJ/GO8=

internal/api/config_api.go

@@ -135,3 +135,48 @@ func (api *ConfigAPI) SaveAppConfig(req SaveAppConfigRequest) (map[string]interf
 		"data":    nil,
 	}, nil
 }
+
+// MigrateTabConfig 迁移旧配置
+func (api *ConfigAPI) MigrateTabConfig() error {
+	config, _ := api.configService.GetTabConfig()
+	if config == nil {
+		return nil
+	}
+
+	// 检查是否包含 device
+	hasDevice := false
+	for _, tab := range config.AvailableTabs {
+		if tab.Key == "device" {
+			hasDevice = true
+			break
+		}
+	}
+	if !hasDevice {
+		return nil
+	}
+
+	// 过滤掉 device
+	newTabs := make([]service.TabDefinition, 0, len(config.AvailableTabs))
+	newVisible := make([]string, 0, len(config.VisibleTabs))
+	for _, tab := range config.AvailableTabs {
+		if tab.Key != "device" {
+			newTabs = append(newTabs, tab)
+		}
+	}
+	for _, key := range config.VisibleTabs {
+		if key != "device" {
+			newVisible = append(newVisible, key)
+		}
+	}
+
+	defaultTab := config.DefaultTab
+	if defaultTab == "device" {
+		defaultTab = "file-system"
+	}
+
+	return api.configService.SaveTabConfig(&service.TabConfig{
+		AvailableTabs: newTabs,
+		VisibleTabs:   newVisible,
+		DefaultTab:    defaultTab,
+	})
+}

internal/api/connection_api.go

@@ -21,29 +21,31 @@ func NewConnectionAPI() (*ConnectionAPI, error) {
 
 // SaveConnectionRequest 保存连接请求结构体
 type SaveConnectionRequest struct {
-	ID       uint   `json:"id"`
+	ID               uint   `json:"id"`
-	Name     string `json:"name"`
+	Name             string `json:"name"`
-	Type     string `json:"type"`
+	Type             string `json:"type"`
-	Host     string `json:"host"`
+	Host             string `json:"host"`
-	Port     int    `json:"port"`
+	Port             int    `json:"port"`
-	Username string `json:"username"`
+	Username         string `json:"username"`
-	Password string `json:"password"`
+	Password         string `json:"password"`
-	Database string `json:"database"`
+	Database         string `json:"database"`
-	Options  string `json:"options"`
+	Options          string `json:"options"`
+	VisibleDatabases string `json:"visible_databases"`
 }
 
 // SaveDbConnection 保存数据库连接配置
 func (api *ConnectionAPI) SaveDbConnection(req SaveConnectionRequest) error {
 	conn := &models.DbConnection{
-		ID:       req.ID,
+		ID:               req.ID,
-		Name:     req.Name,
+		Name:             req.Name,
-		Type:     req.Type,
+		Type:             req.Type,
-		Host:     req.Host,
+		Host:             req.Host,
-		Port:     req.Port,
+		Port:             req.Port,
-		Username: req.Username,
+		Username:         req.Username,
-		Password: req.Password,
+		Password:         req.Password,
-		Database: req.Database,
+		Database:         req.Database,
-		Options:  req.Options,
+		Options:          req.Options,
+		VisibleDatabases: req.VisibleDatabases,
 	}
 	return api.connService.SaveConnection(conn)
 }
@@ -59,16 +61,17 @@ func (api *ConnectionAPI) ListDbConnections() ([]map[string]interface{}, error)
 	timeFormat := "2006-01-02 15:04:05"
 	for i, conn := range connections {
 		result[i] = map[string]interface{}{
-			"id":         conn.ID,
+			"id":                conn.ID,
-			"name":       conn.Name,
+			"name":              conn.Name,
-			"type":       conn.Type,
+			"type":              conn.Type,
-			"host":       conn.Host,
+			"host":              conn.Host,
-			"port":       conn.Port,
+			"port":              conn.Port,
-			"username":   conn.Username,
+			"username":          conn.Username,
-			"database":   conn.Database,
+			"database":          conn.Database,
-			"options":    conn.Options,
+			"options":           conn.Options,
-			"created_at": conn.CreatedAt.Format(timeFormat),
+			"visible_databases": conn.VisibleDatabases,
-			"updated_at": conn.UpdatedAt.Format(timeFormat),
+			"created_at":        conn.CreatedAt.Format(timeFormat),
+			"updated_at":        conn.UpdatedAt.Format(timeFormat),
 		}
 	}
 	return result, nil
@@ -97,13 +100,29 @@ type TestConnectionRequest struct {
 // TestDbConnectionWithParams 测试数据库连接（直接传入参数，不保存数据）
 func (api *ConnectionAPI) TestDbConnectionWithParams(req TestConnectionRequest) error {
 	return api.connService.TestConnectionWithParams(
-		req.Type,
+		req.Type, req.Host, req.Port,
-		req.Host,
+		req.Username, req.Password, req.Database,
-		req.Port,
+		req.Options, req.ID,
-		req.Username,
+	)
-		req.Password,
+}
-		req.Database,
+
-		req.Options,
+// LoadAllDatabasesRequest 加载全部数据库请求结构体
-		req.ID,
+type LoadAllDatabasesRequest struct {
+	ID       uint   `json:"id"`
+	Type     string `json:"type"`
+	Host     string `json:"host"`
+	Port     int    `json:"port"`
+	Username string `json:"username"`
+	Password string `json:"password"`
+	Database string `json:"database"`
+	Options  string `json:"options"`
+}
+
+// LoadAllDatabases 加载全部数据库列表
+func (api *ConnectionAPI) LoadAllDatabases(req LoadAllDatabasesRequest) ([]string, error) {
+	return api.connService.LoadAllDatabases(
+		req.Type, req.Host, req.Port,
+		req.Username, req.Password, req.Database,
+		req.Options, req.ID,
 	)
 }

internal/api/pdf_api.go

@@ -0,0 +1,379 @@
+package api
+
+import (
+	"context"
+	"fmt"
+	"html"
+	"os"
+	"path/filepath"
+	"strings"
+	"time"
+
+	"github.com/chromedp/cdproto/page"
+	"github.com/chromedp/chromedp"
+	"github.com/yuin/goldmark"
+	"u-desk/internal/common"
+)
+
+// PdfExportRequest PDF导出请求结构体
+type PdfExportRequest struct {
+	Content    string `json:"content"`    // Markdown/HTML内容
+	Title      string `json:"title"`      // PDF标题
+	FileName   string `json:"fileName"`   // 文件名（不含扩展名）
+	FontSize   int    `json:"fontSize"`   // 字体大小
+	PageWidth  int    `json:"pageWidth"`  // 页面宽度（mm）
+	PageHeight int    `json:"pageHeight"` // 页面高度（mm）
+}
+
+// PdfExportResponse PDF导出响应结构体
+type PdfExportResponse struct {
+	Success bool   `json:"success"`
+	Message string `json:"message"`
+	Path    string `json:"path"`  // PDF文件保存路径
+	Size    int64  `json:"size"`  // 文件大小（字节）
+}
+
+// PdfAPI PDF导出API
+type PdfAPI struct {
+	// 可以在这里添加依赖，如文件系统服务等
+}
+
+// NewPdfAPI 创建PDF导出API
+func NewPdfAPI() (*PdfAPI, error) {
+	return &PdfAPI{}, nil
+}
+
+// ExportMarkdownToPDF 将Markdown内容导出为PDF - 使用chromedp实现
+func (api *PdfAPI) ExportMarkdownToPDF(req PdfExportRequest) (*PdfExportResponse, error) {
+	// 验证参数
+	if strings.TrimSpace(req.Content) == "" {
+		return nil, fmt.Errorf("内容不能为空")
+	}
+
+	if strings.TrimSpace(req.FileName) == "" {
+		req.FileName = "document_" + time.Now().Format("20060102_150405")
+	}
+
+	if req.FontSize <= 0 {
+		req.FontSize = 12
+	}
+
+	// 设置默认页面尺寸（A4）
+	if req.PageWidth <= 0 {
+		req.PageWidth = 210
+	}
+	if req.PageHeight <= 0 {
+		req.PageHeight = 297
+	}
+
+	// 将Markdown转换为HTML
+	htmlContent := api.markdownToHTML(req.Content, req.Title, req.FontSize)
+
+	// 使用chromedp生成PDF
+	pdfBuffer, err := api.generatePDFFromHTML(htmlContent, req.Title, req.PageWidth, req.PageHeight)
+	if err != nil {
+		return nil, fmt.Errorf("生成PDF失败: %v", err)
+	}
+
+	// 生成文件名
+	if !strings.HasSuffix(strings.ToLower(req.FileName), ".pdf") {
+		req.FileName += ".pdf"
+	}
+
+	// 获取用户桌面目录作为默认保存位置
+	saveDir := api.getDesktopDirectory()
+
+	// 确保目录存在
+	if err := os.MkdirAll(saveDir, 0755); err != nil {
+		return nil, fmt.Errorf("创建目录失败: %v", err)
+	}
+
+	// 完整保存路径
+	savePath := filepath.Join(saveDir, filepath.Base(req.FileName))
+
+	// 保存PDF文件
+	err = os.WriteFile(savePath, pdfBuffer, 0644)
+	if err != nil {
+		return nil, fmt.Errorf("保存PDF文件失败: %v", err)
+	}
+
+	// 获取文件信息
+	fileInfo, err := os.Stat(savePath)
+	if err != nil {
+		return nil, fmt.Errorf("获取文件信息失败: %v", err)
+	}
+
+	// 返回成功响应
+	return &PdfExportResponse{
+		Success: true,
+		Message: "PDF生成成功",
+		Path:    savePath,
+		Size:    fileInfo.Size(),
+	}, nil
+}
+
+// markdownToHTML 将Markdown转换为HTML
+func (api *PdfAPI) markdownToHTML(markdownContent string, title string, fontSize int) string {
+	// 基础HTML模板
+	htmlTemplate := `<!DOCTYPE html>
+<html lang="zh-CN">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <style>
+        body {
+            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, 'Helvetica Neue', Arial, sans-serif;
+            line-height: 1.6;
+            color: #333;
+            max-width: 800px;
+            margin: 0 auto;
+            padding: 40px 20px;
+            font-size: %dpx;
+        }
+        h1, h2, h3, h4, h5, h6 {
+            margin-top: 24px;
+            margin-bottom: 16px;
+            font-weight: 600;
+            line-height: 1.25;
+        }
+        h1 {
+            font-size: 2em;
+            border-bottom: 1px solid #eaecef;
+            padding-bottom: 0.3em;
+        }
+        h2 {
+            font-size: 1.5em;
+            border-bottom: 1px solid #eaecef;
+            padding-bottom: 0.3em;
+        }
+        h3 {
+            font-size: 1.25em;
+        }
+        h4 {
+            font-size: 1em;
+        }
+        h5 {
+            font-size: 0.875em;
+        }
+        h6 {
+            font-size: 0.85em;
+            color: #6a737d;
+        }
+        p {
+            margin-bottom: 16px;
+        }
+        blockquote {
+            margin: 0 0 16px;
+            padding: 0 1em;
+            color: #6a737d;
+            border-left: 0.25em solid #dfe2e5;
+        }
+        ul, ol {
+            padding-left: 2em;
+            margin-bottom: 16px;
+        }
+        li {
+            margin-bottom: 4px;
+        }
+        code {
+            font-family: 'SFMono-Regular', Consolas, 'Liberation Mono', Menlo, monospace;
+            background-color: rgba(27,31,35,0.05);
+            border-radius: 3px;
+            font-size: 85%;
+            margin: 0;
+            padding: 0.2em 0.4em;
+        }
+        pre {
+            background-color: #f6f8fa;
+            border-radius: 3px;
+            padding: 16px;
+            overflow: auto;
+            margin-bottom: 16px;
+        }
+        pre code {
+            background-color: transparent;
+            padding: 0;
+            margin: 0;
+            font-size: 100%;
+        }
+        table {
+            border-collapse: collapse;
+            width: 100%;
+            margin-bottom: 16px;
+            border: 1px solid #dfe2e5;
+        }
+        th, td {
+            padding: 8px 12px;
+            border: 1px solid #dfe2e5;
+            text-align: left;
+        }
+        th {
+            background-color: #f6f8fa;
+            font-weight: 600;
+        }
+        img {
+            max-width: 100%;
+            height: auto;
+            margin: 16px 0;
+        }
+        hr {
+            height: 0.25em;
+            padding: 0;
+            margin: 24px 0;
+            background-color: #e1e4e8;
+            border: 0;
+        }
+        .title {
+            text-align: center;
+            margin-bottom: 32px;
+            font-size: 1.5em;
+            color: #2c3e50;
+        }
+    </style>
+</head>
+<body>
+    <div class="title">%s</div>
+    %s
+</body>
+</html>`
+
+	// 标题处理
+	docTitle := ""
+	if title != "" {
+		docTitle = html.EscapeString(title)
+	} else {
+		docTitle = "文档"
+	}
+
+	// Markdown转HTML（使用goldmark）
+	var htmlContent string
+	var htmlBuf strings.Builder
+	if err := goldmark.Convert([]byte(markdownContent), &htmlBuf); err != nil {
+		htmlContent = "<p>Markdown 解析失败</p>"
+	} else {
+		htmlContent = htmlBuf.String()
+	}
+
+	// 生成完整的HTML
+	fullHTML := fmt.Sprintf(htmlTemplate, fontSize, docTitle, htmlContent)
+
+	return fullHTML
+}
+
+// generatePDFFromHTML 使用chromedp从HTML生成PDF
+func (api *PdfAPI) generatePDFFromHTML(htmlContent, title string, pageWidth, pageHeight int) ([]byte, error) {
+	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+	defer cancel()
+	// 配置chromedp选项
+	opts := []chromedp.ExecAllocatorOption{
+		chromedp.Flag("headless", true),
+		chromedp.Flag("disable-gpu", true),
+		chromedp.Flag("no-sandbox", true),
+		chromedp.Flag("disable-dev-shm-usage", true),
+		chromedp.Flag("disable-software-rasterizer", true),
+		chromedp.Flag("disable-extensions", true),
+		chromedp.Flag("disable-notifications", true),
+	}
+
+	// 在Windows上设置Chrome路径
+	if common.IsWindows() {
+		// 常见的Windows Chrome路径
+		chromePaths := []string{
+			"C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe",
+			"C:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe",
+			"C:\\Users\\" + os.Getenv("USERNAME") + "\\AppData\\Local\\Google\\Chrome\\Application\\chrome.exe",
+		}
+
+		for _, path := range chromePaths {
+			if _, err := os.Stat(path); err == nil {
+				opts = append(opts, chromedp.ExecPath(path))
+				break
+			}
+		}
+	}
+
+	// 创建执行分配器上下文
+	allocCtx, allocCancel := chromedp.NewExecAllocator(ctx, opts...)
+	defer allocCancel()
+
+	// 创建chromedp上下文
+	chromeCtx, chromeCancel := chromedp.NewContext(allocCtx)
+	defer chromeCancel()
+
+	// 创建一个临时的目录用于PDF生成
+	tempDir, err := os.MkdirTemp("", "pdf_gen")
+	if err != nil {
+		return nil, fmt.Errorf("创建临时目录失败: %v", err)
+	}
+	defer os.RemoveAll(tempDir)
+
+	// 将HTML写入临时文件
+	htmlFile := filepath.Join(tempDir, "document.html")
+	if err := os.WriteFile(htmlFile, []byte(htmlContent), 0644); err != nil {
+		return nil, fmt.Errorf("写入HTML文件失败: %v", err)
+	}
+
+	var buf []byte
+
+	// 使用 file URL 加载本地HTML文件
+	err = chromedp.Run(chromeCtx,
+		// 导航到HTML文件
+		chromedp.Navigate("file://"+htmlFile),
+		// 等待页面加载完成
+		chromedp.WaitReady("body"),
+		// 打印到PDF
+		chromedp.ActionFunc(func(ctx context.Context) error {
+			// 设置页面打印参数
+			printToPDF := page.PrintToPDF().
+				WithPrintBackground(true).
+				WithLandscape(false).
+				WithMarginTop(0).
+				WithMarginBottom(0).
+				WithMarginLeft(0).
+				WithMarginRight(0).
+				WithPaperWidth(float64(pageWidth) / 25.4). // mm to inches
+				WithPaperHeight(float64(pageHeight) / 25.4) // mm to inches
+
+			// 执行打印并获取PDF数据
+			var err error
+			buf, _, err = printToPDF.Do(ctx)
+			return err
+		}),
+	)
+
+	if err != nil {
+		return nil, fmt.Errorf("chromedp执行失败: %v", err)
+	}
+
+	return buf, nil
+}
+
+// getDesktopDirectory 获取用户桌面目录
+func (api *PdfAPI) getDesktopDirectory() string {
+	// Windows系统
+	if common.IsWindows() {
+		home := os.Getenv("USERPROFILE")
+		if home != "" {
+			return filepath.Join(home, "Desktop")
+		}
+	}
+	
+	// Linux/Mac系统
+	home := os.Getenv("HOME")
+	if home != "" {
+		return filepath.Join(home, "Desktop")
+	}
+	
+	// 备用：当前目录
+	return "."
+}
+
+// SelectDirectory 选择保存目录（简化版，实际应该使用Wails runtime）
+func (api *PdfAPI) SelectDirectory() (string, error) {
+	// 简化版：直接返回桌面目录
+	desktop := api.getDesktopDirectory()
+	if desktop == "." {
+		return "", fmt.Errorf("无法确定默认目录")
+	}
+	return desktop, nil
+}

internal/api/update_api.go

@@ -50,13 +50,6 @@ func (api *UpdateAPI) CheckUpdate() (map[string]interface{}, error) {
 // GetCurrentVersion 获取当前版本号
 func (api *UpdateAPI) GetCurrentVersion() (map[string]interface{}, error) {
 	version := service.GetCurrentVersion()
-
-	// 同步配置中的版本号
-	if config, err := service.LoadUpdateConfig(); err == nil && config.CurrentVersion != version {
-		config.CurrentVersion = version
-		service.SaveUpdateConfig(config)
-	}
-
 	return successResponse(map[string]interface{}{
 		"version": version,
 	}), nil
@@ -69,13 +62,6 @@ func (api *UpdateAPI) GetUpdateConfig() (map[string]interface{}, error) {
 		return errorResponse(err.Error()), nil
 	}
 
-	// 同步最新版本号
-	latestVersion := service.GetCurrentVersion()
-	if config.CurrentVersion != latestVersion {
-		config.CurrentVersion = latestVersion
-		service.SaveUpdateConfig(config)
-	}
-
 	return successResponse(map[string]interface{}{
 		"current_version":        config.CurrentVersion,
 		"last_check_time":        config.LastCheckTime.Format("2006-01-02 15:04:05"),

internal/common/constants.go

@@ -12,6 +12,3 @@ const (
 
 // DefaultVisibleTabs 默认可见的 Tabs
 var DefaultVisibleTabs = []string{TabDatabase, TabFileSystem, TabDevice}
-
-// DefaultTab 默认打开的 Tab
-const DefaultTab = TabDatabase

internal/common/path.go

@@ -3,43 +3,24 @@ package common
 import (
 	"os"
 	"path/filepath"
-	"runtime"
 )
 
 const (
 	// AppName 应用名称
 	AppName = "u-desk"
+
+	// AppDataDir 应用数据目录名称（带点号，表示隐藏目录）
+	AppDataDir = ".u-desk"
 )
 
 // GetUserDataDir 获取用户数据目录
 // 跨平台支持：Windows、macOS、Linux
+// 所有平台统一使用: ~/.u-desk
 func GetUserDataDir() string {
-	var basePath string
+	homeDir, err := os.UserHomeDir()
-
+	if err != nil {
-	switch runtime.GOOS {
+		return "."
-	case "windows":
-		// Windows: %LOCALAPPDATA% 或 %APPDATA%
-		basePath = os.Getenv("LOCALAPPDATA")
-		if basePath == "" {
-			basePath = os.Getenv("APPDATA")
-		}
-	case "darwin":
-		// macOS: ~/Library/Application Support
-		homeDir, err := os.UserHomeDir()
-		if err == nil {
-			basePath = filepath.Join(homeDir, "Library", "Application Support")
-		}
-	default:
-		// Linux: ~/.config
-		homeDir, err := os.UserHomeDir()
-		if err == nil {
-			basePath = filepath.Join(homeDir, ".config")
-		}
 	}
 
-	if basePath == "" {
+	return filepath.Join(homeDir, AppDataDir)
-		basePath = "."
-	}
-
-	return filepath.Join(basePath, AppName)
 }

internal/common/utils.go

@@ -2,6 +2,7 @@ package common
 
 import (
 	"fmt"
+	"runtime"
 )
 
 // InterfaceSliceToStringSlice 将 []interface{} 安全转换为 []string
@@ -54,3 +55,9 @@ func Difference[T comparable](a, b []T) []T {
 	}
 	return diff
 }
+
+// IsWindows 判断是否为Windows系统
+func IsWindows() bool {
+	return runtime.GOOS == "windows"
+}
+

internal/crypto/aes.go

@@ -7,20 +7,106 @@ import (
 	"encoding/base64"
 	"fmt"
 	"io"
+	"os"
+	"path/filepath"
+	"sync"
 )
 
+// 旧版硬编码密钥（用于兼容迁移已有加密数据）
+var legacyKey = []byte("go-desk-db-cli-key-32bytes123456")
+
 var (
-	// 默认密钥（实际应用中应该从配置文件或环境变量读取）
+	encryptionKey []byte
-	// AES-256 需要 32 字节密钥
+	keyOnce       sync.Once
-	// "go-desk-db-cli-key-32bytes123456" = 32 bytes
+	keyInitErr    error
-	defaultKey = []byte("go-desk-db-cli-key-32bytes123456") // 32 bytes for AES-256
 )
 
-func init() {
+// getKey 获取或创建机器唯一密钥
-	// 验证密钥长度
+// 首次启动时生成并持久化到用户配置目录，后续直接读取
-	if len(defaultKey) != 32 {
+func getKey() ([]byte, error) {
-		panic(fmt.Sprintf("AES-256 密钥长度必须为 32 字节，当前为 %d 字节", len(defaultKey)))
+	keyOnce.Do(func() {
+		keyFile, err := getKeyFilePath()
+		if err != nil {
+			keyInitErr = fmt.Errorf("获取密钥路径失败: %v", err)
+			return
+		}
+
+		// 尝试读取已有密钥
+		if data, err := os.ReadFile(keyFile); err == nil && len(data) == 32 {
+			encryptionKey = data
+			return
+		}
+
+		// 生成新密钥
+		newKey := make([]byte, 32)
+		if _, err := io.ReadFull(rand.Reader, newKey); err != nil {
+			keyInitErr = fmt.Errorf("生成密钥失败: %v", err)
+			return
+		}
+
+		// 持久化密钥
+		dir := filepath.Dir(keyFile)
+		if err := os.MkdirAll(dir, 0700); err != nil {
+			keyInitErr = fmt.Errorf("创建密钥目录失败: %v", err)
+			return
+		}
+		if err := os.WriteFile(keyFile, newKey, 0600); err != nil {
+			keyInitErr = fmt.Errorf("保存密钥失败: %v", err)
+			return
+		}
+
+		encryptionKey = newKey
+	})
+
+	return encryptionKey, keyInitErr
+}
+
+// getKeyFilePath 返回密钥文件路径
+func getKeyFilePath() (string, error) {
+	configDir, err := os.UserConfigDir()
+	if err != nil {
+		return "", err
 	}
+	return filepath.Join(configDir, "u-desk", ".aes-key"), nil
+}
+
+// DecryptPasswordV2 使用指定密钥解密（用于密钥迁移）
+func DecryptPasswordV2(encryptedPassword string, key []byte) (string, error) {
+	if encryptedPassword == "" {
+		return "", nil
+	}
+	if len(encryptedPassword) < 10 {
+		return "", nil
+	}
+
+	ciphertext, err := base64.StdEncoding.DecodeString(encryptedPassword)
+	if err != nil {
+		return "", fmt.Errorf("解码失败: %v", err)
+	}
+
+	block, err := aes.NewCipher(key)
+	if err != nil {
+		return "", fmt.Errorf("创建解密器失败: %v", err)
+	}
+
+	aesGCM, err := cipher.NewGCM(block)
+	if err != nil {
+		return "", fmt.Errorf("创建 GCM 失败: %v", err)
+	}
+
+	nonceSize := aesGCM.NonceSize()
+	if len(ciphertext) < nonceSize {
+		return "", fmt.Errorf("密文长度不足")
+	}
+
+	nonce, ciphertext := ciphertext[:nonceSize], ciphertext[nonceSize:]
+
+	plaintext, err := aesGCM.Open(nil, nonce, ciphertext, nil)
+	if err != nil {
+		return "", fmt.Errorf("解密失败: %v", err)
+	}
+
+	return string(plaintext), nil
 }
 
 // EncryptPassword 加密密码
@@ -29,7 +115,12 @@ func EncryptPassword(password string) (string, error) {
 		return "", nil
 	}
 
-	block, err := aes.NewCipher(defaultKey)
+	key, err := getKey()
+	if err != nil {
+		return "", fmt.Errorf("获取加密密钥失败: %v", err)
+	}
+
+	block, err := aes.NewCipher(key)
 	if err != nil {
 		return "", fmt.Errorf("创建加密器失败: %v", err)
 	}
@@ -53,47 +144,32 @@ func EncryptPassword(password string) (string, error) {
 	return base64.StdEncoding.EncodeToString(ciphertext), nil
 }
 
-// DecryptPassword 解密密码
+// DecryptPassword 解密密码（自动回退旧密钥兼容旧数据）
 func DecryptPassword(encryptedPassword string) (string, error) {
 	if encryptedPassword == "" {
 		return "", nil
 	}
-
-	// 如果加密字符串为空或格式不正确，返回空字符串
 	if len(encryptedPassword) < 10 {
 		return "", nil
 	}
 
-	// Base64 解码
+	key, err := getKey()
-	ciphertext, err := base64.StdEncoding.DecodeString(encryptedPassword)
 	if err != nil {
-		return "", fmt.Errorf("解码失败: %v", err)
+		return "", fmt.Errorf("获取解密密钥失败: %v", err)
 	}
 
-	block, err := aes.NewCipher(defaultKey)
+	// 先用新密钥尝试解密
-	if err != nil {
+	result, err := DecryptPasswordV2(encryptedPassword, key)
-		return "", fmt.Errorf("创建解密器失败: %v", err)
+	if err == nil {
+		return result, nil
 	}
 
-	// 使用 GCM 模式
+	// 新密钥失败，尝试旧密钥（兼容已迁移的旧数据）
-	aesGCM, err := cipher.NewGCM(block)
+	result, err = DecryptPasswordV2(encryptedPassword, legacyKey)
-	if err != nil {
+	if err == nil {
-		return "", fmt.Errorf("创建 GCM 失败: %v", err)
+		return result, nil
 	}
 
-	// 提取 nonce
+	// 两种密钥都失败
-	nonceSize := aesGCM.NonceSize()
+	return "", fmt.Errorf("解密失败: %v", err)
-	if len(ciphertext) < nonceSize {
-		return "", fmt.Errorf("密文长度不足")
-	}
-
-	nonce, ciphertext := ciphertext[:nonceSize], ciphertext[nonceSize:]
-
-	// 解密
-	plaintext, err := aesGCM.Open(nil, nonce, ciphertext, nil)
-	if err != nil {
-		return "", fmt.Errorf("解密失败: %v", err)
-	}
-
-	return string(plaintext), nil
 }

internal/dbclient/cache.go

@@ -0,0 +1,479 @@
+package dbclient
+
+import (
+	"crypto/sha256"
+	"fmt"
+	"sync"
+	"time"
+)
+
+// QueryCache 查询缓存
+type QueryCache struct {
+	items      map[string]*CachedQuery
+	size       int
+	ttl        time.Duration
+	mu         sync.RWMutex
+	stopCh     chan struct{}
+	wg         sync.WaitGroup
+
+	// 智能缓存策略
+	hitRate       float64              // 缓存命中率
+	hitCount      int64                // 命中次数
+	missCount     int64                // 未命中次数
+	evictionCount int64                // 驱逐次数
+	hotQueries    map[string]bool      // 热点查询标记
+	cooldowns     map[string]time.Time // 冷却时间（避免频繁驱逐）
+
+	// 内存限制
+	maxMemoryBytes int64 // 缓存最大内存（字节），默认 100MB
+	usedMemory     int64 // 当前估算内存使用量
+}
+
+// NewQueryCache 创建新的查询缓存
+func NewQueryCache(size int, ttl time.Duration) *QueryCache {
+	cache := &QueryCache{
+		items:          make(map[string]*CachedQuery),
+		size:           size,
+		ttl:            ttl,
+		stopCh:         make(chan struct{}),
+		hitRate:        0.0,
+		hitCount:       0,
+		missCount:      0,
+		evictionCount:  0,
+		hotQueries:     make(map[string]bool),
+		cooldowns:      make(map[string]time.Time),
+		maxMemoryBytes: 100 * 1024 * 1024, // 默认 100MB
+	}
+
+	// 启动清理协程
+	cache.StartCleanup()
+
+	// 启动统计协程
+	cache.StartStatsCollection()
+
+	return cache
+}
+
+// Get 从缓存中获取查询结果
+func (c *QueryCache) Get(params QueryParams) (*CachedQuery, error) {
+	key := c.generateKey(params)
+
+	c.mu.RLock()
+	item, exists := c.items[key]
+	if !exists {
+		c.missCount++
+		_, inCooldown := c.cooldowns[key]
+		if inCooldown && time.Now().Before(c.cooldowns[key]) {
+			c.mu.RUnlock()
+			return nil, ErrCacheCooldown
+		}
+		c.mu.RUnlock()
+		return nil, ErrCacheNotFound
+	}
+
+	// 检查是否过期
+	if time.Now().After(item.ExpiryTime) {
+		if c.isHotQuery(key) {
+			c.mu.RUnlock()
+			c.mu.Lock()
+			item.ExpiryTime = time.Now().Add(c.ttl)
+			c.hitCount++
+			c.markAsHot(key)
+			c.mu.Unlock()
+			return item, nil
+		}
+		c.mu.RUnlock()
+		c.mu.Lock()
+		delete(c.items, key)
+		c.evictionCount++
+		c.missCount++
+		c.mu.Unlock()
+		return nil, ErrCacheExpired
+	}
+
+	// 命中
+	c.hitCount++
+	needsMark := !c.hotQueries[key]
+	c.mu.RUnlock()
+
+	if needsMark {
+		c.mu.Lock()
+		c.markAsHot(key)
+		c.mu.Unlock()
+	}
+
+	return item, nil
+}
+
+// Set 将查询结果存入缓存
+func (c *QueryCache) Set(params QueryParams, item *CachedQuery) {
+	key := c.generateKey(params)
+
+	// 估算条目内存大小
+	itemSize := c.estimateSize(params, item)
+
+	c.mu.Lock()
+	defer c.mu.Unlock()
+
+	// 更新统计
+	c.recordQueryAttempt(key)
+
+	// 如果超过内存限制，执行驱逐直到有空间
+	for c.usedMemory+itemSize > c.maxMemoryBytes && len(c.items) > 0 {
+		c.smartEvict(key)
+	}
+
+	// 如果条目数已满，执行智能驱逐
+	if len(c.items) >= c.size {
+		c.smartEvict(key)
+	}
+
+	// 如果已有旧条目，先减去旧的大小
+	if old, exists := c.items[key]; exists {
+		c.usedMemory -= c.estimateItemSize(old)
+	}
+
+	c.items[key] = item
+	c.usedMemory += itemSize
+
+	// 标记为热点查询
+	c.markAsHot(key)
+}
+
+// smartEvict 智能驱逐策略
+func (c *QueryCache) smartEvict(newKey string) {
+	if len(c.items) == 0 {
+		return
+	}
+	// LRU + LFU 混合策略
+	var evictKey string
+	var worstScore float64 = -1
+
+	for key, item := range c.items {
+		if key == newKey {
+			continue
+		}
+
+		score := c.calculateEvictionScore(key, item)
+		if score > worstScore {
+			worstScore = score
+			evictKey = key
+		}
+	}
+
+	if evictKey != "" {
+		if evicted, exists := c.items[evictKey]; exists {
+			c.usedMemory -= c.estimateItemSize(evicted)
+		}
+		c.cooldowns[evictKey] = time.Now().Add(1 * time.Minute)
+		delete(c.items, evictKey)
+		c.evictionCount++
+	}
+}
+
+// calculateEvictionScore 计算驱逐分数（越低越适合保留）
+func (c *QueryCache) calculateEvictionScore(key string, item *CachedQuery) float64 {
+	now := time.Now()
+
+	// 基础分数
+	score := 1.0
+
+	// 热点查询加分（优先保留）
+	if c.isHotQuery(key) {
+		score -= 0.5
+	}
+
+	// 接近过期的加分（优先驱逐即将过期的）
+	if item.ExpiryTime.Sub(now) < c.ttl/2 {
+		score += 0.3
+	}
+
+	// 最近使用的加分（优先保留最近使用的）
+	if !item.LastUsed.IsZero() {
+		recency := now.Sub(item.LastUsed)
+		if recency < 5*time.Minute {
+			score -= 0.2
+		}
+	}
+
+	return score
+}
+
+// isHotQuery 检查是否为热点查询
+func (c *QueryCache) isHotQuery(key string) bool {
+	return c.hotQueries[key]
+}
+
+// markAsHot 标记为热点查询
+func (c *QueryCache) markAsHot(key string) {
+	c.hotQueries[key] = true
+}
+
+// cleanupHotMarkers 清理热点标记
+func (c *QueryCache) cleanupHotMarkers() {
+	now := time.Now()
+	for key := range c.hotQueries {
+		// 清理超过10分钟未使用的热点标记
+		if item, exists := c.items[key]; exists {
+			if now.Sub(item.LastUsed) > 10*time.Minute {
+				delete(c.hotQueries, key)
+			}
+		} else {
+			delete(c.hotQueries, key)
+		}
+	}
+}
+
+// recordQueryAttempt 记录查询尝试
+func (c *QueryCache) recordQueryAttempt(key string) {
+	// 更新命中率
+	c.updateHitRate()
+
+	// 更新最后使用时间
+	if item, exists := c.items[key]; exists {
+		item.LastUsed = time.Now()
+	}
+}
+
+// updateHitRate 更新命中率
+func (c *QueryCache) updateHitRate() {
+	total := c.hitCount + c.missCount
+	if total > 0 {
+		c.hitRate = float64(c.hitCount) / float64(total)
+	}
+}
+
+// Delete 从缓存中删除指定查询
+func (c *QueryCache) Delete(params QueryParams) {
+	key := c.generateKey(params)
+
+	c.mu.Lock()
+	defer c.mu.Unlock()
+
+	if item, exists := c.items[key]; exists {
+		c.usedMemory -= c.estimateItemSize(item)
+		delete(c.items, key)
+	}
+}
+
+// Clear 清空整个缓存
+func (c *QueryCache) Clear() {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+
+	c.items = make(map[string]*CachedQuery)
+	c.usedMemory = 0
+}
+
+// Size 获取缓存大小
+func (c *QueryCache) Size() int {
+	c.mu.RLock()
+	defer c.mu.RUnlock()
+
+	return len(c.items)
+}
+
+// CleanupExpired 清理过期的缓存条目
+func (c *QueryCache) CleanupExpired() {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+
+	now := time.Now()
+	for key, item := range c.items {
+		if now.After(item.ExpiryTime) {
+			c.usedMemory -= c.estimateItemSize(item)
+			delete(c.items, key)
+		}
+	}
+}
+
+// Keys 获取缓存中所有的键
+func (c *QueryCache) Keys() []string {
+	c.mu.RLock()
+	defer c.mu.RUnlock()
+
+	keys := make([]string, 0, len(c.items))
+	for key := range c.items {
+		keys = append(keys, key)
+	}
+	return keys
+}
+
+// Stats 获取缓存统计信息
+func (c *QueryCache) Stats() CacheStats {
+	c.mu.RLock()
+	defer c.mu.RUnlock()
+
+	now := time.Now()
+	expired := 0
+	active := 0
+
+	for _, item := range c.items {
+		if now.After(item.ExpiryTime) {
+			expired++
+		} else {
+			active++
+		}
+	}
+
+	return CacheStats{
+		TotalItems:    len(c.items),
+		ActiveItems:   active,
+		ExpiredItems:  expired,
+		Size:          c.size,
+		TTL:           c.ttl,
+		HitRate:       c.hitRate,
+		HitCount:      c.hitCount,
+		MissCount:     c.missCount,
+		EvictionCount: c.evictionCount,
+		HotQueries:    len(c.hotQueries),
+	}
+}
+
+// generateKey 生成缓存键
+func (c *QueryCache) generateKey(params QueryParams) string {
+	key := fmt.Sprintf("%s|%s|%d|%d|%s|%s|%s|%v",
+		params.SQL, params.Database, params.Limit, params.Offset,
+		params.Table, params.Where, params.SortBy, params.IsReadOnly)
+	h := sha256.Sum256([]byte(key))
+	return fmt.Sprintf("%x", h)
+}
+
+// evictOldest 删除最老的缓存条目
+func (c *QueryCache) evictOldest() {
+	var oldestKey string
+	var oldestTime time.Time
+
+	for key, item := range c.items {
+		if oldestKey == "" || item.CreatedAt.Before(oldestTime) {
+			oldestKey = key
+			oldestTime = item.CreatedAt
+		}
+	}
+
+	if oldestKey != "" {
+		delete(c.items, oldestKey)
+	}
+}
+
+// StartCleanup 启动清理协程
+func (c *QueryCache) StartCleanup() {
+	c.wg.Add(1)
+	go func() {
+		defer c.wg.Done()
+
+		ticker := time.NewTicker(c.ttl / 2) // 每 TTL/2 时间检查一次
+		defer ticker.Stop()
+
+		for {
+			select {
+			case <-ticker.C:
+				c.CleanupExpired()
+				c.cleanupCooldowns() // 清理冷却时间
+			case <-c.stopCh:
+				return
+			}
+		}
+	}()
+}
+
+// StartStatsCollection 启动统计收集协程
+func (c *QueryCache) StartStatsCollection() {
+	c.wg.Add(1)
+	go func() {
+		defer c.wg.Done()
+
+		ticker := time.NewTicker(1 * time.Minute) // 每分钟收集一次统计
+		defer ticker.Stop()
+
+		for {
+			select {
+			case <-ticker.C:
+				c.updateHitRate()
+				c.cleanupHotMarkers()
+			case <-c.stopCh:
+				return
+			}
+		}
+	}()
+}
+
+// cleanupCooldowns 清理冷却时间
+func (c *QueryCache) cleanupCooldowns() {
+	now := time.Now()
+	for key, cooldown := range c.cooldowns {
+		if now.After(cooldown) {
+			delete(c.cooldowns, key)
+		}
+	}
+}
+
+// Stop 停止缓存清理
+func (c *QueryCache) Stop() {
+	close(c.stopCh)
+	c.wg.Wait()
+}
+
+// CacheStats 缓存统计信息
+type CacheStats struct {
+	TotalItems    int
+	ActiveItems   int
+	ExpiredItems  int
+	Size          int
+	TTL           time.Duration
+	HitRate       float64
+	HitCount      int64
+	MissCount     int64
+	EvictionCount int64
+	HotQueries    int
+}
+
+// 缓存错误定义
+var (
+	ErrCacheNotFound = &CacheError{Message: "缓存未找到"}
+	ErrCacheExpired  = &CacheError{Message: "缓存已过期"}
+	ErrCacheCooldown = &CacheError{Message: "查询在冷却中"}
+)
+
+// CacheError 缓存错误
+type CacheError struct {
+	Message string
+}
+
+func (e *CacheError) Error() string {
+	return e.Message
+}
+
+// estimateSize 估算缓存条目的内存大小（字节）
+func (c *QueryCache) estimateSize(params QueryParams, item *CachedQuery) int64 {
+	size := int64(len(params.SQL) + len(params.Database) + len(params.Table) +
+		len(params.Where) + len(params.SortBy))
+	if item != nil && item.Result != nil {
+		size += c.estimateItemSize(item)
+	}
+	return size
+}
+
+// estimateItemSize 估算 CachedQuery 的内存大小
+func (c *QueryCache) estimateItemSize(item *CachedQuery) int64 {
+	if item == nil || item.Result == nil {
+		return 128 // 基础结构体大小
+	}
+	size := int64(128) // CachedQuery 结构体基础大小
+	for _, row := range item.Result.Data {
+		for _, v := range row {
+			switch val := v.(type) {
+			case string:
+				size += int64(len(val))
+			case []byte:
+				size += int64(len(val))
+			case nil:
+				// 无额外开销
+			default:
+				size += 64 // 其他类型的估算值
+			}
+		}
+	}
+	size += int64(len(item.Result.Columns)) * 64 // 列名估算
+	return size
+}

internal/dbclient/mongo.go

@@ -7,9 +7,9 @@ import (
 
 	"u-desk/internal/common"
 
-	"go.mongodb.org/mongo-driver/bson"
+	"go.mongodb.org/mongo-driver/v2/bson"
-	"go.mongodb.org/mongo-driver/mongo"
+	"go.mongodb.org/mongo-driver/v2/mongo"
-	"go.mongodb.org/mongo-driver/mongo/options"
+	"go.mongodb.org/mongo-driver/v2/mongo/options"
 )
 
 // MongoClient MongoDB 客户端
@@ -111,11 +111,12 @@ func tryConnectMongo(config *MongoConfig, authSource, authMechanism string) (*Mo
 		SetConnectTimeout(common.TimeoutConnect).
 		SetServerSelectionTimeout(common.TimeoutConnect)
 
-	// 创建客户端
+	// 创建客户端 (v2: 移除了 context 参数)
+	client, err := mongo.Connect(clientOptions)
+
+	// 创建 context 用于其他操作
 	ctx, cancel := context.WithTimeout(context.Background(), common.TimeoutConnect)
 	defer cancel()
-
-	client, err := mongo.Connect(ctx, clientOptions)
 	if err != nil {
 		return nil, fmt.Errorf("连接 MongoDB 失败: %v", err)
 	}
@@ -659,14 +660,17 @@ func (c *MongoClient) PreviewCollectionIndexes(ctx context.Context, database, co
 			continue
 		}
 
-		// 构建索引选项
+		// 构建索引选项，并跟踪 unique 状态（v2: IndexOptionsBuilder 无 Unique 字段可读）
 		indexOptions := options.Index()
 		indexOptions.SetName(name)
 
+		isUnique := false
 		if unique, ok := idx["unique"].(bool); ok && unique {
 			indexOptions.SetUnique(true)
+			isUnique = true
 		} else if nonUnique, ok := idx["Non_unique"].(float64); ok && nonUnique == 0 {
 			indexOptions.SetUnique(true)
+			isUnique = true
 		}
 
 		// 如果索引已存在，先删除再创建
@@ -686,7 +690,7 @@ func (c *MongoClient) PreviewCollectionIndexes(ctx context.Context, database, co
 		keysStr += "}"
 
 		optionsStr := "{name: \"" + name + "\""
-		if indexOptions.Unique != nil && *indexOptions.Unique {
+		if isUnique {
 			optionsStr += ", unique: true"
 		}
 		optionsStr += "}"
@@ -748,7 +752,8 @@ func (c *MongoClient) UpdateCollectionIndexes(ctx context.Context, database, col
 	// 删除不存在的索引
 	for name := range currentIndexMap {
 		if !newIndexMap[name] {
-			_, err := coll.Indexes().DropOne(ctx, name)
+			// v2: DropOne 只返回 error，不再返回 bson.Raw
+			err := coll.Indexes().DropOne(ctx, name)
 			if err != nil {
 				return commands, fmt.Errorf("删除索引失败: %v, 索引名: %s", err, name)
 			}
@@ -803,7 +808,8 @@ func (c *MongoClient) UpdateCollectionIndexes(ctx context.Context, database, col
 
 		// 如果索引已存在，先删除再创建
 		if currentIndexMap[name] {
-			_, err := coll.Indexes().DropOne(ctx, name)
+			// v2: DropOne 只返回 error，不再返回 bson.Raw
+			err := coll.Indexes().DropOne(ctx, name)
 			if err != nil {
 				return commands, fmt.Errorf("删除旧索引失败: %v, 索引名: %s", err, name)
 			}

internal/dbclient/pool.go

@@ -5,6 +5,7 @@ import (
 	"encoding/json"
 	"fmt"
 	"sync"
+	"time"
 
 	"u-desk/internal/common"
 	"u-desk/internal/crypto"
@@ -16,6 +17,13 @@ type ConnectionPool struct {
 	mysqlClients map[uint]*MySQLClient
 	redisClients map[uint]*RedisClient
 	mongoClients map[uint]*MongoClient
+
+	// 新增：MySQL 真连接池
+	mysqlPool     *MySQLConnectionPool
+	
+	// 查询优化器
+	queryOptimizer *QueryOptimizer
+
 	mu           sync.RWMutex
 }
 
@@ -27,20 +35,74 @@ var (
 // GetPool 获取全局连接池实例
 func GetPool() *ConnectionPool {
 	poolOnce.Do(func() {
+		// 创建 MySQL 连接池
+		poolConfig := DefaultPoolConfig()
+
+		mysqlPool := NewMySQLConnectionPool(poolConfig)
+		// 启动维护协程
+		mysqlPool.StartMaintenance()
+
+		// 创建查询优化器
+		queryOptimizer := NewQueryOptimizer(nil)
+
 		globalPool = &ConnectionPool{
 			mysqlClients: make(map[uint]*MySQLClient),
 			redisClients: make(map[uint]*RedisClient),
 			mongoClients: make(map[uint]*MongoClient),
+			mysqlPool:     mysqlPool,
+			queryOptimizer: queryOptimizer,
 		}
 	})
 	return globalPool
 }
 
-// GetMySQLClient 获取或创建 MySQL 客户端
+// PooledClient 带释放语义的客户端包装
-func (p *ConnectionPool) GetMySQLClient(conn *models.DbConnection) (*MySQLClient, error) {
+type PooledClient struct {
+	Client  *MySQLClient
+	entry   *MySQLPoolEntry
+	pool    *MySQLConnectionPool
+	fromPool bool
+}
+
+// Release 释放连接回连接池
+func (pc *PooledClient) Release() {
+	if pc.fromPool && pc.pool != nil && pc.entry != nil {
+		pc.pool.Release(pc.entry)
+	}
+}
+
+// GetMySQLClient 获取或创建 MySQL 客户端（使用连接池）
+func (p *ConnectionPool) GetMySQLClient(conn *models.DbConnection) *PooledClient {
 	p.mu.Lock()
 	defer p.mu.Unlock()
 
+	// 尝试从连接池获取连接
+	if p.mysqlPool != nil {
+		entry, err := p.mysqlPool.Acquire(conn)
+		if err == nil {
+			return &PooledClient{Client: entry.Client, entry: entry, pool: p.mysqlPool, fromPool: true}
+		}
+		p.logPoolError("Acquire failed", err)
+	}
+
+	// 降级到原有逻辑
+	client, err := p.getMySQLClientLegacy(conn)
+	if err != nil {
+		return &PooledClient{Client: nil, fromPool: false}
+	}
+	return &PooledClient{Client: client, fromPool: false}
+}
+
+// logPoolError 记录连接池错误
+func (p *ConnectionPool) logPoolError(operation string, err error) {
+	if p.queryOptimizer != nil {
+		// 通过查询优化器记录错误
+		p.queryOptimizer.RecordPoolError(operation, err)
+	}
+}
+
+// getMySQLClientLegacy 原有的 MySQL 客户端获取逻辑（向后兼容）
+func (p *ConnectionPool) getMySQLClientLegacy(conn *models.DbConnection) (*MySQLClient, error) {
 	// 检查是否已存在
 	if client, ok := p.mysqlClients[conn.ID]; ok {
 		// 测试连接是否有效
@@ -76,6 +138,101 @@ func (p *ConnectionPool) GetMySQLClient(conn *models.DbConnection) (*MySQLClient
 	return client, nil
 }
 
+// GetMySQLPoolStats 获取 MySQL 连接池统计信息
+func (p *ConnectionPool) GetMySQLPoolStats() *PoolStats {
+	if p.mysqlPool != nil {
+		stats := p.mysqlPool.Stats()
+		return &stats
+	}
+	return nil
+}
+
+// OptimizeQuery 优化查询执行
+func (p *ConnectionPool) OptimizeQuery(ctx context.Context, conn *models.DbConnection, sqlStr string, database string) (*QueryResult, time.Duration, error) {
+	pc := p.GetMySQLClient(conn)
+	if pc.Client == nil {
+		return nil, 0, fmt.Errorf("获取 MySQL 连接失败")
+	}
+	defer pc.Release()
+
+	// 使用查询优化器
+	if p.queryOptimizer != nil {
+		return p.queryOptimizer.OptimizeQuery(ctx, pc.Client, sqlStr, database)
+	}
+
+	// 降级到普通查询
+	startTime := time.Now()
+	result, err := pc.Client.ExecuteQuery(ctx, sqlStr, database)
+	duration := time.Since(startTime)
+	return result, duration, err
+}
+
+// ExecuteOptimizedUpdate 执行优化的更新操作
+func (p *ConnectionPool) ExecuteOptimizedUpdate(ctx context.Context, conn *models.DbConnection, sqlStr string, database string) (int64, time.Duration, error) {
+	pc := p.GetMySQLClient(conn)
+	if pc.Client == nil {
+		return 0, 0, fmt.Errorf("获取 MySQL 连接失败")
+	}
+	defer pc.Release()
+
+	// 使用查询优化器
+	if p.queryOptimizer != nil {
+		return p.queryOptimizer.ExecuteOptimizedUpdate(ctx, pc.Client, sqlStr, database)
+	}
+
+	// 降级到普通更新
+	startTime := time.Now()
+	result, err := pc.Client.ExecuteUpdate(ctx, sqlStr, database)
+	duration := time.Since(startTime)
+	return result, duration, err
+}
+
+// GetQueryStats 获取查询统计信息
+func (p *ConnectionPool) GetQueryStats() QueryStats {
+	if p.queryOptimizer != nil {
+		return p.queryOptimizer.GetQueryStats()
+	}
+	return QueryStats{}
+}
+
+// GetSlowQueries 获取慢查询记录
+func (p *ConnectionPool) GetSlowQueries(limit int) []SlowQuery {
+	if p.queryOptimizer != nil {
+		return p.queryOptimizer.GetSlowQueries(limit)
+	}
+	return []SlowQuery{}
+}
+
+// GetIndexSuggestions 获取索引建议
+func (p *ConnectionPool) GetIndexSuggestions(table string) []IndexSuggestion {
+	if p.queryOptimizer != nil {
+		return p.queryOptimizer.GetIndexSuggestions(table)
+	}
+	return []IndexSuggestion{}
+}
+
+// GenerateIndexSuggestions 为表生成索引建议
+func (p *ConnectionPool) GenerateIndexSuggestions(ctx context.Context, conn *models.DbConnection, database, table string) error {
+	pc := p.GetMySQLClient(conn)
+	if pc.Client == nil {
+		return fmt.Errorf("获取 MySQL 连接失败")
+	}
+	defer pc.Release()
+
+	// 使用查询优化器
+	if p.queryOptimizer != nil {
+		return p.queryOptimizer.GenerateIndexSuggestions(ctx, pc.Client, database, table)
+	}
+	return nil
+}
+
+// ClearQueryCache 清空查询缓存
+func (p *ConnectionPool) ClearQueryCache() {
+	if p.queryOptimizer != nil {
+		p.queryOptimizer.ClearCache()
+	}
+}
+
 // GetRedisClient 获取或创建 Redis 客户端
 func (p *ConnectionPool) GetRedisClient(conn *models.DbConnection) (*RedisClient, error) {
 	p.mu.Lock()

internal/dbclient/pool_config.go

@@ -0,0 +1,679 @@
+package dbclient
+
+import (
+	"context"
+	"fmt"
+	"sync"
+	"time"
+
+	"u-desk/internal/crypto"
+	"u-desk/internal/storage/models"
+)
+
+// PoolConfig 连接池配置
+type PoolConfig struct {
+	// 最大打开连接数（硬上限）
+	MaxOpenConns int
+	// 最大空闲连接数（超过此数量的空闲连接会被关闭）
+	MaxIdleConns int
+	// 连接最大生命周期（超过此时间的连接会被关闭）
+	ConnMaxLifetime time.Duration
+	// 连接最大空闲时间（超过此时间未使用的连接会被关闭）
+	ConnMaxIdleTime time.Duration
+	// 最小空闲连接数（保持此数量的空闲连接以快速响应）
+	MinIdleConns int
+	// 连接超时时间（建立连接的最长时间）
+	ConnTimeout time.Duration
+	// 健康检查间隔（定期 Ping 连接检查有效性）
+	HealthCheckInterval time.Duration
+	// 是否启用连接预热（启动时建立最小连接）
+	EnableWarmup bool
+	// 是否启用慢连接日志（记录建立时间超过阈值的连接）
+	EnableSlowConnLog bool
+	// 慢连接阈值（超过此时间记录为慢连接）
+	SlowConnThreshold time.Duration
+	// 连接池最大容量（防止资源耗尽）
+	MaxPoolCapacity int
+	
+	// 动态连接池配置
+	EnableDynamicScaling bool     // 是否启用动态连接池调整
+	DynamicScaleFactor  float64  // 动态调整因子（0.5-2.0）
+	ScaleUpThreshold    float64  // 扩容阈值（0-1.0，当使用率超过此值时扩容）
+	ScaleDownThreshold  float64  // 缩容阈值（0-1.0，当使用率低于此值时缩容）
+	MinScaleUpInterval   time.Duration // 最小扩容间隔（防止频繁调整）
+	MinScaleDownInterval time.Duration // 最小缩容间隔
+	MaxIdleTimeForScale  time.Duration // 用于动态调整的最大空闲时间
+}
+
+// DefaultPoolConfig 返回默认连接池配置
+func DefaultPoolConfig() *PoolConfig {
+	return &PoolConfig{
+		MaxOpenConns:         50,                  // 最大50个连接（提高并发）
+		MaxIdleConns:         20,                  // 最大20个空闲（提高响应速度）
+		ConnMaxLifetime:       60 * time.Minute,    // 连接最长60分钟（延长连接生命周期）
+		ConnMaxIdleTime:       15 * time.Minute,    // 空闲15分钟关闭（更长的空闲时间）
+		MinIdleConns:         5,                   // 保持5个最小空闲（更好的响应性能）
+		ConnTimeout:           3 * time.Second,      // 连接超时3秒（更快失败）
+		HealthCheckInterval:   20 * time.Second,     // 20秒健康检查一次（更频繁的健康检查）
+		EnableWarmup:         true,                // 启用预热
+		EnableSlowConnLog:     true,                // 启用慢连接日志
+		SlowConnThreshold:     200 * time.Millisecond, // 超过200ms算慢连接（更严格的性能要求）
+		MaxPoolCapacity:      100,                 // 连接池最大容量（支持更高并发）
+		
+		// 动态连接池配置（更智能的调整策略）
+		EnableDynamicScaling: true,               // 启用动态调整
+		DynamicScaleFactor:   1.8,                // 调整因子1.8倍（更激进的扩容）
+		ScaleUpThreshold:     0.7,                // 使用率超过70%扩容（更早扩容）
+		ScaleDownThreshold:   0.4,                // 使用率低于40%缩容（避免频繁调整）
+		MinScaleUpInterval:   1 * time.Minute,     // 最小扩容间隔1分钟（更快的响应）
+		MinScaleDownInterval: 3 * time.Minute,     // 最小缩容间隔3分钟（稳定缩容）
+		MaxIdleTimeForScale:  20 * time.Minute,    // 用于调整的最大空闲时间
+	}
+}
+
+// MySQLPoolEntry MySQL 连接池条目
+type MySQLPoolEntry struct {
+	Client     *MySQLClient
+	LastUsed   time.Time
+	CreatedAt  time.Time
+	InUse      bool
+	mu         sync.Mutex
+}
+
+// AcquireResult 连接获取结果
+type AcquireResult struct {
+	Entry *MySQLPoolEntry
+	Err   error
+}
+
+// ReleaseResult 连接释放结果
+type ReleaseResult struct {
+	Success bool
+	Err     error
+}
+
+// Stats 连接池统计信息
+type PoolStats struct {
+		TotalConns    int       // 总连接数
+		ActiveConns   int       // 使用中的连接数
+		IdleConns     int       // 空闲连接数
+		WaitCount     int64     // 等待连接的次数
+		WaitDuration  time.Duration // 总等待时间
+	SlowConnCount int64     // 慢连接数量
+}
+
+// MySQLConnectionPool MySQL 连接池（真正的连接池）
+type MySQLConnectionPool struct {
+	config     *PoolConfig
+	configHash string            // 配置哈希，用于检测配置变更
+	mu         sync.RWMutex
+	entries    []*MySQLPoolEntry    // 连接池条目
+	connMap    map[uint]*MySQLClient // 连接ID -> 客户端映射（兼容现有代码）
+	stats      PoolStats
+	stopCh     chan struct{}
+	wg         sync.WaitGroup
+	
+	// 动态调整相关
+	lastScaleUpTime    time.Time       // 上次扩容时间
+	lastScaleDownTime  time.Time       // 上次缩容时间
+	currentTargetSize  int             // 当前目标连接数
+	usageHistory      []float64       // 使用率历史记录（用于智能调整）
+	adaptiveWeights    map[uint]float64 // 连接权重（基于性能表现）
+}
+
+// NewMySQLConnectionPool 创建新的 MySQL 连接池
+func NewMySQLConnectionPool(config *PoolConfig) *MySQLConnectionPool {
+	if config == nil {
+		config = DefaultPoolConfig()
+	}
+
+	pool := &MySQLConnectionPool{
+		config:           config,
+		entries:          make([]*MySQLPoolEntry, 0, config.MaxPoolCapacity),
+		connMap:          make(map[uint]*MySQLClient),
+		stopCh:           make(chan struct{}),
+		currentTargetSize: config.MinIdleConns,
+		usageHistory:    make([]float64, 0, 100), // 保留最近100个使用率记录
+		adaptiveWeights: make(map[uint]float64),
+	}
+
+	return pool
+}
+
+// Acquire 获取一个连接（阻塞等待直到有可用连接）
+func (p *MySQLConnectionPool) Acquire(conn *models.DbConnection) (*MySQLPoolEntry, error) {
+	p.mu.Lock()
+	defer p.mu.Unlock()
+
+	startTime := time.Now()
+
+	// 尝试获取最优连接（启用动态调整时）
+	if p.config.EnableDynamicScaling {
+		if entry, err := p.getOptimalConnection(); err == nil {
+			p.updateWaitStats(startTime)
+			return entry, nil
+		}
+	}
+
+	// 降级到标准逻辑 - 查找空闲连接
+	for _, entry := range p.entries {
+		entry.mu.Lock()
+		if !entry.InUse {
+			entry.InUse = true
+			entry.LastUsed = time.Now()
+			entry.mu.Unlock()
+
+			// 更新统计
+			p.updateWaitStats(startTime)
+
+			return entry, nil
+		}
+		entry.mu.Unlock()
+	}
+
+	// 没有可用连接，创建新连接
+	if len(p.entries) >= p.config.MaxOpenConns {
+		// 已达到最大连接数，等待
+		return p.waitForAvailableConnection(conn)
+	}
+
+	// 创建新连接（使用传入的连接配置）
+	newEntry, err := p.createNewEntry(conn)
+	if err != nil {
+		return nil, fmt.Errorf("创建连接失败: %v", err)
+	}
+
+	p.entries = append(p.entries, newEntry)
+	p.updateStats()
+	p.updateWaitStats(startTime)
+
+	return newEntry, nil
+}
+
+// Release 释放连接回池中
+func (p *MySQLConnectionPool) Release(entry *MySQLPoolEntry) error {
+	if entry == nil {
+		return nil
+	}
+
+	p.mu.Lock()
+	defer p.mu.Unlock()
+
+	entry.mu.Lock()
+	entry.InUse = false
+	entry.LastUsed = time.Now()
+	entry.mu.Unlock()
+
+	p.updateStats()
+
+	return nil
+}
+
+// Close 关闭连接池
+func (p *MySQLConnectionPool) Close() error {
+	p.mu.Lock()
+	defer p.mu.Unlock()
+
+	// 发送停止信号
+	close(p.stopCh)
+
+	// 等待所有 goroutine 完成
+	p.wg.Wait()
+
+	// 关闭所有连接
+	var lastErr error
+	for _, entry := range p.entries {
+		entry.mu.Lock()
+		if err := entry.Client.Close(); err != nil {
+			lastErr = err
+		}
+		entry.InUse = false
+		entry.mu.Unlock()
+	}
+
+	p.entries = make([]*MySQLPoolEntry, 0, p.config.MaxPoolCapacity)
+	p.connMap = make(map[uint]*MySQLClient)
+
+	return lastErr
+}
+
+// Stats 获取连接池统计信息
+func (p *MySQLConnectionPool) Stats() PoolStats {
+	p.mu.RLock()
+	defer p.mu.RUnlock()
+	return p.stats
+}
+
+// cleanupIdleConnections 清理空闲连接
+func (p *MySQLConnectionPool) cleanupIdleConnections() {
+	p.mu.Lock()
+	defer p.mu.Unlock()
+
+	now := time.Now()
+	keepEntries := make([]*MySQLPoolEntry, 0, len(p.entries))
+
+	for _, entry := range p.entries {
+		entry.mu.Lock()
+		isIdle := !entry.InUse
+		idleDuration := now.Sub(entry.LastUsed)
+		entry.mu.Unlock()
+
+		// 保留条件：正在使用 或 空闲时间未超过阈值 或 数量少于最小空闲数
+		keep := !isIdle ||
+			idleDuration < p.config.ConnMaxIdleTime ||
+			len(keepEntries) < p.config.MinIdleConns
+
+		if keep {
+			keepEntries = append(keepEntries, entry)
+		} else {
+			// 关闭连接
+			entry.Client.Close()
+		}
+	}
+
+	p.entries = keepEntries
+	p.updateStats()
+}
+
+// healthCheck 健康检查（增强版本）
+func (p *MySQLConnectionPool) healthCheck() {
+	p.enhancedHealthCheck()
+}
+
+// StartMaintenance 启动维护协程（清理和健康检查）
+func (p *MySQLConnectionPool) StartMaintenance() {
+	p.wg.Add(1)
+	go func() {
+		defer p.wg.Done()
+
+		// 健康检查Ticker
+		healthTicker := time.NewTicker(p.config.HealthCheckInterval)
+		defer healthTicker.Stop()
+
+		// 动态调整Ticker（较短间隔）
+		scaleTicker := time.NewTicker(1 * time.Minute)
+		defer scaleTicker.Stop()
+
+		for {
+			select {
+			case <-healthTicker.C:
+				// 清理空闲连接
+				p.cleanupIdleConnections()
+				// 健康检查
+				p.healthCheck()
+				
+			case <-scaleTicker.C:
+				// 动态连接池调整
+				if p.config.EnableDynamicScaling {
+					p.adaptiveScaling()
+				}
+				
+			case <-p.stopCh:
+				return
+			}
+		}
+	}()
+}
+
+// createNewEntry 创建新的连接池条目
+func (p *MySQLConnectionPool) createNewEntry(conn *models.DbConnection) (*MySQLPoolEntry, error) {
+	startTime := time.Now()
+
+	client, err := createMySQLClient(conn)
+	if err != nil {
+		return nil, err
+	}
+
+	elapsed := time.Since(startTime)
+
+	// 慢连接日志
+	if p.config.EnableSlowConnLog && elapsed > p.config.SlowConnThreshold {
+		// 记录慢连接
+		p.mu.Lock()
+		p.stats.SlowConnCount++
+		p.mu.Unlock()
+	}
+
+	entry := &MySQLPoolEntry{
+		Client:    client,
+		LastUsed:  time.Now(),
+		CreatedAt: startTime,
+		InUse:     true,
+	}
+
+	return entry, nil
+}
+
+// waitForAvailableConnection 等待可用连接并获取它
+func (p *MySQLConnectionPool) waitForAvailableConnection(conn *models.DbConnection) (*MySQLPoolEntry, error) {
+	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+	defer cancel()
+
+	ticker := time.NewTicker(100 * time.Millisecond)
+	defer ticker.Stop()
+
+	for {
+		select {
+		case <-ctx.Done():
+			return nil, ErrPoolExhausted
+		case <-ticker.C:
+			p.mu.Lock()
+			for _, entry := range p.entries {
+				entry.mu.Lock()
+				if !entry.InUse {
+					entry.InUse = true
+					entry.LastUsed = time.Now()
+					entry.mu.Unlock()
+					p.mu.Unlock()
+					return entry, nil
+				}
+				entry.mu.Unlock()
+			}
+			p.mu.Unlock()
+		}
+	}
+}
+
+// updateWaitStats 更新等待统计（调用方必须持有 p.mu）
+func (p *MySQLConnectionPool) updateWaitStats(startTime time.Time) {
+	p.stats.WaitCount++
+	p.stats.WaitDuration += time.Since(startTime)
+}
+
+// updateStats 更新连接池统计
+func (p *MySQLConnectionPool) updateStats() {
+	total := len(p.entries)
+	active := 0
+	idle := 0
+
+	for _, entry := range p.entries {
+		entry.mu.Lock()
+		if entry.InUse {
+			active++
+		} else {
+			idle++
+		}
+		entry.mu.Unlock()
+	}
+
+	p.stats.TotalConns = total
+	p.stats.ActiveConns = active
+	p.stats.IdleConns = idle
+}
+
+// adaptiveScaling 自适应连接池调整
+func (p *MySQLConnectionPool) adaptiveScaling() {
+	p.mu.Lock()
+	defer p.mu.Unlock()
+
+	// 计算当前使用率
+	if len(p.entries) == 0 {
+		return
+	}
+
+	usageRate := float64(p.stats.ActiveConns) / float64(len(p.entries))
+	
+	// 记录使用率历史
+	p.usageHistory = append(p.usageHistory, usageRate)
+	if len(p.usageHistory) > 100 {
+		p.usageHistory = p.usageHistory[1:]
+	}
+
+	// 检查是否需要调整
+	now := time.Now()
+	
+	// 扩容逻辑
+	if usageRate >= p.config.ScaleUpThreshold {
+		if now.Sub(p.lastScaleUpTime) >= p.config.MinScaleUpInterval {
+			p.scaleUp()
+			p.lastScaleUpTime = now
+		}
+		return
+	}
+
+	// 缩容逻辑
+	if usageRate <= p.config.ScaleDownThreshold && len(p.entries) > p.config.MinIdleConns {
+		if now.Sub(p.lastScaleDownTime) >= p.config.MinScaleDownInterval {
+			p.scaleDown()
+			p.lastScaleDownTime = now
+		}
+	}
+}
+
+// scaleUp 扩容
+func (p *MySQLConnectionPool) scaleUp() {
+	// scaleUp 仅更新目标大小，实际连接在 Acquire 时按需创建
+	// 移除了创建无效虚拟连接的逻辑
+	currentSize := len(p.entries)
+	scaleFactor := p.config.DynamicScaleFactor
+
+	newSize := int(float64(currentSize) * scaleFactor)
+	newSize = min(newSize, p.config.MaxOpenConns)
+	newSize = max(newSize, currentSize+1)
+
+	p.currentTargetSize = newSize
+	p.updateStats()
+}
+
+// scaleDown 缩容
+func (p *MySQLConnectionPool) scaleDown() {
+	// 计算新目标大小
+	currentSize := len(p.entries)
+	scaleFactor := 1.0 / p.config.DynamicScaleFactor
+	
+	newSize := int(float64(currentSize) * scaleFactor)
+	newSize = max(newSize, p.config.MinIdleConns)
+	newSize = min(newSize, currentSize-1) // 至少减少1个连接
+
+	if newSize < currentSize {
+		// 关闭多余的空闲连接
+		p.closeIdleConnections(currentSize - newSize)
+		p.currentTargetSize = newSize
+		p.updateStats()
+	}
+}
+
+// closeIdleConnections 关闭指定数量的空闲连接
+func (p *MySQLConnectionPool) closeIdleConnections(count int) {
+	// 收集空闲连接
+	idleEntries := make([]*MySQLPoolEntry, 0)
+	for _, entry := range p.entries {
+		entry.mu.Lock()
+		if !entry.InUse {
+			idleEntries = append(idleEntries, entry)
+		}
+		entry.mu.Unlock()
+	}
+
+	// 关闭指定数量的空闲连接
+	closedEntries := make(map[*MySQLPoolEntry]bool)
+	for i := 0; i < min(count, len(idleEntries)); i++ {
+		entry := idleEntries[i]
+		entry.mu.Lock()
+		entry.Client.Close()
+		entry.mu.Unlock()
+		closedEntries[entry] = true
+	}
+
+	// 重新构建连接池
+	remainingEntries := make([]*MySQLPoolEntry, 0, len(p.entries))
+	for _, entry := range p.entries {
+		if closedEntries[entry] {
+			continue // 跳过已关闭的连接
+		}
+		remainingEntries = append(remainingEntries, entry)
+	}
+
+	p.entries = remainingEntries
+}
+
+// enhancedHealthCheck 增强的健康检查
+func (p *MySQLConnectionPool) enhancedHealthCheck() {
+	p.mu.RLock()
+	entriesCopy := make([]*MySQLPoolEntry, len(p.entries))
+	copy(entriesCopy, p.entries)
+	p.mu.RUnlock()
+
+	var healthyEntries []*MySQLPoolEntry
+	var performanceWeights []float64
+
+	for _, entry := range entriesCopy {
+		entry.mu.Lock()
+		isIdle := !entry.InUse
+
+		// 测试连接有效性
+		isHealthy := true
+		startTime := time.Now()
+
+		if isIdle {
+			// 空闲连接：简单Ping测试
+			if err := entry.Client.sqlDB.Ping(); err != nil {
+				isHealthy = false
+				// 关闭失效连接
+				entry.Client.Close()
+			}
+		} else {
+			// 使用中的连接：快速测试（避免影响正常查询）
+			func() {
+				ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond)
+				defer cancel()
+				if err := entry.Client.sqlDB.PingContext(ctx); err != nil {
+					isHealthy = false
+				}
+			}()
+		}
+
+		// 计算连接性能权重
+		if isHealthy {
+			healthyEntries = append(healthyEntries, entry)
+
+			// 基于连接性能计算权重
+			responseTime := time.Since(startTime).Microseconds()
+			weight := 1.0 / max(float64(responseTime)/1000.0, 1.0) // 转换为毫秒，避免除零
+
+			performanceWeights = append(performanceWeights, weight)
+		} else {
+			// 不健康的连接
+			if isIdle {
+				entry.Client.Close()
+			}
+		}
+
+		entry.mu.Unlock()
+	}
+
+	// 更新连接池
+	p.mu.Lock()
+	defer p.mu.Unlock()
+
+	p.entries = healthyEntries
+
+	// 更新自适应权重
+	if len(healthyEntries) > 0 {
+		for i := range healthyEntries {
+			if i < len(performanceWeights) {
+				p.adaptiveWeights[uint(i)] = performanceWeights[i]
+			}
+		}
+	}
+
+	p.updateStats()
+}
+
+// warmUp 连接池预热
+func (p *MySQLConnectionPool) warmUp() {
+	if !p.config.EnableWarmup {
+		return
+	}
+
+	p.mu.Lock()
+	defer p.mu.Unlock()
+
+	currentIdle := 0
+	for _, entry := range p.entries {
+		entry.mu.Lock()
+		if !entry.InUse {
+			currentIdle++
+		}
+		entry.mu.Unlock()
+	}
+
+	targetIdle := p.config.MinIdleConns
+	needed := targetIdle - currentIdle
+
+	// warmUp 仅记录目标大小，不在无连接配置的情况下创建无效虚拟连接
+	// 实际连接在 Acquire 时按需创建
+	_ = needed
+
+	p.updateStats()
+}
+
+// getOptimalConnection 获取最优连接（基于性能权重）
+// 注意：调用方必须已持有 p.mu
+func (p *MySQLConnectionPool) getOptimalConnection() (*MySQLPoolEntry, error) {
+	var bestEntry *MySQLPoolEntry
+	var bestWeight float64
+
+	for i, entry := range p.entries {
+		entry.mu.Lock()
+		if !entry.InUse {
+			weight := 1.0 // 默认权重
+			if w, ok := p.adaptiveWeights[uint(i)]; ok {
+				weight = w
+			}
+
+			if bestEntry == nil || weight > bestWeight {
+				bestEntry = entry
+				bestWeight = weight
+			}
+		}
+		entry.mu.Unlock()
+	}
+
+	if bestEntry == nil {
+		return nil, ErrPoolExhausted
+	}
+
+	bestEntry.InUse = true
+	bestEntry.LastUsed = time.Now()
+	return bestEntry, nil
+}
+
+// createMySQLClient 创建 MySQL 客户端的辅助函数
+func createMySQLClient(conn *models.DbConnection) (*MySQLClient, error) {
+	// 解密密码
+	password, err := crypto.DecryptPassword(conn.Password)
+	if err != nil {
+		return nil, fmt.Errorf("密码解密失败: %v", err)
+	}
+
+	config := &MySQLConfig{
+		Host:     conn.Host,
+		Port:     conn.Port,
+		Username: conn.Username,
+		Password: password,
+		Database: conn.Database,
+	}
+
+	return NewMySQLClient(config)
+}
+
+// 错误定义
+var (
+	ErrPoolExhausted = &PoolError{Message: "连接池已耗尽"}
+	ErrPoolClosed   = &PoolError{Message: "连接池已关闭"}
+)
+
+// PoolError 连接池错误
+type PoolError struct {
+	Message string
+	Err     error
+}
+
+func (e *PoolError) Error() string {
+	if e.Err != nil {
+		return e.Message + ": " + e.Err.Error()
+	}
+	return e.Message
+}
+

internal/dbclient/query_optimizer.go

@@ -0,0 +1,762 @@
+package dbclient
+
+import (
+	"context"
+	"crypto/sha256"
+	"fmt"
+	"regexp"
+	"strings"
+	"sync"
+	"time"
+)
+
+var (
+	reLimitOffset    = regexp.MustCompile(`limit\s+(\d+)(?:\s*,\s*(\d+))?`)
+	reFromTable      = regexp.MustCompile(`(?i)from\s+([^\s,]+)`)
+	reWhereClause    = regexp.MustCompile(`(?i)where\s+(.*?)(?:\s+order\s+by|\s+limit|\s+group\s+by|$)`)
+	reOrderBy        = regexp.MustCompile(`(?i)order\s+by\s+(.*?)(?:\s+limit|$)`)
+	reBatchOperation = regexp.MustCompile(`(?i)^\s*(INSERT|UPDATE|DELETE).*VALUES\s*\(`)
+)
+
+// CachedQuery 缓存查询结果
+type CachedQuery struct {
+	Result      *QueryResult
+	ExpiryTime  time.Time
+	CreatedAt   time.Time
+	QueryHash   string
+	QueryParams QueryParams
+	LastUsed    time.Time     // 最后使用时间（用于LRU策略）
+	AccessCount int64         // 访问次数（用于LFU策略）
+}
+
+// QueryParams 查询参数（用于缓存键生成）
+type QueryParams struct {
+	SQL        string
+	Database   string
+	Limit      int
+	Offset     int
+	Table      string
+	Where      string
+	SortBy     string
+	IsReadOnly bool
+}
+
+// QueryStats 查询统计信息
+type QueryStats struct {
+	TotalQueries      int64
+	CachedQueries     int64
+	SlowQueries       int64
+	TotalDuration     time.Duration
+	AverageDuration   time.Duration
+	CacheHitRate      float64
+	LastCacheUpdate   time.Time
+}
+
+// SlowQuery 慢查询记录
+type SlowQuery struct {
+	Query        string
+	Database     string
+	Duration     time.Duration
+	Timestamp    time.Time
+	Params       QueryParams
+	Table        string
+	IndexUsed    string
+	RowsAffected int64
+	Error        error
+}
+
+// IndexSuggestion 索引建议
+type IndexSuggestion struct {
+	Table         string
+	Columns       []string
+	IndexType     string // "normal", "unique", "fulltext"
+	Priority      string // "high", "medium", "low"
+	Query         string
+	Justification string
+	CanBeApplied  bool
+}
+
+// QueryOptimizer 查询优化器
+type QueryOptimizer struct {
+	cache            *QueryCache
+	stats            *QueryStats
+	slowQueries      []SlowQuery
+	indexSuggestions []IndexSuggestion
+	mu               sync.RWMutex
+	config           *OptimizerConfig
+	stopCh           chan struct{}
+	wg               sync.WaitGroup
+}
+
+// OptimizerConfig 查询优化器配置
+type OptimizerConfig struct {
+	// 缓存配置
+	CacheSize       int           // 最大缓存条目数
+	CacheTTL        time.Duration // 缓存过期时间
+	EnableCache     bool          // 是否启用缓存
+
+	// 慢查询配置
+	SlowQueryThreshold time.Duration // 慢查询阈值
+	EnableSlowLog     bool          // 是否启用慢查询日志
+	MaxSlowLogs       int           // 最大慢查询记录数
+
+	// 索引建议配置
+	EnableIndexSuggestions bool // 是否启用索引建议
+	MaxSuggestions         int  // 最大索引建议数
+
+	// 查询分析配置
+	EnableQueryAnalysis bool // 是否启用查询分析
+	MaxAnalysisDepth   int  // 查询分析深度
+}
+
+// DefaultOptimizerConfig 返回默认的查询优化器配置
+func DefaultOptimizerConfig() *OptimizerConfig {
+	return &OptimizerConfig{
+		CacheSize:              1000,                   // 最多缓存1000个查询
+		CacheTTL:               30 * time.Minute,       // 缓存30分钟
+		EnableCache:            true,                   // 启用缓存
+		SlowQueryThreshold:     100 * time.Millisecond, // 100ms以上为慢查询
+		EnableSlowLog:          true,                   // 启用慢查询日志
+		MaxSlowLogs:            1000,                   // 最多记录1000条慢查询
+		EnableIndexSuggestions: true,                   // 启用索引建议
+		MaxSuggestions:         100,                    // 最多100个索引建议
+		EnableQueryAnalysis:    true,                   // 启用查询分析
+		MaxAnalysisDepth:       3,                      // 分析深度3
+	}
+}
+
+// NewQueryOptimizer 创建新的查询优化器
+func NewQueryOptimizer(config *OptimizerConfig) *QueryOptimizer {
+	if config == nil {
+		config = DefaultOptimizerConfig()
+	}
+
+	optimizer := &QueryOptimizer{
+		cache:            NewQueryCache(config.CacheSize, config.CacheTTL),
+		stats:            &QueryStats{},
+		config:           config,
+		stopCh:           make(chan struct{}),
+		slowQueries:      make([]SlowQuery, 0),
+		indexSuggestions: make([]IndexSuggestion, 0),
+	}
+
+	// 启动维护协程
+	optimizer.StartMaintenance()
+
+	return optimizer
+}
+
+// OptimizeQuery 优化查询执行
+func (o *QueryOptimizer) OptimizeQuery(ctx context.Context, client *MySQLClient, sqlStr string, database string) (*QueryResult, time.Duration, error) {
+	startTime := time.Now()
+	queryParams := o.parseQueryParams(sqlStr, database)
+
+	// 检查缓存
+	if o.config.EnableCache && queryParams.IsReadOnly {
+		cached, err := o.cache.Get(queryParams)
+		if err == nil && cached != nil {
+			o.recordCacheHit()
+			return cached.Result, time.Since(startTime), nil
+		}
+	}
+
+	// 执行查询
+	result, err := client.ExecuteQuery(ctx, sqlStr, database)
+	if err != nil {
+		duration := time.Since(startTime)
+		o.recordSlowQuery(sqlStr, database, duration, queryParams, result, err)
+		return nil, duration, err
+	}
+
+	duration := time.Since(startTime)
+
+	// 检查是否为慢查询
+	if duration > o.config.SlowQueryThreshold {
+		o.recordSlowQuery(sqlStr, database, duration, queryParams, result, err)
+	}
+
+	// 缓存只读查询结果
+	if o.config.EnableCache && queryParams.IsReadOnly && err == nil {
+		cachedResult := &CachedQuery{
+			Result:      result,
+			ExpiryTime:  time.Now().Add(o.config.CacheTTL),
+			CreatedAt:   time.Now(),
+			QueryHash:   o.generateQueryHash(queryParams),
+			QueryParams: queryParams,
+			LastUsed:    time.Now(),
+			AccessCount: 1,
+		}
+		o.cache.Set(queryParams, cachedResult)
+	}
+
+	o.recordQuery(duration)
+	return result, duration, err
+}
+
+// ExecuteOptimizedUpdate 执行优化的更新操作
+func (o *QueryOptimizer) ExecuteOptimizedUpdate(ctx context.Context, client *MySQLClient, sqlStr string, database string) (int64, time.Duration, error) {
+	startTime := time.Now()
+
+	// 分析更新查询
+	queryParams := o.parseQueryParams(sqlStr, database)
+
+	// 检查是否为批量操作
+	if o.isBatchOperation(sqlStr) {
+		// 优化批量操作
+		rowsAffected, duration, err := o.optimizeBatchUpdate(ctx, client, sqlStr, database)
+		if err != nil {
+			o.recordSlowQuery(sqlStr, database, duration, queryParams, nil, err)
+			return 0, duration, err
+		}
+
+		o.recordQuery(duration)
+		return rowsAffected, duration, nil
+	}
+
+	// 执行普通更新
+	rowsAffected, err := client.ExecuteUpdate(ctx, sqlStr, database)
+	duration := time.Since(startTime)
+
+	if duration > o.config.SlowQueryThreshold {
+		o.recordSlowQuery(sqlStr, database, duration, queryParams, nil, err)
+	}
+
+	o.recordQuery(duration)
+	return rowsAffected, duration, err
+}
+
+// GetIndexSuggestions 获取索引建议
+func (o *QueryOptimizer) GetIndexSuggestions(table string) []IndexSuggestion {
+	o.mu.RLock()
+	defer o.mu.RUnlock()
+
+	var suggestions []IndexSuggestion
+	for _, suggestion := range o.indexSuggestions {
+		if suggestion.Table == table || table == "" {
+			suggestions = append(suggestions, suggestion)
+		}
+	}
+	return suggestions
+}
+
+// GenerateIndexSuggestions 为表生成索引建议
+func (o *QueryOptimizer) GenerateIndexSuggestions(ctx context.Context, client *MySQLClient, database, table string) error {
+	// 获取表的慢查询记录
+	tableSlowQueries := o.getTableSlowQueries(database, table)
+
+	// 分析查询模式
+	for _, slowQuery := range tableSlowQueries {
+		suggestions := o.analyzeQueryForIndexes(slowQuery.Query, table)
+		o.mu.Lock()
+		o.indexSuggestions = append(o.indexSuggestions, suggestions...)
+
+		// 限制建议数量
+		if len(o.indexSuggestions) > o.config.MaxSuggestions {
+			o.indexSuggestions = o.indexSuggestions[:o.config.MaxSuggestions]
+		}
+		o.mu.Unlock()
+	}
+
+	return nil
+}
+
+// GetQueryStats 获取查询统计信息
+func (o *QueryOptimizer) GetQueryStats() QueryStats {
+	o.mu.RLock()
+	defer o.mu.RUnlock()
+
+	return *o.stats
+}
+
+// GetSlowQueries 获取慢查询记录
+func (o *QueryOptimizer) GetSlowQueries(limit int) []SlowQuery {
+	o.mu.RLock()
+	defer o.mu.RUnlock()
+
+	if limit <= 0 || limit > len(o.slowQueries) {
+		limit = len(o.slowQueries)
+	}
+
+	return o.slowQueries[:limit]
+}
+
+// ClearCache 清空缓存
+func (o *QueryOptimizer) ClearCache() {
+	o.cache.Clear()
+}
+
+// Stop 停止优化器
+func (o *QueryOptimizer) Stop() {
+	close(o.stopCh)
+	o.wg.Wait()
+}
+
+// parseQueryParams 解析查询参数
+func (o *QueryOptimizer) parseQueryParams(sqlStr, database string) QueryParams {
+	params := QueryParams{
+		SQL:      sqlStr,
+		Database: database,
+	}
+
+	// 解析LIMIT和OFFSET
+	limit, offset := o.parseLimitOffset(sqlStr)
+	params.Limit = limit
+	params.Offset = offset
+
+	// 解析表名
+	tables := o.parseTables(sqlStr)
+	if len(tables) > 0 {
+		params.Table = tables[0]
+	}
+
+	// 解析WHERE条件
+	where := o.parseWhereCondition(sqlStr)
+	params.Where = where
+
+	// 解析排序
+	sort := o.parseSortOrder(sqlStr)
+	params.SortBy = sort
+
+	// 判断是否为只读查询
+	params.IsReadOnly = o.isReadOnlyQuery(sqlStr)
+
+	return params
+}
+
+// parseLimitOffset 解析LIMIT和OFFSET
+func (o *QueryOptimizer) parseLimitOffset(sqlStr string) (limit, offset int) {
+	sqlStr = strings.ToLower(sqlStr)
+
+	matches := reLimitOffset.FindStringSubmatch(sqlStr)
+
+	if len(matches) > 1 {
+		fmt.Sscanf(matches[1], "%d", &limit)
+		if len(matches) > 2 && matches[2] != "" {
+			fmt.Sscanf(matches[2], "%d", &offset)
+		}
+	}
+
+	// MySQL LIMIT offset, count: matches[1]=offset, matches[2]=count
+	if len(matches) > 2 && matches[2] != "" {
+		offset, limit = limit, offset
+	}
+
+	return limit, offset
+}
+
+// parseTables 解析查询中的表名
+func (o *QueryOptimizer) parseTables(sqlStr string) []string {
+	// 简单实现：解析FROM和JOIN中的表名
+	tables := make([]string, 0)
+
+	fromMatches := reFromTable.FindAllStringSubmatch(sqlStr, -1)
+
+	for _, match := range fromMatches {
+		if len(match) > 1 {
+			tableName := strings.Trim(match[1], "`\"'[]")
+			tables = append(tables, tableName)
+		}
+	}
+
+	return tables
+}
+
+// parseWhereCondition 解析WHERE条件
+func (o *QueryOptimizer) parseWhereCondition(sqlStr string) string {
+	matches := reWhereClause.FindStringSubmatch(sqlStr)
+
+	if len(matches) > 1 {
+		return strings.TrimSpace(matches[1])
+	}
+
+	return ""
+}
+
+// parseSortOrder 解析排序条件
+func (o *QueryOptimizer) parseSortOrder(sqlStr string) string {
+	matches := reOrderBy.FindStringSubmatch(sqlStr)
+
+	if len(matches) > 1 {
+		return strings.TrimSpace(matches[1])
+	}
+
+	return ""
+}
+
+// isReadOnlyQuery 判断是否为只读查询
+func (o *QueryOptimizer) isReadOnlyQuery(sqlStr string) bool {
+	sqlStr = strings.ToUpper(strings.TrimSpace(sqlStr))
+
+	// SELECT只读查询
+	if strings.HasPrefix(sqlStr, "SELECT") {
+		return true
+	}
+
+	// 支持的只读查询类型
+	readOnlyQueries := []string{
+		"SHOW", "DESCRIBE", "DESC", "EXPLAIN",
+		"WITH", "UNION", "INTERSECT", "EXCEPT",
+	}
+
+	for _, query := range readOnlyQueries {
+		if strings.HasPrefix(sqlStr, query) {
+			return true
+		}
+	}
+
+	return false
+}
+
+// isBatchOperation 判断是否为批量操作
+func (o *QueryOptimizer) isBatchOperation(sqlStr string) bool {
+	return reBatchOperation.MatchString(sqlStr)
+}
+
+// generateQueryHash 生成查询哈希
+func (o *QueryOptimizer) generateQueryHash(params QueryParams) string {
+	hashData := fmt.Sprintf("%s|%s|%d|%d|%s|%s|%s|%v",
+		params.SQL, params.Database, params.Limit, params.Offset,
+		params.Table, params.Where, params.SortBy, params.IsReadOnly)
+
+	h := sha256.Sum256([]byte(hashData))
+	return fmt.Sprintf("%x", h)
+}
+
+// recordQuery 记录查询统计
+func (o *QueryOptimizer) recordQuery(duration time.Duration) {
+	o.mu.Lock()
+	defer o.mu.Unlock()
+
+	o.stats.TotalQueries++
+	o.stats.TotalDuration += duration
+	o.stats.AverageDuration = time.Duration(int64(float64(o.stats.TotalDuration) / float64(o.stats.TotalQueries)))
+
+	now := time.Now()
+	if o.stats.LastCacheUpdate.IsZero() || now.Sub(o.stats.LastCacheUpdate) > 5*time.Minute {
+		// 更新缓存命中率
+		total := o.stats.TotalQueries
+		hit := o.stats.CachedQueries
+		o.stats.CacheHitRate = float64(hit) / float64(total) * 100
+		o.stats.LastCacheUpdate = now
+	}
+}
+
+// recordCacheHit 记录缓存命中
+func (o *QueryOptimizer) recordCacheHit() {
+	o.mu.Lock()
+	defer o.mu.Unlock()
+
+	o.stats.CachedQueries++
+}
+
+// recordSlowQuery 记录慢查询
+func (o *QueryOptimizer) recordSlowQuery(query, database string, duration time.Duration, params QueryParams, result *QueryResult, err error) {
+	if !o.config.EnableSlowLog {
+		return
+	}
+
+	slowQuery := SlowQuery{
+		Query:        query,
+		Database:     database,
+		Duration:     duration,
+		Timestamp:    time.Now(),
+		Params:       params,
+		Table:        params.Table,
+		IndexUsed:    o.extractIndexUsed(query),
+		RowsAffected: o.extractRowsAffected(result),
+		Error:        err,
+	}
+
+	o.mu.Lock()
+	defer o.mu.Unlock()
+
+	o.slowQueries = append(o.slowQueries, slowQuery)
+
+	// 限制慢查询记录数量
+	if len(o.slowQueries) > o.config.MaxSlowLogs {
+		o.slowQueries = o.slowQueries[1:]
+	}
+
+	o.stats.SlowQueries++
+}
+
+// extractIndexUsed 提取使用的索引
+func (o *QueryOptimizer) extractIndexUsed(query string) string {
+	// 简单实现：从EXPLAIN结果中提取索引信息
+	// 实际项目中应该执行EXPLAIN语句分析
+	return "unknown"
+}
+
+// extractRowsAffected 提取影响的行数
+func (o *QueryOptimizer) extractRowsAffected(result *QueryResult) int64 {
+	if result != nil && len(result.Data) > 0 {
+		if rows, ok := result.Data[0]["rows_affected"].(int64); ok {
+			return rows
+		}
+	}
+	return 0
+}
+
+// analyzeQuery 分析查询性能
+func (o *QueryOptimizer) analyzeQuery(query, database string, result *QueryResult, duration time.Duration) {
+	// 这里可以实现更复杂的查询分析逻辑
+	// 比如分析查询计划、检测N+1查询问题等
+
+	// 简单实现：记录查询到统计信息中
+	_ = query
+	_ = database
+	_ = result
+	_ = duration
+}
+
+// analyzeQueryForIndexes 分析查询为索引建议
+func (o *QueryOptimizer) analyzeQueryForIndexes(query, table string) []IndexSuggestion {
+	var suggestions []IndexSuggestion
+
+	// 解析查询中的WHERE条件
+	where := o.parseWhereCondition(query)
+	if where != "" {
+		// 提取WHERE条件中的列
+		columns := o.extractColumnsFromWhere(where)
+
+		if len(columns) > 0 {
+			// 创建索引建议
+			suggestion := IndexSuggestion{
+				Table:         table,
+				Columns:       columns,
+				IndexType:     "normal",
+				Priority:      "medium",
+				Query:         query,
+				Justification: fmt.Sprintf("查询经常使用WHERE条件 %s", where),
+				CanBeApplied:  true,
+			}
+			suggestions = append(suggestions, suggestion)
+		}
+	}
+
+	// 解析ORDER BY条件
+	order := o.parseSortOrder(query)
+	if order != "" {
+		// 提取排序的列
+		columns := o.extractColumnsFromOrder(order)
+
+		if len(columns) > 0 {
+			// 创建排序索引建议
+			suggestion := IndexSuggestion{
+				Table:         table,
+				Columns:       columns,
+				IndexType:     "normal",
+				Priority:      "low",
+				Query:         query,
+				Justification: fmt.Sprintf("查询经常使用ORDER BY %s", order),
+				CanBeApplied:  true,
+			}
+			suggestions = append(suggestions, suggestion)
+		}
+	}
+
+	return suggestions
+}
+
+// extractColumnsFromWhere 从WHERE条件中提取列名
+func (o *QueryOptimizer) extractColumnsFromWhere(where string) []string {
+	// 简单实现：提取WHERE条件中的列名
+	columns := make([]string, 0)
+
+	// 这里可以实现更复杂的列名解析逻辑
+	// 目前只做简单处理
+	words := strings.Fields(where)
+	for _, word := range words {
+		// 去除运算符和引号
+		if !strings.Contains(word, "=") &&
+			!strings.Contains(word, ">") &&
+			!strings.Contains(word, "<") &&
+			!strings.Contains(word, "!=") &&
+			!strings.HasPrefix(word, "'") &&
+			!strings.HasPrefix(word, "\"") {
+			columns = append(columns, strings.Trim(word, " `\"'[]"))
+		}
+	}
+
+	return columns
+}
+
+// extractColumnsFromOrder 从ORDER BY条件中提取列名
+func (o *QueryOptimizer) extractColumnsFromOrder(order string) []string {
+	// 简单实现：提取ORDER BY中的列名
+	columns := strings.Split(order, ",")
+	for i, col := range columns {
+		columns[i] = strings.TrimSpace(strings.Split(col, " ")[0])
+	}
+	return columns
+}
+
+// getTableSlowQueries 获取表的慢查询记录
+func (o *QueryOptimizer) getTableSlowQueries(database, table string) []SlowQuery {
+	o.mu.RLock()
+	defer o.mu.RUnlock()
+
+	var tableQueries []SlowQuery
+	for _, query := range o.slowQueries {
+		if (database == "" || query.Database == database) &&
+			(table == "" || query.Table == table) {
+			tableQueries = append(tableQueries, query)
+		}
+	}
+	return tableQueries
+}
+
+// optimizeBatchUpdate 优化批量更新操作
+func (o *QueryOptimizer) optimizeBatchUpdate(ctx context.Context, client *MySQLClient, sqlStr string, database string) (int64, time.Duration, error) {
+	// 简单实现：执行原始查询
+	// 实际项目中可以实现批量操作优化
+	startTime := time.Now()
+	rowsAffected, err := client.ExecuteUpdate(ctx, sqlStr, database)
+	duration := time.Since(startTime)
+	return rowsAffected, duration, err
+}
+
+// StartMaintenance 启动维护协程
+func (o *QueryOptimizer) StartMaintenance() {
+	o.wg.Add(1)
+	go func() {
+		defer o.wg.Done()
+
+		ticker := time.NewTicker(5 * time.Minute)
+		defer ticker.Stop()
+
+		for {
+			select {
+			case <-ticker.C:
+				// 清理过期的缓存
+				o.cache.CleanupExpired()
+
+				// 分析慢查询生成新的索引建议
+				o.analyzeSlowQueriesForSuggestions()
+
+			case <-o.stopCh:
+				return
+			}
+		}
+	}()
+}
+
+// RecordPoolError 记录连接池错误
+func (o *QueryOptimizer) RecordPoolError(operation string, err error) {
+	if !o.config.EnableSlowLog || err == nil {
+		return
+	}
+
+	poolError := SlowQuery{
+		Query:        operation,
+		Database:     "pool",
+		Duration:     0,
+		Timestamp:    time.Now(),
+		Params:       QueryParams{SQL: operation},
+		Table:        "connection_pool",
+		IndexUsed:    "N/A",
+		RowsAffected: 0,
+		Error:        err,
+	}
+
+	o.mu.Lock()
+	defer o.mu.Unlock()
+
+	o.slowQueries = append(o.slowQueries, poolError)
+
+	// 限制慢查询记录数量
+	if len(o.slowQueries) > o.config.MaxSlowLogs {
+		o.slowQueries = o.slowQueries[1:]
+	}
+}
+
+// analyzeSlowQueriesForSuggestions 分析慢查询生成索引建议
+func (o *QueryOptimizer) analyzeSlowQueriesForSuggestions() {
+	// 这里可以实现更复杂的慢查询分析逻辑
+	// 比如分析查询模式、统计索引使用情况等
+
+	// 分析慢查询模式
+	o.analyzeSlowQueryPatterns()
+}
+
+// analyzeSlowQueryPatterns 分析慢查询模式
+func (o *QueryOptimizer) analyzeSlowQueryPatterns() {
+	o.mu.RLock()
+	queryTypes := make(map[string]int)
+	tableQueries := make(map[string]int)
+
+	for _, query := range o.slowQueries {
+		queryType := o.detectQueryType(query.Query)
+		queryTypes[queryType]++
+
+		if query.Table != "" {
+			tableQueries[query.Table]++
+		}
+	}
+	o.mu.RUnlock()
+
+	// 根据统计结果生成智能建议（在锁外执行，避免死锁）
+	o.generateSmartSuggestions(queryTypes, tableQueries)
+}
+
+// detectQueryType 检测查询类型
+func (o *QueryOptimizer) detectQueryType(sqlStr string) string {
+	sqlStr = strings.ToUpper(strings.TrimSpace(sqlStr))
+
+	if strings.HasPrefix(sqlStr, "SELECT") {
+		if strings.Contains(sqlStr, "JOIN") {
+			return "SELECT_JOIN"
+		} else if strings.Contains(sqlStr, "GROUP BY") {
+			return "SELECT_GROUP"
+		} else {
+			return "SELECT_SIMPLE"
+		}
+	} else if strings.HasPrefix(sqlStr, "INSERT") {
+		return "INSERT"
+	} else if strings.HasPrefix(sqlStr, "UPDATE") {
+		return "UPDATE"
+	} else if strings.HasPrefix(sqlStr, "DELETE") {
+		return "DELETE"
+	}
+
+	return "OTHER"
+}
+
+// generateSmartSuggestions 生成智能建议
+func (o *QueryOptimizer) generateSmartSuggestions(queryTypes map[string]int, tableQueries map[string]int) {
+	// 分析频繁执行的查询类型
+	var mostFrequentType string
+	var maxCount int
+
+	for queryType, count := range queryTypes {
+		if count > maxCount {
+			maxCount = count
+			mostFrequentType = queryType
+		}
+	}
+
+	// 生成针对性的索引建议
+	switch mostFrequentType {
+	case "SELECT_JOIN":
+		// 为JOIN查询建议复合索引
+		o.generateJoinSuggestions()
+	case "SELECT_GROUP":
+		// 为GROUP BY查询建议索引
+		o.generateGroupSuggestions()
+	case "INSERT":
+		// 为批量插入建议优化
+		o.generateInsertSuggestions()
+	}
+}
+
+// generateJoinSuggestions 生成JOIN查询建议
+func (o *QueryOptimizer) generateJoinSuggestions() {
+}
+
+// generateGroupSuggestions 生成GROUP BY查询建议
+func (o *QueryOptimizer) generateGroupSuggestions() {
+}
+
+// generateInsertSuggestions 生成批量插入建议
+func (o *QueryOptimizer) generateInsertSuggestions() {
+}

internal/dbclient/redis_pipeline.go

@@ -0,0 +1,151 @@
+package dbclient
+
+import (
+	"context"
+	"fmt"
+	"log"
+
+	"github.com/redis/go-redis/v9"
+)
+
+// RedisPipeline Redis Pipeline 操作
+type RedisPipeline struct {
+	client   *RedisClient
+	commands []RedisCommand
+	ctx      context.Context
+}
+
+// RedisCommand Redis 命令结构
+type RedisCommand struct {
+	Command string
+	Args    []interface{}
+	Result  interface{}
+	Error   error
+}
+
+// NewRedisPipeline 创建新的 Redis Pipeline
+func (r *RedisClient) NewPipeline(ctx context.Context) *RedisPipeline {
+	return &RedisPipeline{
+		client:   r,
+		commands: make([]RedisCommand, 0),
+		ctx:      ctx,
+	}
+}
+
+// AddCommand 添加命令到 Pipeline
+func (p *RedisPipeline) AddCommand(command string, args ...interface{}) {
+	p.commands = append(p.commands, RedisCommand{
+		Command: command,
+		Args:    args,
+	})
+}
+
+// Execute 使用 go-redis 原生 Pipeline 执行所有命令
+func (p *RedisPipeline) Execute() ([]interface{}, error) {
+	if len(p.commands) == 0 {
+		return nil, nil
+	}
+
+	pipe := p.client.client.Pipeline()
+
+	cmds := make([]*redis.Cmd, len(p.commands))
+	for i, c := range p.commands {
+		cmds[i] = pipe.Do(p.ctx, append([]interface{}{c.Command}, c.Args...)...)
+	}
+
+	// 一次性发送所有命令
+	results := make([]interface{}, len(p.commands))
+	cmdResults, err := pipe.Exec(p.ctx)
+	if err != nil && err != redis.Nil {
+		log.Printf("[RedisPipeline] Exec 错误: %v", err)
+	}
+
+	for i, cmd := range cmds {
+		result, cmdErr := cmd.Result()
+		results[i] = result
+		p.commands[i].Result = result
+		p.commands[i].Error = cmdErr
+	}
+
+	// 如果 Exec 返回了命令结果（部分 Redis 版本），使用它们
+	for i, cr := range cmdResults {
+		if cr.Err() != nil && cr.Err() != redis.Nil {
+			p.commands[i].Error = cr.Err()
+			if i < len(results) {
+				results[i] = nil
+			}
+		}
+	}
+
+	_ = results // 已经通过 cmds 获取
+	return results, nil
+}
+
+// GetCommands 获取 Pipeline 中的命令列表
+func (p *RedisPipeline) GetCommands() []RedisCommand {
+	return p.commands
+}
+
+// Len 获取 Pipeline 中的命令数量
+func (p *RedisPipeline) Len() int {
+	return len(p.commands)
+}
+
+// Clear 清空 Pipeline
+func (p *RedisPipeline) Clear() {
+	p.commands = make([]RedisCommand, 0)
+}
+
+// RedisTransaction Redis 事务支持
+type RedisTransaction struct {
+	client *RedisClient
+	watch  []string
+	cmds   []RedisCommand
+	ctx    context.Context
+}
+
+// NewRedisTransaction 创建新的 Redis 事务
+func (r *RedisClient) NewTransaction(ctx context.Context, watch ...string) *RedisTransaction {
+	return &RedisTransaction{
+		client: r,
+		watch:  watch,
+		ctx:    ctx,
+	}
+}
+
+// AddCommand 添加命令到事务
+func (tx *RedisTransaction) AddCommand(command string, args ...interface{}) {
+	tx.cmds = append(tx.cmds, RedisCommand{
+		Command: command,
+		Args:    args,
+	})
+}
+
+// Exec 使用 go-redis Watch + TxPipeline 执行事务（MULTI/EXEC）
+func (tx *RedisTransaction) Exec() ([]interface{}, error) {
+	pipe := tx.client.client.TxPipeline()
+
+	// 添加所有命令
+	cmds := make([]*redis.Cmd, len(tx.cmds))
+	for i, c := range tx.cmds {
+		cmds[i] = pipe.Do(tx.ctx, append([]interface{}{c.Command}, c.Args...)...)
+	}
+
+	// TxPipeline 自动发送 MULTI/EXEC
+	results := make([]interface{}, len(tx.cmds))
+	_, err := pipe.Exec(tx.ctx)
+
+	for i, cmd := range cmds {
+		result, cmdErr := cmd.Result()
+		results[i] = result
+		tx.cmds[i].Result = result
+		tx.cmds[i].Error = cmdErr
+	}
+
+	if err != nil && err != redis.Nil {
+		return results, fmt.Errorf("事务执行失败: %v", err)
+	}
+
+	return results, nil
+}
+

internal/filesystem/asset_handler.go

@@ -1,21 +1,58 @@
 package filesystem
 
 import (
-	"encoding/base64"
+	"context"
 	"fmt"
 	"log"
 	"net/http"
 	"net/url"
 	"os"
 	"path/filepath"
+	"regexp"
 	"strings"
 	"sync"
+	"time"
 )
 
+// 预编译正则表达式（避免每次调用重复编译）
+var (
+	// CSS 相关
+	cssImportRegex = regexp.MustCompile(`@import\s+(?:url\s*\(\s*)?["']([^"']+)["']\s*\)?\s*;`)
+	cssUrlRegex    = regexp.MustCompile(`url\(\s*["']?([^"')]+)["']?\s*\)`)
+
+	// HTML 标签
+	htmlLinkTagRegex   = regexp.MustCompile(`<link\s+([^>]*)>`)
+	htmlScriptTagRegex = regexp.MustCompile(`<script\s+([^>]*)>`)
+	htmlImgTagRegex    = regexp.MustCompile(`<img\s+([^>]*)>`)
+	htmlVideoTagRegex  = regexp.MustCompile(`<video\s+([^>]*)>`)
+	htmlSourceTagRegex = regexp.MustCompile(`<source\s+([^>]*)>`)
+	htmlAudioTagRegex  = regexp.MustCompile(`<audio\s+([^>]*)>`)
+	htmlIframeTagRegex = regexp.MustCompile(`<iframe\s+([^>]*)>`)
+	htmlObjectTagRegex = regexp.MustCompile(`<object\s+([^>]*)>`)
+	htmlEmbedTagRegex  = regexp.MustCompile(`<embed\s+([^>]*)>`)
+
+	// HTML 属性
+	htmlSrcsetRegex    = regexp.MustCompile(`srcset=["']([^"']+)["']`)
+	htmlStyleAttrRegex = regexp.MustCompile(`style=["']([^"']+)["']`)
+	htmlStyleTagRegex  = regexp.MustCompile(`<style([^>]*)>([\s\S]*?)</style>`)
+
+	// ES6 模块语句
+	es6ImportFromRegex = regexp.MustCompile(`import\s+([\s\S]*?)\s+from\s+["']([^"']+)["']`)
+	es6DynamicImport   = regexp.MustCompile(`import\s*\(\s*["']([^"']+)["']\s*\)`)
+	es6BareImport      = regexp.MustCompile(`(?m)^\s*import\s+["']([^"']+)["']`)
+
+	// HTML 预览路径修复
+	locationPathRegex = regexp.MustCompile(`\blocation\.pathname\b`)
+)
+
+// HTML 属性正则缓存（避免 replaceHtmlTagAttribute 中重复编译）
+var attrRegexCache sync.Map // map[string]*regexp.Regexp
+
 // LocalFileServer 本地文件服务器（独立的 HTTP 服务器）
 type LocalFileServer struct {
 	server *http.Server
 	addr   string
+	mu     sync.RWMutex
 }
 
 var (
@@ -33,6 +70,9 @@ func StartLocalFileServer() (string, error) {
 		// 注册 /localfs/ 路由
 		mux.HandleFunc("/localfs/", handleLocalFileRequest)
 
+		// 注册 HTML 预览专用路由
+		mux.HandleFunc("/localfs/html-preview", handleHtmlPreviewRequest)
+
 		// 创建服务器（固定端口）
 		server := &http.Server{
 			Addr:    "localhost:18765",
@@ -64,6 +104,17 @@ func StartLocalFileServer() (string, error) {
 
 // handleLocalFileRequest 处理本地文件请求
 func handleLocalFileRequest(w http.ResponseWriter, r *http.Request) {
+	// CORS 头：允许所有源访问（因为这是本地文件服务器）
+	w.Header().Set("Access-Control-Allow-Origin", "*")
+	w.Header().Set("Access-Control-Allow-Methods", "GET, OPTIONS")
+	w.Header().Set("Access-Control-Allow-Headers", "*")
+
+	// 处理 OPTIONS 预检请求
+	if r.Method == http.MethodOptions {
+		w.WriteHeader(http.StatusOK)
+		return
+	}
+
 	// 只处理 GET 请求
 	if r.Method != http.MethodGet {
 		http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
@@ -110,7 +161,7 @@ func handleLocalFileRequest(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	// 🔒 修复：文件类型白名单检查
+	// 🔒 文件类型白名单检查
 	ext := strings.ToLower(filepath.Ext(filePath))
 	if !isAllowedFileType(ext) {
 		log.Printf("[LocalFileHandler] 不允许的文件类型: %s", ext)
@@ -139,6 +190,50 @@ func handleLocalFileRequest(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
+	// CSS 文件特殊处理：转换内容中的相对路径
+	if ext == ".css" {
+		content, err := os.ReadFile(filePath)
+		if err != nil {
+			log.Printf("[LocalFileHandler] 读取CSS文件失败: %v", err)
+			http.Error(w, fmt.Sprintf("Failed to read CSS file: %v", err), http.StatusInternalServerError)
+			return
+		}
+
+		// 获取 CSS 文件所在目录作为 basePath
+		basePath := filepath.Dir(filePath)
+
+		// 转换内容中的相对路径
+		transformedContent := transformCssContent(string(content), basePath)
+
+		w.Header().Set("Content-Type", "text/css")
+		w.Header().Set("Cache-Control", "public, max-age=3600")
+		w.Write([]byte(transformedContent))
+		log.Printf("[LocalFileHandler] CSS文件转换完成: %s (原始=%d, 转换后=%d)", filePath, len(content), len(transformedContent))
+		return
+	}
+
+	// JavaScript 文件特殊处理：转换动态 import 路径
+	if ext == ".js" || ext == ".mjs" {
+		content, err := os.ReadFile(filePath)
+		if err != nil {
+			log.Printf("[LocalFileHandler] 读取JS文件失败: %v", err)
+			http.Error(w, fmt.Sprintf("Failed to read JS file: %v", err), http.StatusInternalServerError)
+			return
+		}
+
+		// 获取 JS 文件所在目录作为 basePath
+		basePath := filepath.Dir(filePath)
+
+		// 转换动态 import 路径
+		transformedContent := transformJsDynamicImports(string(content), basePath)
+
+		w.Header().Set("Content-Type", "application/javascript")
+		w.Header().Set("Cache-Control", "public, max-age=3600")
+		w.Write([]byte(transformedContent))
+		log.Printf("[LocalFileHandler] JS文件转换完成: %s (原始=%d, 转换后=%d)", filePath, len(content), len(transformedContent))
+		return
+	}
+
 	// 打开文件
 	file, err := os.Open(filePath)
 	if err != nil {
@@ -207,54 +302,515 @@ func getContentType(ext string) string {
 	return defaultFileTypeManager.GetMIMEType(ext)
 }
 
-// ReadFileAsBase64 读取文件并返回 base64 编码的字符串
-// 用于读取从 ZIP 提取的临时图片文件
-func ReadFileAsBase64(filePath string) (string, error) {
-	log.Printf("[ReadFileAsBase64] 读取文件: %s", filePath)
-
-	if !isSafePath(filePath) {
-		return "", fmt.Errorf("路径不安全")
-	}
-
-	// 检查文件是否存在
-	fileInfo, err := os.Stat(filePath)
-	if err != nil {
-		if os.IsNotExist(err) {
-			return "", fmt.Errorf("文件不存在: %s", filePath)
-		}
-		return "", fmt.Errorf("无法访问文件: %v", err)
-	}
-
-	log.Printf("[ReadFileAsBase64] 文件大小: %d bytes", fileInfo.Size())
-
-	// 读取文件
-	data, err := os.ReadFile(filePath)
-	if err != nil {
-		return "", fmt.Errorf("读取文件失败: %v", err)
-	}
-
-	// 编码为 base64
-	encoded := base64.StdEncoding.EncodeToString(data)
-	log.Printf("[ReadFileAsBase64] 编码成功: 原始=%d, base64=%d", len(data), len(encoded))
-
-	// 获取文件扩展名并确定 MIME 类型
-	ext := strings.ToLower(filepath.Ext(filePath))
-	mimeType := getContentType(ext)
-
-	// 返回 data URI 格式: data:image/png;base64,iVBORw0KG...
-	return fmt.Sprintf("data:%s;base64,%s", mimeType, encoded), nil
-}
-
-// HandleLocalFile 处理 /localfs/ 路由的 HTTP 请求
-// 前端可以请求 http://localhost:18765/localfs/C:/path/to/image.jpg
-// 注意：此函数与 ServeHTTP 功能重复，建议统一使用 ServeHTTP
-func HandleLocalFile(w http.ResponseWriter, r *http.Request) {
-	handler := NewLocalFileHandler()
-	handler.ServeHTTP(w, r)
-}
-
 // isAllowedFileType 检查文件类型是否在白名单中
-// 使用统一的文件类型管理器
 func isAllowedFileType(ext string) bool {
 	return defaultFileTypeManager.IsAllowed(ext)
 }
+
+// Shutdown 优雅关闭文件服务器
+func (lfs *LocalFileServer) Shutdown() error {
+	if lfs == nil || lfs.server == nil {
+		return nil
+	}
+
+	lfs.mu.Lock()
+	defer lfs.mu.Unlock()
+
+	// 创建带超时的上下文
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+
+	log.Printf("[LocalFileServer] 正在关闭...")
+
+	if err := lfs.server.Shutdown(ctx); err != nil {
+		log.Printf("[LocalFileServer] 关闭失败: %v", err)
+		return err
+	}
+
+	log.Printf("[LocalFileServer] 已关闭")
+	return nil
+}
+
+// ShutdownLocalFileServer 关闭全局文件服务器
+func ShutdownLocalFileServer() error {
+	if localFileServer != nil {
+		return localFileServer.Shutdown()
+	}
+	return nil
+}
+
+// transformCssContent 转换 CSS 内容中的相对路径
+// basePath: CSS 文件所在目录的绝对路径
+func transformCssContent(content string, basePath string) string {
+	// 1. 处理 @import 语句
+	content = cssImportRegex.ReplaceAllStringFunc(content, func(match string) string {
+		submatches := cssImportRegex.FindStringSubmatch(match)
+		if len(submatches) < 2 {
+			return match
+		}
+		relativePath := submatches[1]
+
+		// 跳过绝对 URL 和数据 URI
+		if isAbsoluteURL(relativePath) || strings.HasPrefix(relativePath, "data:") {
+			return match
+		}
+
+		absolutePath := resolveCssRelativePath(basePath, relativePath)
+		if absolutePath == "" {
+			return match
+		}
+
+		return fmt.Sprintf(`@import url("%s");`, toLocalServerUrl(absolutePath))
+	})
+
+	// 2. 处理 url() 语句
+	content = cssUrlRegex.ReplaceAllStringFunc(content, func(match string) string {
+		submatches := cssUrlRegex.FindStringSubmatch(match)
+		if len(submatches) < 2 {
+			return match
+		}
+		relativePath := strings.TrimSpace(submatches[1])
+
+		// 跳过绝对 URL、数据 URI 和绝对路径
+		if isAbsoluteURL(relativePath) || strings.HasPrefix(relativePath, "data:") || strings.HasPrefix(relativePath, "/") || relativePath == "" {
+			return match
+		}
+
+		absolutePath := resolveCssRelativePath(basePath, relativePath)
+		if absolutePath == "" {
+			return match
+		}
+
+		return fmt.Sprintf(`url("%s")`, toLocalServerUrl(absolutePath))
+	})
+
+	return content
+}
+
+// resolveCssRelativePath 解析 CSS 中的相对路径为绝对路径
+func resolveCssRelativePath(basePath, relativePath string) string {
+	// 清理路径
+	relativePath = strings.TrimSpace(relativePath)
+	if relativePath == "" {
+		return ""
+	}
+
+	// 移除 ./ 前缀
+	relativePath = strings.TrimPrefix(relativePath, "./")
+
+	// 使用 filepath.Join 处理 ../ 等
+	// 注意：需要先将 / 转换为 \ 以便 Windows 路径正确处理
+	relativePath = strings.ReplaceAll(relativePath, "/", string(filepath.Separator))
+	absolutePath := filepath.Join(basePath, relativePath)
+
+	// 清理路径并转换回 /
+	absolutePath = filepath.Clean(absolutePath)
+	absolutePath = strings.ReplaceAll(absolutePath, "\\", "/")
+
+	return absolutePath
+}
+
+// toLocalServerUrl 将绝对路径转换为 /localfs/ URL（带 URL 编码）
+func toLocalServerUrl(absolutePath string) string {
+	// 确保路径使用 /
+	absolutePath = strings.ReplaceAll(absolutePath, "\\", "/")
+	// 对路径进行 URL 编码（分段编码，保留 /）
+	parts := strings.Split(absolutePath, "/")
+	for i, part := range parts {
+		// Windows 驱动器字母（如 E:）需要特殊处理，冒号必须编码
+		if len(part) == 2 && part[1] == ':' {
+			// 将 "E:" 转换为 "E%3A"
+			parts[i] = string(part[0]) + "%3A"
+		} else {
+			parts[i] = url.PathEscape(part)
+		}
+	}
+	return "/localfs/" + strings.Join(parts, "/")
+}
+
+// isAbsoluteURL 检查是否为绝对 URL（http://, https://, //）
+func isAbsoluteURL(path string) bool {
+	path = strings.ToLower(path)
+	return strings.HasPrefix(path, "http://") ||
+		strings.HasPrefix(path, "https://") ||
+		strings.HasPrefix(path, "//")
+}
+
+// handleHtmlPreviewRequest 处理 HTML 预览请求
+// 参数：
+//   - path: HTML 文件绝对路径（URL 编码）
+//   - theme: 主题（light / dark）
+func handleHtmlPreviewRequest(w http.ResponseWriter, r *http.Request) {
+	// CORS
+	w.Header().Set("Access-Control-Allow-Origin", "*")
+	w.Header().Set("Access-Control-Allow-Methods", "GET, OPTIONS")
+	w.Header().Set("Access-Control-Allow-Headers", "*")
+
+	// 处理 OPTIONS 预检请求
+	if r.Method == http.MethodOptions {
+		w.WriteHeader(http.StatusOK)
+		return
+	}
+
+	// 只处理 GET 请求
+	if r.Method != http.MethodGet {
+		http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
+		return
+	}
+
+	// 解析参数
+	filePath := r.URL.Query().Get("path")
+	var err error
+	if filePath, err = url.QueryUnescape(filePath); err != nil {
+		http.Error(w, "Invalid path encoding", http.StatusBadRequest)
+		return
+	}
+	theme := r.URL.Query().Get("theme")
+	if theme == "" {
+		theme = "light"
+	}
+
+	log.Printf("[HtmlPreview] 收到请求: path=%s, theme=%s", filePath, theme)
+
+	// 安全检查
+	if !isSafePath(filePath) {
+		log.Printf("[HtmlPreview] 路径未通过安全检查: %s", filePath)
+		http.Error(w, "Unsafe path", http.StatusForbidden)
+		return
+	}
+
+	// 检查路径遍历攻击
+	if strings.Contains(filePath, "..") {
+		log.Printf("[HtmlPreview] 检测到路径遍历尝试: %s", filePath)
+		http.Error(w, "Path traversal detected", http.StatusForbidden)
+		return
+	}
+
+	// 读取文件
+	content, err := os.ReadFile(filePath)
+	if err != nil {
+		log.Printf("[HtmlPreview] 读取文件失败: %v", err)
+		http.Error(w, "File not found", http.StatusNotFound)
+		return
+	}
+
+	// 获取文件所在目录（用于解析相对路径）
+	baseDir := filepath.Dir(filePath)
+
+	// 转换资源路径（将相对路径和绝对路径都转换为完整的本地文件服务器 URL）
+	processedContent := transformHtmlResourcePaths(string(content), baseDir)
+
+	// 修复 JS 中基于 location.pathname 的相对路径计算
+	// 预览模式下 location.pathname = "/localfs/html-preview"，与实际文件路径不一致
+	// ⚠️ 会替换所有出现位置（含JS字符串内），HTML预览场景下可接受
+	correctPathname := `"/localfs/` + strings.ReplaceAll(baseDir, "\\", "/") + `/`
+	processedContent = locationPathRegex.ReplaceAllString(processedContent, correctPathname)
+
+	// 注入链接点击拦截脚本
+	finalContent := injectLinkInterceptor(processedContent)
+
+	// 返回处理后的 HTML
+	w.Header().Set("Content-Type", "text/html; charset=utf-8")
+	w.Header().Set("Cache-Control", "no-cache")
+	w.Write([]byte(finalContent))
+
+	log.Printf("[HtmlPreview] 处理完成: %s (%d -> %d bytes)", filePath, len(content), len(finalContent))
+}
+
+// transformHtmlResourcePaths 转换 HTML 中的资源路径为本地文件服务器 URL
+func transformHtmlResourcePaths(htmlContent string, baseDir string) string {
+	if baseDir == "" {
+		return htmlContent
+	}
+
+	result := htmlContent
+
+	// 1. 处理 HTML 标签资源
+	tagConfigs := []struct {
+		pattern *regexp.Regexp
+		attr    string
+	}{
+		{htmlLinkTagRegex, "href"},
+		{htmlScriptTagRegex, "src"},
+		{htmlImgTagRegex, "src"},
+		{htmlVideoTagRegex, "src"},
+		{htmlVideoTagRegex, "poster"},
+		{htmlSourceTagRegex, "src"},
+		{htmlAudioTagRegex, "src"},
+		{htmlIframeTagRegex, "src"},
+		{htmlObjectTagRegex, "data"},
+		{htmlEmbedTagRegex, "src"},
+	}
+
+	for _, config := range tagConfigs {
+		result = replaceHtmlTagAttribute(result, config.pattern, config.attr, baseDir)
+	}
+
+	// 2. 处理 srcset 属性
+	result = replaceHtmlSrcset(result, baseDir)
+
+	// 3. 处理内联 style 属性中的 url()
+	result = replaceHtmlInlineStyleUrls(result, baseDir)
+
+	// 4. 处理 <style> 标签内的内容
+	result = replaceHtmlStyleTagContent(result, baseDir)
+
+	// 5. 处理 ES6 模块语句（使用预编译正则）
+	result = es6ImportFromRegex.ReplaceAllStringFunc(result, func(match string) string {
+		submatches := es6ImportFromRegex.FindStringSubmatch(match)
+		if len(submatches) < 3 {
+			return match
+		}
+		modulePath := submatches[2]
+		if isAbsoluteURL(modulePath) || strings.HasPrefix(modulePath, "data:") {
+			return match
+		}
+		return fmt.Sprintf(`import %s from "%s"`, submatches[1], resolveHtmlPathToUrl(baseDir, modulePath))
+	})
+
+	result = es6DynamicImport.ReplaceAllStringFunc(result, func(match string) string {
+		submatches := es6DynamicImport.FindStringSubmatch(match)
+		if len(submatches) < 2 {
+			return match
+		}
+		modulePath := submatches[1]
+		if isAbsoluteURL(modulePath) || strings.HasPrefix(modulePath, "data:") {
+			return match
+		}
+		return fmt.Sprintf(`import("%s")`, resolveHtmlPathToUrl(baseDir, modulePath))
+	})
+
+	return result
+}
+
+// replaceHtmlTagAttribute 替换 HTML 标签中的属性路径
+func replaceHtmlTagAttribute(html string, pattern *regexp.Regexp, attrName string, baseDir string) string {
+	return pattern.ReplaceAllStringFunc(html, func(match string) string {
+		// 提取属性值（使用缓存的正则）
+		var attrRegex *regexp.Regexp
+		if v, ok := attrRegexCache.Load(attrName); ok {
+			attrRegex = v.(*regexp.Regexp)
+		} else {
+			attrRegex = regexp.MustCompile(fmt.Sprintf(`%s=["']([^"']+)["']`, attrName))
+			attrRegexCache.Store(attrName, attrRegex)
+		}
+		attrMatch := attrRegex.FindStringSubmatch(match)
+		if attrMatch == nil {
+			return match
+		}
+
+		relativePath := attrMatch[1]
+		if isAbsoluteURL(relativePath) || strings.HasPrefix(relativePath, "data:") {
+			return match
+		}
+
+		newUrl := resolveHtmlPathToUrl(baseDir, relativePath)
+		return strings.Replace(match, attrMatch[0], fmt.Sprintf(`%s="%s"`, attrName, newUrl), 1)
+	})
+}
+
+// replaceHtmlSrcset 处理 srcset 属性
+func replaceHtmlSrcset(html string, baseDir string) string {
+	return htmlSrcsetRegex.ReplaceAllStringFunc(html, func(match string) string {
+		submatches := htmlSrcsetRegex.FindStringSubmatch(match)
+		if len(submatches) < 2 {
+			return match
+		}
+
+		srcset := submatches[1]
+		var newItems []string
+		for _, item := range strings.Split(srcset, ",") {
+			parts := strings.Fields(strings.TrimSpace(item))
+			if len(parts) == 0 {
+				continue
+			}
+			url := parts[0]
+			descriptor := ""
+			if len(parts) > 1 {
+				descriptor = " " + strings.Join(parts[1:], " ")
+			}
+			if isAbsoluteURL(url) || strings.HasPrefix(url, "data:") {
+				newItems = append(newItems, item)
+			} else {
+				newItems = append(newItems, resolveHtmlPathToUrl(baseDir, url)+descriptor)
+			}
+		}
+		return fmt.Sprintf(`srcset="%s"`, strings.Join(newItems, ", "))
+	})
+}
+
+// replaceHtmlInlineStyleUrls 处理内联 style 属性中的 url()
+func replaceHtmlInlineStyleUrls(html string, baseDir string) string {
+	return htmlStyleAttrRegex.ReplaceAllStringFunc(html, func(match string) string {
+		submatches := htmlStyleAttrRegex.FindStringSubmatch(match)
+		if len(submatches) < 2 {
+			return match
+		}
+
+		styleContent := submatches[1]
+		newStyle := cssUrlRegex.ReplaceAllStringFunc(styleContent, func(urlMatch string) string {
+			urlSubmatches := cssUrlRegex.FindStringSubmatch(urlMatch)
+			if len(urlSubmatches) < 2 {
+				return urlMatch
+			}
+			url := strings.TrimSpace(urlSubmatches[1])
+			if isAbsoluteURL(url) || strings.HasPrefix(url, "data:") {
+				return urlMatch
+			}
+			return fmt.Sprintf(`url("%s")`, resolveHtmlPathToUrl(baseDir, url))
+		})
+		return fmt.Sprintf(`style="%s"`, newStyle)
+	})
+}
+
+// replaceHtmlStyleTagContent 处理 <style> 标签内的内容
+func replaceHtmlStyleTagContent(html string, baseDir string) string {
+	return htmlStyleTagRegex.ReplaceAllStringFunc(html, func(match string) string {
+		submatches := htmlStyleTagRegex.FindStringSubmatch(match)
+		if len(submatches) < 3 {
+			return match
+		}
+
+		attrs := submatches[1]
+		content := submatches[2]
+
+		// 处理 @import（使用预编译正则）
+		content = cssImportRegex.ReplaceAllStringFunc(content, func(m string) string {
+			sm := cssImportRegex.FindStringSubmatch(m)
+			if len(sm) < 2 {
+				return m
+			}
+			url := sm[1]
+			if isAbsoluteURL(url) || strings.HasPrefix(url, "data:") {
+				return m
+			}
+			return fmt.Sprintf(`@import url("%s");`, resolveHtmlPathToUrl(baseDir, url))
+		})
+
+		// 处理 url()（使用预编译正则）
+		content = cssUrlRegex.ReplaceAllStringFunc(content, func(m string) string {
+			sm := cssUrlRegex.FindStringSubmatch(m)
+			if len(sm) < 2 {
+				return m
+			}
+			url := strings.TrimSpace(sm[1])
+			if isAbsoluteURL(url) || strings.HasPrefix(url, "data:") {
+				return m
+			}
+			return fmt.Sprintf(`url("%s")`, resolveHtmlPathToUrl(baseDir, url))
+		})
+
+		return fmt.Sprintf(`<style%s>%s</style>`, attrs, content)
+	})
+}
+
+// resolveHtmlPathToUrl 解析路径并转换为本地文件服务器 URL
+// 支持：相对路径 (./xxx, ../xxx)、绝对路径 (/xxx)
+func resolveHtmlPathToUrl(baseDir string, path string) string {
+	path = strings.TrimSpace(path)
+	if path == "" {
+		return ""
+	}
+
+	// 统一使用 / 作为分隔符
+	baseDir = strings.ReplaceAll(baseDir, "\\", "/")
+
+	// 处理以 / 开头的绝对路径（相对于网站根目录）
+	// 对于 dist/index.html，/assets/... 应该被解析为 dist/assets/...
+	if strings.HasPrefix(path, "/") {
+		path = path[1:] // 移除开头的 /
+	}
+
+	// 移除 ./ 前缀
+	path = strings.TrimPrefix(path, "./")
+
+	// 使用 filepath.Join 进行路径拼接（它会自动处理 ../）
+	pathBackslash := strings.ReplaceAll(path, "/", string(filepath.Separator))
+	absolutePath := filepath.Join(baseDir, pathBackslash)
+
+	// 清理路径并转换回 /
+	absolutePath = filepath.Clean(absolutePath)
+	absolutePath = strings.ReplaceAll(absolutePath, "\\", "/")
+
+	return toLocalServerUrl(absolutePath)
+}
+
+// transformJsDynamicImports 转换 JavaScript 文件中的 import 路径
+func transformJsDynamicImports(jsContent string, baseDir string) string {
+	if baseDir == "" {
+		return jsContent
+	}
+
+	result := jsContent
+
+	// 处理动态 import: import("...")（使用预编译正则）
+	result = es6DynamicImport.ReplaceAllStringFunc(result, func(match string) string {
+		submatches := es6DynamicImport.FindStringSubmatch(match)
+		if len(submatches) < 2 {
+			return match
+		}
+		modulePath := submatches[1]
+		if isAbsoluteURL(modulePath) || strings.HasPrefix(modulePath, "data:") || strings.HasPrefix(modulePath, "/localfs/") {
+			return match
+		}
+		return fmt.Sprintf(`import("%s")`, resolveHtmlPathToUrl(baseDir, modulePath))
+	})
+
+	// 处理静态 import: import ... from "..."（使用预编译正则）
+	result = es6ImportFromRegex.ReplaceAllStringFunc(result, func(match string) string {
+		submatches := es6ImportFromRegex.FindStringSubmatch(match)
+		if len(submatches) < 3 {
+			return match
+		}
+		importClause := submatches[1]
+		modulePath := submatches[2]
+		if isAbsoluteURL(modulePath) || strings.HasPrefix(modulePath, "data:") || strings.HasPrefix(modulePath, "/localfs/") {
+			return match
+		}
+		return fmt.Sprintf(`import %s from "%s"`, importClause, resolveHtmlPathToUrl(baseDir, modulePath))
+	})
+
+	// 处理裸 import: import "..."（使用预编译正则）
+	result = es6BareImport.ReplaceAllStringFunc(result, func(match string) string {
+		submatches := es6BareImport.FindStringSubmatch(match)
+		if len(submatches) < 2 {
+			return match
+		}
+		modulePath := submatches[1]
+		if isAbsoluteURL(modulePath) || strings.HasPrefix(modulePath, "data:") || strings.HasPrefix(modulePath, "/localfs/") {
+			return match
+		}
+		return fmt.Sprintf(`import "%s"`, resolveHtmlPathToUrl(baseDir, modulePath))
+	})
+
+	return result
+}
+
+// injectLinkInterceptor 注入链接点击拦截脚本
+func injectLinkInterceptor(htmlContent string) string {
+	script := `
+    <script>
+      document.addEventListener('click', function(e) {
+        var target = e.target;
+        while (target && target.tagName !== 'A') {
+          target = target.parentElement;
+        }
+        if (target && target.tagName === 'A') {
+          var href = target.getAttribute('href');
+          if (href && !href.startsWith('http://') && !href.startsWith('https://') && !href.startsWith('#') && !href.startsWith('javascript:')) {
+            e.preventDefault();
+            e.stopPropagation();
+            window.parent.postMessage({ type: 'openLocalFile', path: href }, '*');
+          }
+        }
+      }, true);
+    </script>
+`
+
+	// 在 </body> 前插入
+	if strings.Contains(htmlContent, "</body>") {
+		return strings.Replace(htmlContent, "</body>", script+"</body>", 1)
+	}
+	// 没有 body 标签，在末尾插入
+	return htmlContent + script
+}

internal/filesystem/audit_log.go

@@ -220,37 +220,6 @@ func (a *AuditLogger) Close() error {
 	return a.logFile.Close()
 }
 
-// RotateLog 日志轮转（每天创建新文件）
-func (a *AuditLogger) RotateLog() error {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-
-	// 刷新缓冲区
-	if err := a.flush(); err != nil {
-		return err
-	}
-
-	// 关闭当前文件
-	if err := a.logFile.Close(); err != nil {
-		return err
-	}
-
-	// 生成新的日志文件名
-	timestamp := time.Now().Format("2006-01-02")
-	logPath := filepath.Join(filepath.Dir(a.logPath), fmt.Sprintf("audit_%s.log", timestamp))
-
-	// 打开新文件
-	logFile, err := os.OpenFile(logPath, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0644)
-	if err != nil {
-		return err
-	}
-
-	a.logFile = logFile
-	a.logPath = logPath
-
-	return nil
-}
-
 // GetRecentLogs 获取最近的审计日志
 func GetRecentLogs(logDir string, limit int) ([]AuditLogEntry, error) {
 	// 读取今天的日志文件
@@ -309,22 +278,8 @@ func parseLines(text string) []string {
 var globalAuditLogger *AuditLogger
 var auditLoggerOnce sync.Once
 
-// InitAuditLogger 初始化全局审计日志记录器
-func InitAuditLogger(logDir string) error {
-	var err error
-	globalAuditLogger, err = NewAuditLogger(logDir)
-	return err
-}
-
 // GetAuditLogger 获取全局审计日志记录器
 func GetAuditLogger() *AuditLogger {
 	return globalAuditLogger
 }
 
-// CloseAuditLogger 关闭全局审计日志记录器
-func CloseAuditLogger() error {
-	if globalAuditLogger != nil {
-		return globalAuditLogger.Close()
-	}
-	return nil
-}

internal/filesystem/config.go

@@ -276,15 +276,24 @@ func getAllowedExtensions() map[string]bool {
 		".wav": true,
 		".ogg": true,
 		// 文档
-		".pdf": true,
+		".pdf":  true,
+		".doc":  true,
+		".docx": true,
+		".xls":  true,
+		".xlsx": true,
+		".ppt":  true,
+		".pptx": true,
 		// 文本
-		".txt": true,
+		".txt":  true,
-		".md":  true,
+		".md":   true,
 		".json": true,
 		".xml":  true,
 		".html": true,
 		".css":  true,
 		".js":   true,
+		// 表格
+		".csv": true,
+		".tsv": true,
 	}
 }
 
@@ -346,10 +355,23 @@ func getMIMETypeMapping() map[string]string {
 		".wav":  "audio/wav",
 		".ogg":  "audio/ogg",
 		".pdf":  "application/pdf",
+		// Office 文档
+		".doc":  "application/msword",
+		".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+		".xls":  "application/vnd.ms-excel",
+		".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+		".ppt":  "application/vnd.ms-powerpoint",
+		".pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+		// 文本
 		".txt":  "text/plain; charset=utf-8",
 		".html": "text/html; charset=utf-8",
 		".css":  "text/css",
 		".js":   "application/javascript",
 		".json": "application/json",
+		".xml":  "application/xml",
+		".md":   "text/markdown",
+		// 表格
+		".csv": "text/csv; charset=utf-8",
+		".tsv": "text/tab-separated-values; charset=utf-8",
 	}
 }

internal/filesystem/constants.go

@@ -13,22 +13,13 @@ const (
 
 	// HTTP 文件服务大小限制
 	MaxHTTPFileSize = 500 * 1024 * 1024 // 500MB - HTTP 访问文件最大大小
-
-	// 删除操作限制
-	MaxDeleteSizeGB = 1 * 1024 * 1024 * 1024 // 1GB - 单个文件删除大小限制
-	MaxDeleteDirSizeGB = 1 * 1024 * 1024 * 1024 // 1GB - 目录删除大小限制
 )
 
 // 时间相关常量
 const (
 	// 审计日志
-	AuditFlushInterval  = 5 * time.Second  // 审计日志刷新间隔
 	AuditLogBufferSize  = 100              // 审计日志缓冲区大小
 
-	// 回收站
-	RecycleBinRetentionDays = 30            // 回收站文件保留天数（天）
-	RecycleBinRetentionPeriod = 30 * 24 * time.Hour // 回收站文件保留期
-
 	// 临时文件
 	TempFileCleanupAge = 24 * time.Hour     // 临时文件清理周期
 	TempFileDir        = "u-desk-zip"       // 临时文件目录名
@@ -36,7 +27,6 @@ const (
 
 // 数量限制常量
 const (
-	MaxDirectoryDepth = 15  // 最大目录深度
 	MaxFileCount      = 1000 // 最大文件数量（目录）
 )
 
@@ -48,15 +38,9 @@ const (
 
 // 随机字符串相关常量
 const (
-	RandomStringCharset = "abcdefghijklmnopqrstuvwxyz0123456789"
 	RandomStringDefaultLength = 6 // 回收站文件名随机后缀长度
 )
 
-// 文件路径相关常量
-const (
-	WindowsDriveLength = 2 // Windows 盘符长度 (C:)
-)
-
 // 路径遍历检测字符串
 const (
 	PathTraversalPattern = ".." // 路径遍历特征字符串
@@ -69,17 +53,5 @@ const (
 	FileTypeAudio = "audio"
 	FileTypeDocument = "document"
 	FileTypeText = "text"
-	FileTypeArchive = "archive"
 	FileTypeApplication = "application"
 )
-
-// 安全相关常量
-const (
-	// ZIP 安全
-	MinValidZipSize = 22 // ZIP 文件最小有效大小（文件头）
-	ZipFileHeaderSignature = 0x504B // "PK" - ZIP 文件头签名
-
-	// 文件锁
-	LockCheckMaxRetries = 3              // 文件锁检查最大重试次数
-	LockCheckRetryInterval = 100 * time.Millisecond // 文件锁检查重试间隔
-)

internal/filesystem/content_detector.go

@@ -0,0 +1,133 @@
+package filesystem
+
+import (
+	"bytes"
+	"fmt"
+	"os"
+)
+
+const maxDetectSize = 500 * 1024 // 500KB
+
+// FileTypeInfo 文件类型信息
+type FileTypeInfo struct {
+	Extension string  `json:"extension"`
+	Category  string  `json:"category"`  // image, text, binary
+	MIMEType  string  `json:"mime_type"`
+	Confidence float64 `json:"confidence"`
+}
+
+// 常见文件魔数
+var magicNumbers = []struct {
+	magic    []byte
+	ext      string
+	category string
+	mime     string
+}{
+	// 图片
+	{[]byte{0xFF, 0xD8, 0xFF}, "jpg", "image", "image/jpeg"},
+	{[]byte{0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A}, "png", "image", "image/png"},
+	{[]byte{0x47, 0x49, 0x46, 0x38}, "gif", "image", "image/gif"},
+	{[]byte{0x42, 0x4D}, "bmp", "image", "image/bmp"},
+	{[]byte{0x57, 0x45, 0x42, 0x50}, "webp", "image", "image/webp"},
+
+	// 文档
+	{[]byte{0x25, 0x50, 0x44, 0x46}, "pdf", "pdf", "application/pdf"},
+
+	// 压缩
+	{[]byte{0x50, 0x4B, 0x03, 0x04}, "zip", "archive", "application/zip"},
+}
+
+// DetectFileTypeByContent 通过文件内容检测文件类型
+func (s *FileSystemService) DetectFileTypeByContent(path string) (*FileTypeInfo, error) {
+	if err := s.validatePath(path); err != nil {
+		return nil, fmt.Errorf("路径验证失败: %w", err)
+	}
+
+	info, err := os.Stat(path)
+	if err != nil {
+		return nil, fmt.Errorf("无法访问文件: %w", err)
+	}
+
+	if info.Size() > maxDetectSize {
+		return &FileTypeInfo{Category: "unknown", Confidence: 0}, nil
+	}
+
+	data, err := os.ReadFile(path)
+	if err != nil {
+		return nil, fmt.Errorf("读取文件失败: %w", err)
+	}
+
+	// 检测魔数
+	for _, m := range magicNumbers {
+		if len(data) >= len(m.magic) && bytes.Equal(data[:len(m.magic)], m.magic) {
+			return &FileTypeInfo{
+				Extension:  m.ext,
+				Category:   m.category,
+				MIMEType:   m.mime,
+				Confidence: 0.95,
+			}, nil
+		}
+	}
+
+	// 检测是否为文本
+	if isTextContent(data) {
+		return &FileTypeInfo{
+			Extension:  "txt",
+			Category:   "text",
+			MIMEType:   "text/plain",
+			Confidence: 0.8,
+		}, nil
+	}
+
+	return &FileTypeInfo{
+		Extension:  "",
+		Category:   "binary",
+		MIMEType:   "application/octet-stream",
+		Confidence: 0.5,
+	}, nil
+}
+
+// isTextContent 检测是否为文本内容
+func isTextContent(data []byte) bool {
+	if len(data) == 0 {
+		return false
+	}
+
+	textBytes := 0
+	for _, b := range data[:min(len(data), 512)] {
+		if b == 9 || b == 10 || b == 13 || (b >= 32 && b <= 126) {
+			textBytes++
+		} else if b == 0 {
+			return false
+		}
+	}
+
+	return float64(textBytes)/float64(min(len(data), 512)) > 0.9
+}
+
+func min(a, b int) int {
+	if a < b {
+		return a
+	}
+	return b
+}
+
+// DetectFileTypeByContentSimple 简化接口
+func DetectFileTypeByContentSimple(path string) (map[string]interface{}, error) {
+	service, err := GetGlobalService()
+	if err != nil {
+		return nil, err
+	}
+
+	info, err := service.DetectFileTypeByContent(path)
+	if err != nil {
+		return nil, err
+	}
+
+	return map[string]interface{}{
+		"extension":  info.Extension,
+		"category":   info.Category,
+		"mime_type":  info.MIMEType,
+		"confidence": info.Confidence,
+	}, nil
+}

internal/filesystem/errors.go

@@ -6,130 +6,6 @@ import (
 	"runtime"
 )
 
-// ErrorCode 错误码类型
-type ErrorCode string
-
-const (
-	// 通用错误
-	ErrCodeGeneral     ErrorCode = "GENERAL_ERROR"
-	ErrCodeInvalid     ErrorCode = "INVALID_ARGUMENT"
-	ErrCodeNotFound    ErrorCode = "NOT_FOUND"
-	ErrCodePermission  ErrorCode = "PERMISSION_DENIED"
-	ErrCodeIO          ErrorCode = "IO_ERROR"
-
-	// 路径相关错误
-	ErrCodePathTraversal  ErrorCode = "PATH_TRAVERSAL"
-	ErrCodeInvalidPath    ErrorCode = "INVALID_PATH"
-	ErrCodeSensitivePath  ErrorCode = "SENSITIVE_PATH"
-
-	// 文件操作错误
-	ErrCodeFileNotFound    ErrorCode = "FILE_NOT_FOUND"
-	ErrCodeFileExists      ErrorCode = "FILE_EXISTS"
-	ErrCodeDirectoryNotEmpty ErrorCode = "DIRECTORY_NOT_EMPTY"
-
-	// 安全相关错误
-	ErrCodeSecurityViolation ErrorCode = "SECURITY_VIOLATION"
-	ErrCodeSizeLimit        ErrorCode = "SIZE_LIMIT_EXCEEDED"
-	ErrCodeFileLocked      ErrorCode = "FILE_LOCKED"
-
-	// ZIP相关错误
-	ErrCodeZipInvalid    ErrorCode = "ZIP_INVALID"
-	ErrCodeZipBomb       ErrorCode = "ZIP_BOMB"
-	ErrCodeZipExtract    ErrorCode = "ZIP_EXTRACT_FAILED"
-)
-
-// FileError 文件系统专用错误类型
-// 包含详细的错误上下文信息，便于调试和用户提示
-type FileNotFoundError struct {
-	Path string
-	Err  error
-}
-
-func (e *FileNotFoundError) Error() string {
-	return fmt.Sprintf("文件不存在: %s", e.Path)
-}
-
-func (e *FileNotFoundError) Unwrap() error {
-	return e.Err
-}
-
-// PathValidationError 路径验证错误
-type PathValidationError struct {
-	Path        string
-	Reason      string
-	IsSensitive bool
-}
-
-func (e *PathValidationError) Error() string {
-	return fmt.Sprintf("路径验证失败: %s - %s", e.Path, e.Reason)
-}
-
-// SecurityViolationError 安全违规错误
-type SecurityViolationError struct {
-	Path       string
-	Violation  string
-	Suggestion string
-}
-
-func (e *SecurityViolationError) Error() string {
-	msg := fmt.Sprintf("安全违规: %s - %s", e.Path, e.Violation)
-	if e.Suggestion != "" {
-		msg += fmt.Sprintf("\n建议: %s", e.Suggestion)
-	}
-	return msg
-}
-
-// SizeLimitError 大小限制错误
-type SizeLimitError struct {
-	Path        string
-	ActualSize  int64
-	MaxSize     int64
-	SizeType    string // "file" or "directory"
-}
-
-func (e *SizeLimitError) Error() string {
-	return fmt.Sprintf("%s大小超限: %s (实际: %.2f GB, 限制: %.2f GB)",
-		e.SizeType, e.Path,
-		float64(e.ActualSize)/(1024*1024*1024),
-		float64(e.MaxSize)/(1024*1024*1024),
-	)
-}
-
-// FileLockedError 文件锁定错误
-type FileLockedError struct {
-	Path        string
-	ProcessInfo string
-}
-
-func (e *FileLockedError) Error() string {
-	msg := fmt.Sprintf("文件被占用: %s", e.Path)
-	if e.ProcessInfo != "" {
-		msg += fmt.Sprintf("\n占用程序: %s", e.ProcessInfo)
-	}
-	return msg
-}
-
-// WrapError 错误包装函数
-// 添加上下文信息到错误中
-func WrapError(operation string, path string, err error) error {
-	return fmt.Errorf("%s 失败: %s - %w", operation, path, err)
-}
-
-// WrapErrorf 格式化错误包装
-func WrapErrorf(format string, args ...interface{}) error {
-	return fmt.Errorf(format, args...)
-}
-
-// GetStackTrace 获取堆栈跟踪（用于调试）
-func GetStackTrace(skip int) string {
-	buf := make([]byte, 4096)
-	n := runtime.Stack(buf, false)
-	if n > 0 {
-		return string(buf[:n])
-	}
-	return ""
-}
-
 // DeleteRestrictionWarning 删除限制警告
 // 用于在删除受限文件时提供详细的警告信息
 type DeleteRestrictionWarning struct {
@@ -141,3 +17,13 @@ type DeleteRestrictionWarning struct {
 func (w *DeleteRestrictionWarning) Error() string {
 	return fmt.Sprintf("删除限制警告: %s\n%s", w.Path, w.Details)
 }
+
+// GetStackTrace 获取堆栈跟踪（用于调试）
+func GetStackTrace(skip int) string {
+	buf := make([]byte, 4096)
+	n := runtime.Stack(buf, false)
+	if n > 0 {
+		return string(buf[:n])
+	}
+	return ""
+}

internal/filesystem/file_lock.go

@@ -4,14 +4,6 @@ import (
 	"fmt"
 	"os"
 	"syscall"
-	"time"
-)
-
-// Windows API 锁相关函数和常量
-var (
-	modkernel32                  = syscall.NewLazyDLL("kernel32.dll")
-	procGetLastError             = modkernel32.NewProc("GetLastError")
-	procGetProcessId             = modkernel32.NewProc("GetProcessId")
 )
 
 // FileLockChecker 文件锁检查器
@@ -102,37 +94,6 @@ func (c *FileLockChecker) getProcessInfo(path string) (string, error) {
 	return "文件正被其他程序使用", nil
 }
 
-// CheckFileWithRetry 带重试的文件锁检查
-func (c *FileLockChecker) CheckFileWithRetry(path string, maxRetries int, retryInterval time.Duration) error {
-	for i := 0; i < maxRetries; i++ {
-		locked, processInfo, err := c.IsFileLocked(path)
-		if err != nil && !locked {
-			// 非锁相关的错误，直接返回
-			return err
-		}
-
-		if !locked {
-			// 文件未被锁定，可以操作
-			return nil
-		}
-
-		// 文件被锁定
-		if i < maxRetries-1 {
-			// 还有重试机会，等待后重试
-			time.Sleep(retryInterval)
-			continue
-		}
-
-		// 最后一次重试失败，返回错误
-		if processInfo != "" {
-			return fmt.Errorf("文件被占用: %s", processInfo)
-		}
-		return fmt.Errorf("文件被其他程序占用，请关闭相关程序后重试")
-	}
-
-	return fmt.Errorf("文件检查超时")
-}
-
 // SafeDeleteWithLockCheck 带锁检查的安全删除
 func (c *FileLockChecker) SafeDeleteWithLockCheck(path string) error {
 	// 检查文件是否被锁定
@@ -158,20 +119,6 @@ const (
 	ERROR_SHARING_VIOLATION = 32 // syscall.Errno(32)
 )
 
-// BY_HANDLE_FILE_INFORMATION 文件信息结构体
-type BY_HANDLE_FILE_INFORMATION struct {
-	FileAttributes     uint32
-	CreationTime       syscall.Filetime
-	LastAccessTime     syscall.Filetime
-	LastWriteTime      syscall.Filetime
-	VolumeSerialNumber uint32
-	FileSizeHigh       uint32
-	FileSizeLow        uint32
-	NumberOfLinks      uint32
-	FileIndexHigh      uint32
-	FileIndexLow       uint32
-}
-
 // contains 检查字符串是否包含子串（不区分大小写）
 func contains(str, substr string) bool {
 	return len(str) >= len(substr) && (str == substr || len(substr) == 0 ||
@@ -203,18 +150,3 @@ func containsIgnoreCase(str, substr string) bool {
 	return false
 }
 
-// 全局文件锁检查器
-var globalLockChecker *FileLockChecker
-
-// InitFileLockChecker 初始化全局文件锁检查器
-func InitFileLockChecker() {
-	globalLockChecker = NewFileLockChecker()
-}
-
-// GetFileLockChecker 获取全局文件锁检查器
-func GetFileLockChecker() *FileLockChecker {
-	if globalLockChecker == nil {
-		globalLockChecker = NewFileLockChecker()
-	}
-	return globalLockChecker
-}

internal/filesystem/fs.go

@@ -8,90 +8,9 @@ import (
 	"time"
 )
 
-// ========== 向后兼容的全局函数包装器 ==========
+// ========== 辅助函数 ==========
-// 这些函数提供向后兼容性，内部委托给 FileSystemService
-// 新代码应该使用 FileSystemService 而不是这些全局函数
-
-// ReadFile 读取文件内容（向后兼容包装器）
-func ReadFile(path string) (string, error) {
-	service, err := GetGlobalService()
-	if err != nil {
-		return "", fmt.Errorf("服务未初始化: %v", err)
-	}
-	return service.ReadFile(path)
-}
-
-// WriteFile 写入文件（向后兼容包装器）
-func WriteFile(path, content string) error {
-	service, err := GetGlobalService()
-	if err != nil {
-		return fmt.Errorf("服务未初始化: %v", err)
-	}
-	return service.WriteFile(path, content)
-}
-
-// ListDir 列出目录内容（向后兼容包装器）
-func ListDir(path string) ([]map[string]interface{}, error) {
-	service, err := GetGlobalService()
-	if err != nil {
-		return nil, fmt.Errorf("服务未初始化: %v", err)
-	}
-	return service.ListDir(path)
-}
-
-// CreateDir 创建目录（向后兼容包装器）
-func CreateDir(path string) error {
-	service, err := GetGlobalService()
-	if err != nil {
-		return fmt.Errorf("服务未初始化: %v", err)
-	}
-	return service.CreateDir(path)
-}
-
-// CreateFile 创建空文件（向后兼容包装器）
-func CreateFile(path string) error {
-	service, err := GetGlobalService()
-	if err != nil {
-		return fmt.Errorf("服务未初始化: %v", err)
-	}
-	return service.CreateFile(path)
-}
-
-// DeletePath 删除文件或目录（向后兼容包装器）
-func DeletePath(path string) error {
-	service, err := GetGlobalService()
-	if err != nil {
-		return fmt.Errorf("服务未初始化: %v", err)
-	}
-	return service.DeletePath(path)
-}
-
-// DeletePathWithConfig 使用指定配置删除文件或目录（向后兼容包装器）
-func DeletePathWithConfig(path string, config *Config) error {
-	service, err := GetGlobalService()
-	if err != nil {
-		return fmt.Errorf("服务未初始化: %v", err)
-	}
-
-	// 临时替换服务的配置
-	originalConfig := service.config
-	service.config = config
-	defer func() { service.config = originalConfig }()
-
-	return service.DeletePath(path)
-}
-
-// GetFileInfo 获取文件信息（向后兼容包装器）
-func GetFileInfo(path string) (map[string]interface{}, error) {
-	service, err := GetGlobalService()
-	if err != nil {
-		return nil, fmt.Errorf("服务未初始化: %v", err)
-	}
-	return service.GetFileInfo(path)
-}
 
 // OpenPath 打开文件或目录（使用系统默认程序）
-// 这是一个核心工具函数，保留为独立函数
 func OpenPath(path string) error {
 	// 使用 path.validator 进行验证
 	validator := NewPathValidator(DefaultConfig())
@@ -132,16 +51,7 @@ func OpenPath(path string) error {
 	return nil
 }
 
-// RenamePath 重命名文件或目录（向后兼容包装器）
+// ========== 工具函数 ==========
-func RenamePath(oldPath, newPath string) error {
-	service, err := GetGlobalService()
-	if err != nil {
-		return fmt.Errorf("服务未初始化: %v", err)
-	}
-	return service.RenamePath(oldPath, newPath)
-}
-
-// ========== 辅助函数 ==========
 
 // formatBytes 格式化字节大小为人类可读格式
 func formatBytes(bytes int64) string {

internal/filesystem/logger.go

@@ -70,11 +70,6 @@ func (l *Logger) Info(format string, args ...interface{}) {
 	l.log(LogLevelInfo, "INFO", format, args...)
 }
 
-// Warn 记录警告日志
-func (l *Logger) Warn(format string, args ...interface{}) {
-	l.log(LogLevelWarn, "WARN", format, args...)
-}
-
 // Error 记录错误日志
 func (l *Logger) Error(format string, args ...interface{}) {
 	l.log(LogLevelError, "ERROR", format, args...)
@@ -141,37 +136,10 @@ func LogError(operation string, path string, err error) {
 
 var (
 	globalLogger *Logger
-	loggerOnce  sync.Once
 )
 
-// InitLogger 初始化全局日志记录器
-func InitLogger(logDir string, minLevel LogLevel) error {
-	var initErr error
-	loggerOnce.Do(func() {
-		timestamp := time.Now().Format("2006-01-02")
-		logPath := filepath.Join(logDir, fmt.Sprintf("filesystem_%s.log", timestamp))
-
-		logger, err := NewLogger(logPath, minLevel)
-		if err != nil {
-			initErr = err
-			return
-		}
-
-		globalLogger = logger
-		log.Printf("[日志系统] 已启动，日志文件: %s", logPath)
-	})
-	return initErr
-}
-
 // GetGlobalLogger 获取全局日志记录器
 func GetGlobalLogger() *Logger {
 	return globalLogger
 }
 
-// CloseLogger 关闭全局日志记录器
-func CloseLogger() error {
-	if globalLogger != nil {
-		return globalLogger.Close()
-	}
-	return nil
-}