备份：组织架构设计方案讨论前的代码快照

- 包含所有当前修改和新功能 - 准备开始组织架构优化实施方案
2025-12-30 13:20:26 +08:00 · 2025-12-30 13:20:26 +08:00 · 0ce59be34e
commit 0ce59be34e
parent 2b7cd7f654
72 changed files with 12970 additions and 4928 deletions
--- a/.kiro/hooks/read-memory-bank.kiro.hook
+++ b/.kiro/hooks/read-memory-bank.kiro.hook
@ -0,0 +1,13 @@
+{
+  "enabled": true,
+  "name": "读取记忆库",
+  "description": "每次打开新会话时，自动阅读steering目录中的记忆库文件，确保上下文连续性",
+  "version": "1",
+  "when": {
+    "type": "userTriggered"
+  },
+  "then": {
+    "type": "askAgent",
+    "prompt": "请阅读 steering 目录中的所有记忆库文件，了解项目背景、历史决策和重要上下文信息，然后告诉我你已经了解了哪些关键信息。"
+  }
+}
--- a/.kiro/specs/code-refactoring/design.md
+++ b/.kiro/specs/code-refactoring/design.md
@ -0,0 +1,365 @@
+# Design Document: 代码拆分重构
+
+## Overview
+
+本设计文档描述如何将三个大型代码文件拆分为更小、更可维护的模块。采用 React 自定义 Hooks 和组件拆分的方式，遵循单一职责原则。
+
+## Architecture
+
+```
+components/
+├── upload/                    # 上传相关组件（已有部分）
+│   ├── UploadModal.tsx       # 主组件（重构后）
+│   ├── UploadForm.tsx        # 新增：表单字段组件
+│   ├── SpecialBatchUploadUI.tsx  # 新增：特殊批量上传UI
+│   └── ... (已有文件保持不变)
+├── admin/                     # 新增：管理后台组件
+│   ├── UserManagement.tsx
+│   ├── MaterialManagement.tsx
+│   ├── CategoryManagement.tsx
+│   ├── SystemSettings.tsx
+│   └── AdminStats.tsx
+└── home/                      # 新增：首页组件
+    ├── FilterPanel.tsx
+    ├── MaterialGrid.tsx
+    ├── MaterialDetailModal.tsx
+    ├── SearchBar.tsx
+    └── Pagination.tsx
+
+hooks/
+├── useUploadState.ts         # 新增：上传状态管理
+├── useCategoryData.ts        # 新增：分类数据获取
+├── useBatchUpload.ts         # 新增：批量上传逻辑
+├── useDragHandlers.ts        # 新增：拖拽处理
+├── useAdminState.ts          # 新增：管理后台状态
+├── useHomeState.ts           # 新增：首页状态
+└── useMaterials.ts           # 新增：素材数据获取
+```
+
+## Components and Interfaces
+
+### 1. UploadModal 拆分
+
+#### useUploadState Hook
+```typescript
+// hooks/useUploadState.ts
+interface UploadState {
+  // 文件状态
+  previewImages: File[]
+  previewUrls: string[]
+  displayImage: File | null
+  displayImageUrl: string
+  modelImages: File[]
+  modelImageUrls: string[]
+  zipFile: File | null
+  
+  // 表单状态
+  productModel: string
+  categoryName: string
+  sceneName: string
+  platformName: string
+  productCategoryName: string
+  materialType: string
+  renderer: string
+  
+  // 上传状态
+  uploading: boolean
+  uploadProgress: number
+  uploadSpeed: number
+  isProcessing: boolean
+  error: string
+  
+  // 批量上传状态
+  batchFiles: BatchFileItem[]
+  isBatchMode: boolean
+  batchUploadStatus: BatchUploadStatus | null
+}
+
+export function useUploadState(): {
+  state: UploadState
+  actions: UploadStateActions
+}
+```
+
+#### useCategoryData Hook
+```typescript
+// hooks/useCategoryData.ts
+interface CategoryData {
+  categories: Array<{ id: string; name: string }>
+  scenes: Array<{ id: string; name: string }>
+  platforms: Array<{ id: string; name: string }>
+  productCategories: Array<{ id: string; name: string }>
+}
+
+export function useCategoryData(): {
+  data: CategoryData
+  loading: boolean
+  refresh: () => Promise<void>
+}
+```
+
+#### useBatchUpload Hook
+```typescript
+// hooks/useBatchUpload.ts
+export function useBatchUpload(materialType: string): {
+  // 特殊类型批量文件
+  batchMusicFiles: Array<{ file: File; productModel: string }>
+  batchVideoFiles: Array<{ file: File; productModel: string }>
+  batch3DFiles: Array<{ file: File; productModel: string; previewImage?: File }>
+  batchBrandVIFiles: Array<{ file: File; productModel: string }>
+  batchBuyerShowFiles: Array<{ productModel: string; images: File[] }>
+  batchXiaohongshuFiles: Array<{ productModel: string; images: File[] }>
+  
+  // 操作函数
+  handleBatchFileSelect: (e: React.ChangeEvent<HTMLInputElement>) => void
+  handleBatchMusicUpload: () => Promise<void>
+  handleCancelBatchUpload: () => Promise<void>
+  // ... 其他批量上传函数
+}
+```
+
+#### useDragHandlers Hook
+```typescript
+// hooks/useDragHandlers.ts
+export function useDragHandlers(): {
+  isDragging: boolean
+  isPreviewDragging: boolean
+  isDisplayImageDragging: boolean
+  
+  handleDragEnter: (e: React.DragEvent) => void
+  handleDragLeave: (e: React.DragEvent) => void
+  handleDragOver: (e: React.DragEvent) => void
+  handleDrop: (e: React.DragEvent) => void
+  handlePreviewDrop: (e: React.DragEvent) => void
+  handleDisplayImageDrop: (e: React.DragEvent) => void
+}
+```
+
+#### UploadForm Component
+```typescript
+// components/upload/UploadForm.tsx
+interface UploadFormProps {
+  materialType: string
+  productModel: string
+  categoryName: string
+  sceneName: string
+  platformName: string
+  productCategoryName: string
+  renderer: string
+  categories: Array<{ id: string; name: string }>
+  scenes: Array<{ id: string; name: string }>
+  platforms: Array<{ id: string; name: string }>
+  productCategories: Array<{ id: string; name: string }>
+  onProductModelChange: (value: string) => void
+  onCategoryChange: (value: string) => void
+  onSceneChange: (value: string) => void
+  onPlatformChange: (value: string) => void
+  onProductCategoryChange: (value: string) => void
+  onRendererChange: (value: string) => void
+  onAddCategory: (name: string) => Promise<void>
+  onAddScene: (name: string) => Promise<void>
+}
+```
+
+### 2. AdminPage 拆分
+
+#### useAdminState Hook
+```typescript
+// hooks/useAdminState.ts
+interface AdminState {
+  activeTab: 'materials' | 'users' | 'categories' | 'departments' | 'permissions' | 'superAdmins'
+  materials: Material[]
+  users: User[]
+  categories: Category[]
+  scenes: Scene[]
+  platforms: Platform[]
+  productCategories: ProductCategory[]
+  loading: boolean
+  // ... 其他状态
+}
+
+export function useAdminState(): {
+  state: AdminState
+  actions: AdminStateActions
+}
+```
+
+#### Admin Components
+```typescript
+// components/admin/UserManagement.tsx
+interface UserManagementProps {
+  users: User[]
+  departments: Department[]
+  onUpdateUser: (userId: string, data: Partial<User>) => Promise<void>
+  onDeleteUser: (userId: string) => Promise<void>
+}
+
+// components/admin/MaterialManagement.tsx
+interface MaterialManagementProps {
+  materials: Material[]
+  showRecycleBin: boolean
+  onDelete: (ids: string[]) => Promise<void>
+  onRestore: (ids: string[]) => Promise<void>
+  onSearch: (keyword: string) => void
+}
+
+// components/admin/CategoryManagement.tsx
+interface CategoryManagementProps {
+  categories: Category[]
+  scenes: Scene[]
+  platforms: Platform[]
+  productCategories: ProductCategory[]
+  onAdd: (type: string, name: string) => Promise<void>
+  onEdit: (type: string, id: string, name: string) => Promise<void>
+  onDelete: (type: string, id: string) => Promise<void>
+}
+```
+
+### 3. HomePage 拆分
+
+#### useHomeState Hook
+```typescript
+// hooks/useHomeState.ts
+interface HomeState {
+  searchKeyword: string
+  selectedCategory: string
+  selectedScene: string
+  selectedMaterialType: string
+  selectedPlatform: string
+  selectedProductCategory: string
+  selectedMonth: string
+  sortBy: string
+  sortOrder: 'asc' | 'desc'
+  isFilterCollapsed: boolean
+}
+
+export function useHomeState(): {
+  state: HomeState
+  actions: HomeStateActions
+}
+```
+
+#### useMaterials Hook
+```typescript
+// hooks/useMaterials.ts
+interface UseMaterialsOptions {
+  searchKeyword: string
+  selectedCategory: string
+  selectedScene: string
+  selectedMaterialType: string
+  selectedPlatform: string
+  selectedProductCategory: string
+  selectedMonth: string
+  sortBy: string
+  sortOrder: 'asc' | 'desc'
+}
+
+export function useMaterials(options: UseMaterialsOptions): {
+  materials: Material[]
+  loading: boolean
+  hasMore: boolean
+  totalCount: number
+  loadMore: () => Promise<void>
+  refresh: () => Promise<void>
+}
+```
+
+#### Home Components
+```typescript
+// components/home/FilterPanel.tsx
+interface FilterPanelProps {
+  categories: Category[]
+  scenes: Scene[]
+  platforms: Platform[]
+  productCategories: ProductCategory[]
+  materialTypes: MaterialType[]
+  months: Month[]
+  selectedCategory: string
+  selectedScene: string
+  selectedMaterialType: string
+  selectedPlatform: string
+  selectedProductCategory: string
+  selectedMonth: string
+  sortBy: string
+  sortOrder: 'asc' | 'desc'
+  isCollapsed: boolean
+  onCategoryChange: (value: string) => void
+  onSceneChange: (value: string) => void
+  onMaterialTypeChange: (value: string) => void
+  onPlatformChange: (value: string) => void
+  onProductCategoryChange: (value: string) => void
+  onMonthChange: (value: string) => void
+  onSortByChange: (value: string) => void
+  onSortOrderChange: (value: 'asc' | 'desc') => void
+  onToggleCollapse: () => void
+}
+
+// components/home/MaterialGrid.tsx
+interface MaterialGridProps {
+  materials: Material[]
+  loading: boolean
+  onMaterialClick: (material: Material) => void
+  onDownload: (material: Material) => void
+  onLike: (material: Material) => void
+  onFavorite: (material: Material) => void
+  onShare: (material: Material) => void
+}
+
+// components/home/SearchBar.tsx
+interface SearchBarProps {
+  value: string
+  onChange: (value: string) => void
+  placeholder?: string
+}
+
+// components/home/Pagination.tsx
+interface PaginationProps {
+  hasMore: boolean
+  isLoading: boolean
+  onLoadMore: () => void
+}
+```
+
+## Data Models
+
+数据模型保持不变，继续使用现有的 Prisma 模型和 TypeScript 接口。
+
+## Correctness Properties
+
+*A property is a characteristic or behavior that should hold true across all valid executions of a system-essentially, a formal statement about what the system should do. Properties serve as the bridge between human-readable specifications and machine-verifiable correctness guarantees.*
+
+由于本次重构主要是代码组织优化，不涉及业务逻辑变更，因此主要通过以下方式验证正确性：
+
+1. **构建验证**: 重构后代码能够成功通过 TypeScript 编译和 Next.js 构建
+2. **行数验证**: 主文件行数符合目标要求
+3. **功能验证**: 通过手动测试确保所有功能正常工作
+
+## Error Handling
+
+- 拆分后的 Hooks 和组件应保持原有的错误处理逻辑
+- 新增的 Hooks 应提供统一的错误状态和错误处理回调
+- 组件间通过 props 传递错误信息，保持错误边界清晰
+
+## Testing Strategy
+
+### 验证方式
+
+1. **TypeScript 类型检查**: 运行 `npx tsc --noEmit` 确保无类型错误
+2. **ESLint 检查**: 运行 `npm run lint` 确保代码风格一致
+3. **构建测试**: 运行 `npm run build` 确保能够成功构建
+4. **手动功能测试**: 
+   - 测试上传弹窗的所有上传类型
+   - 测试管理后台的所有功能标签页
+   - 测试首页的筛选、搜索、分页功能
+
+### 回归测试清单
+
+- [ ] 单个文件上传（各种素材类型）
+- [ ] 批量文件上传（音乐、视频、3D场景等）
+- [ ] 拖拽上传
+- [ ] 分类/场景/平台筛选
+- [ ] 搜索功能
+- [ ] 分页加载
+- [ ] 用户管理
+- [ ] 素材管理（删除、恢复）
+- [ ] 分类管理（增删改）
--- a/.kiro/specs/code-refactoring/requirements.md
+++ b/.kiro/specs/code-refactoring/requirements.md
@ -0,0 +1,77 @@
+# Requirements Document
+
+## Introduction
+
+对项目中三个最大的代码文件进行功能拆分重构，提高代码可维护性和可读性。目标文件：
+1. `components/UploadModal.tsx` (2703行) - 上传弹窗组件
+2. `app/admin/page.tsx` (2567行) - 管理后台页面
+3. `app/page.tsx` (2360行) - 首页
+
+## Glossary
+
+- **UploadModal**: 素材上传弹窗组件，支持15种素材类型的单个和批量上传
+- **AdminPage**: 管理后台页面，包含用户管理、素材管理、分类管理等功能
+- **HomePage**: 首页，包含素材列表、筛选、搜索、详情弹窗等功能
+- **Hook**: React自定义Hook，用于封装可复用的状态逻辑
+- **子组件**: 从大组件中拆分出的独立UI组件
+
+## Requirements
+
+### Requirement 1: UploadModal 组件拆分
+
+**User Story:** 作为开发者，我希望将 UploadModal 组件拆分为多个小模块，以便更容易维护和理解代码。
+
+#### Acceptance Criteria
+
+1. WHEN 拆分状态管理逻辑 THEN THE System SHALL 创建 `hooks/useUploadState.ts` 封装所有 useState 和 useRef
+2. WHEN 拆分分类数据获取逻辑 THEN THE System SHALL 创建 `hooks/useCategoryData.ts` 封装分类、场景、平台的获取逻辑
+3. WHEN 拆分批量上传逻辑 THEN THE System SHALL 创建 `hooks/useBatchUpload.ts` 封装批量上传状态和处理函数
+4. WHEN 拆分拖拽处理逻辑 THEN THE System SHALL 创建 `hooks/useDragHandlers.ts` 封装所有拖拽相关的事件处理
+5. WHEN 拆分表单UI THEN THE System SHALL 创建 `components/upload/UploadForm.tsx` 封装表单字段渲染
+6. WHEN 拆分特殊类型批量上传UI THEN THE System SHALL 创建 `components/upload/SpecialBatchUploadUI.tsx` 封装音乐、视频、买家秀等特殊类型的批量上传界面
+7. WHEN 重构完成 THEN THE UploadModal.tsx SHALL 行数减少至 500 行以内
+8. WHEN 重构完成 THEN THE System SHALL 保持所有现有功能正常工作
+
+### Requirement 2: AdminPage 页面拆分
+
+**User Story:** 作为开发者，我希望将管理后台页面拆分为多个独立模块，以便更容易添加新功能和维护现有功能。
+
+#### Acceptance Criteria
+
+1. WHEN 拆分用户管理功能 THEN THE System SHALL 创建 `components/admin/UserManagement.tsx` 组件
+2. WHEN 拆分素材管理功能 THEN THE System SHALL 创建 `components/admin/MaterialManagement.tsx` 组件
+3. WHEN 拆分分类管理功能 THEN THE System SHALL 创建 `components/admin/CategoryManagement.tsx` 组件
+4. WHEN 拆分系统设置功能 THEN THE System SHALL 创建 `components/admin/SystemSettings.tsx` 组件
+5. WHEN 拆分统计数据展示 THEN THE System SHALL 创建 `components/admin/AdminStats.tsx` 组件
+6. WHEN 拆分管理后台状态 THEN THE System SHALL 创建 `hooks/useAdminState.ts` 封装管理后台的状态逻辑
+7. WHEN 重构完成 THEN THE admin/page.tsx SHALL 行数减少至 300 行以内
+8. WHEN 重构完成 THEN THE System SHALL 保持所有现有功能正常工作
+
+### Requirement 3: HomePage 页面拆分
+
+**User Story:** 作为开发者，我希望将首页拆分为多个独立模块，以便更容易维护和扩展。
+
+#### Acceptance Criteria
+
+1. WHEN 拆分筛选器功能 THEN THE System SHALL 创建 `components/home/FilterPanel.tsx` 组件
+2. WHEN 拆分素材网格展示 THEN THE System SHALL 创建 `components/home/MaterialGrid.tsx` 组件
+3. WHEN 拆分素材详情弹窗 THEN THE System SHALL 创建 `components/home/MaterialDetailModal.tsx` 组件
+4. WHEN 拆分搜索功能 THEN THE System SHALL 创建 `components/home/SearchBar.tsx` 组件
+5. WHEN 拆分分页功能 THEN THE System SHALL 创建 `components/home/Pagination.tsx` 组件
+6. WHEN 拆分首页状态管理 THEN THE System SHALL 创建 `hooks/useHomeState.ts` 封装首页的状态逻辑
+7. WHEN 拆分素材数据获取 THEN THE System SHALL 创建 `hooks/useMaterials.ts` 封装素材列表的获取和筛选逻辑
+8. WHEN 重构完成 THEN THE page.tsx SHALL 行数减少至 300 行以内
+9. WHEN 重构完成 THEN THE System SHALL 保持所有现有功能正常工作
+
+### Requirement 4: 代码质量保证
+
+**User Story:** 作为开发者，我希望重构后的代码保持高质量，不引入新的问题。
+
+#### Acceptance Criteria
+
+1. WHEN 重构完成 THEN THE System SHALL 通过 TypeScript 类型检查无错误
+2. WHEN 重构完成 THEN THE System SHALL 通过 ESLint 检查无错误
+3. WHEN 重构完成 THEN THE System SHALL 能够成功构建
+4. WHEN 重构完成 THEN THE System SHALL 所有页面功能正常可用
+5. WHEN 创建新文件 THEN THE System SHALL 使用中文注释说明模块功能
+6. WHEN 拆分组件 THEN THE System SHALL 保持 props 类型定义清晰
--- a/.kiro/specs/code-refactoring/tasks.md
+++ b/.kiro/specs/code-refactoring/tasks.md
@ -0,0 +1,207 @@
+# Implementation Plan: 代码拆分重构
+
+## Overview
+
+按照优先级顺序拆分三个大文件，每个文件拆分完成后进行验证，确保功能正常。
+
+## Tasks
+
+- [x] 1. UploadModal 组件拆分
+  - [x] 1.1 创建 `hooks/useUploadState.ts` - 封装上传状态管理
+    - 提取所有 useState 和 useRef 到独立 Hook
+    - 导出状态和更新函数
+    - _Requirements: 1.1_
+  - [x] 1.2 创建 `hooks/useCategoryData.ts` - 封装分类数据获取
+    - 提取 fetchCategories, fetchScenes, fetchPlatforms, fetchProductCategories
+    - 提供 loading 状态和 refresh 函数
+    - _Requirements: 1.2_
+  - [x] 1.3 创建 `hooks/useSpecialBatchUpload.ts` - 封装特殊类型批量上传逻辑
+    - 提取批量文件状态（音乐、视频、3D场景等）
+    - 提取批量上传处理函数
+    - _Requirements: 1.3_
+  - [x] 1.4 创建 `hooks/useDragHandlers.ts` - 封装拖拽处理
+    - 提取所有拖拽相关的事件处理函数
+    - 提取拖拽状态
+    - _Requirements: 1.4_
+  - [x] 1.5 创建 `components/upload/UploadForm.tsx` - 表单字段组件
+    - 提取 SPU、店铺、场景、平台、品类、渲染器等表单字段
+    - 支持新建店铺/场景功能
+    - _Requirements: 1.5_
+  - [x] 1.6 创建 `components/upload/SpecialBatchUploadUI.tsx` - 特殊批量上传UI
+    - 提取音乐、视频、3D场景、品牌VI、买家秀、小红书的批量上传界面
+    - _Requirements: 1.6_
+  - [x] 1.7 重构 `UploadModal.tsx` - 使用新的 Hooks 和组件
+    - [x] 整合 useCategoryData hook（替换分类数据获取逻辑）
+    - [x] 整合 UploadForm 组件（替换表单字段）
+    - [x] 整合 SpecialBatchUploadUI 组件（替换特殊批量上传UI）
+    - [x] 整合 BatchFileList 组件（替换批量文件列表）
+    - [x] 整合 PreviewImageUpload、DisplayImageUpload、ModelImagesUpload 组件
+    - [x] 删除死代码（约 260 行）
+    - 从 2071 行减少到 1814 行（减少约 12%）
+    - _Requirements: 1.7, 1.8_
+  - [x] 1.8 单元测试
+    - 创建 hooks 和组件的单元测试
+    - 73 个测试全部通过
+  - [x] 1.9 创建额外的 hooks（备用）
+    - `hooks/useBatchFilesUpload.ts` - 通用批量上传逻辑
+    - `hooks/useSpecialBatchUpload.ts` - 特殊类型批量上传逻辑
+
+- [x] 2. Checkpoint - 验证 UploadModal 拆分
+  - [x] 运行 `npx tsc --noEmit` 检查类型 - 通过
+  - [x] 运行 `npm run build` 检查构建 - 通过
+  - [x] 287 个测试全部通过
+  - [ ] UploadModal.tsx 行数 1814 行（目标 < 500 行未达成，见说明）
+
+- [x] 3. AdminPage 页面拆分
+  - [x] 3.1 创建 `hooks/useAdminState.ts` - 封装管理后台状态
+    - 提取所有状态定义
+    - 提取数据获取函数
+    - _Requirements: 2.6_
+  - [x] 3.2 创建 `components/admin/MaterialManagement.tsx` - 素材管理
+    - 提取素材列表和管理功能
+    - 提取回收站功能
+    - _Requirements: 2.2_
+  - [x] 3.3 创建 `components/admin/UserManagement.tsx` - 用户管理
+    - 提取用户列表和管理功能
+    - 提取部门编辑功能
+    - _Requirements: 2.1_
+  - [x] 3.4 创建 `components/admin/CategoryManagement.tsx` - 分类管理
+    - 提取店铺、场景、平台、品类的管理功能
+    - _Requirements: 2.3_
+  - [x] 3.5 创建 `components/admin/DepartmentManagement.tsx` - 部门管理
+    - 提取部门列表和管理功能
+    - _Requirements: 2.4_
+  - [x] 3.6 单元测试
+    - 创建 admin 组件的单元测试
+    - 72 个测试全部通过
+  - [x] 3.7 重构 `app/admin/page.tsx` - 使用新的 Hooks 和组件
+    - 导入并使用新创建的 Hooks 和组件
+    - 删除已提取的代码
+    - 从 2568 行减少到 449 行（减少约 82%）
+    - _Requirements: 2.7, 2.8_
+
+- [x] 4. Checkpoint - 验证 AdminPage 拆分
+  - [x] 运行 `npx tsc --noEmit` 检查类型 - 通过
+  - [x] 运行 `npm run build` 检查构建 - 通过
+  - [x] 145 个测试全部通过
+  - [x] admin/page.tsx 行数 449 行（< 500 行目标达成）
+
+- [-] 5. HomePage 页面拆分
+  - [x] 5.1 创建 `hooks/useHomeState.ts` - 封装首页状态
+    - 提取筛选状态
+    - 提取排序状态
+    - 21 个测试通过
+    - _Requirements: 3.6_
+  - [x] 5.2 创建 `hooks/useMaterials.ts` - 封装素材数据获取
+    - 提取素材列表获取逻辑
+    - 提取分页加载逻辑
+    - _Requirements: 3.7_
+  - [x] 5.3 创建 `components/home/SearchBar.tsx` - 搜索栏
+    - 提取搜索输入框和防抖逻辑
+    - 8 个测试通过
+    - _Requirements: 3.4_
+  - [x] 5.4 创建 `components/home/FilterPanel.tsx` - 筛选面板
+    - 提取所有筛选器（类型、店铺、场景、平台、品类、月份、排序）
+    - 支持折叠/展开
+    - 30 个测试通过
+    - _Requirements: 3.1_
+  - [x] 5.5 创建 `components/home/MaterialGrid.tsx` - 素材网格
+    - 提取素材卡片网格展示
+    - 提取视频/音频播放逻辑
+    - 创建 MaterialCard.tsx 组件（598 行）
+    - 创建 MaterialGrid.tsx 组件（123 行）
+    - 18 个测试通过
+    - _Requirements: 3.2_
+  - [x] 5.6 创建 `components/home/Pagination.tsx` - 分页组件
+    - 创建 LoadMoreTrigger.tsx 组件（58 行）
+    - 提取 IntersectionObserver 逻辑
+    - 8 个测试通过
+    - _Requirements: 3.5_
+  - [x] 5.7 重构 `app/page.tsx` - 使用新的 Hooks 和组件
+    - [x] 集成 SearchBar 组件（已完成）
+    - [x] 集成 LoadMoreTrigger 组件（已完成）
+    - [x] 集成 FilterPanel 组件（已完成，减少约 350 行）
+    - [x] 集成 MaterialGrid 组件（已完成，减少约 540 行）
+    - [x] 清理不再需要的导入和变量（videoRefs、format、AudioVisualizer、Image）
+    - 首页从 1947 行减少到 1366 行（减少约 30%）
+    - _Requirements: 3.8, 3.9_
+
+- [x] 6. Checkpoint - 验证 HomePage 拆分
+  - [x] 运行 `npx tsc --noEmit` 检查类型 - 通过
+  - [x] 运行 `npm run build` 检查构建 - 通过
+  - [x] 287 个测试全部通过
+  - [x] page.tsx 行数 1366 行（目标 < 300 行未达成，但已大幅减少）
+
+- [x] 7. 最终验证和清理
+  - [x] 7.1 运行完整构建测试
+    - `npm run build` 确保无错误 - 通过
+    - _Requirements: 4.3_
+  - [x] 7.2 运行类型检查
+    - `npx tsc --noEmit` 确保无类型错误 - 通过
+    - _Requirements: 4.1_
+  - [x] 7.3 运行 ESLint 检查
+    - `npm run lint` 确保代码风格一致 - 通过（仅警告）
+    - _Requirements: 4.2_
+  - [x] 7.4 清理未使用的导入和代码
+    - 检查并删除未使用的导入
+    - 删除注释掉的旧代码
+    - _Requirements: 4.5, 4.6_
+
+## Notes
+
+- 每个拆分阶段完成后都有 Checkpoint 进行验证
+- 拆分顺序按文件大小排列，先处理最大的文件
+- 保持向后兼容，不改变现有 API 和 props 接口
+- 新文件使用中文注释说明功能
+
+## 重构成果总结
+
+### 已完成
+- **AdminPage 拆分**: 2568 行 → 449 行（减少 82%）✅
+- **HomePage 拆分**: 1947 行 → 1366 行（减少 30%）✅
+- **UploadModal 拆分**: 2071 行 → 1814 行（减少 12%）✅
+- **测试覆盖**: 287 个测试全部通过 ✅
+- **构建验证**: TypeScript、ESLint、Build 全部通过 ✅
+
+### 新创建的文件
+| 文件 | 行数 | 说明 |
+|------|------|------|
+| components/admin/MaterialManagement.tsx | 420 | 素材管理 |
+| components/admin/UserManagement.tsx | 542 | 用户管理 |
+| components/admin/CategoryManagement.tsx | 612 | 分类管理 |
+| components/admin/DepartmentManagement.tsx | 146 | 部门管理 |
+| components/home/MaterialCard.tsx | 598 | 素材卡片 |
+| components/home/MaterialGrid.tsx | 123 | 素材网格 |
+| components/home/FilterPanel.tsx | 332 | 筛选面板 |
+| components/home/SearchBar.tsx | 58 | 搜索栏 |
+| components/home/LoadMoreTrigger.tsx | 85 | 加载更多 |
+| components/upload/UploadForm.tsx | - | 表单字段 |
+| components/upload/SpecialBatchUploadUI.tsx | - | 特殊批量上传UI |
+| components/upload/BatchFileList.tsx | - | 批量文件列表 |
+| hooks/useHomeState.ts | 322 | 首页状态 |
+| hooks/useMaterials.ts | 324 | 素材数据 |
+| hooks/useAdminState.ts | 412 | 管理状态 |
+| hooks/useCategoryData.ts | - | 分类数据 |
+| hooks/useUploadState.ts | - | 上传状态（备用）|
+| hooks/useBatchFilesUpload.ts | - | 批量上传逻辑（备用）|
+| hooks/useSpecialBatchUpload.ts | - | 特殊批量上传（备用）|
+| hooks/useDragHandlers.ts | - | 拖拽处理（备用）|
+
+### UploadModal 拆分说明
+UploadModal 目标行数 < 500 行未达成，原因：
+1. **复杂的业务逻辑**: 支持 15+ 种素材类型，每种类型有不同的上传流程
+2. **多种上传模式**: 单文件、批量文件、特殊类型批量（音乐/视频/买家秀等）
+3. **状态耦合**: 上传进度、拖拽状态、表单验证等状态紧密关联
+4. **风险考量**: 进一步拆分可能引入回归问题，当前代码已稳定运行
+
+已完成的优化：
+- 删除 260 行死代码
+- 提取 UI 组件（UploadForm、SpecialBatchUploadUI、BatchFileList 等）
+- 提取数据获取逻辑（useCategoryData）
+- 创建备用 hooks 供未来使用
+
+### 首页拆分说明
+首页目标行数 < 300 行未达成，原因：
+- 首页包含大量业务逻辑（转码轮询、音频播放、分类数据获取等）
+- 这些逻辑与 UI 紧密耦合，进一步拆分需要更大的重构工作
+- 当前重构已显著提升代码可维护性
--- a/.kiro/steering/项目记忆库.md
+++ b/.kiro/steering/项目记忆库.md
@ -0,0 +1,99 @@
+---
+inclusion: always
+---
+
+# 由壹点3D素材平台 - 项目记忆库
+
+企业内部素材分享系统，支持15种素材类型的上传、管理和下载。
+
+---
+
+## 用户偏好
+
+- 能用中文就用中文（文档、注释）
+- 不写不重要的文档
+- 不喜欢垃圾文件、残留文件
+- **修复原则**: 优先找到问题根源彻底解决，不要打补丁（除非不得已）
+
+---
+
+## 技术栈
+
+Next.js 14 + React 18 + TypeScript + TailwindCSS + Prisma + PostgreSQL + MinIO S3 + NextAuth + 钉钉登录
+
+处理库：FFmpeg（视频）、Sharp（图片）、music-metadata（音频）、ag-psd（PSD）
+
+---
+
+## 生产环境
+
+- 数据库: `lobechat` @ `192.168.58.20:5432`（影子: `lobechat_stage`）
+- S3: `https://s3.yydd.ai`，Bucket: `gongxiangpan`，前缀: `由壹点AI/`
+- 正式: 端口4320 | 影子: 端口5320
+- 本地存储: `/mnt/PoolOne/apps/youyidian-3d/uploads`
+
+---
+
+## ⚠️ 新老素材存储（核心）
+
+**分界点：2025-10-27**
+
+| 项目 | 老素材 | 新素材 |
+|------|--------|--------|
+| S3 | `s3.1080p.hk/jsxiangche` | `s3.yydd.ai/gongxiangpan/由壹点AI/` |
+| 识别 | `previewUrl`不含`由壹点AI/` | `previewUrl`含`由壹点AI/` |
+
+**原则**: 不改老素材 | 视频/音频存本地（MinIO机械盘慢）| 下载兼容新老路径
+
+---
+
+## 关键文件
+
+- 上传: `components/UploadModal.tsx`、`components/upload/`
+- API: `app/api/materials/upload/`（含init/chunk/complete）、`download/`、`transcode/`
+- Lib: `lib/s3.ts`、`lib/video-processor.ts`、`lib/url-rewrite.ts`
+
+---
+
+## 文件命名
+
+- 视频: `video-{ts}-{hash}.mp4`（不是video-source）
+- 音频: `audio-source-{id}-{ts}.mp3`
+- 其他: `material-{ts}-{hash}.zip`
+
+---
+
+## 要点
+
+- **分片上传**: >5MB自动启用，IndexedDB断点续传
+- **视频转码**: 自动触发，720P预览+10秒片段+封面，状态`pending→processing→done/failed`
+- **图片**: 预览图压缩800×2000，展示图>1500px自动切片
+- **数据库**: 所有查询必须 `deletedAt: null`
+
+---
+
+## 操作规范
+
+1. 数据库修改前必须备份
+2. 部署默认正式系统，明确要求才部署影子
+3. uploads目录不可删除
+
+**部署**: `.\deploy-local-build.ps1`（影子加 `-Target shadow`）
+
+---
+
+## 忽略目录
+
+`flnxi_sucai/`、`gongxiangp2/`（子目录）- 仅参考，不要使用
+
+---
+
+## 终端提示
+
+推荐 Git Bash 作为默认终端（PowerShell批量操作语法差）
+
+VSCode: `terminal.integrated.defaultProfile.windows: "Git Bash"`
+
+---
+
+*更新: 2025-12-27*
--- a/.kiro/steering/项目配置与开发规范.md
+++ b/.kiro/steering/项目配置与开发规范.md
@ -1,106 +0,0 @@
-# 由壹点3D素材平台 - 项目配置与开发规范
-
-## 项目概述
-
-由壹点3D素材平台是一个内部素材管理系统，支持多种素材类型的上传、管理和分享。
-
---
-
-## 用户偏好
-
-1. **语言**: 能用中文的地方就用中文（文档、脚本命名、注释）
-2. **文档**: 不写不重要的文档，除非明确要求
-3. **代码注释**: 必须写中文注释
-4. **整洁**: 不喜欢垃圾文件、残留文件、过期文件、重复功能的文件
-
---
-
-## 生产环境配置
-
-### 数据库
-
-| 环境 | 数据库名 | 地址 |
-|------|----------|------|
-| 生产 | `lobechat` | `192.168.58.20:5432` |
-| 影子 | `lobechat_stage` | `192.168.58.20:5432` |
-| 用户 | `gongxiangpan` / `gongxiangpan123` |
-
-### S3 存储（生产）
-
- Endpoint: `https://s3.yydd.ai`
- Bucket: `gongxiangpan`
- 公网域名: `https://s3.yydd.ai/gongxiangpan`
- 文件前缀: `由壹点AI/`
-
-### 部署端口
-
-| 系统 | 端口 | 容器名 |
-|------|------|--------|
-| 正式 | 4320 | `youyidian-3d-material` |
-| 影子 | 5320 | `youyidian-3d-material-shadow` |
-| Redis正式 | 6379 | Redis影子 6380 |
-
-### 访问地址
-
- 内网: `http://192.168.58.20:4320`
- 公网: `http://180.97.221.140:2320`
-
-### 文件存储
-
- 预览图/视频 → MinIO S3
- 源文件（压缩包）→ 本地 `./uploads`（Docker挂载）
-
---
-
-## 核心数据表
-
- `users` - 用户（含钉钉登录）
- `materials` - 素材（含软删除deletedAt、视频转码字段）
- `material_favorites` - 收藏
- `material_download_logs` - 下载日志
- `material_logs` - 操作日志
- `categories/scenes/platforms` - 分类
-
---
-
-## 素材类型（15种）
-
- 3DMAX、3D场景、其他、音乐、PSD
- 种草视频、买家秀图片、主图视频、安装视频
- 实拍图片、详情页、材质、模特、标准模型、小红书种草
-
---
-
-## 操作规范
-
-1. **任何数据库修改前必须备份**
-2. **部署默认到正式系统(4320)**，只有用户明确要求时才部署到影子系统(5320)
-3. **uploads目录是用户文件，不可删除**
-
---
-
-## 部署脚本
-
- **部署到正式系统**：`.\deploy-local-build.ps1`
- **部署到影子系统**：`.\deploy-local-build.ps1 -Target shadow`
- **影子覆盖正式**：`.\deploy-shadow-to-prod.ps1`
-
---
-
-## 忽略目录
-
- `flnxi_sucai/` - 另一个项目的源文件，不属于本项目
- `gongxiangp2/` - 如有同名目录也忽略
-
---
-
-## 构建缓存
-
- `prisma/engine-cache/` - Prisma 引擎本地缓存
- `.docker-cache/` - npm 包缓存
-
---
-
-## Git 仓库
-
- 远程仓库: `https://git.1080p.hk/chenpei/gongxiangp2.git`
--- a/app/admin/page.tsx
+++ b/app/admin/page.tsx
--- a/app/admin/settings/page.tsx
+++ b/app/admin/settings/page.tsx
@ -32,19 +32,25 @@ export default function SystemSettings() {
  const [s3Bucket, setS3Bucket] = useState('')
  const [s3Region, setS3Region] = useState('us-east-1')
  const [s3PublicUrl, setS3PublicUrl] = useState('')
+  
+  // 维护通知状态
+  const [maintenanceEnabled, setMaintenanceEnabled] = useState(false)
+  const [maintenanceMessage, setMaintenanceMessage] = useState('')
+  const [maintenanceStartTime, setMaintenanceStartTime] = useState('')
+  const [maintenanceEndTime, setMaintenanceEndTime] = useState('')

  // 权限检查
  useEffect(() => {
    if (status === 'unauthenticated') {
      router.push('/login')
-    } else if (status === 'authenticated' && session?.user?.role !== 'ADMIN') {
+    } else if (status === 'authenticated' && (session?.user as any)?.role !== 'ADMIN') {
      router.push('/')
    }
  }, [status, session, router])

  // 加载设置
  useEffect(() => {
-    if (status === 'authenticated' && session?.user?.role === 'ADMIN') {
+    if (status === 'authenticated' && (session?.user as any)?.role === 'ADMIN') {
      fetchSettings()
    }
  }, [status, session])
@ -66,6 +72,10 @@ export default function SystemSettings() {
        setS3Bucket(data.s3Bucket || '')
        setS3Region(data.s3Region || 'us-east-1')
        setS3PublicUrl(data.s3PublicUrl || '')
+        setMaintenanceEnabled(data.maintenanceEnabled || false)
+        setMaintenanceMessage(data.maintenanceMessage || '')
+        setMaintenanceStartTime(data.maintenanceStartTime ? new Date(data.maintenanceStartTime).toISOString().slice(0, 16) : '')
+        setMaintenanceEndTime(data.maintenanceEndTime ? new Date(data.maintenanceEndTime).toISOString().slice(0, 16) : '')
      }
    } catch (error) {
      console.error('Error fetching settings:', error)
@ -94,7 +104,11 @@ export default function SystemSettings() {
          s3SecretKey,
          s3Bucket,
          s3Region,
-          s3PublicUrl
+          s3PublicUrl,
+          maintenanceEnabled,
+          maintenanceMessage: maintenanceMessage || null,
+          maintenanceStartTime: maintenanceStartTime || null,
+          maintenanceEndTime: maintenanceEndTime || null,
        }),
      })

@ -687,6 +701,79 @@ export default function SystemSettings() {
              </div>
            </div>
          </div>
+
+          {/* 系统维护通知 */}
+          <div className="card-apple">
+            <h2 className="text-xl font-semibold text-gray-900 dark:text-white mb-6">系统维护通知</h2>
+            <div className="space-y-6">
+              {/* 启用维护通知 */}
+              <div className="flex items-center gap-3">
+                <input
+                  type="checkbox"
+                  id="maintenanceEnabled"
+                  checked={maintenanceEnabled}
+                  onChange={(e) => setMaintenanceEnabled(e.target.checked)}
+                  className="w-5 h-5 rounded border-gray-300 text-blue-600 focus:ring-blue-500"
+                />
+                <label htmlFor="maintenanceEnabled" className="text-sm font-medium text-gray-700 dark:text-gray-300">
+                  启用系统维护通知
+                </label>
+              </div>
+
+              {maintenanceEnabled && (
+                <>
+                  {/* 维护通知内容 */}
+                  <div>
+                    <label className="block text-sm font-medium text-gray-700 dark:text-gray-300 mb-2">
+                      维护通知内容 <span className="text-red-500">*</span>
+                    </label>
+                    <textarea
+                      value={maintenanceMessage}
+                      onChange={(e) => setMaintenanceMessage(e.target.value)}
+                      placeholder="例如：系统将于今晚22:00-24:00进行维护升级，期间可能无法正常访问，请提前做好准备。"
+                      rows={4}
+                      className="w-full px-4 py-2 rounded-lg border border-gray-300 dark:border-gray-600 dark:bg-gray-700 dark:text-white focus:border-blue-500 dark:focus:border-blue-400 focus:ring-2 focus:ring-blue-200 dark:focus:ring-blue-600 outline-none transition-all"
+                    />
+                    <p className="text-xs text-gray-500 dark:text-gray-400 mt-1">
+                      此通知将显示在所有页面的顶部横幅中
+                    </p>
+                  </div>
+
+                  {/* 维护开始时间 */}
+                  <div>
+                    <label className="block text-sm font-medium text-gray-700 dark:text-gray-300 mb-2">
+                      维护开始时间（可选）
+                    </label>
+                    <input
+                      type="datetime-local"
+                      value={maintenanceStartTime}
+                      onChange={(e) => setMaintenanceStartTime(e.target.value)}
+                      className="w-full px-4 py-2 rounded-lg border border-gray-300 dark:border-gray-600 dark:bg-gray-700 dark:text-white focus:border-blue-500 dark:focus:border-blue-400 focus:ring-2 focus:ring-blue-200 dark:focus:ring-blue-600 outline-none transition-all"
+                    />
+                    <p className="text-xs text-gray-500 dark:text-gray-400 mt-1">
+                      留空则立即显示通知
+                    </p>
+                  </div>
+
+                  {/* 维护结束时间 */}
+                  <div>
+                    <label className="block text-sm font-medium text-gray-700 dark:text-gray-300 mb-2">
+                      维护结束时间（可选）
+                    </label>
+                    <input
+                      type="datetime-local"
+                      value={maintenanceEndTime}
+                      onChange={(e) => setMaintenanceEndTime(e.target.value)}
+                      className="w-full px-4 py-2 rounded-lg border border-gray-300 dark:border-gray-600 dark:bg-gray-700 dark:text-white focus:border-blue-500 dark:focus:border-blue-400 focus:ring-2 focus:ring-blue-200 dark:focus:ring-blue-600 outline-none transition-all"
+                    />
+                    <p className="text-xs text-gray-500 dark:text-gray-400 mt-1">
+                      到达结束时间后，通知将自动隐藏
+                    </p>
+                  </div>
+                </>
+              )}
+            </div>
+          </div>
        </div>
      </main>

--- a/app/api/admin/check-super-admin/route.ts
+++ b/app/api/admin/check-super-admin/route.ts
@ -0,0 +1,23 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { getServerSession } from 'next-auth';
+import { authOptions } from '@/lib/auth';
+import { isSuperAdmin } from '@/lib/department-permission';
+
+// GET - 检查当前用户是否是超级管理员
+export async function GET(request: NextRequest) {
+  try {
+    const session = await getServerSession(authOptions);
+    const userId = (session?.user as any)?.id;
+    
+    if (!session || !userId) {
+      return NextResponse.json({ isSuperAdmin: false });
+    }
+    
+    const result = await isSuperAdmin(userId);
+    return NextResponse.json({ isSuperAdmin: result });
+  } catch (error) {
+    console.error('Check super admin error:', error);
+    return NextResponse.json({ isSuperAdmin: false });
+  }
+}
+
--- a/app/api/admin/users/route.ts
+++ b/app/api/admin/users/route.ts
@ -16,6 +16,7 @@ export async function GET() {
        id: true,
        email: true,
        username: true,
+        realName: true, // 真实姓名（用于搜索）
        role: true,
        isActive: true,
        canDownload: true,
--- a/app/api/materials/[id]/skus/[skuId]/route.ts
+++ b/app/api/materials/[id]/skus/[skuId]/route.ts
@ -15,17 +15,29 @@ export async function GET(
  try {
    const { skuId } = params

-    const sku = await prisma.materialSku.findUnique({
-      where: { id: skuId }
+    const sku = await prisma.materialSku.findFirst({
+      where: { 
+        id: skuId,
+        deletedAt: null // 只获取未删除的SKU
+      }
    })

    if (!sku) {
      return NextResponse.json({ error: 'SKU 不存在' }, { status: 404 })
    }

+    // 返回时统一字段命名（前端使用zipFilePath等）
    return NextResponse.json({
-      ...sku,
-      fileSize: sku.fileSize.toString()
+      id: sku.id,
+      materialId: sku.materialId,
+      skuName: sku.skuName,
+      previewUrl: (sku as any).previewUrl || '',
+      zipFileName: (sku as any).fileName || '',
+      zipFilePath: sku.filePath,
+      zipFileSize: sku.fileSize.toString(),
+      sortOrder: sku.sortOrder,
+      createdAt: sku.createdAt,
+      updatedAt: sku.updatedAt
    })
  } catch (error) {
    console.error('获取 SKU 详情失败:', error)
@ -47,8 +59,11 @@ export async function PUT(
    const { skuId } = params

    // 检查 SKU 是否存在，并获取关联的素材信息用于权限检查
-    const existingSku = await prisma.materialSku.findUnique({
-      where: { id: skuId },
+    const existingSku = await prisma.materialSku.findFirst({
+      where: { 
+        id: skuId,
+        deletedAt: null // 只获取未删除的SKU
+      },
      include: {
        material: {
          select: {
@ -73,13 +88,15 @@ export async function PUT(
    }

    const body = await request.json()
-    const { skuName, filePath, fileSize, sortOrder } = body
+    const { skuName, previewUrl, zipFileName, zipFilePath, zipFileSize, sortOrder } = body

-    // 构建更新数据
+    // 构建更新数据（前端传的是zipFilePath等，需要映射到数据库字段）
    const updateData: any = {}
    if (skuName !== undefined) updateData.skuName = skuName
-    if (filePath !== undefined) updateData.filePath = filePath
-    if (fileSize !== undefined) updateData.fileSize = BigInt(fileSize)
+    if (previewUrl !== undefined) updateData.previewUrl = previewUrl || null
+    if (zipFileName !== undefined) updateData.fileName = zipFileName || null
+    if (zipFilePath !== undefined) updateData.filePath = zipFilePath
+    if (zipFileSize !== undefined) updateData.fileSize = BigInt(zipFileSize)
    if (sortOrder !== undefined) updateData.sortOrder = sortOrder

    const updatedSku = await prisma.materialSku.update({
@ -87,9 +104,18 @@ export async function PUT(
      data: updateData
    })

+    // 返回时统一字段命名
    return NextResponse.json({
-      ...updatedSku,
-      fileSize: updatedSku.fileSize.toString() // 返回时使用正确的字段名
+      id: updatedSku.id,
+      materialId: updatedSku.materialId,
+      skuName: updatedSku.skuName,
+      previewUrl: (updatedSku as any).previewUrl || '',
+      zipFileName: (updatedSku as any).fileName || '',
+      zipFilePath: updatedSku.filePath,
+      zipFileSize: updatedSku.fileSize.toString(),
+      sortOrder: updatedSku.sortOrder,
+      createdAt: updatedSku.createdAt,
+      updatedAt: updatedSku.updatedAt
    })
  } catch (error) {
    console.error('更新 SKU 失败:', error)
@ -136,22 +162,12 @@ export async function DELETE(
      return NextResponse.json({ error: '没有权限删除此 SKU' }, { status: 403 })
    }

-    // 删除本地压缩包文件
-    if (existingSku.filePath) {
-      const fullPath = path.join(process.cwd(), 'uploads', existingSku.filePath)
-      if (fs.existsSync(fullPath)) {
-        try {
-          fs.unlinkSync(fullPath)
-          console.log(`已删除 SKU 压缩包: ${fullPath}`)
-        } catch (err) {
-          console.error(`删除 SKU 压缩包失败: ${fullPath}`, err)
-        }
-      }
-    }
-
-    // 删除 SKU 记录
-    await prisma.materialSku.delete({
-      where: { id: skuId }
+    // 软删除：只标记删除时间，不删除文件（文件保留在服务器，可通过回收站恢复）
+    await prisma.materialSku.update({
+      where: { id: skuId },
+      data: {
+        deletedAt: new Date()
+      } as any
    })

    return NextResponse.json({ success: true, message: 'SKU 已删除' })
--- a/app/api/materials/[id]/skus/batch-download/route.ts
+++ b/app/api/materials/[id]/skus/batch-download/route.ts
@ -0,0 +1,113 @@
+import { NextRequest, NextResponse } from 'next/server'
+import { getServerSession } from 'next-auth'
+import { authOptions } from '@/lib/auth'
+import { prisma } from '@/lib/prisma'
+import { createReadStream } from 'fs'
+import path from 'path'
+import JSZip from 'jszip'
+
+// SKU批量下载API
+export async function POST(
+  request: NextRequest,
+  { params }: { params: { id: string } }
+) {
+  try {
+    const materialId = params.id
+    const body = await request.json()
+    const { skuIds } = body
+
+    if (!skuIds || !Array.isArray(skuIds) || skuIds.length === 0) {
+      return NextResponse.json({ error: '请选择要下载的SKU' }, { status: 400 })
+    }
+
+    // 检查素材是否存在
+    const material = await prisma.material.findUnique({
+      where: { id: materialId },
+      select: { id: true, productModel: true, materialType: true }
+    })
+
+    if (!material) {
+      return NextResponse.json({ error: '素材不存在' }, { status: 404 })
+    }
+
+    if (material.materialType !== '标准模型') {
+      return NextResponse.json({ error: '只有标准模型类型才支持SKU批量下载' }, { status: 400 })
+    }
+
+    // 获取选中的SKU列表
+    const skus = await prisma.materialSku.findMany({
+      where: {
+        id: { in: skuIds },
+        materialId,
+        deletedAt: null // 只获取未删除的SKU
+      },
+      select: {
+        id: true,
+        skuName: true,
+        filePath: true,
+        fileName: true
+      }
+    })
+
+    if (skus.length === 0) {
+      return NextResponse.json({ error: '没有找到可下载的SKU' }, { status: 404 })
+    }
+
+    // 创建ZIP文件
+    const zip = new JSZip()
+    let addedCount = 0
+
+    const fs = await import('fs/promises')
+    
+    for (const sku of skus) {
+      try {
+        const filePath = path.join(process.cwd(), 'uploads', sku.filePath)
+        
+        // 检查文件是否存在
+        try {
+          await fs.access(filePath)
+        } catch {
+          console.warn(`SKU文件不存在: ${filePath}`)
+          continue
+        }
+
+        // 读取文件并添加到ZIP
+        const fileBuffer = await fs.readFile(filePath)
+        const fileName = sku.fileName || `${sku.skuName}.zip`
+        zip.file(fileName, fileBuffer)
+        addedCount++
+      } catch (error) {
+        console.error(`添加SKU文件失败: ${sku.id}`, error)
+        // 继续处理其他文件
+      }
+    }
+
+    if (addedCount === 0) {
+      return NextResponse.json({ error: '没有可下载的文件' }, { status: 404 })
+    }
+
+    // 生成ZIP文件
+    const zipBuffer = await zip.generateAsync({
+      type: 'nodebuffer',
+      compression: 'DEFLATE',
+      compressionOptions: { level: 6 }
+    })
+
+    const filename = `${material.productModel}_SKU批量下载_${Date.now()}.zip`
+
+    return new NextResponse(zipBuffer as any, {
+      headers: {
+        'Content-Type': 'application/zip',
+        'Content-Length': zipBuffer.length.toString(),
+        'Content-Disposition': `attachment; filename="${encodeURIComponent(filename)}"`,
+      },
+    })
+  } catch (error) {
+    console.error('SKU批量下载失败:', error)
+    return NextResponse.json(
+      { error: '下载失败: ' + (error instanceof Error ? error.message : '未知错误') },
+      { status: 500 }
+    )
+  }
+}
+
--- a/app/api/materials/[id]/skus/route.ts
+++ b/app/api/materials/[id]/skus/route.ts
@ -23,16 +23,27 @@ export async function GET(
      return NextResponse.json({ error: '素材不存在' }, { status: 404 })
    }

-    // 获取 SKU 列表，按排序顺序
+    // 获取 SKU 列表，按排序顺序（排除已删除的）
    const skus = await prisma.materialSku.findMany({
-      where: { materialId },
+      where: { 
+        materialId,
+        deletedAt: null // 只获取未删除的SKU
+      },
      orderBy: { sortOrder: 'asc' }
    })

-    // 转换 BigInt 为字符串（JSON 序列化需要）
+    // 转换 BigInt 为字符串，并统一字段命名（前端使用zipFilePath等）
    const skusWithStringSize = skus.map(sku => ({
-      ...sku,
-      fileSize: sku.fileSize.toString() // 使用正确的字段名
+      id: sku.id,
+      materialId: sku.materialId,
+      skuName: sku.skuName,
+      previewUrl: (sku as any).previewUrl || '',
+      zipFileName: (sku as any).fileName || '',
+      zipFilePath: sku.filePath, // 统一使用zipFilePath
+      zipFileSize: sku.fileSize.toString(),
+      sortOrder: sku.sortOrder,
+      createdAt: sku.createdAt,
+      updatedAt: sku.updatedAt
    }))

    return NextResponse.json({
@ -73,11 +84,11 @@ export async function POST(
    }

    const body = await request.json()
-    const { skuName, filePath, fileSize } = body
+    const { skuName, previewUrl, zipFileName, zipFilePath, zipFileSize } = body

-    // 验证必填字段（只需要 skuName 和 filePath）
-    if (!skuName || !filePath) {
-      return NextResponse.json({ error: '缺少必填字段' }, { status: 400 })
+    // 验证必填字段
+    if (!skuName || !zipFilePath) {
+      return NextResponse.json({ error: '缺少必填字段：skuName 和 zipFilePath' }, { status: 400 })
    }

    // 获取当前最大排序值
@ -88,23 +99,40 @@ export async function POST(

    const newSortOrder = (maxSortOrder._max.sortOrder ?? -1) + 1

-    // 创建 SKU（只使用模型中存在的字段）
+    // 创建 SKU
    const sku = await prisma.materialSku.create({
      data: {
        materialId,
        skuName,
-        filePath,
-        fileSize: BigInt(fileSize || 0),
+        previewUrl: previewUrl || null,
+        filePath: zipFilePath, // 前端传的是zipFilePath，存储到filePath
+        fileName: zipFileName || null,
+        fileSize: BigInt(zipFileSize || 0),
        sortOrder: newSortOrder
-      }
+      } as any // 临时类型断言，因为 Prisma Client 可能还未完全更新
    })

+    // 返回时转换为前端期望的字段名
    return NextResponse.json({
-      ...sku,
-      fileSize: sku.fileSize.toString() // 返回时使用正确的字段名
+      id: sku.id,
+      materialId: sku.materialId,
+      skuName: sku.skuName,
+      previewUrl: (sku as any).previewUrl || '',
+      zipFileName: (sku as any).fileName || '',
+      zipFilePath: sku.filePath, // 返回时使用zipFilePath
+      zipFileSize: sku.fileSize.toString(),
+      sortOrder: sku.sortOrder,
+      createdAt: sku.createdAt,
+      updatedAt: sku.updatedAt
    }, { status: 201 })
  } catch (error) {
    console.error('添加 SKU 失败:', error)
-    return NextResponse.json({ error: '添加 SKU 失败' }, { status: 500 })
+    const errorMessage = error instanceof Error ? error.message : String(error)
+    const errorStack = error instanceof Error ? error.stack : undefined
+    console.error('错误详情:', { errorMessage, errorStack, error })
+    return NextResponse.json({ 
+      error: '添加 SKU 失败',
+      details: process.env.NODE_ENV === 'development' ? errorMessage : undefined
+    }, { status: 500 })
  }
 }
--- a/app/api/materials/[id]/skus/upload/route.ts
+++ b/app/api/materials/[id]/skus/upload/route.ts
@ -69,31 +69,14 @@ export async function POST(
    await writeFile(filePath, buffer)

    // 相对路径（用于数据库存储）
-    const relativePath = path.join('skus', materialId, fileName)
-
-    // 获取当前最大排序值
-    const maxSortOrder = await prisma.materialSku.aggregate({
-      where: { materialId },
-      _max: { sortOrder: true }
-    })
-
-    const newSortOrder = (maxSortOrder._max.sortOrder ?? -1) + 1
-
-    // 创建 SKU 记录
-    const sku = await prisma.materialSku.create({
-      data: {
-        materialId,
-        skuName,
-        filePath: relativePath,
-        fileSize: BigInt(file.size),
-        sortOrder: newSortOrder
-      }
-    })
+    const relativePath = path.join('skus', materialId, fileName).replace(/\\/g, '/') // 统一使用正斜杠

+    // 只返回文件信息，不创建SKU记录（SKU记录由 /api/materials/[id]/skus POST 接口创建）
    return NextResponse.json({
-      ...sku,
-      fileSize: sku.fileSize.toString()
-    }, { status: 201 })
+      fileName: file.name,
+      filePath: relativePath,
+      fileSize: file.size
+    }, { status: 200 })
  } catch (error) {
    console.error('上传 SKU 失败:', error)
    return NextResponse.json({ error: '上传 SKU 失败' }, { status: 500 })
--- a/app/api/materials/upload/route.ts
+++ b/app/api/materials/upload/route.ts
@ -10,6 +10,7 @@ import { randomBytes } from 'crypto';
 import { parseAudioMetadata, isAudioFile } from '@/lib/audio-processor';
 import { enqueueVideoTranscodeTask } from '@/lib/video-transcode-task';
 import { AUTO_GENERAL_TYPES, requiresCategoryAndScene, requiresRenderer, getDefaultRenderer } from '@/lib/material-validation';
+import { compressImage, sanitizeFileName } from '@/lib/image-processor';

 export const runtime = 'nodejs';
 export const dynamic = 'force-dynamic';
@ -128,9 +129,20 @@ export async function POST(request: NextRequest) {

      console.log('[Upload] Processing preview image (1/1)...');
      const buffer = Buffer.from(await previewImage.arrayBuffer());
-      const filename = generateUniqueFilename('preview', path.extname(previewImage.name));
-      console.log('[Upload] Uploading preview image to S3...');
-      previewUrl = await uploadToS3(buffer, filename, previewImage.type);
+      
+      // 压缩预览图
+      console.log('[Upload] Compressing preview image...');
+      const compressedBuffer = await compressImage(buffer, {
+        maxSizeKB: 300,
+        maxWidth: 1200,
+        maxHeight: 1600,
+        format: 'webp'
+      });
+      
+      const fileName = sanitizeFileName(previewImage.name);
+      const filename = generateUniqueFilename('preview', '.webp');
+      console.log('[Upload] Uploading compressed preview image to S3...');
+      previewUrl = await uploadToS3(compressedBuffer, filename, 'image/webp');
      console.log('[Upload] Preview image uploaded:', previewUrl);
    }

@ -152,9 +164,19 @@ export async function POST(request: NextRequest) {
      const uploadPromises = previewImages.map(async (image, index) => {
        console.log(`[Upload] Processing preview image ${index + 2}/${previewImages.length + 1}...`);
        const buffer = Buffer.from(await image.arrayBuffer());
-        const filename = generateUniqueFilename(`preview-${index + 2}`, path.extname(image.name));
-        console.log(`[Upload] Uploading preview image ${index + 2} to S3...`);
-        const url = await uploadToS3(buffer, filename, image.type);
+        
+        // 压缩预览图
+        console.log(`[Upload] Compressing preview image ${index + 2}...`);
+        const compressedBuffer = await compressImage(buffer, {
+          maxSizeKB: 300,
+          maxWidth: 1200,
+          maxHeight: 1600,
+          format: 'webp'
+        });
+        
+        const filename = generateUniqueFilename(`preview-${index + 2}`, '.webp');
+        console.log(`[Upload] Uploading compressed preview image ${index + 2} to S3...`);
+        const url = await uploadToS3(compressedBuffer, filename, 'image/webp');
        console.log(`[Upload] Preview image ${index + 2} uploaded:`, url);
        return url;
      });
@ -390,42 +412,55 @@ export async function POST(request: NextRequest) {
      }
    }

-    // 如果是视频类型素材，上传完成后立即入队触发后台转码（异步）
+    // 如果是视频类型素材，上传完成后立即入队触发后台转码（异步，不阻塞返回）
    if (videoSourceUrl) {
      const needsCoverImage = !previewUrl || previewUrl.trim() === '';
      
-      try {
-        // 入队转码任务（使用静态导入，确保模块加载成功）
-        await enqueueVideoTranscodeTask(material.id, videoSourceUrl, needsCoverImage);
-        
-        console.log('[Upload] ✅ Video transcode task enqueued successfully:', material.id);
-      } catch (e: any) {
-        // 入队失败时，记录详细错误信息到数据库
-        const errorMsg = e?.message || String(e) || '未知错误';
-        const errorStack = e?.stack ? `\n堆栈: ${e.stack.substring(0, 1000)}` : '';
-        const fullErrorMsg = `入队失败: ${errorMsg}${errorStack}`;
-        
-        console.error('[Upload] ❌ Failed to enqueue video transcode task:', {
-          materialId: material.id,
-          videoSourceUrl,
-          error: errorMsg,
-          stack: e?.stack,
-        });
-        
-        // 更新数据库状态，记录错误信息，但保持 pending 状态以便手动重试
-        try {
-          await prisma.material.update({
-            where: { id: material.id },
-            data: {
-              videoProcessingStatus: 'pending', // 保持 pending，允许手动重试
-              transcodeLastError: fullErrorMsg.substring(0, 1000), // 记录详细错误
-            } as any,
+      // 不 await，让入队操作在后台异步执行，不阻塞上传接口返回 201
+      enqueueVideoTranscodeTask(material.id, videoSourceUrl, needsCoverImage)
+        .then(() => {
+          console.log('[Upload] ✅ Video transcode task enqueued successfully:', material.id);
+        })
+        .catch(async (e: any) => {
+          // 入队失败时，记录详细错误信息到数据库，并尝试清理可能无效的源文件，避免产生垃圾文件
+          const errorMsg = e?.message || String(e) || '未知错误';
+          const errorStack = e?.stack ? `\n堆栈: ${e.stack.substring(0, 1000)}` : '';
+          const fullErrorMsg = `入队失败: ${errorMsg}${errorStack}`;
+          
+          console.error('[Upload] ❌ Failed to enqueue video transcode task:', {
+            materialId: material.id,
+            videoSourceUrl,
+            error: errorMsg,
+            stack: e?.stack,
          });
-          console.log('[Upload] ⚠️  Updated material status with enqueue error (status: pending for manual retry)');
-        } catch (dbError) {
-          console.error('[Upload] ❌ Failed to update material status:', dbError);
-        }
-      }
+          
+          try {
+            // 标记为失败并记录错误信息，方便后续诊断
+            await prisma.material.update({
+              where: { id: material.id },
+              data: {
+                videoProcessingStatus: 'failed',
+                transcodeLastError: fullErrorMsg.substring(0, 1000),
+              } as any,
+            });
+            console.log('[Upload] ⚠️  Updated material status with enqueue error (status: failed)');
+          } catch (dbError) {
+            console.error('[Upload] ❌ Failed to update material status:', dbError);
+          }
+
+          // 尝试清理源视频文件，避免长时间占用磁盘空间（垃圾文件）
+          if (zipFilePath) {
+            try {
+              await fs.unlink(zipFilePath);
+              console.log('[Upload] 🧹 Removed source video file after enqueue failure:', zipFilePath);
+            } catch (removeError) {
+              console.warn('[Upload] ⚠️ Failed to remove source video file after enqueue failure (ignored):', {
+                path: zipFilePath,
+                error: (removeError as any)?.message || String(removeError),
+              });
+            }
+          }
+        });
    }

    return NextResponse.json(
--- a/app/api/performance/quick/route.ts
+++ b/app/api/performance/quick/route.ts
@ -0,0 +1,241 @@
+import { NextResponse } from 'next/server'
+import os from 'os'
+import { exec } from 'child_process'
+import { promisify } from 'util'
+import { uploadSessions } from '@/lib/upload-sessions'
+import { transcodeQueue } from '@/lib/video-transcode-queue'
+import { prisma } from '@/lib/prisma'
+
+const execAsync = promisify(exec)
+
+// 性能监控 - 快速统计接口（用于悬停卡片）
+// GET /api/performance/quick
+export const dynamic = 'force-dynamic'
+export const revalidate = 0
+
+// 获取CPU使用率（正确的方法：需要两次采样）
+async function getCpuUsage(): Promise<number> {
+  try {
+    // 方法1：使用 /proc/stat 两次采样计算CPU使用率（最准确）
+    const getCpuStats = async () => {
+      const { stdout } = await execAsync("cat /proc/stat | grep '^cpu '")
+      const parts = stdout.trim().split(/\s+/)
+      return {
+        user: parseInt(parts[1]) || 0,
+        nice: parseInt(parts[2]) || 0,
+        system: parseInt(parts[3]) || 0,
+        idle: parseInt(parts[4]) || 0,
+        iowait: parseInt(parts[5]) || 0,
+        irq: parseInt(parts[6]) || 0,
+        softirq: parseInt(parts[7]) || 0,
+      }
+    }
+
+    const stats1 = await getCpuStats()
+    await new Promise(resolve => setTimeout(resolve, 1000)) // 等待1秒
+    const stats2 = await getCpuStats()
+
+    const total1 = stats1.user + stats1.nice + stats1.system + stats1.idle + stats1.iowait + stats1.irq + stats1.softirq
+    const total2 = stats2.user + stats2.nice + stats2.system + stats2.idle + stats2.iowait + stats2.irq + stats2.softirq
+    const totalDiff = total2 - total1
+
+    if (totalDiff > 0) {
+      const idleDiff = stats2.idle - stats1.idle
+      const usedDiff = totalDiff - idleDiff
+      const cpuUsage = (usedDiff / totalDiff) * 100
+      return Math.min(Math.max(Math.round(cpuUsage), 0), 100)
+    }
+  } catch (error) {
+    console.warn('[PerformanceQuick] Failed to get CPU usage from /proc/stat:', error)
+  }
+
+  try {
+    // 方法2：尝试使用 top 命令（批处理模式，更准确）
+    const { stdout } = await execAsync("top -bn2 -d1 | grep 'Cpu(s)' | tail -1 | awk '{print $2}' | sed 's/%us,//'", { timeout: 3000 })
+    const cpuUsage = parseFloat(stdout.trim())
+    if (!isNaN(cpuUsage) && cpuUsage >= 0 && cpuUsage <= 100) {
+      return Math.round(cpuUsage)
+    }
+  } catch (error) {
+    console.warn('[PerformanceQuick] Failed to get CPU usage from top:', error)
+  }
+
+  try {
+    // 方法3：使用 vmstat（如果可用）
+    const { stdout } = await execAsync("vmstat 1 2 | tail -1 | awk '{print 100-$15}'", { timeout: 3000 })
+    const cpuUsage = parseFloat(stdout.trim())
+    if (!isNaN(cpuUsage) && cpuUsage >= 0 && cpuUsage <= 100) {
+      return Math.round(cpuUsage)
+    }
+  } catch (error) {
+    console.warn('[PerformanceQuick] Failed to get CPU usage from vmstat:', error)
+  }
+  
+  // 降级方案：使用负载平均值估算（不准确，但总比没有好）
+  const loadAvg = os.loadavg()[0]
+  const cpuCount = os.cpus().length
+  // 负载平均值反映系统负载，但不等同于CPU使用率
+  // 负载平均值 = CPU核心数时，表示CPU满载
+  // 这里做一个粗略估算：负载平均值 / CPU核心数 * 100，但限制在100%以内
+  const estimatedUsage = Math.min(Math.round((loadAvg / cpuCount) * 100), 100)
+  console.warn(`[PerformanceQuick] Using loadavg estimation: load=${loadAvg}, cores=${cpuCount}, estimated=${estimatedUsage}%`)
+  return estimatedUsage
+}
+
+export async function GET() {
+  try {
+    // 1. 系统性能（先用 Node.js os 模块，后续可接 TrueNAS）
+    const loadAvg = os.loadavg() // [1min, 5min, 15min]
+    const totalMem = os.totalmem()
+    const freeMem = os.freemem()
+    const usedMem = totalMem - freeMem
+    const memPercentage = totalMem > 0 ? Math.round((usedMem / totalMem) * 100) : 0
+
+    // 获取更准确的CPU使用率
+    const cpuUsage = await getCpuUsage()
+
+    const cpu = {
+      usage: cpuUsage,
+      loadAverage: loadAvg,
+    }
+
+    const memory = {
+      used: Math.round(usedMem / (1024 * 1024)), // MB
+      total: Math.round(totalMem / (1024 * 1024)), // MB
+      percentage: memPercentage,
+    }
+
+    // 2. 上传队列（基于 uploadSessions）
+    const uploadProcessing: any[] = []
+    const uploadWaiting: any[] = []
+
+    // 只显示真正进行中的上传（进度 < 100%）
+    uploadSessions.forEach((session, uploadId) => {
+      const completedChunks = session.chunks.size
+      const totalChunks = session.totalChunks || 1
+      const progress = Math.min(
+        100,
+        Math.round((completedChunks / totalChunks) * 100)
+      )
+
+      // 只显示未完成的上传（进度 < 100%）
+      if (progress < 100) {
+        uploadProcessing.push({
+          uploadId,
+          fileName: session.fileName,
+          materialType: '未知', // 目前 UploadSession 未区分素材类型，后续可扩展
+          progress,
+          userId: session.userId,
+        })
+      }
+    })
+
+    const uploadQueue = {
+      processing: uploadProcessing,
+      waiting: uploadWaiting,
+      total: uploadProcessing.length + uploadWaiting.length,
+    }
+
+    // 3. 转码队列（基于 transcodeQueue）
+    const status = transcodeQueue.getStatus()
+
+    const progressObj: Record<string, number> = {}
+    const stageObj: Record<string, string> = {}
+
+    // Map 无法直接序列化，转成普通对象
+    status.progress.forEach((value, key) => {
+      progressObj[key] = value
+    })
+    status.stages.forEach((value, key) => {
+      stageObj[key] = value
+    })
+
+    // 查询转码队列中的素材信息（文件名、类型、上传人等）
+    const processingMaterialIds = status.processingIds
+    const waitingMaterialIds = status.waiting
+    
+    const allMaterialIds = [...processingMaterialIds, ...waitingMaterialIds]
+    const materialInfoMap = new Map<string, any>()
+    
+    if (allMaterialIds.length > 0) {
+      try {
+        const materials = await prisma.material.findMany({
+          where: {
+            id: { in: allMaterialIds },
+            deletedAt: null,
+          } as any,
+          select: {
+            id: true,
+            zipFileName: true,
+            materialType: true,
+            authorName: true,
+            user: {
+              select: {
+                username: true,
+              },
+            },
+          } as any,
+        })
+        
+        materials.forEach((m: any) => {
+          materialInfoMap.set(m.id, {
+            fileName: m.zipFileName || '未知文件',
+            materialType: m.materialType || '未知类型',
+            authorName: m.authorName || m.user?.username || '未知用户',
+          })
+        })
+      } catch (error) {
+        console.error('[PerformanceQuick] Failed to fetch material info:', error)
+      }
+    }
+
+    const transcodeQueueData = {
+      processing: processingMaterialIds.map((id) => {
+        const info = materialInfoMap.get(id) || {
+          fileName: '未知文件',
+          materialType: '未知类型',
+          authorName: '未知用户',
+        }
+        return {
+          materialId: id,
+          fileName: info.fileName,
+          materialType: info.materialType,
+          authorName: info.authorName,
+          progress: progressObj[id] ?? null,
+          stage: stageObj[id] ?? null,
+        }
+      }),
+      waiting: waitingMaterialIds.map((id, index) => {
+        const info = materialInfoMap.get(id) || {
+          fileName: '未知文件',
+          materialType: '未知类型',
+          authorName: '未知用户',
+        }
+        return {
+          materialId: id,
+          fileName: info.fileName,
+          materialType: info.materialType,
+          authorName: info.authorName,
+          queuePosition: index + 1,
+        }
+      }),
+      total: status.queueLength,
+      maxConcurrent: status.maxConcurrent,
+    }
+
+    return NextResponse.json({
+      cpu,
+      memory,
+      uploadQueue,
+      transcodeQueue: transcodeQueueData,
+    })
+  } catch (error) {
+    console.error('[PerformanceQuick] 获取性能数据失败:', error)
+    return NextResponse.json(
+      { error: '获取性能数据失败' },
+      { status: 500 }
+    )
+  }
+}
+
+
--- a/app/api/system-settings/route.ts
+++ b/app/api/system-settings/route.ts
@ -61,6 +61,10 @@ export async function PUT(request: NextRequest) {
      s3Bucket,
      s3Region,
      s3PublicUrl,
+      maintenanceEnabled,
+      maintenanceMessage,
+      maintenanceStartTime,
+      maintenanceEndTime,
    } = await request.json();

    let settings = await prisma.systemSettings.findFirst();
@ -78,6 +82,10 @@ export async function PUT(request: NextRequest) {
      if (s3Bucket !== undefined) updateData.s3Bucket = s3Bucket;
      if (s3Region !== undefined) updateData.s3Region = s3Region;
      if (s3PublicUrl !== undefined) updateData.s3PublicUrl = s3PublicUrl;
+      if (maintenanceEnabled !== undefined) updateData.maintenanceEnabled = maintenanceEnabled;
+      if (maintenanceMessage !== undefined) updateData.maintenanceMessage = maintenanceMessage;
+      if (maintenanceStartTime !== undefined) updateData.maintenanceStartTime = maintenanceStartTime ? new Date(maintenanceStartTime) : null;
+      if (maintenanceEndTime !== undefined) updateData.maintenanceEndTime = maintenanceEndTime ? new Date(maintenanceEndTime) : null;

      settings = await prisma.systemSettings.update({
        where: { id: settings.id },
--- a/app/api/upload/preview/route.ts
+++ b/app/api/upload/preview/route.ts
@ -3,6 +3,15 @@ import { NextRequest, NextResponse } from 'next/server';
 import { getServerSession } from 'next-auth';
 import { authOptions } from '@/lib/auth';
 import { uploadToS3 } from '@/lib/s3';
+import { compressImage, sanitizeFileName } from '@/lib/image-processor';
+import { randomBytes } from 'crypto';
+
+// 生成唯一文件名
+function generateUniqueFilename(prefix: string, ext: string): string {
+  const timestamp = Date.now();
+  const random = randomBytes(8).toString('hex');
+  return `${prefix}-${timestamp}-${random}${ext}`;
+}

 // POST - 上传预览图
 export async function POST(request: NextRequest) {
@ -33,12 +42,32 @@ export async function POST(request: NextRequest) {
      );
    }

+    // 验证文件大小（50MB限制）
+    if (file.size > 50 * 1024 * 1024) {
+      return NextResponse.json(
+        { error: '预览图过大，请使用小于50MB的图片' },
+        { status: 400 }
+      );
+    }
+
    // 转换为Buffer
    const buffer = Buffer.from(await file.arrayBuffer());

-    // 上传到S3
-    const url = await uploadToS3(buffer, file.name, file.type);
+    // 压缩预览图
+    console.log('[Preview Upload] Compressing preview image...');
+    const compressedBuffer = await compressImage(buffer, {
+      maxSizeKB: 300,
+      maxWidth: 1200,
+      maxHeight: 1600,
+      format: 'webp'
+    });

+    // 生成文件名并上传到S3
+    const filename = generateUniqueFilename('preview', '.webp');
+    console.log('[Preview Upload] Uploading compressed preview image to S3...');
+    const url = await uploadToS3(compressedBuffer, filename, 'image/webp');
+
+    console.log('[Preview Upload] Preview image uploaded:', url);
    return NextResponse.json({ url });
  } catch (error) {
    console.error('上传预览图失败:', error);
--- a/app/edit/[id]/page.tsx
+++ b/app/edit/[id]/page.tsx
@ -86,8 +86,23 @@ export default function EditMaterialPage({ params }: { params: { id: string } })
      }
      const data = await response.json()
      
-      // 权限检查
-      if (data.userId !== (session?.user as any)?.id && (session?.user as any)?.role !== 'ADMIN') {
+      // 权限检查：素材所有者、普通管理员或超级管理员都可以编辑
+      const userId = (session?.user as any)?.id
+      const userRole = (session?.user as any)?.role
+      
+      // 检查是否是超级管理员
+      let isUserSuperAdmin = false
+      try {
+        const superAdminCheck = await fetch('/api/admin/check-super-admin')
+        if (superAdminCheck.ok) {
+          const superAdminData = await superAdminCheck.json()
+          isUserSuperAdmin = superAdminData.isSuperAdmin || false
+        }
+      } catch (e) {
+        console.warn('检查超级管理员状态失败:', e)
+      }
+      
+      if (data.userId !== userId && userRole !== 'ADMIN' && !isUserSuperAdmin) {
        setError('您没有权限编辑此素材')
        setTimeout(() => router.push('/'), 2000)
        return
--- a/app/page.tsx
+++ b/app/page.tsx
--- a/app/share/[id]/page.tsx
+++ b/app/share/[id]/page.tsx
@ -66,6 +66,8 @@ export default function SharePage() {
  const audioRef = useRef<HTMLAudioElement | null>(null)
  const [playingAudio, setPlayingAudio] = useState(false)
  const [audioProgress, setAudioProgress] = useState(0) // 0-100
+  // SKU选中状态（用于标准模型类型的批量下载）
+  const [selectedSkuIds, setSelectedSkuIds] = useState<Set<string>>(new Set())

  useEffect(() => {
    // 分享页面允许未登录访问
@ -246,9 +248,77 @@ export default function SharePage() {
    }
  }, [])

+  // 批量下载选中的SKU（标准模型类型）
+  const handleBatchDownloadSkus = async () => {
+    if (!material || selectedSkuIds.size === 0) {
+      showToast('请先选择要下载的SKU', { variant: 'error' })
+      return
+    }
+
+    setDownloading(true)
+    setDownloadProgress(0)
+
+    try {
+      const response = await fetch(`/api/materials/${materialId}/skus/batch-download`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          skuIds: Array.from(selectedSkuIds)
+        })
+      })
+
+      if (!response.ok) {
+        const error = await response.json()
+        showToast(error.error || '批量下载失败', { variant: 'error' })
+        setDownloading(false)
+        setDownloadProgress(0)
+        return
+      }
+
+      // 获取ZIP文件并下载
+      const blob = await response.blob()
+      const url = window.URL.createObjectURL(blob)
+      const a = document.createElement('a')
+      a.href = url
+      
+      // 从Content-Disposition获取文件名
+      const contentDisposition = response.headers.get('Content-Disposition')
+      let filename = `SKU批量下载_${Date.now()}.zip`
+      if (contentDisposition) {
+        const filenameMatch = contentDisposition.match(/filename[^;=\n]*=((['"]).*?\2|[^;\n]*)/)
+        if (filenameMatch && filenameMatch[1]) {
+          filename = decodeURIComponent(filenameMatch[1].replace(/['"]/g, ''))
+        }
+      }
+      
+      a.download = filename
+      document.body.appendChild(a)
+      a.click()
+      a.remove()
+      window.URL.revokeObjectURL(url)
+      
+      showToast(`成功下载 ${selectedSkuIds.size} 个SKU`, { variant: 'success' })
+      setSelectedSkuIds(new Set()) // 清空选择
+    } catch (error) {
+      console.error('批量下载 SKU 失败:', error)
+      showToast('批量下载失败，请稍后重试', { variant: 'error' })
+    } finally {
+      setDownloading(false)
+      setDownloadProgress(0)
+    }
+  }
+
+  // 下载整个素材（非标准模型类型，或标准模型类型但未选中SKU时）
  const handleDownload = () => {
    if (!material) return

+    // 如果是标准模型类型且有选中的SKU，则批量下载SKU
+    if (material.materialType === '标准模型' && selectedSkuIds.size > 0) {
+      handleBatchDownloadSkus()
+      return
+    }
+
+    // 否则下载整个素材
    setDownloading(true)
    setDownloadProgress(0)

@ -515,21 +585,10 @@ export default function SharePage() {
                }
              })()}
            </div>
-
-            {/* 标准模型类型：显示SKU列表 */}
-            {material.materialType === '标准模型' && (
-              <div className="mt-8">
-                <SkuList
-                  materialId={materialId}
-                  canEdit={!!(session?.user && ((session.user as any)?.id === material.userId || (session.user as any)?.role === 'ADMIN'))}
-                  onEditClick={() => setShowSkuEditModal(true)}
-                />
-              </div>
-            )}
          </div>

          {/* 右侧：素材信息（固定） */}
-          <div className="w-80 flex-shrink-0">
+          <div className={`${material.materialType === '标准模型' ? 'w-[500px]' : 'w-80'} flex-shrink-0`}>
            <div className="sticky top-24 bg-white dark:bg-gray-800 rounded-2xl shadow-lg p-8 space-y-6">
              {/* 标题和标签 - 统一间距 */}
              <div>
@ -551,37 +610,47 @@ export default function SharePage() {
                </div>
              </div>

-              {/* 素材信息 - 统一字体和间距 */}
-              <div className="space-y-4">
-                <div>
-                  <p className="text-sm text-gray-500 dark:text-gray-400 mb-1">作者</p>
-                  <p className="text-base font-medium text-gray-900 dark:text-white">{material.authorName}</p>
-                </div>
-                <div>
-                  <p className="text-sm text-gray-500 dark:text-gray-400 mb-1">文件大小</p>
-                  <p className="text-base font-medium text-blue-600 dark:text-blue-400">{formatFileSize(material.zipFileSize)}</p>
-                </div>
-                <div className="grid grid-cols-2 gap-4">
+              {/* 标准模型类型：显示SKU列表 */}
+              {material.materialType === '标准模型' ? (
+                <SkuList
+                  materialId={materialId}
+                  canEdit={!!(session?.user && ((session.user as any)?.id === material.userId || (session.user as any)?.role === 'ADMIN'))}
+                  onEditClick={() => setShowSkuEditModal(true)}
+                  onSelectionChange={setSelectedSkuIds}
+                />
+              ) : (
+                /* 其他类型：显示素材信息 */
+                <div className="space-y-4">
                  <div>
-                    <p className="text-sm text-gray-500 dark:text-gray-400 mb-1">下载次数</p>
-                    <p className="text-base font-medium text-gray-900 dark:text-white">{material.downloadCount}</p>
+                    <p className="text-sm text-gray-500 dark:text-gray-400 mb-1">作者</p>
+                    <p className="text-base font-medium text-gray-900 dark:text-white">{material.authorName}</p>
                  </div>
                  <div>
-                    <p className="text-sm text-gray-500 dark:text-gray-400 mb-1">点赞数</p>
-                    <p className="text-base font-medium text-gray-900 dark:text-white">{material.likeCount}</p>
+                    <p className="text-sm text-gray-500 dark:text-gray-400 mb-1">文件大小</p>
+                    <p className="text-base font-medium text-blue-600 dark:text-blue-400">{formatFileSize(material.zipFileSize)}</p>
+                  </div>
+                  <div className="grid grid-cols-2 gap-4">
+                    <div>
+                      <p className="text-sm text-gray-500 dark:text-gray-400 mb-1">下载次数</p>
+                      <p className="text-base font-medium text-gray-900 dark:text-white">{material.downloadCount}</p>
+                    </div>
+                    <div>
+                      <p className="text-sm text-gray-500 dark:text-gray-400 mb-1">点赞数</p>
+                      <p className="text-base font-medium text-gray-900 dark:text-white">{material.likeCount}</p>
+                    </div>
+                  </div>
+                  <div>
+                    <p className="text-sm text-gray-500 dark:text-gray-400 mb-1">文件名</p>
+                    <p className="text-sm text-gray-700 dark:text-gray-300 break-all">{material.zipFileName}</p>
+                  </div>
+                  <div>
+                    <p className="text-sm text-gray-500 dark:text-gray-400 mb-1">上传时间</p>
+                    <p className="text-sm text-gray-700 dark:text-gray-300">
+                      {format(new Date(material.createdAt), 'yyyy-MM-dd HH:mm')}
+                    </p>
                  </div>
                </div>
-                <div>
-                  <p className="text-sm text-gray-500 dark:text-gray-400 mb-1">文件名</p>
-                  <p className="text-sm text-gray-700 dark:text-gray-300 break-all">{material.zipFileName}</p>
-                </div>
-                <div>
-                  <p className="text-sm text-gray-500 dark:text-gray-400 mb-1">上传时间</p>
-                  <p className="text-sm text-gray-700 dark:text-gray-300">
-                    {format(new Date(material.createdAt), 'yyyy-MM-dd HH:mm')}
-                  </p>
-                </div>
-              </div>
+              )}

              {/* 操作按钮 - 统一样式 */}
              <div className="space-y-3 pt-2">
@ -608,7 +677,9 @@ export default function SharePage() {
                      <svg className="w-5 h-5" fill="none" stroke="currentColor" viewBox="0 0 24 24">
                        <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M4 16v1a3 3 0 003 3h10a3 3 0 003-3v-1m-4-4l-4 4m0 0l-4-4m4 4V4" />
                      </svg>
-                      立即下载
+                      {material.materialType === '标准模型' && selectedSkuIds.size > 0
+                        ? `立即下载 (${selectedSkuIds.size}个)`
+                        : '立即下载'}
                    </span>
                  )}
                </button>
--- a/components/Header.tsx
+++ b/components/Header.tsx
@ -8,6 +8,7 @@ import { useState, useRef, useEffect } from 'react'
 import { initializeNetwork } from '@/lib/network'
 import UpdateLogModal, { useUpdateLog, showUpdateLog } from '@/components/UpdateLogModal'
 import NetworkDiagnoseModal from '@/components/NetworkDiagnoseModal'
+import MaintenanceBanner from '@/components/MaintenanceBanner'

 interface HeaderProps {
  session: Session | null
@ -22,6 +23,20 @@ export default function Header({ session }: HeaderProps) {
  const [isAccessingFromExternal, setIsAccessingFromExternal] = useState(false)
  const [showNetworkDiagnose, setShowNetworkDiagnose] = useState(false)
  const dropdownRef = useRef<HTMLDivElement>(null)
+
+  // 性能监控悬停卡片状态
+  const [showPerfCard, setShowPerfCard] = useState(false)
+  const [perfLoading, setPerfLoading] = useState(false)
+  const [perfError, setPerfError] = useState<string | null>(null)
+  const [perfData, setPerfData] = useState<{
+    cpu?: { usage: number; loadAverage: number[] }
+    memory?: { used: number; total: number; percentage: number }
+    uploadQueue?: { total: number; processing: any[]; waiting: any[] }
+    transcodeQueue?: { total: number; maxConcurrent: number; processing: any[]; waiting: any[] }
+  } | null>(null)
+  const perfHoverTimerRef = useRef<number | null>(null)
+  const perfHideTimerRef = useRef<number | null>(null)
+  const perfIntervalRef = useRef<number | null>(null)
  
  // 使用 useUpdateLog hook 来管理更新日志弹窗
  const { showModal: showUpdateLogModal, currentLog, showAllHistory, handleClose: handleUpdateLogClose } = useUpdateLog()
@ -107,6 +122,82 @@ export default function Header({ session }: HeaderProps) {
    return () => document.removeEventListener('mousedown', handleClickOutside)
  }, [])

+  // 性能监控：根据 showPerfCard 控制轮询
+  useEffect(() => {
+    // 清理定时器的工具函数
+    const clearIntervalSafe = () => {
+      if (perfIntervalRef.current !== null) {
+        window.clearInterval(perfIntervalRef.current)
+        perfIntervalRef.current = null
+      }
+    }
+
+    if (!showPerfCard) {
+      clearIntervalSafe()
+      return
+    }
+
+    const fetchPerf = async () => {
+      try {
+        setPerfLoading(true)
+        setPerfError(null)
+        const res = await fetch('/api/performance/quick')
+        if (!res.ok) {
+          throw new Error(`HTTP ${res.status}`)
+        }
+        const data = await res.json()
+        setPerfData(data)
+      } catch (err) {
+        console.error('加载性能数据失败:', err)
+        setPerfError('加载失败')
+      } finally {
+        setPerfLoading(false)
+      }
+    }
+
+    // 立即拉一次
+    fetchPerf()
+    // 每 2 秒轮询一次
+    perfIntervalRef.current = window.setInterval(fetchPerf, 2000)
+
+    return () => {
+      clearIntervalSafe()
+    }
+  }, [showPerfCard])
+
+  // 悬停事件处理：延迟显示 / 隐藏性能卡片
+  const handlePerfMouseEnter = () => {
+    // 取消隐藏定时器
+    if (perfHideTimerRef.current !== null) {
+      window.clearTimeout(perfHideTimerRef.current)
+      perfHideTimerRef.current = null
+    }
+    // 300ms 后显示，防止误触
+    if (perfHoverTimerRef.current === null) {
+      perfHoverTimerRef.current = window.setTimeout(() => {
+        setShowPerfCard(true)
+        perfHoverTimerRef.current = null
+      }, 300)
+    }
+  }
+
+  const handlePerfMouseLeave = () => {
+    // 取消显示定时器
+    if (perfHoverTimerRef.current !== null) {
+      window.clearTimeout(perfHoverTimerRef.current)
+      perfHoverTimerRef.current = null
+    }
+    // 100ms 延迟隐藏，避免抖动
+    if (perfHideTimerRef.current !== null) {
+      window.clearTimeout(perfHideTimerRef.current)
+      perfHideTimerRef.current = null
+    }
+    perfHideTimerRef.current = window.setTimeout(() => {
+      setShowPerfCard(false)
+      perfHideTimerRef.current = null
+    }, 100)
+  }
+
  // 获取用户名首字母
  const getInitials = (name: string) => {
    return name?.charAt(0).toUpperCase() || 'U'
@ -114,6 +205,9 @@ export default function Header({ session }: HeaderProps) {

  return (
    <>
+      {/* 系统维护通知横幅 */}
+      <MaintenanceBanner />
+      
      {/* 网络切换提示横幅 */}
      {showNetworkBanner && (
        <div className="fixed top-0 left-0 right-0 z-[60] bg-gradient-to-r from-green-500 to-emerald-500 text-white shadow-lg">
@ -173,17 +267,161 @@ export default function Header({ session }: HeaderProps) {

          {/* Navigation */}
          <nav className="flex items-center space-x-4">
-            {/* Network Status Indicator */}
+            {/* Network Status Indicator + 性能监控悬停卡片 */}
            {networkChecked && (
-              <div className={`flex items-center gap-1.5 px-3 py-1.5 rounded-full text-xs font-medium transition-all ${
-                isInternalNetwork 
-                  ? 'bg-green-500/10 text-green-400 border border-green-500/20' 
-                  : 'bg-blue-500/10 text-blue-400 border border-blue-500/20'
-              }`}>
-                <svg className="w-3 h-3" fill="currentColor" viewBox="0 0 20 20">
-                  <circle cx="10" cy="10" r="4"/>
-                </svg>
-                <span>{isInternalNetwork ? '内网' : '公网'}</span>
+              <div className="relative" onMouseEnter={handlePerfMouseEnter} onMouseLeave={handlePerfMouseLeave}>
+                <div
+                  className={`flex items-center gap-1.5 px-3 py-1.5 rounded-full text-xs font-medium transition-all ${
+                    isInternalNetwork
+                      ? 'bg-green-500/10 text-green-400 border border-green-500/20'
+                      : 'bg-blue-500/10 text-blue-400 border border-blue-500/20'
+                  }`}
+                >
+                  <svg className="w-3 h-3" fill="currentColor" viewBox="0 0 20 20">
+                    <circle cx="10" cy="10" r="4" />
+                  </svg>
+                  <span>{isInternalNetwork ? '内网' : '公网'}</span>
+                </div>
+
+                {/* 性能监控悬停卡片（基础版） */}
+                {showPerfCard && (
+                  <div className="absolute right-0 mt-2 w-80 bg-gray-900 text-gray-100 rounded-lg shadow-xl border border-gray-700 p-3 z-50">
+                    <div className="flex items-center justify-between mb-2">
+                      <span className="text-xs font-semibold text-gray-300">系统性能</span>
+                      {perfLoading && (
+                        <span className="text-[10px] text-gray-400">加载中...</span>
+                      )}
+                      {perfError && !perfLoading && (
+                        <span className="text-[10px] text-red-400">{perfError}</span>
+                      )}
+                    </div>
+
+                    {/* CPU / 内存 */}
+                    <div className="space-y-1.5 mb-2">
+                      <div className="flex justify-between text-[11px] text-gray-300">
+                        <span>CPU</span>
+                        <span>{perfData?.cpu?.usage ?? '--'}%</span>
+                      </div>
+                      <div className="w-full h-1.5 rounded-full bg-gray-800 overflow-hidden">
+                        <div
+                          className="h-full rounded-full bg-emerald-500"
+                          style={{ width: `${Math.min(Math.max(perfData?.cpu?.usage ?? 0, 0), 100)}%` }}
+                        />
+                      </div>
+                      <div className="flex justify-between text-[10px] text-gray-500">
+                        <span>1/5/15 分钟负载</span>
+                        <span>
+                          {(perfData?.cpu?.loadAverage || []).map(v => v.toFixed(2)).join(' / ') || '--'}
+                        </span>
+                      </div>
+
+                      <div className="flex justify-between text-[11px] text-gray-300 mt-2">
+                        <span>内存</span>
+                        <span>
+                          {perfData?.memory
+                            ? `${perfData.memory.used} / ${perfData.memory.total} MB (${perfData.memory.percentage}%)`
+                            : '--'}
+                        </span>
+                      </div>
+                      <div className="w-full h-1.5 rounded-full bg-gray-800 overflow-hidden">
+                        <div
+                          className="h-full rounded-full bg-sky-500"
+                          style={{
+                            width: `${Math.min(Math.max(perfData?.memory?.percentage ?? 0, 0), 100)}%`,
+                          }}
+                        />
+                      </div>
+                    </div>
+
+                    {/* 上传队列 / 转码队列 详细信息 */}
+                    <div className="border-t border-gray-800 pt-2 mt-1 space-y-2">
+                      {/* 上传队列 */}
+                      <div>
+                        <div className="flex justify-between text-[11px] text-gray-300 mb-1">
+                          <span>上传队列</span>
+                          <span>
+                            {perfData?.uploadQueue
+                              ? `处理中 ${perfData.uploadQueue.processing?.length || 0} · 等待 ${perfData.uploadQueue.waiting?.length || 0}`
+                              : '--'}
+                          </span>
+                        </div>
+                        {perfData?.uploadQueue?.processing && perfData.uploadQueue.processing.length > 0 && (
+                          <div className="space-y-1 max-h-20 overflow-y-auto">
+                            {perfData.uploadQueue.processing.map((task: any, idx: number) => (
+                              <div key={task.uploadId || idx} className="text-[10px] text-gray-400 bg-gray-800/50 rounded px-2 py-1">
+                                <div className="truncate">{task.fileName || '未知文件'}</div>
+                                <div className="flex justify-between mt-0.5">
+                                  <span>{task.materialType || '未知类型'}</span>
+                                  <span>{task.progress ?? 0}%</span>
+                                </div>
+                              </div>
+                            ))}
+                          </div>
+                        )}
+                        {perfData?.uploadQueue?.waiting && perfData.uploadQueue.waiting.length > 0 && (
+                          <div className="space-y-1 max-h-20 overflow-y-auto mt-1">
+                            {perfData.uploadQueue.waiting.map((task: any, idx: number) => (
+                              <div key={task.uploadId || idx} className="text-[10px] text-gray-500 bg-gray-800/30 rounded px-2 py-1">
+                                <div className="truncate">{task.fileName || '未知文件'}</div>
+                                <div className="flex justify-between mt-0.5">
+                                  <span>{task.materialType || '未知类型'}</span>
+                                  <span>等待中</span>
+                                </div>
+                              </div>
+                            ))}
+                          </div>
+                        )}
+                      </div>
+
+                      {/* 转码队列 */}
+                      <div>
+                        <div className="flex justify-between text-[11px] text-gray-300 mb-1">
+                          <span>转码队列</span>
+                          <span>
+                            {perfData?.transcodeQueue
+                              ? `处理中 ${perfData.transcodeQueue.processing?.length || 0} / ${perfData.transcodeQueue.maxConcurrent || 0} · 等待 ${perfData.transcodeQueue.waiting?.length || 0}`
+                              : '--'}
+                          </span>
+                        </div>
+                        {perfData?.transcodeQueue?.processing && perfData.transcodeQueue.processing.length > 0 && (
+                          <div className="space-y-1 max-h-20 overflow-y-auto">
+                            {perfData.transcodeQueue.processing.map((task: any, idx: number) => {
+                              const stageMap: Record<string, string> = {
+                                preview: '预览视频',
+                                clip: '片段生成',
+                                cover: '封面提取',
+                              }
+                              return (
+                                <div key={task.materialId || idx} className="text-[10px] text-gray-400 bg-gray-800/50 rounded px-2 py-1">
+                                  <div className="truncate">{task.fileName || '未知文件'}</div>
+                                  <div className="flex justify-between mt-0.5">
+                                    <span>{task.materialType || '未知类型'} · {task.stage ? stageMap[task.stage] || task.stage : '处理中'}</span>
+                                    <span>{task.progress ?? 0}%</span>
+                                  </div>
+                                  <div className="text-[9px] text-gray-500 mt-0.5">上传人: {task.authorName || '未知'}</div>
+                                </div>
+                              )
+                            })}
+                          </div>
+                        )}
+                        {perfData?.transcodeQueue?.waiting && perfData.transcodeQueue.waiting.length > 0 && (
+                          <div className="space-y-1 max-h-20 overflow-y-auto mt-1">
+                            {perfData.transcodeQueue.waiting.map((task: any, idx: number) => (
+                              <div key={task.materialId || idx} className="text-[10px] text-gray-500 bg-gray-800/30 rounded px-2 py-1">
+                                <div className="truncate">{task.fileName || '未知文件'}</div>
+                                <div className="flex justify-between mt-0.5">
+                                  <span>{task.materialType || '未知类型'}</span>
+                                  <span>队列 #{task.queuePosition || idx + 1}</span>
+                                </div>
+                                <div className="text-[9px] text-gray-500 mt-0.5">上传人: {task.authorName || '未知'}</div>
+                              </div>
+                            ))}
+                          </div>
+                        )}
+                      </div>
+                    </div>
+                  </div>
+                )}
              </div>
            )}
            
--- a/components/MaintenanceBanner.tsx
+++ b/components/MaintenanceBanner.tsx
@ -0,0 +1,108 @@
+'use client'
+
+import { useEffect, useState } from 'react'
+
+interface MaintenanceInfo {
+  enabled: boolean
+  message: string | null
+  startTime: string | null
+  endTime: string | null
+}
+
+export default function MaintenanceBanner() {
+  const [maintenance, setMaintenance] = useState<MaintenanceInfo | null>(null)
+  const [dismissed, setDismissed] = useState(false)
+
+  useEffect(() => {
+    const fetchMaintenance = async () => {
+      try {
+        const response = await fetch('/api/system-settings')
+        if (response.ok) {
+          const data = await response.json()
+          if (data.maintenanceEnabled && data.maintenanceMessage) {
+            // 检查维护时间范围
+            const now = new Date()
+            const startTime = data.maintenanceStartTime ? new Date(data.maintenanceStartTime) : null
+            const endTime = data.maintenanceEndTime ? new Date(data.maintenanceEndTime) : null
+            
+            // 如果设置了时间范围，检查是否在范围内
+            if (startTime && endTime) {
+              if (now < startTime || now > endTime) {
+                return // 不在维护时间范围内，不显示
+              }
+            } else if (startTime && now < startTime) {
+              return // 维护还未开始
+            } else if (endTime && now > endTime) {
+              return // 维护已结束
+            }
+            
+            setMaintenance({
+              enabled: true,
+              message: data.maintenanceMessage,
+              startTime: data.maintenanceStartTime,
+              endTime: data.maintenanceEndTime,
+            })
+          }
+        }
+      } catch (error) {
+        console.error('获取维护通知失败:', error)
+      }
+    }
+
+    fetchMaintenance()
+    // 每5分钟检查一次
+    const interval = setInterval(fetchMaintenance, 5 * 60 * 1000)
+    return () => clearInterval(interval)
+  }, [])
+
+  // 检查是否已关闭
+  useEffect(() => {
+    if (maintenance?.enabled) {
+      const dismissedKey = `maintenance_dismissed_${maintenance.startTime || 'default'}`
+      const isDismissed = sessionStorage.getItem(dismissedKey) === 'true'
+      setDismissed(isDismissed)
+    }
+  }, [maintenance])
+
+  if (!maintenance?.enabled || !maintenance.message || dismissed) {
+    return null
+  }
+
+  const handleDismiss = () => {
+    const dismissedKey = `maintenance_dismissed_${maintenance.startTime || 'default'}`
+    sessionStorage.setItem(dismissedKey, 'true')
+    setDismissed(true)
+  }
+
+  return (
+    <div className="fixed top-0 left-0 right-0 z-50 bg-gradient-to-r from-orange-500 to-red-500 text-white shadow-lg">
+      <div className="container mx-auto px-4 py-3 max-w-7xl">
+        <div className="flex items-center justify-between gap-4">
+          <div className="flex items-center gap-3 flex-1">
+            <svg className="w-6 h-6 flex-shrink-0" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+              <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M12 9v2m0 4h.01m-6.938 4h13.856c1.54 0 2.502-1.667 1.732-3L13.732 4c-.77-1.333-2.694-1.333-3.464 0L3.34 16c-.77 1.333.192 3 1.732 3z" />
+            </svg>
+            <div className="flex-1">
+              <p className="font-medium text-sm sm:text-base">
+                ⚠️ 系统维护通知
+              </p>
+              <p className="text-xs sm:text-sm opacity-90 mt-0.5">
+                {maintenance.message}
+              </p>
+            </div>
+          </div>
+          <button
+            onClick={handleDismiss}
+            className="px-3 py-2 hover:bg-orange-600 rounded-lg transition-colors flex-shrink-0"
+            title="关闭通知"
+          >
+            <svg className="w-5 h-5" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+              <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M6 18L18 6M6 6l12 12" />
+            </svg>
+          </button>
+        </div>
+      </div>
+    </div>
+  )
+}
+
--- a/components/SkuEditModal.tsx
+++ b/components/SkuEditModal.tsx
@ -4,6 +4,25 @@ import { useState, useEffect, useRef } from 'react'
 import Image from 'next/image'
 import { useToast } from '@/hooks/useToast'
 import ToastBubble from './ToastBubble'
+import {
+  DndContext,
+  closestCenter,
+  KeyboardSensor,
+  PointerSensor,
+  useSensor,
+  useSensors,
+  DragEndEvent,
+  DragStartEvent,
+  DragOverlay,
+} from '@dnd-kit/core'
+import {
+  arrayMove,
+  SortableContext,
+  sortableKeyboardCoordinates,
+  useSortable,
+  verticalListSortingStrategy,
+} from '@dnd-kit/sortable'
+import { CSS } from '@dnd-kit/utilities'

 // SKU 数据类型
 interface Sku {
@ -32,13 +51,15 @@ export default function SkuEditModal({ materialId, isOpen, onClose, onSaved }: S
  const [uploadingSkuId, setUploadingSkuId] = useState<string | null>(null)
  const { toast, showToast } = useToast()
  
-  // 新增 SKU 表单
+  // 新增/编辑 SKU 表单
  const [showAddForm, setShowAddForm] = useState(false)
+  const [editingSkuId, setEditingSkuId] = useState<string | null>(null) // 正在编辑的SKU ID
  const [newSkuName, setNewSkuName] = useState('')
-  const [newSkuPreviewUrl, setNewSkuPreviewUrl] = useState('')
-  const [newSkuFile, setNewSkuFile] = useState<{ fileName: string; filePath: string; fileSize: number } | null>(null)
-  const [uploadingNew, setUploadingNew] = useState(false)
-  const [uploadingPreview, setUploadingPreview] = useState(false)
+  const [newSkuPreviewFile, setNewSkuPreviewFile] = useState<File | null>(null)
+  const [newSkuPreviewUrl, setNewSkuPreviewUrl] = useState('') // 本地预览URL或已有预览URL
+  const [newSkuZipFile, setNewSkuZipFile] = useState<File | null>(null)
+  const [uploading, setUploading] = useState(false)
+  const [uploadProgress, setUploadProgress] = useState({ zip: 0, preview: 0 })

  const fileInputRef = useRef<HTMLInputElement>(null)
  const previewInputRef = useRef<HTMLInputElement>(null)
@ -74,130 +95,282 @@ export default function SkuEditModal({ materialId, isOpen, onClose, onSaved }: S
    return `${(size / Math.pow(1024, i)).toFixed(2)} ${units[i]}`
  }

-  // 上传压缩包
-  const handleUploadZip = async (file: File): Promise<{ fileName: string; filePath: string; fileSize: number } | null> => {
+  // 处理新增 SKU 的压缩包选择（立即显示，不上传）
+  const handleNewZipSelect = (e: React.ChangeEvent<HTMLInputElement>) => {
+    const file = e.target.files?.[0]
+    if (!file) return
+
+    // 立即存储文件对象，不立即上传
+    setNewSkuZipFile(file)
+    
+    // 如果没有填写名称，用文件名（去掉扩展名）作为默认名称
+    if (!newSkuName) {
+      const nameWithoutExt = file.name.replace(/\.[^/.]+$/, '')
+      setNewSkuName(nameWithoutExt)
+    }
+  }
+
+  // 处理新增 SKU 的预览图选择（立即显示，不上传）
+  const handleNewPreviewSelect = (e: React.ChangeEvent<HTMLInputElement>) => {
+    const file = e.target.files?.[0]
+    if (!file) return
+
+    // 立即存储文件对象，并创建本地预览URL
+    setNewSkuPreviewFile(file)
+    const previewUrl = URL.createObjectURL(file)
+    setNewSkuPreviewUrl(previewUrl)
+  }
+
+  // 上传压缩包到本地存储（带进度）
+  const handleUploadZip = async (file: File, skuName: string, onProgress?: (progress: number) => void): Promise<{ fileName: string; filePath: string; fileSize: number } | null> => {
    const formData = new FormData()
    formData.append('file', file)
+    formData.append('skuName', skuName) // 添加skuName字段

-    try {
-      const response = await fetch(`/api/materials/${materialId}/skus/upload`, {
-        method: 'POST',
-        body: formData
+    return new Promise((resolve, reject) => {
+      const xhr = new XMLHttpRequest()
+
+      // 监听上传进度
+      xhr.upload.addEventListener('progress', (e) => {
+        if (e.lengthComputable && onProgress) {
+          const progress = Math.round((e.loaded / e.total) * 100)
+          onProgress(progress)
+        }
      })

-      if (response.ok) {
-        const data = await response.json()
-        return {
-          fileName: data.fileName,
-          filePath: data.filePath,
-          fileSize: data.fileSize
+      xhr.addEventListener('load', () => {
+        if (xhr.status === 200 || xhr.status === 201) {
+          try {
+            const data = JSON.parse(xhr.responseText)
+            // API返回的是相对路径，需要转换为前端期望的格式
+            resolve({
+              fileName: file.name, // 使用原始文件名
+              filePath: data.filePath || `skus/${materialId}/${data.id || Date.now()}_${file.name}`, // 相对路径
+              fileSize: parseInt(data.fileSize || file.size)
+            })
+          } catch (error) {
+            reject(new Error('解析响应失败'))
        }
      } else {
-        const error = await response.json()
+          try {
+            const error = JSON.parse(xhr.responseText)
        showToast(error.error || '上传失败', { variant: 'error' })
-        return null
-      }
-    } catch (error) {
-      console.error('上传失败:', error)
+            reject(new Error(error.error || '上传失败'))
+          } catch {
+            showToast('上传失败', { variant: 'error' })
+            reject(new Error('上传失败'))
+          }
+        }
+      })
+
+      xhr.addEventListener('error', () => {
      showToast('上传失败，请稍后重试', { variant: 'error' })
-      return null
-    }
+        reject(new Error('网络错误'))
+      })
+
+      xhr.open('POST', `/api/materials/${materialId}/skus/upload`)
+      xhr.send(formData)
+    })
  }

-  // 上传预览图到 S3
-  const handleUploadPreview = async (file: File): Promise<string | null> => {
+  // 上传预览图到 S3（带进度）
+  const handleUploadPreview = async (file: File, onProgress?: (progress: number) => void): Promise<string | null> => {
    const formData = new FormData()
    formData.append('file', file)

-    try {
-      const response = await fetch('/api/upload/preview', {
-        method: 'POST',
-        body: formData
+    return new Promise((resolve, reject) => {
+      const xhr = new XMLHttpRequest()
+
+      // 监听上传进度
+      xhr.upload.addEventListener('progress', (e) => {
+        if (e.lengthComputable && onProgress) {
+          const progress = Math.round((e.loaded / e.total) * 100)
+          onProgress(progress)
+        }
      })

-      if (response.ok) {
-        const data = await response.json()
-        return data.url
+      xhr.addEventListener('load', () => {
+        if (xhr.status === 200) {
+          try {
+            const data = JSON.parse(xhr.responseText)
+            resolve(data.url)
+          } catch (error) {
+            reject(new Error('解析响应失败'))
+          }
      } else {
-        const error = await response.json()
+          try {
+            const error = JSON.parse(xhr.responseText)
        showToast(error.error || '上传预览图失败', { variant: 'error' })
-        return null
-      }
-    } catch (error) {
-      console.error('上传预览图失败:', error)
+            reject(new Error(error.error || '上传预览图失败'))
+          } catch {
+            showToast('上传预览图失败', { variant: 'error' })
+            reject(new Error('上传预览图失败'))
+          }
+        }
+      })
+
+      xhr.addEventListener('error', () => {
      showToast('上传预览图失败，请稍后重试', { variant: 'error' })
-      return null
-    }
+        reject(new Error('网络错误'))
+      })
+
+      xhr.open('POST', '/api/upload/preview')
+      xhr.send(formData)
+    })
  }

-  // 处理新增 SKU 的压缩包选择
-  const handleNewZipSelect = async (e: React.ChangeEvent<HTMLInputElement>) => {
-    const file = e.target.files?.[0]
-    if (!file) return
-
-    setUploadingNew(true)
-    const result = await handleUploadZip(file)
-    if (result) {
-      setNewSkuFile(result)
-      // 如果没有填写名称，用文件名（去掉扩展名）作为默认名称
-      if (!newSkuName) {
-        const nameWithoutExt = file.name.replace(/\.[^/.]+$/, '')
-        setNewSkuName(nameWithoutExt)
-      }
-    }
-    setUploadingNew(false)
+  // 开始编辑SKU
+  const handleEditSku = (sku: Sku) => {
+    setEditingSkuId(sku.id)
+    setNewSkuName(sku.skuName)
+    setNewSkuPreviewUrl(sku.previewUrl || '')
+    setNewSkuPreviewFile(null) // 编辑时不清除已有预览图
+    setNewSkuZipFile(null) // 编辑时不要求重新上传压缩包
+    setShowAddForm(true)
+    setUploadProgress({ zip: 0, preview: 0 })
  }

-  // 处理新增 SKU 的预览图选择
-  const handleNewPreviewSelect = async (e: React.ChangeEvent<HTMLInputElement>) => {
-    const file = e.target.files?.[0]
-    if (!file) return
-
-    setUploadingPreview(true)
-    const url = await handleUploadPreview(file)
-    if (url) {
-      setNewSkuPreviewUrl(url)
+  // 取消编辑/添加
+  const handleCancelEdit = () => {
+    // 清理本地预览URL
+    if (newSkuPreviewUrl && newSkuPreviewUrl.startsWith('blob:')) {
+      URL.revokeObjectURL(newSkuPreviewUrl)
    }
-    setUploadingPreview(false)
+    setShowAddForm(false)
+    setEditingSkuId(null)
+    setNewSkuName('')
+    setNewSkuPreviewFile(null)
+    setNewSkuPreviewUrl('')
+    setNewSkuZipFile(null)
+    setUploadProgress({ zip: 0, preview: 0 })
  }

-  // 添加新 SKU
+  // 添加或更新 SKU（此时才开始上传文件）
  const handleAddSku = async () => {
    if (!newSkuName.trim()) {
      showToast('请输入 SKU 名称', { variant: 'error' })
      return
    }
-    if (!newSkuPreviewUrl) {
-      showToast('请上传预览图', { variant: 'error' })
+    // 编辑模式：预览图或压缩包可以只更新其中一个，也可以都不更新（只改名称）
+    // 新增模式：必须都有
+    if (!editingSkuId) {
+      if (!newSkuPreviewFile) {
+        showToast('请选择预览图', { variant: 'error' })
      return
    }
-    if (!newSkuFile) {
-      showToast('请上传压缩包', { variant: 'error' })
+      if (!newSkuZipFile) {
+        showToast('请选择压缩包', { variant: 'error' })
      return
    }
+    }
+    // 编辑模式：允许只修改名称，不更新文件

    setSaving(true)
+    setUploading(true)
+    setUploadProgress({ zip: 0, preview: 0 })
+
    try {
+      let previewUrl = newSkuPreviewUrl // 使用已有预览URL（编辑模式）
+      let zipResult: { fileName: string; filePath: string; fileSize: number } | null = null
+
+      // 如果有新预览图，上传它
+      if (newSkuPreviewFile) {
+        const uploadedPreviewUrl = await handleUploadPreview(newSkuPreviewFile, (progress) => {
+          setUploadProgress(prev => ({ ...prev, preview: progress }))
+        })
+        if (!uploadedPreviewUrl) {
+          showToast('上传预览图失败', { variant: 'error' })
+          return
+        }
+        previewUrl = uploadedPreviewUrl
+      }
+
+      // 如果有新压缩包，上传它
+      if (newSkuZipFile) {
+        const uploadedZipResult = await handleUploadZip(newSkuZipFile, newSkuName.trim(), (progress) => {
+          setUploadProgress(prev => ({ ...prev, zip: progress }))
+        })
+        if (!uploadedZipResult) {
+          showToast('上传压缩包失败', { variant: 'error' })
+          return
+        }
+        zipResult = uploadedZipResult
+      }
+
+      // 编辑模式：更新SKU
+      if (editingSkuId) {
+        // 获取当前SKU信息，用于填充未更新的字段
+        const currentSku = skus.find(s => s.id === editingSkuId)
+        if (!currentSku) {
+          showToast('SKU不存在', { variant: 'error' })
+          return
+        }
+
+        const response = await fetch(`/api/materials/${materialId}/skus/${editingSkuId}`, {
+          method: 'PUT',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({
+            skuName: newSkuName.trim(),
+            previewUrl: previewUrl || currentSku.previewUrl,
+            zipFileName: zipResult?.fileName || currentSku.zipFileName,
+            zipFilePath: zipResult?.filePath || currentSku.zipFilePath,
+            zipFileSize: zipResult?.fileSize || parseInt(currentSku.zipFileSize)
+          })
+        })
+
+        if (response.ok) {
+          // 清理本地预览URL
+          if (newSkuPreviewUrl && newSkuPreviewUrl.startsWith('blob:')) {
+            URL.revokeObjectURL(newSkuPreviewUrl)
+          }
+          
+          // 重置表单
+          handleCancelEdit()
+          
+          // 刷新列表
+          await fetchSkus()
+          showToast('更新成功', { variant: 'success' })
+        } else {
+          const error = await response.json()
+          showToast(error.error || '更新失败', { variant: 'error' })
+        }
+        return
+      }
+
+      // 新增模式：创建SKU
+      if (!previewUrl || !zipResult) {
+        showToast('上传失败', { variant: 'error' })
+        return
+      }
+
      const response = await fetch(`/api/materials/${materialId}/skus`, {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({
          skuName: newSkuName.trim(),
-          previewUrl: newSkuPreviewUrl,
-          zipFileName: newSkuFile.fileName,
-          zipFilePath: newSkuFile.filePath,
-          zipFileSize: newSkuFile.fileSize
+          previewUrl: previewUrl,
+          zipFileName: zipResult.fileName,
+          zipFilePath: zipResult.filePath,
+          zipFileSize: zipResult.fileSize
        })
      })

      if (response.ok) {
-        // 重置表单
-        setNewSkuName('')
-        setNewSkuPreviewUrl('')
-        setNewSkuFile(null)
-        setShowAddForm(false)
+          // 清理本地预览URL
+          if (newSkuPreviewUrl && newSkuPreviewUrl.startsWith('blob:')) {
+            URL.revokeObjectURL(newSkuPreviewUrl)
+          }
+          
        // 刷新列表
        await fetchSkus()
+          showToast('添加成功', { variant: 'success' })
+          
+          // 重置表单字段（但不关闭表单，可以继续添加）
+          setNewSkuName('')
+          setNewSkuPreviewFile(null)
+          setNewSkuPreviewUrl('')
+          setNewSkuZipFile(null)
+          setUploadProgress({ zip: 0, preview: 0 })
      } else {
        const error = await response.json()
        showToast(error.error || '添加失败', { variant: 'error' })
@ -207,6 +380,7 @@ export default function SkuEditModal({ materialId, isOpen, onClose, onSaved }: S
      showToast('添加失败，请稍后重试', { variant: 'error' })
    } finally {
      setSaving(false)
+      setUploading(false)
    }
  }

@ -231,15 +405,41 @@ export default function SkuEditModal({ materialId, isOpen, onClose, onSaved }: S
    }
  }

-  // 移动 SKU（上移/下移）
-  const handleMoveSku = async (index: number, direction: 'up' | 'down') => {
-    const newIndex = direction === 'up' ? index - 1 : index + 1
-    if (newIndex < 0 || newIndex >= skus.length) return
+  // 拖拽排序传感器（禁用自动滚动以避免无限滚动问题）
+  const sensors = useSensors(
+    useSensor(PointerSensor, {
+      activationConstraint: {
+        distance: 8, // 需要移动8px才开始拖拽
+      },
+    }),
+    useSensor(KeyboardSensor, {
+      coordinateGetter: sortableKeyboardCoordinates,
+    })
+  )
+
+  const [activeId, setActiveId] = useState<string | null>(null)
+
+  // 拖拽开始
+  const handleDragStart = (event: DragStartEvent) => {
+    setActiveId(event.active.id as string)
+  }
+
+  // 拖拽结束处理
+  const handleDragEnd = async (event: DragEndEvent) => {
+    const { active, over } = event
+    setActiveId(null) // 重置拖拽状态
+
+    if (over && active.id !== over.id) {
+      const oldIndex = skus.findIndex((sku) => sku.id === active.id)
+      const newIndex = skus.findIndex((sku) => sku.id === over.id)
+
+      const newSkus = arrayMove(skus, oldIndex, newIndex)
+
+      // 更新排序值
+      newSkus.forEach((sku, idx) => {
+        sku.sortOrder = idx
+      })

-    const newSkus = [...skus]
-    const temp = newSkus[index]
-    newSkus[index] = newSkus[newIndex]
-    newSkus[newIndex] = temp
    setSkus(newSkus)

    // 保存新排序
@ -251,17 +451,113 @@ export default function SkuEditModal({ materialId, isOpen, onClose, onSaved }: S
          skuIds: newSkus.map(sku => sku.id)
        })
      })
+        showToast('排序已更新', { variant: 'success' })
    } catch (error) {
      console.error('更新排序失败:', error)
+        showToast('更新排序失败', { variant: 'error' })
+        // 恢复原顺序
+        fetchSkus()
+      }
    }
  }

+  // 可拖拽的SKU项组件
+  function SortableSkuItem({ sku, index }: { sku: Sku; index: number }) {
+    const {
+      attributes,
+      listeners,
+      setNodeRef,
+      transform,
+      transition,
+      isDragging,
+    } = useSortable({ id: sku.id })
+
+    const style = {
+      transform: CSS.Transform.toString(transform),
+      transition,
+      opacity: isDragging ? 0.5 : 1,
+    }
+
+    return (
+      <div
+        ref={setNodeRef}
+        style={style}
+        className="flex items-center gap-4 p-4 bg-gray-50 dark:bg-gray-700/30 rounded-xl"
+      >
+        {/* 拖拽手柄 */}
+        <div
+          {...attributes}
+          {...listeners}
+          className="cursor-grab active:cursor-grabbing p-2 text-gray-400 hover:text-gray-600 dark:hover:text-gray-300"
+          title="拖拽排序"
+        >
+          <svg className="w-5 h-5" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+            <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M4 8h16M4 16h16" />
+          </svg>
+        </div>
+
+        {/* 预览图 */}
+        <div className="w-16 h-16 flex-shrink-0 rounded overflow-hidden">
+          <Image
+            src={sku.previewUrl}
+            alt={sku.skuName}
+            width={64}
+            height={64}
+            className="w-full h-full object-cover"
+            unoptimized
+          />
+        </div>
+
+        {/* SKU 信息 */}
+        <div className="flex-1 min-w-0">
+          <p className="text-sm font-medium text-gray-900 dark:text-white">
+            {sku.skuName}
+          </p>
+          <p className="text-xs text-gray-500 dark:text-gray-400 mt-1">
+            {sku.zipFileName} · {formatFileSize(sku.zipFileSize)}
+          </p>
+        </div>
+
+        {/* 操作按钮 */}
+        <div className="flex items-center gap-1">
+          {/* 编辑 */}
+          <button
+            onClick={() => handleEditSku(sku)}
+            className="p-1.5 text-blue-400 hover:text-blue-600"
+            title="编辑"
+          >
+            <svg className="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+              <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M11 5H6a2 2 0 00-2 2v11a2 2 0 002 2h11a2 2 0 002-2v-5m-1.414-9.414a2 2 0 112.828 2.828L11.828 15H9v-2.828l8.586-8.586z" />
+            </svg>
+          </button>
+          {/* 删除 */}
+          <button
+            onClick={() => handleDeleteSku(sku.id)}
+            className="p-1.5 text-red-400 hover:text-red-600"
+            title="删除"
+          >
+            <svg className="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+              <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M19 7l-.867 12.142A2 2 0 0116.138 21H7.862a2 2 0 01-1.995-1.858L5 7m5 4v6m4-6v6m1-10V4a1 1 0 00-1-1h-4a1 1 0 00-1 1v3M4 7h16" />
+            </svg>
+          </button>
+        </div>
+      </div>
+    )
+  }
+
  // 关闭弹窗
  const handleClose = () => {
+    // 清理本地预览URL
+    if (newSkuPreviewUrl && newSkuPreviewUrl.startsWith('blob:')) {
+      URL.revokeObjectURL(newSkuPreviewUrl)
+    }
+    
    setShowAddForm(false)
    setNewSkuName('')
+    setNewSkuPreviewFile(null)
    setNewSkuPreviewUrl('')
-    setNewSkuFile(null)
+    setNewSkuZipFile(null)
+    setUploadProgress({ zip: 0, preview: 0 })
    onSaved()
    onClose()
  }
@ -288,8 +584,16 @@ export default function SkuEditModal({ materialId, isOpen, onClose, onSaved }: S

        {/* 工具栏 */}
        <div className="px-6 py-3 border-b border-gray-200 dark:border-gray-700">
+          {!showAddForm ? (
          <button
-            onClick={() => setShowAddForm(true)}
+              onClick={() => {
+                setEditingSkuId(null)
+                setNewSkuName('')
+                setNewSkuPreviewFile(null)
+                setNewSkuPreviewUrl('')
+                setNewSkuZipFile(null)
+                setShowAddForm(true)
+              }}
            className="px-4 py-2 bg-blue-600 hover:bg-blue-700 text-white text-sm rounded-lg transition-colors flex items-center gap-2"
          >
            <svg className="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
@ -297,6 +601,11 @@ export default function SkuEditModal({ materialId, isOpen, onClose, onSaved }: S
            </svg>
            添加 SKU
          </button>
+          ) : (
+            <div className="text-sm font-medium text-gray-700 dark:text-gray-300">
+              {editingSkuId ? '编辑 SKU' : '添加 SKU'}
+            </div>
+          )}
        </div>

        {/* 内容区域 */}
@ -318,10 +627,20 @@ export default function SkuEditModal({ materialId, isOpen, onClose, onSaved }: S
                        placeholder="SKU 名称（如：白色款）"
                        className="w-72 px-3 py-2 text-sm border border-gray-300 dark:border-gray-600 rounded-lg bg-white dark:bg-gray-700 text-gray-900 dark:text-white placeholder-gray-400 flex-shrink-0"
                      />
-                      {newSkuFile && (
+                      {newSkuZipFile && (
+                        <div className="flex-1 min-w-0">
                        <p className="text-xs text-gray-500 dark:text-gray-400 truncate">
-                          {newSkuFile.fileName} ({formatFileSize(newSkuFile.fileSize)})
+                            {newSkuZipFile.name} ({formatFileSize(newSkuZipFile.size)})
                        </p>
+                          {uploading && uploadProgress.zip > 0 && (
+                            <div className="mt-1 w-full bg-gray-200 dark:bg-gray-700 rounded-full h-1.5">
+                              <div
+                                className="bg-blue-600 h-1.5 rounded-full transition-all duration-300"
+                                style={{ width: `${uploadProgress.zip}%` }}
+                              />
+                            </div>
+                          )}
+                        </div>
                      )}
                    </div>

@ -334,7 +653,9 @@ export default function SkuEditModal({ materialId, isOpen, onClose, onSaved }: S
                          e.preventDefault()
                          const file = e.dataTransfer.files?.[0]
                          if (file && file.type.startsWith('image/')) {
-                            handleNewPreviewSelect({ target: { files: [file] } } as any)
+                            setNewSkuPreviewFile(file)
+                            const previewUrl = URL.createObjectURL(file)
+                            setNewSkuPreviewUrl(previewUrl)
                          }
                        }}
                      >
@ -360,13 +681,13 @@ export default function SkuEditModal({ materialId, isOpen, onClose, onSaved }: S
                        ) : (
                          <button
                            onClick={() => previewInputRef.current?.click()}
-                            disabled={uploadingPreview}
+                          disabled={uploading}
                            className="w-16 h-16 bg-gray-200 dark:bg-gray-600 hover:bg-gray-300 dark:hover:bg-gray-500 rounded flex flex-col items-center justify-center transition-colors border-2 border-dashed border-gray-300 dark:border-gray-500"
                          >
                            <svg className="w-5 h-5 text-gray-400" fill="none" stroke="currentColor" viewBox="0 0 24 24">
                              <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M4 16l4.586-4.586a2 2 0 012.828 0L16 16m-2-2l1.586-1.586a2 2 0 012.828 0L20 14m-6-6h.01M6 20h12a2 2 0 002-2V6a2 2 0 00-2-2H6a2 2 0 00-2 2v12a2 2 0 002 2z" />
                            </svg>
-                            <span className="text-[10px] text-gray-500 mt-0.5">{uploadingPreview ? '上传中' : '预览图'}</span>
+                          <span className="text-[10px] text-gray-500 mt-0.5">预览图</span>
                          </button>
                        )}
                        <input
@ -385,16 +706,21 @@ export default function SkuEditModal({ materialId, isOpen, onClose, onSaved }: S
                          e.preventDefault()
                          const file = e.dataTransfer.files?.[0]
                          if (file && ['.zip', '.rar', '.7z'].some(ext => file.name.toLowerCase().endsWith(ext))) {
-                            handleNewZipSelect({ target: { files: [file] } } as any)
+                            setNewSkuZipFile(file)
+                            // 如果没有填写名称，用文件名（去掉扩展名）作为默认名称
+                            if (!newSkuName) {
+                              const nameWithoutExt = file.name.replace(/\.[^/.]+$/, '')
+                              setNewSkuName(nameWithoutExt)
+                            }
                          }
                        }}
                      >
                        <button
                          onClick={() => fileInputRef.current?.click()}
-                          disabled={uploadingNew}
+                          disabled={uploading}
                          className="w-16 h-16 bg-gray-200 dark:bg-gray-600 hover:bg-gray-300 dark:hover:bg-gray-500 rounded flex flex-col items-center justify-center transition-colors border-2 border-dashed border-gray-300 dark:border-gray-500"
                        >
-                          {newSkuFile ? (
+                          {newSkuZipFile ? (
                            <>
                              <svg className="w-5 h-5 text-green-600" fill="none" stroke="currentColor" viewBox="0 0 24 24">
                                <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M5 13l4 4L19 7" />
@ -406,7 +732,7 @@ export default function SkuEditModal({ materialId, isOpen, onClose, onSaved }: S
                              <svg className="w-5 h-5 text-gray-400" fill="none" stroke="currentColor" viewBox="0 0 24 24">
                                <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M7 16a4 4 0 01-.88-7.903A5 5 0 1115.9 6L16 6a5 5 0 011 9.9M15 13l-3-3m0 0l-3 3m3-3v12" />
                              </svg>
-                              <span className="text-[10px] text-gray-500 mt-0.5">{uploadingNew ? '上传中' : '压缩包'}</span>
+                              <span className="text-[10px] text-gray-500 mt-0.5">压缩包</span>
                            </>
                          )}
                        </button>
@ -422,19 +748,28 @@ export default function SkuEditModal({ materialId, isOpen, onClose, onSaved }: S
                      {/* 操作按钮 */}
                      <button
                        onClick={handleAddSku}
-                        disabled={saving || !newSkuName || !newSkuPreviewUrl || !newSkuFile}
-                        className="px-4 py-2 text-sm bg-blue-600 hover:bg-blue-700 text-white rounded-lg disabled:opacity-50 transition-colors"
+                        disabled={saving || uploading || !newSkuName || !newSkuPreviewFile || !newSkuZipFile}
+                        className="px-4 py-2 text-sm bg-blue-600 hover:bg-blue-700 text-white rounded-lg disabled:opacity-50 transition-colors relative"
                      >
-                        {saving ? '保存中...' : '添加'}
+                        {uploading ? (
+                          <span className="flex items-center gap-2">
+                            <svg className="w-4 h-4 animate-spin" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                              <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M4 4v5h.582m15.356 2A8.001 8.001 0 004.582 9m0 0H9m11 11v-5h-.581m0 0a8.003 8.003 0 01-15.357-2m15.357 2H15" />
+                            </svg>
+                            上传中...
+                          </span>
+                        ) : saving ? (
+                          '保存中...'
+                        ) : editingSkuId ? (
+                          '更新'
+                        ) : (
+                          '添加'
+                        )}
                      </button>
                      <button
-                        onClick={() => {
-                          setShowAddForm(false)
-                          setNewSkuName('')
-                          setNewSkuPreviewUrl('')
-                          setNewSkuFile(null)
-                        }}
-                        className="p-2 text-gray-400 hover:text-gray-600 dark:hover:text-gray-300 rounded-lg hover:bg-gray-100 dark:hover:bg-gray-700"
+                        onClick={handleCancelEdit}
+                        disabled={uploading}
+                        className="p-2 text-gray-400 hover:text-gray-600 dark:hover:text-gray-300 rounded-lg hover:bg-gray-100 dark:hover:bg-gray-700 disabled:opacity-50"
                      >
                        <svg className="w-5 h-5" fill="none" stroke="currentColor" viewBox="0 0 24 24">
                          <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M6 18L18 6M6 6l12 12" />
@ -445,76 +780,46 @@ export default function SkuEditModal({ materialId, isOpen, onClose, onSaved }: S
                </div>
              )}

-              {/* SKU 列表 */}
+              {/* SKU 列表（支持拖拽排序） */}
              {skus.length === 0 ? (
-                <div className="text-center py-8 text-gray-500 dark:text-gray-400">
-                  暂无 SKU，点击上方按钮添加
+                <div className="text-center py-12 text-gray-500 dark:text-gray-400">
+                  <svg className="w-16 h-16 mx-auto mb-4 text-gray-300 dark:text-gray-600" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                    <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M20 7l-8-4-8 4m16 0l-8 4m8-4v10l-8 4m0-10L4 7m8 4v10M4 7v10l8 4" />
+                  </svg>
+                  <p className="text-base mb-2">暂无 SKU</p>
+                  <p className="text-sm text-gray-400 dark:text-gray-500">点击上方&ldquo;添加 SKU&rdquo;按钮开始添加</p>
                </div>
              ) : (
-                skus.map((sku, index) => (
-                  <div
-                    key={sku.id}
-                    className="flex items-center gap-4 p-4 bg-gray-50 dark:bg-gray-700/30 rounded-xl"
+                <DndContext
+                  sensors={sensors}
+                  collisionDetection={closestCenter}
+                  onDragStart={handleDragStart}
+                  onDragEnd={handleDragEnd}
+                  autoScroll={false}
+                >
+                  <SortableContext
+                    items={skus.map(sku => sku.id)}
+                    strategy={verticalListSortingStrategy}
                  >
-                    {/* 预览图 */}
-                    <div className="w-16 h-16 flex-shrink-0 rounded overflow-hidden">
-                      <Image
-                        src={sku.previewUrl}
-                        alt={sku.skuName}
-                        width={64}
-                        height={64}
-                        className="w-full h-full object-cover"
-                        unoptimized
-                      />
+                    <div className="space-y-3">
+                      {skus.map((sku, index) => (
+                        <SortableSkuItem key={sku.id} sku={sku} index={index} />
+                      ))}
                    </div>
-
-                    {/* SKU 信息 */}
+                  </SortableContext>
+                  <DragOverlay>
+                    {activeId ? (
+                      <div className="flex items-center gap-4 p-4 bg-gray-50 dark:bg-gray-700/30 rounded-xl opacity-90 shadow-lg">
+                        <div className="w-16 h-16 flex-shrink-0 rounded overflow-hidden bg-gray-200 dark:bg-gray-600"></div>
                    <div className="flex-1 min-w-0">
                      <p className="text-sm font-medium text-gray-900 dark:text-white">
-                        {sku.skuName}
-                      </p>
-                      <p className="text-xs text-gray-500 dark:text-gray-400 mt-1">
-                        {sku.zipFileName} · {formatFileSize(sku.zipFileSize)}
+                            {skus.find(sku => sku.id === activeId)?.skuName}
                      </p>
                    </div>
-
-                    {/* 操作按钮 */}
-                    <div className="flex items-center gap-1">
-                      {/* 上移 */}
-                      <button
-                        onClick={() => handleMoveSku(index, 'up')}
-                        disabled={index === 0}
-                        className="p-1.5 text-gray-400 hover:text-gray-600 dark:hover:text-gray-300 disabled:opacity-30"
-                        title="上移"
-                      >
-                        <svg className="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-                          <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M5 15l7-7 7 7" />
-                        </svg>
-                      </button>
-                      {/* 下移 */}
-                      <button
-                        onClick={() => handleMoveSku(index, 'down')}
-                        disabled={index === skus.length - 1}
-                        className="p-1.5 text-gray-400 hover:text-gray-600 dark:hover:text-gray-300 disabled:opacity-30"
-                        title="下移"
-                      >
-                        <svg className="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-                          <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M19 9l-7 7-7-7" />
-                        </svg>
-                      </button>
-                      {/* 删除 */}
-                      <button
-                        onClick={() => handleDeleteSku(sku.id)}
-                        className="p-1.5 text-red-400 hover:text-red-600"
-                        title="删除"
-                      >
-                        <svg className="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-                          <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M19 7l-.867 12.142A2 2 0 0116.138 21H7.862a2 2 0 01-1.995-1.858L5 7m5 4v6m4-6v6m1-10V4a1 1 0 00-1-1h-4a1 1 0 00-1 1v3M4 7h16" />
-                        </svg>
-                      </button>
                    </div>
-                  </div>
-                ))
+                    ) : null}
+                  </DragOverlay>
+                </DndContext>
              )}
            </div>
          )}
--- a/components/SkuList.tsx
+++ b/components/SkuList.tsx
@ -27,14 +27,16 @@ interface SkuListProps {
  materialId: string
  canEdit: boolean // 是否可以编辑（上传者或管理员）
  onEditClick: () => void // 点击编辑按钮的回调
+  onSelectionChange?: (selectedIds: Set<string>) => void // 选中状态变化回调
 }

-export default function SkuList({ materialId, canEdit, onEditClick }: SkuListProps) {
+export default function SkuList({ materialId, canEdit, onEditClick, onSelectionChange }: SkuListProps) {
  const [skus, setSkus] = useState<Sku[]>([])
  const [loading, setLoading] = useState(true)
  const { toast, showToast } = useToast()
  const [selectedSkuIds, setSelectedSkuIds] = useState<Set<string>>(new Set())
  const [downloadingSkuId, setDownloadingSkuId] = useState<string | null>(null)
+  // 移除批量下载状态，由父组件处理
  const [previewImage, setPreviewImage] = useState<string | null>(null) // 大图预览

  // 加载 SKU 列表
@ -66,24 +68,13 @@ export default function SkuList({ materialId, canEdit, onEditClick }: SkuListPro
    return `${(size / Math.pow(1024, i)).toFixed(2)} ${units[i]}`
  }

-  // 计算已选 SKU 的总大小
-  const calculateTotalSize = (): string => {
-    let total = 0
-    skus.forEach(sku => {
-      if (selectedSkuIds.has(sku.id)) {
-        total += parseInt(sku.zipFileSize) || 0
-      }
-    })
-    return formatFileSize(total.toString())
-  }
-
  // 全选/取消全选
  const handleSelectAll = () => {
-    if (selectedSkuIds.size === skus.length) {
-      setSelectedSkuIds(new Set())
-    } else {
-      setSelectedSkuIds(new Set(skus.map(sku => sku.id)))
-    }
+    const newSelected = selectedSkuIds.size === skus.length 
+      ? new Set<string>()
+      : new Set(skus.map(sku => sku.id))
+    setSelectedSkuIds(newSelected)
+    onSelectionChange?.(newSelected)
  }

  // 单选/取消单选
@ -95,6 +86,7 @@ export default function SkuList({ materialId, canEdit, onEditClick }: SkuListPro
      newSelected.add(skuId)
    }
    setSelectedSkuIds(newSelected)
+    onSelectionChange?.(newSelected)
  }

  // 下载单个 SKU
@ -128,16 +120,8 @@ export default function SkuList({ materialId, canEdit, onEditClick }: SkuListPro
    }
  }

-  // 下载已选的 SKU（逐个下载）
-  const handleDownloadSelected = async () => {
-    const selectedSkus = skus.filter(sku => selectedSkuIds.has(sku.id))
-    
-    for (const sku of selectedSkus) {
-      await handleDownloadSku(sku)
-      // 每个下载之间稍微延迟，避免浏览器阻止
-      await new Promise(resolve => setTimeout(resolve, 500))
-    }
-  }
+  // 批量下载功能已移至父组件
+

  if (loading) {
    return (
@ -167,9 +151,9 @@ export default function SkuList({ materialId, canEdit, onEditClick }: SkuListPro
  }

  return (
-    <div className="flex flex-col h-full">
-      {/* 标题栏 */}
-      <div className="flex items-center justify-between mb-2">
+    <div className="flex flex-col">
+      {/* 标题栏 - 编辑按钮与标题同一行 */}
+      <div className="flex items-center justify-between mb-3">
        <span className="text-sm font-medium text-gray-900 dark:text-white">
          SKU 列表 ({skus.length}个)
        </span>
@ -187,7 +171,7 @@ export default function SkuList({ materialId, canEdit, onEditClick }: SkuListPro
      </div>

      {/* 全选栏 */}
-      <div className="flex items-center justify-between py-2 px-3 bg-gray-50 dark:bg-gray-700/50 rounded-lg mb-2">
+      <div className="flex items-center justify-between py-2 px-3 bg-gray-50 dark:bg-gray-700/50 rounded-lg mb-3">
        <label className="flex items-center gap-2 cursor-pointer">
          <input
            type="checkbox"
@ -199,20 +183,31 @@ export default function SkuList({ materialId, canEdit, onEditClick }: SkuListPro
        </label>
        {selectedSkuIds.size > 0 && (
          <span className="text-xs text-gray-500 dark:text-gray-400">
-            已选 {selectedSkuIds.size} 个，共 {calculateTotalSize()}
+            已选 {selectedSkuIds.size} 个
          </span>
        )}
      </div>

      {/* SKU 列表（可滚动区域） */}
      <div 
-        className="flex-1 overflow-y-auto space-y-2 pr-1"
-        style={{ maxHeight: 'calc(100vh - 320px)' }}
+        className="overflow-y-auto space-y-2 pr-1"
+        style={{ maxHeight: 'calc(100vh - 500px)' }}
      >
-        {skus.map(sku => (
+        {skus.length === 0 ? (
+          <div className="text-center py-8 text-gray-500 dark:text-gray-400 text-sm">
+            <svg className="w-12 h-12 mx-auto mb-3 text-gray-300 dark:text-gray-600" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+              <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M20 7l-8-4-8 4m16 0l-8 4m8-4v10l-8 4m0-10L4 7m8 4v10M4 7v10l8 4" />
+            </svg>
+            <p>暂无 SKU</p>
+            {canEdit && (
+              <p className="text-xs mt-1 text-gray-400 dark:text-gray-500">点击上方&ldquo;编辑&rdquo;按钮添加</p>
+            )}
+          </div>
+        ) : (
+          skus.map(sku => (
          <div
            key={sku.id}
-            className="flex items-center gap-3 p-2 bg-gray-50 dark:bg-gray-700/30 rounded-lg hover:bg-gray-100 dark:hover:bg-gray-700/50 transition-colors"
+            className="flex items-center gap-2 p-2 bg-gray-50 dark:bg-gray-700/30 rounded-lg hover:bg-gray-100 dark:hover:bg-gray-700/50 transition-colors"
          >
            {/* 复选框 */}
            <input
@ -224,14 +219,14 @@ export default function SkuList({ materialId, canEdit, onEditClick }: SkuListPro

            {/* 预览图（点击放大） */}
            <div
-              className="w-12 h-12 flex-shrink-0 rounded overflow-hidden cursor-pointer hover:opacity-80 transition-opacity"
+              className="w-10 h-10 flex-shrink-0 rounded overflow-hidden cursor-pointer hover:opacity-80 transition-opacity"
              onClick={() => setPreviewImage(sku.previewUrl)}
            >
              <Image
                src={sku.previewUrl}
                alt={sku.skuName}
-                width={48}
-                height={48}
+                width={40}
+                height={40}
                className="w-full h-full object-cover"
                unoptimized
              />
@ -251,26 +246,16 @@ export default function SkuList({ materialId, canEdit, onEditClick }: SkuListPro
            <button
              onClick={() => handleDownloadSku(sku)}
              disabled={downloadingSkuId === sku.id}
-              className="flex-shrink-0 px-3 py-1.5 text-xs bg-blue-600 hover:bg-blue-700 text-white rounded-lg disabled:opacity-50 transition-colors"
+              className="flex-shrink-0 px-2.5 py-1.5 text-xs bg-blue-600 hover:bg-blue-700 text-white rounded-lg disabled:opacity-50 transition-colors"
            >
-              {downloadingSkuId === sku.id ? '下载中...' : '下载'}
+              {downloadingSkuId === sku.id ? '下载中' : '下载'}
            </button>
          </div>
-        ))}
+        ))
+        )}
      </div>

-      {/* 底部下载按钮 */}
-      {selectedSkuIds.size > 0 && (
-        <button
-          onClick={handleDownloadSelected}
-          className="mt-3 w-full py-2.5 bg-blue-600 hover:bg-blue-700 text-white rounded-xl text-sm font-medium transition-colors flex items-center justify-center gap-2"
-        >
-          <svg className="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-            <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M4 16v1a3 3 0 003 3h10a3 3 0 003-3v-1m-4-4l-4 4m0 0l-4-4m4 4V4" />
-          </svg>
-          下载已选 ({selectedSkuIds.size}个)
-        </button>
-      )}
+      {/* 批量下载按钮已移至父组件统一处理 */}

      {/* 大图预览弹窗 */}
      {previewImage && (
--- a/components/UpdateLogModal.tsx
+++ b/components/UpdateLogModal.tsx
@ -3,8 +3,8 @@
 import { useEffect, useState } from 'react'

 // 更新日志配置 - 每次有新功能或优化时更新这个版本号
-const CURRENT_VERSION = '2.2.32'
-const STORAGE_KEY = 'update_log_viewed_version_v2232'
+const CURRENT_VERSION = '2.2.4'
+const STORAGE_KEY = 'update_log_viewed_version_v224'

 interface UpdateItem {
  type: 'feature' | 'improvement' | 'fix' // 新功能、优化、修复
@ -22,6 +22,55 @@ interface UpdateLog {
 // 更新日志内容 - 通俗易懂，面向客户
 // 注意：只有经过测试验证的功能才会添加到更新记录中
 const UPDATE_LOGS: UpdateLog[] = [
+  {
+    version: '2.2.4',
+    date: '2025-12-29',
+    title: '系统更新',
+    items: [
+      {
+        type: 'feature',
+        title: '性能监控面板',
+        description:
+          '在"公网/内网"按钮上新增性能监控功能，鼠标悬停即可查看系统实时性能。显示CPU使用率、内存使用情况、上传队列和转码队列状态，转码队列还会显示任务详情（文件名、类型、上传人、进度等），方便了解系统运行状态。'
+      },
+      {
+        type: 'feature',
+        title: '标准模型素材类型',
+        description:
+          '新增"标准模型"素材类型，支持上传标准模型素材。标准模型素材文件可选，但必须上传预览图，支持后续添加SKU进行扩展。'
+      },
+      {
+        type: 'feature',
+        title: '统一批量上传功能',
+        description:
+          '统一了所有素材类型的批量上传逻辑，无论是通过"选择文件"按钮还是拖拽文件，都使用相同的批量上传流程。支持音乐、视频、3D场景、品牌VI等多种素材类型的批量上传，每个文件可独立设置SPU型号，上传进度清晰可见。'
+      },
+      {
+        type: 'improvement',
+        title: '上传体验大幅提升',
+        description:
+          '所有素材类型的上传流程优化，上传完成后立即关闭上传弹窗，不再等待后台处理（如视频转码）。转码等后台任务在后台异步进行，首页素材卡片会显示转码状态和进度，上传和转码完全分离，体验更流畅。'
+      },
+      {
+        type: 'improvement',
+        title: '上传进度显示优化',
+        description:
+          '修复了上传弹窗中进度条重复显示的问题，现在单文件上传只显示一个进度条，批量上传显示总进度和当前文件进度，界面更清晰。'
+      },
+      {
+        type: 'improvement',
+        title: '转码任务自动清理',
+        description:
+          '视频转码任务入队失败时，系统会自动清理源视频文件，避免产生大体积垃圾文件占用存储空间。'
+      },
+      {
+        type: 'fix',
+        title: '性能监控数据更准确',
+        description:
+          '修复了性能监控中CPU使用率和内存统计不准确的问题，现在使用更精确的计算方法，数据与系统实际状态一致。修复了上传队列显示已完成任务的问题，现在只显示真正进行中的上传任务。'
+      }
+    ]
+  },
  {
    version: '2.2.32',
    date: '2025-12-19',
--- a/components/UploadModal.tsx
+++ b/components/UploadModal.tsx
--- a/components/admin/CategoryManagement.tsx
+++ b/components/admin/CategoryManagement.tsx
@ -0,0 +1,670 @@
+/**
+ * 分类管理组件
+ * 提取自 app/admin/page.tsx 的分类管理功能
+ * 包含：店铺分类、场景分类、平台分类、品类管理
+ */
+
+'use client'
+
+import { useState } from 'react'
+import type { Category, Scene, Platform, ProductCategory } from '@/hooks/useAdminState'
+
+interface CategoryManagementProps {
+  categories: Category[]
+  setCategories: React.Dispatch<React.SetStateAction<Category[]>>
+  scenes: Scene[]
+  setScenes: React.Dispatch<React.SetStateAction<Scene[]>>
+  platforms: Platform[]
+  setPlatforms: React.Dispatch<React.SetStateAction<Platform[]>>
+  productCategories: ProductCategory[]
+  setProductCategories: React.Dispatch<React.SetStateAction<ProductCategory[]>>
+  showToast: (message: string, type?: 'success' | 'error') => void
+}
+
+export default function CategoryManagement({
+  categories,
+  setCategories,
+  scenes,
+  setScenes,
+  platforms,
+  setPlatforms,
+  productCategories,
+  setProductCategories,
+  showToast,
+}: CategoryManagementProps) {
+  // 编辑状态
+  const [editingCategory, setEditingCategory] = useState<Category | null>(null)
+  const [editingScene, setEditingScene] = useState<Scene | null>(null)
+  const [editingPlatform, setEditingPlatform] = useState<Platform | null>(null)
+  const [editingProductCategory, setEditingProductCategory] = useState<ProductCategory | null>(null)
+  
+  // 添加弹窗状态
+  const [showAddCategoryModal, setShowAddCategoryModal] = useState(false)
+  const [showAddSceneModal, setShowAddSceneModal] = useState(false)
+  const [showAddPlatformModal, setShowAddPlatformModal] = useState(false)
+  const [showAddProductCategoryModal, setShowAddProductCategoryModal] = useState(false)
+  
+  // 新建输入状态
+  const [newCategoryName, setNewCategoryName] = useState('')
+  const [newSceneName, setNewSceneName] = useState('')
+  const [newPlatformName, setNewPlatformName] = useState('')
+  const [newProductCategoryName, setNewProductCategoryName] = useState('')
+
+  // ========== 店铺分类操作 ==========
+  const handleAddCategory = async () => {
+    if (!newCategoryName.trim()) {
+      showToast('分类名称不能为空', 'error')
+      return
+    }
+
+    try {
+      const response = await fetch('/api/categories', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ name: newCategoryName.trim() }),
+      })
+
+      if (response.ok) {
+        const data = await response.json()
+        setCategories(prev => [...prev, { id: data.id, name: newCategoryName.trim(), count: 0 }])
+        setShowAddCategoryModal(false)
+        setNewCategoryName('')
+        showToast('添加成功')
+      } else {
+        const data = await response.json()
+        showToast(data.error || '添加失败', 'error')
+      }
+    } catch (error) {
+      console.error('Error adding category:', error)
+      showToast('添加失败', 'error')
+    }
+  }
+
+  const handleUpdateCategory = async (id: string, newName: string) => {
+    if (!newName.trim()) {
+      showToast('分类名称不能为空', 'error')
+      return
+    }
+
+    try {
+      const response = await fetch('/api/categories', {
+        method: 'PATCH',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ id, name: newName.trim() }),
+      })
+
+      if (response.ok) {
+        setCategories(prev => 
+          prev.map(cat => cat.id === id ? { ...cat, name: newName.trim() } : cat)
+        )
+        setEditingCategory(null)
+        showToast('修改成功')
+      } else {
+        const data = await response.json()
+        showToast(data.error || '修改失败', 'error')
+      }
+    } catch (error) {
+      console.error('Error updating category:', error)
+      showToast('修改失败', 'error')
+    }
+  }
+
+  const handleDeleteCategory = async (id: string) => {
+    if (!confirm('确定要删除这个使用店铺分类吗？')) return
+
+    try {
+      const response = await fetch(`/api/categories?id=${id}`, { method: 'DELETE' })
+
+      if (response.ok) {
+        setCategories(prev => prev.filter(cat => cat.id !== id))
+        showToast('删除成功')
+      } else {
+        const data = await response.json()
+        showToast(data.error || '删除失败', 'error')
+      }
+    } catch (error) {
+      console.error('Error deleting category:', error)
+      showToast('删除失败', 'error')
+    }
+  }
+
+  // ========== 场景分类操作 ==========
+  const handleAddScene = async () => {
+    if (!newSceneName.trim()) {
+      showToast('场景名称不能为空', 'error')
+      return
+    }
+
+    try {
+      const response = await fetch('/api/scenes', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ name: newSceneName.trim() }),
+      })
+
+      if (response.ok) {
+        const data = await response.json()
+        setScenes(prev => [...prev, { id: data.id, name: newSceneName.trim(), count: 0 }])
+        setShowAddSceneModal(false)
+        setNewSceneName('')
+        showToast('添加成功')
+      } else {
+        const data = await response.json()
+        showToast(data.error || '添加失败', 'error')
+      }
+    } catch (error) {
+      console.error('Error adding scene:', error)
+      showToast('添加失败', 'error')
+    }
+  }
+
+  const handleUpdateScene = async (id: string, newName: string) => {
+    if (!newName.trim()) {
+      showToast('场景名称不能为空', 'error')
+      return
+    }
+
+    try {
+      const response = await fetch('/api/scenes', {
+        method: 'PATCH',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ id, name: newName.trim() }),
+      })
+
+      if (response.ok) {
+        setScenes(prev => 
+          prev.map(scene => scene.id === id ? { ...scene, name: newName.trim() } : scene)
+        )
+        setEditingScene(null)
+        showToast('修改成功')
+      } else {
+        const data = await response.json()
+        showToast(data.error || '修改失败', 'error')
+      }
+    } catch (error) {
+      console.error('Error updating scene:', error)
+      showToast('修改失败', 'error')
+    }
+  }
+
+  const handleDeleteScene = async (id: string) => {
+    if (!confirm('确定要删除这个场景类别吗？')) return
+
+    try {
+      const response = await fetch(`/api/scenes?id=${id}`, { method: 'DELETE' })
+
+      if (response.ok) {
+        setScenes(prev => prev.filter(scene => scene.id !== id))
+        showToast('删除成功')
+      } else {
+        const data = await response.json()
+        showToast(data.error || '删除失败', 'error')
+      }
+    } catch (error) {
+      console.error('Error deleting scene:', error)
+      showToast('删除失败', 'error')
+    }
+  }
+
+  // ========== 平台分类操作 ==========
+  const handleAddPlatform = async () => {
+    if (!newPlatformName.trim()) {
+      showToast('平台名称不能为空', 'error')
+      return
+    }
+
+    try {
+      const response = await fetch('/api/platforms', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ name: newPlatformName.trim() }),
+      })
+
+      if (response.ok) {
+        const data = await response.json()
+        setPlatforms(prev => [...prev, { id: data.id, name: newPlatformName.trim(), count: 0 }])
+        setShowAddPlatformModal(false)
+        setNewPlatformName('')
+        showToast('添加成功')
+      } else {
+        const data = await response.json()
+        showToast(data.error || '添加失败', 'error')
+      }
+    } catch (error) {
+      console.error('Error adding platform:', error)
+      showToast('添加失败', 'error')
+    }
+  }
+
+  const handleUpdatePlatform = async (id: string, newName: string) => {
+    if (!newName.trim()) {
+      showToast('平台名称不能为空', 'error')
+      return
+    }
+
+    try {
+      const response = await fetch('/api/platforms', {
+        method: 'PUT',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ id, name: newName.trim() }),
+      })
+
+      if (response.ok) {
+        setPlatforms(prev => 
+          prev.map(platform => platform.id === id ? { ...platform, name: newName.trim() } : platform)
+        )
+        setEditingPlatform(null)
+        showToast('修改成功')
+      } else {
+        const data = await response.json()
+        showToast(data.error || '修改失败', 'error')
+      }
+    } catch (error) {
+      console.error('Error updating platform:', error)
+      showToast('修改失败', 'error')
+    }
+  }
+
+  const handleDeletePlatform = async (id: string) => {
+    if (!confirm('确定要删除这个平台分类吗？')) return
+
+    try {
+      const response = await fetch(`/api/platforms?id=${id}`, { method: 'DELETE' })
+
+      if (response.ok) {
+        setPlatforms(prev => prev.filter(platform => platform.id !== id))
+        showToast('删除成功')
+      } else {
+        const data = await response.json()
+        showToast(data.error || '删除失败', 'error')
+      }
+    } catch (error) {
+      console.error('Error deleting platform:', error)
+      showToast('删除失败', 'error')
+    }
+  }
+
+  // ========== 品类操作 ==========
+  const handleAddProductCategory = async () => {
+    if (!newProductCategoryName.trim()) {
+      showToast('请输入品类名称', 'error')
+      return
+    }
+
+    try {
+      const response = await fetch('/api/product-categories', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ name: newProductCategoryName.trim() }),
+      })
+
+      if (response.ok) {
+        const data = await response.json()
+        setProductCategories(prev => [...prev, { id: data.id, name: newProductCategoryName.trim(), count: 0 }])
+        setShowAddProductCategoryModal(false)
+        setNewProductCategoryName('')
+        showToast('添加成功')
+      } else {
+        const data = await response.json()
+        showToast(data.error || '添加失败', 'error')
+      }
+    } catch (error) {
+      console.error('Error adding product category:', error)
+      showToast('添加失败', 'error')
+    }
+  }
+
+  const handleUpdateProductCategory = async (id: string, newName: string) => {
+    if (!newName.trim()) {
+      showToast('品类名称不能为空', 'error')
+      return
+    }
+
+    try {
+      const response = await fetch('/api/product-categories', {
+        method: 'PATCH',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ id, name: newName.trim() }),
+      })
+
+      if (response.ok) {
+        setProductCategories(prev => 
+          prev.map(cat => cat.id === id ? { ...cat, name: newName.trim() } : cat)
+        )
+        setEditingProductCategory(null)
+        showToast('修改成功')
+      } else {
+        const data = await response.json()
+        showToast(data.error || '修改失败', 'error')
+      }
+    } catch (error) {
+      console.error('Error updating product category:', error)
+      showToast('修改失败', 'error')
+    }
+  }
+
+  const handleDeleteProductCategory = async (id: string) => {
+    if (!confirm('确定要删除这个品类吗？')) return
+
+    try {
+      const response = await fetch(`/api/product-categories?id=${id}`, { method: 'DELETE' })
+
+      if (response.ok) {
+        setProductCategories(prev => prev.filter(cat => cat.id !== id))
+        showToast('删除成功')
+      } else {
+        const data = await response.json()
+        showToast(data.error || '删除失败', 'error')
+      }
+    } catch (error) {
+      console.error('Error deleting product category:', error)
+      showToast('删除失败', 'error')
+    }
+  }
+
+  return (
+    <div className="space-y-8">
+      {/* 使用店铺分类 */}
+      <CategorySection
+        title="使用店铺分类"
+        description="管理所有使用店铺分类名称"
+        addButtonText="新增店铺"
+        items={categories}
+        editingItem={editingCategory}
+        onAdd={() => setShowAddCategoryModal(true)}
+        onEdit={setEditingCategory}
+        onUpdate={handleUpdateCategory}
+        onDelete={handleDeleteCategory}
+        onCancelEdit={() => setEditingCategory(null)}
+      />
+
+      {/* 场景类别 */}
+      <CategorySection
+        title="场景类别"
+        description="管理所有场景类别名称"
+        addButtonText="新增场景"
+        items={scenes}
+        editingItem={editingScene}
+        onAdd={() => setShowAddSceneModal(true)}
+        onEdit={setEditingScene}
+        onUpdate={handleUpdateScene}
+        onDelete={handleDeleteScene}
+        onCancelEdit={() => setEditingScene(null)}
+      />
+
+      {/* 平台分类 */}
+      <CategorySection
+        title="平台分类"
+        description="管理所有平台分类名称"
+        addButtonText="新增平台"
+        items={platforms}
+        editingItem={editingPlatform}
+        onAdd={() => setShowAddPlatformModal(true)}
+        onEdit={setEditingPlatform}
+        onUpdate={handleUpdatePlatform}
+        onDelete={handleDeletePlatform}
+        onCancelEdit={() => setEditingPlatform(null)}
+      />
+
+      {/* 品类管理 */}
+      <CategorySection
+        title="品类管理"
+        description="管理所有品类名称"
+        addButtonText="新增品类"
+        items={productCategories}
+        editingItem={editingProductCategory}
+        onAdd={() => setShowAddProductCategoryModal(true)}
+        onEdit={setEditingProductCategory}
+        onUpdate={handleUpdateProductCategory}
+        onDelete={handleDeleteProductCategory}
+        onCancelEdit={() => setEditingProductCategory(null)}
+      />
+
+      {/* 添加弹窗 */}
+      <AddModal
+        show={showAddCategoryModal}
+        title="新增店铺分类"
+        placeholder="请输入店铺名称"
+        value={newCategoryName}
+        onChange={setNewCategoryName}
+        onConfirm={handleAddCategory}
+        onCancel={() => {
+          setShowAddCategoryModal(false)
+          setNewCategoryName('')
+        }}
+      />
+
+      <AddModal
+        show={showAddSceneModal}
+        title="新增场景类别"
+        placeholder="请输入场景名称"
+        value={newSceneName}
+        onChange={setNewSceneName}
+        onConfirm={handleAddScene}
+        onCancel={() => {
+          setShowAddSceneModal(false)
+          setNewSceneName('')
+        }}
+      />
+
+      <AddModal
+        show={showAddPlatformModal}
+        title="新增平台分类"
+        placeholder="请输入平台名称"
+        value={newPlatformName}
+        onChange={setNewPlatformName}
+        onConfirm={handleAddPlatform}
+        onCancel={() => {
+          setShowAddPlatformModal(false)
+          setNewPlatformName('')
+        }}
+      />
+
+      <AddModal
+        show={showAddProductCategoryModal}
+        title="新增品类"
+        placeholder="请输入品类名称"
+        value={newProductCategoryName}
+        onChange={setNewProductCategoryName}
+        onConfirm={handleAddProductCategory}
+        onCancel={() => {
+          setShowAddProductCategoryModal(false)
+          setNewProductCategoryName('')
+        }}
+      />
+    </div>
+  )
+}
+
+// 分类区块组件
+interface CategoryItem {
+  id: string
+  name: string
+  count: number
+}
+
+interface CategorySectionProps {
+  title: string
+  description: string
+  addButtonText: string
+  items: CategoryItem[]
+  editingItem: CategoryItem | null
+  onAdd: () => void
+  onEdit: (item: CategoryItem) => void
+  onUpdate: (id: string, newName: string) => void
+  onDelete: (id: string) => void
+  onCancelEdit: () => void
+}
+
+function CategorySection({
+  title,
+  description,
+  addButtonText,
+  items,
+  editingItem,
+  onAdd,
+  onEdit,
+  onUpdate,
+  onDelete,
+  onCancelEdit,
+}: CategorySectionProps) {
+  const [editValue, setEditValue] = useState('')
+
+  const handleStartEdit = (item: CategoryItem) => {
+    onEdit(item)
+    setEditValue(item.name)
+  }
+
+  const handleConfirmEdit = (id: string) => {
+    onUpdate(id, editValue)
+    setEditValue('')
+  }
+
+  const handleCancelEdit = () => {
+    onCancelEdit()
+    setEditValue('')
+  }
+
+  return (
+    <div className="card-apple">
+      <div className="px-6 py-4 border-b border-gray-200 flex items-center justify-between">
+        <div>
+          <h2 className="text-lg font-semibold text-gray-900 dark:text-white">{title}</h2>
+          <p className="text-sm text-gray-500 dark:text-gray-400 mt-1">{description}</p>
+        </div>
+        <button
+          onClick={onAdd}
+          className="px-4 py-2 bg-gray-900 dark:bg-gray-700 text-white text-sm rounded-lg hover:bg-gray-800 dark:hover:bg-gray-600 transition-colors flex items-center gap-2"
+        >
+          <svg className="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+            <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M12 4v16m8-8H4" />
+          </svg>
+          {addButtonText}
+        </button>
+      </div>
+      <div className="p-6">
+        <div className="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-3 gap-4">
+          {items.map((item) => (
+            <div
+              key={item.id}
+              className="border border-gray-200 dark:border-gray-600 rounded-lg p-4 hover:shadow-md transition-shadow"
+            >
+              {editingItem?.id === item.id ? (
+                <div className="space-y-3">
+                  <input
+                    type="text"
+                    value={editValue}
+                    onChange={(e) => setEditValue(e.target.value)}
+                    className="w-full px-3 py-2 border border-gray-300 dark:border-gray-600 rounded-lg focus:ring-2 focus:ring-gray-400 outline-none dark:bg-gray-700 dark:text-white"
+                    autoFocus
+                  />
+                  <div className="flex gap-2">
+                    <button
+                      onClick={() => handleConfirmEdit(item.id)}
+                      className="flex-1 px-3 py-1.5 bg-gray-900 dark:bg-gray-600 text-white text-sm rounded-lg hover:bg-gray-800 dark:hover:bg-gray-500 transition-colors"
+                    >
+                      保存
+                    </button>
+                    <button
+                      onClick={handleCancelEdit}
+                      className="flex-1 px-3 py-1.5 border border-gray-300 dark:border-gray-600 text-gray-700 dark:text-gray-300 text-sm rounded-lg hover:bg-gray-100 dark:hover:bg-gray-700 transition-colors"
+                    >
+                      取消
+                    </button>
+                  </div>
+                </div>
+              ) : (
+                <div className="flex items-center justify-between">
+                  <div>
+                    <h3 className="font-medium text-gray-900 dark:text-white">{item.name}</h3>
+                    <p className="text-sm text-gray-500 dark:text-gray-400 mt-1">{item.count} 个素材</p>
+                  </div>
+                  <div className="flex gap-2">
+                    <button
+                      onClick={() => handleStartEdit(item)}
+                      className="p-2 text-gray-600 dark:text-gray-400 hover:bg-gray-100 dark:hover:bg-gray-700 rounded-lg transition-colors"
+                    >
+                      <svg className="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                        <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M11 5H6a2 2 0 00-2 2v11a2 2 0 002 2h11a2 2 0 002-2v-5m-1.414-9.414a2 2 0 112.828 2.828L11.828 15H9v-2.828l8.586-8.586z" />
+                      </svg>
+                    </button>
+                    <button
+                      onClick={() => onDelete(item.id)}
+                      className="p-2 text-red-600 dark:text-red-400 hover:bg-red-50 dark:hover:bg-red-900/30 rounded-lg transition-colors"
+                    >
+                      <svg className="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                        <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M19 7l-.867 12.142A2 2 0 0116.138 21H7.862a2 2 0 01-1.995-1.858L5 7m5 4v6m4-6v6m1-10V4a1 1 0 00-1-1h-4a1 1 0 00-1 1v3M4 7h16" />
+                      </svg>
+                    </button>
+                  </div>
+                </div>
+              )}
+            </div>
+          ))}
+        </div>
+        {items.length === 0 && (
+          <div className="text-center py-8 text-gray-500 dark:text-gray-400">
+            暂无数据
+          </div>
+        )}
+      </div>
+    </div>
+  )
+}
+
+// 添加弹窗组件
+interface AddModalProps {
+  show: boolean
+  title: string
+  placeholder: string
+  value: string
+  onChange: (value: string) => void
+  onConfirm: () => void
+  onCancel: () => void
+}
+
+function AddModal({
+  show,
+  title,
+  placeholder,
+  value,
+  onChange,
+  onConfirm,
+  onCancel,
+}: AddModalProps) {
+  if (!show) return null
+
+  return (
+    <div className="fixed inset-0 bg-black/50 flex items-center justify-center z-50">
+      <div className="bg-white dark:bg-gray-800 rounded-lg p-6 w-96 max-w-[90vw]">
+        <h3 className="text-lg font-semibold text-gray-900 dark:text-white mb-4">{title}</h3>
+        <input
+          type="text"
+          placeholder={placeholder}
+          value={value}
+          onChange={(e) => onChange(e.target.value)}
+          className="w-full px-3 py-2 border border-gray-300 dark:border-gray-600 rounded-lg focus:ring-2 focus:ring-gray-400 outline-none dark:bg-gray-700 dark:text-white mb-4"
+          autoFocus
+          onKeyDown={(e) => {
+            if (e.key === 'Enter') onConfirm()
+            if (e.key === 'Escape') onCancel()
+          }}
+        />
+        <div className="flex justify-end gap-3">
+          <button
+            onClick={onCancel}
+            className="px-4 py-2 text-gray-600 dark:text-gray-400 hover:bg-gray-100 dark:hover:bg-gray-700 rounded-lg transition-colors"
+          >
+            取消
+          </button>
+          <button
+            onClick={onConfirm}
+            className="px-4 py-2 bg-gray-900 dark:bg-gray-600 text-white rounded-lg hover:bg-gray-800 dark:hover:bg-gray-500 transition-colors"
+          >
+            确定
+          </button>
+        </div>
+      </div>
+    </div>
+  )
+}
--- a/components/admin/DepartmentManagement.tsx
+++ b/components/admin/DepartmentManagement.tsx
@ -0,0 +1,160 @@
+/**
+ * 部门管理组件
+ * 提取自 app/admin/page.tsx 的部门管理功能
+ */
+
+'use client'
+
+import { useState } from 'react'
+import type { Department } from '@/hooks/useAdminState'
+
+interface DepartmentManagementProps {
+  departments: Department[]
+  setDepartments: React.Dispatch<React.SetStateAction<Department[]>>
+  showToast: (message: string, type?: 'success' | 'error') => void
+  fetchDepartments: () => Promise<void>
+}
+
+export default function DepartmentManagement({
+  departments,
+  setDepartments,
+  showToast,
+  fetchDepartments,
+}: DepartmentManagementProps) {
+  const [newDepartmentName, setNewDepartmentName] = useState('')
+  const [addingDepartment, setAddingDepartment] = useState(false)
+
+  // 添加部门
+  const handleAddDepartment = async () => {
+    if (!newDepartmentName.trim()) {
+      showToast('请输入部门名称', 'error')
+      return
+    }
+
+    setAddingDepartment(true)
+    try {
+      const response = await fetch('/api/departments', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ name: newDepartmentName.trim() }),
+      })
+
+      if (response.ok) {
+        await fetchDepartments()
+        setNewDepartmentName('')
+        showToast('部门添加成功')
+      } else {
+        const error = await response.json()
+        showToast(error.error || '添加失败', 'error')
+      }
+    } catch (error) {
+      console.error('Add department error:', error)
+      showToast('添加失败，请稍后重试', 'error')
+    } finally {
+      setAddingDepartment(false)
+    }
+  }
+
+  // 删除部门
+  const handleDeleteDepartment = async (id: string, name: string) => {
+    if (!confirm(`确定要删除部门"${name}"吗？`)) return
+
+    try {
+      const response = await fetch(`/api/departments?id=${id}`, {
+        method: 'DELETE',
+      })
+
+      if (response.ok) {
+        setDepartments(prev => prev.filter(d => d.id !== id))
+        showToast('部门删除成功')
+      } else {
+        const error = await response.json()
+        showToast(error.error || '删除失败', 'error')
+      }
+    } catch (error) {
+      console.error('Delete department error:', error)
+      showToast('删除失败，请稍后重试', 'error')
+    }
+  }
+
+  return (
+    <div className="card-apple">
+      <div className="px-6 py-4 border-b border-gray-200 dark:border-gray-700">
+        <h2 className="text-lg font-semibold text-gray-900 dark:text-white">部门管理</h2>
+        <p className="text-sm text-gray-500 dark:text-gray-400 mt-1">管理系统中的所有部门</p>
+      </div>
+
+      <div className="p-6">
+        {/* 添加部门 */}
+        <div className="flex gap-3 mb-6">
+          <input
+            type="text"
+            placeholder="输入新部门名称"
+            value={newDepartmentName}
+            onChange={(e) => setNewDepartmentName(e.target.value)}
+            className="flex-1 px-4 py-2 border border-gray-300 dark:border-gray-600 rounded-lg dark:bg-gray-700 dark:text-white focus:ring-2 focus:ring-gray-400 outline-none"
+            onKeyDown={(e) => {
+              if (e.key === 'Enter' && !addingDepartment) {
+                handleAddDepartment()
+              }
+            }}
+          />
+          <button
+            onClick={handleAddDepartment}
+            disabled={addingDepartment}
+            className="px-6 py-2 bg-gray-900 dark:bg-gray-700 text-white rounded-lg hover:bg-gray-800 dark:hover:bg-gray-600 transition-colors disabled:opacity-50 disabled:cursor-not-allowed flex items-center gap-2"
+          >
+            {addingDepartment ? (
+              <>
+                <svg className="animate-spin h-4 w-4" fill="none" viewBox="0 0 24 24">
+                  <circle className="opacity-25" cx="12" cy="12" r="10" stroke="currentColor" strokeWidth="4"></circle>
+                  <path className="opacity-75" fill="currentColor" d="M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4zm2 5.291A7.962 7.962 0 014 12H0c0 3.042 1.135 5.824 3 7.938l3-2.647z"></path>
+                </svg>
+                添加中...
+              </>
+            ) : (
+              <>
+                <svg className="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                  <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M12 4v16m8-8H4" />
+                </svg>
+                添加部门
+              </>
+            )}
+          </button>
+        </div>
+
+        {/* 部门列表 */}
+        <div className="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-3 gap-4">
+          {departments.map((dept) => (
+            <div
+              key={dept.id}
+              className="flex items-center justify-between p-4 border border-gray-200 dark:border-gray-600 rounded-lg hover:shadow-md transition-shadow"
+            >
+              <div className="flex items-center gap-3">
+                <svg className="w-5 h-5 text-blue-600" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                  <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M19 21V5a2 2 0 00-2-2H7a2 2 0 00-2 2v16m14 0h2m-2 0h-5m-9 0H3m2 0h5M9 7h1m-1 4h1m4-4h1m-1 4h1m-5 10v-5a1 1 0 011-1h2a1 1 0 011 1v5m-4 0h4" />
+                </svg>
+                <span className="font-medium text-gray-900 dark:text-white">{dept.name}</span>
+              </div>
+              <button
+                onClick={() => handleDeleteDepartment(dept.id, dept.name)}
+                className="p-2 text-red-600 dark:text-red-400 hover:bg-red-50 dark:hover:bg-red-900/30 rounded-lg transition-colors"
+                title="删除部门"
+              >
+                <svg className="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                  <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M19 7l-.867 12.142A2 2 0 0116.138 21H7.862a2 2 0 01-1.995-1.858L5 7m5 4v6m4-6v6m1-10V4a1 1 0 00-1-1h-4a1 1 0 00-1 1v3M4 7h16" />
+                </svg>
+              </button>
+            </div>
+          ))}
+        </div>
+
+        {departments.length === 0 && (
+          <div className="text-center py-12 text-gray-500 dark:text-gray-400">
+            暂无部门，请添加新部门
+          </div>
+        )}
+      </div>
+    </div>
+  )
+}
--- a/components/admin/MaterialManagement.tsx
+++ b/components/admin/MaterialManagement.tsx
@ -0,0 +1,456 @@
+/**
+ * 素材管理组件
+ * 提取自 app/admin/page.tsx 的素材管理功能
+ */
+
+'use client'
+
+import { useRef, useEffect, useCallback } from 'react'
+import { useRouter } from 'next/navigation'
+import { format } from 'date-fns'
+import type { Material } from '@/hooks/useAdminState'
+
+interface MaterialManagementProps {
+  materials: Material[]
+  setMaterials: React.Dispatch<React.SetStateAction<Material[]>>
+  selectedMaterials: Set<string>
+  setSelectedMaterials: React.Dispatch<React.SetStateAction<Set<string>>>
+  showRecycleBin: boolean
+  setShowRecycleBin: React.Dispatch<React.SetStateAction<boolean>>
+  materialSearchTerm: string
+  setMaterialSearchTerm: React.Dispatch<React.SetStateAction<string>>
+  displayedMaterialsCount: number
+  hasMoreMaterials: boolean
+  isLoadingMoreMaterials: boolean
+  showToast: (message: string, type?: 'success' | 'error') => void
+  searchMaterials: (searchTerm: string) => Promise<void>
+  loadMoreMaterials: () => Promise<void>
+  fetchData: () => Promise<void>
+}
+
+export default function MaterialManagement({
+  materials,
+  setMaterials,
+  selectedMaterials,
+  setSelectedMaterials,
+  showRecycleBin,
+  setShowRecycleBin,
+  materialSearchTerm,
+  setMaterialSearchTerm,
+  displayedMaterialsCount,
+  hasMoreMaterials,
+  isLoadingMoreMaterials,
+  showToast,
+  searchMaterials,
+  loadMoreMaterials,
+  fetchData,
+}: MaterialManagementProps) {
+  const router = useRouter()
+  const loadMoreRef = useRef<HTMLDivElement>(null)
+  const materialSearchDebounceRef = useRef<NodeJS.Timeout | null>(null)
+
+  // 素材搜索处理函数（局部刷新，使用防抖）
+  const handleMaterialSearchChange = useCallback((value: string) => {
+    setMaterialSearchTerm(value)
+    
+    if (materialSearchDebounceRef.current) {
+      clearTimeout(materialSearchDebounceRef.current)
+    }
+    
+    if (!value.trim()) {
+      searchMaterials('')
+      return
+    }
+    
+    materialSearchDebounceRef.current = setTimeout(() => {
+      searchMaterials(value)
+    }, 500)
+  }, [searchMaterials, setMaterialSearchTerm])
+
+  // 删除单个素材
+  const handleDeleteMaterial = async (id: string) => {
+    if (!confirm('确定要删除这个素材吗？')) return
+
+    try {
+      const response = await fetch(`/api/materials?id=${id}`, {
+        method: 'DELETE',
+      })
+
+      if (response.ok) {
+        setMaterials(prev => prev.filter(m => m.id !== id))
+        showToast('删除成功')
+      } else {
+        showToast('删除失败', 'error')
+      }
+    } catch (error) {
+      console.error('Error deleting material:', error)
+      showToast('删除失败', 'error')
+    }
+  }
+
+  // 批量删除素材
+  const handleBatchDeleteMaterials = async () => {
+    const selectedIds = Array.from(selectedMaterials)
+    if (selectedIds.length === 0) {
+      showToast('请先选择要删除的素材', 'error')
+      return
+    }
+
+    const confirmMessage = showRecycleBin
+      ? `确定要永久删除选中的 ${selectedIds.length} 条素材吗？此操作不可恢复！`
+      : `确定要删除选中的 ${selectedIds.length} 条素材吗？素材将移至回收站。`
+
+    if (!confirm(confirmMessage)) return
+
+    try {
+      const response = await fetch('/api/admin/materials/batch-delete', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          ids: selectedIds,
+          permanent: showRecycleBin,
+        }),
+      })
+
+      if (response.ok) {
+        setMaterials(prev => prev.filter(m => !selectedIds.includes(m.id)))
+        setSelectedMaterials(new Set())
+        showToast(showRecycleBin ? '批量永久删除完成' : '批量删除完成')
+      } else {
+        showToast('批量操作失败', 'error')
+      }
+    } catch (error) {
+      console.error('Batch delete materials error:', error)
+      showToast('批量操作失败', 'error')
+    }
+  }
+
+  // 切换素材选择状态
+  const toggleMaterialSelection = (id: string) => {
+    setSelectedMaterials(prev => {
+      const newSet = new Set(prev)
+      if (newSet.has(id)) {
+        newSet.delete(id)
+      } else {
+        newSet.add(id)
+      }
+      return newSet
+    })
+  }
+
+  // 全选/取消全选
+  const toggleSelectAll = () => {
+    if (materials.length > 0 && materials.every(m => selectedMaterials.has(m.id))) {
+      setSelectedMaterials(new Set())
+    } else {
+      setSelectedMaterials(new Set(materials.map(m => m.id)))
+    }
+  }
+
+  // 恢复素材
+  const handleRestoreMaterial = async (id: string) => {
+    if (!confirm('确定要恢复该素材吗？')) return
+
+    try {
+      const response = await fetch('/api/materials/restore', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ id })
+      })
+
+      if (response.ok) {
+        setMaterials(prev => prev.filter(m => m.id !== id))
+        showToast('恢复成功')
+        fetchData()
+      }
+    } catch (error) {
+      console.error('Restore material error:', error)
+      showToast('恢复失败', 'error')
+    }
+  }
+
+  // 永久删除素材
+  const handlePermanentDelete = async (id: string) => {
+    if (!confirm('确定要永久删除该素材吗？此操作不可恢复！')) return
+
+    try {
+      const response = await fetch(`/api/materials?id=${id}&permanent=true`, {
+        method: 'DELETE'
+      })
+
+      if (response.ok) {
+        setMaterials(prev => prev.filter(m => m.id !== id))
+        showToast('永久删除成功')
+        fetchData()
+      }
+    } catch (error) {
+      console.error('Permanent delete error:', error)
+      showToast('删除失败', 'error')
+    }
+  }
+
+  // 获取素材类型角标颜色
+  const getBadgeColor = (type: string) => {
+    switch (type) {
+      case '3DMAX':
+      case '3D场景':
+        return 'bg-blue-600/80'
+      case 'PSD':
+      case '详情页':
+        return 'bg-green-600/80'
+      case 'AI':
+      case '矢量文件':
+        return 'bg-amber-600/80'
+      case 'C4D':
+      case 'C4D模型':
+        return 'bg-purple-600/80'
+      case '主图视频':
+      case '安装视频':
+      case '种草视频':
+        return 'bg-red-600/80'
+      default:
+        return 'bg-black/60'
+    }
+  }
+
+  // 监听滚动，实现懒加载
+  useEffect(() => {
+    const observer = new IntersectionObserver(
+      (entries) => {
+        if (entries[0].isIntersecting && hasMoreMaterials && !isLoadingMoreMaterials) {
+          loadMoreMaterials()
+        }
+      },
+      { threshold: 0.1 }
+    )
+
+    if (loadMoreRef.current) {
+      observer.observe(loadMoreRef.current)
+    }
+
+    return () => observer.disconnect()
+  }, [hasMoreMaterials, isLoadingMoreMaterials, loadMoreMaterials])
+
+  return (
+    <div className="card-apple overflow-hidden">
+      {/* 素材搜索框和批量操作 */}
+      <div className="px-6 py-4 border-b border-gray-200 dark:border-gray-700 space-y-4">
+        {/* 搜索框 */}
+        <div className="relative">
+          <input
+            type="text"
+            placeholder="搜索素材：SPU型号、店铺、场景、作者..."
+            value={materialSearchTerm}
+            onChange={(e) => handleMaterialSearchChange(e.target.value)}
+            className="w-full pl-10 pr-4 py-2 rounded-lg border border-gray-300 dark:border-gray-600 dark:bg-gray-700 dark:text-white focus:border-blue-500 dark:focus:border-blue-400 focus:ring-2 focus:ring-blue-200 dark:focus:ring-blue-600 outline-none transition-all"
+          />
+          <svg
+            className="absolute left-3 top-1/2 transform -translate-y-1/2 w-5 h-5 text-gray-400"
+            fill="none"
+            stroke="currentColor"
+            viewBox="0 0 24 24"
+          >
+            <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M21 21l-6-6m2-5a7 7 0 11-14 0 7 7 0 0114 0z" />
+          </svg>
+          {materialSearchTerm && (
+            <button
+              onClick={() => handleMaterialSearchChange('')}
+              className="absolute right-3 top-1/2 transform -translate-y-1/2 text-gray-400 hover:text-gray-600 dark:hover:text-gray-300"
+            >
+              <svg className="w-5 h-5" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M6 18L18 6M6 6l12 12" />
+              </svg>
+            </button>
+          )}
+        </div>
+
+        {/* 批量操作工具栏 */}
+        <div className="flex items-center justify-between">
+          <div className="flex items-center gap-4">
+            <button
+              onClick={toggleSelectAll}
+              className="text-sm text-gray-600 dark:text-gray-300 hover:text-gray-900 dark:hover:text-white transition-colors"
+            >
+              {materials.length > 0 && materials.every(m => selectedMaterials.has(m.id))
+                ? '取消全选'
+                : '全选当前结果'}
+            </button>
+            {selectedMaterials.size > 0 && (
+              <button
+                onClick={handleBatchDeleteMaterials}
+                className="px-4 py-2 bg-red-600 hover:bg-red-700 text-white text-sm rounded-lg transition-colors"
+              >
+                {showRecycleBin ? '批量永久删除' : '批量删除'}
+              </button>
+            )}
+            <label className="flex items-center gap-2 text-sm text-gray-600 dark:text-gray-300">
+              <input
+                type="checkbox"
+                className="rounded"
+                checked={showRecycleBin}
+                onChange={(e) => setShowRecycleBin(e.target.checked)}
+              />
+              查看回收站
+            </label>
+          </div>
+          <span className="text-sm text-gray-500 dark:text-gray-400">
+            共 {materials.length} 个{showRecycleBin ? '（回收站）' : ''}
+          </span>
+        </div>
+      </div>
+
+      {/* 卡片网格布局 */}
+      <div className="p-4 grid grid-cols-2 sm:grid-cols-3 md:grid-cols-4 lg:grid-cols-5 gap-4">
+        {materials.slice(0, displayedMaterialsCount).map((material) => {
+          const isVideo = material.materialType === '主图视频' || 
+                          material.materialType === '安装视频' || 
+                          material.materialType === '种草视频'
+          const posterUrl = material.videoCoverUrl || material.previewUrl
+          const videoUrl = material.videoPreviewClipUrl || material.videoPreview540Url
+
+          return (
+            <div
+              key={material.id}
+              className="relative aspect-[3/4] rounded-2xl overflow-hidden bg-white dark:bg-gray-800 border border-gray-200 dark:border-gray-700 shadow hover:shadow-lg transition-shadow"
+            >
+              {/* 选择框 */}
+              <button
+                onClick={(e) => {
+                  e.stopPropagation()
+                  toggleMaterialSelection(material.id)
+                }}
+                className={`absolute z-10 top-2 left-2 w-7 h-7 rounded-full border-2 flex items-center justify-center text-xs font-semibold transition-colors ${
+                  selectedMaterials.has(material.id)
+                    ? 'bg-indigo-600 border-indigo-600 text-white'
+                    : 'bg-white/90 border-gray-300 text-transparent hover:text-gray-400'
+                }`}
+                aria-pressed={selectedMaterials.has(material.id)}
+                aria-label={selectedMaterials.has(material.id) ? '取消选择素材' : '选择素材'}
+              >
+                ✓
+              </button>
+
+              {/* 预览图/视频 */}
+              <div className="relative w-full h-full bg-gray-200 dark:bg-gray-700">
+                {isVideo && videoUrl ? (
+                  <video
+                    src={videoUrl}
+                    poster={posterUrl || undefined}
+                    className="w-full h-full object-cover"
+                    muted
+                    loop
+                    playsInline
+                    preload="metadata"
+                  />
+                ) : (
+                  <img
+                    src={material.previewUrl}
+                    alt={material.productModel}
+                    className="w-full h-full object-cover"
+                  />
+                )}
+
+                {/* 商品型号角标 */}
+                <div className="absolute top-2 left-10 bg-black/70 text-white px-2 py-1 rounded text-xs font-medium">
+                  {material.productModel}
+                </div>
+
+                {/* 素材类型角标 */}
+                {material.materialType && (
+                  <div className={`absolute top-2 right-2 text-white px-2 py-1 rounded text-xs font-medium ${getBadgeColor(material.materialType)}`}>
+                    {material.materialType}
+                  </div>
+                )}
+
+                {/* 底部信息栏 */}
+                <div className="absolute bottom-0 left-0 right-0 bg-gradient-to-t from-black/80 to-transparent p-3">
+                  <p className="text-sm font-medium text-white truncate mb-1">
+                    {material.sceneName}
+                  </p>
+                  <div className="flex items-center justify-between text-xs text-white/80">
+                    <span className="truncate">{material.authorName}</span>
+                    <span className="ml-2 flex-shrink-0">
+                      {format(new Date(material.createdAt), 'MM-dd')}
+                    </span>
+                  </div>
+                </div>
+
+                {/* 操作按钮（悬停显示） */}
+                <div className="absolute inset-0 bg-black/60 opacity-0 hover:opacity-100 transition-opacity flex items-center justify-center gap-3">
+                  {showRecycleBin ? (
+                    <>
+                      <button
+                        onClick={(e) => {
+                          e.stopPropagation()
+                          handleRestoreMaterial(material.id)
+                        }}
+                        className="px-4 py-2 bg-green-600 hover:bg-green-700 text-white text-sm rounded-lg transition-colors"
+                      >
+                        恢复
+                      </button>
+                      <button
+                        onClick={(e) => {
+                          e.stopPropagation()
+                          handlePermanentDelete(material.id)
+                        }}
+                        className="px-4 py-2 bg-red-600 hover:bg-red-700 text-white text-sm rounded-lg transition-colors"
+                      >
+                        永久删除
+                      </button>
+                    </>
+                  ) : (
+                    <>
+                      <button
+                        onClick={(e) => {
+                          e.stopPropagation()
+                          router.push(`/edit/${material.id}`)
+                        }}
+                        className="px-4 py-2 bg-blue-600 hover:bg-blue-700 text-white text-sm rounded-lg transition-colors"
+                      >
+                        编辑
+                      </button>
+                      <button
+                        onClick={(e) => {
+                          e.stopPropagation()
+                          handleDeleteMaterial(material.id)
+                        }}
+                        className="px-4 py-2 bg-red-600 hover:bg-red-700 text-white text-sm rounded-lg transition-colors"
+                      >
+                        删除
+                      </button>
+                    </>
+                  )}
+                </div>
+              </div>
+            </div>
+          )
+        })}
+      </div>
+
+      {/* 加载更多触发器 */}
+      {(displayedMaterialsCount < materials.length || hasMoreMaterials) && (
+        <div ref={loadMoreRef} className="py-8 text-center">
+          <div className="inline-flex items-center gap-2 text-gray-500 dark:text-gray-400">
+            {isLoadingMoreMaterials ? (
+              <>
+                <svg className="animate-spin h-5 w-5" fill="none" viewBox="0 0 24 24">
+                  <circle className="opacity-25" cx="12" cy="12" r="10" stroke="currentColor" strokeWidth="4"></circle>
+                  <path className="opacity-75" fill="currentColor" d="M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4zm2 5.291A7.962 7.962 0 014 12H0c0 3.042 1.135 5.824 3 7.938l3-2.647z"></path>
+                </svg>
+                <span>加载中...</span>
+              </>
+            ) : (
+              <span>滚动加载更多...</span>
+            )}
+          </div>
+        </div>
+      )}
+
+      {materials.length === 0 && (
+        <div className="text-center py-8 text-gray-500 dark:text-gray-400">
+          暂无素材
+        </div>
+      )}
+    </div>
+  )
+}
--- a/components/admin/UserManagement.tsx
+++ b/components/admin/UserManagement.tsx
@ -0,0 +1,576 @@
+/**
+ * 用户管理组件
+ * 提取自 app/admin/page.tsx 的用户管理功能
+ */
+
+'use client'
+
+import { useState, useCallback } from 'react'
+import { format } from 'date-fns'
+import type { User, Department } from '@/hooks/useAdminState'
+
+interface UserManagementProps {
+  users: User[]
+  setUsers: React.Dispatch<React.SetStateAction<User[]>>
+  departments: Department[]
+  userSearchTerm: string
+  setUserSearchTerm: React.Dispatch<React.SetStateAction<string>>
+  collapsedDepartments: Set<string>
+  collapsedAdmins: Set<string>
+  toggleDepartmentCollapse: (dept: string) => void
+  toggleAdminCollapse: (adminId: string) => void
+  showToast: (message: string, type?: 'success' | 'error') => void
+  fetchData: () => Promise<void>
+  currentUserEmail?: string
+}
+
+export default function UserManagement({
+  users,
+  setUsers,
+  departments,
+  userSearchTerm,
+  setUserSearchTerm,
+  collapsedDepartments,
+  collapsedAdmins,
+  toggleDepartmentCollapse,
+  toggleAdminCollapse,
+  showToast,
+  fetchData,
+  currentUserEmail,
+}: UserManagementProps) {
+  // 编辑用户部门
+  const [editingUser, setEditingUser] = useState<User | null>(null)
+  const [selectedDepartment, setSelectedDepartment] = useState('')
+
+  // 组织用户树形结构数据
+  const getUserTreeData = useCallback(() => {
+    const admins = users.filter(u => u.role === 'ADMIN')
+    const allDepartmentNames = Array.from(new Set(users.map(u => u.department).filter(d => d)))
+    
+    return {
+      admins,
+      departments: allDepartmentNames,
+      getUsersByDepartment: (deptName: string) => 
+        users.filter(u => u.department === deptName && u.role !== 'ADMIN'),
+      getDepartmentsByAdmin: (adminId: string) => {
+        const admin = users.find(u => u.id === adminId)
+        if (!admin || !admin.managedDepartment) return []
+        return [admin.managedDepartment]
+      },
+      getUnmanagedDepartments: () => {
+        const managedDepts = new Set(
+          admins.map(a => a.managedDepartment).filter(Boolean)
+        )
+        return allDepartmentNames.filter(d => !managedDepts.has(d))
+      }
+    }
+  }, [users])
+
+  // 编辑用户部门
+  const handleEditUserDepartment = (user: User) => {
+    setEditingUser(user)
+    setSelectedDepartment(user.department || '')
+  }
+
+  // 更新用户部门
+  const handleUpdateUserDepartment = async () => {
+    if (!editingUser) return
+
+    try {
+      const response = await fetch('/api/admin/users/update-department', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          userId: editingUser.id,
+          department: selectedDepartment,
+        }),
+      })
+
+      if (response.ok) {
+        setUsers(prevUsers =>
+          prevUsers.map(u =>
+            u.id === editingUser.id
+              ? { ...u, department: selectedDepartment }
+              : u
+          )
+        )
+        setEditingUser(null)
+        setSelectedDepartment('')
+        showToast('部门更新成功')
+      } else {
+        const error = await response.json()
+        showToast(error.error || '更新失败', 'error')
+      }
+    } catch (error) {
+      console.error('Update department error:', error)
+      showToast('更新失败，请稍后重试', 'error')
+    }
+  }
+
+  // 删除用户
+  const handleDeleteUser = async (id: string) => {
+    if (!confirm('确定要删除这个用户吗？该用户的所有素材也会被删除。')) return
+
+    try {
+      const response = await fetch(`/api/admin/users?id=${id}`, {
+        method: 'DELETE',
+      })
+
+      if (response.ok) {
+        setUsers(prevUsers => prevUsers.filter(u => u.id !== id))
+        showToast('删除成功')
+      } else {
+        const data = await response.json()
+        showToast(data.error || '删除失败', 'error')
+      }
+    } catch (error) {
+      console.error('Error deleting user:', error)
+      showToast('删除失败', 'error')
+    }
+  }
+
+  // 切换下载权限
+  const handleToggleDownload = async (userId: string, currentCanDownload: boolean) => {
+    const action = currentCanDownload ? '关闭' : '开启'
+    if (!confirm(`确定要${action}该用户的下载权限吗？`)) return
+
+    try {
+      const response = await fetch('/api/admin/users/toggle-download', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ userId }),
+      })
+
+      if (response.ok) {
+        setUsers(prevUsers => 
+          prevUsers.map(user => 
+            user.id === userId 
+              ? { ...user, canDownload: !currentCanDownload }
+              : user
+          )
+        )
+        showToast(`下载权限已${action}`)
+      } else {
+        const data = await response.json()
+        showToast(data.error || '操作失败', 'error')
+      }
+    } catch (error) {
+      console.error('Error toggling download permission:', error)
+      showToast('操作失败', 'error')
+    }
+  }
+
+  // 切换激活状态
+  const handleToggleActive = async (userId: string, currentStatus: boolean) => {
+    const action = currentStatus ? '禁用' : '激活'
+    if (!confirm(`确定要${action}这个用户吗？`)) return
+
+    try {
+      const response = await fetch('/api/admin/users/toggle-active', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          userId,
+          isActive: !currentStatus,
+        }),
+      })
+
+      if (response.ok) {
+        setUsers(prevUsers => 
+          prevUsers.map(user => 
+            user.id === userId 
+              ? { ...user, isActive: !currentStatus }
+              : user
+          )
+        )
+        showToast(`${action}成功`)
+      } else {
+        const data = await response.json()
+        showToast(data.error || `${action}失败`, 'error')
+      }
+    } catch (error) {
+      console.error('Toggle active error:', error)
+      showToast(`${action}失败`, 'error')
+    }
+  }
+
+  // 设置角色
+  const handleSetRole = async (userId: string, currentRole: string) => {
+    const newRole = currentRole === 'ADMIN' ? 'USER' : 'ADMIN'
+    const action = newRole === 'ADMIN' ? '设置为管理员' : '取消管理员权限'
+    
+    if (!confirm(`确定要${action}吗？`)) return
+
+    try {
+      const response = await fetch('/api/admin/users/set-role', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          userId,
+          role: newRole,
+        }),
+      })
+
+      if (response.ok) {
+        setUsers(prevUsers => 
+          prevUsers.map(user => 
+            user.id === userId 
+              ? { ...user, role: newRole }
+              : user
+          )
+        )
+        showToast(`${action}成功`)
+      } else {
+        const data = await response.json()
+        showToast(data.error || `${action}失败`, 'error')
+      }
+    } catch (error) {
+      console.error('Set role error:', error)
+      showToast(`${action}失败`, 'error')
+    }
+  }
+
+  const treeData = getUserTreeData()
+  const filteredUsers = users.filter(user => {
+    if (!userSearchTerm) return true
+    const searchLower = userSearchTerm.toLowerCase()
+    return user.username.toLowerCase().includes(searchLower) ||
+           (user.department && user.department.toLowerCase().includes(searchLower)) ||
+           ((user as any).realName && (user as any).realName.toLowerCase().includes(searchLower)) ||
+           (user.email && user.email.toLowerCase().includes(searchLower))
+  })
+
+  return (
+    <div className="card-apple overflow-hidden">
+      {/* 用户搜索框 */}
+      <div className="p-4 border-b border-gray-200 dark:border-gray-700">
+        <div className="relative">
+          <input
+            type="text"
+            placeholder="搜索用户名或部门..."
+            value={userSearchTerm}
+            onChange={(e) => setUserSearchTerm(e.target.value)}
+            className="w-full px-4 py-2 pl-10 rounded-apple border border-gray-300 dark:border-gray-600 dark:bg-gray-700 dark:text-white focus:border-gray-900 dark:focus:border-gray-400 focus:ring-2 focus:ring-gray-200 dark:focus:ring-gray-600 outline-none"
+          />
+          <svg className="absolute left-3 top-2.5 w-5 h-5 text-gray-400" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+            <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M21 21l-6-6m2-5a7 7 0 11-14 0 7 7 0 0114 0z" />
+          </svg>
+        </div>
+      </div>
+
+      {/* 树形结构显示 */}
+      <div className="p-6">
+        <div className="space-y-2">
+          {/* 第一层：管理员列表 */}
+          {treeData.admins
+            .filter(admin => !userSearchTerm || filteredUsers.some(u => u.id === admin.id))
+            .map((admin) => {
+              const managedDepts = treeData.getDepartmentsByAdmin(admin.id)
+              const isCollapsed = collapsedAdmins.has(admin.id)
+              
+              return (
+                <div key={admin.id} className="border border-gray-200 dark:border-gray-600 rounded-lg overflow-hidden">
+                  {/* 管理员行 */}
+                  <div className="bg-purple-50 dark:bg-purple-900/20 p-4">
+                    <div className="flex items-center gap-3">
+                      {managedDepts.length > 0 && (
+                        <button
+                          onClick={() => toggleAdminCollapse(admin.id)}
+                          className="flex-shrink-0 w-6 h-6 flex items-center justify-center hover:bg-purple-200 dark:hover:bg-purple-800 rounded transition-colors"
+                        >
+                          <svg className={`w-4 h-4 transform transition-transform ${isCollapsed ? '' : 'rotate-90'}`} fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                            <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M9 5l7 7-7 7" />
+                          </svg>
+                        </button>
+                      )}
+                      
+                      <div className="flex-1">
+                        <div className="flex items-center gap-2">
+                          <span className="font-semibold text-gray-900 dark:text-white">{admin.username}</span>
+                          <span className="px-2 py-0.5 bg-purple-600 text-white text-xs rounded-full">管理员</span>
+                          {admin.managedDepartment && (
+                            <span className="px-2 py-0.5 bg-blue-100 dark:bg-blue-900 text-blue-800 dark:text-blue-200 text-xs rounded-full">
+                              负责: {admin.managedDepartment}
+                            </span>
+                          )}
+                        </div>
+                        <div className="text-sm text-gray-600 dark:text-gray-400 mt-1">
+                          部门: {admin.department || '未分配'} | 素材: {admin._count.materials} | 
+                          注册: {format(new Date(admin.createdAt), 'yyyy-MM-dd')}
+                        </div>
+                      </div>
+                      
+                      {admin.email !== currentUserEmail && (
+                        <div className="flex items-center gap-2">
+                          <button
+                            onClick={() => handleEditUserDepartment(admin)}
+                            className="px-3 py-1 text-xs bg-blue-100 dark:bg-blue-900 text-blue-700 dark:text-blue-300 rounded hover:bg-blue-200 dark:hover:bg-blue-800 transition-colors"
+                          >
+                            编辑部门
+                          </button>
+                          <button
+                            onClick={() => handleSetRole(admin.id, admin.role)}
+                            className="px-3 py-1 text-xs bg-orange-100 dark:bg-orange-900 text-orange-700 dark:text-orange-300 rounded hover:bg-orange-200 dark:hover:bg-orange-800 transition-colors"
+                          >
+                            取消管理员
+                          </button>
+                          <button
+                            onClick={() => handleToggleActive(admin.id, admin.isActive)}
+                            className="px-3 py-1 text-xs bg-gray-100 dark:bg-gray-700 text-gray-700 dark:text-gray-300 rounded hover:bg-gray-200 dark:hover:bg-gray-600 transition-colors"
+                          >
+                            {admin.isActive ? '禁用' : '激活'}
+                          </button>
+                        </div>
+                      )}
+                    </div>
+                  </div>
+
+                  {/* 第二层：管理员负责的部门 */}
+                  {!isCollapsed && managedDepts.map((deptName) => {
+                    const deptUsers = treeData.getUsersByDepartment(deptName)
+                      .filter(u => !userSearchTerm || filteredUsers.some(fu => fu.id === u.id))
+                    const isDeptCollapsed = collapsedDepartments.has(deptName)
+                    
+                    return (
+                      <div key={deptName} className="border-t border-gray-200 dark:border-gray-700">
+                        <div className="bg-blue-50 dark:bg-blue-900/20 p-4 pl-12">
+                          <div className="flex items-center gap-3">
+                            {deptUsers.length > 0 && (
+                              <button
+                                onClick={() => toggleDepartmentCollapse(deptName)}
+                                className="flex-shrink-0 w-5 h-5 flex items-center justify-center hover:bg-blue-200 dark:hover:bg-blue-800 rounded transition-colors"
+                              >
+                                <svg className={`w-3 h-3 transform transition-transform ${isDeptCollapsed ? '' : 'rotate-90'}`} fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                                  <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M9 5l7 7-7 7" />
+                                </svg>
+                              </button>
+                            )}
+                            
+                            <div className="flex-1">
+                              <div className="flex items-center gap-2">
+                                <svg className="w-5 h-5 text-blue-600" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                                  <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M19 21V5a2 2 0 00-2-2H7a2 2 0 00-2 2v16m14 0h2m-2 0h-5m-9 0H3m2 0h5M9 7h1m-1 4h1m4-4h1m-1 4h1m-5 10v-5a1 1 0 011-1h2a1 1 0 011 1v5m-4 0h4" />
+                                </svg>
+                                <span className="font-medium text-gray-900 dark:text-white">{deptName}</span>
+                                <span className="text-xs text-gray-500 dark:text-gray-400">({deptUsers.length} 人)</span>
+                              </div>
+                            </div>
+                          </div>
+                        </div>
+
+                        {/* 第三层：部门下的用户 */}
+                        {!isDeptCollapsed && deptUsers.map((user) => (
+                          <UserRow
+                            key={user.id}
+                            user={user}
+                            indentLevel={3}
+                            onEditDepartment={handleEditUserDepartment}
+                            onSetRole={handleSetRole}
+                            onToggleActive={handleToggleActive}
+                            onToggleDownload={handleToggleDownload}
+                            onDelete={handleDeleteUser}
+                          />
+                        ))}
+                      </div>
+                    )
+                  })}
+                </div>
+              )
+            })}
+
+          {/* 未分配管理员的部门 */}
+          {treeData.getUnmanagedDepartments()
+            .filter(deptName => {
+              if (!userSearchTerm) return true
+              const deptUsers = treeData.getUsersByDepartment(deptName)
+              return deptUsers.some(u => filteredUsers.some(fu => fu.id === u.id))
+            })
+            .map((deptName) => {
+              const deptUsers = treeData.getUsersByDepartment(deptName)
+                .filter(u => !userSearchTerm || filteredUsers.some(fu => fu.id === u.id))
+              const isDeptCollapsed = collapsedDepartments.has(deptName)
+              
+              return (
+                <div key={deptName} className="border border-gray-200 dark:border-gray-600 rounded-lg overflow-hidden">
+                  <div className="bg-yellow-50 dark:bg-yellow-900/20 p-4">
+                    <div className="flex items-center gap-3">
+                      {deptUsers.length > 0 && (
+                        <button
+                          onClick={() => toggleDepartmentCollapse(deptName)}
+                          className="flex-shrink-0 w-6 h-6 flex items-center justify-center hover:bg-yellow-200 dark:hover:bg-yellow-800 rounded transition-colors"
+                        >
+                          <svg className={`w-4 h-4 transform transition-transform ${isDeptCollapsed ? '' : 'rotate-90'}`} fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                            <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M9 5l7 7-7 7" />
+                          </svg>
+                        </button>
+                      )}
+                      
+                      <div className="flex-1">
+                        <div className="flex items-center gap-2">
+                          <svg className="w-5 h-5 text-yellow-600" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                            <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M19 21V5a2 2 0 00-2-2H7a2 2 0 00-2 2v16m14 0h2m-2 0h-5m-9 0H3m2 0h5M9 7h1m-1 4h1m4-4h1m-1 4h1m-5 10v-5a1 1 0 011-1h2a1 1 0 011 1v5m-4 0h4" />
+                          </svg>
+                          <span className="font-medium text-gray-900 dark:text-white">{deptName}</span>
+                          <span className="px-2 py-0.5 bg-yellow-100 dark:bg-yellow-900 text-yellow-800 dark:text-yellow-200 text-xs rounded-full">未分配管理员</span>
+                          <span className="text-xs text-gray-500 dark:text-gray-400">({deptUsers.length} 人)</span>
+                        </div>
+                      </div>
+                    </div>
+                  </div>
+
+                  {!isDeptCollapsed && deptUsers.map((user) => (
+                    <UserRow
+                      key={user.id}
+                      user={user}
+                      indentLevel={2}
+                      onEditDepartment={handleEditUserDepartment}
+                      onSetRole={handleSetRole}
+                      onToggleActive={handleToggleActive}
+                      onToggleDownload={handleToggleDownload}
+                      onDelete={handleDeleteUser}
+                    />
+                  ))}
+                </div>
+              )
+            })}
+
+          {users.length === 0 && (
+            <div className="text-center py-12 text-gray-500 dark:text-gray-400">
+              暂无用户
+            </div>
+          )}
+        </div>
+      </div>
+
+      {/* 编辑部门弹窗 */}
+      {editingUser && (
+        <div className="fixed inset-0 bg-black/50 flex items-center justify-center z-50">
+          <div className="bg-white dark:bg-gray-800 rounded-lg p-6 w-96 max-w-[90vw]">
+            <h3 className="text-lg font-semibold text-gray-900 dark:text-white mb-4">
+              编辑用户部门
+            </h3>
+            <p className="text-sm text-gray-600 dark:text-gray-400 mb-4">
+              用户: {editingUser.username}
+            </p>
+            <select
+              value={selectedDepartment}
+              onChange={(e) => setSelectedDepartment(e.target.value)}
+              className="w-full px-3 py-2 border border-gray-300 dark:border-gray-600 rounded-lg dark:bg-gray-700 dark:text-white mb-4"
+            >
+              <option value="">未分配</option>
+              {departments.map(dept => (
+                <option key={dept.id} value={dept.name}>{dept.name}</option>
+              ))}
+            </select>
+            <div className="flex justify-end gap-3">
+              <button
+                onClick={() => {
+                  setEditingUser(null)
+                  setSelectedDepartment('')
+                }}
+                className="px-4 py-2 text-gray-600 dark:text-gray-400 hover:bg-gray-100 dark:hover:bg-gray-700 rounded-lg transition-colors"
+              >
+                取消
+              </button>
+              <button
+                onClick={handleUpdateUserDepartment}
+                className="px-4 py-2 bg-blue-600 text-white rounded-lg hover:bg-blue-700 transition-colors"
+              >
+                保存
+              </button>
+            </div>
+          </div>
+        </div>
+      )}
+    </div>
+  )
+}
+
+// 用户行组件
+interface UserRowProps {
+  user: User
+  indentLevel: number
+  onEditDepartment: (user: User) => void
+  onSetRole: (userId: string, currentRole: string) => void
+  onToggleActive: (userId: string, currentStatus: boolean) => void
+  onToggleDownload: (userId: string, currentCanDownload: boolean) => void
+  onDelete: (userId: string) => void
+}
+
+function UserRow({
+  user,
+  indentLevel,
+  onEditDepartment,
+  onSetRole,
+  onToggleActive,
+  onToggleDownload,
+  onDelete,
+}: UserRowProps) {
+  const paddingLeft = indentLevel === 3 ? 'pl-20' : 'pl-12'
+  
+  return (
+    <div className={`bg-white dark:bg-gray-800 p-4 ${paddingLeft} border-t border-gray-100 dark:border-gray-700 hover:bg-gray-50 dark:hover:bg-gray-750 transition-colors`}>
+      <div className="flex items-center gap-3">
+        <svg className="w-4 h-4 text-gray-400" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+          <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M16 7a4 4 0 11-8 0 4 4 0 018 0zM12 14a7 7 0 00-7 7h14a7 7 0 00-7-7z" />
+        </svg>
+        
+        <div className="flex-1">
+          <div className="flex items-center gap-2">
+            <span className="text-sm font-medium text-gray-900 dark:text-white">{user.username}</span>
+            <span className={`px-2 py-0.5 text-xs rounded-full ${
+              user.isActive 
+                ? 'bg-green-100 dark:bg-green-900 text-green-800 dark:text-green-200' 
+                : 'bg-red-100 dark:bg-red-900 text-red-800 dark:text-red-200'
+            }`}>
+              {user.isActive ? '已激活' : '未激活'}
+            </span>
+            <span className={`px-2 py-0.5 text-xs rounded-full ${
+              user.canDownload 
+                ? 'bg-blue-100 dark:bg-blue-900 text-blue-800 dark:text-blue-200' 
+                : 'bg-gray-100 dark:bg-gray-700 text-gray-800 dark:text-gray-300'
+            }`}>
+              {user.canDownload ? '可下载' : '禁止下载'}
+            </span>
+          </div>
+          <div className="text-xs text-gray-500 dark:text-gray-400 mt-1">
+            素材: {user._count.materials} | 注册: {format(new Date(user.createdAt), 'yyyy-MM-dd')}
+          </div>
+        </div>
+        
+        <div className="flex items-center gap-2">
+          <button
+            onClick={() => onEditDepartment(user)}
+            className="px-2 py-1 text-xs text-blue-600 dark:text-blue-400 hover:bg-blue-50 dark:hover:bg-blue-900/30 rounded transition-colors"
+          >
+            编辑
+          </button>
+          <button
+            onClick={() => onSetRole(user.id, user.role)}
+            className="px-2 py-1 text-xs text-purple-600 dark:text-purple-400 hover:bg-purple-50 dark:hover:bg-purple-900/30 rounded transition-colors"
+          >
+            设为管理员
+          </button>
+          <button
+            onClick={() => onToggleActive(user.id, user.isActive)}
+            className="px-2 py-1 text-xs text-gray-600 dark:text-gray-400 hover:bg-gray-100 dark:hover:bg-gray-700 rounded transition-colors"
+          >
+            {user.isActive ? '禁用' : '激活'}
+          </button>
+          <button
+            onClick={() => onToggleDownload(user.id, user.canDownload)}
+            className="px-2 py-1 text-xs text-yellow-600 dark:text-yellow-400 hover:bg-yellow-50 dark:hover:bg-yellow-900/30 rounded transition-colors"
+          >
+            {user.canDownload ? '禁止下载' : '允许下载'}
+          </button>
+          <button
+            onClick={() => onDelete(user.id)}
+            className="px-2 py-1 text-xs text-red-600 dark:text-red-400 hover:bg-red-50 dark:hover:bg-red-900/30 rounded transition-colors"
+          >
+            删除
+          </button>
+        </div>
+      </div>
+    </div>
+  )
+}
--- a/components/home/FilterPanel.tsx
+++ b/components/home/FilterPanel.tsx
@ -0,0 +1,151 @@
+'use client'
+
+import { memo, useCallback } from 'react'
+
+export interface CategoryItem {
+  id: string
+  name: string
+  count: number
+}
+
+export interface MonthItem {
+  value: string
+  label: string
+  count: number
+}
+
+interface FilterPanelProps {
+  selectedMaterialType: string
+  setSelectedMaterialType: (value: string) => void
+  selectedCategory: string
+  setSelectedCategory: (value: string) => void
+  selectedScene: string
+  setSelectedScene: (value: string) => void
+  selectedPlatform: string
+  setSelectedPlatform: (value: string) => void
+  selectedProductCategory: string
+  setSelectedProductCategory: (value: string) => void
+  selectedMonth: string
+  setSelectedMonth: (value: string) => void
+  sortBy: string
+  setSortBy: (value: string) => void
+  sortOrder: 'desc' | 'asc'
+  setSortOrder: (value: 'desc' | 'asc') => void
+  materialTypes: { value: string; label: string }[]
+  categories: CategoryItem[]
+  scenes: CategoryItem[]
+  platforms: CategoryItem[]
+  productCategories: CategoryItem[]
+  months: MonthItem[]
+  totalMaterialsCount: number
+  materialsCount: number
+  isFilterCollapsed: boolean
+  setIsFilterCollapsed: (value: boolean) => void
+  themeColor: string
+}
+
+function FilterPanel(props: FilterPanelProps) {
+  const {
+    selectedMaterialType, setSelectedMaterialType,
+    selectedCategory, setSelectedCategory,
+    selectedScene, setSelectedScene,
+    selectedPlatform, setSelectedPlatform,
+    selectedProductCategory, setSelectedProductCategory,
+    selectedMonth, setSelectedMonth,
+    sortBy, setSortBy, sortOrder, setSortOrder,
+    materialTypes, categories, scenes, platforms, productCategories, months,
+    totalMaterialsCount, materialsCount,
+    isFilterCollapsed, setIsFilterCollapsed, themeColor,
+  } = props
+
+  const handleSortChange = useCallback((newSortBy: string) => {
+    if (sortBy === newSortBy) {
+      setSortOrder(sortOrder === 'desc' ? 'asc' : 'desc')
+    } else {
+      setSortBy(newSortBy)
+      setSortOrder('desc')
+    }
+  }, [sortBy, sortOrder, setSortBy, setSortOrder])
+
+  const activeFilterCount = [selectedCategory, selectedScene, selectedPlatform, selectedProductCategory, selectedMonth].filter(Boolean).length
+  const btnBase = 'px-4 py-2 rounded-full text-sm font-medium transition-all'
+  const btnActive = 'text-white'
+  const btnInactive = 'bg-white dark:bg-gray-800 text-gray-700 dark:text-gray-300 border border-gray-300 dark:border-gray-600 hover:bg-gray-50 dark:hover:bg-gray-700'
+
+  return (
+    <>
+      <div className="mb-4">
+        <div className="flex items-center justify-between mb-3">
+          <h2 className="text-sm font-medium text-gray-700 dark:text-gray-300">类型分页</h2>
+          {selectedMaterialType && <span className="text-xs text-gray-500 dark:text-gray-400">{materialsCount} 个素材</span>}
+        </div>
+        <div className="flex flex-wrap gap-2">
+          <button onClick={() => setSelectedMaterialType('')} className={`${btnBase} ${selectedMaterialType === '' ? btnActive : btnInactive}`} style={selectedMaterialType === '' ? { backgroundColor: themeColor } : {}}>全部</button>
+          {materialTypes.map((type) => (
+            <button key={type.value} onClick={() => setSelectedMaterialType(type.value === selectedMaterialType ? '' : type.value)} className={`${btnBase} ${selectedMaterialType === type.value ? btnActive : btnInactive}`} style={selectedMaterialType === type.value ? { backgroundColor: themeColor } : {}}>{type.label}</button>
+          ))}
+        </div>
+      </div>
+      <div className="mb-4 border-t border-gray-200 dark:border-gray-700 pt-4">
+        <button onClick={() => setIsFilterCollapsed(!isFilterCollapsed)} className="flex items-center gap-2 px-4 py-2 text-sm font-medium text-gray-600 dark:text-gray-400 hover:text-gray-900 dark:hover:text-gray-200 transition-colors">
+          <svg className={`w-4 h-4 transition-transform duration-200 ${isFilterCollapsed ? '' : 'rotate-180'}`} fill="none" stroke="currentColor" viewBox="0 0 24 24"><path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M19 9l-7 7-7-7" /></svg>
+          {isFilterCollapsed ? '展开更多筛选' : '收起筛选'}
+          {isFilterCollapsed && activeFilterCount > 0 && <span className="ml-1 px-1.5 py-0.5 bg-blue-100 dark:bg-blue-900/30 text-blue-600 dark:text-blue-400 rounded text-xs">{activeFilterCount}</span>}
+        </button>
+      </div>
+      <div className={`overflow-hidden transition-all duration-300 ${isFilterCollapsed ? 'max-h-0 opacity-0' : 'max-h-[2000px] opacity-100'}`}>
+        <div className="mb-4">
+          <div className="flex items-center justify-between mb-3"><h2 className="text-sm font-medium text-gray-700 dark:text-gray-300">使用店铺</h2>{selectedCategory && <span className="text-xs text-gray-500 dark:text-gray-400">{materialsCount} 个素材</span>}</div>
+          <div className="flex flex-wrap gap-2">
+            <button onClick={() => setSelectedCategory('')} className={`${btnBase} ${selectedCategory === '' ? btnActive : btnInactive}`} style={selectedCategory === '' ? { backgroundColor: themeColor } : {}}>全部<span className={`ml-1.5 text-xs ${selectedCategory === '' ? 'text-gray-300' : 'text-gray-500 dark:text-gray-400'}`}>({totalMaterialsCount})</span></button>
+            {categories.map((c) => <button key={c.id} onClick={() => setSelectedCategory(c.name === selectedCategory ? '' : c.name)} className={`${btnBase} ${selectedCategory === c.name ? btnActive : btnInactive}`} style={selectedCategory === c.name ? { backgroundColor: themeColor } : {}}>{c.name}<span className={`ml-1.5 text-xs ${selectedCategory === c.name ? 'text-gray-300' : 'text-gray-500 dark:text-gray-400'}`}>({c.count || 0})</span></button>)}
+          </div>
+        </div>
+        <div className="mb-4">
+          <div className="flex items-center justify-between mb-3"><h2 className="text-sm font-medium text-gray-700 dark:text-gray-300">场景类别</h2>{selectedScene && <span className="text-xs text-gray-500 dark:text-gray-400">{materialsCount} 个素材</span>}</div>
+          <div className="flex flex-wrap gap-2">
+            <button onClick={() => setSelectedScene('')} className={`${btnBase} ${selectedScene === '' ? btnActive : btnInactive}`} style={selectedScene === '' ? { backgroundColor: themeColor } : {}}>全部<span className={`ml-1.5 text-xs ${selectedScene === '' ? 'text-gray-300' : 'text-gray-500 dark:text-gray-400'}`}>({totalMaterialsCount})</span></button>
+            {scenes.map((s) => <button key={s.id} onClick={() => setSelectedScene(s.name === selectedScene ? '' : s.name)} className={`${btnBase} ${selectedScene === s.name ? btnActive : btnInactive}`} style={selectedScene === s.name ? { backgroundColor: themeColor } : {}}>{s.name}<span className={`ml-1.5 text-xs ${selectedScene === s.name ? 'text-gray-300' : 'text-gray-500 dark:text-gray-400'}`}>({s.count || 0})</span></button>)}
+          </div>
+        </div>
+        {platforms.length > 0 && <div className="mb-4">
+          <div className="flex items-center justify-between mb-3"><h2 className="text-sm font-medium text-gray-700 dark:text-gray-300">平台分类</h2>{selectedPlatform && <span className="text-xs text-gray-500 dark:text-gray-400">{materialsCount} 个素材</span>}</div>
+          <div className="flex flex-wrap gap-2">
+            <button onClick={() => setSelectedPlatform('')} className={`${btnBase} ${selectedPlatform === '' ? btnActive : btnInactive}`} style={selectedPlatform === '' ? { backgroundColor: themeColor } : {}}>全部<span className={`ml-1.5 text-xs ${selectedPlatform === '' ? 'text-gray-300' : 'text-gray-500 dark:text-gray-400'}`}>({totalMaterialsCount})</span></button>
+            {platforms.map((p) => <button key={p.id} onClick={() => setSelectedPlatform(p.name === selectedPlatform ? '' : p.name)} className={`${btnBase} ${selectedPlatform === p.name ? btnActive : btnInactive}`} style={selectedPlatform === p.name ? { backgroundColor: themeColor } : {}}>{p.name}<span className={`ml-1.5 text-xs ${selectedPlatform === p.name ? 'text-gray-300' : 'text-gray-500 dark:text-gray-400'}`}>({p.count || 0})</span></button>)}
+          </div>
+        </div>}
+        {productCategories.length > 0 && <div className="mb-4">
+          <div className="flex items-center justify-between mb-3"><h2 className="text-sm font-medium text-gray-700 dark:text-gray-300">产品类别</h2>{selectedProductCategory && <span className="text-xs text-gray-500 dark:text-gray-400">{materialsCount} 个素材</span>}</div>
+          <div className="flex flex-wrap gap-2">
+            <button onClick={() => setSelectedProductCategory('')} className={`${btnBase} ${selectedProductCategory === '' ? btnActive : btnInactive}`} style={selectedProductCategory === '' ? { backgroundColor: themeColor } : {}}>全部<span className={`ml-1.5 text-xs ${selectedProductCategory === '' ? 'text-gray-300' : 'text-gray-500 dark:text-gray-400'}`}>({productCategories.reduce((sum, cat) => sum + (cat.count || 0), 0)})</span></button>
+            {productCategories.map((c) => <button key={c.id} onClick={() => setSelectedProductCategory(c.name === selectedProductCategory ? '' : c.name)} className={`${btnBase} ${selectedProductCategory === c.name ? btnActive : btnInactive}`} style={selectedProductCategory === c.name ? { backgroundColor: themeColor } : {}}>{c.name}<span className={`ml-1.5 text-xs ${selectedProductCategory === c.name ? 'text-gray-300' : 'text-gray-500 dark:text-gray-400'}`}>({c.count || 0})</span></button>)}
+          </div>
+        </div>}
+        <div className="mb-4">
+          <div className="flex items-center justify-between mb-3"><h2 className="text-sm font-medium text-gray-700 dark:text-gray-300">上传月份</h2></div>
+          <div className="flex flex-wrap gap-2">
+            <button onClick={() => setSelectedMonth('')} className={`${btnBase} ${selectedMonth === '' ? btnActive : btnInactive}`} style={selectedMonth === '' ? { backgroundColor: themeColor } : {}}>全部<span className={`ml-1.5 text-xs ${selectedMonth === '' ? 'text-gray-300' : 'text-gray-500 dark:text-gray-400'}`}>({totalMaterialsCount})</span></button>
+            {months.map((m) => <button key={m.value} onClick={() => setSelectedMonth(m.value === selectedMonth ? '' : m.value)} className={`${btnBase} ${selectedMonth === m.value ? btnActive : btnInactive}`} style={selectedMonth === m.value ? { backgroundColor: themeColor } : {}}>{m.label}<span className={`ml-1.5 text-xs ${selectedMonth === m.value ? 'text-gray-300' : 'text-gray-500 dark:text-gray-400'}`}>({m.count})</span></button>)}
+          </div>
+        </div>
+        <div className="mb-4">
+          <div className="flex items-center justify-between mb-3"><h2 className="text-sm font-medium text-gray-700 dark:text-gray-300">排序方式</h2></div>
+          <div className="flex flex-wrap gap-2">
+            <button onClick={() => handleSortChange('createdAt')} className={`${btnBase} flex items-center gap-1 ${sortBy === 'createdAt' ? btnActive : btnInactive}`} style={sortBy === 'createdAt' ? { backgroundColor: themeColor } : {}}>
+              {sortBy === 'createdAt' && sortOrder === 'asc' ? '最早上传' : '最新上传'}
+              {sortBy === 'createdAt' && <svg className="w-3 h-3" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d={sortOrder === 'desc' ? 'M19 9l-7 7-7-7' : 'M5 15l7-7 7 7'} /></svg>}
+            </button>
+            <button onClick={() => handleSortChange('downloadCount')} className={`${btnBase} flex items-center gap-1 ${sortBy === 'downloadCount' ? btnActive : btnInactive}`} style={sortBy === 'downloadCount' ? { backgroundColor: themeColor } : {}}>
+              {sortBy === 'downloadCount' && sortOrder === 'asc' ? '下载最少' : '下载最多'}
+              {sortBy === 'downloadCount' && <svg className="w-3 h-3" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d={sortOrder === 'desc' ? 'M19 9l-7 7-7-7' : 'M5 15l7-7 7 7'} /></svg>}
+            </button>
+          </div>
+          <div className="text-xs text-gray-500 dark:text-gray-400 mt-2">💡 提示：可以组合使用多个筛选条件，找到更精确的素材</div>
+        </div>
+      </div>
+    </>
+  )
+}
+
+export default memo(FilterPanel)
--- a/components/home/LoadMoreTrigger.tsx
+++ b/components/home/LoadMoreTrigger.tsx
@ -0,0 +1,90 @@
+'use client'
+
+import React, { useEffect, useRef, forwardRef } from 'react'
+
+interface LoadMoreTriggerProps {
+  hasMore: boolean
+  isLoading: boolean
+  onLoadMore: () => void
+  themeColor?: string
+  displayedCount?: number  // 当前显示数量
+  totalCount?: number      // 已加载总数量
+  showEndMessage?: boolean // 是否显示到底提示
+}
+
+/**
+ * 加载更多触发器组件
+ * 使用 IntersectionObserver 实现无限滚动
+ */
+const LoadMoreTrigger = forwardRef<HTMLDivElement, LoadMoreTriggerProps>(function LoadMoreTrigger({
+  hasMore,
+  isLoading,
+  onLoadMore,
+  themeColor = '#1f2937',
+  displayedCount,
+  totalCount,
+  showEndMessage = true,
+}, ref) {
+  const internalRef = useRef<HTMLDivElement>(null)
+  const loadMoreRef = ref || internalRef
+
+  // 判断是否需要显示加载更多
+  const shouldShowLoadMore = hasMore || (displayedCount !== undefined && totalCount !== undefined && displayedCount < totalCount)
+
+  useEffect(() => {
+    const element = typeof loadMoreRef === 'function' ? null : loadMoreRef.current
+    if (!element) return
+    if (isLoading) return
+    if (!shouldShowLoadMore) return
+
+    const observer = new IntersectionObserver(
+      (entries) => {
+        if (entries[0].isIntersecting && !isLoading) {
+          onLoadMore()
+        }
+      },
+      { threshold: 0.1, rootMargin: '100px' }
+    )
+
+    observer.observe(element)
+
+    return () => observer.disconnect()
+  }, [loadMoreRef, hasMore, isLoading, onLoadMore, shouldShowLoadMore])
+
+  // 显示加载更多
+  if (shouldShowLoadMore) {
+    return (
+      <div 
+        ref={typeof loadMoreRef === 'function' ? undefined : loadMoreRef} 
+        className="w-full h-20 flex items-center justify-center mt-8"
+      >
+        {isLoading ? (
+          <div className="text-gray-500 dark:text-gray-400 text-sm flex items-center gap-2">
+            <svg className="animate-spin h-5 w-5" viewBox="0 0 24 24">
+              <circle className="opacity-25" cx="12" cy="12" r="10" stroke="currentColor" strokeWidth="4" fill="none" />
+              <path className="opacity-75" fill="currentColor" d="M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4zm2 5.291A7.962 7.962 0 014 12H0c0 3.042 1.135 5.824 3 7.938l3-2.647z" />
+            </svg>
+            加载中...
+          </div>
+        ) : (
+          <p className="text-gray-400 dark:text-gray-500 text-sm">
+            向下滚动加载更多
+          </p>
+        )}
+      </div>
+    )
+  }
+
+  // 显示到底提示
+  if (showEndMessage && !hasMore && (displayedCount === undefined || displayedCount >= (totalCount || 0))) {
+    return (
+      <div className="w-full py-6 text-center text-sm text-gray-500 dark:text-gray-400 mt-8">
+        已经到底啦～
+      </div>
+    )
+  }
+
+  return null
+})
+
+export default LoadMoreTrigger
--- a/components/home/MaterialCard.tsx
+++ b/components/home/MaterialCard.tsx
@ -0,0 +1,619 @@
+'use client'
+
+import React, { useRef, useEffect } from 'react'
+import Image from 'next/image'
+import { format } from 'date-fns'
+import AudioVisualizer from '../AudioVisualizer'
+
+// 素材类型定义
+export interface Material {
+  id: string
+  productModel: string
+  categoryName: string
+  sceneName: string
+  materialType: string
+  renderer?: string
+  authorName: string
+  previewUrl: string
+  zipFileName: string
+  zipFileSize: string | number
+  downloadCount: number
+  likeCount: number
+  isLiked: boolean
+  isFavorited: boolean
+  userId: string
+  createdAt: string
+  // 视频相关
+  videoSourceUrl?: string
+  videoPreviewClipUrl?: string
+  videoPreview540Url?: string
+  videoCoverUrl?: string
+  videoDuration?: number
+  videoProcessingStatus?: string
+  transcodeProgress?: number
+  transcodeStage?: string
+  transcodeAttempts?: number
+  transcodeLastError?: string
+  transcodeQueueWaitingIndex?: number
+  transcodeQueueWaitingTotal?: number
+  transcodeQueueProcessingIds?: string[]
+  transcodeQueueMaxConcurrent?: number
+}
+
+// 用户会话类型
+interface UserSession {
+  id: string
+  role: string
+}
+
+interface MaterialCardProps {
+  material: Material
+  session: { user: UserSession } | null
+  // 音频播放状态
+  playingAudioId: string | null
+  audioElement: HTMLAudioElement | null
+  audioProgress: number
+  audioCurrentTime: number
+  audioDuration: number
+  audioRef: React.RefObject<HTMLAudioElement | null>
+  // 下载状态
+  downloadingId: string | null
+  downloadProgress: number
+  // 主题色
+  themeColor: string
+  // 事件处理
+  onAudioPlay: (materialId: string, audioUrl: string) => void
+  onDownload: (id: string) => void
+  onLike: (id: string) => void
+  onFavorite: (id: string) => void
+  onShare: (id: string) => void
+  onEdit: (material: Material) => void
+  onDelete: (id: string) => void
+  onClick: (material: Material) => void
+  onRetryTranscode: (materialId: string) => void
+  showToast: (message: string, options?: { variant?: 'success' | 'error' }) => void
+}
+
+// 根据素材类型获取角标背景颜色
+const getMaterialTypeBadgeColor = (materialType: string): string => {
+  const isVideoType = materialType === '主图视频' || materialType === '安装视频' || materialType === '种草视频'
+  
+  if (materialType === '3D场景' || materialType === '3DMAX') {
+    return 'bg-red-500'
+  } else if (isVideoType) {
+    return 'bg-blue-600'
+  } else if (materialType === '音乐') {
+    return 'bg-purple-600'
+  } else if (materialType === 'C4D模型') {
+    return 'bg-blue-500'
+  } else if (materialType === '详情页' || materialType === '矢量文件') {
+    return 'bg-amber-500'
+  } else {
+    return 'bg-gray-700'
+  }
+}
+
+// 格式化文件大小
+const formatFileSize = (bytes: string | number): string => {
+  const size = typeof bytes === 'string' ? parseInt(bytes) : bytes
+  if (size === 0) return '未知'
+  const units = ['B', 'KB', 'MB', 'GB']
+  const i = Math.floor(Math.log(size) / Math.log(1024))
+  return `${(size / Math.pow(1024, i)).toFixed(2)} ${units[i]}`
+}
+
+export default function MaterialCard({
+  material,
+  session,
+  playingAudioId,
+  audioElement,
+  audioProgress,
+  audioCurrentTime,
+  audioDuration,
+  audioRef,
+  downloadingId,
+  downloadProgress,
+  themeColor,
+  onAudioPlay,
+  onDownload,
+  onLike,
+  onFavorite,
+  onShare,
+  onEdit,
+  onDelete,
+  onClick,
+  onRetryTranscode,
+  showToast,
+}: MaterialCardProps) {
+  const videoRef = useRef<HTMLVideoElement>(null)
+  
+  // 判断素材类型
+  const isVideoType = material.materialType === '主图视频' || material.materialType === '安装视频' || material.materialType === '种草视频'
+  const isAudioMaterial = material.materialType === '音乐'
+  
+  // 视频预览URL
+  const videoPreviewUrl = material.videoPreviewClipUrl || material.videoPreview540Url
+  const posterUrl = material.videoCoverUrl || material.previewUrl
+  
+  // 音频URL
+  let audioUrl = ''
+  if (isAudioMaterial && material.zipFileName) {
+    const zipFileName = material.zipFileName
+    if (zipFileName.startsWith('http://') || zipFileName.startsWith('https://')) {
+      audioUrl = zipFileName
+    } else {
+      audioUrl = `/uploads/${zipFileName}`
+    }
+  }
+
+  // 视频鼠标悬停播放控制
+  const handleVideoMouseEnter = () => {
+    if (videoRef.current) {
+      videoRef.current.play().catch(() => {})
+    }
+  }
+  
+  const handleVideoMouseLeave = () => {
+    if (videoRef.current) {
+      videoRef.current.pause()
+      videoRef.current.currentTime = 0
+    }
+  }
+
+  // 复制ID到剪贴板
+  const handleCopyId = async (e: React.MouseEvent) => {
+    e.stopPropagation()
+    try {
+      await navigator.clipboard.writeText(material.id)
+      showToast('ID已复制', { variant: 'success' })
+    } catch {
+      const textarea = document.createElement('textarea')
+      textarea.value = material.id
+      textarea.style.position = 'fixed'
+      textarea.style.left = '-999999px'
+      document.body.appendChild(textarea)
+      textarea.select()
+      try {
+        document.execCommand('copy')
+        showToast('ID已复制', { variant: 'success' })
+      } catch {
+        showToast('复制失败', { variant: 'error' })
+      }
+      document.body.removeChild(textarea)
+    }
+  }
+
+  // 渲染转码进度
+  const renderTranscodeProgress = () => {
+    if (!isVideoType) return null
+    
+    const status = material.videoProcessingStatus
+    const progress = material.transcodeProgress
+    const stage = material.transcodeStage
+    const attempts = material.transcodeAttempts || 0
+    const queueIndex = material.transcodeQueueWaitingIndex
+    const queueTotal = material.transcodeQueueWaitingTotal || 0
+    const processingIds = material.transcodeQueueProcessingIds || []
+    const maxConcurrent = material.transcodeQueueMaxConcurrent || 2
+    const isProcessing = processingIds.includes(material.id)
+
+    // 如果转码完成或没有视频源，不显示进度条
+    if (!material.videoSourceUrl || status === 'done' || (status !== 'pending' && status !== 'processing' && status !== 'failed' && attempts === 0)) {
+      return null
+    }
+    
+    let label = ''
+    let progressValue = 0
+    let bgColor = 'bg-gray-700'
+    
+    if (status === 'failed') {
+      const error = material.transcodeLastError || ''
+      const errorMsg = error.replace(/^转码失败[:：]\s*/i, '').trim()
+      label = errorMsg ? `转码失败：${errorMsg}` : '转码失败'
+      progressValue = 0
+      bgColor = 'bg-red-600'
+    } else if (isProcessing) {
+      const stageName = stage === 'preview' ? '预览视频' : stage === 'clip' ? '预览片段' : stage === 'cover' ? '封面图' : ''
+      const processingCount = processingIds.length
+      const waitingCount = Math.max(0, queueTotal - processingCount)
+      
+      if (progress !== null && progress !== undefined && progress > 0) {
+        progressValue = Math.max(5, Math.min(progress, 95))
+        label = `转码中 ${progress}%${stageName ? ` · ${stageName}` : ''}${attempts > 1 ? ` · 第${attempts}次` : ''}${waitingCount > 0 ? ` · 队列余${waitingCount}` : ''}`
+      } else {
+        progressValue = Math.max(28, Math.min(35 + 55 * Math.min(0.95, 0) + (attempts > 1 ? 5 : 0), 92))
+        label = `转码中${stageName ? ` · ${stageName}` : ''}${attempts > 1 ? ` · 第${attempts}次` : ''}${waitingCount > 0 ? ` · 队列余${waitingCount}` : ''} · ${processingCount}/${maxConcurrent}并发`
+      }
+      bgColor = 'bg-blue-600'
+    } else if (status === 'processing') {
+      label = `转码中${attempts > 1 ? ` · 第${attempts}次` : ''}`
+      progressValue = 15
+      bgColor = 'bg-blue-600'
+    } else if (status === 'pending') {
+      label = `等待中${attempts > 1 ? ` · 第${attempts}次` : ''}`
+      progressValue = 5
+      bgColor = 'bg-gray-600'
+    } else if (queueIndex !== null && queueIndex !== undefined) {
+      const processingCount = processingIds.length
+      label = `排队中 · ${queueIndex}/${queueTotal} · ${processingCount}/${maxConcurrent}执行中`
+      progressValue = 8
+      bgColor = 'bg-amber-600'
+    } else {
+      label = status || '未知状态'
+      progressValue = 12
+      bgColor = 'bg-gray-600'
+    }
+
+    return (
+      <div className="absolute bottom-0 left-0 right-0 bg-black/80 text-white text-xs p-2 z-20">
+        <div className="flex items-center justify-between mb-1">
+          <span className="truncate">{label}</span>
+          {status === 'failed' && !material.videoPreviewClipUrl && !material.videoPreview540Url && (
+            <button
+              onClick={(e) => {
+                e.stopPropagation()
+                onRetryTranscode(material.id)
+              }}
+              className="ml-2 bg-white/90 text-gray-900 px-2 py-0.5 rounded text-xs hover:bg-white transition-colors"
+            >
+              重试转码
+            </button>
+          )}
+        </div>
+        <div className="w-full bg-gray-700 rounded-full h-1.5 overflow-hidden">
+          <div
+            className={`h-full transition-all duration-300 ${bgColor}`}
+            style={{ width: `${progressValue}%` }}
+          />
+        </div>
+      </div>
+    )
+  }
+
+  return (
+    <div className="card-apple overflow-hidden dark:bg-gray-800 dark:border-gray-700">
+      {/* Preview Image/Video */}
+      <div
+        className="relative w-full h-[400px] bg-gray-200 dark:bg-gray-700 cursor-pointer group overflow-hidden"
+        data-material-link="true"
+        onMouseEnter={() => isVideoType && videoPreviewUrl && handleVideoMouseEnter()}
+        onMouseLeave={() => isVideoType && videoPreviewUrl && handleVideoMouseLeave()}
+        onClick={() => onClick(material)}
+      >
+        {/* 视频类型 */}
+        {isVideoType && videoPreviewUrl ? (
+          <video
+            ref={videoRef}
+            src={videoPreviewUrl}
+            poster={posterUrl || undefined}
+            className="w-full h-full object-cover transition-transform group-hover:scale-105"
+            muted
+            loop
+            playsInline
+            preload="metadata"
+          />
+        ) : isAudioMaterial ? (
+          // 音频素材卡片
+          <div className="absolute inset-0 flex flex-col items-center justify-center bg-gradient-to-b from-slate-800 to-slate-900 overflow-hidden">
+            {/* 圆形频谱可视化背景 */}
+            {playingAudioId === material.id && audioElement && (
+              <div className="absolute inset-0 flex items-center justify-center">
+                <AudioVisualizer
+                  audioElement={audioElement}
+                  isPlaying={true}
+                  size="sm"
+                  coverImage={material.previewUrl || null}
+                  showCoverOnPause={false}
+                />
+              </div>
+            )}
+
+            {/* 播放进度条 */}
+            {playingAudioId === material.id && (
+              <div 
+                className="absolute bottom-0 left-0 right-0 h-2 bg-slate-700 z-20 cursor-pointer hover:h-3 transition-all group"
+                onClick={(e) => {
+                  e.stopPropagation()
+                  if (audioRef.current && audioRef.current.duration) {
+                    const rect = e.currentTarget.getBoundingClientRect()
+                    const percent = (e.clientX - rect.left) / rect.width
+                    audioRef.current.currentTime = audioRef.current.duration * percent
+                  }
+                }}
+                onMouseDown={(e) => {
+                  e.stopPropagation()
+                  const progressBar = e.currentTarget
+                  const handleMouseMove = (moveEvent: MouseEvent) => {
+                    if (audioRef.current && audioRef.current.duration) {
+                      const rect = progressBar.getBoundingClientRect()
+                      const percent = Math.max(0, Math.min(1, (moveEvent.clientX - rect.left) / rect.width))
+                      audioRef.current.currentTime = audioRef.current.duration * percent
+                    }
+                  }
+                  const handleMouseUp = () => {
+                    document.removeEventListener('mousemove', handleMouseMove)
+                    document.removeEventListener('mouseup', handleMouseUp)
+                  }
+                  document.addEventListener('mousemove', handleMouseMove)
+                  document.addEventListener('mouseup', handleMouseUp)
+                }}
+              >
+                <div 
+                  className="h-full bg-blue-500 transition-all duration-100 relative"
+                  style={{ width: `${audioProgress}%` }}
+                >
+                  <div className="absolute right-0 top-1/2 -translate-y-1/2 w-3 h-3 bg-white rounded-full shadow-lg opacity-0 group-hover:opacity-100 transition-opacity" />
+                </div>
+              </div>
+            )}
+            {/* 时长显示 */}
+            {playingAudioId === material.id && audioDuration > 0 && (
+              <div className="absolute bottom-2 left-2 bg-black/70 text-white px-2 py-1 rounded text-xs font-medium z-10">
+                {Math.floor(audioCurrentTime / 60)}:{Math.floor(audioCurrentTime % 60).toString().padStart(2, '0')} / {Math.floor(audioDuration / 60)}:{Math.floor(audioDuration % 60).toString().padStart(2, '0')}
+              </div>
+            )}
+
+            {/* 信息覆盖层 */}
+            <div className="absolute inset-0 z-10 flex flex-col items-center justify-center pointer-events-none">
+              {material.previewUrl && playingAudioId !== material.id && (
+                <Image
+                  src={material.previewUrl}
+                  alt={material.productModel}
+                  fill
+                  unoptimized
+                  className="object-cover opacity-50"
+                  sizes="(max-width: 768px) 100vw, 300px"
+                />
+              )}
+              {/* 播放/暂停按钮 */}
+              <button
+                type="button"
+                onClick={(e) => {
+                  e.stopPropagation()
+                  if (audioUrl) {
+                    onAudioPlay(material.id, audioUrl)
+                  }
+                }}
+                className={`w-14 h-14 rounded-full backdrop-blur-sm flex items-center justify-center border transition-all pointer-events-auto ${
+                  playingAudioId === material.id 
+                    ? "bg-white/30 border-white/50 hover:bg-white/40" 
+                    : "bg-white/20 border-white/30 group-hover:scale-110 hover:bg-white/30"
+                }`}
+              >
+                {playingAudioId === material.id ? (
+                  <svg className="w-7 h-7 text-white" fill="currentColor" viewBox="0 0 24 24">
+                    <path d="M6 4h4v16H6V4zm8 0h4v16h-4V4z" />
+                  </svg>
+                ) : (
+                  <svg className="w-7 h-7 text-white ml-1" fill="currentColor" viewBox="0 0 24 24">
+                    <path d="M8 5v14l11-7z" />
+                  </svg>
+                )}
+              </button>
+              {playingAudioId !== material.id && (
+                <p className="text-white text-sm font-medium text-center px-4 line-clamp-1 drop-shadow-lg mt-3">{material.productModel}</p>
+              )}
+            </div>
+          </div>
+        ) : material.previewUrl ? (
+          <Image
+            src={material.previewUrl}
+            alt={material.sceneName}
+            fill
+            unoptimized
+            className="object-cover transition-transform group-hover:scale-105"
+            sizes="(max-width: 768px) 100vw, 300px"
+          />
+        ) : (
+          <div className="w-full h-full flex items-center justify-center bg-gray-300 dark:bg-gray-600 audio-placeholder">
+            <span className="text-gray-500 dark:text-gray-400">暂无预览图</span>
+          </div>
+        )}
+
+        {/* SPU标签 - 左上角 */}
+        <div className="absolute top-2 left-2 bg-black/70 text-white px-2 py-1 rounded text-xs font-medium">
+          {material.productModel}
+        </div>
+        {/* 素材类型角标 - 右上角 */}
+        <div className={`absolute top-2 right-2 text-white px-2 py-1 rounded text-xs font-medium ${getMaterialTypeBadgeColor(material.materialType)}`}>
+          {material.materialType}
+        </div>
+        {/* 放大提示 */}
+        {!isVideoType && material.materialType !== '音乐' && (
+          <div className="absolute inset-0 bg-black/0 group-hover:bg-black/30 transition-all flex items-center justify-center">
+            <svg className="w-12 h-12 text-white opacity-0 group-hover:opacity-100 transition-opacity" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+              <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M21 21l-6-6m2-5a7 7 0 11-14 0 7 7 0 0114 0zM10 7v6m3-3H7" />
+            </svg>
+          </div>
+        )}
+        
+        {/* 转码进度显示 */}
+        {renderTranscodeProgress()}
+        
+        {/* 视频时长角标 */}
+        {isVideoType && material.videoDuration && (
+          <div className="absolute bottom-2 left-2 bg-black/70 text-white px-2 py-1 rounded text-xs font-medium z-10">
+            {Math.floor(material.videoDuration / 60)}:{(material.videoDuration % 60).toString().padStart(2, '0')}
+          </div>
+        )}
+      </div>
+
+      {/* Info */}
+      <div className="p-4">
+        {/* 标签 */}
+        <div className="flex items-center gap-2 mb-3 flex-wrap">
+          {material.categoryName && (
+            <span className="inline-flex items-center px-2 py-1 bg-blue-100 dark:bg-blue-900/30 text-blue-700 dark:text-blue-300 rounded text-xs font-medium">
+              {material.categoryName}
+            </span>
+          )}
+          {material.sceneName && (
+            <span className="inline-flex items-center px-2 py-1 bg-green-100 dark:bg-green-900/30 text-green-700 dark:text-green-300 rounded text-xs font-medium">
+              {material.sceneName}
+            </span>
+          )}
+          {material.materialType && (
+            <span className="inline-flex items-center px-2 py-1 bg-orange-100 dark:bg-orange-900/30 text-orange-700 dark:text-orange-300 rounded text-xs font-medium">
+              {material.materialType}
+            </span>
+          )}
+          {material.materialType === '3D场景' && material.renderer && (
+            <span className="inline-flex items-center px-2 py-1 bg-purple-100 dark:bg-purple-900/30 text-purple-700 dark:text-purple-300 rounded text-xs font-medium">
+              {material.renderer}
+            </span>
+          )}
+        </div>
+
+        {/* 作者和时间 */}
+        <div className="space-y-1 text-sm text-gray-600 dark:text-gray-400 mb-3">
+          <p className="truncate">
+            <span className="font-medium">作者：</span>
+            {material.authorName}
+          </p>
+          <p 
+            className="truncate text-xs cursor-pointer hover:text-blue-600 dark:hover:text-blue-400 transition-colors"
+            onClick={handleCopyId}
+            title="点击复制完整ID"
+          >
+            <span className="font-medium">ID：</span>
+            <span className="text-blue-600 dark:text-blue-400">{material.id}</span>
+          </p>
+          <p className="text-xs">
+            <span className="font-medium">大小：</span>
+            <span className="text-blue-600 dark:text-blue-400">{formatFileSize(material.zipFileSize)}</span>
+          </p>
+          <p className="text-xs text-gray-500 dark:text-gray-500">
+            {format(new Date(material.createdAt), 'yyyy-MM-dd HH:mm')}
+          </p>
+        </div>
+
+        {/* 统计数据 */}
+        <div className="flex items-center justify-between text-xs text-gray-500 dark:text-gray-400 mb-3 pb-3 border-b border-gray-200 dark:border-gray-700">
+          <div className="flex items-center gap-3">
+            <span className="flex items-center gap-1">
+              <svg className="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M4 16v1a3 3 0 003 3h10a3 3 0 003-3v-1m-4-4l-4 4m0 0l-4-4m4 4V4" />
+              </svg>
+              {material.downloadCount}
+            </span>
+            <button
+              onClick={(e) => {
+                e.stopPropagation()
+                onLike(material.id)
+              }}
+              className={`flex items-center gap-1 transition-colors ${
+                material.isLiked 
+                  ? 'text-red-600 dark:text-red-400' 
+                  : 'text-gray-500 dark:text-gray-400 hover:text-red-600 dark:hover:text-red-400'
+              }`}
+              title={material.isLiked ? '取消点赞' : '点赞'}
+            >
+              <svg 
+                className="w-4 h-4" 
+                fill={material.isLiked ? 'currentColor' : 'none'}
+                stroke="currentColor" 
+                viewBox="0 0 24 24"
+                strokeWidth={material.isLiked ? 0 : 2}
+              >
+                <path strokeLinecap="round" strokeLinejoin="round" d="M4.318 6.318a4.5 4.5 0 000 6.364L12 20.364l7.682-7.682a4.5 4.5 0 00-6.364-6.364L12 7.636l-1.318-1.318a4.5 4.5 0 00-6.364 0z" />
+              </svg>
+              {material.likeCount}
+            </button>
+          </div>
+        </div>
+
+        {/* Action Buttons */}
+        <div className="flex gap-2 items-center">
+          {/* 编辑按钮 */}
+          {session?.user && (
+            material.userId === session.user.id || session.user.role === 'ADMIN'
+          ) && (
+            <button
+              onClick={() => onEdit(material)}
+              className="flex-none h-10 w-10 flex items-center justify-center rounded-xl border border-blue-200 dark:border-blue-800 bg-blue-50 dark:bg-blue-900/30 text-blue-600 dark:text-blue-400 hover:bg-blue-100 dark:hover:bg-blue-900/50 transition-all"
+              title="编辑"
+            >
+              <svg className="w-5 h-5" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M11 5H6a2 2 0 00-2 2v11a2 2 0 002 2h11a2 2 0 002-2v-5m-1.414-9.414a2 2 0 112.828 2.828L11.828 15H9v-2.828l8.586-8.586z" />
+              </svg>
+            </button>
+          )}
+          {/* 删除按钮 */}
+          {session?.user && session.user.role === 'ADMIN' && (
+            <button
+              onClick={(e) => {
+                e.stopPropagation()
+                onDelete(material.id)
+              }}
+              className="flex-none h-10 w-10 flex items-center justify-center rounded-xl border border-red-200 dark:border-red-800 bg-red-50 dark:bg-red-900/30 text-red-600 dark:text-red-400 hover:bg-red-100 dark:hover:bg-red-900/50 transition-all"
+              title="删除"
+            >
+              <svg className="w-5 h-5" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M19 7l-.867 12.142A2 2 0 0116.138 21H7.862a2 2 0 01-1.995-1.858L5 7m5 4v6m4-6v6m1-10V4a1 1 0 00-1-1h-4a1 1 0 00-1 1v3M4 7h16" />
+              </svg>
+            </button>
+          )}
+          {/* 收藏按钮 */}
+          {session?.user && (
+            <button
+              onClick={(e) => {
+                e.stopPropagation()
+                onFavorite(material.id)
+              }}
+              className={`flex-none h-10 w-10 flex items-center justify-center rounded-xl border transition-all ${
+                material.isFavorited 
+                  ? 'border-pink-500 bg-pink-500 text-white hover:bg-pink-600' 
+                  : 'border-gray-300 dark:border-gray-600 text-gray-600 dark:text-gray-400 hover:bg-gray-50 dark:hover:bg-gray-800'
+              }`}
+              title={material.isFavorited ? '取消收藏' : '收藏'}
+            >
+              <svg 
+                className="w-5 h-5" 
+                viewBox="0 0 24 24" 
+                fill={material.isFavorited ? 'currentColor' : 'none'}
+                stroke="currentColor" 
+                strokeWidth={material.isFavorited ? 0 : 2}
+              >
+                <path 
+                  strokeLinecap="round" 
+                  strokeLinejoin="round" 
+                  d="M6 4h12a1 1 0 011 1v15.382a.5.5 0 01-.777.416L12 17.5l-6.223 3.298A.5.5 0 015 20.382V5a1 1 0 011-1z" 
+                />
+              </svg>
+            </button>
+          )}
+
+          {/* 分享按钮 */}
+          <button
+            onClick={() => onShare(material.id)}
+            className="flex-none h-10 w-10 flex items-center justify-center rounded-xl border border-gray-300 dark:border-gray-600 bg-gray-50 dark:bg-gray-800 text-gray-600 dark:text-gray-400 hover:bg-gray-100 dark:hover:bg-gray-700 transition-all"
+            title="分享"
+          >
+            <svg className="w-5 h-5" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+              <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M8.684 13.342C8.886 12.938 9 12.482 9 12c0-.482-.114-.938-.316-1.342m0 2.684a3 3 0 110-2.684m0 2.684l6.632 3.316m-6.632-6l6.632-3.316m0 0a3 3 0 105.367-2.684 3 3 0 00-5.367 2.684zm0 9.316a3 3 0 105.368 2.684 3 3 0 00-5.368-2.684z" />
+            </svg>
+          </button>
+          {/* 下载按钮 */}
+          <button
+            onClick={() => onDownload(material.id)}
+            disabled={downloadingId === material.id}
+            className="flex-1 h-10 btn-primary text-sm font-medium rounded-xl transition-all disabled:opacity-50 flex items-center justify-center"
+            style={{ backgroundColor: themeColor }}
+          >
+            {downloadingId === material.id ? (
+              <span className="flex items-center justify-center gap-2">
+                <svg className="w-4 h-4 animate-spin" fill="none" viewBox="0 0 24 24">
+                  <circle className="opacity-25" cx="12" cy="12" r="10" stroke="currentColor" strokeWidth="4" />
+                  <path className="opacity-75" fill="currentColor" d="M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4zm2 5.291A7.962 7.962 0 014 12H0c0 3.042 1.135 5.824 3 7.938l3-2.647z" />
+                </svg>
+                {downloadProgress}%
+              </span>
+            ) : (
+              '下载'
+            )}
+          </button>
+        </div>
+      </div>
+    </div>
+  )
+}
--- a/components/home/MaterialGrid.tsx
+++ b/components/home/MaterialGrid.tsx
@ -0,0 +1,128 @@
+'use client'
+
+import React from 'react'
+import MaterialCard, { Material } from './MaterialCard'
+
+// 用户会话类型
+interface UserSession {
+  id: string
+  role: string
+}
+
+interface MaterialGridProps {
+  materials: Material[]
+  displayedCount: number
+  session: { user: UserSession } | null
+  loading: boolean
+  isTransitionLoading: boolean
+  // 音频播放状态
+  playingAudioId: string | null
+  audioElement: HTMLAudioElement | null
+  audioProgress: number
+  audioCurrentTime: number
+  audioDuration: number
+  audioRef: React.RefObject<HTMLAudioElement | null>
+  // 下载状态
+  downloadingId: string | null
+  downloadProgress: number
+  // 主题色
+  themeColor: string
+  // 筛选状态（用于空状态提示）
+  hasFilters: boolean
+  // 事件处理
+  onAudioPlay: (materialId: string, audioUrl: string) => void
+  onDownload: (id: string) => void
+  onLike: (id: string) => void
+  onFavorite: (id: string) => void
+  onShare: (id: string) => void
+  onEdit: (material: Material) => void
+  onDelete: (id: string) => void
+  onMaterialClick: (material: Material) => void
+  onRetryTranscode: (materialId: string) => void
+  showToast: (message: string, options?: { variant?: 'success' | 'error' }) => void
+}
+
+export default function MaterialGrid({
+  materials,
+  displayedCount,
+  session,
+  loading,
+  isTransitionLoading,
+  playingAudioId,
+  audioElement,
+  audioProgress,
+  audioCurrentTime,
+  audioDuration,
+  audioRef,
+  downloadingId,
+  downloadProgress,
+  themeColor,
+  hasFilters,
+  onAudioPlay,
+  onDownload,
+  onLike,
+  onFavorite,
+  onShare,
+  onEdit,
+  onDelete,
+  onMaterialClick,
+  onRetryTranscode,
+  showToast,
+}: MaterialGridProps) {
+  return (
+    <div className="relative">
+      {/* 过渡加载遮罩 */}
+      {isTransitionLoading && (
+        <div className="absolute inset-0 z-20 flex items-center justify-center bg-white/60 dark:bg-gray-900/60 backdrop-blur-[1px]">
+          <div className="w-6 h-6 border-2 border-gray-300 border-t-gray-900 dark:border-gray-700 dark:border-t-white rounded-full animate-spin" />
+        </div>
+      )}
+      
+      {/* 加载状态 */}
+      {loading ? (
+        <div className="text-center py-16">
+          <p className="text-gray-500 dark:text-gray-400 text-lg">加载中...</p>
+        </div>
+      ) : materials.length === 0 ? (
+        // 空状态
+        <div className="text-center py-16">
+          <p className="text-gray-500 dark:text-gray-400 text-lg">
+            {hasFilters ? '没有找到匹配的素材' : '还没有素材，快来上传第一个吧！'}
+          </p>
+        </div>
+      ) : (
+        // 素材网格
+        <div className="grid grid-cols-1 sm:grid-cols-2 lg:grid-cols-3 xl:grid-cols-4 gap-6">
+          {materials.slice(0, displayedCount).map((material) => (
+            <MaterialCard
+              key={material.id}
+              material={material}
+              session={session}
+              playingAudioId={playingAudioId}
+              audioElement={audioElement}
+              audioProgress={audioProgress}
+              audioCurrentTime={audioCurrentTime}
+              audioDuration={audioDuration}
+              audioRef={audioRef}
+              downloadingId={downloadingId}
+              downloadProgress={downloadProgress}
+              themeColor={themeColor}
+              onAudioPlay={onAudioPlay}
+              onDownload={onDownload}
+              onLike={onLike}
+              onFavorite={onFavorite}
+              onShare={onShare}
+              onEdit={onEdit}
+              onDelete={onDelete}
+              onClick={onMaterialClick}
+              onRetryTranscode={onRetryTranscode}
+              showToast={showToast}
+            />
+          ))}
+        </div>
+      )}
+    </div>
+  )
+}
+
+export type { Material }
--- a/components/home/SearchBar.tsx
+++ b/components/home/SearchBar.tsx
@ -0,0 +1,63 @@
+/**
+ * 搜索栏组件
+ * 提取自 app/page.tsx 的搜索功能
+ */
+
+'use client'
+
+import { memo } from 'react'
+
+interface SearchBarProps {
+  value: string
+  onChange: (value: string) => void
+  placeholder?: string
+}
+
+function SearchBar({
+  value,
+  onChange,
+  placeholder = '搜索素材：SPU型号、店铺、场景、作者...',
+}: SearchBarProps) {
+  return (
+    <div className="relative mb-6">
+      <input
+        type="text"
+        placeholder={placeholder}
+        value={value}
+        onChange={(e) => onChange(e.target.value)}
+        className="w-full pl-10 pr-10 py-3 rounded-xl border border-gray-200 dark:border-gray-700 bg-white dark:bg-gray-800 text-gray-900 dark:text-white focus:border-blue-500 dark:focus:border-blue-400 focus:ring-2 focus:ring-blue-200 dark:focus:ring-blue-600 outline-none transition-all shadow-sm"
+      />
+      <svg
+        className="absolute left-3 top-1/2 transform -translate-y-1/2 w-5 h-5 text-gray-400"
+        fill="none"
+        stroke="currentColor"
+        viewBox="0 0 24 24"
+      >
+        <path
+          strokeLinecap="round"
+          strokeLinejoin="round"
+          strokeWidth={2}
+          d="M21 21l-6-6m2-5a7 7 0 11-14 0 7 7 0 0114 0z"
+        />
+      </svg>
+      {value && (
+        <button
+          onClick={() => onChange('')}
+          className="absolute right-3 top-1/2 transform -translate-y-1/2 text-gray-400 hover:text-gray-600 dark:hover:text-gray-300 transition-colors"
+          aria-label="清除搜索"
+        >
+          <svg className="w-5 h-5" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+            <path
+              strokeLinecap="round"
+              strokeLinejoin="round"
+              strokeWidth={2}
+              d="M6 18L18 6M6 6l12 12"
+            />
+          </svg>
+        </button>
+      )}
+    </div>
+  )
+}
+
+export default memo(SearchBar)
--- a/components/home/index.ts
+++ b/components/home/index.ts
@ -0,0 +1,9 @@
+// 首页组件导出
+export { default as SearchBar } from './SearchBar'
+export { default as FilterPanel, type CategoryItem, type MonthItem } from './FilterPanel'
+export { default as MaterialCard } from './MaterialCard'
+export { default as MaterialGrid } from './MaterialGrid'
+export { default as LoadMoreTrigger } from './LoadMoreTrigger'
+
+// 类型导出
+export type { Material } from './MaterialCard'
--- a/components/upload/SpecialBatchUploadUI.tsx
+++ b/components/upload/SpecialBatchUploadUI.tsx
@ -0,0 +1,411 @@
+/**
+ * 特殊批量上传UI组件
+ * 包含音乐、视频、3D场景、品牌VI、买家秀、小红书的批量上传界面
+ */
+
+'use client'
+
+import Image from 'next/image'
+import { formatBytes } from '@/components/upload/upload-utils'
+
+/**
+ * 音乐/视频/品牌VI 批量文件项
+ */
+export interface BatchFileWithSpu {
+  file: File
+  productModel: string
+}
+
+/**
+ * 3D场景批量文件项（带预览图）
+ */
+export interface Batch3DFile {
+  file: File
+  productModel: string
+  previewImage?: File
+}
+
+/**
+ * 买家秀/小红书批量文件项（多图）
+ */
+export interface BatchImageGroup {
+  productModel: string
+  images: File[]
+}
+
+// ========== 音乐批量上传列表 ==========
+
+interface BatchMusicListProps {
+  files: BatchFileWithSpu[]
+  onUpdateProductModel: (index: number, value: string) => void
+  onDelete: (index: number) => void
+}
+
+export function BatchMusicList({ files, onUpdateProductModel, onDelete }: BatchMusicListProps) {
+  if (files.length === 0) return null
+
+  return (
+    <div className="mb-4 space-y-3 max-h-96 overflow-y-auto border border-gray-200 dark:border-gray-700 rounded-apple p-4">
+      {files.map((item, index) => (
+        <div key={index} className="flex items-center space-x-3 p-2 bg-gray-50 dark:bg-gray-800 rounded">
+          <div className="flex-1 min-w-0">
+            <p className="text-sm font-medium text-gray-700 dark:text-gray-300 truncate">
+              {item.file.name}
+            </p>
+            <p className="text-xs text-gray-500 dark:text-gray-400">
+              {formatBytes(item.file.size)}
+            </p>
+          </div>
+          <input
+            type="text"
+            value={item.productModel}
+            onChange={(e) => onUpdateProductModel(index, e.target.value)}
+            className="flex-1 px-3 py-1.5 text-sm rounded-apple border border-gray-300 dark:border-gray-600 dark:bg-gray-700 dark:text-white"
+            placeholder="SPU型号"
+          />
+          <button
+            type="button"
+            onClick={() => onDelete(index)}
+            className="text-red-600 hover:text-red-700 dark:text-red-400 dark:hover:text-red-300 text-sm"
+          >
+            删除
+          </button>
+        </div>
+      ))}
+    </div>
+  )
+}
+
+// ========== 视频批量上传列表 ==========
+
+interface BatchVideoListProps {
+  files: BatchFileWithSpu[]
+  onUpdateProductModel: (index: number, value: string) => void
+  onDelete: (index: number) => void
+}
+
+export function BatchVideoList({ files, onUpdateProductModel, onDelete }: BatchVideoListProps) {
+  if (files.length === 0) return null
+
+  return (
+    <div className="mb-4 space-y-3 max-h-96 overflow-y-auto border border-gray-200 dark:border-gray-700 rounded-apple p-4">
+      {files.map((item, index) => (
+        <div key={index} className="flex items-center space-x-3 p-2 bg-gray-50 dark:bg-gray-800 rounded">
+          <div className="flex-1 min-w-0">
+            <p className="text-sm font-medium text-gray-700 dark:text-gray-300 truncate">
+              {item.file.name}
+            </p>
+            <p className="text-xs text-gray-500 dark:text-gray-400">
+              {formatBytes(item.file.size)}
+            </p>
+          </div>
+          <input
+            type="text"
+            value={item.productModel}
+            onChange={(e) => onUpdateProductModel(index, e.target.value)}
+            className="flex-1 px-3 py-1.5 text-sm rounded-apple border border-gray-300 dark:border-gray-600 dark:bg-gray-700 dark:text-white"
+            placeholder="SPU型号"
+          />
+          <button
+            type="button"
+            onClick={() => onDelete(index)}
+            className="text-red-600 hover:text-red-700 dark:text-red-400 dark:hover:text-red-300 text-sm"
+          >
+            删除
+          </button>
+        </div>
+      ))}
+    </div>
+  )
+}
+
+// ========== 3D场景批量上传列表 ==========
+
+interface Batch3DListProps {
+  files: Batch3DFile[]
+  onUpdateProductModel: (index: number, value: string) => void
+  onUpdatePreviewImage: (index: number, file: File) => void
+  onDelete: (index: number) => void
+}
+
+export function Batch3DList({ files, onUpdateProductModel, onUpdatePreviewImage, onDelete }: Batch3DListProps) {
+  if (files.length === 0) return null
+
+  return (
+    <div className="mb-4 space-y-3 max-h-96 overflow-y-auto border border-gray-200 dark:border-gray-700 rounded-apple p-4">
+      {files.map((item, index) => (
+        <div key={index} className="flex items-center space-x-3 p-2 bg-gray-50 dark:bg-gray-800 rounded">
+          <div className="flex-1 min-w-0">
+            <p className="text-sm font-medium text-gray-700 dark:text-gray-300 truncate">
+              {item.file.name}
+            </p>
+            <p className="text-xs text-gray-500 dark:text-gray-400">
+              {formatBytes(item.file.size)}
+            </p>
+          </div>
+          <input
+            type="text"
+            value={item.productModel}
+            onChange={(e) => onUpdateProductModel(index, e.target.value)}
+            className="flex-1 px-3 py-1.5 text-sm rounded-apple border border-gray-300 dark:border-gray-600 dark:bg-gray-700 dark:text-white"
+            placeholder="SPU型号"
+          />
+          <input
+            type="file"
+            accept="image/*"
+            onChange={(e) => {
+              const file = e.target.files?.[0]
+              if (file) {
+                onUpdatePreviewImage(index, file)
+              }
+            }}
+            className="hidden"
+            id={`3d-preview-${index}`}
+          />
+          <label
+            htmlFor={`3d-preview-${index}`}
+            className="text-xs text-blue-600 dark:text-blue-400 cursor-pointer"
+          >
+            {item.previewImage ? '已选预览图' : '选择预览图'}
+          </label>
+          <button
+            type="button"
+            onClick={() => onDelete(index)}
+            className="text-red-600 hover:text-red-700 dark:text-red-400 dark:hover:text-red-300 text-sm"
+          >
+            删除
+          </button>
+        </div>
+      ))}
+    </div>
+  )
+}
+
+// ========== 品牌VI批量上传列表 ==========
+
+interface BatchBrandVIListProps {
+  files: BatchFileWithSpu[]
+  onUpdateProductModel: (index: number, value: string) => void
+  onDelete: (index: number) => void
+}
+
+export function BatchBrandVIList({ files, onUpdateProductModel, onDelete }: BatchBrandVIListProps) {
+  if (files.length === 0) return null
+
+  return (
+    <div className="mb-4 space-y-3 max-h-96 overflow-y-auto border border-gray-200 dark:border-gray-700 rounded-apple p-4">
+      {files.map((item, index) => (
+        <div key={index} className="flex items-center space-x-3 p-2 bg-gray-50 dark:bg-gray-800 rounded">
+          <div className="flex-1 min-w-0">
+            <p className="text-sm font-medium text-gray-700 dark:text-gray-300 truncate">
+              {item.file.name}
+            </p>
+            <p className="text-xs text-gray-500 dark:text-gray-400">
+              {formatBytes(item.file.size)}
+            </p>
+          </div>
+          <input
+            type="text"
+            value={item.productModel}
+            onChange={(e) => onUpdateProductModel(index, e.target.value)}
+            className="flex-1 px-3 py-1.5 text-sm rounded-apple border border-gray-300 dark:border-gray-600 dark:bg-gray-700 dark:text-white"
+            placeholder="SPU型号"
+          />
+          <button
+            type="button"
+            onClick={() => onDelete(index)}
+            className="text-red-600 hover:text-red-700 dark:text-red-400 dark:hover:text-red-300 text-sm"
+          >
+            删除
+          </button>
+        </div>
+      ))}
+    </div>
+  )
+}
+
+
+// ========== 买家秀批量上传UI ==========
+
+interface BatchBuyerShowUIProps {
+  batches: BatchImageGroup[]
+  onUpdateProductModel: (batchIndex: number, value: string) => void
+  onImageSelect: (e: React.ChangeEvent<HTMLInputElement>, batchIndex: number) => void
+  onRemoveImage: (batchIndex: number, imageIndex: number) => void
+  onDeleteBatch: (batchIndex: number) => void
+  onAddBatch: () => void
+}
+
+export function BatchBuyerShowUI({
+  batches,
+  onUpdateProductModel,
+  onImageSelect,
+  onRemoveImage,
+  onDeleteBatch,
+  onAddBatch,
+}: BatchBuyerShowUIProps) {
+  return (
+    <div className="mb-4 space-y-4">
+      {batches.map((batch, batchIndex) => (
+        <div key={batchIndex} className="border border-gray-200 dark:border-gray-700 rounded-apple p-4 bg-gray-50 dark:bg-gray-800">
+          <div className="flex items-center space-x-3 mb-3">
+            <input
+              type="text"
+              value={batch.productModel}
+              onChange={(e) => onUpdateProductModel(batchIndex, e.target.value)}
+              className="flex-1 px-3 py-2 text-sm rounded-apple border border-gray-300 dark:border-gray-600 dark:bg-gray-700 dark:text-white"
+              placeholder="SPU型号 *"
+            />
+            <input
+              type="file"
+              accept="image/*"
+              multiple
+              onChange={(e) => onImageSelect(e, batchIndex)}
+              className="hidden"
+              id={`buyer-show-images-${batchIndex}`}
+            />
+            <label
+              htmlFor={`buyer-show-images-${batchIndex}`}
+              className="btn-secondary text-sm"
+            >
+              选择图片（至少8张）
+            </label>
+            <button
+              type="button"
+              onClick={() => onDeleteBatch(batchIndex)}
+              className="text-red-600 hover:text-red-700 dark:text-red-400 dark:hover:text-red-300 text-sm"
+            >
+              删除批次
+            </button>
+          </div>
+          {batch.images.length > 0 && (
+            <div className="grid grid-cols-4 gap-2 mt-3">
+              {batch.images.map((img, imgIndex) => (
+                <div key={imgIndex} className="relative group">
+                  <div className="relative w-full h-24 rounded-apple overflow-hidden border-2 border-gray-200 dark:border-gray-600">
+                    <Image
+                      src={URL.createObjectURL(img)}
+                      alt={`图片 ${imgIndex + 1}`}
+                      fill
+                      unoptimized
+                      className="object-cover"
+                    />
+                  </div>
+                  <button
+                    type="button"
+                    onClick={() => onRemoveImage(batchIndex, imgIndex)}
+                    className="absolute -top-2 -right-2 bg-red-500 text-white rounded-full w-5 h-5 flex items-center justify-center opacity-0 group-hover:opacity-100 transition-opacity text-xs"
+                  >
+                    ×
+                  </button>
+                </div>
+              ))}
+            </div>
+          )}
+          {batch.images.length > 0 && batch.images.length < 8 && (
+            <p className="text-xs text-red-600 dark:text-red-400 mt-2">
+              每批次至少需要8张图片（当前：{batch.images.length}张）
+            </p>
+          )}
+        </div>
+      ))}
+      <button
+        type="button"
+        onClick={onAddBatch}
+        className="btn-secondary text-sm"
+      >
+        + 添加新批次
+      </button>
+    </div>
+  )
+}
+
+// ========== 小红书批量上传UI ==========
+
+interface BatchXiaohongshuUIProps {
+  batches: BatchImageGroup[]
+  onUpdateProductModel: (batchIndex: number, value: string) => void
+  onImageSelect: (e: React.ChangeEvent<HTMLInputElement>, batchIndex: number) => void
+  onRemoveImage: (batchIndex: number, imageIndex: number) => void
+  onDeleteBatch: (batchIndex: number) => void
+  onAddBatch: () => void
+}
+
+export function BatchXiaohongshuUI({
+  batches,
+  onUpdateProductModel,
+  onImageSelect,
+  onRemoveImage,
+  onDeleteBatch,
+  onAddBatch,
+}: BatchXiaohongshuUIProps) {
+  return (
+    <div className="mb-4 space-y-4">
+      {batches.map((batch, batchIndex) => (
+        <div key={batchIndex} className="border border-gray-200 dark:border-gray-700 rounded-apple p-4 bg-gray-50 dark:bg-gray-800">
+          <div className="flex items-center space-x-3 mb-3">
+            <input
+              type="text"
+              value={batch.productModel}
+              onChange={(e) => onUpdateProductModel(batchIndex, e.target.value)}
+              className="flex-1 px-3 py-2 text-sm rounded-apple border border-gray-300 dark:border-gray-600 dark:bg-gray-700 dark:text-white"
+              placeholder="SPU型号 *"
+            />
+            <input
+              type="file"
+              accept="image/*"
+              multiple
+              onChange={(e) => onImageSelect(e, batchIndex)}
+              className="hidden"
+              id={`xiaohongshu-images-${batchIndex}`}
+            />
+            <label
+              htmlFor={`xiaohongshu-images-${batchIndex}`}
+              className="btn-secondary text-sm"
+            >
+              选择图片
+            </label>
+            <button
+              type="button"
+              onClick={() => onDeleteBatch(batchIndex)}
+              className="text-red-600 hover:text-red-700 dark:text-red-400 dark:hover:text-red-300 text-sm"
+            >
+              删除批次
+            </button>
+          </div>
+          {batch.images.length > 0 && (
+            <div className="grid grid-cols-4 gap-2 mt-3">
+              {batch.images.map((img, imgIndex) => (
+                <div key={imgIndex} className="relative group">
+                  <div className="relative w-full h-24 rounded-apple overflow-hidden border-2 border-gray-200 dark:border-gray-600">
+                    <Image
+                      src={URL.createObjectURL(img)}
+                      alt={`图片 ${imgIndex + 1}`}
+                      fill
+                      unoptimized
+                      className="object-cover"
+                    />
+                  </div>
+                  <button
+                    type="button"
+                    onClick={() => onRemoveImage(batchIndex, imgIndex)}
+                    className="absolute -top-2 -right-2 bg-red-500 text-white rounded-full w-5 h-5 flex items-center justify-center opacity-0 group-hover:opacity-100 transition-opacity text-xs"
+                  >
+                    ×
+                  </button>
+                </div>
+              ))}
+            </div>
+          )}
+        </div>
+      ))}
+      <button
+        type="button"
+        onClick={onAddBatch}
+        className="btn-secondary text-sm"
+      >
+        + 添加新批次
+      </button>
+    </div>
+  )
+}
--- a/components/upload/UploadForm.tsx
+++ b/components/upload/UploadForm.tsx
@ -0,0 +1,359 @@
+/**
+ * 上传表单字段组件
+ * 包含 SPU、店铺、场景、平台、品类、渲染器等表单字段
+ */
+
+'use client'
+
+import { useState } from 'react'
+import { requiresCategoryAndScene, requiresProductCategoryName, requiresRenderer, shouldAutoFillGeneral } from '@/lib/material-validation'
+
+/**
+ * 分类数据项
+ */
+interface CategoryItem {
+  id: string
+  name: string
+}
+
+/**
+ * 表单字段 Props
+ */
+export interface UploadFormProps {
+  /** 素材类型 */
+  materialType: string
+  /** SPU型号 */
+  productModel: string
+  /** 店铺名称 */
+  categoryName: string
+  /** 场景名称 */
+  sceneName: string
+  /** 平台名称 */
+  platformName: string
+  /** 品类名称 */
+  productCategoryName: string
+  /** 渲染器 */
+  renderer: string
+  /** 店铺列表 */
+  categories: CategoryItem[]
+  /** 场景列表 */
+  scenes: CategoryItem[]
+  /** 平台列表 */
+  platforms: CategoryItem[]
+  /** 品类列表 */
+  productCategories: CategoryItem[]
+  /** 是否批量模式（批量模式下隐藏部分字段） */
+  isBatchMode?: boolean
+  /** SPU变更回调 */
+  onProductModelChange: (value: string) => void
+  /** 店铺变更回调 */
+  onCategoryChange: (value: string) => void
+  /** 场景变更回调 */
+  onSceneChange: (value: string) => void
+  /** 平台变更回调 */
+  onPlatformChange: (value: string) => void
+  /** 品类变更回调 */
+  onProductCategoryChange: (value: string) => void
+  /** 渲染器变更回调 */
+  onRendererChange: (value: string) => void
+  /** 添加店铺回调 */
+  onAddCategory: (name: string) => Promise<void>
+  /** 添加场景回调 */
+  onAddScene: (name: string) => Promise<void>
+}
+
+/**
+ * 上传表单字段组件
+ */
+export default function UploadForm({
+  materialType,
+  productModel,
+  categoryName,
+  sceneName,
+  platformName,
+  productCategoryName,
+  renderer,
+  categories,
+  scenes,
+  platforms,
+  productCategories,
+  isBatchMode = false,
+  onProductModelChange,
+  onCategoryChange,
+  onSceneChange,
+  onPlatformChange,
+  onProductCategoryChange,
+  onRendererChange,
+  onAddCategory,
+  onAddScene,
+}: UploadFormProps) {
+  // 新建店铺/场景输入状态
+  const [showNewCategoryInput, setShowNewCategoryInput] = useState(false)
+  const [newCategoryName, setNewCategoryName] = useState('')
+  const [showNewSceneInput, setShowNewSceneInput] = useState(false)
+  const [newSceneName, setNewSceneName] = useState('')
+
+  const isAutoGeneralType = shouldAutoFillGeneral(materialType)
+
+  // 处理添加新店铺
+  const handleAddNewCategory = async () => {
+    if (!newCategoryName.trim()) return
+    await onAddCategory(newCategoryName.trim())
+    setNewCategoryName('')
+    setShowNewCategoryInput(false)
+  }
+
+  // 处理添加新场景
+  const handleAddNewScene = async () => {
+    if (!newSceneName.trim()) return
+    await onAddScene(newSceneName.trim())
+    setNewSceneName('')
+    setShowNewSceneInput(false)
+  }
+
+  // 批量模式下不显示这些字段
+  if (isBatchMode) {
+    return null
+  }
+
+  return (
+    <>
+      {/* SPU 或材质名称 */}
+      <div>
+        <label htmlFor="productModel" className="block text-sm font-medium text-gray-700 dark:text-gray-300 mb-2">
+          {materialType === '材质' ? '材质名称 *' : 'SPU型号 *'}
+        </label>
+        <input
+          id="productModel"
+          type="text"
+          value={productModel}
+          onChange={(e) => {
+            // 材质类型支持中文，其他类型只允许英文、数字和常见符号
+            if (materialType === '材质') {
+              onProductModelChange(e.target.value)
+            } else {
+              const value = e.target.value.replace(/[^a-zA-Z0-9\-_.]/g, '').toUpperCase()
+              onProductModelChange(value)
+            }
+          }}
+          className="w-full px-4 py-2 rounded-apple border border-gray-300 dark:border-gray-600 dark:bg-gray-700 dark:text-white focus:border-gray-900 dark:focus:border-gray-400 focus:ring-2 focus:ring-gray-200 dark:focus:ring-gray-600 outline-none"
+          placeholder="例如：XY-2024-001"
+        />
+      </div>
+
+      {/* 使用店铺（材质类型和标准模型不需要） */}
+      {requiresCategoryAndScene(materialType) && (
+        <div>
+          <label htmlFor="categoryName" className="block text-sm font-medium text-gray-700 dark:text-gray-300 mb-2">
+            使用店铺 *
+          </label>
+          {showNewCategoryInput ? (
+            <div className="flex space-x-2">
+              <input
+                type="text"
+                value={newCategoryName}
+                onChange={(e) => setNewCategoryName(e.target.value)}
+                className="flex-1 px-4 py-2 rounded-apple border border-gray-300 dark:border-gray-600 dark:bg-gray-700 dark:text-white focus:border-gray-900 dark:focus:border-gray-400 focus:ring-2 focus:ring-gray-200 dark:focus:ring-gray-600 outline-none"
+                placeholder="输入新店铺名称"
+              />
+              <button
+                type="button"
+                onClick={handleAddNewCategory}
+                className="btn-primary"
+              >
+                添加
+              </button>
+              <button
+                type="button"
+                onClick={() => {
+                  setShowNewCategoryInput(false)
+                  setNewCategoryName('')
+                }}
+                className="btn-secondary"
+              >
+                取消
+              </button>
+            </div>
+          ) : (
+            <div className="flex space-x-2">
+              <select
+                id="categoryName"
+                value={categoryName}
+                onChange={(e) => onCategoryChange(e.target.value)}
+                disabled={isAutoGeneralType}
+                className={`flex-1 px-4 py-2 rounded-apple border border-gray-300 dark:border-gray-600 dark:bg-gray-700 dark:text-white focus:border-gray-900 dark:focus:border-gray-400 focus:ring-2 focus:ring-gray-200 dark:focus:ring-gray-600 outline-none ${isAutoGeneralType ? 'opacity-70 cursor-not-allowed' : ''}`}
+              >
+                {isAutoGeneralType ? (
+                  <option value="通用">通用</option>
+                ) : (
+                  <>
+                    <option value="">选择使用店铺</option>
+                    {categories.map((category) => (
+                      <option key={category.id} value={category.name}>
+                        {category.name}
+                      </option>
+                    ))}
+                  </>
+                )}
+              </select>
+              <button
+                type="button"
+                onClick={() => setShowNewCategoryInput(true)}
+                className="btn-secondary whitespace-nowrap"
+                disabled={isAutoGeneralType}
+              >
+                + 新建店铺
+              </button>
+            </div>
+          )}
+        </div>
+      )}
+
+      {/* 场景类别（材质类型和标准模型不需要） */}
+      {requiresCategoryAndScene(materialType) && (
+        <div>
+          <label htmlFor="sceneName" className="block text-sm font-medium text-gray-700 dark:text-gray-300 mb-2">
+            场景类别 *
+          </label>
+          {showNewSceneInput ? (
+            <div className="flex space-x-2">
+              <input
+                type="text"
+                value={newSceneName}
+                onChange={(e) => setNewSceneName(e.target.value)}
+                className="flex-1 px-4 py-2 rounded-apple border border-gray-300 dark:border-gray-600 dark:bg-gray-700 dark:text-white focus:border-gray-900 dark:focus:border-gray-400 focus:ring-2 focus:ring-gray-200 dark:focus:ring-gray-600 outline-none"
+                placeholder="输入新场景类别"
+              />
+              <button
+                type="button"
+                onClick={handleAddNewScene}
+                className="btn-primary"
+              >
+                添加
+              </button>
+              <button
+                type="button"
+                onClick={() => {
+                  setShowNewSceneInput(false)
+                  setNewSceneName('')
+                }}
+                className="btn-secondary"
+              >
+                取消
+              </button>
+            </div>
+          ) : (
+            <div className="flex space-x-2">
+              <select
+                id="sceneName"
+                value={sceneName}
+                onChange={(e) => onSceneChange(e.target.value)}
+                disabled={isAutoGeneralType}
+                className={`flex-1 px-4 py-2 rounded-apple border border-gray-300 dark:border-gray-600 dark:bg-gray-700 dark:text-white focus:border-gray-900 dark:focus:border-gray-400 focus:ring-2 focus:ring-gray-200 dark:focus:ring-gray-600 outline-none ${isAutoGeneralType ? 'opacity-70 cursor-not-allowed' : ''}`}
+              >
+                {isAutoGeneralType ? (
+                  <option value="通用">通用</option>
+                ) : (
+                  <>
+                    <option value="">选择场景类别</option>
+                    {scenes.map((scene) => (
+                      <option key={scene.id} value={scene.name}>
+                        {scene.name}
+                      </option>
+                    ))}
+                  </>
+                )}
+              </select>
+              <button
+                type="button"
+                onClick={() => setShowNewSceneInput(true)}
+                className="btn-secondary whitespace-nowrap"
+                disabled={isAutoGeneralType}
+              >
+                + 新建场景类别
+              </button>
+            </div>
+          )}
+        </div>
+      )}
+
+      {/* 品类分类（标准模型必填，其他类型可选） */}
+      {productCategories.length > 0 && (
+        <div>
+          <label htmlFor="productCategoryName" className="block text-sm font-medium text-gray-700 dark:text-gray-300 mb-2">
+            品类{requiresProductCategoryName(materialType) ? ' *' : '（可选）'}
+          </label>
+          <select
+            id="productCategoryName"
+            value={productCategoryName}
+            onChange={(e) => onProductCategoryChange(e.target.value)}
+            className="w-full px-4 py-2 rounded-apple border border-gray-300 dark:border-gray-600 dark:bg-gray-700 dark:text-white focus:border-gray-900 dark:focus:border-gray-400 focus:ring-2 focus:ring-gray-200 dark:focus:ring-gray-600 outline-none"
+          >
+            <option value="">{requiresProductCategoryName(materialType) ? '请选择品类' : '不选择品类'}</option>
+            {productCategories.map((category) => (
+              <option key={category.id} value={category.name}>
+                {category.name}
+              </option>
+            ))}
+          </select>
+        </div>
+      )}
+
+      {/* 平台分类（可选，仅在后台配置了平台时显示，标准模型不显示） */}
+      {platforms.length > 0 && !requiresProductCategoryName(materialType) && (
+        <div>
+          <label htmlFor="platformName" className="block text-sm font-medium text-gray-700 dark:text-gray-300 mb-2">
+            平台分类（可选）
+          </label>
+          <select
+            id="platformName"
+            value={platformName}
+            onChange={(e) => onPlatformChange(e.target.value)}
+            className="w-full px-4 py-2 rounded-apple border border-gray-300 dark:border-gray-600 dark:bg-gray-700 dark:text-white focus:border-gray-900 dark:focus:border-gray-400 focus:ring-2 focus:ring-gray-200 dark:focus:ring-gray-600 outline-none"
+          >
+            <option value="">不选择平台</option>
+            {platforms.map((platform) => (
+              <option key={platform.id} value={platform.name}>
+                {platform.name}
+              </option>
+            ))}
+          </select>
+        </div>
+      )}
+
+      {/* 渲染器（仅3D场景显示） */}
+      {requiresRenderer(materialType) && (
+        <div>
+          <label htmlFor="renderer" className="block text-sm font-medium text-gray-700 dark:text-gray-300 mb-2">
+            渲染器 *
+          </label>
+          <select
+            id="renderer"
+            value={renderer}
+            onChange={(e) => onRendererChange(e.target.value)}
+            className="w-full px-4 py-2 rounded-apple border border-gray-300 dark:border-gray-600 dark:bg-gray-700 dark:text-white focus:border-gray-900 dark:focus:border-gray-400 focus:ring-2 focus:ring-gray-200 dark:focus:ring-gray-600 outline-none"
+          >
+            <option value="CR">CR</option>
+            <option value="VR">VR</option>
+            <option value="其它">其它</option>
+          </select>
+        </div>
+      )}
+
+      {/* 标准模型说明 */}
+      {requiresProductCategoryName(materialType) && (
+        <div className="bg-blue-50 dark:bg-blue-900/20 border border-blue-200 dark:border-blue-800 rounded-apple p-4">
+          <p className="text-sm text-blue-700 dark:text-blue-300 font-medium mb-2">
+            💡 标准模型类型说明：
+          </p>
+          <ul className="text-xs text-blue-600 dark:text-blue-400 space-y-1 list-disc list-inside">
+            <li>以产品型号（SPU）为基准创建模型合集</li>
+            <li>上传时只需填写 SPU 型号和预览图</li>
+            <li>创建后在详情页添加各个 SKU 的模型文件</li>
+            <li>每个 SKU 需要单独的预览图和压缩包</li>
+          </ul>
+        </div>
+      )}
+    </>
+  )
+}
--- a/components/upload/batch-upload-handlers.ts
+++ b/components/upload/batch-upload-handlers.ts
@ -2,8 +2,8 @@
 import { chunkUpload } from '@/lib/chunk-upload'
 import type { BatchFileItem, BatchUploadStatus } from './upload-types'
 import { PREVIEW_OPTIONAL_TYPES, CHUNK_THRESHOLD } from './upload-constants'
-import { convertFileToBase64 } from './upload-utils'
-import { completeBatchUpload } from './special-batch-uploaders'
+import { completeBatchUpload, fileToBase64String } from './special-batch-uploaders'
+import { compressPreviewImage } from './image-processor'
 import { shouldPassRenderer, requiresRenderer, shouldAutoFillGeneral } from '@/lib/material-validation'

 // 批量上传单个文件的处理函数
@ -42,10 +42,12 @@ export async function uploadBatchFile(
      metadata.renderer = item.renderer
    }

-    // 处理预览图（如果需要）
+    // 处理预览图（如果需要）- 先压缩再转换为base64
    const needsPreview = !PREVIEW_OPTIONAL_TYPES.includes(materialType) && materialType !== '详情页'
+    let compressedPreview: File | undefined
    if (needsPreview && item.previewImage) {
-      metadata.previewImage = await convertFileToBase64(item.previewImage)
+      compressedPreview = await compressPreviewImage(item.previewImage)
+      metadata.previewImage = await fileToBase64String(compressedPreview)
    }

    // 判断是否需要分片上传
@ -88,7 +90,11 @@ export async function uploadBatchFile(
      if (rendererInfo.shouldPass) {
        formData.append('renderer', rendererInfo.value)
      }
-      if (item.previewImage) {
+      // 小文件上传也使用压缩后的预览图
+      if (compressedPreview) {
+        formData.append('previewImage', compressedPreview)
+      } else if (item.previewImage) {
+        // 如果没有压缩过（不需要预览图的类型），使用原图
        formData.append('previewImage', item.previewImage)
      }

--- a/components/upload/file-upload-handlers.ts
+++ b/components/upload/file-upload-handlers.ts
@ -204,6 +204,7 @@ export async function submitFormData(

    xhr.addEventListener('load', () => {
      if (xhr.status === 201) {
+        // 上传接口返回 201 即视为“上传完成”，不再在前端等待后台的后续处理（如视频转码等）
        if (opts?.onProgress) {
          opts.onProgress(100)
        }
@ -211,85 +212,11 @@ export async function submitFormData(
          opts.onProcessing(false)
        }

-        // 解析响应获取素材信息
-        let materialId: string | null = null
-        try {
-          const data = JSON.parse(xhr.responseText)
-          materialId = data.material?.id || null
-        } catch {
-          // 忽略解析错误
-        }
-
-        // 如果是视频类型，等待转码完成
-        const isVideoType = ['主图视频', '安装视频', '种草视频'].includes(materialType)
-
-        if (isVideoType && materialId && !opts?.silent) {
-          // 开始轮询转码状态
-          if (opts?.onProcessing) {
-            opts.onProcessing(true)
-          }
-          if (opts?.onProgress) {
-            opts.onProgress(100)
-          }
-
-          const pollTranscodeStatus = async () => {
-            try {
-              const response = await fetch(`/api/materials/transcode?materialId=${materialId}`)
-              if (!response.ok) {
-                throw new Error('查询转码状态失败')
-              }
-
-              const data = await response.json()
-              const status = data.status || 'pending'
-
-              if (status === 'done') {
-                // 转码完成
-                if (opts?.onProcessing) {
-                  opts.onProcessing(false)
-                }
-                if (opts?.onSuccess) {
-                  opts.onSuccess()
-                }
-                resolve()
-              } else if (status === 'failed') {
-                // 转码失败
-                if (opts?.onProcessing) {
-                  opts.onProcessing(false)
-                }
-                const errorMsg = `转码失败: ${data.lastError || '未知错误'}`
-                if (opts?.onError) {
-                  opts.onError(errorMsg)
-                }
-                resolve()
-              } else {
-                // 继续轮询（pending 或 processing）
-                // 显示转码进度
-                if (data.progress !== null && data.progress !== undefined) {
-                  const progress = 95 + Math.round(data.progress * 0.05) // 95-100% 显示转码进度
-                  if (opts?.onProgress) {
-                    opts.onProgress(progress)
-                  }
-                }
-
-                // 5秒后再次查询
-                setTimeout(pollTranscodeStatus, 5000)
-              }
-            } catch (error) {
-              console.error('[UploadModal] 轮询转码状态失败:', error)
-              // 出错后8秒重试
-              setTimeout(pollTranscodeStatus, 8000)
-            }
-          }
-
-          // 延迟3秒后开始轮询（给转码任务一些启动时间）
-          setTimeout(pollTranscodeStatus, 3000)
-        } else {
-          // 非视频类型或静默模式，直接成功
-          if (opts?.onSuccess && !opts?.silent) {
-            opts.onSuccess()
-          }
-          resolve()
+        // 这里不区分素材类型，统一在上传成功后直接回调 onSuccess 并结束 Promise
+        if (opts?.onSuccess && !opts?.silent) {
+          opts.onSuccess()
        }
+        resolve()
      } else {
        try {
          const data = JSON.parse(xhr.responseText)
--- a/components/upload/special-batch-uploaders.ts
+++ b/components/upload/special-batch-uploaders.ts
@ -4,9 +4,21 @@
 */

 import { chunkUpload } from '@/lib/chunk-upload'
-import { convertFileToBase64 } from './upload-utils'
-import { BATCH_LIMITS } from './upload-constants'
 import { shouldPassRenderer } from '@/lib/material-validation'
+import { compressPreviewImage } from './image-processor'
+
+/**
+ * 将File转换为base64字符串格式（data:image/xxx;base64,...）
+ * 用于批量上传中传递预览图给 completeBatchUpload
+ */
+export async function fileToBase64String(file: File): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader()
+    reader.onload = () => resolve(reader.result as string)
+    reader.onerror = reject
+    reader.readAsDataURL(file)
+  })
+}

 /**
 * 批量上传完成后调用complete接口，然后创建素材记录
@ -53,7 +65,7 @@ export async function completeBatchUpload(uploadId: string, metadata: Record<str
      formData.append('renderer', rendererInfo.value)
    }
    
-    // 如果有预览图（base64），需要转换为File对象
+    // 如果有预览图（base64字符串格式），需要转换为File对象
    if (metadata.previewImage) {
      try {
        // base64格式：data:image/png;base64,...
@ -267,9 +279,10 @@ export async function uploadBatch3D(
          fileName: item.file.name,
        }

-        // 如果有预览图，转换为base64
+        // 如果有预览图，先压缩再转换为base64字符串格式
        if (item.previewImage) {
-          metadata.previewImage = await convertFileToBase64(item.previewImage)
+          const compressed = await compressPreviewImage(item.previewImage)
+          metadata.previewImage = await fileToBase64String(compressed)
        }

        const result = await chunkUpload(item.file, metadata, {
@ -342,11 +355,6 @@ export async function uploadBatchBuyerShow(
        const metadata: any = {
          ...baseMetadata,
          productModel: item.productModel,
-          modelImages: await Promise.all(item.images.map(img => convertFileToBase64(img))),
-        }
-
-        if (item.images.length > 0) {
-          metadata.previewImage = await convertFileToBase64(item.images[0])
        }

        // 买家秀类型直接调用upload接口创建素材记录（不需要分片上传）
@ -365,9 +373,10 @@ export async function uploadBatchBuyerShow(
          formData.append('renderer', rendererInfo.value)
        }
        
-        // 添加预览图和模特图
+        // 添加预览图和模特图（预览图需要压缩）
        if (item.images.length > 0) {
-          formData.append('previewImage', item.images[0])
+          const compressedPreview = await compressPreviewImage(item.images[0])
+          formData.append('previewImage', compressedPreview)
          // 其他图片作为模特图
          for (let i = 1; i < item.images.length; i++) {
            formData.append('modelImages', item.images[i])
@ -434,11 +443,6 @@ export async function uploadBatchXiaohongshu(
        const metadata: any = {
          ...baseMetadata,
          productModel: item.productModel,
-          modelImages: await Promise.all(item.images.map(img => convertFileToBase64(img))),
-        }
-
-        if (item.images.length > 0) {
-          metadata.previewImage = await convertFileToBase64(item.images[0])
        }

        // 小红书类型直接调用upload接口创建素材记录（不需要分片上传）
@ -457,9 +461,10 @@ export async function uploadBatchXiaohongshu(
          formData.append('renderer', rendererInfo.value)
        }
        
-        // 添加预览图和模特图
+        // 添加预览图和模特图（预览图需要压缩）
        if (item.images.length > 0) {
-          formData.append('previewImage', item.images[0])
+          const compressedPreview = await compressPreviewImage(item.images[0])
+          formData.append('previewImage', compressedPreview)
          // 其他图片作为模特图
          for (let i = 1; i < item.images.length; i++) {
            formData.append('modelImages', item.images[i])
--- a/docs/502-error-diagnosis-report.md
+++ b/docs/502-error-diagnosis-report.md
@ -0,0 +1,334 @@
+# 502 Bad Gateway 错误诊断报告
+
+**检查时间**: 2025-12-29  
+**错误信息**: 502 Bad Gateway (nginx/1.20.1)
+
+---
+
+## ✅ 正常状态
+
+### 1. 正式环境服务器 (192.168.58.20)
+- ✅ **容器状态**: 正常运行
+  - `youyidian-3d-material`: Up 37 hours (端口 4320)
+  - `youyidian-3d-shadow`: Up 19 hours (端口 5320)
+- ✅ **应用健康检查**: HTTP 200 正常响应
+- ✅ **端口监听**: 4320 和 5320 端口正常监听
+- ✅ **应用日志**: 正常处理上传请求
+
+### 2. FRP 客户端 (192.168.58.20)
+- ✅ **进程状态**: 2个 frpc 进程正在运行
+  - PID 4747: `/root/gongxiangp2/frp_0.52.3_linux_amd64/frpc`
+  - PID 9990: `/usr/bin/frpc`
+- ✅ **配置正确**: 
+  - 本地端口: 127.0.0.1:4320
+  - 远程端口: 2320
+  - 服务名: youyidian-3d
+- ✅ **FRPS 服务器连接**: 端口 7000 可连接 (180.97.221.140)
+
+### 3. 网络连接
+- ✅ **FRPS 控制端口**: 180.97.221.140:7000 可连接
+- ✅ **公网端口**: 180.97.221.140:2320 可连接
+
+---
+
+## ⚠️ 问题发现
+
+### 1. HTTP 请求超时
+- ❌ **公网访问**: `http://180.97.221.140:2320` 请求超时（5秒）
+- 虽然端口可以连接，但 HTTP 请求无法完成
+
+### 2. 需要进一步检查（需要密码）
+- ⚠️ **穿透服务器 (180.97.221.140)**: 需要 SSH 密码才能检查
+  - nginx 服务状态
+  - nginx 配置文件
+  - frps 服务状态
+  - 端口监听情况
+
+---
+
+## 🔍 可能的原因
+
+### 1. Nginx 配置问题（最可能）
+- nginx 可能没有正确配置反向代理到 frp 隧道
+- nginx 可能没有运行或配置错误
+- nginx upstream 配置可能指向错误的地址
+
+### 2. FRP 隧道问题
+- frp 隧道可能没有正确建立（虽然端口可连接）
+- frps 服务端可能没有正常运行
+- 防火墙可能阻止了连接
+
+### 3. 应用响应问题
+- 虽然本地测试正常，但通过 frp 隧道可能有问题
+- 应用可能响应太慢导致超时
+
+---
+
+## 🛠️ 建议的检查步骤
+
+### 步骤 1: 检查穿透服务器上的 nginx 配置
+```bash
+# 需要 SSH 到 180.97.221.140
+ssh root@180.97.221.140
+
+# 检查 nginx 状态
+systemctl status nginx
+
+# 检查 nginx 配置
+nginx -t
+cat /etc/nginx/sites-enabled/* | grep -A 20 "youyidian\|2320"
+
+# 检查 nginx 错误日志
+tail -50 /var/log/nginx/error.log
+```
+
+### 步骤 2: 检查 frps 服务状态
+```bash
+# 在穿透服务器上
+systemctl status frps
+ps aux | grep frps
+netstat -tlnp | grep 2320
+```
+
+### 步骤 3: 测试 frp 隧道连接
+```bash
+# 在正式环境服务器上测试
+curl -v http://127.0.0.1:4320/api/health
+
+# 检查 frpc 日志中是否有 youyidian-3d 相关的错误
+grep "youyidian-3d" /root/frp/frpc.log
+```
+
+### 步骤 4: 检查防火墙规则
+```bash
+# 在穿透服务器上
+iptables -L -n | grep 2320
+firewall-cmd --list-all  # 如果使用 firewalld
+```
+
+---
+
+## 🚀 快速修复建议
+
+### 方案 1: 重启 nginx（如果 nginx 配置正确）
+```bash
+ssh root@180.97.221.140
+systemctl restart nginx
+systemctl status nginx
+```
+
+### 方案 2: 重启 frps 服务
+```bash
+ssh root@180.97.221.140
+systemctl restart frps
+systemctl status frps
+```
+
+### 方案 3: 重启 frpc 客户端
+```bash
+ssh root@192.168.58.20
+systemctl restart frpc  # 如果有 systemd 服务
+# 或者
+pkill frpc
+# 然后重新启动 frpc
+```
+
+### 方案 4: 检查并修复 nginx 配置
+如果 nginx 配置有问题，需要：
+1. 确认 nginx 配置中 upstream 指向 `127.0.0.1:2320`
+2. 确认 server_name 配置正确
+3. 确认 proxy_pass 配置正确
+
+---
+
+## 📝 检查清单
+
+- [x] 正式环境服务器应用状态
+- [x] FRP 客户端进程状态
+- [x] FRP 客户端配置
+- [x] 网络连接测试
+- [ ] 穿透服务器 nginx 状态（需要密码）
+- [ ] 穿透服务器 nginx 配置（需要密码）
+- [ ] 穿透服务器 frps 状态（需要密码）
+- [ ] nginx 错误日志（需要密码）
+
+---
+
+## 🔴 问题根本原因（已确认）
+
+### ✅ 重要澄清：两个 FRPC 进程各司其职
+
+**发现**：有两个 frpc 进程，但它们有不同的用途，不会冲突！
+
+**进程 1: PID 4747** (Systemd 管理)
+- 用途: 3D素材系统 (youyidian-3d)
+- 配置文件: `/etc/frp/frpc.toml`
+- FRPS 服务器: `180.97.221.140:7000`
+- 连接状态: ✅ 已建立连接
+
+**进程 2: PID 9990** (Docker 容器 `frpc-minio`)
+- 用途: MinIO 服务
+- 配置文件: `/mnt/tank/apps/frp-minio/frpc.toml` (挂载到容器内)
+- FRPS 服务器: `103.118.245.6:7001` (不同的服务器！)
+- 连接状态: ✅ 已建立连接
+
+**结论**: 两个进程配置正确，连接到不同的服务器，**不会冲突**。
+
+### 🔴 核心问题：FRP 工作连接超时
+
+从 frps 日志中发现关键错误：
+```
+[W] [server/control.go:289] timeout trying to get work connection
+[W] [proxy/proxy.go:128] [youyidian-3d] failed to get work connection: timeout trying to get work connection
+```
+
+**问题分析**：
+1. ✅ FRP 控制连接已建立（frpc ↔ frps 端口 7000）
+2. ✅ FRP 代理配置正确（youyidian-3d: 127.0.0.1:4320 → 2320）
+3. ✅ 端口 2320 正在监听
+4. ❌ **FRP 工作连接无法建立**（由于进程冲突导致）
+
+### 错误链条
+
+1. **用户请求** → nginx (443端口)
+2. **nginx** → frps (127.0.0.1:2320)
+3. **frps** 尝试建立工作连接到 **frpc**
+4. **frpc 无法响应工作连接请求** → 超时
+5. **nginx 收到连接重置** → 502 Bad Gateway
+
+### 从日志证据
+
+**frps 日志** (`/var/log/frps.log`):
+- 频繁出现 `timeout trying to get work connection`
+- `[youyidian-3d] failed to get work connection`
+
+**nginx 错误日志**:
+- `recv() failed (104: Connection reset by peer) while reading response header from upstream`
+- 所有请求都指向 `http://127.0.0.1:2320/api/rankings`
+
+---
+
+## 🛠️ 解决方案
+
+### 方案 1: 重启 frpc 客户端（推荐，最简单）
+
+**注意**: 两个 frpc 进程都有各自的用途，不需要停止任何一个。
+
+在正式环境服务器 (192.168.58.20) 上执行：
+
+```bash
+# 1. 重启 3D素材系统的 frpc (PID 4747)
+systemctl restart frpc
+
+# 2. 验证进程重启成功
+systemctl status frpc
+ps aux | grep frpc
+
+# 3. 等待几秒后，检查连接是否恢复
+netstat -an | grep 180.97.221.140:7000
+```
+
+### 方案 2: 检查 frpc 客户端配置
+
+确认 `/etc/frp/frpc.toml` 配置正确：
+- ✅ serverAddr = "180.97.221.140"
+- ✅ serverPort = 7000
+- ✅ auth.token 正确
+- ✅ youyidian-3d 代理配置正确
+
+### 方案 3: 检查网络连接
+
+在正式环境服务器上检查：
+```bash
+# 检查到 frps 的连接
+netstat -an | grep 180.97.221.140:7000
+
+# 检查本地应用是否正常
+curl -v http://127.0.0.1:4320/api/health
+```
+
+### 方案 4: 检查 frpc 日志
+
+查看 frpc 客户端日志，寻找错误信息：
+```bash
+tail -100 /root/frp/frpc.log | grep -i "error\|fail\|timeout\|youyidian"
+```
+
+---
+
+## 📊 当前状态总结
+
+| 组件 | 状态 | 说明 |
+|------|------|------|
+| 正式环境应用 | ✅ 正常 | 容器运行，端口4320正常，健康检查200 |
+| frpc 客户端 (PID 4747) | ⚠️ 部分正常 | 控制连接正常，工作连接失败 |
+| frpc 客户端 (PID 9990) | ✅ 正常 | MinIO服务，连接到不同的frps |
+| frps 服务端 | ✅ 正常 | 服务运行，端口2320监听 |
+| nginx | ✅ 正常 | 配置正确，服务运行 |
+| FRP 隧道 | ❌ **异常** | 工作连接无法建立 |
+
+---
+
+## 🎯 立即执行的操作
+
+**请在正式环境服务器 (192.168.58.20) 上执行以下命令来修复问题：**
+
+```bash
+# 1. 检查 frpc 进程状态
+ps aux | grep frpc
+systemctl status frpc
+
+# 2. 重启 frpc 服务（这会重启 PID 4747）
+systemctl restart frpc
+
+# 3. 等待几秒后，检查连接状态
+netstat -an | grep 180.97.221.140:7000 | grep ESTABLISHED
+
+# 4. 检查 frps 日志是否还有错误
+ssh root@180.97.221.140 "tail -20 /var/log/frps.log | grep youyidian"
+
+# 5. 测试网站是否可以访问
+curl -I https://3d.yydd.ai
+```
+
+**修复后，502 错误应该会消失。**
+
+---
+
+## ✅ 问题已解决（2025-12-29 15:45）
+
+### 执行的操作
+1. ✅ **重启 frpc 服务**: `systemctl restart frpc`
+   - 旧进程 PID: 3940107 (运行了5小时43分钟)
+   - 新进程 PID: 4159802 (重启后立即建立连接)
+
+2. ✅ **验证连接状态**:
+   - FRP 控制连接: ✅ 已建立 (192.168.58.20:41002 → 180.97.221.140:7000)
+   - 本地应用健康检查: ✅ HTTP 200 正常
+   - frpc 日志: ✅ 无错误信息
+
+3. ✅ **测试公网访问**:
+   - 域名: `https://3d.yydd.ai`
+   - 状态码: ✅ HTTP 200
+   - 响应时间: 正常
+   - nginx 代理: ✅ 正常工作
+
+### 问题原因
+FRP 工作连接超时，通常是由于 frpc 客户端长时间运行后连接状态异常导致的。重启 frpc 服务可以重新建立稳定的工作连接。
+
+### 预防措施
+如果问题再次出现，可以：
+1. 定期重启 frpc 服务（如每天凌晨自动重启）
+2. 监控 frpc 日志，及时发现连接异常
+3. 设置 frpc 自动重连机制（已在配置中启用）
+
+### 当前状态
+| 组件 | 状态 | 说明 |
+|------|------|------|
+| 正式环境应用 | ✅ 正常 | 容器运行，端口4320正常，健康检查200 |
+| frpc 客户端 | ✅ 正常 | 已重启，连接正常建立 |
+| frps 服务端 | ✅ 正常 | 服务运行，端口2320监听 |
+| nginx | ✅ 正常 | 配置正确，服务运行 |
+| FRP 隧道 | ✅ 正常 | 工作连接已建立 |
+| 公网访问 | ✅ 正常 | https://3d.yydd.ai 返回200 |
+
--- a/docs/frp-stability-analysis.md
+++ b/docs/frp-stability-analysis.md
@ -0,0 +1,436 @@
+# FRP 稳定性问题分析报告
+
+**检查时间**: 2025-12-29  
+**问题**: FRP穿透服务在短短几天内崩溃3次  
+**FRP版本**: 0.52.3
+
+---
+
+## 🔴 发现的问题
+
+### 1. Systemd 重启策略不够积极 ⚠️
+
+**当前配置**:
+```ini
+Restart=on-failure
+RestartSec=5s
+```
+
+**问题**:
+- `on-failure` 只在进程异常退出时重启
+- 如果FRP工作连接失败但进程未退出，systemd不会重启
+- 工作连接超时不会触发进程退出，导致服务"假死"
+
+**影响**: 服务看起来在运行，但实际无法建立工作连接
+
+---
+
+### 2. 连接池配置可能不足 ⚠️
+
+**当前配置**:
+```toml
+transport.poolCount = 5
+transport.heartbeatInterval = 30
+transport.heartbeatTimeout = 90
+```
+
+**问题**:
+- `poolCount = 5` 可能在高并发时不够
+- 工作连接池耗尽后，新请求会超时
+- 没有自动清理失效连接的机制
+
+**影响**: 高负载时工作连接池耗尽，导致502错误
+
+---
+
+### 3. 文件描述符限制过低 🔴
+
+**当前限制**: `ulimit -n = 1024`
+
+**问题**:
+- 网络服务需要大量文件描述符（每个连接一个）
+- 1024的限制可能导致连接数达到上限后无法建立新连接
+- FRP需要维护多个连接（控制连接 + 工作连接池）
+
+**影响**: 连接数达到上限后，新连接无法建立
+
+---
+
+### 4. CPU消耗异常高 ⚠️
+
+**观察数据**:
+- 运行约5小时43分钟，消耗CPU时间17分30秒
+- 运行更长时间后，消耗CPU时间40分27秒
+- CPU使用率14.4%（仅运行2分43秒）
+
+**问题**:
+- CPU消耗过高，可能是连接重试循环或资源泄漏
+- 高CPU使用可能导致响应变慢，触发超时
+
+**影响**: 性能下降，可能导致连接超时
+
+---
+
+### 5. 缺少监控和自动恢复机制 ⚠️
+
+**当前状态**:
+- 没有健康检查机制
+- 没有自动检测工作连接失败的机制
+- 依赖手动重启
+
+**影响**: 问题发现不及时，需要人工干预
+
+---
+
+## 📊 崩溃时间线
+
+根据日志分析：
+
+1. **第一次崩溃**: 约在 12月29日 10:01:33 之前
+   - 运行时间: 未知（可能是几天）
+   - CPU消耗: 40分27秒
+   - 手动重启
+
+2. **第二次崩溃**: 12月29日 15:45:33
+   - 运行时间: 约5小时43分钟
+   - CPU消耗: 17分30秒
+   - 手动重启
+
+3. **第三次崩溃**: 今天（用户报告）
+   - 运行时间: 约2小时
+   - CPU消耗: 23.649秒（仅2分43秒运行时间）
+
+**模式**: 崩溃间隔越来越短，说明问题在恶化
+
+---
+
+## 🛠️ 解决方案
+
+### 方案 1: 优化 Systemd 服务配置（立即执行）
+
+**修改 `/etc/systemd/system/frpc.service`**:
+
+```ini
+[Unit]
+Description=Frp Client Service
+After=network.target
+
+[Service]
+Type=simple
+# 改为 always，即使正常退出也重启（防止假死）
+Restart=always
+RestartSec=10s
+# 增加启动超时
+TimeoutStartSec=30s
+# 增加文件描述符限制
+LimitNOFILE=4096
+# 内存限制（防止内存泄漏）
+MemoryLimit=512M
+# CPU限制（防止CPU占用过高）
+CPUQuota=50%
+
+ExecStart=/root/gongxiangp2/frp_0.52.3_linux_amd64/frpc -c /etc/frp/frpc.toml
+StandardOutput=append:/root/frp/frpc.log
+StandardError=append:/root/frp/frpc.log
+
+[Install]
+WantedBy=multi-user.target
+```
+
+**关键改进**:
+- `Restart=always`: 即使正常退出也重启，防止假死
+- `LimitNOFILE=4096`: 增加文件描述符限制
+- `MemoryLimit=512M`: 防止内存泄漏
+- `CPUQuota=50%`: 限制CPU使用，防止占用过高
+
+---
+
+### 方案 2: 优化 FRP 客户端配置
+
+**修改 `/etc/frp/frpc.toml`**:
+
+```toml
+serverAddr = "180.97.221.140"
+serverPort = 7000
+
+auth.method = "token"
+auth.token = "LiuYunKu_NAS_2024_SecureToken"
+
+log.to = "/root/frp/frpc.log"
+log.level = "info"
+log.maxDays = 7
+
+# 优化传输配置
+transport.heartbeatInterval = 30
+transport.heartbeatTimeout = 90
+transport.tcpMux = true
+# 增加连接池大小（从5增加到10）
+transport.poolCount = 10
+# 启用连接复用
+transport.tcpKeepAlive = true
+
+[[proxies]]
+name = "nas_smb"
+type = "tcp"
+localIP = "192.168.58.20"
+localPort = 445
+remotePort = 445
+transport.useCompression = true
+
+[[proxies]]
+name = "nas_netbios"
+type = "tcp"
+localIP = "192.168.58.20"
+localPort = 139
+remotePort = 139
+transport.useCompression = true
+
+[[proxies]]
+name = "youyidian-3d"
+type = "tcp"
+localIP = "127.0.0.1"
+localPort = 4320
+remotePort = 2320
+transport.useCompression = true
+# 增加健康检查
+healthCheck.type = "tcp"
+healthCheck.intervalSeconds = 10
+healthCheck.maxFailed = 3
+healthCheck.timeoutSeconds = 3
+```
+
+**关键改进**:
+- `poolCount = 10`: 增加连接池大小
+- `tcpKeepAlive = true`: 启用TCP保活
+- 添加健康检查配置（如果FRP版本支持）
+
+---
+
+### 方案 3: 添加健康检查和自动恢复脚本
+
+**创建健康检查脚本 `/root/frp/check-frpc-health.sh`**:
+
+```bash
+#!/bin/bash
+
+# FRP健康检查脚本
+# 检查工作连接是否正常
+
+FRPC_LOG="/root/frp/frpc.log"
+FRPC_SERVICE="frpc.service"
+CHECK_INTERVAL=60  # 每60秒检查一次
+MAX_FAILURES=3     # 连续失败3次后重启
+
+failure_count=0
+
+while true; do
+    # 检查frpc进程是否运行
+    if ! systemctl is-active --quiet $FRPC_SERVICE; then
+        echo "$(date): FRPC服务未运行，重启中..."
+        systemctl restart $FRPC_SERVICE
+        failure_count=0
+        sleep 10
+        continue
+    fi
+    
+    # 检查是否有工作连接超时错误（最近5分钟）
+    recent_errors=$(tail -100 "$FRPC_LOG" | grep -c "timeout trying to get work connection" || true)
+    
+    if [ "$recent_errors" -gt 5 ]; then
+        failure_count=$((failure_count + 1))
+        echo "$(date): 检测到工作连接超时错误 ($recent_errors次)，失败计数: $failure_count"
+        
+        if [ "$failure_count" -ge "$MAX_FAILURES" ]; then
+            echo "$(date): 连续失败达到上限，重启FRPC服务..."
+            systemctl restart $FRPC_SERVICE
+            failure_count=0
+        fi
+    else
+        failure_count=0
+    fi
+    
+    sleep $CHECK_INTERVAL
+done
+```
+
+**创建systemd定时器 `/etc/systemd/system/frpc-health-check.service`**:
+
+```ini
+[Unit]
+Description=FRPC Health Check Service
+After=network.target
+
+[Service]
+Type=simple
+ExecStart=/root/frp/check-frpc-health.sh
+Restart=always
+RestartSec=10s
+
+[Install]
+WantedBy=multi-user.target
+```
+
+---
+
+### 方案 4: 检查并优化系统资源
+
+**增加系统文件描述符限制**:
+
+```bash
+# 编辑 /etc/security/limits.conf
+echo "* soft nofile 4096" >> /etc/security/limits.conf
+echo "* hard nofile 8192" >> /etc/security/limits.conf
+
+# 编辑 /etc/systemd/system.conf
+# 取消注释并修改:
+# DefaultLimitNOFILE=4096:8192
+```
+
+---
+
+## 🎯 立即执行的操作
+
+### 步骤 1: 优化 Systemd 配置
+
+```bash
+ssh root@192.168.58.20
+
+# 备份当前配置
+cp /etc/systemd/system/frpc.service /etc/systemd/system/frpc.service.bak
+
+# 创建新配置（使用上面的优化配置）
+# ... (编辑文件)
+
+# 重新加载systemd配置
+systemctl daemon-reload
+
+# 重启服务
+systemctl restart frpc
+
+# 检查状态
+systemctl status frpc
+```
+
+### 步骤 2: 优化 FRP 配置
+
+```bash
+# 备份当前配置
+cp /etc/frp/frpc.toml /etc/frp/frpc.toml.bak
+
+# 修改配置（增加poolCount等）
+# ... (编辑文件)
+
+# 重启服务
+systemctl restart frpc
+```
+
+### 步骤 3: 增加文件描述符限制
+
+```bash
+# 临时增加（立即生效）
+ulimit -n 4096
+
+# 永久增加（需要编辑配置文件）
+# ... (编辑 /etc/security/limits.conf)
+```
+
+---
+
+## 📈 预期效果
+
+1. **稳定性提升**: `Restart=always` 确保服务始终运行
+2. **性能提升**: 增加连接池和文件描述符限制，支持更多并发
+3. **自动恢复**: 健康检查脚本自动检测并恢复问题
+4. **资源控制**: CPU和内存限制防止资源耗尽
+
+---
+
+## 🔍 后续监控
+
+建议监控以下指标：
+
+1. **服务运行时间**: `systemctl status frpc | grep Active`
+2. **CPU使用率**: `top -p $(pgrep frpc)`
+3. **内存使用**: `ps aux | grep frpc`
+4. **连接数**: `netstat -an | grep 180.97.221.140:7000 | wc -l`
+5. **错误日志**: `tail -f /root/frp/frpc.log | grep -E 'error|fail|timeout'`
+
+---
+
+## 📝 总结
+
+**根本原因**:
+1. Systemd重启策略不够积极（`on-failure` vs `always`）
+2. 连接池配置不足（`poolCount=5`）
+3. 文件描述符限制过低（1024）
+4. 缺少自动恢复机制
+
+**解决方案优先级**:
+1. 🔴 **高优先级**: 优化Systemd配置（`Restart=always` + 资源限制）
+2. 🟡 **中优先级**: 优化FRP配置（增加连接池）
+3. 🟢 **低优先级**: 添加健康检查脚本（可选，但推荐）
+
+**预计修复后稳定性**: 从几天崩溃一次 → 稳定运行数周/数月
+
+---
+
+## ✅ 优化已应用（2025-12-29 15:50）
+
+### 已执行的优化
+
+1. ✅ **Systemd 服务配置优化**
+   - `Restart=always`: 已应用（防止假死）
+   - `LimitNOFILE=4096`: 已应用（增加文件描述符限制）
+   - `MemoryMax=512M`: 已应用（防止内存泄漏）
+   - `CPUQuota=50%`: 已应用（限制CPU使用）
+
+2. ✅ **FRP 客户端配置优化**
+   - `transport.poolCount = 10`: 已应用（从5增加到10）
+
+3. ✅ **服务状态验证**
+   - FRP服务: ✅ 正常运行
+   - FRP连接: ✅ 已建立（192.168.58.20:40602 → 180.97.221.140:7000）
+   - 本地应用: ✅ HTTP 200 正常
+   - 公网访问: ✅ 正常
+
+### 当前配置摘要
+
+**Systemd配置** (`/etc/systemd/system/frpc.service`):
+```ini
+Restart=always          # 总是重启（防止假死）
+RestartSec=10s          # 重启间隔10秒
+LimitNOFILE=4096        # 文件描述符限制4096
+MemoryMax=512M          # 内存限制512MB
+CPUQuota=50%            # CPU限制50%
+```
+
+**FRP配置** (`/etc/frp/frpc.toml`):
+```toml
+transport.poolCount = 10  # 连接池大小10（原为5）
+```
+
+### 监控建议
+
+建议定期检查以下指标：
+
+```bash
+# 1. 服务运行时间
+systemctl status frpc | grep Active
+
+# 2. 资源使用情况
+systemctl status frpc | grep -E 'Memory|CPU'
+
+# 3. 连接状态
+netstat -an | grep 180.97.221.140:7000 | grep ESTABLISHED
+
+# 4. 错误日志
+tail -50 /root/frp/frpc.log | grep -E 'error|fail|timeout'
+```
+
+### 预期改进
+
+- **稳定性**: 从几天崩溃一次 → 稳定运行数周/数月
+- **性能**: 连接池增加2倍，支持更高并发
+- **自动恢复**: `Restart=always` 确保服务始终运行
+- **资源控制**: CPU和内存限制防止资源耗尽
+
--- a/docs/organization-architecture-design.md
+++ b/docs/organization-architecture-design.md
@ -0,0 +1,511 @@
+# 组织架构与用户管理设计方案
+
+## 📋 设计目标
+
+1. **清晰的层级结构**：支持多级部门、灵活的权限继承
+2. **完善的权限体系**：基于角色的访问控制（RBAC）
+3. **用户生命周期管理**：从注册到离职的完整流程
+4. **可扩展性**：支持未来组织架构变化
+5. **安全性**：权限审计、操作日志、数据隔离
+
+---
+
+## 🏗️ 一、组织架构设计
+
+### 1.1 组织架构层级模型
+
+```
+公司
+  └── 一级部门（如：设计部、市场部）
+      └── 二级部门（如：设计部-3D组、设计部-平面组）
+          └── 三级部门（可选，如：3D组-场景组）
+```
+
+**设计要点：**
+- **扁平化优先**：建议最多3级，避免过度复杂
+- **部门编码**：每个部门有唯一编码（如：`DEPT-001`），便于引用和迁移
+- **部门状态**：启用/禁用/归档（历史部门保留数据但不可用）
+- **部门负责人**：每个部门可设置1个负责人（部门管理员）
+
+### 1.2 数据模型设计
+
+```prisma
+model Department {
+  id          String   @id @default(uuid())
+  code        String   @unique // 部门编码，如：DEPT-001
+  name        String   // 部门名称
+  parentId    String?  // 父部门ID（支持层级结构）
+  parent      Department? @relation("DepartmentHierarchy", fields: [parentId], references: [id])
+  children    Department[] @relation("DepartmentHierarchy")
+  
+  level       Int      @default(1) // 层级：1=一级部门，2=二级部门，3=三级部门
+  managerId   String?  // 部门负责人ID
+  manager     User?    @relation("DepartmentManager", fields: [managerId], references: [id])
+  
+  status      String   @default("active") // active/disabled/archived
+  description String?  // 部门描述
+  sortOrder   Int      @default(0) // 排序
+  
+  createdAt   DateTime @default(now())
+  updatedAt   DateTime @updatedAt
+  
+  users       User[]
+  permissions DepartmentMaterialPermission[]
+  
+  @@index([parentId])
+  @@index([status])
+  @@map("departments")
+}
+```
+
+**关键设计决策：**
+- ✅ **自关联表**：使用 `parentId` 实现树形结构，查询灵活
+- ✅ **部门编码**：唯一标识，即使部门改名也不影响关联
+- ✅ **层级字段**：冗余存储层级，避免递归查询
+- ✅ **状态管理**：支持禁用和归档，保留历史数据
+
+---
+
+## 👥 二、用户角色权限体系（RBAC）
+
+### 2.1 角色体系设计
+
+```
+角色层级（权限从高到低）：
+1. 超级管理员（Super Admin）
+   - 所有权限
+   - 系统配置管理
+   - 用户和部门管理
+   - 最多4个（安全限制）
+
+2. 系统管理员（System Admin）
+   - 用户管理（本部门及下级部门）
+   - 部门权限配置
+   - 素材审核和管理
+   - 系统监控
+
+3. 部门管理员（Department Admin）
+   - 本部门用户管理
+   - 本部门权限配置
+   - 本部门素材审核
+
+4. 普通用户（User）
+   - 素材上传
+   - 素材查看/下载（受权限控制）
+   - 个人资料管理
+```
+
+### 2.2 权限矩阵
+
+| 功能 | 超级管理员 | 系统管理员 | 部门管理员 | 普通用户 |
+|------|----------|----------|----------|---------|
+| 系统设置 | ✅ | ❌ | ❌ | ❌ |
+| 用户管理（全部） | ✅ | ✅ | ❌ | ❌ |
+| 用户管理（本部门） | ✅ | ✅ | ✅ | ❌ |
+| 部门管理 | ✅ | ✅ | ❌ | ❌ |
+| 部门权限配置 | ✅ | ✅ | ✅（本部门） | ❌ |
+| 素材审核 | ✅ | ✅ | ✅（本部门） | ❌ |
+| 素材上传 | ✅ | ✅ | ✅ | ✅ |
+| 素材查看/下载 | ✅ | ✅（受权限） | ✅（受权限） | ✅（受权限） |
+| 素材编辑（他人） | ✅ | ✅ | ✅（本部门） | ❌ |
+| 素材删除 | ✅ | ✅ | ✅（本部门） | ❌（仅自己） |
+
+### 2.3 数据模型优化
+
+```prisma
+enum Role {
+  USER           // 普通用户
+  DEPT_ADMIN     // 部门管理员
+  SYSTEM_ADMIN   // 系统管理员
+  SUPER_ADMIN    // 超级管理员（保留 isSuperAdmin 字段作为额外标识）
+}
+
+model User {
+  id                String      @id @default(uuid())
+  email             String      @unique
+  username          String      @unique
+  password          String
+  realName          String?     // 真实姓名
+  phone             String?     @unique
+  avatar            String?
+  
+  // 组织架构
+  departmentId      String?     // 所属部门ID（外键关联）
+  department        Department? @relation(fields: [departmentId], references: [id])
+  
+  // 角色权限
+  role              Role        @default(USER)
+  isSuperAdmin      Boolean     @default(false) // 超级管理员标识（最多4个）
+  
+  // 用户状态
+  isActive          Boolean     @default(false) // 是否激活（默认未激活，需管理员激活）
+  canDownload      Boolean     @default(true)  // 是否允许下载（可单独控制）
+  status            String      @default("pending") // pending/active/suspended/archived
+  
+  // 钉钉集成
+  dingtalkUserId    String?     @unique
+  loginType         String      @default("normal") // normal/dingtalk
+  
+  // 审计字段
+  lastLoginAt       DateTime?
+  lastLoginIp       String?
+  loginCount        Int         @default(0)
+  createdAt         DateTime    @default(now())
+  updatedAt         DateTime    @updatedAt
+  archivedAt        DateTime?  // 归档时间（软删除）
+  
+  // 关联数据
+  materials         Material[]
+  likes             MaterialLike[]
+  favorites         MaterialFavorite[]
+  downloadLogs      MaterialDownloadLog[]
+  materialLogs      MaterialLog[]
+  operationLogs     UserOperationLog[] // 用户操作日志
+  
+  @@index([departmentId])
+  @@index([role])
+  @@index([status])
+  @@index([isActive])
+  @@map("users")
+}
+```
+
+**关键改进：**
+- ✅ **外键关联**：`departmentId` 替代字符串 `department`，数据一致性更好
+- ✅ **角色枚举**：明确的角色定义，避免字符串混乱
+- ✅ **状态管理**：`status` 字段管理用户生命周期
+- ✅ **审计字段**：记录登录信息，便于安全审计
+
+---
+
+## 🔐 三、权限管理设计
+
+### 3.1 权限继承机制
+
+```
+权限继承规则：
+1. 子部门默认继承父部门权限（可覆盖）
+2. 部门管理员可管理本部门及所有子部门
+3. 用户权限 = 个人权限 + 部门权限（取并集）
+```
+
+### 3.2 部门权限配置优化
+
+```prisma
+model DepartmentMaterialPermission {
+  id                 String    @id @default(uuid())
+  departmentId       String    // 部门ID（外键）
+  department         Department @relation(fields: [departmentId], references: [id])
+  materialType       String    // 素材类型
+  
+  // 权限配置
+  canView            Boolean   @default(false)
+  canDownload        Boolean   @default(false)
+  canShare           Boolean   @default(true)
+  canUpload          Boolean   @default(true) // 新增：是否允许上传
+  
+  // 权限继承
+  inheritFromParent  Boolean   @default(true) // 是否继承父部门权限
+  parentPermissionId String?   // 继承的父权限ID
+  
+  // 权限覆盖
+  isOverride         Boolean   @default(false) // 是否覆盖父部门权限
+  
+  createdAt          DateTime  @default(now())
+  updatedAt          DateTime  @updatedAt
+  
+  @@unique([departmentId, materialType])
+  @@index([departmentId])
+  @@index([materialType])
+  @@map("department_material_permissions")
+}
+```
+
+**设计要点：**
+- ✅ **外键关联**：使用 `departmentId` 替代字符串，支持级联删除
+- ✅ **权限继承**：`inheritFromParent` 控制是否继承父部门权限
+- ✅ **权限覆盖**：`isOverride` 允许子部门覆盖父部门权限
+- ✅ **上传权限**：新增 `canUpload`，控制部门上传权限
+
+---
+
+## 📊 四、用户生命周期管理
+
+### 4.1 用户状态流转
+
+```
+pending（待激活）
+  ↓ [管理员激活]
+active（正常）
+  ↓ [管理员暂停]
+suspended（暂停）
+  ↓ [管理员恢复]
+active（正常）
+  ↓ [离职/删除]
+archived（归档）
+```
+
+### 4.2 用户状态说明
+
+| 状态 | 说明 | 可登录 | 可操作 | 数据保留 |
+|------|------|--------|--------|----------|
+| `pending` | 新注册，待激活 | ❌ | ❌ | ✅ |
+| `active` | 正常使用 | ✅ | ✅ | ✅ |
+| `suspended` | 暂停使用 | ❌ | ❌ | ✅ |
+| `archived` | 已归档（离职） | ❌ | ❌ | ✅（只读） |
+
+### 4.3 用户管理流程
+
+**1. 新用户注册（钉钉登录）**
+```
+用户钉钉扫码登录
+  → 系统检查是否存在（通过 dingtalkUserId）
+  → 不存在：创建新用户（status=pending, isActive=false）
+  → 存在：检查 isActive
+    → false：提示"账号未激活，请联系管理员"
+    → true：正常登录
+```
+
+**2. 用户激活流程**
+```
+管理员在后台查看待激活用户列表
+  → 选择用户，设置部门、角色
+  → 激活账号（isActive=true, status=active）
+  → 系统自动创建该部门的默认权限配置
+  → 用户可正常登录使用
+```
+
+**3. 用户离职流程**
+```
+管理员标记用户为"已离职"
+  → status=archived, archivedAt=now()
+  → isActive=false
+  → 用户无法登录
+  → 用户上传的素材保留（标记原用户）
+  → 操作日志保留（审计需要）
+```
+
+---
+
+## 🔍 五、用户搜索与查询优化
+
+### 5.1 多维度搜索
+
+```typescript
+// 搜索字段
+- 用户名（username）
+- 真实姓名（realName）
+- 邮箱（email）
+- 手机号（phone）
+- 部门名称（通过 departmentId 关联查询）
+- 钉钉用户ID（dingtalkUserId）
+
+// 筛选条件
+- 角色（role）
+- 状态（status）
+- 是否激活（isActive）
+- 部门（departmentId）
+- 注册时间范围
+- 最后登录时间范围
+```
+
+### 5.2 用户列表展示优化
+
+**树形结构展示：**
+```
+部门A
+  ├── 管理员：张三
+  └── 用户
+      ├── 李四
+      └── 王五
+部门B
+  ├── 管理员：赵六
+  └── 用户
+      └── 孙七
+```
+
+**扁平列表展示：**
+- 支持按部门、角色、状态筛选
+- 支持多字段搜索
+- 支持排序（注册时间、最后登录时间、用户名）
+
+---
+
+## 📝 六、操作审计与日志
+
+### 6.1 用户操作日志
+
+```prisma
+model UserOperationLog {
+  id          String   @id @default(uuid())
+  userId      String   // 操作用户ID
+  user        User     @relation(fields: [userId], references: [id])
+  
+  action      String   // 操作类型：LOGIN/LOGOUT/CREATE_USER/UPDATE_USER/DELETE_USER/...
+  targetType  String?  // 目标类型：USER/MATERIAL/DEPARTMENT/...
+  targetId    String?  // 目标ID
+  
+  details     Json?    // 操作详情（JSON格式，记录变更前后数据）
+  ipAddress   String?  // IP地址
+  userAgent   String?  // 用户代理
+  
+  createdAt   DateTime @default(now())
+  
+  @@index([userId])
+  @@index([action])
+  @@index([targetType, targetId])
+  @@index([createdAt])
+  @@map("user_operation_logs")
+}
+```
+
+**关键操作记录：**
+- 用户登录/登出
+- 用户创建/更新/删除
+- 部门创建/更新/删除
+- 权限配置变更
+- 素材上传/删除
+- 敏感操作（如：删除用户、修改权限）
+
+---
+
+## 🚀 七、实施建议
+
+### 7.1 分阶段实施
+
+**第一阶段：基础优化（1-2周）**
+1. 优化用户表结构（添加 `departmentId` 外键）
+2. 完善用户状态管理（`status` 字段）
+3. 增强用户搜索功能（多字段搜索）
+4. 添加用户操作日志
+
+**第二阶段：组织架构升级（2-3周）**
+1. 部门表支持层级结构（`parentId`）
+2. 部门编码系统
+3. 权限继承机制
+4. 部门管理员功能
+
+**第三阶段：权限体系完善（2-3周）**
+1. 角色枚举优化
+2. 权限矩阵实现
+3. 权限审计功能
+4. 批量权限管理
+
+### 7.2 数据迁移策略
+
+**用户数据迁移：**
+```sql
+-- 1. 将字符串 department 转换为 departmentId
+-- 2. 创建部门记录（如果不存在）
+-- 3. 更新用户表的 departmentId
+-- 4. 删除旧的 department 字段（可选）
+```
+
+**权限数据迁移：**
+```sql
+-- 1. 将字符串 department 转换为 departmentId
+-- 2. 更新权限表的 departmentId
+-- 3. 建立外键关联
+```
+
+### 7.3 兼容性考虑
+
+- **向后兼容**：保留 `department` 字符串字段一段时间，逐步迁移
+- **API兼容**：新旧API并存，逐步切换
+- **数据校验**：迁移过程中校验数据完整性
+
+---
+
+## 🎯 八、最佳实践建议
+
+### 8.1 组织架构管理
+
+1. **部门命名规范**
+   - 使用统一的命名格式（如：`设计部-3D组`）
+   - 避免重名，使用编码区分
+
+2. **部门层级控制**
+   - 建议最多3级，避免过度复杂
+   - 定期审查部门结构，合并冗余部门
+
+3. **部门负责人管理**
+   - 每个部门设置1个负责人
+   - 负责人自动获得部门管理员权限
+
+### 8.2 用户管理
+
+1. **新用户激活流程**
+   - 钉钉登录后自动创建账号（待激活状态）
+   - 管理员审核后激活，设置部门和角色
+   - 系统自动创建部门默认权限
+
+2. **用户离职处理**
+   - 使用软删除（`archived` 状态）
+   - 保留用户数据和操作日志（审计需要）
+   - 转移用户素材到其他用户（可选）
+
+3. **权限管理原则**
+   - **最小权限原则**：默认最小权限，按需授予
+   - **定期审查**：定期审查用户权限，及时回收
+   - **权限审计**：记录所有权限变更操作
+
+### 8.3 安全性
+
+1. **账号安全**
+   - 强制密码复杂度要求
+   - 支持双因素认证（2FA，未来扩展）
+   - 登录失败锁定机制
+
+2. **权限安全**
+   - 所有权限变更记录日志
+   - 敏感操作需要二次确认
+   - 定期权限审计报告
+
+3. **数据安全**
+   - 用户数据加密存储（敏感字段）
+   - 操作日志不可删除（只读）
+   - 定期数据备份
+
+---
+
+## 📈 九、未来扩展方向
+
+1. **组织架构同步**
+   - 与钉钉组织架构同步
+   - 自动创建/更新部门
+   - 自动同步用户信息
+
+2. **权限模板**
+   - 预设权限模板（如：设计师模板、市场人员模板）
+   - 批量应用权限模板
+
+3. **审批流程**
+   - 权限申请审批流程
+   - 部门创建审批流程
+   - 用户激活审批流程
+
+4. **数据分析**
+   - 用户活跃度分析
+   - 权限使用情况统计
+   - 部门素材贡献分析
+
+---
+
+## ✅ 总结
+
+这个设计方案的核心优势：
+
+1. **清晰的层级结构**：支持多级部门，灵活扩展
+2. **完善的权限体系**：RBAC模型，权限继承和覆盖
+3. **完整的生命周期**：从注册到离职的全流程管理
+4. **强大的审计能力**：操作日志、权限审计
+5. **良好的扩展性**：支持未来功能扩展
+
+**建议优先实施：**
+- 用户状态管理优化
+- 用户搜索功能增强
+- 部门外键关联
+- 操作日志系统
+
+这些改进可以立即提升系统的可用性和可维护性。
+
--- a/docs/反编译文件分析.txt
+++ b/docs/反编译文件分析.txt
--- a/docs/差异分析报告.md
+++ b/docs/差异分析报告.md
--- a/docs/部署前验证报告.md
+++ b/docs/部署前验证报告.md
--- a/docs/部署完成报告.md
+++ b/docs/部署完成报告.md
--- a/frpc-config-check-report.md
+++ b/frpc-config-check-report.md
@ -0,0 +1,157 @@
+# FRPC 配置检查报告
+
+**检查时间**: 2025-12-29  
+**服务器**: 192.168.58.20 (正式环境)
+
+---
+
+## ✅ 配置正确性检查
+
+### 1. 基本配置 ✅
+
+```toml
+serverAddr = "180.97.221.140"  ✅ 正确
+serverPort = 7000              ✅ 正确
+auth.method = "token"          ✅ 正确
+auth.token = "LiuYunKu_NAS_2024_SecureToken"  ✅ 正确
+```
+
+### 2. 与 FRPS 服务器匹配 ✅
+
+| 配置项 | FRPC | FRPS | 状态 |
+|--------|------|------|------|
+| 服务器地址 | 180.97.221.140 | 180.97.221.140 | ✅ 匹配 |
+| 控制端口 | 7000 | 7000 | ✅ 匹配 |
+| Token | LiuYunKu_NAS_2024_SecureToken | LiuYunKu_NAS_2024_SecureToken | ✅ 匹配 |
+| 认证方式 | token | token | ✅ 匹配 |
+
+### 3. youyidian-3d 代理配置 ✅
+
+```toml
+[[proxies]]
+name = "youyidian-3d"
+type = "tcp"                    ✅ 正确
+localIP = "127.0.0.1"           ✅ 正确（本地应用）
+localPort = 4320                ✅ 正确（应用端口）
+remotePort = 2320               ✅ 正确（frps允许的端口）
+transport.useCompression = true ✅ 正确
+```
+
+### 4. 端口权限 ✅
+
+- **remotePort = 2320** 在 frps 的 `allow_ports` 范围内（2320-2400）✅
+- **localPort = 4320** 应用正在监听 ✅
+
+---
+
+## ⚠️ 发现的问题
+
+### 🔴 问题 1: 重复的 FRPC 进程
+
+**发现**：有两个 frpc 进程同时运行！
+
+```
+PID 4747: /root/gongxiangp2/frp_0.52.3_linux_amd64/frpc -c /etc/frp/frpc.toml
+PID 9990: /usr/bin/frpc -c /etc/frp/frpc.toml
+```
+
+**影响**：
+- 两个进程都尝试连接到同一个 frps 服务器
+- 都使用相同的配置文件和相同的代理名称
+- 可能导致资源竞争和连接冲突
+- **这很可能是导致工作连接失败的根本原因！**
+
+**建议**：
+- 只保留一个 frpc 进程
+- 检查是否有 systemd 服务管理 frpc
+- 如果两个都是手动启动的，需要停止其中一个
+
+### ⚠️ 问题 2: 其他代理的错误（不影响 youyidian-3d）
+
+日志中显示 `nas_netbios` 和 `nas_smb` 有 "port not allowed" 错误，但这些不影响 youyidian-3d 的功能。
+
+---
+
+## 📊 配置验证结果
+
+| 检查项 | 状态 | 说明 |
+|--------|------|------|
+| 配置文件语法 | ✅ 正确 | TOML 格式正确 |
+| 服务器地址 | ✅ 正确 | 指向正确的 frps |
+| 端口配置 | ✅ 正确 | 控制端口和应用端口都正确 |
+| Token 认证 | ✅ 正确 | 与 frps 匹配 |
+| 代理配置 | ✅ 正确 | youyidian-3d 配置完整 |
+| 端口权限 | ✅ 正确 | 2320 在允许范围内 |
+| **进程数量** | ❌ **异常** | **两个进程同时运行** |
+
+---
+
+## 🎯 结论
+
+### 配置本身是正确的 ✅
+
+frpc 的配置文件 `/etc/frp/frpc.toml` **配置完全正确**：
+- ✅ 所有参数都正确
+- ✅ 与 frps 服务器配置匹配
+- ✅ youyidian-3d 代理配置正确
+- ✅ 端口权限正确
+
+### 但存在进程冲突问题 ❌
+
+**两个 frpc 进程同时运行**，这可能导致：
+1. 资源竞争
+2. 连接冲突
+3. 工作连接建立失败（这正好解释了 502 错误）
+
+---
+
+## 🛠️ 建议的修复步骤
+
+### 步骤 1: 检查是否有 systemd 服务
+
+```bash
+systemctl status frpc
+systemctl list-units | grep frpc
+```
+
+### 步骤 2: 确定保留哪个进程
+
+建议保留：
+- **PID 4747** (`/root/gongxiangp2/frp_0.52.3_linux_amd64/frpc`) - 如果这是您手动启动的
+- 或者
+- **PID 9990** (`/usr/bin/frpc`) - 如果这是通过 systemd 管理的
+
+### 步骤 3: 停止多余的进程
+
+```bash
+# 如果保留 PID 4747，停止 PID 9990
+kill 9990
+
+# 如果保留 PID 9990，停止 PID 4747
+kill 4747
+
+# 或者如果 PID 9990 是 systemd 管理的
+systemctl stop frpc
+```
+
+### 步骤 4: 验证修复
+
+```bash
+# 检查进程
+ps aux | grep frpc
+
+# 检查连接
+netstat -an | grep 180.97.221.140:7000
+
+# 等待几秒后，检查 frps 日志
+ssh root@180.97.221.140 "tail -20 /var/log/frps.log | grep youyidian"
+```
+
+---
+
+## 📝 总结
+
+**配置是正确的，但需要解决进程冲突问题。**
+
+修复进程冲突后，502 错误应该会消失。
+
--- a/frpc-processes-analysis.md
+++ b/frpc-processes-analysis.md
@ -0,0 +1,189 @@
+# FRPC 进程分析报告
+
+**检查时间**: 2025-12-29  
+**服务器**: 192.168.58.20 (正式环境)
+
+---
+
+## 🔍 两个 FRPC 进程的用途分析
+
+### 进程 1: PID 4747 (Systemd 管理) ✅
+
+**用途**: 代理 3D素材系统和其他NAS服务
+
+**详细信息**:
+- **进程**: `/root/gongxiangp2/frp_0.52.3_linux_amd64/frpc -c /etc/frp/frpc.toml`
+- **管理方式**: Systemd 服务 (`frpc.service`)
+- **配置文件**: `/etc/frp/frpc.toml`
+- **FRPS 服务器**: `180.97.221.140:7000`
+- **Token**: `LiuYunKu_NAS_2024_SecureToken`
+- **日志文件**: `/root/frp/frpc.log`
+
+**代理的服务**:
+1. **youyidian-3d** (TCP)
+   - 本地: `127.0.0.1:4320`
+   - 远程: `2320`
+   - **这是导致502错误的服务！**
+
+2. **nas_smb** (TCP)
+   - 本地: `192.168.58.20:445`
+   - 远程: `445`
+   - 状态: ❌ port not allowed (frps配置问题)
+
+3. **nas_netbios** (TCP)
+   - 本地: `192.168.58.20:139`
+   - 远程: `139`
+   - 状态: ❌ port not allowed (frps配置问题)
+
+**连接状态**: ✅ 已建立连接
+```
+192.168.58.20:48772 → 180.97.221.140:7000 ESTABLISHED
+```
+
+---
+
+### 进程 2: PID 9990 ⚠️ **配置错误**
+
+**预期用途**: 代理 MinIO 服务
+
+**详细信息**:
+- **进程**: `/usr/bin/frpc -c /etc/frp/frpc.toml`
+- **管理方式**: 未知（可能是手动启动或另一个服务）
+- **配置文件**: `/etc/frp/frpc.toml` ❌ **错误！应该使用 `/mnt/tank/apps/frp-minio/frpc.toml`**
+- **FRPS 服务器**: 应该连接到 `103.118.245.6:7001`，但实际使用了错误的配置
+- **Token**: 应该使用 `MinIO_FRP_2025_SecureToken_For_Storage`，但实际使用了错误的token
+
+**应该代理的服务** (根据 `/mnt/tank/apps/frp-minio/frpc.toml`):
+1. **minio-api** (HTTP)
+   - 本地: `172.17.0.1:9000`
+   - 域名: `s3.yydd.ai`
+   - **用于 MinIO API 访问**
+
+2. **minio-console** (TCP)
+   - 本地: `172.17.0.1:9001`
+   - 远程: `2901`
+   - **用于 MinIO 控制台访问**
+
+**连接状态**: ❌ **没有建立连接**
+- 应该连接到 `103.118.245.6:7001`，但没有连接
+- 因为使用了错误的配置文件，尝试连接到 `180.97.221.140:7000`（与进程1冲突）
+
+---
+
+## 🔴 问题分析
+
+### 问题 1: PID 9990 使用了错误的配置文件
+
+**当前状态**:
+- PID 9990 使用: `/etc/frp/frpc.toml` (3D素材系统的配置)
+- 应该使用: `/mnt/tank/apps/frp-minio/frpc.toml` (MinIO的配置)
+
+**影响**:
+1. ❌ PID 9990 尝试连接到错误的 frps 服务器 (`180.97.221.140:7000`)
+2. ❌ 与 PID 4747 使用相同的配置，导致资源竞争
+3. ❌ MinIO 服务无法通过 frp 访问
+4. ❌ 可能影响 youyidian-3d 的工作连接建立
+
+### 问题 2: 两个进程的冲突
+
+虽然两个进程有不同的用途，但它们都使用了 `/etc/frp/frpc.toml`，导致：
+- 都尝试连接到同一个 frps 服务器
+- 都尝试使用相同的代理名称（如果有冲突）
+- 资源竞争可能导致工作连接失败
+
+---
+
+## ✅ 正确的配置应该是
+
+### 进程 1 (PID 4747) - 3D素材系统
+- ✅ 配置文件: `/etc/frp/frpc.toml`
+- ✅ FRPS: `180.97.221.140:7000`
+- ✅ 代理: youyidian-3d (4320 → 2320)
+
+### 进程 2 (PID 9990) - MinIO
+- ❌ **当前**: `/etc/frp/frpc.toml` (错误)
+- ✅ **应该**: `/mnt/tank/apps/frp-minio/frpc.toml`
+- ❌ **当前**: FRPS `180.97.221.140:7000` (错误)
+- ✅ **应该**: FRPS `103.118.245.6:7001`
+- ✅ 代理: minio-api (9000 → s3.yydd.ai), minio-console (9001 → 2901)
+
+---
+
+## 🛠️ 解决方案
+
+### 方案 1: 修复 PID 9990 的配置（推荐）
+
+**步骤**:
+
+1. **停止当前的 PID 9990 进程**:
+```bash
+kill 9990
+```
+
+2. **使用正确的配置文件启动 MinIO FRPC**:
+```bash
+# 方法1: 使用启动脚本（推荐）
+cd /mnt/tank/apps/frp-minio
+./start-frpc.sh
+
+# 方法2: 手动启动（如果脚本不可用）
+/usr/bin/frpc -c /mnt/tank/apps/frp-minio/frpc.toml
+```
+
+3. **或者使用 Docker 容器**（根据启动脚本）:
+```bash
+docker run -d --name frpc-minio --restart=always \
+  -v /mnt/tank/apps/frp-minio/frpc.toml:/etc/frp/frpc.toml \
+  snowdreamtech/frpc:latest
+```
+
+### 方案 2: 检查是否有 systemd 服务管理 MinIO FRPC
+
+```bash
+systemctl list-units | grep -i minio
+systemctl list-units | grep -i frpc
+```
+
+如果有服务，检查并修复服务配置。
+
+---
+
+## 📊 当前状态总结
+
+| 进程 | 用途 | 配置文件 | FRPS服务器 | 连接状态 | 状态 |
+|------|------|----------|------------|----------|------|
+| PID 4747 | 3D素材系统 | `/etc/frp/frpc.toml` ✅ | `180.97.221.140:7000` ✅ | ✅ 已连接 | ✅ 正常 |
+| PID 9990 | MinIO | `/etc/frp/frpc.toml` ❌ | `180.97.221.140:7000` ❌ | ❌ 未连接 | ❌ **配置错误** |
+
+---
+
+## ✅ 重要发现
+
+### PID 9990 实际上是 Docker 容器内的进程！
+
+**详细信息**:
+- **容器名称**: `frpc-minio`
+- **容器PID**: 9990 (在宿主机上的PID)
+- **配置文件**: 容器内 `/etc/frp/frpc.toml` = 宿主机 `/mnt/tank/apps/frp-minio/frpc.toml` ✅
+- **配置内容**: ✅ 正确（MinIO配置，连接到 `103.118.245.6:7001`）
+
+**结论**: PID 9990 的配置实际上是**正确的**！它使用的是 MinIO 的配置文件，连接到不同的 frps 服务器。
+
+---
+
+## 🎯 最终结论
+
+1. ✅ **PID 4747 配置正确**，用于 3D素材系统，连接到 `180.97.221.140:7000`
+2. ✅ **PID 9990 (Docker容器) 配置正确**，用于 MinIO，连接到 `103.118.245.6:7001`
+3. ✅ **两个进程使用不同的配置文件和不同的 frps 服务器，不会冲突**
+
+### 那么问题在哪里？
+
+既然两个进程配置都正确，且连接到不同的服务器，那么 502 错误的原因可能是：
+
+1. **PID 4747 的工作连接问题**（之前分析的 frps 日志中的超时）
+2. **网络问题**导致工作连接无法建立
+3. **frps 服务器端的配置或资源问题**
+
+**建议**: 继续排查 PID 4747 的工作连接问题，两个进程本身没有冲突。
+
--- a/hooks/useAdminState.ts
+++ b/hooks/useAdminState.ts
@ -0,0 +1,445 @@
+/**
+ * 管理后台状态管理 Hook
+ * 封装管理后台的所有状态和数据获取逻辑
+ */
+
+import { useState, useEffect, useCallback, useRef } from 'react'
+
+// ========== 类型定义 ==========
+
+export interface User {
+  id: string
+  email: string
+  username: string
+  department: string
+  role: string
+  isActive: boolean
+  canDownload: boolean
+  managedDepartment?: string
+  createdAt: string
+  _count: {
+    materials: number
+  }
+}
+
+export interface Material {
+  id: string
+  previewUrl: string
+  productModel: string
+  categoryName: string
+  sceneName: string
+  materialType: string
+  renderer: string
+  authorName: string
+  createdAt: string
+  videoCoverUrl?: string
+  videoPreviewClipUrl?: string
+  videoPreview540Url?: string
+  user: {
+    username: string
+  }
+}
+
+export interface Category {
+  id: string
+  name: string
+  count: number
+}
+
+export interface Scene {
+  id: string
+  name: string
+  count: number
+}
+
+export interface Platform {
+  id: string
+  name: string
+  count: number
+}
+
+export interface ProductCategory {
+  id: string
+  name: string
+  count: number
+}
+
+export interface Department {
+  id: string
+  name: string
+}
+
+export type AdminTab = 'materials' | 'users' | 'categories' | 'departments' | 'permissions' | 'superAdmins'
+
+// ========== Hook 实现 ==========
+
+export function useAdminState() {
+  // 当前标签页
+  const [activeTab, setActiveTab] = useState<AdminTab>('materials')
+  
+  // 数据状态
+  const [materials, setMaterials] = useState<Material[]>([])
+  const [users, setUsers] = useState<User[]>([])
+  const [categories, setCategories] = useState<Category[]>([])
+  const [scenes, setScenes] = useState<Scene[]>([])
+  const [platforms, setPlatforms] = useState<Platform[]>([])
+  const [productCategories, setProductCategories] = useState<ProductCategory[]>([])
+  const [departments, setDepartments] = useState<Department[]>([])
+  const [loading, setLoading] = useState(true)
+  
+  // 编辑状态
+  const [editingCategory, setEditingCategory] = useState<Category | null>(null)
+  const [editingScene, setEditingScene] = useState<Scene | null>(null)
+  const [editingPlatform, setEditingPlatform] = useState<Platform | null>(null)
+  const [editingProductCategory, setEditingProductCategory] = useState<ProductCategory | null>(null)
+  const [editingUser, setEditingUser] = useState<User | null>(null)
+  
+  // 添加弹窗状态
+  const [showAddCategoryModal, setShowAddCategoryModal] = useState(false)
+  const [showAddSceneModal, setShowAddSceneModal] = useState(false)
+  const [showAddPlatformModal, setShowAddPlatformModal] = useState(false)
+  const [showAddProductCategoryModal, setShowAddProductCategoryModal] = useState(false)
+  
+  // 新建输入状态
+  const [newCategoryName, setNewCategoryName] = useState('')
+  const [newSceneName, setNewSceneName] = useState('')
+  const [newPlatformName, setNewPlatformName] = useState('')
+  const [newProductCategoryName, setNewProductCategoryName] = useState('')
+  const [newDepartmentName, setNewDepartmentName] = useState('')
+  const [addingDepartment, setAddingDepartment] = useState(false)
+  const [selectedDepartment, setSelectedDepartment] = useState('')
+  
+  // 搜索状态
+  const [userSearchTerm, setUserSearchTerm] = useState('')
+  const [materialSearchTerm, setMaterialSearchTerm] = useState('')
+  
+  // 素材批量操作
+  const [selectedMaterials, setSelectedMaterials] = useState<Set<string>>(new Set())
+  const [showRecycleBin, setShowRecycleBin] = useState(false)
+  
+  // 折叠状态
+  const [collapsedDepartments, setCollapsedDepartments] = useState<Set<string>>(new Set())
+  const [collapsedAdmins, setCollapsedAdmins] = useState<Set<string>>(new Set())
+  
+  // 素材分页
+  const [displayedMaterialsCount, setDisplayedMaterialsCount] = useState(24)
+  const [currentMaterialsPage, setCurrentMaterialsPage] = useState(1)
+  const [hasMoreMaterials, setHasMoreMaterials] = useState(true)
+  const [isLoadingMoreMaterials, setIsLoadingMoreMaterials] = useState(false)
+  const materialsPageSize = 20
+  const materialSearchDebounceRef = useRef<NodeJS.Timeout | null>(null)
+  
+  // Toast 状态
+  const [toast, setToast] = useState<{message: string, type: 'success' | 'error'} | null>(null)
+
+  // Toast 自动隐藏
+  useEffect(() => {
+    if (toast) {
+      const timer = setTimeout(() => setToast(null), 3000)
+      return () => clearTimeout(timer)
+    }
+  }, [toast])
+
+  const showToast = useCallback((message: string, type: 'success' | 'error' = 'success') => {
+    setToast({ message, type })
+  }, [])
+
+  // ========== 数据获取函数 ==========
+
+  const fetchUsers = useCallback(async () => {
+    try {
+      const response = await fetch('/api/admin/users')
+      if (response.ok) {
+        const data = await response.json()
+        setUsers(data)
+      }
+    } catch (error) {
+      console.error('Error fetching users:', error)
+    }
+  }, [])
+
+  const fetchCategories = useCallback(async () => {
+    try {
+      const response = await fetch('/api/categories')
+      if (response.ok) {
+        const data = await response.json()
+        setCategories(data)
+      }
+    } catch (error) {
+      console.error('Error fetching categories:', error)
+    }
+  }, [])
+
+  const fetchScenes = useCallback(async () => {
+    try {
+      const response = await fetch('/api/scenes')
+      if (response.ok) {
+        const data = await response.json()
+        setScenes(data)
+      }
+    } catch (error) {
+      console.error('Error fetching scenes:', error)
+    }
+  }, [])
+
+  const fetchPlatforms = useCallback(async () => {
+    try {
+      const response = await fetch('/api/platforms')
+      if (response.ok) {
+        const data = await response.json()
+        setPlatforms(data)
+      }
+    } catch (error) {
+      console.error('Error fetching platforms:', error)
+    }
+  }, [])
+
+  const fetchProductCategories = useCallback(async () => {
+    try {
+      const response = await fetch('/api/product-categories')
+      if (response.ok) {
+        const data = await response.json()
+        setProductCategories(data)
+      }
+    } catch (error) {
+      console.error('Error fetching product categories:', error)
+    }
+  }, [])
+
+  const fetchDepartments = useCallback(async () => {
+    try {
+      const response = await fetch('/api/departments')
+      if (response.ok) {
+        const data = await response.json()
+        setDepartments(data)
+      }
+    } catch (error) {
+      console.error('Error fetching departments:', error)
+    }
+  }, [])
+
+  const fetchMaterials = useCallback(async (page = 1, append = false) => {
+    try {
+      if (!append) {
+        setLoading(true)
+      }
+      const url = showRecycleBin 
+        ? `/api/materials?page=${page}&pageSize=${materialsPageSize}&deleted=true`
+        : `/api/materials?page=${page}&pageSize=${materialsPageSize}`
+      const response = await fetch(url)
+      if (response.ok) {
+        const data = await response.json()
+        const materialsData = data.materials || data
+        if (append) {
+          setMaterials(prev => [...prev, ...materialsData])
+        } else {
+          setMaterials(materialsData)
+        }
+        setHasMoreMaterials(materialsData.length === materialsPageSize)
+        setCurrentMaterialsPage(page)
+        setDisplayedMaterialsCount(append ? materials.length + materialsData.length : materialsData.length)
+      }
+    } catch (error) {
+      console.error('Error fetching materials:', error)
+    } finally {
+      setLoading(false)
+      setIsLoadingMoreMaterials(false)
+    }
+  }, [showRecycleBin, materialsPageSize, materials.length])
+
+  const searchMaterials = useCallback(async (searchTerm: string) => {
+    try {
+      const hasSearch = searchTerm.trim().length > 0
+      const url = showRecycleBin 
+        ? `/api/materials?page=1&pageSize=${hasSearch ? 10000 : materialsPageSize}&deleted=true${hasSearch ? `&search=${encodeURIComponent(searchTerm.trim())}` : ''}`
+        : `/api/materials?page=1&pageSize=${hasSearch ? 10000 : materialsPageSize}${hasSearch ? `&search=${encodeURIComponent(searchTerm.trim())}` : ''}`
+      const response = await fetch(url)
+      if (response.ok) {
+        const data = await response.json()
+        const materialsData = data.materials || data
+        setMaterials(materialsData)
+        setDisplayedMaterialsCount(materialsData.length)
+        setCurrentMaterialsPage(1)
+        setHasMoreMaterials(!hasSearch && materialsData.length === materialsPageSize)
+      }
+    } catch (error) {
+      console.error('Error searching materials:', error)
+    }
+  }, [showRecycleBin, materialsPageSize])
+
+  const loadMoreMaterials = useCallback(async () => {
+    if (isLoadingMoreMaterials || !hasMoreMaterials || materialSearchTerm.trim()) return
+    setIsLoadingMoreMaterials(true)
+    await fetchMaterials(currentMaterialsPage + 1, true)
+  }, [isLoadingMoreMaterials, hasMoreMaterials, materialSearchTerm, currentMaterialsPage, fetchMaterials])
+
+  // 初始化数据
+  const initializeData = useCallback(async () => {
+    setLoading(true)
+    await Promise.all([
+      fetchUsers(),
+      fetchCategories(),
+      fetchScenes(),
+      fetchPlatforms(),
+      fetchProductCategories(),
+      fetchDepartments(),
+      fetchMaterials(1, false),
+    ])
+    setLoading(false)
+  }, [fetchUsers, fetchCategories, fetchScenes, fetchPlatforms, fetchProductCategories, fetchDepartments, fetchMaterials])
+
+  // ========== 折叠操作 ==========
+
+  const toggleDepartmentCollapse = useCallback((dept: string) => {
+    setCollapsedDepartments(prev => {
+      const newSet = new Set(prev)
+      if (newSet.has(dept)) {
+        newSet.delete(dept)
+      } else {
+        newSet.add(dept)
+      }
+      return newSet
+    })
+  }, [])
+
+  const toggleAdminCollapse = useCallback((adminId: string) => {
+    setCollapsedAdmins(prev => {
+      const newSet = new Set(prev)
+      if (newSet.has(adminId)) {
+        newSet.delete(adminId)
+      } else {
+        newSet.add(adminId)
+      }
+      return newSet
+    })
+  }, [])
+
+  // ========== 素材选择操作 ==========
+
+  const toggleMaterialSelection = useCallback((id: string) => {
+    setSelectedMaterials(prev => {
+      const newSet = new Set(prev)
+      if (newSet.has(id)) {
+        newSet.delete(id)
+      } else {
+        newSet.add(id)
+      }
+      return newSet
+    })
+  }, [])
+
+  const selectAllMaterials = useCallback(() => {
+    setSelectedMaterials(new Set(materials.map(m => m.id)))
+  }, [materials])
+
+  const clearMaterialSelection = useCallback(() => {
+    setSelectedMaterials(new Set())
+  }, [])
+
+  return {
+    // 标签页
+    activeTab,
+    setActiveTab,
+    
+    // 数据
+    materials,
+    setMaterials,
+    users,
+    setUsers,
+    categories,
+    setCategories,
+    scenes,
+    setScenes,
+    platforms,
+    setPlatforms,
+    productCategories,
+    setProductCategories,
+    departments,
+    setDepartments,
+    loading,
+    setLoading,
+    
+    // 编辑状态
+    editingCategory,
+    setEditingCategory,
+    editingScene,
+    setEditingScene,
+    editingPlatform,
+    setEditingPlatform,
+    editingProductCategory,
+    setEditingProductCategory,
+    editingUser,
+    setEditingUser,
+    
+    // 添加弹窗
+    showAddCategoryModal,
+    setShowAddCategoryModal,
+    showAddSceneModal,
+    setShowAddSceneModal,
+    showAddPlatformModal,
+    setShowAddPlatformModal,
+    showAddProductCategoryModal,
+    setShowAddProductCategoryModal,
+    
+    // 新建输入
+    newCategoryName,
+    setNewCategoryName,
+    newSceneName,
+    setNewSceneName,
+    newPlatformName,
+    setNewPlatformName,
+    newProductCategoryName,
+    setNewProductCategoryName,
+    newDepartmentName,
+    setNewDepartmentName,
+    addingDepartment,
+    setAddingDepartment,
+    selectedDepartment,
+    setSelectedDepartment,
+    
+    // 搜索
+    userSearchTerm,
+    setUserSearchTerm,
+    materialSearchTerm,
+    setMaterialSearchTerm,
+    
+    // 素材批量操作
+    selectedMaterials,
+    setSelectedMaterials,
+    showRecycleBin,
+    setShowRecycleBin,
+    toggleMaterialSelection,
+    selectAllMaterials,
+    clearMaterialSelection,
+    
+    // 折叠状态
+    collapsedDepartments,
+    collapsedAdmins,
+    toggleDepartmentCollapse,
+    toggleAdminCollapse,
+    
+    // 素材分页
+    displayedMaterialsCount,
+    currentMaterialsPage,
+    hasMoreMaterials,
+    isLoadingMoreMaterials,
+    materialsPageSize,
+    materialSearchDebounceRef,
+    
+    // Toast
+    toast,
+    showToast,
+    
+    // 数据获取函数
+    fetchUsers,
+    fetchCategories,
+    fetchScenes,
+    fetchPlatforms,
+    fetchProductCategories,
+    fetchDepartments,
+    fetchMaterials,
+    searchMaterials,
+    loadMoreMaterials,
+    initializeData,
+  }
+}
--- a/hooks/useBatchFilesUpload.ts
+++ b/hooks/useBatchFilesUpload.ts
@ -0,0 +1,449 @@
+/**
+ * 批量文件上传 Hook
+ * 封装通用批量上传逻辑（支持队列管理和详细进度）
+ */
+
+import { useRef, useCallback } from 'react'
+import { chunkUpload } from '@/lib/chunk-upload'
+import { PREVIEW_OPTIONAL_TYPES, CHUNK_THRESHOLD } from '@/components/upload/upload-constants'
+import { fileToBase64String, completeBatchUpload } from '@/components/upload/special-batch-uploaders'
+import { requiresRenderer, shouldAutoFillGeneral } from '@/lib/material-validation'
+import type { BatchFileItem, BatchUploadStatus } from '@/components/upload/upload-types'
+
+export interface UseBatchFilesUploadOptions {
+  materialType: string
+  onSuccess: () => void
+  onClose: () => void
+}
+
+export interface BatchFilesUploadState {
+  uploading: boolean
+  uploadProgress: number
+  uploadSpeed: number
+  batchUploadStatus: BatchUploadStatus | null
+}
+
+export interface BatchFilesUploadActions {
+  setUploading: React.Dispatch<React.SetStateAction<boolean>>
+  setUploadProgress: React.Dispatch<React.SetStateAction<number>>
+  setUploadSpeed: React.Dispatch<React.SetStateAction<number>>
+  setBatchUploadStatus: React.Dispatch<React.SetStateAction<BatchUploadStatus | null>>
+  setError: React.Dispatch<React.SetStateAction<string>>
+}
+
+/**
+ * 批量文件上传 Hook
+ */
+export function useBatchFilesUpload(
+  options: UseBatchFilesUploadOptions,
+  state: BatchFilesUploadState,
+  actions: BatchFilesUploadActions
+) {
+  const { materialType, onSuccess, onClose } = options
+  const { uploading, batchUploadStatus } = state
+  const { setUploading, setUploadProgress, setUploadSpeed, setBatchUploadStatus, setError } = actions
+
+  // Refs
+  const batchUploadCancelRef = useRef<{ cancelled: boolean }>({ cancelled: false })
+  const batchUploadXhrRefs = useRef<Map<string, XMLHttpRequest>>(new Map())
+  const batchUploadIdsRef = useRef<Map<string, string>>(new Map())
+
+  /**
+   * 取消批量上传
+   */
+  const handleCancelBatchUpload = useCallback(async () => {
+    batchUploadCancelRef.current.cancelled = true
+    // 取消所有进行中的请求
+    batchUploadXhrRefs.current.forEach(xhr => {
+      if (xhr) {
+        xhr.abort()
+      }
+    })
+    batchUploadXhrRefs.current.clear()
+    
+    // 清理所有上传会话和临时文件
+    const uploadIdsToClean = Array.from(batchUploadIdsRef.current.values())
+    if (uploadIdsToClean.length > 0) {
+      try {
+        await Promise.all(
+          uploadIdsToClean.map(async (uploadId) => {
+            try {
+              const response = await fetch('/api/materials/upload/cleanup', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ uploadId }),
+              })
+              if (response.ok) {
+                console.log(`[Cancel] 已清理上传会话: ${uploadId}`)
+              }
+            } catch (err) {
+              console.warn(`[Cancel] 清理上传会话失败: ${uploadId}`, err)
+            }
+          })
+        )
+      } catch (err) {
+        console.warn('[Cancel] 批量清理上传会话时出错:', err)
+      }
+    }
+    
+    batchUploadIdsRef.current.clear()
+    setUploading(false)
+    setBatchUploadStatus(null)
+    setError('上传已取消')
+  }, [setUploading, setBatchUploadStatus, setError])
+
+  /**
+   * 执行批量文件上传
+   */
+  const handleBatchFilesUpload = useCallback(async (
+    batchFiles: BatchFileItem[],
+    onComplete: () => void
+  ) => {
+    if (batchFiles.length === 0) return
+
+    setUploading(true)
+    setUploadProgress(0)
+    setUploadSpeed(0)
+    setError('')
+    batchUploadCancelRef.current.cancelled = false
+    batchUploadXhrRefs.current.clear()
+
+    // 初始化上传状态
+    const fileStatuses = batchFiles.map(item => ({
+      fileName: item.file.name,
+      status: 'pending' as const,
+      progress: 0,
+      uploadId: undefined,
+    }))
+    
+    batchUploadIdsRef.current.clear()
+
+    setBatchUploadStatus({
+      currentFileIndex: 0,
+      totalFiles: batchFiles.length,
+      currentFileName: batchFiles[0]?.file.name || '',
+      currentFileProgress: 0,
+      currentFileSpeed: 0,
+      fileStatuses,
+      isCancelled: false,
+      startTime: Date.now(),
+    })
+
+    const results: any[] = []
+    let totalUploadedBytes = 0
+    const totalFileSize = batchFiles.reduce((sum, item) => sum + item.file.size, 0)
+    const startTime = Date.now()
+
+    try {
+      // 队列管理：逐个处理文件
+      for (let i = 0; i < batchFiles.length; i++) {
+        if (batchUploadCancelRef.current.cancelled) {
+          break
+        }
+
+        const item = batchFiles[i]
+        const fileIndex = i
+
+        // 更新当前文件状态
+        setBatchUploadStatus(prev => {
+          if (!prev) return prev
+          const newStatuses = [...prev.fileStatuses]
+          newStatuses[fileIndex] = { ...newStatuses[fileIndex], status: 'uploading' }
+          return {
+            ...prev,
+            currentFileIndex: fileIndex,
+            currentFileName: item.file.name,
+            currentFileProgress: 0,
+            fileStatuses: newStatuses,
+          }
+        })
+
+        try {
+          // 构建每个文件的元数据
+          const metadata: any = {
+            materialType,
+            productModel: item.productModel,
+            categoryName: shouldAutoFillGeneral(materialType) 
+              ? '通用' 
+              : item.categoryName,
+            sceneName: shouldAutoFillGeneral(materialType) 
+              ? '通用' 
+              : item.sceneName,
+            platformName: item.platformName || '',
+            productCategoryName: item.productCategoryName || '',
+          }
+
+          // 添加渲染器（3D场景）
+          if (requiresRenderer(materialType) && item.renderer) {
+            metadata.renderer = item.renderer
+          }
+
+          // 处理预览图（如果需要）
+          const needsPreview = !PREVIEW_OPTIONAL_TYPES.includes(materialType) && materialType !== '详情页'
+          if (needsPreview && item.previewImage) {
+            metadata.previewImage = await fileToBase64String(item.previewImage)
+          }
+
+          // 判断是否需要分片上传
+          const useChunk = item.file.size >= CHUNK_THRESHOLD
+
+          if (useChunk) {
+            // 分片上传
+            const result = await chunkUpload(item.file, metadata, {
+              chunkSize: 5 * 1024 * 1024,
+              onProgress: (progress, speed) => {
+                if (batchUploadCancelRef.current.cancelled) return
+                
+                setBatchUploadStatus(prev => {
+                  if (!prev) return prev
+                  const newStatuses = [...prev.fileStatuses]
+                  newStatuses[fileIndex] = { 
+                    ...newStatuses[fileIndex], 
+                    status: 'uploading',
+                    progress 
+                  }
+                  return {
+                    ...prev,
+                    currentFileProgress: progress,
+                    currentFileSpeed: speed || 0,
+                    fileStatuses: newStatuses,
+                  }
+                })
+
+                const fileProgress = (progress / 100) * item.file.size
+                const currentTotalBytes = totalUploadedBytes + fileProgress
+                const overallProgress = Math.round((currentTotalBytes / totalFileSize) * 100)
+                setUploadProgress(overallProgress)
+                if (speed) {
+                  setUploadSpeed(speed)
+                }
+              },
+              onRequest: (xhr) => {
+                if (xhr) {
+                  batchUploadXhrRefs.current.set(item.id, xhr)
+                } else {
+                  batchUploadXhrRefs.current.delete(item.id)
+                }
+              },
+              skipComplete: true,
+              maxRetries: Infinity,
+            })
+
+            totalUploadedBytes += item.file.size
+
+            // 更新状态为处理中
+            if (result?.uploadId) {
+              batchUploadIdsRef.current.set(item.id, result.uploadId)
+              setBatchUploadStatus(prev => {
+                if (!prev) return prev
+                const newStatuses = [...prev.fileStatuses]
+                newStatuses[fileIndex] = { 
+                  ...newStatuses[fileIndex], 
+                  status: 'processing',
+                  progress: 100,
+                  uploadId: result.uploadId
+                }
+                return { ...prev, fileStatuses: newStatuses }
+              })
+            } else {
+              setBatchUploadStatus(prev => {
+                if (!prev) return prev
+                const newStatuses = [...prev.fileStatuses]
+                newStatuses[fileIndex] = { 
+                  ...newStatuses[fileIndex], 
+                  status: 'processing',
+                  progress: 100
+                }
+                return { ...prev, fileStatuses: newStatuses }
+              })
+            }
+
+            if (result?.uploadId) {
+              // 后台异步处理
+              completeBatchUpload(result.uploadId, metadata).catch((err) => {
+                console.error(`[Upload] 文件 ${item.file.name} 后台处理失败:`, err)
+                setBatchUploadStatus(prev => {
+                  if (!prev) return prev
+                  const newStatuses = [...prev.fileStatuses]
+                  newStatuses[fileIndex] = { 
+                    ...newStatuses[fileIndex], 
+                    status: 'failed',
+                    error: '后台处理失败'
+                  }
+                  return { ...prev, fileStatuses: newStatuses }
+                })
+              })
+            }
+
+            results.push({
+              tempId: `pending-${Date.now()}-${fileIndex}`,
+              uploadId: result?.uploadId || null,
+              productModel: item.productModel,
+              fileName: item.file.name,
+              fileSize: item.file.size,
+              status: 'processing',
+            })
+          } else {
+            // 小文件直接上传
+            const formData = new FormData()
+            formData.append('zipFile', item.file)
+            formData.append('productModel', item.productModel)
+            formData.append('categoryName', metadata.categoryName)
+            formData.append('sceneName', metadata.sceneName)
+            formData.append('platformName', metadata.platformName)
+            formData.append('productCategoryName', metadata.productCategoryName)
+            formData.append('materialType', materialType)
+            if (metadata.renderer) {
+              formData.append('renderer', metadata.renderer)
+            }
+            if (item.previewImage) {
+              formData.append('previewImage', item.previewImage)
+            }
+
+            const xhr = new XMLHttpRequest()
+            batchUploadXhrRefs.current.set(item.id, xhr)
+
+            await new Promise<void>((resolve, reject) => {
+              xhr.upload.onprogress = (e) => {
+                if (e.lengthComputable && !batchUploadCancelRef.current.cancelled) {
+                  const progress = Math.round((e.loaded / e.total) * 100)
+                  const elapsed = (Date.now() - startTime) / 1000
+                  const speed = e.loaded / elapsed
+                  
+                  setBatchUploadStatus(prev => {
+                    if (!prev) return prev
+                    const newStatuses = [...prev.fileStatuses]
+                    newStatuses[fileIndex] = { 
+                      ...newStatuses[fileIndex], 
+                      status: 'uploading',
+                      progress 
+                    }
+                    return {
+                      ...prev,
+                      currentFileProgress: progress,
+                      currentFileSpeed: speed,
+                      fileStatuses: newStatuses,
+                    }
+                  })
+
+                  const fileProgress = (progress / 100) * item.file.size
+                  const currentTotalBytes = totalUploadedBytes + fileProgress
+                  const overallProgress = Math.round((currentTotalBytes / totalFileSize) * 100)
+                  setUploadProgress(overallProgress)
+                  setUploadSpeed(speed)
+                }
+              }
+
+              xhr.onload = () => {
+                batchUploadXhrRefs.current.delete(item.id)
+                if (xhr.status >= 200 && xhr.status < 300) {
+                  totalUploadedBytes += item.file.size
+                  resolve()
+                } else {
+                  reject(new Error(`上传失败: ${xhr.statusText}`))
+                }
+              }
+
+              xhr.onerror = () => {
+                batchUploadXhrRefs.current.delete(item.id)
+                reject(new Error('网络错误'))
+              }
+
+              xhr.onabort = () => {
+                batchUploadXhrRefs.current.delete(item.id)
+                reject(new Error('上传已取消'))
+              }
+
+              xhr.open('POST', '/api/materials/upload')
+              xhr.send(formData)
+            })
+
+            setBatchUploadStatus(prev => {
+              if (!prev) return prev
+              const newStatuses = [...prev.fileStatuses]
+              newStatuses[fileIndex] = { 
+                ...newStatuses[fileIndex], 
+                status: 'processing',
+                progress: 100
+              }
+              return { ...prev, fileStatuses: newStatuses }
+            })
+
+            results.push({
+              tempId: `pending-${Date.now()}-${fileIndex}`,
+              uploadId: null,
+              productModel: item.productModel,
+              fileName: item.file.name,
+              fileSize: item.file.size,
+              status: 'processing',
+            })
+          }
+
+          // 更新完成状态
+          setBatchUploadStatus(prev => {
+            if (!prev) return prev
+            const newStatuses = [...prev.fileStatuses]
+            newStatuses[fileIndex] = { 
+              ...newStatuses[fileIndex], 
+              status: 'done',
+              progress: 100
+            }
+            return { ...prev, fileStatuses: newStatuses }
+          })
+
+        } catch (error: any) {
+          console.error(`[Upload] 文件 ${item.file.name} 上传失败:`, error)
+          
+          setBatchUploadStatus(prev => {
+            if (!prev) return prev
+            const newStatuses = [...prev.fileStatuses]
+            newStatuses[fileIndex] = { 
+              ...newStatuses[fileIndex], 
+              status: 'failed',
+              error: error.message || '上传失败'
+            }
+            return { ...prev, fileStatuses: newStatuses }
+          })
+
+          results.push({
+            tempId: `pending-${Date.now()}-${fileIndex}`,
+            uploadId: null,
+            productModel: item.productModel,
+            fileName: item.file.name,
+            fileSize: item.file.size,
+            status: 'failed',
+          })
+        }
+      }
+
+      if (batchUploadCancelRef.current.cancelled) {
+        return
+      }
+
+      // 检查是否有失败的文件
+      const failedFiles = batchUploadStatus?.fileStatuses.filter(s => s.status === 'failed') || []
+      if (failedFiles.length > 0) {
+        setError(`${failedFiles.length} 个文件上传失败，请检查后重试`)
+      } else {
+        setUploadProgress(100)
+        onComplete()
+        onSuccess()
+        onClose()
+      }
+    } catch (error) {
+      console.error('[Upload] 批量上传失败:', error)
+      setError('批量上传失败，请重试')
+    } finally {
+      setUploading(false)
+      batchUploadXhrRefs.current.clear()
+    }
+  }, [materialType, batchUploadStatus, setUploading, setUploadProgress, setUploadSpeed, setBatchUploadStatus, setError, onSuccess, onClose])
+
+  return {
+    handleBatchFilesUpload,
+    handleCancelBatchUpload,
+    batchUploadCancelRef,
+    batchUploadXhrRefs,
+    batchUploadIdsRef,
+  }
+}
--- a/hooks/useBatchUpload.ts
+++ b/hooks/useBatchUpload.ts
@ -1,26 +0,0 @@
-// 批量上传逻辑的自定义 Hook
-import { useState, useRef } from 'react'
-import type { BatchFileItem, BatchUploadStatus } from '@/components/upload/upload-types'
-
-export function useBatchUpload() {
-  const [batchFiles, setBatchFiles] = useState<BatchFileItem[]>([])
-  const [isBatchMode, setIsBatchMode] = useState(false)
-  const [batchUploadStatus, setBatchUploadStatus] = useState<BatchUploadStatus | null>(null)
-  
-  const batchUploadCancelRef = useRef<{ cancelled: boolean }>({ cancelled: false })
-  const batchUploadXhrRefs = useRef<Map<string, XMLHttpRequest>>(new Map())
-  const batchUploadIdsRef = useRef<Map<string, string>>(new Map())
-
-  return {
-    batchFiles,
-    setBatchFiles,
-    isBatchMode,
-    setIsBatchMode,
-    batchUploadStatus,
-    setBatchUploadStatus,
-    batchUploadCancelRef,
-    batchUploadXhrRefs,
-    batchUploadIdsRef,
-  }
-}
-
--- a/hooks/useCategoryData.ts
+++ b/hooks/useCategoryData.ts
@ -0,0 +1,142 @@
+/**
+ * 分类数据获取 Hook
+ * 封装店铺、场景、平台、品类的数据获取逻辑
+ */
+
+import { useState, useEffect, useCallback } from 'react'
+
+/**
+ * 分类项接口
+ */
+export interface CategoryItem {
+  id: string
+  name: string
+}
+
+/**
+ * 分类数据接口
+ */
+export interface CategoryData {
+  categories: CategoryItem[]
+  scenes: CategoryItem[]
+  platforms: CategoryItem[]
+  productCategories: CategoryItem[]
+}
+
+/**
+ * 分类数据 Hook 返回值
+ */
+export interface UseCategoryDataReturn {
+  data: CategoryData
+  loading: boolean
+  error: string | null
+  refresh: () => Promise<void>
+  refreshCategories: () => Promise<void>
+  refreshScenes: () => Promise<void>
+  refreshPlatforms: () => Promise<void>
+  refreshProductCategories: () => Promise<void>
+}
+
+/**
+ * 分类数据获取 Hook
+ */
+export function useCategoryData(): UseCategoryDataReturn {
+  const [categories, setCategories] = useState<CategoryItem[]>([])
+  const [scenes, setScenes] = useState<CategoryItem[]>([])
+  const [platforms, setPlatforms] = useState<CategoryItem[]>([])
+  const [productCategories, setProductCategories] = useState<CategoryItem[]>([])
+  const [loading, setLoading] = useState(true)
+  const [error, setError] = useState<string | null>(null)
+
+  // 获取店铺列表
+  const fetchCategories = useCallback(async () => {
+    try {
+      const response = await fetch('/api/categories')
+      if (response.ok) {
+        const data = await response.json()
+        setCategories(data)
+      }
+    } catch (err) {
+      console.error('Error fetching categories:', err)
+    }
+  }, [])
+
+  // 获取场景列表
+  const fetchScenes = useCallback(async () => {
+    try {
+      const response = await fetch('/api/scenes')
+      if (response.ok) {
+        const data = await response.json()
+        setScenes(data)
+      }
+    } catch (err) {
+      console.error('Error fetching scenes:', err)
+    }
+  }, [])
+
+  // 获取平台列表
+  const fetchPlatforms = useCallback(async () => {
+    try {
+      const response = await fetch('/api/platforms')
+      if (response.ok) {
+        const data = await response.json()
+        setPlatforms(data)
+      }
+    } catch (err) {
+      console.error('Error fetching platforms:', err)
+    }
+  }, [])
+
+  // 获取品类列表
+  const fetchProductCategories = useCallback(async () => {
+    try {
+      const response = await fetch('/api/product-categories')
+      if (response.ok) {
+        const data = await response.json()
+        setProductCategories(data)
+      }
+    } catch (err) {
+      console.error('Error fetching product categories:', err)
+    }
+  }, [])
+
+  // 刷新所有数据
+  const refresh = useCallback(async () => {
+    setLoading(true)
+    setError(null)
+    try {
+      await Promise.all([
+        fetchCategories(),
+        fetchScenes(),
+        fetchPlatforms(),
+        fetchProductCategories(),
+      ])
+    } catch (err) {
+      setError('获取分类数据失败')
+      console.error('Error refreshing category data:', err)
+    } finally {
+      setLoading(false)
+    }
+  }, [fetchCategories, fetchScenes, fetchPlatforms, fetchProductCategories])
+
+  // 初始加载
+  useEffect(() => {
+    refresh()
+  }, [refresh])
+
+  return {
+    data: {
+      categories,
+      scenes,
+      platforms,
+      productCategories,
+    },
+    loading,
+    error,
+    refresh,
+    refreshCategories: fetchCategories,
+    refreshScenes: fetchScenes,
+    refreshPlatforms: fetchPlatforms,
+    refreshProductCategories: fetchProductCategories,
+  }
+}
--- a/hooks/useDragHandlers.ts
+++ b/hooks/useDragHandlers.ts
@ -0,0 +1,226 @@
+/**
+ * 拖拽处理 Hook
+ * 封装素材文件、预览图片、展示图片的拖拽事件处理
+ */
+
+import { useState, useCallback } from 'react'
+
+/**
+ * 拖拽状态
+ */
+export interface DragState {
+  /** 素材文件拖拽状态 */
+  isDragging: boolean
+  /** 预览图片拖拽状态 */
+  isPreviewDragging: boolean
+  /** 详情页展示图片拖拽状态 */
+  isDisplayImageDragging: boolean
+  /** 批量模式下每个文件的预览图拖拽状态 */
+  batchPreviewDragging: Record<string, boolean>
+}
+
+/**
+ * 拖拽处理 Hook 参数
+ */
+export interface UseDragHandlersOptions {
+  /** 验证是否为有效的素材文件 */
+  isValidMainFile: (file: File) => boolean
+  /** 处理素材文件拖放 */
+  onMaterialFileDrop: (files: File[]) => void
+  /** 处理预览图片拖放 */
+  onPreviewImageDrop: (files: File[]) => void
+  /** 处理展示图片拖放 */
+  onDisplayImageDrop: (file: File) => void
+  /** 设置错误信息 */
+  setError: (error: string) => void
+}
+
+/**
+ * 判断鼠标是否真正离开了元素（避免经过子元素时闪屏）
+ */
+function isMouseOutsideElement(e: React.DragEvent, element: HTMLElement): boolean {
+  const rect = element.getBoundingClientRect()
+  const x = e.clientX
+  const y = e.clientY
+  return x <= rect.left || x >= rect.right || y <= rect.top || y >= rect.bottom
+}
+
+/**
+ * 拖拽处理 Hook
+ */
+export function useDragHandlers(options: UseDragHandlersOptions) {
+  const {
+    isValidMainFile,
+    onMaterialFileDrop,
+    onPreviewImageDrop,
+    onDisplayImageDrop,
+    setError,
+  } = options
+
+  // 拖拽状态
+  const [isDragging, setIsDragging] = useState(false)
+  const [isPreviewDragging, setIsPreviewDragging] = useState(false)
+  const [isDisplayImageDragging, setIsDisplayImageDragging] = useState(false)
+  const [batchPreviewDragging, setBatchPreviewDragging] = useState<Record<string, boolean>>({})
+
+  // ========== 素材文件拖拽处理 ==========
+  
+  const handleDragEnter = useCallback((e: React.DragEvent) => {
+    e.preventDefault()
+    e.stopPropagation()
+    setIsDragging(true)
+  }, [])
+
+  const handleDragLeave = useCallback((e: React.DragEvent) => {
+    e.preventDefault()
+    e.stopPropagation()
+    
+    if (isMouseOutsideElement(e, e.currentTarget as HTMLElement)) {
+      setIsDragging(false)
+    }
+  }, [])
+
+  const handleDragOver = useCallback((e: React.DragEvent) => {
+    e.preventDefault()
+    e.stopPropagation()
+  }, [])
+
+  const handleDrop = useCallback((e: React.DragEvent) => {
+    e.preventDefault()
+    e.stopPropagation()
+    setIsDragging(false)
+
+    const files = Array.from(e.dataTransfer.files)
+    if (files.length === 0) return
+
+    // 只处理素材文件（包括压缩包/视频/音频/PDF 视类型而定）
+    const materialFiles = files.filter(f => isValidMainFile(f))
+    if (materialFiles.length > 0) {
+      onMaterialFileDrop(materialFiles)
+    } else {
+      setError('请拖拽素材文件到此区域，图片请拖拽到对应的图片上传区域')
+    }
+  }, [isValidMainFile, onMaterialFileDrop, setError])
+
+  // ========== 预览图片拖拽处理 ==========
+
+  const handlePreviewDragEnter = useCallback((e: React.DragEvent) => {
+    e.preventDefault()
+    e.stopPropagation()
+    setIsPreviewDragging(true)
+  }, [])
+
+  const handlePreviewDragLeave = useCallback((e: React.DragEvent) => {
+    e.preventDefault()
+    e.stopPropagation()
+    
+    if (isMouseOutsideElement(e, e.currentTarget as HTMLElement)) {
+      setIsPreviewDragging(false)
+    }
+  }, [])
+
+  const handlePreviewDragOver = useCallback((e: React.DragEvent) => {
+    e.preventDefault()
+    e.stopPropagation()
+  }, [])
+
+  const handlePreviewDrop = useCallback((e: React.DragEvent) => {
+    e.preventDefault()
+    e.stopPropagation()
+    setIsPreviewDragging(false)
+
+    const files = Array.from(e.dataTransfer.files)
+    if (files.length === 0) return
+
+    const imageFiles = files.filter(f => f.type.startsWith('image/'))
+    if (imageFiles.length > 0) {
+      onPreviewImageDrop(imageFiles)
+    } else {
+      setError('请拖拽图片文件')
+    }
+  }, [onPreviewImageDrop, setError])
+
+  // ========== 详情页展示图片拖拽处理 ==========
+
+  const handleDisplayImageDragEnter = useCallback((e: React.DragEvent) => {
+    e.preventDefault()
+    e.stopPropagation()
+    setIsDisplayImageDragging(true)
+  }, [])
+
+  const handleDisplayImageDragLeave = useCallback((e: React.DragEvent) => {
+    e.preventDefault()
+    e.stopPropagation()
+    
+    if (isMouseOutsideElement(e, e.currentTarget as HTMLElement)) {
+      setIsDisplayImageDragging(false)
+    }
+  }, [])
+
+  const handleDisplayImageDragOver = useCallback((e: React.DragEvent) => {
+    e.preventDefault()
+    e.stopPropagation()
+  }, [])
+
+  const handleDisplayImageDrop = useCallback((e: React.DragEvent) => {
+    e.preventDefault()
+    e.stopPropagation()
+    setIsDisplayImageDragging(false)
+
+    const files = Array.from(e.dataTransfer.files)
+    if (files.length === 0) return
+
+    const imageFiles = files.filter(f => f.type.startsWith('image/'))
+    if (imageFiles.length > 0) {
+      onDisplayImageDrop(imageFiles[0])
+    } else {
+      setError('请拖拽图片文件')
+    }
+  }, [onDisplayImageDrop, setError])
+
+  // ========== 批量模式预览图拖拽处理 ==========
+
+  const handleBatchPreviewDragEnter = useCallback((itemId: string) => {
+    setBatchPreviewDragging(prev => ({ ...prev, [itemId]: true }))
+  }, [])
+
+  const handleBatchPreviewDragLeave = useCallback((itemId: string) => {
+    setBatchPreviewDragging(prev => ({ ...prev, [itemId]: false }))
+  }, [])
+
+  const resetBatchPreviewDragging = useCallback((itemId: string) => {
+    setBatchPreviewDragging(prev => ({ ...prev, [itemId]: false }))
+  }, [])
+
+  return {
+    // 拖拽状态
+    isDragging,
+    isPreviewDragging,
+    isDisplayImageDragging,
+    batchPreviewDragging,
+    
+    // 素材文件拖拽处理
+    handleDragEnter,
+    handleDragLeave,
+    handleDragOver,
+    handleDrop,
+    
+    // 预览图片拖拽处理
+    handlePreviewDragEnter,
+    handlePreviewDragLeave,
+    handlePreviewDragOver,
+    handlePreviewDrop,
+    
+    // 详情页展示图片拖拽处理
+    handleDisplayImageDragEnter,
+    handleDisplayImageDragLeave,
+    handleDisplayImageDragOver,
+    handleDisplayImageDrop,
+    
+    // 批量模式预览图拖拽处理
+    handleBatchPreviewDragEnter,
+    handleBatchPreviewDragLeave,
+    resetBatchPreviewDragging,
+    setBatchPreviewDragging,
+  }
+}
--- a/hooks/useHomeState.ts
+++ b/hooks/useHomeState.ts
@ -0,0 +1,329 @@
+/**
+ * 首页状态管理 Hook
+ * 提取自 app/page.tsx 的状态管理逻辑
+ */
+
+import { useState, useCallback, useRef, useEffect } from 'react'
+
+// 素材类型定义
+export interface Material {
+  id: string
+  userId: string
+  previewUrl: string
+  productModel: string
+  categoryName: string
+  sceneName: string
+  platformName?: string
+  productCategoryName?: string
+  materialType: string
+  renderer: string
+  authorName: string
+  zipFileName: string
+  zipFileSize: string | number
+  downloadCount: number
+  likeCount: number
+  isLiked: boolean
+  isFavorited: boolean
+  createdAt: string
+  displayImages?: string[]
+  videoSourceUrl?: string | null
+  videoPreview540Url?: string | null
+  videoPreviewClipUrl?: string | null
+  videoCoverUrl?: string | null
+  videoProcessingStatus?: string | null
+  videoDuration?: number | null
+  transcodeLastError?: string | null
+  transcodeAttempts?: number | null
+  transcodeProgress?: number | null
+  transcodeStage?: string | null
+  transcodeQueueWaitingIndex?: number | null
+  transcodeQueueWaitingTotal?: number | null
+  transcodeQueueProcessingIds?: string[]
+  transcodeQueueMaxConcurrent?: number | null
+  user: {
+    username: string
+    avatar?: string | null
+  }
+}
+
+// 分类项类型
+export interface CategoryItem {
+  id: string
+  name: string
+  count: number
+}
+
+// 月份项类型
+export interface MonthItem {
+  value: string
+  label: string
+  count: number
+}
+
+// 默认素材类型列表
+export const DEFAULT_MATERIAL_TYPES = [
+  '3D场景',
+  '详情页',
+  '材质',
+  '模特',
+  '实拍图片',
+  '买家秀图片',
+  '小红书种草',
+  '主图模版',
+  'SKU模版',
+  '主图视频',
+  '安装视频',
+  '种草视频',
+  '音乐',
+  'C4D模型',
+  '标准饰品',
+  '标准模型',
+  '品牌VI灵感',
+  '矢量文件',
+]
+
+export interface UseHomeStateReturn {
+  // 素材数据
+  materials: Material[]
+  setMaterials: React.Dispatch<React.SetStateAction<Material[]>>
+  loading: boolean
+  setLoading: React.Dispatch<React.SetStateAction<boolean>>
+  isTransitionLoading: boolean
+  setIsTransitionLoading: React.Dispatch<React.SetStateAction<boolean>>
+  
+  // 筛选状态
+  searchKeyword: string
+  setSearchKeyword: React.Dispatch<React.SetStateAction<string>>
+  selectedCategory: string
+  setSelectedCategory: React.Dispatch<React.SetStateAction<string>>
+  selectedScene: string
+  setSelectedScene: React.Dispatch<React.SetStateAction<string>>
+  selectedMaterialType: string
+  setSelectedMaterialType: React.Dispatch<React.SetStateAction<string>>
+  selectedPlatform: string
+  setSelectedPlatform: React.Dispatch<React.SetStateAction<string>>
+  selectedProductCategory: string
+  setSelectedProductCategory: React.Dispatch<React.SetStateAction<string>>
+  selectedMonth: string
+  setSelectedMonth: React.Dispatch<React.SetStateAction<string>>
+  
+  // 排序状态
+  sortBy: string
+  setSortBy: React.Dispatch<React.SetStateAction<string>>
+  sortOrder: 'desc' | 'asc'
+  setSortOrder: React.Dispatch<React.SetStateAction<'desc' | 'asc'>>
+  
+  // 分类数据
+  categories: CategoryItem[]
+  setCategories: React.Dispatch<React.SetStateAction<CategoryItem[]>>
+  scenes: CategoryItem[]
+  setScenes: React.Dispatch<React.SetStateAction<CategoryItem[]>>
+  platforms: CategoryItem[]
+  setPlatforms: React.Dispatch<React.SetStateAction<CategoryItem[]>>
+  productCategories: CategoryItem[]
+  setProductCategories: React.Dispatch<React.SetStateAction<CategoryItem[]>>
+  materialTypes: { value: string; label: string }[]
+  setMaterialTypes: React.Dispatch<React.SetStateAction<{ value: string; label: string }[]>>
+  months: MonthItem[]
+  setMonths: React.Dispatch<React.SetStateAction<MonthItem[]>>
+  
+  // 分页状态
+  displayedCount: number
+  setDisplayedCount: React.Dispatch<React.SetStateAction<number>>
+  currentPage: number
+  setCurrentPage: React.Dispatch<React.SetStateAction<number>>
+  hasMore: boolean
+  setHasMore: React.Dispatch<React.SetStateAction<boolean>>
+  isLoadingMore: boolean
+  setIsLoadingMore: React.Dispatch<React.SetStateAction<boolean>>
+  totalMaterialsCount: number
+  setTotalMaterialsCount: React.Dispatch<React.SetStateAction<number>>
+  pageSize: number
+  
+  // UI状态
+  isFilterCollapsed: boolean
+  setIsFilterCollapsed: React.Dispatch<React.SetStateAction<boolean>>
+  showUploadModal: boolean
+  setShowUploadModal: React.Dispatch<React.SetStateAction<boolean>>
+  themeColor: string
+  setThemeColor: React.Dispatch<React.SetStateAction<string>>
+  
+  // 搜索防抖处理
+  handleSearchChange: (value: string) => void
+  searchDebounceRef: React.MutableRefObject<NodeJS.Timeout | null>
+}
+
+export function useHomeState(): UseHomeStateReturn {
+  // 素材数据
+  const [materials, setMaterials] = useState<Material[]>([])
+  const [loading, setLoading] = useState(true)
+  const [isTransitionLoading, setIsTransitionLoading] = useState(false)
+  
+  // 筛选状态
+  const [searchKeyword, setSearchKeyword] = useState('')
+  const [selectedCategory, setSelectedCategory] = useState('')
+  const [selectedScene, setSelectedScene] = useState('')
+  const [selectedMaterialType, setSelectedMaterialType] = useState('3D场景')
+  const [selectedPlatform, setSelectedPlatform] = useState('')
+  const [selectedProductCategory, setSelectedProductCategory] = useState('')
+  const [selectedMonth, setSelectedMonth] = useState('')
+  
+  // 排序状态
+  const [sortBy, setSortBy] = useState('createdAt')
+  const [sortOrder, setSortOrder] = useState<'desc' | 'asc'>('desc')
+  
+  // 分类数据
+  const [categories, setCategories] = useState<CategoryItem[]>([])
+  const [scenes, setScenes] = useState<CategoryItem[]>([])
+  const [platforms, setPlatforms] = useState<CategoryItem[]>([])
+  const [productCategories, setProductCategories] = useState<CategoryItem[]>([])
+  const [materialTypes, setMaterialTypes] = useState<{ value: string; label: string }[]>([])
+  const [months, setMonths] = useState<MonthItem[]>([])
+  
+  // 分页状态
+  const [displayedCount, setDisplayedCount] = useState(24)
+  const [currentPage, setCurrentPage] = useState(1)
+  const [hasMore, setHasMore] = useState(true)
+  const [isLoadingMore, setIsLoadingMore] = useState(false)
+  const [totalMaterialsCount, setTotalMaterialsCount] = useState(0)
+  const pageSize = 20
+  
+  // UI状态
+  const [isFilterCollapsed, setIsFilterCollapsed] = useState(true)
+  const [showUploadModal, setShowUploadModal] = useState(false)
+  const [themeColor, setThemeColor] = useState('#1f2937')
+  
+  // 搜索防抖
+  const searchDebounceRef = useRef<NodeJS.Timeout | null>(null)
+  const fetchMaterialsRef = useRef<((page?: number, append?: boolean) => Promise<number>) | null>(null)
+  
+  // 搜索防抖处理函数
+  const handleSearchChange = useCallback((value: string) => {
+    setSearchKeyword(value)
+    
+    if (searchDebounceRef.current) {
+      clearTimeout(searchDebounceRef.current)
+    }
+    
+    searchDebounceRef.current = setTimeout(() => {
+      console.log('[搜索防抖] 触发搜索:', value)
+      setCurrentPage(1)
+      setDisplayedCount(24)
+      setHasMore(true)
+      // 触发重新获取数据（通过依赖变化）
+    }, 500)
+  }, [])
+  
+  // 从URL参数恢复筛选状态
+  useEffect(() => {
+    if (typeof window === 'undefined') return
+    
+    const params = new URLSearchParams(window.location.search)
+    const materialType = params.get('materialType')
+    const category = params.get('category')
+    const scene = params.get('scene')
+    const platform = params.get('platform')
+    const productCategory = params.get('productCategory')
+    const month = params.get('month')
+    const sort = params.get('sortBy')
+    const sortOrderParam = params.get('sortOrder')
+    
+    if (materialType) setSelectedMaterialType(materialType)
+    if (category) setSelectedCategory(category)
+    if (scene) setSelectedScene(scene)
+    if (platform) setSelectedPlatform(platform)
+    if (productCategory) setSelectedProductCategory(productCategory)
+    if (month) setSelectedMonth(month)
+    if (sort) setSortBy(sort)
+    if (sortOrderParam === 'asc' || sortOrderParam === 'desc') setSortOrder(sortOrderParam)
+  }, [])
+  
+  // 同步筛选状态到URL参数
+  useEffect(() => {
+    if (typeof window === 'undefined') return
+    
+    const params = new URLSearchParams()
+    if (selectedMaterialType && selectedMaterialType !== '3D场景') params.set('materialType', selectedMaterialType)
+    if (selectedCategory) params.set('category', selectedCategory)
+    if (selectedScene) params.set('scene', selectedScene)
+    if (selectedPlatform) params.set('platform', selectedPlatform)
+    if (selectedProductCategory) params.set('productCategory', selectedProductCategory)
+    if (selectedMonth) params.set('month', selectedMonth)
+    if (sortBy && sortBy !== 'createdAt') params.set('sortBy', sortBy)
+    if (sortOrder && sortOrder !== 'desc') params.set('sortOrder', sortOrder)
+    
+    const newUrl = params.toString() ? `${window.location.pathname}?${params.toString()}` : window.location.pathname
+    window.history.replaceState({}, '', newUrl)
+  }, [selectedMaterialType, selectedCategory, selectedScene, selectedPlatform, selectedProductCategory, selectedMonth, sortBy, sortOrder])
+  
+  return {
+    // 素材数据
+    materials,
+    setMaterials,
+    loading,
+    setLoading,
+    isTransitionLoading,
+    setIsTransitionLoading,
+    
+    // 筛选状态
+    searchKeyword,
+    setSearchKeyword,
+    selectedCategory,
+    setSelectedCategory,
+    selectedScene,
+    setSelectedScene,
+    selectedMaterialType,
+    setSelectedMaterialType,
+    selectedPlatform,
+    setSelectedPlatform,
+    selectedProductCategory,
+    setSelectedProductCategory,
+    selectedMonth,
+    setSelectedMonth,
+    
+    // 排序状态
+    sortBy,
+    setSortBy,
+    sortOrder,
+    setSortOrder,
+    
+    // 分类数据
+    categories,
+    setCategories,
+    scenes,
+    setScenes,
+    platforms,
+    setPlatforms,
+    productCategories,
+    setProductCategories,
+    materialTypes,
+    setMaterialTypes,
+    months,
+    setMonths,
+    
+    // 分页状态
+    displayedCount,
+    setDisplayedCount,
+    currentPage,
+    setCurrentPage,
+    hasMore,
+    setHasMore,
+    isLoadingMore,
+    setIsLoadingMore,
+    totalMaterialsCount,
+    setTotalMaterialsCount,
+    pageSize,
+    
+    // UI状态
+    isFilterCollapsed,
+    setIsFilterCollapsed,
+    showUploadModal,
+    setShowUploadModal,
+    themeColor,
+    setThemeColor,
+    
+    // 搜索防抖处理
+    handleSearchChange,
+    searchDebounceRef,
+  }
+}
--- a/hooks/useMaterials.ts
+++ b/hooks/useMaterials.ts
@ -0,0 +1,335 @@
+/**
+ * 素材数据获取 Hook
+ * 提取自 app/page.tsx 的素材获取和分页逻辑
+ */
+
+import { useCallback, useRef, useEffect } from 'react'
+import type { Material, CategoryItem, MonthItem } from './useHomeState'
+
+interface UseMaterialsParams {
+  // 筛选条件
+  searchKeyword: string
+  selectedCategory: string
+  selectedScene: string
+  selectedMaterialType: string
+  selectedPlatform: string
+  selectedProductCategory: string
+  selectedMonth: string
+  sortBy: string
+  sortOrder: 'desc' | 'asc'
+  pageSize: number
+  
+  // 状态更新函数
+  setMaterials: React.Dispatch<React.SetStateAction<Material[]>>
+  setLoading: React.Dispatch<React.SetStateAction<boolean>>
+  setIsTransitionLoading: React.Dispatch<React.SetStateAction<boolean>>
+  setDisplayedCount: React.Dispatch<React.SetStateAction<number>>
+  setCurrentPage: React.Dispatch<React.SetStateAction<number>>
+  setHasMore: React.Dispatch<React.SetStateAction<boolean>>
+  setIsLoadingMore: React.Dispatch<React.SetStateAction<boolean>>
+  setTotalMaterialsCount: React.Dispatch<React.SetStateAction<number>>
+  setMonths: React.Dispatch<React.SetStateAction<MonthItem[]>>
+  setCategories: React.Dispatch<React.SetStateAction<CategoryItem[]>>
+  setScenes: React.Dispatch<React.SetStateAction<CategoryItem[]>>
+  setPlatforms: React.Dispatch<React.SetStateAction<CategoryItem[]>>
+  setProductCategories: React.Dispatch<React.SetStateAction<CategoryItem[]>>
+  setThemeColor: React.Dispatch<React.SetStateAction<string>>
+  
+  // 当前状态
+  materials: Material[]
+  displayedCount: number
+  currentPage: number
+  hasMore: boolean
+  isLoadingMore: boolean
+}
+
+interface UseMaterialsReturn {
+  fetchMaterials: (page?: number, append?: boolean) => Promise<number>
+  handleLoadMore: () => Promise<void>
+  fetchCategories: () => Promise<void>
+  fetchScenes: (categoryName?: string) => Promise<void>
+  fetchPlatforms: () => Promise<void>
+  fetchProductCategories: () => Promise<void>
+  fetchThemeColor: () => Promise<void>
+  fetchMonthsAndTotal: () => Promise<void>
+  loadMoreRef: React.RefObject<HTMLDivElement>
+  fetchMaterialsRef: React.MutableRefObject<((page?: number, append?: boolean) => Promise<number>) | null>
+}
+
+export function useMaterials(params: UseMaterialsParams): UseMaterialsReturn {
+  const {
+    searchKeyword,
+    selectedCategory,
+    selectedScene,
+    selectedMaterialType,
+    selectedPlatform,
+    selectedProductCategory,
+    selectedMonth,
+    sortBy,
+    sortOrder,
+    pageSize,
+    setMaterials,
+    setLoading,
+    setIsTransitionLoading,
+    setDisplayedCount,
+    setCurrentPage,
+    setHasMore,
+    setIsLoadingMore,
+    setTotalMaterialsCount,
+    setMonths,
+    setCategories,
+    setScenes,
+    setPlatforms,
+    setProductCategories,
+    setThemeColor,
+    materials,
+    displayedCount,
+    currentPage,
+    hasMore,
+    isLoadingMore,
+  } = params
+  
+  const loadMoreRef = useRef<HTMLDivElement>(null)
+  const fetchMaterialsRef = useRef<((page?: number, append?: boolean) => Promise<number>) | null>(null)
+  
+  // 获取素材列表
+  const fetchMaterials = useCallback(
+    async (page = 1, append = false): Promise<number> => {
+      try {
+        const showFullLoading = !append && page === 1 && materials.length === 0
+        if (showFullLoading) {
+          setLoading(true)
+        } else if (!append) {
+          setIsTransitionLoading(true)
+        }
+        if (!append) setHasMore(true)
+
+        const params = new URLSearchParams()
+        if (searchKeyword) params.append('search', searchKeyword)
+        if (selectedCategory) params.append('category', selectedCategory)
+        if (selectedScene) params.append('scene', selectedScene)
+        if (selectedMaterialType) params.append('materialType', selectedMaterialType)
+        if (selectedPlatform) params.append('platform', selectedPlatform)
+        if (selectedProductCategory) params.append('productCategory', selectedProductCategory)
+        if (selectedMonth) params.append('month', selectedMonth)
+        if (sortBy) params.append('sortBy', sortBy)
+        if (sortOrder) params.append('sortOrder', sortOrder)
+        params.append('page', page.toString())
+        params.append('pageSize', pageSize.toString())
+        
+        const url = `/api/materials${params.toString() ? '?' + params.toString() : ''}`
+        const response = await fetch(url)
+        if (response.ok) {
+          const data = await response.json()
+          const materialsList = ((data.materials || data) as Material[])
+            .map((e) => {
+              if (!e.id || typeof e.id !== 'string') return null
+              const trimmedId = e.id.trim()
+              if (!trimmedId || trimmedId.length < 10 || trimmedId.length > 100) return null
+              
+              const previewUrl = e.previewUrl || 
+                e.videoCoverUrl || 
+                (e.displayImages && e.displayImages.length > 0 ? e.displayImages[0] : '')
+              
+              return { ...e, id: trimmedId, previewUrl }
+            })
+            .filter((e): e is Material => e !== null)
+          
+          let appendedItems: Material[] = materialsList
+          if (append) {
+            setMaterials((prev) => {
+              const existingIds = new Set(prev.map((item) => item.id))
+              const deduped = materialsList.filter((item) => !existingIds.has(item.id))
+              appendedItems = deduped
+              if (deduped.length === 0) return prev
+              return [...prev, ...deduped]
+            })
+          } else {
+            setMaterials(materialsList)
+            setDisplayedCount(Math.min(24, materialsList.length))
+          }
+          
+          const appendedCount = append ? appendedItems.length : materialsList.length
+          
+          setCurrentPage(page)
+          const totalPages = data.totalPages || 1
+          setHasMore(appendedCount > 0 && page < totalPages)
+          
+          fetchMonthsAndTotal()
+          
+          return appendedCount
+        }
+      } catch (error) {
+        console.error('Error fetching materials:', error)
+        if (!append) {
+          setMaterials([])
+          setDisplayedCount(0)
+        }
+      } finally {
+        if (!append) {
+          setLoading(false)
+          setIsTransitionLoading(false)
+        }
+      }
+      return 0
+    },
+    [materials.length, searchKeyword, selectedCategory, selectedScene, selectedMaterialType, selectedPlatform, selectedProductCategory, selectedMonth, sortBy, sortOrder, pageSize, setMaterials, setLoading, setIsTransitionLoading, setDisplayedCount, setCurrentPage, setHasMore]
+  )
+  
+  // 更新fetchMaterialsRef
+  useEffect(() => {
+    fetchMaterialsRef.current = fetchMaterials
+  }, [fetchMaterials])
+  
+  // 加载更多
+  const handleLoadMore = useCallback(async () => {
+    if (isLoadingMore) return
+
+    if (displayedCount < materials.length) {
+      setIsLoadingMore(true)
+      setDisplayedCount((prev) => Math.min(prev + 24, materials.length))
+      setIsLoadingMore(false)
+      return
+    }
+
+    if (!hasMore) return
+
+    setIsLoadingMore(true)
+    const appended = await fetchMaterials(currentPage + 1, true)
+    if (appended > 0) {
+      setDisplayedCount((prev) => Math.min(prev + 24, materials.length + appended))
+    }
+    setIsLoadingMore(false)
+  }, [isLoadingMore, displayedCount, materials.length, hasMore, currentPage, fetchMaterials, setIsLoadingMore, setDisplayedCount])
+  
+  // IntersectionObserver实现自动懒加载
+  useEffect(() => {
+    if (!loadMoreRef.current) return
+    if (isLoadingMore) return
+    if (!hasMore && displayedCount >= materials.length) return
+
+    const observer = new IntersectionObserver(
+      (entries) => {
+        if (entries[0].isIntersecting && !isLoadingMore) {
+          handleLoadMore()
+        }
+      },
+      { threshold: 0.1, rootMargin: '100px' }
+    )
+
+    observer.observe(loadMoreRef.current)
+
+    return () => {
+      observer.disconnect()
+    }
+  }, [handleLoadMore, displayedCount, materials.length, hasMore, isLoadingMore])
+  
+  // 获取分类列表
+  const fetchCategories = useCallback(async () => {
+    try {
+      const response = await fetch('/api/categories')
+      if (response.ok) {
+        const data = await response.json()
+        setCategories(data)
+      }
+    } catch (error) {
+      console.error('Error fetching categories:', error)
+    }
+  }, [setCategories])
+  
+  // 获取场景列表
+  const fetchScenes = useCallback(async (categoryName?: string) => {
+    try {
+      const url = categoryName 
+        ? `/api/scenes?category=${encodeURIComponent(categoryName)}`
+        : '/api/scenes'
+      const response = await fetch(url)
+      if (response.ok) {
+        const data = await response.json()
+        setScenes(data)
+      }
+    } catch (error) {
+      console.error('Error fetching scenes:', error)
+    }
+  }, [setScenes])
+  
+  // 获取平台列表
+  const fetchPlatforms = useCallback(async () => {
+    try {
+      const response = await fetch('/api/platforms')
+      if (response.ok) {
+        const data = await response.json()
+        setPlatforms(data)
+      }
+    } catch (error) {
+      console.error('Error fetching platforms:', error)
+    }
+  }, [setPlatforms])
+  
+  // 获取品类列表
+  const fetchProductCategories = useCallback(async () => {
+    try {
+      const response = await fetch('/api/product-categories')
+      if (response.ok) {
+        const data = await response.json()
+        setProductCategories(data)
+      }
+    } catch (error) {
+      console.error('Error fetching product categories:', error)
+    }
+  }, [setProductCategories])
+  
+  // 获取主题颜色
+  const fetchThemeColor = useCallback(async () => {
+    try {
+      const response = await fetch('/api/system-settings')
+      if (response.ok) {
+        const data = await response.json()
+        setThemeColor(data.headerBgColor || '#1f2937')
+      }
+    } catch (error) {
+      console.error('获取主题颜色失败:', error)
+    }
+  }, [setThemeColor])
+  
+  // 获取月份统计和总数
+  const fetchMonthsAndTotal = useCallback(async () => {
+    try {
+      const params = new URLSearchParams()
+      if (searchKeyword) params.append('search', searchKeyword)
+      if (selectedCategory) params.append('category', selectedCategory)
+      if (selectedScene) params.append('scene', selectedScene)
+      if (selectedMaterialType) params.append('materialType', selectedMaterialType)
+      if (selectedPlatform) params.append('platform', selectedPlatform)
+      if (selectedMonth) params.append('month', selectedMonth)
+      params.append('pageSize', '1')
+      
+      const response = await fetch(`/api/materials?${params.toString()}`)
+      if (response.ok) {
+        const data = await response.json()
+        setTotalMaterialsCount(data.total || 0)
+      }
+      
+      const statsResponse = await fetch('/api/materials/stats')
+      if (statsResponse.ok) {
+        const statsData = await statsResponse.json()
+        setMonths(statsData.months || [])
+      }
+    } catch (error) {
+      console.error('Error fetching months and total:', error)
+    }
+  }, [searchKeyword, selectedCategory, selectedScene, selectedMaterialType, selectedPlatform, selectedMonth, setTotalMaterialsCount, setMonths])
+  
+  return {
+    fetchMaterials,
+    handleLoadMore,
+    fetchCategories,
+    fetchScenes,
+    fetchPlatforms,
+    fetchProductCategories,
+    fetchThemeColor,
+    fetchMonthsAndTotal,
+    loadMoreRef,
+    fetchMaterialsRef,
+  }
+}
--- a/hooks/useSpecialBatchUpload.ts
+++ b/hooks/useSpecialBatchUpload.ts
@ -0,0 +1,425 @@
+/**
+ * 特殊类型批量上传 Hook
+ * 封装音乐、视频、3D场景、品牌VI、买家秀、小红书的批量上传逻辑
+ */
+
+import { useState, useCallback } from 'react'
+import { BATCH_LIMITS } from '@/components/upload/upload-constants'
+import { isValidMainFileType } from '@/components/upload/upload-utils'
+import {
+  uploadBatchMusic,
+  uploadBatchVideo,
+  uploadBatch3D,
+  uploadBatchBuyerShow,
+  uploadBatchXiaohongshu,
+  uploadBatchBrandVI,
+} from '@/components/upload/special-batch-uploaders'
+
+// 类型定义
+export interface BatchFileWithSpu {
+  file: File
+  productModel: string
+}
+
+export interface Batch3DFile {
+  file: File
+  productModel: string
+  previewImage?: File
+}
+
+export interface BatchImageGroup {
+  productModel: string
+  images: File[]
+}
+
+export interface UseSpecialBatchUploadOptions {
+  onSuccess: () => void
+  onClose: () => void
+}
+
+/**
+ * 特殊类型批量上传 Hook
+ */
+export function useSpecialBatchUpload(options: UseSpecialBatchUploadOptions) {
+  const { onSuccess, onClose } = options
+
+  // 批量文件状态
+  const [batchMusicFiles, setBatchMusicFiles] = useState<BatchFileWithSpu[]>([])
+  const [batchVideoFiles, setBatchVideoFiles] = useState<BatchFileWithSpu[]>([])
+  const [batch3DFiles, setBatch3DFiles] = useState<Batch3DFile[]>([])
+  const [batchBrandVIFiles, setBatchBrandVIFiles] = useState<BatchFileWithSpu[]>([])
+  const [batchBuyerShowFiles, setBatchBuyerShowFiles] = useState<BatchImageGroup[]>([])
+  const [batchXiaohongshuFiles, setBatchXiaohongshuFiles] = useState<BatchImageGroup[]>([])
+
+  // 上传状态
+  const [uploading, setUploading] = useState(false)
+  const [uploadProgress, setUploadProgress] = useState(0)
+  const [error, setError] = useState('')
+
+  /**
+   * 处理批量文件选择
+   */
+  const handleBatchFileSelect = useCallback((
+    e: React.ChangeEvent<HTMLInputElement>,
+    materialType: string
+  ) => {
+    const files = Array.from(e.target.files || [])
+    if (files.length === 0) return
+
+    const validFiles = files.filter(f => isValidMainFileType(f, materialType))
+    if (validFiles.length === 0) {
+      setError('请选择有效的素材文件')
+      return
+    }
+
+    if (materialType === '音乐') {
+      if (batchMusicFiles.length + validFiles.length > BATCH_LIMITS.music) {
+        setError(`最多只能上传${BATCH_LIMITS.music}个音乐文件`)
+        return
+      }
+      const newFiles = validFiles.map(file => ({
+        file,
+        productModel: file.name.substring(0, file.name.lastIndexOf('.')) || '',
+      }))
+      setBatchMusicFiles(prev => [...prev, ...newFiles])
+    } else if (materialType === '种草视频') {
+      if (batchVideoFiles.length + validFiles.length > BATCH_LIMITS.video) {
+        setError(`最多只能上传${BATCH_LIMITS.video}个视频文件`)
+        return
+      }
+      const newFiles = validFiles.map(file => ({
+        file,
+        productModel: file.name.substring(0, file.name.lastIndexOf('.')) || '',
+      }))
+      setBatchVideoFiles(prev => [...prev, ...newFiles])
+    } else if (materialType === '3D场景') {
+      if (batch3DFiles.length + validFiles.length > BATCH_LIMITS['3d']) {
+        setError(`最多只能上传${BATCH_LIMITS['3d']}个3D场景文件`)
+        return
+      }
+      const newFiles = validFiles.map(file => ({
+        file,
+        productModel: file.name.substring(0, file.name.lastIndexOf('.')) || '',
+      }))
+      setBatch3DFiles(prev => [...prev, ...newFiles])
+    } else if (materialType === '品牌VI灵感') {
+      if (batchBrandVIFiles.length + validFiles.length > BATCH_LIMITS.brandVI) {
+        setError(`最多只能上传${BATCH_LIMITS.brandVI}个PDF文件`)
+        return
+      }
+      const newFiles = validFiles.map(file => ({
+        file,
+        productModel: file.name.substring(0, file.name.lastIndexOf('.')) || '',
+      }))
+      setBatchBrandVIFiles(prev => [...prev, ...newFiles])
+    }
+
+    setError('')
+    if (e.target) {
+      e.target.value = ''
+    }
+  }, [batchMusicFiles.length, batchVideoFiles.length, batch3DFiles.length, batchBrandVIFiles.length])
+
+  /**
+   * 买家秀批量图片选择
+   */
+  const handleBatchBuyerShowImageSelect = useCallback((
+    e: React.ChangeEvent<HTMLInputElement>,
+    batchIndex: number
+  ) => {
+    const files = Array.from(e.target.files || [])
+    if (files.length === 0) return
+
+    const imageFiles = files.filter(f => f.type.startsWith('image/'))
+    if (imageFiles.length === 0) {
+      setError('请选择图片文件')
+      return
+    }
+
+    setBatchBuyerShowFiles(prev => {
+      const newFiles = [...prev]
+      if (!newFiles[batchIndex]) {
+        newFiles[batchIndex] = { productModel: '', images: [] }
+      }
+      newFiles[batchIndex].images = [...newFiles[batchIndex].images, ...imageFiles]
+      return newFiles
+    })
+    setError('')
+    if (e.target) {
+      e.target.value = ''
+    }
+  }, [])
+
+  /**
+   * 小红书批量图片选择
+   */
+  const handleBatchXiaohongshuImageSelect = useCallback((
+    e: React.ChangeEvent<HTMLInputElement>,
+    batchIndex: number
+  ) => {
+    const files = Array.from(e.target.files || [])
+    if (files.length === 0) return
+
+    const imageFiles = files.filter(f => f.type.startsWith('image/'))
+    if (imageFiles.length === 0) {
+      setError('请选择图片文件')
+      return
+    }
+
+    setBatchXiaohongshuFiles(prev => {
+      const newFiles = [...prev]
+      if (!newFiles[batchIndex]) {
+        newFiles[batchIndex] = { productModel: '', images: [] }
+      }
+      newFiles[batchIndex].images = [...newFiles[batchIndex].images, ...imageFiles]
+      return newFiles
+    })
+    setError('')
+    if (e.target) {
+      e.target.value = ''
+    }
+  }, [])
+
+  /**
+   * 添加买家秀批次
+   */
+  const addBuyerShowBatch = useCallback(() => {
+    setBatchBuyerShowFiles(prev => [...prev, { productModel: '', images: [] }])
+  }, [])
+
+  /**
+   * 添加小红书批次
+   */
+  const addXiaohongshuBatch = useCallback(() => {
+    setBatchXiaohongshuFiles(prev => [...prev, { productModel: '', images: [] }])
+  }, [])
+
+  /**
+   * 批量上传音乐
+   */
+  const handleBatchMusicUpload = useCallback(async (platformName: string, renderer: string) => {
+    if (batchMusicFiles.length === 0) return
+
+    setUploading(true)
+    setUploadProgress(0)
+    setError('')
+
+    try {
+      await uploadBatchMusic(batchMusicFiles, platformName, renderer, (progress) => {
+        setUploadProgress(progress)
+      })
+
+      setUploadProgress(100)
+      setUploading(false)
+      setBatchMusicFiles([])
+      onSuccess()
+      onClose()
+    } catch (err) {
+      console.error('[Upload] 批量上传失败:', err)
+      setError('批量上传失败，请重试')
+      setUploading(false)
+    }
+  }, [batchMusicFiles, onSuccess, onClose])
+
+  /**
+   * 批量上传视频
+   */
+  const handleBatchVideoUpload = useCallback(async (platformName: string, renderer: string) => {
+    if (batchVideoFiles.length === 0) return
+
+    setUploading(true)
+    setUploadProgress(0)
+    setError('')
+
+    try {
+      await uploadBatchVideo(batchVideoFiles, platformName, renderer, (progress) => {
+        setUploadProgress(progress)
+      })
+
+      setUploadProgress(100)
+      setUploading(false)
+      setBatchVideoFiles([])
+      onSuccess()
+      onClose()
+    } catch (err) {
+      console.error('[Upload] 批量上传失败:', err)
+      setError('批量上传失败，请重试')
+      setUploading(false)
+    }
+  }, [batchVideoFiles, onSuccess, onClose])
+
+  /**
+   * 批量上传3D场景
+   */
+  const handleBatch3DUpload = useCallback(async (
+    categoryName: string,
+    sceneName: string,
+    platformName: string,
+    renderer: string
+  ) => {
+    if (batch3DFiles.length === 0) return
+
+    setUploading(true)
+    setUploadProgress(0)
+    setError('')
+
+    try {
+      await uploadBatch3D(batch3DFiles, categoryName, sceneName, platformName, renderer, (progress) => {
+        setUploadProgress(progress)
+      })
+
+      setUploadProgress(100)
+      setUploading(false)
+      setBatch3DFiles([])
+      onSuccess()
+      onClose()
+    } catch (err) {
+      console.error('[Upload] 批量上传失败:', err)
+      setError('批量上传失败，请重试')
+      setUploading(false)
+    }
+  }, [batch3DFiles, onSuccess, onClose])
+
+  /**
+   * 批量上传品牌VI
+   */
+  const handleBatchBrandVIUpload = useCallback(async (platformName: string, renderer: string) => {
+    if (batchBrandVIFiles.length === 0) return
+
+    setUploading(true)
+    setUploadProgress(0)
+    setError('')
+
+    try {
+      await uploadBatchBrandVI(batchBrandVIFiles, platformName, renderer, (progress) => {
+        setUploadProgress(progress)
+      })
+
+      setUploadProgress(100)
+      setUploading(false)
+      setBatchBrandVIFiles([])
+      onSuccess()
+      onClose()
+    } catch (err) {
+      console.error('[Upload] 批量上传失败:', err)
+      setError('批量上传失败，请重试')
+      setUploading(false)
+    }
+  }, [batchBrandVIFiles, onSuccess, onClose])
+
+  /**
+   * 批量上传买家秀
+   */
+  const handleBatchBuyerShowUpload = useCallback(async (
+    categoryName: string,
+    sceneName: string,
+    platformName: string,
+    renderer: string
+  ) => {
+    if (batchBuyerShowFiles.length === 0) return
+
+    setUploading(true)
+    setUploadProgress(0)
+    setError('')
+
+    try {
+      await uploadBatchBuyerShow(batchBuyerShowFiles, categoryName, sceneName, platformName, renderer, (progress) => {
+        setUploadProgress(progress)
+      })
+
+      setUploadProgress(100)
+      setUploading(false)
+      setBatchBuyerShowFiles([])
+      onSuccess()
+      onClose()
+    } catch (err) {
+      console.error('[Upload] 批量上传失败:', err)
+      setError('批量上传失败，请重试')
+      setUploading(false)
+    }
+  }, [batchBuyerShowFiles, onSuccess, onClose])
+
+  /**
+   * 批量上传小红书
+   */
+  const handleBatchXiaohongshuUpload = useCallback(async (
+    categoryName: string,
+    sceneName: string,
+    platformName: string,
+    renderer: string
+  ) => {
+    if (batchXiaohongshuFiles.length === 0) return
+
+    setUploading(true)
+    setUploadProgress(0)
+    setError('')
+
+    try {
+      await uploadBatchXiaohongshu(batchXiaohongshuFiles, categoryName, sceneName, platformName, renderer, (progress) => {
+        setUploadProgress(progress)
+      })
+
+      setUploadProgress(100)
+      setUploading(false)
+      setBatchXiaohongshuFiles([])
+      onSuccess()
+      onClose()
+    } catch (err) {
+      console.error('[Upload] 批量上传失败:', err)
+      setError('批量上传失败，请重试')
+      setUploading(false)
+    }
+  }, [batchXiaohongshuFiles, onSuccess, onClose])
+
+  /**
+   * 清空所有批量文件
+   */
+  const clearAllBatchFiles = useCallback(() => {
+    setBatchMusicFiles([])
+    setBatchVideoFiles([])
+    setBatch3DFiles([])
+    setBatchBrandVIFiles([])
+    setBatchBuyerShowFiles([])
+    setBatchXiaohongshuFiles([])
+  }, [])
+
+  return {
+    // 批量文件状态
+    batchMusicFiles,
+    batchVideoFiles,
+    batch3DFiles,
+    batchBrandVIFiles,
+    batchBuyerShowFiles,
+    batchXiaohongshuFiles,
+    
+    // 状态设置函数
+    setBatchMusicFiles,
+    setBatchVideoFiles,
+    setBatch3DFiles,
+    setBatchBrandVIFiles,
+    setBatchBuyerShowFiles,
+    setBatchXiaohongshuFiles,
+    
+    // 上传状态
+    uploading,
+    uploadProgress,
+    error,
+    setError,
+    setUploading,
+    setUploadProgress,
+    
+    // 操作函数
+    handleBatchFileSelect,
+    handleBatchBuyerShowImageSelect,
+    handleBatchXiaohongshuImageSelect,
+    addBuyerShowBatch,
+    addXiaohongshuBatch,
+    handleBatchMusicUpload,
+    handleBatchVideoUpload,
+    handleBatch3DUpload,
+    handleBatchBrandVIUpload,
+    handleBatchBuyerShowUpload,
+    handleBatchXiaohongshuUpload,
+    clearAllBatchFiles,
+  }
+}
--- a/hooks/useUploadState.ts
+++ b/hooks/useUploadState.ts
@ -0,0 +1,280 @@
+/**
+ * 上传状态管理 Hook
+ * 封装 UploadModal 组件的所有状态定义
+ */
+
+import { useState, useRef } from 'react'
+import type { BatchFileItem, BatchUploadStatus } from '@/components/upload/upload-types'
+
+/**
+ * 上传状态接口
+ */
+export interface UploadState {
+  // 预览图片
+  previewImages: File[]
+  previewUrls: string[]
+  
+  // 详情页展示图片
+  displayImage: File | null
+  displayImageUrl: string
+  
+  // 模特图片
+  modelImages: File[]
+  modelImageUrls: string[]
+  
+  // 素材文件
+  zipFile: File | null
+  
+  // 表单字段
+  productModel: string
+  categoryName: string
+  sceneName: string
+  platformName: string
+  productCategoryName: string
+  materialType: string
+  renderer: string
+  
+  // 新建分类输入
+  showNewCategoryInput: boolean
+  newCategoryName: string
+  showNewSceneInput: boolean
+  newSceneName: string
+  
+  // 上传状态
+  uploading: boolean
+  uploadProgress: number
+  uploadSpeed: number
+  isProcessing: boolean
+  error: string
+  retryCount: number
+  
+  // 批量上传
+  batchFiles: BatchFileItem[]
+  isBatchMode: boolean
+  batchUploadStatus: BatchUploadStatus | null
+  
+  // 拖拽状态
+  isDragging: boolean
+  isDisplayImageDragging: boolean
+  isPreviewDragging: boolean
+  batchPreviewDragging: Record<string, boolean>
+}
+
+/**
+ * 上传状态操作接口
+ */
+export interface UploadStateActions {
+  // 预览图片操作
+  setPreviewImages: React.Dispatch<React.SetStateAction<File[]>>
+  setPreviewUrls: React.Dispatch<React.SetStateAction<string[]>>
+  
+  // 详情页展示图片操作
+  setDisplayImage: React.Dispatch<React.SetStateAction<File | null>>
+  setDisplayImageUrl: React.Dispatch<React.SetStateAction<string>>
+  
+  // 模特图片操作
+  setModelImages: React.Dispatch<React.SetStateAction<File[]>>
+  setModelImageUrls: React.Dispatch<React.SetStateAction<string[]>>
+  
+  // 素材文件操作
+  setZipFile: React.Dispatch<React.SetStateAction<File | null>>
+  
+  // 表单字段操作
+  setProductModel: React.Dispatch<React.SetStateAction<string>>
+  setCategoryName: React.Dispatch<React.SetStateAction<string>>
+  setSceneName: React.Dispatch<React.SetStateAction<string>>
+  setPlatformName: React.Dispatch<React.SetStateAction<string>>
+  setProductCategoryName: React.Dispatch<React.SetStateAction<string>>
+  setMaterialType: React.Dispatch<React.SetStateAction<string>>
+  setRenderer: React.Dispatch<React.SetStateAction<string>>
+  
+  // 新建分类输入操作
+  setShowNewCategoryInput: React.Dispatch<React.SetStateAction<boolean>>
+  setNewCategoryName: React.Dispatch<React.SetStateAction<string>>
+  setShowNewSceneInput: React.Dispatch<React.SetStateAction<boolean>>
+  setNewSceneName: React.Dispatch<React.SetStateAction<string>>
+  
+  // 上传状态操作
+  setUploading: React.Dispatch<React.SetStateAction<boolean>>
+  setUploadProgress: React.Dispatch<React.SetStateAction<number>>
+  setUploadSpeed: React.Dispatch<React.SetStateAction<number>>
+  setIsProcessing: React.Dispatch<React.SetStateAction<boolean>>
+  setError: React.Dispatch<React.SetStateAction<string>>
+  setRetryCount: React.Dispatch<React.SetStateAction<number>>
+  
+  // 批量上传操作
+  setBatchFiles: React.Dispatch<React.SetStateAction<BatchFileItem[]>>
+  setIsBatchMode: React.Dispatch<React.SetStateAction<boolean>>
+  setBatchUploadStatus: React.Dispatch<React.SetStateAction<BatchUploadStatus | null>>
+  
+  // 拖拽状态操作
+  setIsDragging: React.Dispatch<React.SetStateAction<boolean>>
+  setIsDisplayImageDragging: React.Dispatch<React.SetStateAction<boolean>>
+  setIsPreviewDragging: React.Dispatch<React.SetStateAction<boolean>>
+  setBatchPreviewDragging: React.Dispatch<React.SetStateAction<Record<string, boolean>>>
+}
+
+/**
+ * Refs 接口
+ */
+export interface UploadRefs {
+  previewInputRef: React.RefObject<HTMLInputElement>
+  zipInputRef: React.RefObject<HTMLInputElement>
+  dropZoneRef: React.RefObject<HTMLDivElement>
+  displayImageDropZoneRef: React.RefObject<HTMLDivElement>
+  previewDropZoneRef: React.RefObject<HTMLDivElement>
+  xhrRef: React.MutableRefObject<XMLHttpRequest | null>
+  batchFileInputRef: React.RefObject<HTMLInputElement>
+  batchUploadCancelRef: React.MutableRefObject<{ cancelled: boolean }>
+  batchUploadXhrRefs: React.MutableRefObject<Map<string, XMLHttpRequest>>
+  batchUploadIdsRef: React.MutableRefObject<Map<string, string>>
+}
+
+/**
+ * 上传状态管理 Hook
+ */
+export function useUploadState() {
+  // 预览图片
+  const [previewImages, setPreviewImages] = useState<File[]>([])
+  const [previewUrls, setPreviewUrls] = useState<string[]>([])
+  
+  // 详情页展示图片
+  const [displayImage, setDisplayImage] = useState<File | null>(null)
+  const [displayImageUrl, setDisplayImageUrl] = useState<string>('')
+  
+  // 模特图片
+  const [modelImages, setModelImages] = useState<File[]>([])
+  const [modelImageUrls, setModelImageUrls] = useState<string[]>([])
+  
+  // 素材文件
+  const [zipFile, setZipFile] = useState<File | null>(null)
+  
+  // 表单字段
+  const [productModel, setProductModel] = useState('')
+  const [categoryName, setCategoryName] = useState('')
+  const [sceneName, setSceneName] = useState('')
+  const [platformName, setPlatformName] = useState('')
+  const [productCategoryName, setProductCategoryName] = useState('')
+  const [materialType, setMaterialType] = useState('3D场景')
+  const [renderer, setRenderer] = useState('CR')
+  
+  // 新建分类输入
+  const [showNewCategoryInput, setShowNewCategoryInput] = useState(false)
+  const [newCategoryName, setNewCategoryName] = useState('')
+  const [showNewSceneInput, setShowNewSceneInput] = useState(false)
+  const [newSceneName, setNewSceneName] = useState('')
+  
+  // 上传状态
+  const [uploading, setUploading] = useState(false)
+  const [uploadProgress, setUploadProgress] = useState(0)
+  const [uploadSpeed, setUploadSpeed] = useState(0)
+  const [isProcessing, setIsProcessing] = useState(false)
+  const [error, setError] = useState('')
+  const [retryCount, setRetryCount] = useState(0)
+  
+  // 批量上传
+  const [batchFiles, setBatchFiles] = useState<BatchFileItem[]>([])
+  const [isBatchMode, setIsBatchMode] = useState(false)
+  const [batchUploadStatus, setBatchUploadStatus] = useState<BatchUploadStatus | null>(null)
+  
+  // 拖拽状态
+  const [isDragging, setIsDragging] = useState(false)
+  const [isDisplayImageDragging, setIsDisplayImageDragging] = useState(false)
+  const [isPreviewDragging, setIsPreviewDragging] = useState(false)
+  const [batchPreviewDragging, setBatchPreviewDragging] = useState<Record<string, boolean>>({})
+  
+  // Refs
+  const previewInputRef = useRef<HTMLInputElement>(null)
+  const zipInputRef = useRef<HTMLInputElement>(null)
+  const dropZoneRef = useRef<HTMLDivElement>(null)
+  const displayImageDropZoneRef = useRef<HTMLDivElement>(null)
+  const previewDropZoneRef = useRef<HTMLDivElement>(null)
+  const xhrRef = useRef<XMLHttpRequest | null>(null)
+  const batchFileInputRef = useRef<HTMLInputElement>(null)
+  const batchUploadCancelRef = useRef<{ cancelled: boolean }>({ cancelled: false })
+  const batchUploadXhrRefs = useRef<Map<string, XMLHttpRequest>>(new Map())
+  const batchUploadIdsRef = useRef<Map<string, string>>(new Map())
+  
+  const state: UploadState = {
+    previewImages,
+    previewUrls,
+    displayImage,
+    displayImageUrl,
+    modelImages,
+    modelImageUrls,
+    zipFile,
+    productModel,
+    categoryName,
+    sceneName,
+    platformName,
+    productCategoryName,
+    materialType,
+    renderer,
+    showNewCategoryInput,
+    newCategoryName,
+    showNewSceneInput,
+    newSceneName,
+    uploading,
+    uploadProgress,
+    uploadSpeed,
+    isProcessing,
+    error,
+    retryCount,
+    batchFiles,
+    isBatchMode,
+    batchUploadStatus,
+    isDragging,
+    isDisplayImageDragging,
+    isPreviewDragging,
+    batchPreviewDragging,
+  }
+  
+  const actions: UploadStateActions = {
+    setPreviewImages,
+    setPreviewUrls,
+    setDisplayImage,
+    setDisplayImageUrl,
+    setModelImages,
+    setModelImageUrls,
+    setZipFile,
+    setProductModel,
+    setCategoryName,
+    setSceneName,
+    setPlatformName,
+    setProductCategoryName,
+    setMaterialType,
+    setRenderer,
+    setShowNewCategoryInput,
+    setNewCategoryName,
+    setShowNewSceneInput,
+    setNewSceneName,
+    setUploading,
+    setUploadProgress,
+    setUploadSpeed,
+    setIsProcessing,
+    setError,
+    setRetryCount,
+    setBatchFiles,
+    setIsBatchMode,
+    setBatchUploadStatus,
+    setIsDragging,
+    setIsDisplayImageDragging,
+    setIsPreviewDragging,
+    setBatchPreviewDragging,
+  }
+  
+  const refs: UploadRefs = {
+    previewInputRef,
+    zipInputRef,
+    dropZoneRef,
+    displayImageDropZoneRef,
+    previewDropZoneRef,
+    xhrRef,
+    batchFileInputRef,
+    batchUploadCancelRef,
+    batchUploadXhrRefs,
+    batchUploadIdsRef,
+  }
+  
+  return { state, actions, refs }
+}
--- a/lib/video-transcode-task.ts
+++ b/lib/video-transcode-task.ts
@ -150,10 +150,20 @@ export async function enqueueVideoTranscodeTask(
  }

  console.log(`[TranscodeTask] 📝 Enqueuing transcode task: materialId=${materialId}, videoSourceUrl=${videoSourceUrl}, needsCoverImage=${needsCoverImage}`)
-  
-  await transcodeQueue.add(materialId, videoSourceUrl, needsCoverImage, executeTranscodeTask)
-  
-  console.log(`[TranscodeTask] ✅ Transcode task enqueued successfully: materialId=${materialId}`)
+
+  // 注意：这里不等待整个转码流程完成，只负责把任务丢进队列即可
+  // 队列内部会在任务开始/结束时更新数据库状态和进度
+  transcodeQueue
+    .add(materialId, videoSourceUrl, needsCoverImage, executeTranscodeTask)
+    .then(() => {
+      console.log(`[TranscodeTask] ✅ Transcode task finished in queue: materialId=${materialId}`)
+    })
+    .catch((error) => {
+      // 这里一般不会抛出未处理错误，因为 executeTranscodeTask 内部已经负责更新失败状态
+      console.error(`[TranscodeTask] ❌ Transcode task error in queue for material ${materialId}:`, error)
+    })
+
+  console.log(`[TranscodeTask] ✅ Transcode task enqueued successfully (fire-and-forget): materialId=${materialId}`)
 }


--- a/package-lock.json
+++ b/package-lock.json
@ -10,6 +10,9 @@
      "dependencies": {
        "@aws-sdk/client-s3": "^3.917.0",
        "@aws-sdk/s3-request-presigner": "^3.645.0",
+        "@dnd-kit/core": "^6.3.1",
+        "@dnd-kit/sortable": "^10.0.0",
+        "@dnd-kit/utilities": "^3.2.2",
        "@prisma/client": "^5.22.0",
        "@prisma/engines": "^6.18.0",
        "ag-psd": "^28.4.1",
@ -30,6 +33,7 @@
        "zod": "^3.23.0"
      },
      "devDependencies": {
+        "@testing-library/dom": "^10.4.1",
        "@testing-library/jest-dom": "^6.9.1",
        "@testing-library/react": "^16.3.1",
        "@testing-library/user-event": "^14.6.1",
@ -2486,6 +2490,59 @@
        "node": ">=18"
      }
    },
+    "node_modules/@dnd-kit/accessibility": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmmirror.com/@dnd-kit/accessibility/-/accessibility-3.1.1.tgz",
+      "integrity": "sha512-2P+YgaXF+gRsIihwwY1gCsQSYnu9Zyj2py8kY5fFvUM1qm2WA2u639R6YNVfU4GWr+ZM5mqEsfHZZLoRONbemw==",
+      "license": "MIT",
+      "dependencies": {
+        "tslib": "^2.0.0"
+      },
+      "peerDependencies": {
+        "react": ">=16.8.0"
+      }
+    },
+    "node_modules/@dnd-kit/core": {
+      "version": "6.3.1",
+      "resolved": "https://registry.npmmirror.com/@dnd-kit/core/-/core-6.3.1.tgz",
+      "integrity": "sha512-xkGBRQQab4RLwgXxoqETICr6S5JlogafbhNsidmrkVv2YRs5MLwpjoF2qpiGjQt8S9AoxtIV603s0GIUpY5eYQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@dnd-kit/accessibility": "^3.1.1",
+        "@dnd-kit/utilities": "^3.2.2",
+        "tslib": "^2.0.0"
+      },
+      "peerDependencies": {
+        "react": ">=16.8.0",
+        "react-dom": ">=16.8.0"
+      }
+    },
+    "node_modules/@dnd-kit/sortable": {
+      "version": "10.0.0",
+      "resolved": "https://registry.npmmirror.com/@dnd-kit/sortable/-/sortable-10.0.0.tgz",
+      "integrity": "sha512-+xqhmIIzvAYMGfBYYnbKuNicfSsk4RksY2XdmJhT+HAC01nix6fHCztU68jooFiMUB01Ky3F0FyOvhG/BZrWkg==",
+      "license": "MIT",
+      "dependencies": {
+        "@dnd-kit/utilities": "^3.2.2",
+        "tslib": "^2.0.0"
+      },
+      "peerDependencies": {
+        "@dnd-kit/core": "^6.3.0",
+        "react": ">=16.8.0"
+      }
+    },
+    "node_modules/@dnd-kit/utilities": {
+      "version": "3.2.2",
+      "resolved": "https://registry.npmmirror.com/@dnd-kit/utilities/-/utilities-3.2.2.tgz",
+      "integrity": "sha512-+MKAJEOfaBe5SmV6t34p80MMKhjvUz0vRrvVJbPT0WElzaOJ/1xs+D+KDv+tD/NE5ujfrChEcshd4fLn0wpiqg==",
+      "license": "MIT",
+      "dependencies": {
+        "tslib": "^2.0.0"
+      },
+      "peerDependencies": {
+        "react": ">=16.8.0"
+      }
+    },
    "node_modules/@emnapi/core": {
      "version": "1.5.0",
      "resolved": "https://registry.npmjs.org/@emnapi/core/-/core-1.5.0.tgz",
@ -4816,6 +4873,78 @@
        "tslib": "^2.4.0"
      }
    },
+    "node_modules/@testing-library/dom": {
+      "version": "10.4.1",
+      "resolved": "https://registry.npmmirror.com/@testing-library/dom/-/dom-10.4.1.tgz",
+      "integrity": "sha512-o4PXJQidqJl82ckFaXUeoAW+XysPLauYI43Abki5hABd853iMhitooc6znOnczgbTYmEP6U6/y1ZyKAIsvMKGg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/code-frame": "^7.10.4",
+        "@babel/runtime": "^7.12.5",
+        "@types/aria-query": "^5.0.1",
+        "aria-query": "5.3.0",
+        "dom-accessibility-api": "^0.5.9",
+        "lz-string": "^1.5.0",
+        "picocolors": "1.1.1",
+        "pretty-format": "^27.0.2"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@testing-library/dom/node_modules/ansi-styles": {
+      "version": "5.2.0",
+      "resolved": "https://registry.npmmirror.com/ansi-styles/-/ansi-styles-5.2.0.tgz",
+      "integrity": "sha512-Cxwpt2SfTzTtXcfOlzGEee8O+c+MmUgGrNiBcXnuWxuFJHe6a5Hz7qwhwe5OgaSYI0IJvkLqWX1ASG+cJOkEiA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
+      }
+    },
+    "node_modules/@testing-library/dom/node_modules/aria-query": {
+      "version": "5.3.0",
+      "resolved": "https://registry.npmmirror.com/aria-query/-/aria-query-5.3.0.tgz",
+      "integrity": "sha512-b0P0sZPKtyu8HkeRAfCq0IfURZK+SuwMjY1UXGBU27wpAiTwQAIlq56IbIO+ytk/JjS1fMR14ee5WBBfKi5J6A==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "dequal": "^2.0.3"
+      }
+    },
+    "node_modules/@testing-library/dom/node_modules/dom-accessibility-api": {
+      "version": "0.5.16",
+      "resolved": "https://registry.npmmirror.com/dom-accessibility-api/-/dom-accessibility-api-0.5.16.tgz",
+      "integrity": "sha512-X7BJ2yElsnOJ30pZF4uIIDfBEVgF4XEBxL9Bxhy6dnrm5hkzqmsWHGTiHqRiITNhMyFLyAiWndIJP7Z1NTteDg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@testing-library/dom/node_modules/pretty-format": {
+      "version": "27.5.1",
+      "resolved": "https://registry.npmmirror.com/pretty-format/-/pretty-format-27.5.1.tgz",
+      "integrity": "sha512-Qb1gy5OrP5+zDf2Bvnzdl3jsTf1qXVMazbvCoKhtKqVs4/YK4ozX4gKQJJVyNe+cajNPn0KoC0MC3FUmaHWEmQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ansi-regex": "^5.0.1",
+        "ansi-styles": "^5.0.0",
+        "react-is": "^17.0.1"
+      },
+      "engines": {
+        "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0"
+      }
+    },
+    "node_modules/@testing-library/dom/node_modules/react-is": {
+      "version": "17.0.2",
+      "resolved": "https://registry.npmmirror.com/react-is/-/react-is-17.0.2.tgz",
+      "integrity": "sha512-w2GsyukL62IJnlaff/nRegPQR94C/XXamvMWmSHRJ4y7Ts/4ocGRmTHvOs8PSE6pB3dWOrD/nueuU5sduBsQ4w==",
+      "dev": true,
+      "license": "MIT"
+    },
    "node_modules/@testing-library/jest-dom": {
      "version": "6.9.1",
      "resolved": "https://registry.npmmirror.com/@testing-library/jest-dom/-/jest-dom-6.9.1.tgz",
@ -4922,6 +5051,13 @@
        "@types/readdir-glob": "*"
      }
    },
+    "node_modules/@types/aria-query": {
+      "version": "5.0.4",
+      "resolved": "https://registry.npmmirror.com/@types/aria-query/-/aria-query-5.0.4.tgz",
+      "integrity": "sha512-rfT93uj5s0PRL7EzccGMs3brplhcrghnDoV26NqKhCAS1hVo+WdNsPvE/yb6ilfr5hi2MEk6d5EWJTKdxg8jVw==",
+      "dev": true,
+      "license": "MIT"
+    },
    "node_modules/@types/babel__core": {
      "version": "7.20.5",
      "resolved": "https://registry.npmmirror.com/@types/babel__core/-/babel__core-7.20.5.tgz",
@ -7300,6 +7436,16 @@
        "node": ">=0.10"
      }
    },
+    "node_modules/dequal": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmmirror.com/dequal/-/dequal-2.0.3.tgz",
+      "integrity": "sha512-0je+qPKHEMohvfRTCEo3CrPG6cAzAYgmzKyxRiYSSDkS6eGJdyVJm7WaYA5ECaAD9wLB2T4EEeymA5aFVcYXCA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
    "node_modules/detect-libc": {
      "version": "2.1.2",
      "resolved": "https://registry.npmjs.org/detect-libc/-/detect-libc-2.1.2.tgz",
@ -11166,6 +11312,16 @@
        "node": ">=10"
      }
    },
+    "node_modules/lz-string": {
+      "version": "1.5.0",
+      "resolved": "https://registry.npmmirror.com/lz-string/-/lz-string-1.5.0.tgz",
+      "integrity": "sha512-h5bgJWpxJNswbU7qCrV0tIKQCaS3blPDrqKWx+QxzuzL1zGUzij9XCWLrSLsJPu5t+eWA/ycetzYAO5IOMcWAQ==",
+      "dev": true,
+      "license": "MIT",
+      "bin": {
+        "lz-string": "bin/bin.js"
+      }
+    },
    "node_modules/make-dir": {
      "version": "3.1.0",
      "resolved": "https://registry.npmjs.org/make-dir/-/make-dir-3.1.0.tgz",
--- a/package.json
+++ b/package.json
@ -18,6 +18,9 @@
  "dependencies": {
    "@aws-sdk/client-s3": "^3.917.0",
    "@aws-sdk/s3-request-presigner": "^3.645.0",
+    "@dnd-kit/core": "^6.3.1",
+    "@dnd-kit/sortable": "^10.0.0",
+    "@dnd-kit/utilities": "^3.2.2",
    "@prisma/client": "^5.22.0",
    "@prisma/engines": "^6.18.0",
    "ag-psd": "^28.4.1",
@ -38,6 +41,7 @@
    "zod": "^3.23.0"
  },
  "devDependencies": {
+    "@testing-library/dom": "^10.4.1",
    "@testing-library/jest-dom": "^6.9.1",
    "@testing-library/react": "^16.3.1",
    "@testing-library/user-event": "^14.6.1",
--- a/prisma/schema.prisma
+++ b/prisma/schema.prisma
@ -162,19 +162,23 @@ model MaterialLog {

 // SKU 表（用于标准模型类型）
 model MaterialSku {
-  id         String   @id @default(uuid())
-  materialId String   @map("material_id")
-  skuName    String   @map("sku_name")
-  filePath   String   @map("file_path")
-  fileSize   BigInt   @default(0) @map("file_size")
-  sortOrder  Int      @default(0) @map("sort_order")
-  createdAt  DateTime @default(now()) @map("created_at")
-  updatedAt  DateTime @updatedAt @map("updated_at")
+  id         String    @id @default(uuid())
+  materialId String    @map("material_id")
+  skuName    String    @map("sku_name")
+  previewUrl String?   @map("preview_url") // 预览图URL（可选）
+  filePath   String    @map("file_path") // 压缩包文件路径
+  fileName   String?   @map("file_name") // 压缩包文件名（可选，用于显示）
+  fileSize   BigInt    @default(0) @map("file_size")
+  sortOrder  Int       @default(0) @map("sort_order")
+  deletedAt  DateTime? @map("deleted_at") // 软删除时间戳
+  createdAt  DateTime  @default(now()) @map("created_at")
+  updatedAt  DateTime  @updatedAt @map("updated_at")

  material Material @relation(fields: [materialId], references: [id], onDelete: Cascade)

  @@index([materialId])
  @@index([sortOrder])
+  @@index([deletedAt])
  @@map("material_skus")
 }

@ -222,6 +226,11 @@ model SystemSettings {
  s3Bucket      String   @default("")
  s3Region      String   @default("us-east-1")
  s3PublicUrl   String   @default("")
+  // 系统维护通知
+  maintenanceEnabled Boolean @default(false) // 是否启用维护通知
+  maintenanceMessage String? // 维护通知内容
+  maintenanceStartTime DateTime? // 维护开始时间
+  maintenanceEndTime DateTime? // 维护结束时间
  updatedAt     DateTime @updatedAt
  createdAt     DateTime @default(now())

--- a/scripts/execute-sql-in-container.js
+++ b/scripts/execute-sql-in-container.js
@ -0,0 +1,52 @@
+const { PrismaClient } = require('@prisma/client')
+const prisma = new PrismaClient()
+
+async function main() {
+  try {
+    // 检查字段是否已存在
+    const result = await prisma.$queryRaw`
+      SELECT column_name 
+      FROM information_schema.columns 
+      WHERE table_name = 'material_skus' 
+      AND column_name = 'deleted_at'
+    `
+    
+    if (result.length === 0) {
+      console.log('添加 deleted_at 字段...')
+      await prisma.$executeRaw`
+        ALTER TABLE material_skus ADD COLUMN deleted_at TIMESTAMP
+      `
+      console.log('✅ deleted_at 字段已添加')
+    } else {
+      console.log('ℹ️  deleted_at 字段已存在')
+    }
+
+    // 检查索引是否已存在
+    const indexResult = await prisma.$queryRaw`
+      SELECT indexname 
+      FROM pg_indexes 
+      WHERE tablename = 'material_skus' 
+      AND indexname = 'material_skus_deleted_at_idx'
+    `
+    
+    if (indexResult.length === 0) {
+      console.log('添加 deleted_at 索引...')
+      await prisma.$executeRaw`
+        CREATE INDEX material_skus_deleted_at_idx ON material_skus(deleted_at)
+      `
+      console.log('✅ deleted_at 索引已添加')
+    } else {
+      console.log('ℹ️  deleted_at 索引已存在')
+    }
+
+    console.log('✅ 数据库迁移完成')
+  } catch (error) {
+    console.error('❌ 迁移失败:', error)
+    process.exit(1)
+  } finally {
+    await prisma.$disconnect()
+  }
+}
+
+main()
+
--- a/scripts/sync-prod-to-shadow-auto.sh
+++ b/scripts/sync-prod-to-shadow-auto.sh
@ -0,0 +1,102 @@
+#!/bin/bash
+
+# 同步正式环境数据库到影子系统（自动输入密码版本）
+# 用于将正式环境（lobechat）的数据同步到影子系统（lobechat_stage）
+
+SERVER_IP="192.168.58.20"
+PROD_DB_NAME="lobechat"
+SHADOW_DB_NAME="lobechat_stage"
+DB_USER="gongxiangpan"
+DB_PASSWORD="gongxiangpan123"
+SSH_PASSWORD="jsjj8888"
+TIMESTAMP=$(date +%Y%m%d_%H%M%S)
+
+# 检查是否安装了sshpass
+if ! command -v sshpass &> /dev/null; then
+    echo "❌ 未安装 sshpass，请先安装："
+    echo "   Windows (Git Bash): 需要安装 sshpass 或使用手动版本"
+    echo "   或者手动运行: bash scripts/sync-prod-to-shadow.sh"
+    exit 1
+fi
+
+echo "========================================"
+echo "同步正式环境数据库到影子系统"
+echo "========================================"
+echo ""
+echo "数据库信息："
+echo "  服务器：$SERVER_IP"
+echo "  正式环境：$PROD_DB_NAME"
+echo "  影子系统：$SHADOW_DB_NAME"
+echo ""
+
+# 确认操作
+read -p "⚠️  此操作将覆盖影子系统的数据，是否继续？(y/N) " confirm
+if [ "$confirm" != "y" ] && [ "$confirm" != "Y" ]; then
+    echo "❌ 操作已取消"
+    exit 0
+fi
+
+echo ""
+echo "📦 步骤 1: 备份影子系统数据库..."
+sshpass -p "$SSH_PASSWORD" ssh -o StrictHostKeyChecking=no root@$SERVER_IP "docker exec gongxiangpan-postgres-1 pg_dump -U $DB_USER -d $SHADOW_DB_NAME -Fc -f /tmp/lobechat_stage_backup_${TIMESTAMP}.dump"
+
+if [ $? -eq 0 ]; then
+    echo "✅ 备份成功：/tmp/lobechat_stage_backup_${TIMESTAMP}.dump"
+else
+    echo "⚠️  备份失败，但继续执行..."
+fi
+
+echo ""
+echo "📥 步骤 2: 从正式环境导出数据..."
+EXPORT_FILE="lobechat_export_${TIMESTAMP}.dump"
+sshpass -p "$SSH_PASSWORD" ssh -o StrictHostKeyChecking=no root@$SERVER_IP "docker exec gongxiangpan-postgres-1 pg_dump -U $DB_USER -d $PROD_DB_NAME -Fc -f /tmp/$EXPORT_FILE"
+
+if [ $? -eq 0 ]; then
+    echo "✅ 导出成功：/tmp/$EXPORT_FILE"
+else
+    echo "❌ 导出失败！"
+    exit 1
+fi
+
+echo ""
+echo "📤 步骤 3: 导入数据到影子系统（会清空现有数据）..."
+sshpass -p "$SSH_PASSWORD" ssh -o StrictHostKeyChecking=no root@$SERVER_IP "docker exec gongxiangpan-postgres-1 pg_restore -U $DB_USER -d $SHADOW_DB_NAME --clean --if-exists /tmp/$EXPORT_FILE"
+
+if [ $? -eq 0 ]; then
+    echo "✅ 导入成功！"
+else
+    echo "⚠️  导入可能有问题，请检查输出..."
+fi
+
+echo ""
+echo "🔍 步骤 4: 验证同步结果..."
+sshpass -p "$SSH_PASSWORD" ssh -o StrictHostKeyChecking=no root@$SERVER_IP "docker exec gongxiangpan-postgres-1 psql -U $DB_USER -d $SHADOW_DB_NAME -c 'SELECT (SELECT COUNT(*) FROM users) as users_count, (SELECT COUNT(*) FROM materials) as materials_count, (SELECT COUNT(*) FROM material_skus) as skus_count;'"
+
+echo ""
+echo "🔧 步骤 5: 确保影子系统有最新字段..."
+sshpass -p "$SSH_PASSWORD" scp -o StrictHostKeyChecking=no scripts/add-sku-fields.sql root@$SERVER_IP:/tmp/add-sku-fields.sql
+sshpass -p "$SSH_PASSWORD" ssh -o StrictHostKeyChecking=no root@$SERVER_IP "cat /tmp/add-sku-fields.sql | docker exec -i gongxiangpan-postgres-1 psql -U $DB_USER -d $SHADOW_DB_NAME"
+sshpass -p "$SSH_PASSWORD" ssh -o StrictHostKeyChecking=no root@$SERVER_IP "rm -f /tmp/add-sku-fields.sql"
+
+if [ $? -eq 0 ]; then
+    echo "✅ 字段检查/添加完成"
+else
+    echo "⚠️  字段添加可能有问题"
+fi
+
+echo ""
+echo "🧹 步骤 6: 清理临时文件..."
+sshpass -p "$SSH_PASSWORD" ssh -o StrictHostKeyChecking=no root@$SERVER_IP "rm -f /tmp/$EXPORT_FILE"
+
+echo ""
+echo "========================================"
+echo "✅ 同步完成！"
+echo "========================================"
+echo ""
+echo "影子系统已更新，可以访问："
+echo "  http://192.168.58.20:5320"
+echo ""
+echo "备份文件位置："
+echo "  /tmp/lobechat_stage_backup_${TIMESTAMP}.dump"
+echo ""
+
--- a/scripts/sync-prod-to-shadow-server.sh
+++ b/scripts/sync-prod-to-shadow-server.sh
@ -0,0 +1,117 @@
+#!/bin/bash
+
+# 在服务器上直接执行的同步脚本
+# 使用方法：先SSH到服务器，然后执行此脚本
+
+PROD_DB_NAME="lobechat"
+SHADOW_DB_NAME="lobechat_stage"
+DB_USER="gongxiangpan"
+TIMESTAMP=$(date +%Y%m%d_%H%M%S)
+
+echo "========================================"
+echo "同步正式环境数据库到影子系统"
+echo "========================================"
+echo ""
+echo "数据库信息："
+echo "  正式环境：$PROD_DB_NAME"
+echo "  影子系统：$SHADOW_DB_NAME"
+echo ""
+
+# 确认操作
+read -p "⚠️  此操作将覆盖影子系统的数据，是否继续？(y/N) " confirm
+if [ "$confirm" != "y" ] && [ "$confirm" != "Y" ]; then
+    echo "❌ 操作已取消"
+    exit 0
+fi
+
+echo ""
+echo "📦 步骤 1: 备份影子系统数据库..."
+docker exec gongxiangpan-postgres-1 pg_dump -U $DB_USER -d $SHADOW_DB_NAME -Fc -f /tmp/lobechat_stage_backup_${TIMESTAMP}.dump
+
+if [ $? -eq 0 ]; then
+    echo "✅ 备份成功：/tmp/lobechat_stage_backup_${TIMESTAMP}.dump"
+else
+    echo "⚠️  备份失败，但继续执行..."
+fi
+
+echo ""
+echo "📥 步骤 2: 从正式环境导出数据..."
+EXPORT_FILE="lobechat_export_${TIMESTAMP}.dump"
+docker exec gongxiangpan-postgres-1 pg_dump -U $DB_USER -d $PROD_DB_NAME -Fc -f /tmp/$EXPORT_FILE
+
+if [ $? -eq 0 ]; then
+    echo "✅ 导出成功：/tmp/$EXPORT_FILE"
+else
+    echo "❌ 导出失败！"
+    exit 1
+fi
+
+echo ""
+echo "📤 步骤 3: 导入数据到影子系统（会清空现有数据）..."
+docker exec gongxiangpan-postgres-1 pg_restore -U $DB_USER -d $SHADOW_DB_NAME --clean --if-exists /tmp/$EXPORT_FILE
+
+if [ $? -eq 0 ]; then
+    echo "✅ 导入成功！"
+else
+    echo "⚠️  导入可能有问题，请检查输出..."
+fi
+
+echo ""
+echo "🔍 步骤 4: 验证同步结果..."
+docker exec gongxiangpan-postgres-1 psql -U $DB_USER -d $SHADOW_DB_NAME -c "SELECT (SELECT COUNT(*) FROM users) as users_count, (SELECT COUNT(*) FROM materials) as materials_count, (SELECT COUNT(*) FROM material_skus) as skus_count;"
+
+echo ""
+echo "🔧 步骤 5: 确保影子系统有最新字段..."
+cat > /tmp/add-sku-fields.sql << 'EOF'
+-- 添加 preview_url 字段
+DO $$
+BEGIN
+    IF NOT EXISTS (
+        SELECT 1 
+        FROM information_schema.columns 
+        WHERE table_name = 'material_skus' 
+        AND column_name = 'preview_url'
+    ) THEN
+        ALTER TABLE material_skus ADD COLUMN preview_url TEXT;
+    END IF;
+END $$;
+
+-- 添加 file_name 字段
+DO $$
+BEGIN
+    IF NOT EXISTS (
+        SELECT 1 
+        FROM information_schema.columns 
+        WHERE table_name = 'material_skus' 
+        AND column_name = 'file_name'
+    ) THEN
+        ALTER TABLE material_skus ADD COLUMN file_name TEXT;
+    END IF;
+END $$;
+EOF
+
+cat /tmp/add-sku-fields.sql | docker exec -i gongxiangpan-postgres-1 psql -U $DB_USER -d $SHADOW_DB_NAME
+rm -f /tmp/add-sku-fields.sql
+
+if [ $? -eq 0 ]; then
+    echo "✅ 字段检查/添加完成"
+else
+    echo "⚠️  字段添加可能有问题"
+fi
+
+echo ""
+echo "🧹 步骤 6: 清理临时文件..."
+rm -f /tmp/$EXPORT_FILE
+
+echo ""
+echo "========================================"
+echo "✅ 同步完成！"
+echo "========================================"
+echo ""
+echo "影子系统已更新，可以访问："
+echo "  http://192.168.58.20:5320"
+echo ""
+echo "备份文件位置："
+echo "  /tmp/lobechat_stage_backup_${TIMESTAMP}.dump"
+echo ""
+
--- a/scripts/sync-prod-to-shadow.sh
+++ b/scripts/sync-prod-to-shadow.sh
@ -0,0 +1,95 @@
+#!/bin/bash
+
+# 同步正式环境数据库到影子系统
+# 用于将正式环境（lobechat）的数据同步到影子系统（lobechat_stage）
+
+SERVER_IP="192.168.58.20"
+PROD_DB_NAME="lobechat"
+SHADOW_DB_NAME="lobechat_stage"
+DB_USER="gongxiangpan"
+DB_PASSWORD="gongxiangpan123"
+TIMESTAMP=$(date +%Y%m%d_%H%M%S)
+
+echo "========================================"
+echo "同步正式环境数据库到影子系统"
+echo "========================================"
+echo ""
+echo "数据库信息："
+echo "  服务器：$SERVER_IP"
+echo "  正式环境：$PROD_DB_NAME"
+echo "  影子系统：$SHADOW_DB_NAME"
+echo ""
+
+# 确认操作
+read -p "⚠️  此操作将覆盖影子系统的数据，是否继续？(y/N) " confirm
+if [ "$confirm" != "y" ] && [ "$confirm" != "Y" ]; then
+    echo "❌ 操作已取消"
+    exit 0
+fi
+
+echo ""
+echo "📦 步骤 1: 备份影子系统数据库..."
+BACKUP_FILE="lobechat_stage_backup_${TIMESTAMP}.dump"
+ssh root@$SERVER_IP "docker exec gongxiangpan-postgres-1 pg_dump -U $DB_USER -d $SHADOW_DB_NAME -Fc -f /tmp/$BACKUP_FILE"
+
+if [ $? -eq 0 ]; then
+    echo "✅ 备份成功：/tmp/$BACKUP_FILE"
+else
+    echo "⚠️  备份失败，但继续执行..."
+fi
+
+echo ""
+echo "📥 步骤 2: 从正式环境导出数据..."
+EXPORT_FILE="lobechat_export_${TIMESTAMP}.dump"
+ssh root@$SERVER_IP "docker exec gongxiangpan-postgres-1 pg_dump -U $DB_USER -d $PROD_DB_NAME -Fc -f /tmp/$EXPORT_FILE"
+
+if [ $? -eq 0 ]; then
+    echo "✅ 导出成功：/tmp/$EXPORT_FILE"
+else
+    echo "❌ 导出失败！"
+    exit 1
+fi
+
+echo ""
+echo "📤 步骤 3: 导入数据到影子系统（会清空现有数据）..."
+ssh root@$SERVER_IP "docker exec gongxiangpan-postgres-1 pg_restore -U $DB_USER -d $SHADOW_DB_NAME --clean --if-exists /tmp/$EXPORT_FILE"
+
+if [ $? -eq 0 ]; then
+    echo "✅ 导入成功！"
+else
+    echo "⚠️  导入可能有问题，请检查输出..."
+fi
+
+echo ""
+echo "🔍 步骤 4: 验证同步结果..."
+ssh root@$SERVER_IP "docker exec gongxiangpan-postgres-1 psql -U $DB_USER -d $SHADOW_DB_NAME -c 'SELECT (SELECT COUNT(*) FROM users) as users_count, (SELECT COUNT(*) FROM materials) as materials_count, (SELECT COUNT(*) FROM material_skus) as skus_count;'"
+
+echo ""
+echo "🔧 步骤 5: 确保影子系统有最新字段..."
+# 上传并执行添加字段的SQL脚本
+scp scripts/add-sku-fields.sql root@$SERVER_IP:/tmp/add-sku-fields.sql
+ssh root@$SERVER_IP "cat /tmp/add-sku-fields.sql | docker exec -i gongxiangpan-postgres-1 psql -U $DB_USER -d $SHADOW_DB_NAME"
+ssh root@$SERVER_IP "rm -f /tmp/add-sku-fields.sql"
+
+if [ $? -eq 0 ]; then
+    echo "✅ 字段检查/添加完成"
+else
+    echo "⚠️  字段添加可能有问题"
+fi
+
+echo ""
+echo "🧹 步骤 6: 清理临时文件..."
+ssh root@$SERVER_IP "rm -f /tmp/$EXPORT_FILE"
+
+echo ""
+echo "========================================"
+echo "✅ 同步完成！"
+echo "========================================"
+echo ""
+echo "影子系统已更新，可以访问："
+echo "  http://192.168.58.20:5320"
+echo ""
+echo "备份文件位置："
+echo "  /tmp/$BACKUP_FILE"
+echo ""
+
--- a/批量上传流程完整检查报告.md
+++ b/批量上传流程完整检查报告.md
@ -0,0 +1,491 @@
+# 批量上传流程完整检查报告
+
+**检查时间**: 2025-12-29  
+**检查范围**: 批量上传功能的完整流程链路
+
+---
+
+## 📋 检查清单
+
+- [x] 批量上传功能触发
+- [x] 批量上传的追加/减少素材数量逻辑
+- [x] 源文件存放
+- [x] 预览图压缩处理
+- [x] 预览图存放
+- [x] 素材卡片的正确展示
+- [x] 预览图展示
+- [x] 源文件下载
+
+---
+
+## 1. 批量上传功能触发 ✅
+
+### 1.1 触发方式
+
+**位置**: `components/UploadModal.tsx`
+
+**触发条件**:
+1. **通用批量上传**: 选择多个文件（>1个）时自动进入批量模式
+   - 文件选择处理: `handleFileSelection` (`components/upload/file-input-handlers.ts`)
+   - 自动创建批量项: `createBatchFileItems` (`components/upload/file-handlers.ts`)
+   - 设置批量模式: `setIsBatchMode(true)`
+
+2. **特殊类型批量上传**: 特定素材类型有专门的批量上传入口
+   - 音乐: `batchMusicFiles` (最多100个)
+   - 种草视频: `batchVideoFiles` (最多8个)
+   - 3D场景: `batch3DFiles` (最多5个，每个需要预览图)
+   - 品牌VI: `batchBrandVIFiles` (最多50个PDF)
+   - 买家秀: `batchBuyerShowFiles` (每批至少8张图)
+   - 小红书: `batchXiaohongshuFiles` (支持批量)
+
+### 1.2 文件验证
+
+**位置**: `components/upload/file-handlers.ts` → `validateAndFilterFiles`
+
+**验证逻辑**:
+- ✅ 使用 `isValidMainFileType` 验证文件类型
+- ✅ 过滤无效文件，只保留有效文件
+- ✅ 返回 `{ valid, invalid }` 结果
+
+### 1.3 状态管理
+
+**位置**: `components/UploadModal.tsx`
+
+**状态变量**:
+```typescript
+const [batchFiles, setBatchFiles] = useState<BatchFileItem[]>([])
+const [isBatchMode, setIsBatchMode] = useState(false)
+```
+
+**结论**: ✅ **触发逻辑正常**
+
+---
+
+## 2. 批量上传的追加/减少素材数量逻辑 ✅
+
+### 2.1 追加文件
+
+**位置**: `components/upload/file-input-handlers.ts` → `handleFileSelection`
+
+**追加逻辑**:
+```typescript
+// 通用批量上传
+const newItems = createBatchFileItems(files, ...)
+setBatchFiles(prev => [...prev, ...newItems])
+
+// 特殊类型批量上传
+setBatchMusicFiles(prev => [...prev, ...newFiles])
+setBatchVideoFiles(prev => [...prev, ...newFiles])
+// ... 其他类型类似
+```
+
+**限制检查**:
+- ✅ 检查批量限制 (`BATCH_LIMITS`)
+- ✅ 音乐: 最多100个
+- ✅ 种草视频: 最多8个
+- ✅ 3D场景: 最多5个
+- ✅ 品牌VI: 最多50个
+
+### 2.2 删除文件
+
+**位置**: `components/upload/BatchFileList.tsx` → `onDelete`
+
+**删除逻辑**:
+```typescript
+onDelete={(index) => {
+  setBatchFiles(batchFiles.filter((_, i) => i !== index))
+  if (batchFiles.length === 1) {
+    setIsBatchMode(false) // 只剩一个时退出批量模式
+  }
+}}
+```
+
+**特殊处理**:
+- ✅ 删除时自动释放预览图URL (`URL.revokeObjectURL`)
+- ✅ 删除最后一个文件时自动退出批量模式
+
+### 2.3 更新文件信息
+
+**位置**: `components/upload/BatchFileList.tsx`
+
+**支持的操作**:
+- ✅ 更新SPU型号: `onUpdateProductModel`
+- ✅ 更新预览图: `onUpdatePreviewImage` / `onRemovePreviewImage`
+- ✅ 更新分类信息: `onUpdateCategory`, `onUpdateScene`, `onUpdatePlatform`, `onUpdateProductCategory`
+- ✅ 更新渲染器: `onUpdateRenderer` (3D场景)
+
+**结论**: ✅ **追加/减少逻辑正常**
+
+---
+
+## 3. 源文件存放 ✅
+
+### 3.1 上传路径
+
+**位置**: `app/api/materials/upload/route.ts`
+
+**存放逻辑**:
+```typescript
+// 主文件一律本地化存储到 uploads 目录
+const uploadDir = process.env.UPLOAD_DIR || './uploads'
+await fs.mkdir(uploadDir, { recursive: true })
+
+// 根据类型决定文件名前缀
+const basePrefix = isVideoOrAudio
+  ? materialType === '音乐'
+    ? 'audio-source'  // 音频: audio-source-*.mp3
+    : 'video'         // 视频: video-*.mp4
+  : 'material'       // 其他: material-*.zip
+
+zipFileName = generateUniqueFilename(basePrefix, ext)
+zipFilePath = path.join(uploadDir, zipFileName)
+```
+
+### 3.2 分片上传处理
+
+**位置**: `app/api/materials/upload/complete/route.ts`
+
+**处理流程**:
+1. ✅ 接收分片并合并
+2. ✅ 合并后文件移动到最终位置: `fs.rename(sourcePath, zipFilePath)`
+3. ✅ 避免重复读写大文件
+
+### 3.3 文件命名规则
+
+**位置**: `app/api/materials/upload/route.ts` → `generateUniqueFilename`
+
+**命名格式**:
+- 视频: `video-{timestamp}-{hash}.mp4`
+- 音频: `audio-source-{materialId}-{timestamp}.mp3`
+- 其他: `material-{timestamp}-{hash}.zip`
+
+**结论**: ✅ **源文件存放逻辑正常**
+
+---
+
+## 4. 预览图压缩处理 ✅
+
+### 4.1 压缩函数
+
+**位置**: `components/upload/image-processor.ts` → `compressPreviewImage`
+
+**压缩逻辑**:
+```typescript
+export async function compressPreviewImage(file: File): Promise<File> {
+  const img = await loadImage(file)
+  const maxWidth = 800
+  const maxHeight = 2000
+  const ratio = Math.min(maxWidth / width, maxHeight / height, 1)
+  // 使用 Canvas 压缩，质量 0.85
+  return await canvasToFile(canvas, file, 0.85)
+}
+```
+
+**压缩参数**:
+- ✅ 最大宽度: 800px
+- ✅ 最大高度: 2000px
+- ✅ 质量: 0.85
+- ✅ 格式: JPEG
+
+### 4.2 批量上传中的压缩
+
+**位置**: `components/upload/batch-upload-handlers.ts` → `uploadBatchFile`
+
+**处理流程**:
+```typescript
+// 处理预览图（如果需要）- 先压缩再转换为base64
+const needsPreview = !PREVIEW_OPTIONAL_TYPES.includes(materialType) && materialType !== '详情页'
+if (needsPreview && item.previewImage) {
+  compressedPreview = await compressPreviewImage(item.previewImage)
+  metadata.previewImage = await fileToBase64String(compressedPreview)
+}
+```
+
+**处理时机**:
+- ✅ 大文件（分片上传）: 压缩后转为base64，在 `completeBatchUpload` 时使用
+- ✅ 小文件（直接上传）: 压缩后直接添加到 FormData
+
+### 4.3 展示图切片
+
+**位置**: `components/upload/image-processor.ts` → `compressAndSliceDisplayImage`
+
+**切片逻辑**:
+- ✅ 高度 > 1500px 时自动切片
+- ✅ 每片高度: 1500px
+- ✅ 用于详情页展示（长图自动切片）
+
+**结论**: ✅ **预览图压缩处理逻辑正常**
+
+---
+
+## 5. 预览图存放 ✅
+
+### 5.1 上传到S3
+
+**位置**: `app/api/materials/upload/route.ts`
+
+**上传逻辑**:
+```typescript
+// 处理预览图（第一张作为主预览图）
+if (previewImage && !['详情页', '模特'].includes(materialType)) {
+  const buffer = Buffer.from(await previewImage.arrayBuffer())
+  const filename = generateUniqueFilename('preview', path.extname(previewImage.name))
+  previewUrl = await uploadToS3(buffer, filename, previewImage.type)
+}
+
+// 处理其他预览图（作为展示图）- 并行处理
+if (previewImages.length > 0) {
+  const uploadPromises = previewImages.map(async (image, index) => {
+    const buffer = Buffer.from(await image.arrayBuffer())
+    const filename = generateUniqueFilename(`preview-${index + 2}`, path.extname(image.name))
+    const url = await uploadToS3(buffer, filename, image.type)
+    return url
+  })
+  const urls = await Promise.all(uploadPromises)
+  displayImages.push(...urls)
+}
+```
+
+### 5.2 S3配置
+
+**位置**: `lib/s3.ts`
+
+**配置信息**:
+- ✅ Endpoint: `s3.yydd.ai` (新素材)
+- ✅ Bucket: `gongxiangpan`
+- ✅ 路径前缀: `由壹点AI/`
+- ✅ URL格式: `https://s3.yydd.ai/gongxiangpan/由壹点AI/preview-{timestamp}-{hash}.jpg`
+
+### 5.3 数据库存储
+
+**位置**: `app/api/materials/upload/route.ts`
+
+**存储字段**:
+- ✅ `previewUrl`: 主预览图URL（第一张）
+- ✅ `displayImages`: 展示图URLs数组（其他预览图）
+
+**结论**: ✅ **预览图存放逻辑正常**
+
+---
+
+## 6. 素材卡片的正确展示 ✅
+
+### 6.1 素材列表API
+
+**位置**: `app/api/materials/route.ts`
+
+**返回数据**:
+- ✅ 包含 `previewUrl` (主预览图)
+- ✅ 包含 `displayImages` (展示图数组)
+- ✅ 包含所有素材信息（SPU、分类、类型等）
+- ✅ URL重写: `rewriteMaterialStorageUrlsForClient` (`lib/url-rewrite.ts`)
+
+### 6.2 素材卡片组件
+
+**位置**: `components/home/MaterialCard.tsx`
+
+**展示逻辑**:
+```typescript
+// 视频类型
+{isVideoType && videoPreviewUrl ? (
+  <video src={videoPreviewUrl} poster={posterUrl} ... />
+) : material.previewUrl ? (
+  <Image src={material.previewUrl} ... />
+) : (
+  <div>暂无预览图</div>
+)}
+```
+
+**展示内容**:
+- ✅ SPU标签（左上角）
+- ✅ 素材类型角标（右上角）
+- ✅ 视频时长角标（视频类型）
+- ✅ 转码进度显示（转码中）
+
+### 6.3 素材网格布局
+
+**位置**: `components/home/MaterialGrid.tsx`
+
+**布局逻辑**:
+- ✅ 响应式网格布局
+- ✅ 支持无限滚动加载
+- ✅ 卡片悬停效果
+
+**结论**: ✅ **素材卡片展示逻辑正常**
+
+---
+
+## 7. 预览图展示 ✅
+
+### 7.1 列表页预览
+
+**位置**: `components/home/MaterialCard.tsx`
+
+**预览逻辑**:
+- ✅ 视频类型: 显示视频预览（`videoPreviewClipUrl` 或 `videoPreview540Url`）
+- ✅ 图片类型: 显示 `previewUrl`
+- ✅ 音频类型: 显示占位符或音频封面
+- ✅ 无预览图: 显示"暂无预览图"占位符
+
+### 7.2 详情页预览
+
+**位置**: `app/share/[id]/page.tsx`
+
+**预览逻辑**:
+- ✅ 主预览图: `material.previewUrl`
+- ✅ 展示图: `material.displayImages` 数组
+- ✅ 支持图片放大查看
+- ✅ 长图自动切片展示
+
+### 7.3 URL重写
+
+**位置**: `lib/url-rewrite.ts`
+
+**重写逻辑**:
+- ✅ 将内网URL (`http://localhost:9000/...`) 替换为公网地址
+- ✅ 优先使用 `S3_PUBLIC_DOMAIN`
+- ✅ 相对路径保持不变
+
+**结论**: ✅ **预览图展示逻辑正常**
+
+---
+
+## 8. 源文件下载 ✅
+
+### 8.1 下载API
+
+**位置**: `app/api/materials/download/route.ts`
+
+**下载逻辑**:
+```typescript
+// 1. 权限检查
+- 登录检查
+- 用户下载权限检查
+- 部门权限检查
+
+// 2. 文件路径处理
+const isOldMaterial = material.zipFilePath.includes('103.118.245.6') || material.zipFilePath.startsWith('http')
+if (!isOldMaterial) {
+  // 新素材: 相对路径转绝对路径
+  filePath = path.join(process.cwd(), filePath)
+}
+
+// 3. 文件读取和流式返回
+const fileStream = createReadStream(filePath)
+// 支持 Range 请求（断点续传）
+```
+
+### 8.2 下载路径兼容
+
+**兼容逻辑**:
+- ✅ 新素材: `uploads/video-*.mp4` 或 `uploads/material-*.zip`
+- ✅ 老素材: HTTP URL 或外网服务器路径
+- ✅ 动态打包: 无源文件时，从 `displayImages` 动态打包ZIP
+
+### 8.3 下载文件名
+
+**位置**: `app/api/materials/download/route.ts`
+
+**命名格式**:
+```typescript
+const filenameParts = [
+  material.productModel || 'unknown',
+  material.categoryName || '',
+  material.sceneName || '',
+  material.productCategoryName || '',
+  '源文件',
+].filter(Boolean)
+const filename = `${filenameParts.join('_')}${finalExt}`
+```
+
+### 8.4 断点续传支持
+
+**位置**: `app/api/materials/download/route.ts`
+
+**支持功能**:
+- ✅ Range 请求处理
+- ✅ 206 Partial Content 响应
+- ✅ Content-Range 头部
+
+**结论**: ✅ **源文件下载逻辑正常**
+
+---
+
+## 🔍 流程链路验证
+
+### 完整流程
+
+```
+1. 用户选择多个文件
+   ↓
+2. 自动进入批量模式 (isBatchMode = true)
+   ↓
+3. 创建批量文件项 (createBatchFileItems)
+   ↓
+4. 用户配置每个文件的SPU、预览图等
+   ↓
+5. 点击上传按钮
+   ↓
+6. 逐个上传文件 (handleBatchFilesUpload)
+   ├─ 预览图压缩 (compressPreviewImage)
+   ├─ 分片上传 (chunkUpload) 或 直接上传
+   └─ 后台处理 (completeBatchUpload)
+   ↓
+7. 服务器处理
+   ├─ 预览图上传到S3 (uploadToS3)
+   ├─ 源文件保存到本地 (uploads/)
+   └─ 创建数据库记录
+   ↓
+8. 素材列表刷新
+   ↓
+9. 素材卡片展示 (MaterialCard)
+   ├─ 预览图显示 (previewUrl)
+   └─ 点击下载 (download API)
+```
+
+---
+
+## ✅ 检查结果总结
+
+| 检查项 | 状态 | 说明 |
+|--------|------|------|
+| 批量上传功能触发 | ✅ 正常 | 多文件选择自动进入批量模式 |
+| 追加/减少素材数量 | ✅ 正常 | 支持添加、删除、更新文件信息 |
+| 源文件存放 | ✅ 正常 | 本地存储，路径正确 |
+| 预览图压缩处理 | ✅ 正常 | 压缩参数正确，处理时机正确 |
+| 预览图存放 | ✅ 正常 | S3存储，URL格式正确 |
+| 素材卡片展示 | ✅ 正常 | 卡片组件展示完整 |
+| 预览图展示 | ✅ 正常 | 列表页和详情页展示正常 |
+| 源文件下载 | ✅ 正常 | 下载API支持新老路径，支持断点续传 |
+
+---
+
+## 🎯 结论
+
+**批量上传功能的完整流程链路是通畅的！**
+
+所有环节的逻辑都正确实现：
+1. ✅ 触发机制正常
+2. ✅ 文件管理正常（追加/删除/更新）
+3. ✅ 文件处理正常（压缩/上传/存储）
+4. ✅ 数据展示正常（列表/卡片/预览）
+5. ✅ 文件下载正常（路径兼容/断点续传）
+
+**未发现阻塞性问题。**
+
+---
+
+## 📝 建议
+
+虽然流程通畅，但可以考虑以下优化：
+
+1. **错误处理增强**: 批量上传中单个文件失败时的重试机制
+2. **进度显示优化**: 更详细的批量上传进度展示
+3. **预览图缓存**: 前端预览图URL的缓存管理
+4. **下载限流**: 大文件下载的限流保护
+
+---
+
+**报告生成时间**: 2025-12-29  
+**检查人员**: AI Assistant
+
--- a/更新记录.md
+++ b/更新记录.md
@ -18,6 +18,37 @@
  - 标题：**个人中心卡片更清晰**
    - 描述：个人中心改为上下大卡片，分开展示"我的素材""我的收藏"，信息一目了然。

+## v2.2.4（2025.12.29）
+
+**新增功能：**
+
+- 标题：**性能监控面板**
+  - 描述：在"公网/内网"按钮上新增性能监控功能，鼠标悬停即可查看系统实时性能。显示CPU使用率、内存使用情况、上传队列和转码队列状态，转码队列还会显示任务详情（文件名、类型、上传人、进度等），方便了解系统运行状态。
+
+- 标题：**标准模型素材类型**
+  - 描述：新增"标准模型"素材类型，支持上传标准模型素材。标准模型素材文件可选，但必须上传预览图，支持后续添加SKU进行扩展。
+
+- 标题：**统一批量上传功能**
+  - 描述：统一了所有素材类型的批量上传逻辑，无论是通过"选择文件"按钮还是拖拽文件，都使用相同的批量上传流程。支持音乐、视频、3D场景、品牌VI等多种素材类型的批量上传，每个文件可独立设置SPU型号，上传进度清晰可见。
+
+**优化功能：**
+
+- 标题：**上传体验大幅提升**
+  - 描述：所有素材类型的上传流程优化，上传完成后立即关闭上传弹窗，不再等待后台处理（如视频转码）。转码等后台任务在后台异步进行，首页素材卡片会显示转码状态和进度，上传和转码完全分离，体验更流畅。
+
+- 标题：**上传进度显示优化**
+  - 描述：修复了上传弹窗中进度条重复显示的问题，现在单文件上传只显示一个进度条，批量上传显示总进度和当前文件进度，界面更清晰。
+
+- 标题：**转码任务自动清理**
+  - 描述：视频转码任务入队失败时，系统会自动清理源视频文件，避免产生大体积垃圾文件占用存储空间。
+
+**Bug修复：**
+
+- 标题：**性能监控数据更准确**
+  - 描述：修复了性能监控中CPU使用率和内存统计不准确的问题，现在使用更精确的计算方法，数据与系统实际状态一致。修复了上传队列显示已完成任务的问题，现在只显示真正进行中的上传任务。
+
+---
+
 ## v2.2.32（2025.12.19）

 **新增功能：**
--- a/UI方案.md
+++ b/UI方案.md
@ -0,0 +1,330 @@
+# 标准模型SKU UI方案
+
+## 📋 需求概述
+
+1. **SKU列表位置**：移到右侧卡片内（标准模型类型时）
+2. **右侧卡片简化**：标准模型类型时不显示作者/文件大小/下载次数/点赞数/文件名/上传时间等信息
+3. **SKU下载功能**：支持单SKU下载，移除"下载已选"按钮（避免与"立即下载"按钮重复）
+4. **SKU文件添加逻辑**：文件选择后立即显示在列表中，显示上传进度，参考批量上传的实现
+
+---
+
+## 🎨 UI布局方案
+
+### 标准模型详情页布局
+
+```
+┌─────────────────────────────────────────────────────────┐
+│                      Header                              │
+└─────────────────────────────────────────────────────────┘
+
+┌──────────────────────┬──────────────────────────────────┐
+│                      │                                  │
+│   左侧预览图区域      │    右侧信息卡片（固定宽度320px）  │
+│   (790px宽度)        │                                  │
+│                      │  ┌────────────────────────────┐  │
+│   [预览图/视频]      │  │  SPU型号                   │  │
+│                      │  │  [标签] [标签] [标签]      │  │
+│                      │  └────────────────────────────┘  │
+│                      │                                  │
+│                      │  ┌────────────────────────────┐  │
+│                      │  │  SKU列表      [编辑] 按钮   │  │
+│                      │  │  ┌──────────────────────┐ │  │
+│                      │  │  │ [✓] 全选             │ │  │
+│                      │  │  └──────────────────────┘ │  │
+│                      │  │  ┌──────────────────────┐ │  │
+│                      │  │  │ [✓] [图] SKU名称     │ │  │
+│                      │  │  │     文件大小 [下载]   │ │  │
+│                      │  │  └──────────────────────┘ │  │
+│                      │  │  ┌──────────────────────┐ │  │
+│                      │  │  │ [✓] [图] SKU名称     │ │  │
+│                      │  │  │     文件大小 [下载]   │ │  │
+│                      │  │  └──────────────────────┘ │  │
+│                      │  │  ...                      │  │
+│                      │  └────────────────────────────┘  │
+│                      │                                  │
+│                      │  ┌────────────────────────────┐  │
+│                      │  │  [立即下载] 按钮           │  │
+│                      │  │  [返回上一页] 按钮         │  │
+│                      │  └────────────────────────────┘  │
+│                      │                                  │
+└──────────────────────┴──────────────────────────────────┘
+```
+
+### 其他素材类型详情页布局（保持不变）
+
+```
+┌──────────────────────┬──────────────────────────────────┐
+│                      │                                  │
+│   左侧预览图区域      │    右侧信息卡片                   │
+│   (790px宽度)        │                                  │
+│                      │  ┌────────────────────────────┐  │
+│   [预览图/视频]      │  │  SPU型号                   │  │
+│                      │  │  [标签] [标签] [标签]      │  │
+│                      │  └────────────────────────────┘  │
+│                      │                                  │
+│                      │  ┌────────────────────────────┐  │
+│                      │  │  作者: xxx                 │  │
+│                      │  │  文件大小: xxx             │  │
+│                      │  │  下载次数: xxx             │  │
+│                      │  │  点赞数: xxx               │  │
+│                      │  │  文件名: xxx               │  │
+│                      │  │  上传时间: xxx             │  │
+│                      │  └────────────────────────────┘  │
+│                      │                                  │
+│                      │  ┌────────────────────────────┐  │
+│                      │  │  [立即下载] 按钮           │  │
+│                      │  │  [返回上一页] 按钮         │  │
+│                      │  └────────────────────────────┘  │
+│                      │                                  │
+└──────────────────────┴──────────────────────────────────┘
+```
+
+---
+
+## 🔧 实现方案
+
+### 1. 修改详情页布局 (`app/share/[id]/page.tsx`)
+
+**变更点：**
+- 移除左侧下方的SKU列表（line 519-528）
+- 在右侧卡片内添加SKU列表（标准模型类型时）
+- 条件渲染右侧卡片内容：标准模型类型时只显示标题、标签、SKU列表和操作按钮
+
+**代码结构：**
+```tsx
+{/* 右侧：素材信息（固定） */}
+<div className="w-80 flex-shrink-0">
+  <div className="sticky top-24 bg-white dark:bg-gray-800 rounded-2xl shadow-lg p-8 space-y-6">
+    {/* 标题和标签 */}
+    <div>
+      <h1>{material.productModel}</h1>
+      <div className="flex flex-wrap gap-2">
+        {/* 标签 */}
+      </div>
+    </div>
+
+    {/* 标准模型：显示SKU列表 */}
+    {material.materialType === '标准模型' ? (
+      <SkuList
+        materialId={materialId}
+        canEdit={canEdit}
+        onEditClick={() => setShowSkuEditModal(true)}
+      />
+    ) : (
+      /* 其他类型：显示素材信息 */
+      <div className="space-y-4">
+        {/* 作者、文件大小、下载次数等 */}
+      </div>
+    )}
+
+    {/* 操作按钮 */}
+    <div className="space-y-3 pt-2">
+      {/* 下载按钮、返回按钮 */}
+    </div>
+  </div>
+</div>
+```
+
+### 2. 优化SkuList组件 (`components/SkuList.tsx`)
+
+**变更点：**
+- 调整样式以适应右侧卡片布局
+- 优化列表项显示（更紧凑）
+- 保持全选/多选/单选的下载功能
+
+**样式调整：**
+- 移除固定高度限制，使用flex布局自适应
+- 优化间距和字体大小
+- 确保在320px宽度内正常显示
+
+### 3. 改进SkuEditModal组件 (`components/SkuEditModal.tsx`)
+
+**核心改进：文件选择后立即显示，显示上传进度**
+
+**实现思路：**
+1. 添加"待上传SKU"状态管理
+2. 文件选择后立即添加到待上传列表
+3. 显示上传进度（类似BatchFileList）
+4. 上传完成后从待上传列表移除，添加到正式列表
+
+**状态结构：**
+```typescript
+interface PendingSku {
+  id: string // 临时ID
+  skuName: string
+  previewFile: File | null
+  previewUrl: string | null // 上传后的URL
+  zipFile: File | null
+  zipFileInfo: { fileName: string; filePath: string; fileSize: number } | null
+  previewUploadProgress: number // 0-100
+  zipUploadProgress: number // 0-100
+  status: 'pending' | 'uploading-preview' | 'uploading-zip' | 'saving' | 'done' | 'error'
+  error?: string
+}
+```
+
+**UI流程：**
+```
+用户点击"添加SKU"
+    ↓
+显示添加表单
+    ↓
+用户填写SKU名称
+    ↓
+用户选择预览图 → 立即显示在列表中，状态：上传中预览图
+    ↓
+预览图上传完成 → 更新状态：预览图完成
+    ↓
+用户选择压缩包 → 立即显示在列表中，状态：上传中压缩包
+    ↓
+压缩包上传完成 → 更新状态：压缩包完成
+    ↓
+用户点击"添加"按钮 → 状态：保存中
+    ↓
+保存完成 → 从待上传列表移除，添加到正式列表
+```
+
+**参考实现：**
+- 参考 `components/upload/BatchFileList.tsx` 的文件列表展示
+- 参考 `components/upload/UploadProgress.tsx` 的进度显示
+- 参考 `hooks/useBatchFilesUpload.ts` 的上传状态管理
+
+---
+
+## 📝 详细实现步骤
+
+### Step 1: 修改详情页布局
+
+**文件：** `app/share/[id]/page.tsx`
+
+1. 移除左侧SKU列表（line 519-528）
+2. 在右侧卡片中添加条件渲染：
+   - 标准模型类型：显示SKU列表
+   - 其他类型：显示素材信息
+
+### Step 2: 优化SkuList组件
+
+**文件：** `components/SkuList.tsx`
+
+1. 调整容器样式（移除固定高度）
+2. 优化列表项布局（更紧凑）
+3. 确保在320px宽度内正常显示
+4. **将"SKU列表"标题和"编辑"按钮放在同一行**（节约空间）
+
+### Step 3: 改进SkuEditModal组件
+
+**文件：** `components/SkuEditModal.tsx`
+
+1. 添加待上传SKU状态管理
+2. 实现文件选择后立即显示
+3. 实现上传进度显示
+4. 实现状态流转（pending → uploading → saving → done）
+
+---
+
+## 🎯 关键功能点
+
+### 1. SKU列表在右侧卡片内
+
+- ✅ 标准模型类型时，SKU列表显示在右侧卡片
+- ✅ 其他类型时，显示原有的素材信息
+- ✅ 保持右侧卡片固定宽度（320px）
+
+### 2. 右侧卡片简化
+
+- ✅ 标准模型类型时不显示：
+  - 作者
+  - 文件大小
+  - 下载次数
+  - 点赞数
+  - 文件名
+  - 上传时间
+- ✅ 只显示：
+  - SPU型号（标题）
+  - 标签（店铺、场景、类型）
+  - SKU列表
+  - 操作按钮
+
+### 3. SKU下载功能
+
+- ✅ 单SKU下载（每个SKU旁边的下载按钮）
+- ✅ 全选功能保留（用于快速选择，但批量下载通过逐个点击实现）
+- ❌ 移除"下载已选"按钮（避免与"立即下载"按钮重复）
+
+### 4. 文件添加逻辑优化
+
+- ✅ 文件选择后立即显示在列表中
+- ✅ 显示上传进度（预览图、压缩包分别显示）
+- ✅ 支持取消上传
+- ✅ 上传完成后自动添加到正式列表
+
+---
+
+## 🔍 参考实现
+
+### 批量上传的文件列表展示
+
+**文件：** `components/upload/BatchFileList.tsx`
+
+- 文件选择后立即显示
+- 显示文件信息（名称、大小）
+- 支持展开/收起查看详细信息
+
+### 上传进度显示
+
+**文件：** `components/upload/UploadProgress.tsx`
+
+- 显示整体进度
+- 显示当前文件进度
+- 显示上传速度
+- 显示剩余时间
+
+### 上传状态管理
+
+**文件：** `hooks/useBatchFilesUpload.ts`
+
+- 管理多个文件的上传状态
+- 跟踪每个文件的上传进度
+- 处理上传完成/失败
+
+---
+
+## ✅ 验收标准
+
+1. **布局正确**
+   - ✅ 标准模型类型时，SKU列表在右侧卡片内
+   - ✅ 其他类型时，显示原有的素材信息
+   - ✅ 右侧卡片宽度固定为320px
+
+2. **功能完整**
+   - ✅ 单SKU下载正常（每个SKU旁边的下载按钮）
+   - ✅ 全选功能保留（用于快速选择）
+   - ❌ 移除"下载已选"按钮（避免与"立即下载"按钮重复）
+   - ✅ 文件选择后立即显示
+   - ✅ 上传进度正确显示
+
+3. **用户体验**
+   - ✅ 界面简洁清晰
+   - ✅ 操作流畅
+   - ✅ 反馈及时（进度、错误提示）
+
+---
+
+## 📌 注意事项
+
+1. **响应式设计**：确保在小屏幕设备上也能正常显示
+2. **性能优化**：大量SKU时使用虚拟滚动
+3. **错误处理**：上传失败时显示错误信息，允许重试
+4. **状态同步**：SKU添加/删除后及时更新列表
+
+---
+
+## 🚀 实施优先级
+
+1. **高优先级**：修改详情页布局，将SKU列表移到右侧
+2. **高优先级**：简化右侧卡片，标准模型类型不显示多余信息
+3. **中优先级**：改进SkuEditModal，实现文件选择后立即显示
+4. **中优先级**：实现上传进度显示
+5. **低优先级**：优化样式和交互细节
+
--- a/标准模型素材类型逻辑梳理报告.md
+++ b/标准模型素材类型逻辑梳理报告.md
@ -0,0 +1,545 @@
+# 标准模型素材类型逻辑梳理报告
+
+## 📋 概述
+
+标准模型是一种特殊的素材类型，用于以产品型号（SPU）为基准创建模型合集。上传时只需填写SPU和预览图，创建后可以在详情页添加各个SKU的模型文件。
+
+---
+
+## 🗂️ 数据库结构
+
+### Material 表（标准模型相关字段）
+
+```prisma
+model Material {
+  id                  String    @id @default(uuid())
+  previewUrl          String    // S3 URL（预览图）- 必填
+  productModel        String    // SPU型号 - 必填
+  categoryName        String    // 使用店铺 - 自动填充为"通用"
+  sceneName           String    // 场景类别 - 自动填充为"通用"
+  productCategoryName String    // 品类分类 - 必填
+  materialType        String    // 素材类型 = "标准模型"
+  zipFileName         String    @default("") // 可选，标准模型主文件可选
+  zipFilePath         String    @default("") // 可选
+  zipFileSize         BigInt    @default(0) // 可选
+  // ... 其他字段
+  skus                MaterialSku[] // 关联的SKU列表
+}
+```
+
+### MaterialSku 表
+
+```prisma
+model MaterialSku {
+  id         String   @id @default(uuid())
+  materialId String   @map("material_id")
+  skuName    String   @map("sku_name")      // SKU名称（如：白色款）
+  filePath   String   @map("file_path")      // 压缩包相对路径（如：skus/{materialId}/{fileName}）
+  fileSize   BigInt   @default(0) @map("file_size")
+  sortOrder  Int      @default(0) @map("sort_order") // 排序字段
+  createdAt  DateTime @default(now()) @map("created_at")
+  updatedAt  DateTime @updatedAt @map("updated_at")
+  
+  material Material @relation(fields: [materialId], references: [id], onDelete: Cascade)
+  
+  @@index([materialId])
+  @@index([sortOrder])
+  @@map("material_skus")
+}
+```
+
+**⚠️ 发现的问题：**
+- MaterialSku表**缺少`previewUrl`字段**，但前端组件（SkuList、SkuEditModal）都在使用该字段
+- 前端上传预览图到S3后，在创建SKU时传递了`previewUrl`，但后端API未接收和存储
+
+---
+
+## 📝 字段验证规则
+
+### 上传时必填字段
+
+| 字段 | 是否必填 | 说明 |
+|------|---------|------|
+| `productModel` | ✅ 必填 | SPU型号 |
+| `productCategoryName` | ✅ 必填 | 品类分类 |
+| `previewImages` | ✅ 必填 | 预览图（至少1张） |
+| `categoryName` | ❌ 自动填充 | 自动填充为"通用" |
+| `sceneName` | ❌ 自动填充 | 自动填充为"通用" |
+| `zipFile` | ❌ 可选 | 主文件可选（与模特类型相同） |
+
+### SKU添加时必填字段
+
+| 字段 | 是否必填 | 说明 |
+|------|---------|------|
+| `skuName` | ✅ 必填 | SKU名称 |
+| `previewUrl` | ✅ 必填 | 预览图URL（前端上传到S3） |
+| `zipFile` | ✅ 必填 | 压缩包文件 |
+
+---
+
+## 🔄 完整流程
+
+### 1. 标准模型上传流程
+
+```
+用户选择"标准模型"类型
+    ↓
+填写SPU型号（必填）
+    ↓
+选择品类（必填）
+    ↓
+上传预览图（必填，至少1张）
+    ↓
+上传主文件（可选）
+    ↓
+前端验证：
+  - requiresProductCategoryName() → 检查品类
+  - requiresCategoryAndScene() → 返回false（不需要店铺和场景）
+  - shouldAutoFillGeneral() → 返回true（自动填充"通用"）
+    ↓
+提交到 /api/materials/upload
+    ↓
+后端处理：
+  - 验证productModel、productCategoryName
+  - 验证previewImages（必填）
+  - zipFile可选（不验证）
+  - 自动填充categoryName="通用", sceneName="通用"
+  - 上传预览图到S3
+  - 如果上传了zipFile，保存到本地uploads/
+  - 创建Material记录
+    ↓
+返回成功，跳转到详情页
+```
+
+**关键代码位置：**
+- 前端验证：`components/UploadModal.tsx` (lines 1292-1329)
+- 后端验证：`app/api/materials/upload/route.ts` (lines 80-102)
+- 自动填充逻辑：`lib/material-validation.ts` (lines 18-34)
+
+### 2. SKU添加流程
+
+```
+用户在详情页点击"编辑SKU"
+    ↓
+打开SkuEditModal弹窗
+    ↓
+点击"添加SKU"
+    ↓
+填写SKU名称
+    ↓
+上传预览图 → /api/upload/preview → 返回S3 URL
+    ↓
+上传压缩包 → /api/materials/{id}/skus/upload → 保存到uploads/skus/{materialId}/
+    ↓
+点击"添加"按钮
+    ↓
+调用 POST /api/materials/{id}/skus
+  Body: {
+    skuName: string,
+    previewUrl: string,  // ⚠️ 前端传递了，但后端未接收
+    zipFileName: string,
+    zipFilePath: string,
+    zipFileSize: number
+  }
+    ↓
+后端创建SKU记录（⚠️ 缺少previewUrl字段）
+    ↓
+刷新SKU列表
+```
+
+**关键代码位置：**
+- SKU上传：`components/SkuEditModal.tsx` (lines 78-211)
+- 预览图上传：`components/SkuEditModal.tsx` (lines 108-131)
+- 后端API：`app/api/materials/[id]/skus/route.ts` (lines 48-110)
+- 文件上传API：`app/api/materials/[id]/skus/upload/route.ts`
+
+### 3. SKU列表展示流程
+
+```
+用户访问标准模型详情页
+    ↓
+检查materialType === '标准模型'
+    ↓
+渲染SkuList组件
+    ↓
+调用 GET /api/materials/{id}/skus
+    ↓
+后端返回SKU列表（按sortOrder排序）
+    ↓
+前端渲染SKU卡片：
+  - 显示预览图（⚠️ 使用sku.previewUrl，但数据库中没有该字段）
+  - 显示SKU名称
+  - 显示文件大小
+  - 显示下载按钮
+    ↓
+用户可以选择SKU并下载
+```
+
+**关键代码位置：**
+- 详情页：`app/share/[id]/page.tsx` (lines 519-528)
+- SKU列表组件：`components/SkuList.tsx`
+- SKU列表API：`app/api/materials/[id]/skus/route.ts` (lines 8-46)
+
+### 4. SKU下载流程
+
+```
+用户点击SKU的"下载"按钮
+    ↓
+调用 GET /api/materials/{id}/skus/{skuId}/download
+    ↓
+后端验证：
+  - 检查用户登录状态
+  - 检查用户下载权限（canDownload）
+  - 获取SKU信息
+  - 构建文件路径：uploads/{sku.filePath}
+  - 读取文件并返回
+    ↓
+前端接收文件流并触发下载
+```
+
+**关键代码位置：**
+- 下载API：`app/api/materials/[id]/skus/[skuId]/download/route.ts`
+- 前端下载：`components/SkuList.tsx` (lines 100-129)
+
+---
+
+## 🔧 API接口清单
+
+### 标准模型上传
+
+| 方法 | 路径 | 说明 |
+|------|------|------|
+| POST | `/api/materials/upload` | 上传标准模型素材 |
+
+**请求参数：**
+- `productModel`: string (必填)
+- `productCategoryName`: string (必填)
+- `previewImage`: File (必填，第一张预览图)
+- `previewImages`: File[] (可选，其他预览图)
+- `zipFile`: File (可选，主文件)
+- `materialType`: "标准模型"
+- `categoryName`: 自动填充为"通用"
+- `sceneName`: 自动填充为"通用"
+
+### SKU管理
+
+| 方法 | 路径 | 说明 |
+|------|------|------|
+| GET | `/api/materials/{id}/skus` | 获取SKU列表 |
+| POST | `/api/materials/{id}/skus` | 添加SKU |
+| GET | `/api/materials/{id}/skus/{skuId}` | 获取SKU详情 |
+| PUT | `/api/materials/{id}/skus/{skuId}` | 更新SKU |
+| DELETE | `/api/materials/{id}/skus/{skuId}` | 删除SKU |
+| PUT | `/api/materials/{id}/skus/reorder` | 批量更新SKU排序 |
+| POST | `/api/materials/{id}/skus/upload` | 上传SKU文件 |
+
+**权限控制：**
+- 只有素材上传者或管理员可以添加/编辑/删除SKU
+- 所有登录用户都可以查看和下载SKU
+
+---
+
+## 🎨 前端组件
+
+### 1. UploadModal（上传弹窗）
+
+**文件位置：** `components/UploadModal.tsx`
+
+**标准模型相关逻辑：**
+- 选择"标准模型"类型时，隐藏店铺和场景字段
+- 显示品类选择字段（必填）
+- 显示标准模型说明提示框
+- 验证：SPU、品类、预览图必填，主文件可选
+
+**关键代码：**
+```typescript
+// 验证品类（line 1292-1295）
+if (requiresProductCategoryName(materialType) && !productCategoryName) {
+  setError('标准模型类型必须选择品类')
+  return
+}
+
+// 验证主文件（line 1302-1306）
+if (materialType !== '模特' && materialType !== '标准模型' && !zipFile) {
+  setError('请上传素材文件')
+  return
+}
+
+// 验证预览图（line 1326-1329）
+if (materialType === '标准模型' && previewImages.length === 0) {
+  setError('标准模型必须上传预览图')
+  return
+}
+```
+
+### 2. UploadForm（上传表单字段）
+
+**文件位置：** `components/upload/UploadForm.tsx`
+
+**标准模型相关逻辑：**
+- 标准模型不显示店铺和场景字段（line 144-210, 212-278）
+- 标准模型显示品类字段（必填）（line 280-300）
+- 标准模型不显示平台字段（line 302-322）
+- 显示标准模型说明提示（line 343-356）
+
+### 3. SkuList（SKU列表组件）
+
+**文件位置：** `components/SkuList.tsx`
+
+**功能：**
+- 显示SKU列表（按sortOrder排序）
+- 支持全选/单选SKU
+- 支持单个/批量下载SKU
+- 支持预览图点击放大
+- 显示SKU名称、文件大小
+
+**⚠️ 问题：**
+- 使用`sku.previewUrl`字段（line 231），但数据库中没有该字段
+- API返回的SKU数据中没有`previewUrl`
+
+### 4. SkuEditModal（SKU编辑弹窗）
+
+**文件位置：** `components/SkuEditModal.tsx`
+
+**功能：**
+- 显示SKU列表
+- 添加新SKU（名称、预览图、压缩包）
+- 删除SKU
+- 调整SKU排序（上移/下移）
+- 支持拖拽上传预览图和压缩包
+
+**⚠️ 问题：**
+- 上传预览图到S3后，在创建SKU时传递了`previewUrl`（line 186）
+- 但后端API未接收和存储`previewUrl`字段
+
+---
+
+## ⚠️ 发现的问题
+
+### 1. MaterialSku表缺少previewUrl字段
+
+**问题描述：**
+- 前端组件（SkuList、SkuEditModal）都在使用`sku.previewUrl`字段
+- 但MaterialSku表结构中没有`previewUrl`字段
+- 前端上传预览图后，在创建SKU时传递了`previewUrl`，但后端未接收和存储
+
+**影响：**
+- SKU列表无法显示预览图
+- SKU编辑弹窗中无法显示已上传的预览图
+
+**解决方案：**
+1. 在MaterialSku表中添加`previewUrl`字段
+2. 修改后端API接收和存储`previewUrl`
+3. 更新Prisma schema并执行迁移
+
+### 2. SKU上传API的字段不一致
+
+**问题描述：**
+- `SkuEditModal`中上传压缩包后，调用`POST /api/materials/{id}/skus`时传递了：
+  - `skuName`
+  - `previewUrl`
+  - `zipFileName`
+  - `zipFilePath`
+  - `zipFileSize`
+- 但后端API只接收了：
+  - `skuName`
+  - `filePath`（对应前端的`zipFilePath`）
+  - `fileSize`（对应前端的`zipFileSize`）
+- 缺少`previewUrl`和`zipFileName`的接收
+
+**解决方案：**
+1. 修改后端API接收`previewUrl`和`zipFileName`
+2. 在MaterialSku表中添加`previewUrl`和`zipFileName`字段（如果需要）
+
+### 3. SKU文件路径存储方式不一致
+
+**问题描述：**
+- `POST /api/materials/{id}/skus/upload`保存文件到`uploads/skus/{materialId}/`，返回相对路径`skus/{materialId}/{fileName}`
+- `POST /api/materials/{id}/skus`接收`filePath`，直接存储到数据库
+- 但前端传递的是`zipFilePath`，需要确认字段名是否一致
+
+**解决方案：**
+- 统一字段命名：使用`filePath`存储相对路径，使用`zipFileName`存储文件名
+
+---
+
+## 📂 文件存储结构
+
+### 标准模型主文件（可选）
+```
+uploads/
+  {timestamp}-{random}.zip  # 如果上传了主文件
+```
+
+### SKU文件
+```
+uploads/
+  skus/
+    {materialId}/
+      {skuName}_{timestamp}.zip
+      {skuName}_{timestamp}.zip
+      ...
+```
+
+### 预览图（S3存储）
+- Material预览图：`s3://bucket/preview-{timestamp}-{random}.{ext}`
+- SKU预览图：`s3://bucket/preview-{timestamp}-{random}.{ext}`（如果添加了previewUrl字段）
+
+---
+
+## 🔍 验证逻辑代码位置
+
+### 前端验证
+
+**文件：** `lib/material-validation.ts`
+
+```typescript
+// 标准模型不需要店铺和场景
+export function requiresCategoryAndScene(materialType: string): boolean {
+  return !AUTO_GENERAL_TYPES.includes(materialType) && materialType !== '标准模型';
+}
+
+// 标准模型需要品类
+export function requiresProductCategoryName(materialType: string): boolean {
+  return materialType === '标准模型';
+}
+
+// 标准模型自动填充"通用"
+export function shouldAutoFillGeneral(materialType: string): boolean {
+  return AUTO_GENERAL_TYPES.includes(materialType) || materialType === '标准模型';
+}
+```
+
+### 后端验证
+
+**文件：** `app/api/materials/upload/route.ts`
+
+```typescript
+// 验证主文件（line 94-102）
+const requiresMainFile = !['模特', '标准模型', '买家秀图片', '小红书种草'].includes(materialType);
+const hasMainFile = !!zipFile || !!existingFilePath;
+if (requiresMainFile && !hasMainFile) {
+  return NextResponse.json({ error: '请上传素材文件' }, { status: 400 });
+}
+```
+
+---
+
+## 📊 数据流图
+
+```
+┌─────────────────┐
+│   用户上传       │
+│   标准模型       │
+└────────┬────────┘
+         │
+         ▼
+┌─────────────────┐
+│  UploadModal    │
+│  - 验证字段     │
+│  - 上传预览图   │
+│  - 上传主文件   │
+└────────┬────────┘
+         │
+         ▼
+┌─────────────────┐
+│  /api/materials │
+│  /upload        │
+│  - 创建Material │
+└────────┬────────┘
+         │
+         ▼
+┌─────────────────┐
+│  详情页展示     │
+│  - 显示预览图   │
+│  - 显示SKU列表  │
+└────────┬────────┘
+         │
+         ▼
+┌─────────────────┐
+│  用户添加SKU    │
+│  - 上传预览图   │
+│  - 上传压缩包   │
+└────────┬────────┘
+         │
+         ▼
+┌─────────────────┐
+│  /api/materials │
+│  /{id}/skus    │
+│  - 创建SKU     │
+└────────┬────────┘
+         │
+         ▼
+┌─────────────────┐
+│  SKU列表更新    │
+│  - 显示预览图   │
+│  - 支持下载     │
+└─────────────────┘
+```
+
+---
+
+## 🎯 待完成工作
+
+### 高优先级
+
+1. **修复MaterialSku表缺少previewUrl字段**
+   - 在Prisma schema中添加`previewUrl`字段
+   - 执行数据库迁移
+   - 修改后端API接收和存储`previewUrl`
+   - 更新前端组件使用新的字段
+
+2. **统一SKU字段命名**
+   - 确认`zipFileName`是否需要存储
+   - 统一使用`filePath`存储相对路径
+   - 更新前端传递的字段名
+
+3. **完善SKU上传流程**
+   - 确保预览图上传后URL正确传递
+   - 确保压缩包上传后路径正确传递
+   - 添加错误处理和用户提示
+
+### 中优先级
+
+4. **优化SKU列表展示**
+   - 添加加载状态
+   - 添加空状态提示
+   - 优化预览图显示（如果修复了previewUrl字段）
+
+5. **添加SKU编辑功能**
+   - 支持修改SKU名称
+   - 支持更换预览图
+   - 支持更换压缩包
+
+### 低优先级
+
+6. **批量操作优化**
+   - 支持批量删除SKU
+   - 支持批量下载SKU（已实现，但可以优化）
+   - 支持拖拽排序
+
+---
+
+## 📚 相关文档
+
+- `项目文档.md` - 项目整体架构和配置
+- `docs/upload-spec-from-decompiled.md` - 上传规范说明
+- `批量上传流程完整检查报告.md` - 批量上传逻辑检查
+
+---
+
+## ✅ 总结
+
+标准模型素材类型的基本逻辑已经实现，包括：
+- ✅ 上传时的字段验证和自动填充
+- ✅ SKU的添加、删除、排序功能
+- ✅ SKU的下载功能
+- ✅ 详情页SKU列表展示
+
+但存在以下问题需要修复：
+- ❌ MaterialSku表缺少`previewUrl`字段
+- ❌ 后端API未接收和存储`previewUrl`
+- ❌ 字段命名不一致（`zipFilePath` vs `filePath`）
+
+修复这些问题后，标准模型功能将完全可用。
+