feat: add TypeORM, logger, schemas, hooks and stores

- Add TypeORM integration with data-source, entities and repositories - Add logger service for structured logging - Add Zod validation schemas for auth, cleaner and extractor - Add custom React hooks (useAuth, useCleaner, useExtractor, useValidation) - Add Zustand stores (useAppStore, useUserStore) - Add UI components (Button, Modal, Toast) - Add error types and ErpBrowserManager - Refactor IPC handlers and services - Add unit tests for new modules Co-Authored-By: Claude (glm-5) <noreply@anthropic.com>
2026-03-02 23:10:15 +08:00
parent 982fb8fde6
commit a05c8a9037
57 changed files with 5150 additions and 974 deletions
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -5,6 +5,7 @@ This file provides guidance to Claude Code (claude.ai/code) when working with co
 ## Development Commands

 ### Running the Application
+
 ```bash
 npm run dev              # Start development server with hot reload
 npm run build            # Full build with type checking
@@ -14,6 +15,7 @@ npm run build:linux      # Build Linux AppImage
 ```

 ### Code Quality
+
 ```bash
 npm run lint             # ESLint check
 npm run format           # Prettier format
@@ -23,6 +25,7 @@ npm run typecheck:web    # TypeScript check for renderer only
 ```

 ### Testing
+
 ```bash
 npm run test             # Run unit tests (Vitest)
 npm run test:coverage    # Run tests with coverage report
@@ -80,6 +83,7 @@ The main process is organized around domain-specific services in `src/main/servi
 ### IPC Handler Pattern

 All IPC communication follows a consistent pattern:
+
 - Handlers are in `src/main/ipc/`, organized by domain (8 modules)
 - Each handler module exports a `register*Handlers()` function
 - All handlers are registered in `src/main/ipc/index.ts`
--- a/docs/cleaner-validation-flow.md
+++ b/docs/cleaner-validation-flow.md
@@ -108,19 +108,13 @@ const handleValidation = async () => {
      setValidationResults(response.results)
      // 自动勾选已标记物料
      const markedCodes = new Set(
-        response.results
-          .filter(r => r.isMarkedForDeletion)
-          .map(r => r.materialCode)
+        response.results.filter((r) => r.isMarkedForDeletion).map((r) => r.materialCode)
      )
      setSelectedItems(markedCodes)

      // 管理员更新负责人列表
      if (isAdmin) {
-        const uniqueManagers = new Set(
-          response.results
-            .map(r => r.managerName)
-            .filter(Boolean)
-        )
+        const uniqueManagers = new Set(response.results.map((r) => r.managerName).filter(Boolean))
        setManagers([...uniqueManagers])
        setSelectedManagers(uniqueManagers)
      }
@@ -350,10 +344,7 @@ for (const record of materialRecords) {
  // 优先级2: 匹配 MaterialsTypeToBeDeleted (MaterialName 包含匹配)
  if (!managerName) {
    for (const typeKeyword of typeKeywords) {
-      if (
-        typeKeyword.materialName &&
-        typeKeyword.materialName.includes(materialName)
-      ) {
+      if (typeKeyword.materialName && typeKeyword.materialName.includes(materialName)) {
        matchedTypeKeyword = typeKeyword.materialName
        managerName = typeKeyword.managerName
        break
@@ -419,7 +410,7 @@ graph TB
 interface ValidationRequest {
  mode: 'database_full' | 'database_filtered'
  useSharedProductionIds?: boolean
-  productionIdFile?: string  // 可选，文件路径
+  productionIdFile?: string // 可选，文件路径
 }
 ```

@@ -431,8 +422,8 @@ interface ValidationResponse {
  results?: ValidationResult[]
  stats?: {
    totalRecords: number
-    matchedCount: number    // 有负责人(包括类型匹配)
-    markedCount: number     // 已标记删除
+    matchedCount: number // 有负责人(包括类型匹配)
+    markedCount: number // 已标记删除
  }
  error?: string
 }
@@ -446,9 +437,9 @@ interface ValidationResult {
  materialCode: string
  specification: string
  model: string
-  managerName: string          // 负责人名称
+  managerName: string // 负责人名称
  isMarkedForDeletion: boolean // 是否精确匹配MaterialsToBeDeleted
-  matchedTypeKeyword?: string  // 如果匹配了类型关键词，记录匹配项
+  matchedTypeKeyword?: string // 如果匹配了类型关键词，记录匹配项
 }
 ```

@@ -644,7 +635,8 @@ const handleConfirmDeletion = async () => {

  // 5. 用户确认
  const confirmParts: string[] = []
-  if (materialsToUpsert.length > 0) confirmParts.push(`写入/更新 ${materialsToUpsert.length} 条记录`)
+  if (materialsToUpsert.length > 0)
+    confirmParts.push(`写入/更新 ${materialsToUpsert.length} 条记录`)
  if (materialsToDelete.length > 0) confirmParts.push(`删除 ${materialsToDelete.length} 条记录`)

  if (!window.confirm(`确认以下操作吗？\n\n${confirmParts.join('\n')}`)) return
@@ -686,14 +678,14 @@ const handleConfirmDeletion = async () => {

 **数据分类逻辑**:

-| 物料状态 | 勾选状态 | 负责人信息 | 处理方式 |
-|---------|---------|-----------|---------|
-| 已标记删除 | ✅ 勾选 | ✅ 有 | 保存/更新到数据库 |
-| 已标记删除 | ✅ 勾选 | ❌ 无 | 拒绝操作，弹出警告 |
-| 已标记删除 | ❌ 未勾选 | - | 从数据库删除 |
-| 未标记删除 | ✅ 勾选 | ✅ 有 | 保存/更新到数据库 |
-| 未标记删除 | ✅ 勾选 | ❌ 无 | 拒绝操作，弹出警告 |
-| 未标记删除 | ❌ 未勾选 | - | 从数据库删除 |
+| 物料状态   | 勾选状态  | 负责人信息 | 处理方式           |
+| ---------- | --------- | ---------- | ------------------ |
+| 已标记删除 | ✅ 勾选   | ✅ 有      | 保存/更新到数据库  |
+| 已标记删除 | ✅ 勾选   | ❌ 无      | 拒绝操作，弹出警告 |
+| 已标记删除 | ❌ 未勾选 | -          | 从数据库删除       |
+| 未标记删除 | ✅ 勾选   | ✅ 有      | 保存/更新到数据库  |
+| 未标记删除 | ✅ 勾选   | ❌ 无      | 拒绝操作，弹出警告 |
+| 未标记删除 | ❌ 未勾选 | -          | 从数据库删除       |

 ---

@@ -976,12 +968,14 @@ for (let i = 0; i < materialCodes.length; i += batchSize) {
 **SQL示例**:

 **MySQL**:
+
 ```sql
 DELETE FROM dbo_MaterialsToDeleted
 WHERE MaterialCode IN (?, ?, ?, ..., ?)  -- 最多1000个占位符
 ```

 **SQL Server**:
+
 ```sql
 DELETE FROM [dbo].[MaterialsToBeDeleted]
 WHERE MaterialCode IN (@p0, @p1, @p2, ..., @p999)  -- 最多1000个参数
@@ -1116,8 +1110,8 @@ graph TB
 ```typescript
 interface MaterialUpsertBatchRequest {
  materials: {
-    materialCode: string   // 物料代码
-    managerName: string    // 负责人名称
+    materialCode: string // 物料代码
+    managerName: string // 负责人名称
  }[]
 }
 ```
@@ -1126,7 +1120,7 @@ interface MaterialUpsertBatchRequest {

 ```typescript
 interface MaterialDeleteRequest {
-  materialCodes: string[]  // 要删除的物料代码数组
+  materialCodes: string[] // 要删除的物料代码数组
 }
 ```

@@ -1135,8 +1129,8 @@ interface MaterialDeleteRequest {
 ```typescript
 interface MaterialOperationResponse {
  success: boolean
-  stats?: UpsertStats     // upsert操作返回
-  count?: number          // delete操作返回
+  stats?: UpsertStats // upsert操作返回
+  count?: number // delete操作返回
  error?: string
 }
 ```
@@ -1145,9 +1139,9 @@ interface MaterialOperationResponse {

 ```typescript
 interface UpsertStats {
-  total: number    // 总处理数量
-  success: number  // 成功数量
-  failed: number   // 失败数量
+  total: number // 总处理数量
+  success: number // 成功数量
+  failed: number // 失败数量
 }
 ```

@@ -1210,29 +1204,29 @@ flowchart TB

 ### 8. 与"获取校验状态"流程的对比

-| 对比维度 | 获取校验状态 | 确认删除(同步数据库) |
-|---------|------------|-------------------|
-| **操作方向** | 数据库 → 前端 (读取) | 前端 → 数据库 (写入) |
-| **主要操作** | SELECT 查询 | MERGE/INSERT + DELETE |
-| **数据量** | 可能很大(全表查询) | 取决于用户勾选数量 |
-| **事务性** | 只读，无需事务 | 写操作，逐条处理 |
-| **用户交互** | 单次点击 | 点击 → 确认对话框 → 执行 |
-| **错误处理** | 整体失败或成功 | 部分失败继续处理 |
-| **结果反馈** | 校验结果列表 | 操作统计(成功/删除条数) |
-| **副作用** | 无 | 修改数据库内容 |
-| **权限要求** | 读取权限 | 写入+删除权限 |
+| 对比维度     | 获取校验状态         | 确认删除(同步数据库)     |
+| ------------ | -------------------- | ------------------------ |
+| **操作方向** | 数据库 → 前端 (读取) | 前端 → 数据库 (写入)     |
+| **主要操作** | SELECT 查询          | MERGE/INSERT + DELETE    |
+| **数据量**   | 可能很大(全表查询)   | 取决于用户勾选数量       |
+| **事务性**   | 只读，无需事务       | 写操作，逐条处理         |
+| **用户交互** | 单次点击             | 点击 → 确认对话框 → 执行 |
+| **错误处理** | 整体失败或成功       | 部分失败继续处理         |
+| **结果反馈** | 校验结果列表         | 操作统计(成功/删除条数)  |
+| **副作用**   | 无                   | 修改数据库内容           |
+| **权限要求** | 读取权限             | 写入+删除权限            |

 ---

 ## 文件索引

-| 文件路径 | 说明 | 关键行号 |
-|---------|------|---------|
-| `src/renderer/src/pages/CleanerPage.tsx` | 前端清理页面 | 117-155 (handleValidation)<br>166-226 (handleConfirmDeletion) |
-| `src/main/ipc/validation-handler.ts` | IPC处理器 | 209-392 (validation:validate)<br>399-422 (materials:upsertBatch)<br>427-449 (materials:delete) |
-| `src/main/services/database/discrete-material-plan-dao.ts` | 物料计划DAO | 191-227 (queryAllDistinctByMaterialCode) |
-| `src/main/services/database/discrete-material-plan-dao.ts` | 物料计划DAO | 294-377 (queryBySourceNumbersDistinct) |
-| `src/main/services/database/materials-to-be-deleted-dao.ts` | 待删除物料DAO | 180-240 (upsertBatch)<br>248-268 (getAllMaterialCodes)<br>539-586 (deleteByMaterialCodes) |
+| 文件路径                                                    | 说明          | 关键行号                                                                                       |
+| ----------------------------------------------------------- | ------------- | ---------------------------------------------------------------------------------------------- |
+| `src/renderer/src/pages/CleanerPage.tsx`                    | 前端清理页面  | 117-155 (handleValidation)<br>166-226 (handleConfirmDeletion)                                  |
+| `src/main/ipc/validation-handler.ts`                        | IPC处理器     | 209-392 (validation:validate)<br>399-422 (materials:upsertBatch)<br>427-449 (materials:delete) |
+| `src/main/services/database/discrete-material-plan-dao.ts`  | 物料计划DAO   | 191-227 (queryAllDistinctByMaterialCode)                                                       |
+| `src/main/services/database/discrete-material-plan-dao.ts`  | 物料计划DAO   | 294-377 (queryBySourceNumbersDistinct)                                                         |
+| `src/main/services/database/materials-to-be-deleted-dao.ts` | 待删除物料DAO | 180-240 (upsertBatch)<br>248-268 (getAllMaterialCodes)<br>539-586 (deleteByMaterialCodes)      |

 ---

--- a/docs/optimization-execution-plan.md
+++ b/docs/optimization-execution-plan.md
@@ -0,0 +1,93 @@
+# ERPAuto 优化执行计划文档
+
+基于《ERPAuto 优化建议与规范指南》，本文档规划了具体的分阶段重构与优化执行步骤。每个阶段遵循“渐进式重构”原则，保证在优化期间项目依然可运行、可测试。
+
+## 阶段一：基础设施建设 (Error & Logging)
+
+在进行大规模业务逻辑重构前，首先建立坚实的基础设施，以便后续问题排查与数据追踪。
+
+1. **引入并配置统一日志库**
+   - **目标**: 替换分散的 `console.log`。
+   - **执行**:
+     - 安装 `winston` (针对 Node.js 主进程)。
+     - 在 `src/main/services/logger` 创建单例日志记录器。
+     - 配置双通道输出：Console (Dev 环境) 与 File (生产环境按天切割，如 `%AppData%/ERPAuto/logs/app-%DATE%.log`)。
+2. **定义全局错误类型与 IPC 拦截器**
+   - **目标**: 规范前后端错误抛出与展示体系。
+   - **执行**:
+     - 在 `src/main/types/errors.ts` 定义 `BaseError`, `ErpConnectionError`, `DatabaseQueryError`。
+     - 在 `src/main/ipc/index.ts` 中封装高阶函数 `withErrorHandling`。所有 IPC Handler 统一用此高阶函数包裹，将捕获的错误统一转为 `{ success: false, error: string, code: string }` 结构。
+
+## 阶段二：数据层抽象与 ORM 改造
+
+彻底解决 SQL 语句散落和不同数据库适配成本高的问题。
+
+1. **选型并引入 ORM**
+   - **目标**: 弃用原生 SQL 拼接。
+   - **执行**:
+     - 引入 `Prisma` 或 `TypeORM`。结合当前多数据源 (MySQL + SQL Server) 需求，推荐 `TypeORM` 因为其在运行时切换数据源更为灵活。
+2. **创建 Repository 抽象**
+   - **目标**: 隔离数据库实现细节。
+   - **执行**:
+     - 建立 `src/main/services/database/repositories` 目录。
+     - 为业务实体 (如 Users, ExtractedPlans 等) 编写 Repository 类接口。
+     - 将原有 `mysql2` 和 `mssql` 的调用逐步迁移至 Repository 中。
+3. **Zod 运行时校验**
+   - **目标**: 保护 IPC 边界免受恶意/格式错误的 payload 影响。
+   - **执行**:
+     - 安装 `zod`。
+     - 对所有的 IPC Handler 的入参（如 `ExtractorInput`, `LoginRequest`）添加 `zod` Schema 校验。
+
+## 阶段三：React 渲染层规范化
+
+提高前端代码复用率，解耦视图与逻辑。
+
+1. **提取 IPC Hooks**
+   - **目标**: 清理组件中的大段异步调用。
+   - **执行**:
+     - 在 `src/renderer/src/hooks` 创建 `useExtractor.ts`, `useCleaner.ts`。
+     - 使用 React 的 `useState` 包装 `window.api` 调用，返回 `{ loading, data, error, execute }`。
+2. **状态管理引入 (Zustand)**
+   - **目标**: 解决跨组件状态共享 (如全局报错信息、用户认证状态)。
+   - **执行**:
+     - 安装 `zustand`。
+     - 创建 `useUserStore` 和 `useAppStore`。
+3. **UI 组件库/公共样式提取**
+   - **目标**: 统一 Tailwind 设计语言。
+   - **执行**:
+     - 将高频使用的 Button, Input, Modal 抽取到 `src/renderer/src/components/ui/`。
+
+## 阶段四：自动化服务解耦 (Domain Logic)
+
+将基于 Playwright 的具体执行细节与业务调度逻辑分离。
+
+1. **重构 ERP 自动化服务 (`cleaner.ts` / `extractor.ts`)**
+   - **目标**: 遵循单一职责原则。
+   - **执行**:
+     - 抽象出 `ErpBrowserManager` (负责浏览器启动与资源回收)。
+     - 抽象出 `ErpAuthService` (专职处理登录和 Session)。
+     - `extractor.ts` 将只负责调度：调用 Browser -> Auth -> Navigate -> Download -> Excel Parse。
+2. **加强 TypeScript 严格模式**
+   - **目标**: 提升代码健壮性。
+   - **执行**:
+     - 开启 `tsconfig.json` 中的 `"strict": true` 和 `"noImplicitAny": true`。
+     - 全局清理并替换现存的 `any` 为具体的 Type 或 `unknown` 并添加类型保护。
+
+## 阶段五：测试覆盖率补充
+
+确保核心流程不被破坏。
+
+1. **补充关键服务的单元测试**
+   - **目标**: 防止复杂转换逻辑衰退。
+   - **执行**:
+     - 使用 `Vitest` 测试所有的 Repository (使用内存数据库/Mock) 和工具函数 (如 ExcelParser)。
+2. **核心业务 E2E 测试**
+   - **目标**: 确保 IPC 及 Electron 整体运行顺畅。
+   - **执行**:
+     - 使用 Playwright 针对 Electron 的测试框架 (`@playwright/test` 的 electron 插件) 编写主流程测试：登录 -> 点击提取 -> 验证本地结果文件生成。
+
+## 执行建议与回顾
+
+- 每个阶段应作为一个单独的 Git 分支 (Feature Branch) 开发。
+- 完成一个阶段后，必须全量运行既有的测试套件并通过 `npm run typecheck`。
+- 本文档可作为每次 PR Review 的检查清单使用。
--- a/logs/.869a8c37397718a299488a3d6c7b9753a8bc7cf9-audit.json
+++ b/logs/.869a8c37397718a299488a3d6c7b9753a8bc7cf9-audit.json
@@ -0,0 +1,15 @@
+{
+  "keep": {
+    "days": true,
+    "amount": 14
+  },
+  "auditLog": "D:\\FileLib\\Projects\\CodeMigration\\ERPAuto\\logs\\.869a8c37397718a299488a3d6c7b9753a8bc7cf9-audit.json",
+  "files": [
+    {
+      "date": 1772462852547,
+      "name": "D:\\FileLib\\Projects\\CodeMigration\\ERPAuto\\logs\\app-2026-03-02.log",
+      "hash": "baa4ab4c2dfd6ec62a003e44496d2f428a4ad4037ce2529a8da14da1b91ef7a2"
+    }
+  ],
+  "hashType": "sha256"
+}
--- a/package-lock.json
+++ b/package-lock.json
--- a/package.json
+++ b/package.json
@@ -37,14 +37,20 @@
    "mssql": "^12.2.0",
    "mysql2": "^3.18.2",
    "playwright": "^1.58.2",
+    "reflect-metadata": "^0.2.2",
+    "typeorm": "^0.3.28",
    "uuid": "^13.0.0",
-    "zod": "^4.3.6"
+    "winston": "^3.19.0",
+    "winston-daily-rotate-file": "^5.0.0",
+    "zod": "^4.3.6",
+    "zustand": "^5.0.11"
  },
  "devDependencies": {
    "@electron-toolkit/eslint-config-prettier": "^3.0.0",
    "@electron-toolkit/eslint-config-ts": "^3.1.0",
    "@electron-toolkit/tsconfig": "^2.0.0",
    "@playwright/test": "^1.58.2",
+    "@types/mssql": "^9.1.9",
    "@types/node": "^22.19.13",
    "@types/react": "^19.2.7",
    "@types/react-dom": "^19.2.3",
--- a/src/main/ipc/auth-handler.ts
+++ b/src/main/ipc/auth-handler.ts
@@ -12,8 +12,11 @@

 import { ipcMain } from 'electron'
 import { SessionManager } from '../services/user/session-manager'
+import { createLogger } from '../services/logger'
 import type { UserInfo } from '../types/user.types'

+const log = createLogger('AuthHandler')
+
 /**
 * Login request
 */
@@ -75,110 +78,115 @@ export function registerAuthHandlers(): void {
  /**
   * Silent login by computer name
   */
-  ipcMain.handle(
-    'auth:silentLogin',
-    async (): Promise<SilentLoginResponse> => {
-      try {
-        const success = await sessionManager.loginByComputerName()
-        const userInfo = sessionManager.getUserInfo()
+  ipcMain.handle('auth:silentLogin', async (): Promise<SilentLoginResponse> => {
+    try {
+      log.info('Attempting silent login')
+      const success = await sessionManager.loginByComputerName()
+      const userInfo = sessionManager.getUserInfo()

-        if (success && userInfo) {
-          // Check if admin needs user selection
-          const requiresUserSelection = userInfo.userType === 'Admin'
+      if (success && userInfo) {
+        // Check if admin needs user selection
+        const requiresUserSelection = userInfo.userType === 'Admin'

-          return {
-            success: true,
-            userInfo,
-            requiresUserSelection
-          }
-        }
+        log.info('Silent login successful', {
+          username: userInfo.username,
+          userType: userInfo.userType,
+          requiresUserSelection
+        })

        return {
-          success: false,
-          requiresUserSelection: false
-        }
-      } catch (error) {
-        const message = error instanceof Error ? error.message : 'Unknown error'
-        return {
-          success: false,
-          error: `无感登录失败：${message}`
+          success: true,
+          userInfo,
+          requiresUserSelection
        }
      }
+
+      log.warn('Silent login failed - no matching user')
+      return {
+        success: false,
+        requiresUserSelection: false
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : 'Unknown error'
+      log.error('Silent login error', { error: message })
+      return {
+        success: false,
+        error: `无感登录失败：${message}`
+      }
    }
-  )
+  })

  /**
   * Login with username and password
   */
-  ipcMain.handle(
-    'auth:login',
-    async (_event, request: LoginRequest): Promise<LoginResponse> => {
-      try {
-        const { username, password } = request
-
-        if (!username || !password) {
-          return {
-            success: false,
-            error: '请输入用户名和密码'
-          }
-        }
-
-        const success = await sessionManager.login(username, password)
-        const userInfo = sessionManager.getUserInfo()
-
-        if (success && userInfo) {
-          return {
-            success: true,
-            userInfo
-          }
-        }
+  ipcMain.handle('auth:login', async (_event, request: LoginRequest): Promise<LoginResponse> => {
+    try {
+      const { username, password } = request

+      if (!username || !password) {
+        log.warn('Login attempt with missing credentials')
        return {
          success: false,
-          error: '用户名或密码错误'
-        }
-      } catch (error) {
-        const message = error instanceof Error ? error.message : 'Unknown error'
-        return {
-          success: false,
-          error: `登录失败：${message}`
+          error: '请输入用户名和密码'
        }
      }
+
+      log.info('Login attempt', { username })
+      const success = await sessionManager.login(username, password)
+      const userInfo = sessionManager.getUserInfo()
+
+      if (success && userInfo) {
+        log.info('Login successful', { username, userType: userInfo.userType })
+        return {
+          success: true,
+          userInfo
+        }
+      }
+
+      log.warn('Login failed - invalid credentials', { username })
+      return {
+        success: false,
+        error: '用户名或密码错误'
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : 'Unknown error'
+      log.error('Login error', { error: message })
+      return {
+        success: false,
+        error: `登录失败：${message}`
+      }
    }
-  )
+  })

  /**
   * Logout
   */
  ipcMain.handle('auth:logout', async (): Promise<void> => {
+    const userInfo = sessionManager.getUserInfo()
+    log.info('User logout', { username: userInfo?.username })
    sessionManager.logout()
  })

  /**
   * Get current user
   */
-  ipcMain.handle(
-    'auth:getCurrentUser',
-    async (): Promise<CurrentUserResponse> => {
-      const isAuthenticated = sessionManager.isAuthenticated()
-      const userInfo = sessionManager.getUserInfo()
+  ipcMain.handle('auth:getCurrentUser', async (): Promise<CurrentUserResponse> => {
+    const isAuthenticated = sessionManager.isAuthenticated()
+    const userInfo = sessionManager.getUserInfo()

-      return {
-        isAuthenticated,
-        userInfo: userInfo ?? undefined
-      }
+    return {
+      isAuthenticated,
+      userInfo: userInfo ?? undefined
    }
-  )
+  })

  /**
   * Get all users (for admin user selection)
   */
-  ipcMain.handle(
-    'auth:getAllUsers',
-    async (): Promise<UserInfo[]> => {
-      return await sessionManager.getAllUsers()
-    }
-  )
+  ipcMain.handle('auth:getAllUsers', async (): Promise<UserInfo[]> => {
+    log.debug('Fetching all users for admin selection')
+    return await sessionManager.getAllUsers()
+  })

  /**
   * Switch user (admin only)
@@ -187,22 +195,26 @@ export function registerAuthHandlers(): void {
    'auth:switchUser',
    async (_event, userInfo: UserInfo): Promise<UserSelectionResponse> => {
      try {
+        log.info('User switch attempt', { targetUser: userInfo.username })
        const success = sessionManager.switchUser(userInfo)

        if (success) {
          const newUser = sessionManager.getUserInfo()
+          log.info('User switch successful', { newUsername: newUser?.username })
          return {
            success: true,
            userInfo: newUser ?? undefined
          }
        }

+        log.warn('User switch failed')
        return {
          success: false,
          error: '用户切换失败'
        }
      } catch (error) {
        const message = error instanceof Error ? error.message : 'Unknown error'
+        log.error('User switch error', { error: message })
        return {
          success: false,
          error: `用户切换失败：${message}`
@@ -214,10 +226,7 @@ export function registerAuthHandlers(): void {
  /**
   * Check if current user is admin
   */
-  ipcMain.handle(
-    'auth:isAdmin',
-    async (): Promise<boolean> => {
-      return sessionManager.isAdmin()
-    }
-  )
+  ipcMain.handle('auth:isAdmin', async (): Promise<boolean> => {
+    return sessionManager.isAdmin()
+  })
 }
--- a/src/main/ipc/cleaner-handler.ts
+++ b/src/main/ipc/cleaner-handler.ts
@@ -3,125 +3,153 @@ import { ErpAuthService } from '../services/erp/erp-auth'
 import { CleanerService } from '../services/erp/cleaner'
 import { OrderNumberResolver } from '../services/erp/order-resolver'
 import { MySqlService } from '../services/database/mysql'
+import { createLogger } from '../services/logger'
+import { withErrorHandling, type IpcResult } from './index'
+import { ErpConnectionError, ValidationError, DatabaseQueryError } from '../types/errors'
 import type { CleanerInput, CleanerResult } from '../types/cleaner.types'

+const log = createLogger('CleanerHandler')
+
 /**
 * Register IPC handlers for cleaner service
 */
 export function registerCleanerHandlers(): void {
  ipcMain.handle(
    'cleaner:run',
-    async (
-      _event,
-      input: CleanerInput
-    ): Promise<{ success: boolean; data?: CleanerResult; error?: string }> => {
-      let authService: ErpAuthService | null = null
-      let mysqlService: MySqlService | null = null
+    async (_event, input: CleanerInput): Promise<IpcResult<CleanerResult>> => {
+      return withErrorHandling(async () => {
+        let authService: ErpAuthService | null = null
+        let mysqlService: MySqlService | null = null

-      try {
-        // Check environment variables
-        const erpUrl = process.env.ERP_URL || ''
-        const erpUsername = process.env.ERP_USERNAME || ''
-        const erpPassword = process.env.ERP_PASSWORD || ''
+        try {
+          // Check environment variables
+          const erpUrl = process.env.ERP_URL || ''
+          const erpUsername = process.env.ERP_USERNAME || ''
+          const erpPassword = process.env.ERP_PASSWORD || ''

-        console.log('[Cleaner] Config:', {
-          url: erpUrl ? '***' : 'EMPTY',
-          username: erpUsername ? '***' : 'EMPTY'
-        })
+          log.info('Config check', {
+            url: erpUrl ? 'configured' : 'EMPTY',
+            username: erpUsername ? 'configured' : 'EMPTY'
+          })

-        if (!erpUrl || !erpUsername || !erpPassword) {
-          throw new Error(
-            'ERP 配置不完整。请检查 .env 文件中的 ERP_URL, ERP_USERNAME, ERP_PASSWORD'
-          )
-        }
+          if (!erpUrl || !erpUsername || !erpPassword) {
+            throw new ValidationError(
+              'ERP 配置不完整。请检查 .env 文件中的 ERP_URL, ERP_USERNAME, ERP_PASSWORD',
+              'VAL_MISSING_REQUIRED'
+            )
+          }

-        // Resolve order numbers (convert productionIDs to 生产订单号)
-        const mysqlConfig = {
-          host: process.env.DB_MYSQL_HOST || 'localhost',
-          port: parseInt(process.env.DB_MYSQL_PORT || '3306', 10),
-          user: process.env.DB_USERNAME || 'root',
-          password: process.env.DB_PASSWORD || '',
-          database: process.env.DB_NAME || ''
-        }
+          // Resolve order numbers (convert productionIDs to 生产订单号)
+          const mysqlConfig = {
+            host: process.env.DB_MYSQL_HOST || 'localhost',
+            port: parseInt(process.env.DB_MYSQL_PORT || '3306', 10),
+            user: process.env.DB_USERNAME || 'root',
+            password: process.env.DB_PASSWORD || '',
+            database: process.env.DB_NAME || ''
+          }

-        console.log('[Cleaner] Connecting to MySQL for order resolution...')
-        mysqlService = new MySqlService(mysqlConfig)
-        await mysqlService.connect()
+          log.info('Connecting to MySQL for order resolution...')
+          mysqlService = new MySqlService(mysqlConfig)

-        const resolver = new OrderNumberResolver(mysqlService)
-        const mappings = await resolver.resolve(input.orderNumbers)
-
-        // Get valid order numbers and warnings
-        const validOrderNumbers = resolver.getValidOrderNumbers(mappings)
-        const warnings = resolver.getWarnings(mappings)
-
-        if (warnings.length > 0) {
-          console.warn('[Cleaner] Resolution warnings:', warnings)
-        }
-
-        if (validOrderNumbers.length === 0) {
-          throw new Error('没有有效的生产订单号可处理。请检查输入的格式或数据库连接。')
-        }
-
-        console.log('[Cleaner] Resolved order numbers:', validOrderNumbers)
-
-        // Create auth service and login
-        authService = new ErpAuthService({
-          url: erpUrl,
-          username: erpUsername,
-          password: erpPassword,
-          headless: true
-        })
-
-        console.log('[Cleaner] Logging in to ERP...')
-        await authService.login()
-        console.log('[Cleaner] Login successful')
-
-        // Create cleaner service and run cleaning with resolved order numbers
-        const cleaner = new CleanerService(authService)
-
-        const modifiedInput: CleanerInput = {
-          ...input,
-          orderNumbers: validOrderNumbers,
-          onProgress: input.onProgress
-        }
-
-        console.log('[Cleaner] Starting cleaning:', modifiedInput)
-        const result = await cleaner.clean(modifiedInput)
-        console.log('[Cleaner] Cleaning completed:', result)
-
-        // Add warnings to result errors if any
-        if (warnings.length > 0) {
-          result.errors = [...warnings, ...result.errors]
-        }
-
-        return { success: true, data: result }
-      } catch (error) {
-        const message = error instanceof Error ? error.message : 'Unknown error'
-        console.error('[Cleaner] Error:', message)
-        console.error('[Cleaner] Stack:', error instanceof Error ? error.stack : 'N/A')
-        return { success: false, error: `清理失败：${message}` }
-      } finally {
-        // Clean up: close browser
-        if (authService) {
          try {
-            await authService.close()
-            console.log('[Cleaner] Browser closed')
-          } catch (closeError) {
-            console.warn('[Cleaner] Error closing browser:', closeError)
+            await mysqlService.connect()
+          } catch (error) {
+            throw new DatabaseQueryError(
+              'MySQL 连接失败',
+              'DB_CONNECTION_FAILED',
+              error instanceof Error ? error : undefined
+            )
+          }
+
+          const resolver = new OrderNumberResolver(mysqlService)
+          const mappings = await resolver.resolve(input.orderNumbers)
+
+          // Get valid order numbers and warnings
+          const validOrderNumbers = resolver.getValidOrderNumbers(mappings)
+          const warnings = resolver.getWarnings(mappings)
+
+          if (warnings.length > 0) {
+            log.warn('Resolution warnings', { warnings })
+          }
+
+          if (validOrderNumbers.length === 0) {
+            throw new ValidationError(
+              '没有有效的生产订单号可处理。请检查输入的格式或数据库连接。',
+              'VAL_INVALID_INPUT'
+            )
+          }
+
+          log.info('Resolved order numbers', { count: validOrderNumbers.length })
+
+          // Create auth service and login
+          authService = new ErpAuthService({
+            url: erpUrl,
+            username: erpUsername,
+            password: erpPassword,
+            headless: true
+          })
+
+          log.info('Logging in to ERP...')
+          try {
+            await authService.login()
+          } catch (error) {
+            throw new ErpConnectionError(
+              'ERP 登录失败',
+              'ERP_LOGIN_FAILED',
+              error instanceof Error ? error : undefined
+            )
+          }
+          log.info('Login successful')
+
+          // Create cleaner service and run cleaning with resolved order numbers
+          const cleaner = new CleanerService(authService)
+
+          const modifiedInput: CleanerInput = {
+            ...input,
+            orderNumbers: validOrderNumbers,
+            onProgress: input.onProgress
+          }
+
+          log.info('Starting cleaning', { orderCount: validOrderNumbers.length })
+          const result = await cleaner.clean(modifiedInput)
+
+          // Add warnings to result errors if any
+          if (warnings.length > 0) {
+            result.errors = [...warnings, ...result.errors]
+          }
+
+          log.info('Cleaning completed', {
+            processedCount: result.ordersProcessed,
+            errorCount: result.errors.length
+          })
+
+          return result
+        } finally {
+          // Clean up: close browser
+          if (authService) {
+            try {
+              await authService.close()
+              log.debug('Browser closed')
+            } catch (closeError) {
+              log.warn('Error closing browser', {
+                error: closeError instanceof Error ? closeError.message : String(closeError)
+              })
+            }
+          }
+
+          // Clean up: disconnect MySQL
+          if (mysqlService) {
+            try {
+              await mysqlService.disconnect()
+              log.debug('MySQL disconnected')
+            } catch (closeError) {
+              log.warn('Error disconnecting MySQL', {
+                error: closeError instanceof Error ? closeError.message : String(closeError)
+              })
+            }
          }
        }
-
-        // Clean up: disconnect MySQL
-        if (mysqlService) {
-          try {
-            await mysqlService.disconnect()
-            console.log('[Cleaner] MySQL disconnected')
-          } catch (closeError) {
-            console.warn('[Cleaner] Error disconnecting MySQL:', closeError)
-          }
-        }
-      }
+      }, 'cleaner:run')
    }
  )
 }
--- a/src/main/ipc/database-handler.ts
+++ b/src/main/ipc/database-handler.ts
@@ -1,6 +1,8 @@
 import { ipcMain } from 'electron'
 import { MySqlService } from '../services/database/mysql'
 import { SqlServerService } from '../services/database/sql-server'
+import { createLogger } from '../services/logger'
+import { DatabaseQueryError, ValidationError } from '../types/errors'
 import type {
  MySqlConfig,
  MySqlQueryResult,
@@ -8,6 +10,8 @@ import type {
  SqlServerQueryResult
 } from '../types/ipc-api.types'

+const log = createLogger('DatabaseHandler')
+
 // Store MySQL service instances per window/connection
 const mysqlServices = new Map<string, MySqlService>()

@@ -64,34 +68,47 @@ export function registerDatabaseHandlers(): void {
  ipcMain.handle('database:mysql:connect', async (event, config: MySqlConfig): Promise<void> => {
    try {
      // Use window ID as connection identifier
-      const windowId = (event.sender as any).id.toString()
+      const windowId = (event.sender as { id: number }).id.toString()
+      log.info('Connecting to MySQL', { windowId })
      const service = new MySqlService(config)
      await service.connect()
      setMySqlService(windowId, service)
+      log.info('MySQL connected', { windowId })
    } catch (error) {
      const message = error instanceof Error ? error.message : 'Failed to connect to MySQL'
-      throw new Error(message)
+      log.error('MySQL connection failed', { error: message })
+      throw new DatabaseQueryError(
+        message,
+        'DB_CONNECTION_FAILED',
+        error instanceof Error ? error : undefined
+      )
    }
  })

  // Disconnect from MySQL
  ipcMain.handle('database:mysql:disconnect', async (event): Promise<void> => {
    try {
-      const windowId = (event.sender as any).id.toString()
+      const windowId = (event.sender as { id: number }).id.toString()
      const service = getMySqlService(windowId)
      if (service) {
        await service.disconnect()
        deleteMySqlService(windowId)
+        log.info('MySQL disconnected', { windowId })
      }
    } catch (error) {
      const message = error instanceof Error ? error.message : 'Failed to disconnect from MySQL'
-      throw new Error(message)
+      log.error('MySQL disconnect failed', { error: message })
+      throw new DatabaseQueryError(
+        message,
+        'DB_CONNECTION_FAILED',
+        error instanceof Error ? error : undefined
+      )
    }
  })

  // Check if MySQL is connected
  ipcMain.handle('database:mysql:isConnected', async (event): Promise<boolean> => {
-    const windowId = (event.sender as any).id.toString()
+    const windowId = (event.sender as { id: number }).id.toString()
    const service = getMySqlService(windowId)
    return service ? service.isConnected() : false
  })
@@ -99,19 +116,28 @@ export function registerDatabaseHandlers(): void {
  // Execute MySQL query
  ipcMain.handle(
    'database:mysql:query',
-    async (event, sql: string, params?: any[]): Promise<MySqlQueryResult> => {
+    async (event, sql: string, params?: unknown[]): Promise<MySqlQueryResult> => {
      try {
-        const windowId = (event.sender as any).id.toString()
+        const windowId = (event.sender as { id: number }).id.toString()
        const service = getMySqlService(windowId)

        if (!service) {
-          throw new Error('Not connected to MySQL. Call connect() first.')
+          throw new ValidationError(
+            'Not connected to MySQL. Call connect() first.',
+            'VAL_INVALID_INPUT'
+          )
        }

+        log.debug('Executing MySQL query', { windowId, sql: sql.substring(0, 100) })
        return await service.query(sql, params)
      } catch (error) {
        const message = error instanceof Error ? error.message : 'MySQL query failed'
-        throw new Error(message)
+        log.error('MySQL query failed', { error: message })
+        throw new DatabaseQueryError(
+          message,
+          'DB_QUERY_FAILED',
+          error instanceof Error ? error : undefined
+        )
      }
    }
  )
@@ -121,13 +147,20 @@ export function registerDatabaseHandlers(): void {
    'database:sqlserver:connect',
    async (event, config: SqlServerConfig): Promise<void> => {
      try {
-        const windowId = (event.sender as any).id.toString()
+        const windowId = (event.sender as { id: number }).id.toString()
+        log.info('Connecting to SQL Server', { windowId })
        const service = new SqlServerService(config)
        await service.connect()
        setSqlServerService(windowId, service)
+        log.info('SQL Server connected', { windowId })
      } catch (error) {
        const message = error instanceof Error ? error.message : 'Failed to connect to SQL Server'
-        throw new Error(message)
+        log.error('SQL Server connection failed', { error: message })
+        throw new DatabaseQueryError(
+          message,
+          'DB_CONNECTION_FAILED',
+          error instanceof Error ? error : undefined
+        )
      }
    }
  )
@@ -135,22 +168,28 @@ export function registerDatabaseHandlers(): void {
  // Disconnect from SQL Server
  ipcMain.handle('database:sqlserver:disconnect', async (event): Promise<void> => {
    try {
-      const windowId = (event.sender as any).id.toString()
+      const windowId = (event.sender as { id: number }).id.toString()
      const service = getSqlServerService(windowId)
      if (service) {
        await service.disconnect()
        deleteSqlServerService(windowId)
+        log.info('SQL Server disconnected', { windowId })
      }
    } catch (error) {
      const message =
        error instanceof Error ? error.message : 'Failed to disconnect from SQL Server'
-      throw new Error(message)
+      log.error('SQL Server disconnect failed', { error: message })
+      throw new DatabaseQueryError(
+        message,
+        'DB_CONNECTION_FAILED',
+        error instanceof Error ? error : undefined
+      )
    }
  })

  // Check if SQL Server is connected
  ipcMain.handle('database:sqlserver:isConnected', async (event): Promise<boolean> => {
-    const windowId = (event.sender as any).id.toString()
+    const windowId = (event.sender as { id: number }).id.toString()
    const service = getSqlServerService(windowId)
    return service ? service.isConnected() : false
  })
@@ -164,17 +203,26 @@ export function registerDatabaseHandlers(): void {
      params?: Record<string, unknown>
    ): Promise<SqlServerQueryResult> => {
      try {
-        const windowId = (event.sender as any).id.toString()
+        const windowId = (event.sender as { id: number }).id.toString()
        const service = getSqlServerService(windowId)

        if (!service) {
-          throw new Error('Not connected to SQL Server. Call connect() first.')
+          throw new ValidationError(
+            'Not connected to SQL Server. Call connect() first.',
+            'VAL_INVALID_INPUT'
+          )
        }

+        log.debug('Executing SQL Server query', { windowId, sql: sqlString.substring(0, 100) })
        return await service.query(sqlString, params)
      } catch (error) {
        const message = error instanceof Error ? error.message : 'SQL Server query failed'
-        throw new Error(message)
+        log.error('SQL Server query failed', { error: message })
+        throw new DatabaseQueryError(
+          message,
+          'DB_QUERY_FAILED',
+          error instanceof Error ? error : undefined
+        )
      }
    }
  )
--- a/src/main/ipc/extractor-handler.ts
+++ b/src/main/ipc/extractor-handler.ts
@@ -3,125 +3,152 @@ import { ErpAuthService } from '../services/erp/erp-auth'
 import { ExtractorService } from '../services/erp/extractor'
 import { OrderNumberResolver } from '../services/erp/order-resolver'
 import { MySqlService } from '../services/database/mysql'
+import { createLogger } from '../services/logger'
+import { withErrorHandling, type IpcResult } from './index'
+import { ErpConnectionError, ValidationError, DatabaseQueryError } from '../types/errors'
 import type { ExtractorInput, ExtractorResult } from '../types/extractor.types'

+const log = createLogger('ExtractorHandler')
+
 /**
 * Register IPC handlers for extractor service
 */
 export function registerExtractorHandlers(): void {
  ipcMain.handle(
    'extractor:run',
-    async (
-      _event,
-      input: ExtractorInput
-    ): Promise<{ success: boolean; data?: ExtractorResult; error?: string }> => {
-      let authService: ErpAuthService | null = null
-      let mysqlService: MySqlService | null = null
+    async (_event, input: ExtractorInput): Promise<IpcResult<ExtractorResult>> => {
+      return withErrorHandling(async () => {
+        let authService: ErpAuthService | null = null
+        let mysqlService: MySqlService | null = null

-      try {
-        // Check environment variables
-        const erpUrl = process.env.ERP_URL || ''
-        const erpUsername = process.env.ERP_USERNAME || ''
-        const erpPassword = process.env.ERP_PASSWORD || ''
+        try {
+          // Check environment variables
+          const erpUrl = process.env.ERP_URL || ''
+          const erpUsername = process.env.ERP_USERNAME || ''
+          const erpPassword = process.env.ERP_PASSWORD || ''

-        console.log('[Extractor] Config:', {
-          url: erpUrl ? '***' : 'EMPTY',
-          username: erpUsername ? '***' : 'EMPTY'
-        })
+          log.info('Config check', {
+            url: erpUrl ? 'configured' : 'EMPTY',
+            username: erpUsername ? 'configured' : 'EMPTY'
+          })

-        if (!erpUrl || !erpUsername || !erpPassword) {
-          throw new Error(
-            'ERP 配置不完整。请检查 .env 文件中的 ERP_URL, ERP_USERNAME, ERP_PASSWORD'
-          )
-        }
+          if (!erpUrl || !erpUsername || !erpPassword) {
+            throw new ValidationError(
+              'ERP 配置不完整。请检查 .env 文件中的 ERP_URL, ERP_USERNAME, ERP_PASSWORD',
+              'VAL_MISSING_REQUIRED'
+            )
+          }

-        // Resolve order numbers (convert productionIDs to 生产订单号)
-        const mysqlConfig = {
-          host: process.env.DB_MYSQL_HOST || 'localhost',
-          port: parseInt(process.env.DB_MYSQL_PORT || '3306', 10),
-          user: process.env.DB_USERNAME || 'root',
-          password: process.env.DB_PASSWORD || '',
-          database: process.env.DB_NAME || ''
-        }
+          // Resolve order numbers (convert productionIDs to 生产订单号)
+          const mysqlConfig = {
+            host: process.env.DB_MYSQL_HOST || 'localhost',
+            port: parseInt(process.env.DB_MYSQL_PORT || '3306', 10),
+            user: process.env.DB_USERNAME || 'root',
+            password: process.env.DB_PASSWORD || '',
+            database: process.env.DB_NAME || ''
+          }

-        console.log('[Extractor] Connecting to MySQL for order resolution...')
-        mysqlService = new MySqlService(mysqlConfig)
-        await mysqlService.connect()
+          log.info('Connecting to MySQL for order resolution...')
+          mysqlService = new MySqlService(mysqlConfig)

-        const resolver = new OrderNumberResolver(mysqlService)
-        const mappings = await resolver.resolve(input.orderNumbers)
-
-        // Get valid order numbers and warnings
-        const validOrderNumbers = resolver.getValidOrderNumbers(mappings)
-        const warnings = resolver.getWarnings(mappings)
-
-        if (warnings.length > 0) {
-          console.warn('[Extractor] Resolution warnings:', warnings)
-        }
-
-        if (validOrderNumbers.length === 0) {
-          throw new Error('没有有效的生产订单号可处理。请检查输入的格式或数据库连接。')
-        }
-
-        console.log('[Extractor] Resolved order numbers:', validOrderNumbers)
-
-        // Create auth service and login
-        authService = new ErpAuthService({
-          url: erpUrl,
-          username: erpUsername,
-          password: erpPassword,
-          headless: true
-        })
-
-        console.log('[Extractor] Logging in to ERP...')
-        await authService.login()
-        console.log('[Extractor] Login successful')
-
-        // Create extractor service and run extraction with resolved order numbers
-        const extractor = new ExtractorService(authService)
-        console.log('[Extractor] Starting extraction for orders:', validOrderNumbers)
-
-        const modifiedInput: ExtractorInput = {
-          ...input,
-          orderNumbers: validOrderNumbers
-        }
-
-        const result = await extractor.extract(modifiedInput)
-
-        // Add warnings to result errors if any
-        if (warnings.length > 0) {
-          result.errors = [...warnings, ...result.errors]
-        }
-
-        console.log('[Extractor] Extraction completed:', result)
-
-        return { success: true, data: result }
-      } catch (error) {
-        const message = error instanceof Error ? error.message : 'Unknown error'
-        console.error('[Extractor] Error:', message)
-        console.error('[Extractor] Stack:', error instanceof Error ? error.stack : 'N/A')
-        return { success: false, error: `提取失败：${message}` }
-      } finally {
-        // Clean up: close browser
-        if (authService) {
          try {
-            await authService.close()
-            console.log('[Extractor] Browser closed')
-          } catch (closeError) {
-            console.warn('[Extractor] Error closing browser:', closeError)
+            await mysqlService.connect()
+          } catch (error) {
+            throw new DatabaseQueryError(
+              'MySQL 连接失败',
+              'DB_CONNECTION_FAILED',
+              error instanceof Error ? error : undefined
+            )
+          }
+
+          const resolver = new OrderNumberResolver(mysqlService)
+          const mappings = await resolver.resolve(input.orderNumbers)
+
+          // Get valid order numbers and warnings
+          const validOrderNumbers = resolver.getValidOrderNumbers(mappings)
+          const warnings = resolver.getWarnings(mappings)
+
+          if (warnings.length > 0) {
+            log.warn('Resolution warnings', { warnings })
+          }
+
+          if (validOrderNumbers.length === 0) {
+            throw new ValidationError(
+              '没有有效的生产订单号可处理。请检查输入的格式或数据库连接。',
+              'VAL_INVALID_INPUT'
+            )
+          }
+
+          log.info('Resolved order numbers', { count: validOrderNumbers.length })
+
+          // Create auth service and login
+          authService = new ErpAuthService({
+            url: erpUrl,
+            username: erpUsername,
+            password: erpPassword,
+            headless: true
+          })
+
+          log.info('Logging in to ERP...')
+          try {
+            await authService.login()
+          } catch (error) {
+            throw new ErpConnectionError(
+              'ERP 登录失败',
+              'ERP_LOGIN_FAILED',
+              error instanceof Error ? error : undefined
+            )
+          }
+          log.info('Login successful')
+
+          // Create extractor service and run extraction with resolved order numbers
+          const extractor = new ExtractorService(authService)
+          log.info('Starting extraction', { orderCount: validOrderNumbers.length })
+
+          const modifiedInput: ExtractorInput = {
+            ...input,
+            orderNumbers: validOrderNumbers
+          }
+
+          const result = await extractor.extract(modifiedInput)
+
+          // Add warnings to result errors if any
+          if (warnings.length > 0) {
+            result.errors = [...warnings, ...result.errors]
+          }
+
+          log.info('Extraction completed', {
+            rowCount: result.recordCount,
+            errorCount: result.errors.length
+          })
+
+          return result
+        } finally {
+          // Clean up: close browser
+          if (authService) {
+            try {
+              await authService.close()
+              log.debug('Browser closed')
+            } catch (closeError) {
+              log.warn('Error closing browser', {
+                error: closeError instanceof Error ? closeError.message : String(closeError)
+              })
+            }
+          }
+
+          // Clean up: disconnect MySQL
+          if (mysqlService) {
+            try {
+              await mysqlService.disconnect()
+              log.debug('MySQL disconnected')
+            } catch (closeError) {
+              log.warn('Error disconnecting MySQL', {
+                error: closeError instanceof Error ? closeError.message : String(closeError)
+              })
+            }
          }
        }
-
-        // Clean up: disconnect MySQL
-        if (mysqlService) {
-          try {
-            await mysqlService.disconnect()
-            console.log('[Extractor] MySQL disconnected')
-          } catch (closeError) {
-            console.warn('[Extractor] Error disconnecting MySQL:', closeError)
-          }
-        }
-      }
+      }, 'extractor:run')
    }
  )
 }
--- a/src/main/ipc/file-handler.ts
+++ b/src/main/ipc/file-handler.ts
@@ -1,6 +1,9 @@
 import { ipcMain } from 'electron'
 import * as fs from 'fs/promises'
 import * as path from 'path'
+import { createLogger } from '../services/logger'
+
+const log = createLogger('FileHandler')

 /**
 * Register IPC handlers for file operations
@@ -9,9 +12,11 @@ export function registerFileHandlers(): void {
  // Read file content
  ipcMain.handle('file:read', async (_event, filePath: string): Promise<string> => {
    try {
+      log.debug('Reading file', { filePath })
      return await fs.readFile(filePath, 'utf-8')
    } catch (error) {
      const message = error instanceof Error ? error.message : 'Failed to read file'
+      log.error('Failed to read file', { filePath, error: message })
      throw new Error(message)
    }
  })
@@ -19,12 +24,14 @@ export function registerFileHandlers(): void {
  // Write content to file
  ipcMain.handle('file:write', async (_event, filePath: string, content: string): Promise<void> => {
    try {
+      log.debug('Writing file', { filePath })
      // Ensure directory exists
      const dir = path.dirname(filePath)
      await fs.mkdir(dir, { recursive: true })
      await fs.writeFile(filePath, content, 'utf-8')
    } catch (error) {
      const message = error instanceof Error ? error.message : 'Failed to write file'
+      log.error('Failed to write file', { filePath, error: message })
      throw new Error(message)
    }
  })
@@ -42,6 +49,7 @@ export function registerFileHandlers(): void {
  // List files in directory
  ipcMain.handle('file:list', async (_event, dirPath: string): Promise<string[]> => {
    try {
+      log.debug('Listing directory', { dirPath })
      const entries = await fs.readdir(dirPath, { withFileTypes: true })
      return entries
        .filter((entry) => entry.isFile())
@@ -49,6 +57,7 @@ export function registerFileHandlers(): void {
        .sort()
    } catch (error) {
      const message = error instanceof Error ? error.message : 'Failed to list directory'
+      log.error('Failed to list directory', { dirPath, error: message })
      throw new Error(message)
    }
  })
--- a/src/main/ipc/index.ts
+++ b/src/main/ipc/index.ts
@@ -11,11 +11,60 @@ import { registerResolverHandlers } from './resolver-handler'
 import { registerAuthHandlers } from './auth-handler'
 import { registerValidationHandlers } from './validation-handler'
 import { registerSettingsHandlers } from './settings-handler'
+import { createLogger } from '../services/logger'
+import { getErrorMessage, getErrorCode, isBaseError } from '../types/errors'
+
+const log = createLogger('IPC')
+
+/**
+ * Standard result type for all IPC handlers
+ */
+export interface IpcResult<T = unknown> {
+  success: boolean
+  data?: T
+  error?: string
+  code?: string
+}
+
+/**
+ * Higher-order function to wrap IPC handlers with consistent error handling
+ * @param handler - The async handler function to wrap
+ * @param context - The context name for logging
+ * @returns A wrapped handler that returns IpcResult
+ */
+export function withErrorHandling<T>(
+  handler: () => Promise<T>,
+  context: string
+): Promise<IpcResult<T>> {
+  return handler()
+    .then((data) => {
+      log.debug(`[${context}] Handler completed successfully`)
+      return { success: true, data }
+    })
+    .catch((error: unknown) => {
+      const message = getErrorMessage(error)
+      const code = getErrorCode(error)
+
+      if (isBaseError(error)) {
+        log.error(`[${context}] ${error.name}: ${message}`, { code, cause: error.cause?.message })
+      } else {
+        log.error(`[${context}] Error: ${message}`, { code })
+      }
+
+      // Include stack trace in development
+      if (process.env.NODE_ENV !== 'production' && error instanceof Error) {
+        log.debug(`[${context}] Stack trace:`, { stack: error.stack })
+      }
+
+      return { success: false, error: message, code }
+    })
+}

 /**
 * Register all IPC handlers
 */
 export function registerIpcHandlers(): void {
+  log.info('Registering IPC handlers...')
  registerFileHandlers()
  registerExtractorHandlers()
  registerCleanerHandlers()
@@ -24,4 +73,5 @@ export function registerIpcHandlers(): void {
  registerAuthHandlers()
  registerValidationHandlers()
  registerSettingsHandlers()
+  log.info('All IPC handlers registered')
 }
--- a/src/main/ipc/resolver-handler.ts
+++ b/src/main/ipc/resolver-handler.ts
@@ -9,8 +9,12 @@
 import { ipcMain } from 'electron'
 import { MySqlService } from '../services/database/mysql'
 import { OrderNumberResolver } from '../services/erp/order-resolver'
+import { createLogger } from '../services/logger'
+import { DatabaseQueryError } from '../types/errors'
 import type { OrderMapping, ResolutionStats } from '../services/erp/order-resolver'

+const log = createLogger('ResolverHandler')
+
 /**
 * Resolver input from renderer
 */
@@ -69,6 +73,7 @@ export function registerResolverHandlers(): void {
        }

        // Create MySQL service
+        log.info('Connecting to MySQL for resolution', { inputCount: input.inputs.length })
        mysqlService = new MySqlService(mysqlConfig)
        await mysqlService.connect()

@@ -81,6 +86,12 @@ export function registerResolverHandlers(): void {
        const warnings = resolver.getWarnings(mappings)
        const stats = resolver.getStats(mappings)

+        log.info('Resolution completed', {
+          inputCount: input.inputs.length,
+          validCount: validOrderNumbers.length,
+          warningCount: warnings.length
+        })
+
        return {
          success: true,
          mappings,
@@ -90,6 +101,7 @@ export function registerResolverHandlers(): void {
        }
      } catch (error) {
        const message = error instanceof Error ? error.message : 'Unknown error'
+        log.error('Resolution failed', { error: message })
        return {
          success: false,
          error: `解析失败：${message}`
@@ -99,8 +111,11 @@ export function registerResolverHandlers(): void {
        if (mysqlService) {
          try {
            await mysqlService.disconnect()
+            log.debug('MySQL disconnected')
          } catch (closeError) {
-            console.warn('[Resolver] Error disconnecting MySQL:', closeError)
+            log.warn('Error disconnecting MySQL', {
+              error: closeError instanceof Error ? closeError.message : String(closeError)
+            })
          }
        }
      }
@@ -112,7 +127,10 @@ export function registerResolverHandlers(): void {
   */
  ipcMain.handle(
    'resolver:validateFormat',
-    async (_event, inputs: string[]): Promise<{
+    async (
+      _event,
+      inputs: string[]
+    ): Promise<{
      success: boolean
      results?: Array<{ input: string; type: 'productionId' | 'orderNumber' | 'unknown' }>
      error?: string
@@ -122,14 +140,17 @@ export function registerResolverHandlers(): void {
          isConnected: () => false
        } as MySqlService)

-        const results = inputs.map(input => ({
+        const results = inputs.map((input) => ({
          input,
          type: resolver.recognizeType(input)
        }))

+        log.debug('Format validation completed', { inputCount: inputs.length })
+
        return { success: true, results }
      } catch (error) {
        const message = error instanceof Error ? error.message : 'Unknown error'
+        log.error('Format validation failed', { error: message })
        return {
          success: false,
          error: `验证失败：${message}`
--- a/src/main/ipc/settings-handler.ts
+++ b/src/main/ipc/settings-handler.ts
@@ -14,6 +14,7 @@ import { SessionManager } from '../services/user/session-manager'
 import { ErpAuthService } from '../services/erp/erp-auth'
 import { MySqlService } from '../services/database/mysql'
 import { SqlServerService } from '../services/database/sql-server'
+import { createLogger } from '../services/logger'
 import type {
  SettingsData,
  UserType,
@@ -21,14 +22,13 @@ import type {
  SaveSettingsResult
 } from '../types/settings.types'

+const log = createLogger('SettingsHandler')
+
 /**
 * Filter settings by user type
 * Admin users get all settings, User users get limited settings
 */
-function filterSettingsByUserType(
-  settings: SettingsData,
-  userType: UserType
-): SettingsData {
+function filterSettingsByUserType(settings: SettingsData, userType: UserType): SettingsData {
  if (userType === 'Admin') {
    return settings // Return all settings for Admin
  }
@@ -72,6 +72,7 @@ export function registerSettingsHandlers(): void {
   */
  ipcMain.handle('settings:getSettings', async (): Promise<SettingsData> => {
    const userType = (sessionManager.getUserType() as UserType) || 'Guest'
+    log.debug('Getting settings', { userType })
    const settings = configManager.getAllSettings()
    return filterSettingsByUserType(settings, userType)
  })
@@ -83,14 +84,18 @@ export function registerSettingsHandlers(): void {
    'settings:saveSettings',
    async (_event, settings: SettingsData): Promise<SaveSettingsResult> => {
      try {
+        log.info('Saving settings')
        const success = await configManager.saveAllSettings(settings)
        if (success) {
+          log.info('Settings saved successfully')
          return { success: true }
        } else {
+          log.warn('Failed to save settings')
          return { success: false, error: '保存设置失败' }
        }
      } catch (error) {
        const message = error instanceof Error ? error.message : 'Unknown error'
+        log.error('Error saving settings', { error: message })
        return { success: false, error: `保存设置失败：${message}` }
      }
    }
@@ -99,157 +104,166 @@ export function registerSettingsHandlers(): void {
  /**
   * Reset to default settings (Admin only)
   */
-  ipcMain.handle(
-    'settings:resetDefaults',
-    async (): Promise<SaveSettingsResult> => {
-      try {
-        const userType = sessionManager.getUserType()
-        if (userType !== 'Admin') {
-          return { success: false, error: '只有管理员可以恢复默认设置' }
-        }
-
-        configManager.resetToDefaults()
-        const success = await configManager.save()
-        if (success) {
-          return { success: true }
-        } else {
-          return { success: false, error: '恢复默认设置失败' }
-        }
-      } catch (error) {
-        const message = error instanceof Error ? error.message : 'Unknown error'
-        return { success: false, error: `恢复默认设置失败：${message}` }
+  ipcMain.handle('settings:resetDefaults', async (): Promise<SaveSettingsResult> => {
+    try {
+      const userType = sessionManager.getUserType()
+      if (userType !== 'Admin') {
+        log.warn('Non-admin user attempted to reset defaults', { userType })
+        return { success: false, error: '只有管理员可以恢复默认设置' }
      }
+
+      log.info('Resetting settings to defaults')
+      configManager.resetToDefaults()
+      const success = await configManager.save()
+      if (success) {
+        log.info('Settings reset to defaults successfully')
+        return { success: true }
+      } else {
+        log.warn('Failed to reset settings to defaults')
+        return { success: false, error: '恢复默认设置失败' }
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : 'Unknown error'
+      log.error('Error resetting settings', { error: message })
+      return { success: false, error: `恢复默认设置失败：${message}` }
    }
-  )
+  })

  /**
   * Test ERP connection
   */
-  ipcMain.handle(
-    'settings:testErpConnection',
-    async (): Promise<ConnectionTestResult> => {
-      try {
-        const settings = configManager.getAllSettings()
-        const erpConfig = settings.erp
+  ipcMain.handle('settings:testErpConnection', async (): Promise<ConnectionTestResult> => {
+    try {
+      log.info('Testing ERP connection')
+      const settings = configManager.getAllSettings()
+      const erpConfig = settings.erp

-        if (!erpConfig.url || !erpConfig.username || !erpConfig.password) {
-          return {
-            success: false,
-            message: '请先配置 ERP URL、用户名和密码'
-          }
-        }
-
-        // Create ERP auth service and try to login
-        const erpAuthService = new ErpAuthService(erpConfig)
-
-        try {
-          await erpAuthService.login()
-          // Login successful, close browser
-          await erpAuthService.close()
-          return {
-            success: true,
-            message: 'ERP 连接测试成功！'
-          }
-        } catch (loginError) {
-          const errorMessage = loginError instanceof Error ? loginError.message : '登录失败'
-          return {
-            success: false,
-            message: `ERP 连接测试失败：${errorMessage}`
-          }
-        }
-      } catch (error) {
-        const message = error instanceof Error ? error.message : 'Unknown error'
+      if (!erpConfig.url || !erpConfig.username || !erpConfig.password) {
+        log.warn('ERP connection test failed - missing configuration')
        return {
          success: false,
-          message: `ERP 连接测试失败：${message}`
+          message: '请先配置 ERP URL、用户名和密码'
        }
      }
+
+      // Create ERP auth service and try to login
+      const erpAuthService = new ErpAuthService(erpConfig)
+
+      try {
+        await erpAuthService.login()
+        // Login successful, close browser
+        await erpAuthService.close()
+        log.info('ERP connection test successful')
+        return {
+          success: true,
+          message: 'ERP 连接测试成功！'
+        }
+      } catch (loginError) {
+        const errorMessage = loginError instanceof Error ? loginError.message : '登录失败'
+        log.error('ERP login failed', { error: errorMessage })
+        return {
+          success: false,
+          message: `ERP 连接测试失败：${errorMessage}`
+        }
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : 'Unknown error'
+      log.error('ERP connection test error', { error: message })
+      return {
+        success: false,
+        message: `ERP 连接测试失败：${message}`
+      }
    }
-  )
+  })

  /**
   * Test database connection
   */
-  ipcMain.handle(
-    'settings:testDbConnection',
-    async (): Promise<ConnectionTestResult> => {
-      try {
-        const settings = configManager.getAllSettings()
-        const dbConfig = settings.database
+  ipcMain.handle('settings:testDbConnection', async (): Promise<ConnectionTestResult> => {
+    try {
+      log.info('Testing database connection')
+      const settings = configManager.getAllSettings()
+      const dbConfig = settings.database

-        if (dbConfig.dbType === 'mysql') {
-          // Test MySQL connection
-          if (!dbConfig.mysqlHost || !dbConfig.database || !dbConfig.username) {
-            return {
-              success: false,
-              message: '请先配置 MySQL 主机、数据库名和用户名'
-            }
-          }
-
-          const mysqlService = new MySqlService({
-            host: dbConfig.mysqlHost,
-            port: dbConfig.mysqlPort,
-            user: dbConfig.username,
-            password: dbConfig.password,
-            database: dbConfig.database
-          })
-
-          try {
-            await mysqlService.connect()
-            await mysqlService.disconnect()
-            return {
-              success: true,
-              message: 'MySQL 数据库连接测试成功！'
-            }
-          } catch (connError) {
-            const errorMessage = connError instanceof Error ? connError.message : '连接失败'
-            return {
-              success: false,
-              message: `MySQL 数据库连接测试失败：${errorMessage}`
-            }
-          }
-        } else {
-          // Test SQL Server connection
-          if (!dbConfig.server || !dbConfig.database || !dbConfig.username) {
-            return {
-              success: false,
-              message: '请先配置 SQL Server 服务器、数据库名和用户名'
-            }
-          }
-
-          const sqlServerService = new SqlServerService({
-            server: dbConfig.server,
-            port: 1433, // Default SQL Server port
-            user: dbConfig.username,
-            password: dbConfig.password,
-            database: dbConfig.database,
-            options: {
-              trustServerCertificate: true
-            }
-          })
-
-          try {
-            await sqlServerService.connect()
-            await sqlServerService.disconnect()
-            return {
-              success: true,
-              message: 'SQL Server 数据库连接测试成功！'
-            }
-          } catch (connError) {
-            const errorMessage = connError instanceof Error ? connError.message : '连接失败'
-            return {
-              success: false,
-              message: `SQL Server 数据库连接测试失败：${errorMessage}`
-            }
+      if (dbConfig.dbType === 'mysql') {
+        // Test MySQL connection
+        if (!dbConfig.mysqlHost || !dbConfig.database || !dbConfig.username) {
+          log.warn('MySQL connection test failed - missing configuration')
+          return {
+            success: false,
+            message: '请先配置 MySQL 主机、数据库名和用户名'
          }
        }
-      } catch (error) {
-        const message = error instanceof Error ? error.message : 'Unknown error'
-        return {
-          success: false,
-          message: `数据库连接测试失败：${message}`
+
+        const mysqlService = new MySqlService({
+          host: dbConfig.mysqlHost,
+          port: dbConfig.mysqlPort,
+          user: dbConfig.username,
+          password: dbConfig.password,
+          database: dbConfig.database
+        })
+
+        try {
+          await mysqlService.connect()
+          await mysqlService.disconnect()
+          log.info('MySQL connection test successful')
+          return {
+            success: true,
+            message: 'MySQL 数据库连接测试成功！'
+          }
+        } catch (connError) {
+          const errorMessage = connError instanceof Error ? connError.message : '连接失败'
+          log.error('MySQL connection failed', { error: errorMessage })
+          return {
+            success: false,
+            message: `MySQL 数据库连接测试失败：${errorMessage}`
+          }
+        }
+      } else {
+        // Test SQL Server connection
+        if (!dbConfig.server || !dbConfig.database || !dbConfig.username) {
+          log.warn('SQL Server connection test failed - missing configuration')
+          return {
+            success: false,
+            message: '请先配置 SQL Server 服务器、数据库名和用户名'
+          }
+        }
+
+        const sqlServerService = new SqlServerService({
+          server: dbConfig.server,
+          port: 1433, // Default SQL Server port
+          user: dbConfig.username,
+          password: dbConfig.password,
+          database: dbConfig.database,
+          options: {
+            trustServerCertificate: true
+          }
+        })
+
+        try {
+          await sqlServerService.connect()
+          await sqlServerService.disconnect()
+          log.info('SQL Server connection test successful')
+          return {
+            success: true,
+            message: 'SQL Server 数据库连接测试成功！'
+          }
+        } catch (connError) {
+          const errorMessage = connError instanceof Error ? connError.message : '连接失败'
+          log.error('SQL Server connection failed', { error: errorMessage })
+          return {
+            success: false,
+            message: `SQL Server 数据库连接测试失败：${errorMessage}`
+          }
        }
      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : 'Unknown error'
+      log.error('Database connection test error', { error: message })
+      return {
+        success: false,
+        message: `数据库连接测试失败：${message}`
+      }
    }
-  )
+  })
 }
--- a/src/main/ipc/validation-handler.ts
+++ b/src/main/ipc/validation-handler.ts
@@ -12,6 +12,7 @@ import { MySqlService } from '../services/database/mysql'
 import { SqlServerService } from '../services/database/sql-server'
 import { MaterialsToBeDeletedDAO } from '../services/database/materials-to-be-deleted-dao'
 import { DiscreteMaterialPlanDAO } from '../services/database/discrete-material-plan-dao'
+import { createLogger } from '../services/logger'
 import type {
  ValidationRequest,
  ValidationResponse,
@@ -22,6 +23,8 @@ import type {
  MaterialRecordSummary
 } from '../types/validation.types'

+const log = createLogger('ValidationHandler')
+
 /**
 * Shared state for Production IDs from extractor page
 * This is a simple in-memory store for sharing Production IDs between pages
@@ -32,7 +35,7 @@ const sharedProductionIds = new Set<string>()
 * Set shared Production IDs
 */
 export function setSharedProductionIds(ids: string[]): void {
-  ids.forEach(id => sharedProductionIds.add(id))
+  ids.forEach((id) => sharedProductionIds.add(id))
 }

 /**
@@ -110,11 +113,11 @@ function getTableName(mysqlTableName: string): string {
 */
 function readProductionIds(filePath: string): string[] {
  const fs = require('fs')
-  const content = fs.readFileSync(filePath, 'utf-8')
+  const content = fs.readFileSync(filePath, 'utf-8') as string
  return content
    .split('\n')
-    .map(line => line.trim())
-    .filter(line => line.length > 0)
+    .map((line: string) => line.trim())
+    .filter((line: string) => line.length > 0)
 }

 /**
@@ -173,10 +176,11 @@ async function getSourceNumbersFromInputs(
        FROM ${contractTableName}
        WHERE 总排号 IN (${placeholders})
      `
-      const contractResult = await (dbService as SqlServerService).queryWithParams(contractSql, params)
-      const dbOrderNumbers = contractResult.rows.map(
-        row => row.生产订单号 as string
+      const contractResult = await (dbService as SqlServerService).queryWithParams(
+        contractSql,
+        params
      )
+      const dbOrderNumbers = contractResult.rows.map((row) => row.生产订单号 as string)
      orderNumbers.push(...dbOrderNumbers)
    } else {
      const placeholders = productionIds.map(() => '?').join(',')
@@ -186,9 +190,7 @@ async function getSourceNumbersFromInputs(
        WHERE 总排号 IN (${placeholders})
      `
      const contractResult = await (dbService as MySqlService).query(contractSql, productionIds)
-      const dbOrderNumbers = contractResult.rows.map(
-        row => row.生产订单号 as string
-      )
+      const dbOrderNumbers = contractResult.rows.map((row) => row.生产订单号 as string)
      orderNumbers.push(...dbOrderNumbers)
    }
  }
@@ -208,14 +210,11 @@ export function registerValidationHandlers(): void {
   */
  ipcMain.handle(
    'validation:validate',
-    async (
-      _event,
-      request: ValidationRequest
-    ): Promise<ValidationResponse> => {
+    async (_event, request: ValidationRequest): Promise<ValidationResponse> => {
      let dbService: MySqlService | SqlServerService | null = null

      try {
-        console.log('[Validation] Starting validation:', request)
+        log.info('Starting validation', { mode: request.mode })

        // Connect to database
        dbService = await getValidationDatabaseService()
@@ -229,7 +228,7 @@ export function registerValidationHandlers(): void {
          if (request.useSharedProductionIds) {
            // Use shared Production IDs from extractor page
            const sharedIds = getSharedProductionIds()
-            console.log(`[Validation] Using ${sharedIds.length} shared Production IDs`)
+            log.info(`Using ${sharedIds.length} shared Production IDs`)

            if (sharedIds.length === 0) {
              return {
@@ -244,19 +243,13 @@ export function registerValidationHandlers(): void {
            }

            sourceNumbers = await getSourceNumbersFromInputs(sharedIds, dbService)
-            console.log(
-              `[Validation] Got ${sourceNumbers.length} source numbers from shared Production IDs`
-            )
+            log.info(`Got ${sourceNumbers.length} source numbers from shared Production IDs`)
          } else if (request.productionIdFile) {
            // Read from file
            const inputs = readProductionIds(request.productionIdFile)
-            console.log(
-              `[Validation] Read ${inputs.length} inputs from file`
-            )
+            log.info(`Read ${inputs.length} inputs from file`)
            sourceNumbers = await getSourceNumbersFromInputs(inputs, dbService)
-            console.log(
-              `[Validation] Got ${sourceNumbers.length} source numbers`
-            )
+            log.info(`Got ${sourceNumbers.length} source numbers`)
          }
        }

@@ -270,9 +263,7 @@ export function registerValidationHandlers(): void {
          materialRecords = await materialDao.queryAllDistinctByMaterialCode()
        } else if (sourceNumbers && sourceNumbers.length > 0) {
          // Filtered query by source numbers
-          materialRecords = await materialDao.queryBySourceNumbersDistinct(
-            sourceNumbers
-          )
+          materialRecords = await materialDao.queryBySourceNumbersDistinct(sourceNumbers)
        }

        if (materialRecords.length === 0) {
@@ -298,7 +289,7 @@ export function registerValidationHandlers(): void {
          ? await (dbService as SqlServerService).query(typeKeywordSql)
          : await (dbService as MySqlService).query(typeKeywordSql)

-        const typeKeywords = typeKeywordResult.rows.map(row => ({
+        const typeKeywords = typeKeywordResult.rows.map((row) => ({
          materialName: row.MaterialName as string,
          managerName: row.ManagerName as string
        }))
@@ -316,10 +307,7 @@ export function registerValidationHandlers(): void {

        const markedCodesDict = new Map<string, string>()
        for (const row of markedResult.rows) {
-          markedCodesDict.set(
-            row.MaterialCode as string,
-            row.ManagerName as string
-          )
+          markedCodesDict.set(row.MaterialCode as string, row.ManagerName as string)
        }

        // Match materials
@@ -338,10 +326,7 @@ export function registerValidationHandlers(): void {
          // Priority 2: Match with MaterialsTypeToBeDeleted (MaterialName contains)
          if (!managerName) {
            for (const typeKeyword of typeKeywords) {
-              if (
-                typeKeyword.materialName &&
-                materialName.includes(typeKeyword.materialName)
-              ) {
+              if (typeKeyword.materialName && materialName.includes(typeKeyword.materialName)) {
                matchedTypeKeyword = typeKeyword.materialName
                managerName = typeKeyword.managerName
                break
@@ -360,8 +345,8 @@ export function registerValidationHandlers(): void {
          })
        }

-        const markedCount = results.filter(r => r.isMarkedForDeletion).length
-        const matchedCount = results.filter(r => r.managerName).length
+        const markedCount = results.filter((r) => r.isMarkedForDeletion).length
+        const matchedCount = results.filter((r) => r.managerName).length

        return {
          success: true,
@@ -374,7 +359,9 @@ export function registerValidationHandlers(): void {
        }
      } catch (error) {
        const message = error instanceof Error ? error.message : 'Unknown error'
-        console.error('[Validation] Validation error:', error)
+        log.error('Validation error', {
+          error: error instanceof Error ? error.message : String(error)
+        })
        return {
          success: false,
          error: `Validation failed: ${message}`
@@ -384,7 +371,9 @@ export function registerValidationHandlers(): void {
          try {
            await dbService.disconnect()
          } catch (closeError) {
-            console.warn('[Validation] Error disconnecting database:', closeError)
+            log.warn('Error disconnecting database', {
+              error: closeError instanceof Error ? closeError.message : String(closeError)
+            })
          }
        }
      }
@@ -398,10 +387,7 @@ export function registerValidationHandlers(): void {
   */
  ipcMain.handle(
    'materials:upsertBatch',
-    async (
-      _event,
-      request: MaterialUpsertBatchRequest
-    ): Promise<MaterialOperationResponse> => {
+    async (_event, request: MaterialUpsertBatchRequest): Promise<MaterialOperationResponse> => {
      try {
        const dao = new MaterialsToBeDeletedDAO()
        const stats = await dao.upsertBatch(request.materials)
@@ -412,7 +398,9 @@ export function registerValidationHandlers(): void {
        }
      } catch (error) {
        const message = error instanceof Error ? error.message : 'Unknown error'
-        console.error('[Materials] Upsert batch error:', error)
+        log.error('Upsert batch error', {
+          error: error instanceof Error ? error.message : String(error)
+        })
        return {
          success: false,
          error: `Upsert failed: ${message}`
@@ -426,10 +414,7 @@ export function registerValidationHandlers(): void {
   */
  ipcMain.handle(
    'materials:delete',
-    async (
-      _event,
-      request: MaterialDeleteRequest
-    ): Promise<MaterialOperationResponse> => {
+    async (_event, request: MaterialDeleteRequest): Promise<MaterialOperationResponse> => {
      try {
        const dao = new MaterialsToBeDeletedDAO()
        const count = await dao.deleteByMaterialCodes(request.materialCodes)
@@ -440,7 +425,7 @@ export function registerValidationHandlers(): void {
        }
      } catch (error) {
        const message = error instanceof Error ? error.message : 'Unknown error'
-        console.error('[Materials] Delete error:', error)
+        log.error('Delete error', { error: error instanceof Error ? error.message : String(error) })
        return {
          success: false,
          error: `Delete failed: ${message}`
@@ -452,29 +437,25 @@ export function registerValidationHandlers(): void {
  /**
   * Get unique manager names
   */
-  ipcMain.handle(
-    'materials:getManagers',
-    async (_event): Promise<{ managers: string[] }> => {
-      try {
-        const dao = new MaterialsToBeDeletedDAO()
-        const managers = await dao.getManagers()
-        return { managers }
-      } catch (error) {
-        console.error('[Materials] Get managers error:', error)
-        return { managers: [] }
-      }
+  ipcMain.handle('materials:getManagers', async (_event): Promise<{ managers: string[] }> => {
+    try {
+      const dao = new MaterialsToBeDeletedDAO()
+      const managers = await dao.getManagers()
+      return { managers }
+    } catch (error) {
+      log.error('Get managers error', {
+        error: error instanceof Error ? error.message : String(error)
+      })
+      return { managers: [] }
    }
-  )
+  })

  /**
   * Get materials by manager
   */
  ipcMain.handle(
    'materials:getByManager',
-    async (
-      _event,
-      managerName: string
-    ): Promise<{ materials: MaterialRecordSummary[] }> => {
+    async (_event, managerName: string): Promise<{ materials: MaterialRecordSummary[] }> => {
      let dbService: MySqlService | SqlServerService | null = null

      try {
@@ -512,25 +493,16 @@ export function registerValidationHandlers(): void {
              WHERE MaterialCode = ?
              LIMIT 1
            `
-            detailResult = await (dbService as MySqlService).query(detailSql, [
-              mat.materialCode
-            ])
+            detailResult = await (dbService as MySqlService).query(detailSql, [mat.materialCode])
          }

          enrichedMaterials.push({
            materialCode: mat.materialCode,
            materialName:
-              detailResult.rows.length > 0
-                ? (detailResult.rows[0].MaterialName as string)
-                : '',
+              detailResult.rows.length > 0 ? (detailResult.rows[0].MaterialName as string) : '',
            specification:
-              detailResult.rows.length > 0
-                ? (detailResult.rows[0].Specification as string)
-                : '',
-            model:
-              detailResult.rows.length > 0
-                ? (detailResult.rows[0].Model as string)
-                : '',
+              detailResult.rows.length > 0 ? (detailResult.rows[0].Specification as string) : '',
+            model: detailResult.rows.length > 0 ? (detailResult.rows[0].Model as string) : '',
            managerName: mat.managerName,
            isMarked: markedCodes.has(mat.materialCode)
          })
@@ -538,14 +510,18 @@ export function registerValidationHandlers(): void {

        return { materials: enrichedMaterials }
      } catch (error) {
-        console.error('[Materials] Get by manager error:', error)
+        log.error('Get by manager error', {
+          error: error instanceof Error ? error.message : String(error)
+        })
        return { materials: [] }
      } finally {
        if (dbService) {
          try {
            await dbService.disconnect()
          } catch (closeError) {
-            console.warn('[Materials] Error disconnecting database:', closeError)
+            log.warn('Error disconnecting database', {
+              error: closeError instanceof Error ? closeError.message : String(closeError)
+            })
          }
        }
      }
@@ -592,25 +568,16 @@ export function registerValidationHandlers(): void {
              WHERE MaterialCode = ?
              LIMIT 1
            `
-            detailResult = await (dbService as MySqlService).query(detailSql, [
-              mat.materialCode
-            ])
+            detailResult = await (dbService as MySqlService).query(detailSql, [mat.materialCode])
          }

          enrichedMaterials.push({
            materialCode: mat.materialCode,
            materialName:
-              detailResult.rows.length > 0
-                ? (detailResult.rows[0].MaterialName as string)
-                : '',
+              detailResult.rows.length > 0 ? (detailResult.rows[0].MaterialName as string) : '',
            specification:
-              detailResult.rows.length > 0
-                ? (detailResult.rows[0].Specification as string)
-                : '',
-            model:
-              detailResult.rows.length > 0
-                ? (detailResult.rows[0].Model as string)
-                : '',
+              detailResult.rows.length > 0 ? (detailResult.rows[0].Specification as string) : '',
+            model: detailResult.rows.length > 0 ? (detailResult.rows[0].Model as string) : '',
            managerName: mat.managerName,
            isMarked: markedCodes.has(mat.materialCode)
          })
@@ -618,14 +585,18 @@ export function registerValidationHandlers(): void {

        return { materials: enrichedMaterials }
      } catch (error) {
-        console.error('[Materials] Get all error:', error)
+        log.error('Get all error', {
+          error: error instanceof Error ? error.message : String(error)
+        })
        return { materials: [] }
      } finally {
        if (dbService) {
          try {
            await dbService.disconnect()
          } catch (closeError) {
-            console.warn('[Materials] Error disconnecting database:', closeError)
+            log.warn('Error disconnecting database', {
+              error: closeError instanceof Error ? closeError.message : String(closeError)
+            })
          }
        }
      }
@@ -635,19 +606,18 @@ export function registerValidationHandlers(): void {
  /**
   * Get statistics
   */
-  ipcMain.handle(
-    'materials:getStatistics',
-    async (_event): Promise<{ stats: any }> => {
-      try {
-        const dao = new MaterialsToBeDeletedDAO()
-        const stats = await dao.getStatistics()
-        return { stats }
-      } catch (error) {
-        console.error('[Materials] Get statistics error:', error)
-        return { stats: null }
-      }
+  ipcMain.handle('materials:getStatistics', async (_event): Promise<{ stats: any }> => {
+    try {
+      const dao = new MaterialsToBeDeletedDAO()
+      const stats = await dao.getStatistics()
+      return { stats }
+    } catch (error) {
+      log.error('Get statistics error', {
+        error: error instanceof Error ? error.message : String(error)
+      })
+      return { stats: null }
    }
-  )
+  })

  /**
   * Set shared Production IDs from extractor page
@@ -655,7 +625,7 @@ export function registerValidationHandlers(): void {
  ipcMain.handle(
    'validation:setSharedProductionIds',
    async (_event, productionIds: string[]): Promise<void> => {
-      console.log(`[Validation] Received ${productionIds.length} shared Production IDs`)
+      log.info(`Received ${productionIds.length} shared Production IDs`)
      setSharedProductionIds(productionIds)
    }
  )
@@ -676,14 +646,18 @@ export function registerValidationHandlers(): void {
   */
  ipcMain.handle(
    'validation:getCleanerData',
-    async (_event): Promise<{
+    async (
+      _event
+    ): Promise<{
      success: boolean
      orderNumbers?: string[]
      materialCodes?: string[]
      error?: string
    }> => {
      let dbService: MySqlService | SqlServerService | null = null
-      const sessionManager = (await import('../services/user/session-manager')).SessionManager.getInstance()
+      const sessionManager = (
+        await import('../services/user/session-manager')
+      ).SessionManager.getInstance()

      try {
        // Get current user
@@ -700,7 +674,7 @@ export function registerValidationHandlers(): void {
        const dbType = process.env.DB_TYPE?.toLowerCase()
        const isSqlServer = dbType === 'sqlserver' || dbType === 'mssql'

-        console.log(`[CleanerData] User: ${username}, isAdmin: ${isAdmin}`)
+        log.info(`User: ${username}, isAdmin: ${isAdmin}`)

        // Connect to database
        dbService = await getValidationDatabaseService()
@@ -710,9 +684,9 @@ export function registerValidationHandlers(): void {
        let orderNumbers: string[] = []

        if (sharedIds.length > 0) {
-          console.log(`[CleanerData] Using ${sharedIds.length} shared Production IDs`)
+          log.info(`Using ${sharedIds.length} shared Production IDs`)
          orderNumbers = await getSourceNumbersFromInputs(sharedIds, dbService)
-          console.log(`[CleanerData] Got ${orderNumbers.length} order numbers`)
+          log.info(`Got ${orderNumbers.length} order numbers`)
        }

        // 2. Get material codes from MaterialsToBeDeleted table
@@ -730,10 +704,8 @@ export function registerValidationHandlers(): void {
            ? await (dbService as SqlServerService).query(allCodesSql)
            : await (dbService as MySqlService).query(allCodesSql)

-          materialCodes = result.rows
-            .map(row => row.MaterialCode as string)
-            .filter(Boolean)
-          console.log(`[CleanerData] Admin user: got ${materialCodes.length} materials`)
+          materialCodes = result.rows.map((row) => row.MaterialCode as string).filter(Boolean)
+          log.info(`Admin user: got ${materialCodes.length} materials`)
        } else {
          // Regular users only see their own materials
          if (isSqlServer) {
@@ -746,9 +718,7 @@ export function registerValidationHandlers(): void {
            const result = await (dbService as SqlServerService).queryWithParams(userMaterialsSql, {
              username: { value: username, type: sql.NVarChar }
            })
-            materialCodes = result.rows
-              .map(row => row.MaterialCode as string)
-              .filter(Boolean)
+            materialCodes = result.rows.map((row) => row.MaterialCode as string).filter(Boolean)
          } else {
            const userMaterialsSql = `
              SELECT MaterialCode
@@ -756,11 +726,9 @@ export function registerValidationHandlers(): void {
              WHERE ManagerName = ? AND MaterialCode IS NOT NULL
            `
            const result = await (dbService as MySqlService).query(userMaterialsSql, [username])
-            materialCodes = result.rows
-              .map(row => row.MaterialCode as string)
-              .filter(Boolean)
+            materialCodes = result.rows.map((row) => row.MaterialCode as string).filter(Boolean)
          }
-          console.log(`[CleanerData] Regular user: got ${materialCodes.length} materials`)
+          log.info(`Regular user: got ${materialCodes.length} materials`)
        }

        return {
@@ -770,7 +738,9 @@ export function registerValidationHandlers(): void {
        }
      } catch (error) {
        const message = error instanceof Error ? error.message : 'Unknown error'
-        console.error('[CleanerData] Error:', error)
+        log.error('CleanerData error', {
+          error: error instanceof Error ? error.message : String(error)
+        })
        return {
          success: false,
          error: `获取清理数据失败：${message}`
@@ -780,7 +750,9 @@ export function registerValidationHandlers(): void {
          try {
            await dbService.disconnect()
          } catch (closeError) {
-            console.warn('[CleanerData] Error disconnecting database:', closeError)
+            log.warn('Error disconnecting database', {
+              error: closeError instanceof Error ? closeError.message : String(closeError)
+            })
          }
        }
      }
--- a/src/main/schemas/auth.schema.ts
+++ b/src/main/schemas/auth.schema.ts
@@ -0,0 +1,45 @@
+/**
+ * Zod schemas for Authentication module validation
+ */
+
+import { z } from 'zod'
+
+/**
+ * Schema for login request validation
+ */
+export const LoginRequestSchema = z.object({
+  username: z.string().min(1, 'Username is required'),
+  password: z.string().min(1, 'Password is required')
+})
+
+export type LoginRequestZod = z.infer<typeof LoginRequestSchema>
+
+/**
+ * Schema for user info validation
+ */
+export const UserInfoSchema = z.object({
+  id: z.number().int().positive(),
+  username: z.string().min(1),
+  userType: z.enum(['Admin', 'User', 'Guest']),
+  computerName: z.string().optional()
+})
+
+export type UserInfoZod = z.infer<typeof UserInfoSchema>
+
+/**
+ * Validate login request
+ */
+export function validateLoginRequest(input: unknown): {
+  success: boolean
+  data?: LoginRequestZod
+  error?: string
+} {
+  const result = LoginRequestSchema.safeParse(input)
+  if (result.success) {
+    return { success: true, data: result.data }
+  }
+  return {
+    success: false,
+    error: result.error.issues.map((e) => `${e.path.join('.')}: ${e.message}`).join('; ')
+  }
+}
--- a/src/main/schemas/cleaner.schema.ts
+++ b/src/main/schemas/cleaner.schema.ts
@@ -0,0 +1,47 @@
+/**
+ * Zod schemas for Cleaner module validation
+ */
+
+import { z } from 'zod'
+
+/**
+ * Schema for cleaner input validation
+ */
+export const CleanerInputSchema = z.object({
+  orderNumbers: z
+    .array(z.string().min(1, 'Order number cannot be empty'))
+    .min(1, 'At least one order number is required'),
+  materialCodes: z.array(z.string().min(1, 'Material code cannot be empty')),
+  dryRun: z.boolean()
+  // Note: onProgress is a function, not validated via Zod
+})
+
+export type CleanerInputZod = z.infer<typeof CleanerInputSchema>
+
+/**
+ * Schema for cleaner result validation
+ */
+export const CleanerResultSchema = z.object({
+  processedCount: z.number().int().nonnegative(),
+  errors: z.array(z.string())
+})
+
+export type CleanerResultZod = z.infer<typeof CleanerResultSchema>
+
+/**
+ * Validate cleaner input
+ */
+export function validateCleanerInput(input: unknown): {
+  success: boolean
+  data?: CleanerInputZod
+  error?: string
+} {
+  const result = CleanerInputSchema.safeParse(input)
+  if (result.success) {
+    return { success: true, data: result.data }
+  }
+  return {
+    success: false,
+    error: result.error.issues.map((e) => `${e.path.join('.')}: ${e.message}`).join('; ')
+  }
+}
--- a/src/main/schemas/extractor.schema.ts
+++ b/src/main/schemas/extractor.schema.ts
@@ -0,0 +1,46 @@
+/**
+ * Zod schemas for Extractor module validation
+ */
+
+import { z } from 'zod'
+
+/**
+ * Schema for extractor input validation
+ */
+export const ExtractorInputSchema = z.object({
+  orderNumbers: z
+    .array(z.string().min(1, 'Order number cannot be empty'))
+    .min(1, 'At least one order number is required'),
+  batchSize: z.number().int().positive().optional().default(10)
+  // Note: onProgress is a function, not validated via Zod
+})
+
+export type ExtractorInputZod = z.infer<typeof ExtractorInputSchema>
+
+/**
+ * Schema for extractor result validation
+ */
+export const ExtractorResultSchema = z.object({
+  data: z.array(z.record(z.string(), z.unknown())),
+  errors: z.array(z.string())
+})
+
+export type ExtractorResultZod = z.infer<typeof ExtractorResultSchema>
+
+/**
+ * Validate extractor input
+ */
+export function validateExtractorInput(input: unknown): {
+  success: boolean
+  data?: ExtractorInputZod
+  error?: string
+} {
+  const result = ExtractorInputSchema.safeParse(input)
+  if (result.success) {
+    return { success: true, data: result.data }
+  }
+  return {
+    success: false,
+    error: result.error.issues.map((e) => `${e.path.join('.')}: ${e.message}`).join('; ')
+  }
+}
--- a/src/main/services/config/config-manager.ts
+++ b/src/main/services/config/config-manager.ts
@@ -186,11 +186,21 @@ export class ConfigManager {
      lines.push('# ERP 系统配置')
      lines.push('# ===========================')
      lines.push(`ERP_URL=${this.configCache.get('erp.url') || DEFAULT_SETTINGS.erp.url}`)
-      lines.push(`ERP_USERNAME=${this.configCache.get('erp.username') || DEFAULT_SETTINGS.erp.username}`)
-      lines.push(`ERP_PASSWORD=${this.configCache.get('erp.password') || DEFAULT_SETTINGS.erp.password}`)
-      lines.push(`ERP_HEADLESS=${this.configCache.get('erp.headless') || DEFAULT_SETTINGS.erp.headless}`)
-      lines.push(`ERP_IGNORE_HTTPS_ERRORS=${this.configCache.get('erp.ignoreHttpsErrors') || DEFAULT_SETTINGS.erp.ignoreHttpsErrors}`)
-      lines.push(`ERP_AUTO_CLOSE_BROWSER=${this.configCache.get('erp.autoCloseBrowser') || DEFAULT_SETTINGS.erp.autoCloseBrowser}`)
+      lines.push(
+        `ERP_USERNAME=${this.configCache.get('erp.username') || DEFAULT_SETTINGS.erp.username}`
+      )
+      lines.push(
+        `ERP_PASSWORD=${this.configCache.get('erp.password') || DEFAULT_SETTINGS.erp.password}`
+      )
+      lines.push(
+        `ERP_HEADLESS=${this.configCache.get('erp.headless') || DEFAULT_SETTINGS.erp.headless}`
+      )
+      lines.push(
+        `ERP_IGNORE_HTTPS_ERRORS=${this.configCache.get('erp.ignoreHttpsErrors') || DEFAULT_SETTINGS.erp.ignoreHttpsErrors}`
+      )
+      lines.push(
+        `ERP_AUTO_CLOSE_BROWSER=${this.configCache.get('erp.autoCloseBrowser') || DEFAULT_SETTINGS.erp.autoCloseBrowser}`
+      )
      lines.push('')

      // Database Configuration - SQL Server
@@ -210,12 +220,24 @@ export class ConfigManager {
      lines.push('# ===========================')
      lines.push('# 数据库配置 - MySQL (切换时使用)')
      lines.push('# ===========================')
-      lines.push(`DB_TYPE=${this.configCache.get('database.dbType') || DEFAULT_SETTINGS.database.dbType}`)
-      lines.push(`DB_NAME=${this.configCache.get('database.database') || DEFAULT_SETTINGS.database.database}`)
-      lines.push(`DB_USERNAME=${this.configCache.get('database.username') || DEFAULT_SETTINGS.database.username}`)
-      lines.push(`DB_PASSWORD=${this.configCache.get('database.password') || DEFAULT_SETTINGS.database.password}`)
-      lines.push(`DB_MYSQL_HOST=${this.configCache.get('database.mysqlHost') || DEFAULT_SETTINGS.database.mysqlHost}`)
-      lines.push(`DB_MYSQL_PORT=${this.configCache.get('database.mysqlPort') || DEFAULT_SETTINGS.database.mysqlPort}`)
+      lines.push(
+        `DB_TYPE=${this.configCache.get('database.dbType') || DEFAULT_SETTINGS.database.dbType}`
+      )
+      lines.push(
+        `DB_NAME=${this.configCache.get('database.database') || DEFAULT_SETTINGS.database.database}`
+      )
+      lines.push(
+        `DB_USERNAME=${this.configCache.get('database.username') || DEFAULT_SETTINGS.database.username}`
+      )
+      lines.push(
+        `DB_PASSWORD=${this.configCache.get('database.password') || DEFAULT_SETTINGS.database.password}`
+      )
+      lines.push(
+        `DB_MYSQL_HOST=${this.configCache.get('database.mysqlHost') || DEFAULT_SETTINGS.database.mysqlHost}`
+      )
+      lines.push(
+        `DB_MYSQL_PORT=${this.configCache.get('database.mysqlPort') || DEFAULT_SETTINGS.database.mysqlPort}`
+      )
      lines.push(`DB_MYSQL_CHARSET=utf8mb4`)
      lines.push('')

@@ -233,49 +255,85 @@ export class ConfigManager {
      lines.push('# ===========================')
      lines.push('# 路径配置')
      lines.push('# ===========================')
-      lines.push(`PATH_DATA_DIR=${this.configCache.get('paths.dataDir') || DEFAULT_SETTINGS.paths.dataDir}`)
+      lines.push(
+        `PATH_DATA_DIR=${this.configCache.get('paths.dataDir') || DEFAULT_SETTINGS.paths.dataDir}`
+      )
      lines.push(`PATH_PRODUCTION_ID_FILE=ProductionID.txt`)
-      lines.push(`PATH_DEFAULT_OUTPUT=${this.configCache.get('paths.defaultOutput') || DEFAULT_SETTINGS.paths.defaultOutput}`)
-      lines.push(`PATH_VALIDATION_OUTPUT=${this.configCache.get('paths.validationOutput') || DEFAULT_SETTINGS.paths.validationOutput}`)
+      lines.push(
+        `PATH_DEFAULT_OUTPUT=${this.configCache.get('paths.defaultOutput') || DEFAULT_SETTINGS.paths.defaultOutput}`
+      )
+      lines.push(
+        `PATH_VALIDATION_OUTPUT=${this.configCache.get('paths.validationOutput') || DEFAULT_SETTINGS.paths.validationOutput}`
+      )
      lines.push('')

      // Data Extraction Configuration
      lines.push('# ===========================')
      lines.push('# 数据提取配置')
      lines.push('# ===========================')
-      lines.push(`EXTRACTION_BATCH_SIZE=${this.configCache.get('extraction.batchSize') || DEFAULT_SETTINGS.extraction.batchSize}`)
-      lines.push(`EXTRACTION_VERBOSE=${this.configCache.get('extraction.verbose') || DEFAULT_SETTINGS.extraction.verbose}`)
-      lines.push(`EXTRACTION_AUTO_CONVERT=${this.configCache.get('extraction.autoConvert') || DEFAULT_SETTINGS.extraction.autoConvert}`)
-      lines.push(`EXTRACTION_MERGE_BATCHES=${this.configCache.get('extraction.mergeBatches') || DEFAULT_SETTINGS.extraction.mergeBatches}`)
-      lines.push(`EXTRACTION_ENABLE_DB_PERSISTENCE=${this.configCache.get('extraction.enableDbPersistence') || DEFAULT_SETTINGS.extraction.enableDbPersistence}`)
+      lines.push(
+        `EXTRACTION_BATCH_SIZE=${this.configCache.get('extraction.batchSize') || DEFAULT_SETTINGS.extraction.batchSize}`
+      )
+      lines.push(
+        `EXTRACTION_VERBOSE=${this.configCache.get('extraction.verbose') || DEFAULT_SETTINGS.extraction.verbose}`
+      )
+      lines.push(
+        `EXTRACTION_AUTO_CONVERT=${this.configCache.get('extraction.autoConvert') || DEFAULT_SETTINGS.extraction.autoConvert}`
+      )
+      lines.push(
+        `EXTRACTION_MERGE_BATCHES=${this.configCache.get('extraction.mergeBatches') || DEFAULT_SETTINGS.extraction.mergeBatches}`
+      )
+      lines.push(
+        `EXTRACTION_ENABLE_DB_PERSISTENCE=${this.configCache.get('extraction.enableDbPersistence') || DEFAULT_SETTINGS.extraction.enableDbPersistence}`
+      )
      lines.push('')

      // Validation Configuration
      lines.push('# ===========================')
      lines.push('# 校验配置')
      lines.push('# ===========================')
-      lines.push(`VALIDATION_DATA_SOURCE=${this.configCache.get('validation.dataSource') || DEFAULT_SETTINGS.validation.dataSource}`)
-      lines.push(`VALIDATION_USE_DATABASE=${this.configCache.get('validation.useDatabase') || true}`)
-      lines.push(`VALIDATION_BATCH_SIZE=${this.configCache.get('validation.batchSize') || DEFAULT_SETTINGS.validation.batchSize}`)
-      lines.push(`VALIDATION_ENABLE_CRUD=${this.configCache.get('validation.enableCrud') || DEFAULT_SETTINGS.validation.enableCrud}`)
-      lines.push(`VALIDATION_DEFAULT_MANAGER=${this.configCache.get('validation.defaultManager') || DEFAULT_SETTINGS.validation.defaultManager}`)
-      lines.push(`VALIDATION_MATCH_MODE=${this.configCache.get('validation.matchMode') || DEFAULT_SETTINGS.validation.matchMode}`)
+      lines.push(
+        `VALIDATION_DATA_SOURCE=${this.configCache.get('validation.dataSource') || DEFAULT_SETTINGS.validation.dataSource}`
+      )
+      lines.push(
+        `VALIDATION_USE_DATABASE=${this.configCache.get('validation.useDatabase') || true}`
+      )
+      lines.push(
+        `VALIDATION_BATCH_SIZE=${this.configCache.get('validation.batchSize') || DEFAULT_SETTINGS.validation.batchSize}`
+      )
+      lines.push(
+        `VALIDATION_ENABLE_CRUD=${this.configCache.get('validation.enableCrud') || DEFAULT_SETTINGS.validation.enableCrud}`
+      )
+      lines.push(
+        `VALIDATION_DEFAULT_MANAGER=${this.configCache.get('validation.defaultManager') || DEFAULT_SETTINGS.validation.defaultManager}`
+      )
+      lines.push(
+        `VALIDATION_MATCH_MODE=${this.configCache.get('validation.matchMode') || DEFAULT_SETTINGS.validation.matchMode}`
+      )
      lines.push('')

      // UI Configuration
      lines.push('# ===========================')
      lines.push('# UI 配置')
      lines.push('# ===========================')
-      lines.push(`UI_FONT_FAMILY=${this.configCache.get('ui.fontFamily') || DEFAULT_SETTINGS.ui.fontFamily}`)
-      lines.push(`UI_FONT_SIZE=${this.configCache.get('ui.fontSize') || DEFAULT_SETTINGS.ui.fontSize}`)
-      lines.push(`UI_PRODUCTION_ID_INPUT_WIDTH=${this.configCache.get('ui.productionIdInputWidth') || DEFAULT_SETTINGS.ui.productionIdInputWidth}`)
+      lines.push(
+        `UI_FONT_FAMILY=${this.configCache.get('ui.fontFamily') || DEFAULT_SETTINGS.ui.fontFamily}`
+      )
+      lines.push(
+        `UI_FONT_SIZE=${this.configCache.get('ui.fontSize') || DEFAULT_SETTINGS.ui.fontSize}`
+      )
+      lines.push(
+        `UI_PRODUCTION_ID_INPUT_WIDTH=${this.configCache.get('ui.productionIdInputWidth') || DEFAULT_SETTINGS.ui.productionIdInputWidth}`
+      )
      lines.push('')

      // Execution Configuration
      lines.push('# ===========================')
      lines.push('# 执行配置')
      lines.push('# ===========================')
-      lines.push(`EXECUTION_DRYRUN=${this.configCache.get('execution.dryRun') || DEFAULT_SETTINGS.execution.dryRun}`)
+      lines.push(
+        `EXECUTION_DRYRUN=${this.configCache.get('execution.dryRun') || DEFAULT_SETTINGS.execution.dryRun}`
+      )

      const content = lines.join('\n')
      fs.writeFileSync(this.envPath, content, 'utf-8')
@@ -296,11 +354,19 @@ export class ConfigManager {
        username: this.get('ERP_USERNAME', DEFAULT_SETTINGS.erp.username),
        password: this.get('ERP_PASSWORD', DEFAULT_SETTINGS.erp.password),
        headless: this.getBoolean('ERP_HEADLESS', DEFAULT_SETTINGS.erp.headless),
-        ignoreHttpsErrors: this.getBoolean('ERP_IGNORE_HTTPS_ERRORS', DEFAULT_SETTINGS.erp.ignoreHttpsErrors),
-        autoCloseBrowser: this.getBoolean('ERP_AUTO_CLOSE_BROWSER', DEFAULT_SETTINGS.erp.autoCloseBrowser)
+        ignoreHttpsErrors: this.getBoolean(
+          'ERP_IGNORE_HTTPS_ERRORS',
+          DEFAULT_SETTINGS.erp.ignoreHttpsErrors
+        ),
+        autoCloseBrowser: this.getBoolean(
+          'ERP_AUTO_CLOSE_BROWSER',
+          DEFAULT_SETTINGS.erp.autoCloseBrowser
+        )
      },
      database: {
-        dbType: (this.get('DB_TYPE', DEFAULT_SETTINGS.database.dbType) as DatabaseType) || DEFAULT_SETTINGS.database.dbType,
+        dbType:
+          (this.get('DB_TYPE', DEFAULT_SETTINGS.database.dbType) as DatabaseType) ||
+          DEFAULT_SETTINGS.database.dbType,
        server: this.get('DB_SERVER', DEFAULT_SETTINGS.database.server),
        mysqlHost: this.get('DB_MYSQL_HOST', DEFAULT_SETTINGS.database.mysqlHost),
        mysqlPort: this.getNumber('DB_MYSQL_PORT', DEFAULT_SETTINGS.database.mysqlPort),
@@ -311,26 +377,53 @@ export class ConfigManager {
      paths: {
        dataDir: this.get('PATH_DATA_DIR', DEFAULT_SETTINGS.paths.dataDir),
        defaultOutput: this.get('PATH_DEFAULT_OUTPUT', DEFAULT_SETTINGS.paths.defaultOutput),
-        validationOutput: this.get('PATH_VALIDATION_OUTPUT', DEFAULT_SETTINGS.paths.validationOutput)
+        validationOutput: this.get(
+          'PATH_VALIDATION_OUTPUT',
+          DEFAULT_SETTINGS.paths.validationOutput
+        )
      },
      extraction: {
        batchSize: this.getNumber('EXTRACTION_BATCH_SIZE', DEFAULT_SETTINGS.extraction.batchSize),
        verbose: this.getBoolean('EXTRACTION_VERBOSE', DEFAULT_SETTINGS.extraction.verbose),
-        autoConvert: this.getBoolean('EXTRACTION_AUTO_CONVERT', DEFAULT_SETTINGS.extraction.autoConvert),
-        mergeBatches: this.getBoolean('EXTRACTION_MERGE_BATCHES', DEFAULT_SETTINGS.extraction.mergeBatches),
-        enableDbPersistence: this.getBoolean('EXTRACTION_ENABLE_DB_PERSISTENCE', DEFAULT_SETTINGS.extraction.enableDbPersistence)
+        autoConvert: this.getBoolean(
+          'EXTRACTION_AUTO_CONVERT',
+          DEFAULT_SETTINGS.extraction.autoConvert
+        ),
+        mergeBatches: this.getBoolean(
+          'EXTRACTION_MERGE_BATCHES',
+          DEFAULT_SETTINGS.extraction.mergeBatches
+        ),
+        enableDbPersistence: this.getBoolean(
+          'EXTRACTION_ENABLE_DB_PERSISTENCE',
+          DEFAULT_SETTINGS.extraction.enableDbPersistence
+        )
      },
      validation: {
-        dataSource: (this.get('VALIDATION_DATA_SOURCE', DEFAULT_SETTINGS.validation.dataSource) as ValidationDataSource) || DEFAULT_SETTINGS.validation.dataSource,
+        dataSource:
+          (this.get(
+            'VALIDATION_DATA_SOURCE',
+            DEFAULT_SETTINGS.validation.dataSource
+          ) as ValidationDataSource) || DEFAULT_SETTINGS.validation.dataSource,
        batchSize: this.getNumber('VALIDATION_BATCH_SIZE', DEFAULT_SETTINGS.validation.batchSize),
-        matchMode: (this.get('VALIDATION_MATCH_MODE', DEFAULT_SETTINGS.validation.matchMode) as MatchMode) || DEFAULT_SETTINGS.validation.matchMode,
-        enableCrud: this.getBoolean('VALIDATION_ENABLE_CRUD', DEFAULT_SETTINGS.validation.enableCrud),
-        defaultManager: this.get('VALIDATION_DEFAULT_MANAGER', DEFAULT_SETTINGS.validation.defaultManager)
+        matchMode:
+          (this.get('VALIDATION_MATCH_MODE', DEFAULT_SETTINGS.validation.matchMode) as MatchMode) ||
+          DEFAULT_SETTINGS.validation.matchMode,
+        enableCrud: this.getBoolean(
+          'VALIDATION_ENABLE_CRUD',
+          DEFAULT_SETTINGS.validation.enableCrud
+        ),
+        defaultManager: this.get(
+          'VALIDATION_DEFAULT_MANAGER',
+          DEFAULT_SETTINGS.validation.defaultManager
+        )
      },
      ui: {
        fontFamily: this.get('UI_FONT_FAMILY', DEFAULT_SETTINGS.ui.fontFamily),
        fontSize: this.getNumber('UI_FONT_SIZE', DEFAULT_SETTINGS.ui.fontSize),
-        productionIdInputWidth: this.getNumber('UI_PRODUCTION_ID_INPUT_WIDTH', DEFAULT_SETTINGS.ui.productionIdInputWidth)
+        productionIdInputWidth: this.getNumber(
+          'UI_PRODUCTION_ID_INPUT_WIDTH',
+          DEFAULT_SETTINGS.ui.productionIdInputWidth
+        )
      },
      execution: {
        dryRun: this.getBoolean('EXECUTION_DRYRUN', DEFAULT_SETTINGS.execution.dryRun)
--- a/src/main/services/database/data-source.ts
+++ b/src/main/services/database/data-source.ts
@@ -0,0 +1,97 @@
+/**
+ * TypeORM Data Source Configuration
+ *
+ * Provides a centralized database connection for TypeORM entities.
+ * Supports both MySQL and SQL Server based on DB_TYPE environment variable.
+ */
+
+import 'reflect-metadata'
+import { DataSource, DataSourceOptions } from 'typeorm'
+
+/**
+ * Get database type from environment
+ */
+function getDatabaseType(): 'mysql' | 'mssql' {
+  const dbType = process.env.DB_TYPE?.toLowerCase()
+  if (dbType === 'sqlserver' || dbType === 'mssql') {
+    return 'mssql'
+  }
+  return 'mysql'
+}
+
+/**
+ * Build DataSourceOptions based on database type
+ */
+function buildDataSourceOptions(): DataSourceOptions {
+  const type = getDatabaseType()
+
+  const commonOptions: Partial<DataSourceOptions> = {
+    entities: [__dirname + '/entities/*.{ts,js}'],
+    synchronize: false, // Never auto-sync in production
+    logging: process.env.NODE_ENV !== 'production'
+  }
+
+  if (type === 'mssql') {
+    return {
+      type: 'mssql',
+      host: process.env.DB_SERVER || 'localhost',
+      port: parseInt(process.env.DB_SQLSERVER_PORT || '1433', 10),
+      username: process.env.DB_USERNAME || 'sa',
+      password: process.env.DB_PASSWORD || '',
+      database: process.env.DB_NAME || '',
+      options: {
+        encrypt: process.env.DB_TRUST_SERVER_CERTIFICATE === 'yes',
+        trustServerCertificate: process.env.DB_TRUST_SERVER_CERTIFICATE === 'yes'
+      },
+      ...commonOptions
+    } as DataSourceOptions
+  }
+
+  return {
+    type: 'mysql',
+    host: process.env.DB_MYSQL_HOST || 'localhost',
+    port: parseInt(process.env.DB_MYSQL_PORT || '3306', 10),
+    username: process.env.DB_USERNAME || 'root',
+    password: process.env.DB_PASSWORD || '',
+    database: process.env.DB_NAME || '',
+    ...commonOptions
+  } as DataSourceOptions
+}
+
+/**
+ * TypeORM DataSource singleton
+ */
+let dataSource: DataSource | null = null
+
+/**
+ * Get or create the DataSource
+ */
+export function getDataSource(): DataSource {
+  if (!dataSource) {
+    dataSource = new DataSource(buildDataSourceOptions())
+  }
+  return dataSource
+}
+
+/**
+ * Initialize the DataSource
+ */
+export async function initializeDataSource(): Promise<DataSource> {
+  const ds = getDataSource()
+  if (!ds.isInitialized) {
+    await ds.initialize()
+  }
+  return ds
+}
+
+/**
+ * Destroy the DataSource
+ */
+export async function destroyDataSource(): Promise<void> {
+  if (dataSource && dataSource.isInitialized) {
+    await dataSource.destroy()
+    dataSource = null
+  }
+}
+
+export default getDataSource
--- a/src/main/services/database/discrete-material-plan-dao.ts
+++ b/src/main/services/database/discrete-material-plan-dao.ts
@@ -11,6 +11,9 @@
 import { MySqlService } from './mysql'
 import { SqlServerService } from './sql-server'
 import sql from 'mssql'
+import { createLogger } from '../logger'
+
+const log = createLogger('DiscreteMaterialPlanDAO')

 /**
 * Material plan record interface
@@ -171,13 +174,16 @@ export class DiscreteMaterialPlanDAO {

      const sqlString = `SELECT * FROM ${tableName}`

-      const result = this.dbType === 'sqlserver'
-        ? await (dbService as SqlServerService).query(sqlString)
-        : await (dbService as MySqlService).query(sqlString)
+      const result =
+        this.dbType === 'sqlserver'
+          ? await (dbService as SqlServerService).query(sqlString)
+          : await (dbService as MySqlService).query(sqlString)

      return result.rows
    } catch (error) {
-      console.error('[DiscreteMaterialPlanDAO] Query all error:', error)
+      log.error('Query all error', {
+        error: error instanceof Error ? error.message : String(error)
+      })
      return []
    }
  }
@@ -215,13 +221,16 @@ export class DiscreteMaterialPlanDAO {
        WHERE rn = 1
      `

-      const result = this.dbType === 'sqlserver'
-        ? await (dbService as SqlServerService).query(sqlString)
-        : await (dbService as MySqlService).query(sqlString)
+      const result =
+        this.dbType === 'sqlserver'
+          ? await (dbService as SqlServerService).query(sqlString)
+          : await (dbService as MySqlService).query(sqlString)

      return result.rows
    } catch (error) {
-      console.error('[DiscreteMaterialPlanDAO] Query all distinct by material code error:', error)
+      log.error('Query all distinct by material code error', {
+        error: error instanceof Error ? error.message : String(error)
+      })
      return []
    }
  }
@@ -279,7 +288,9 @@ export class DiscreteMaterialPlanDAO {

      return allResults
    } catch (error) {
-      console.error('[DiscreteMaterialPlanDAO] Query by source numbers error:', error)
+      log.error('Query by source numbers error', {
+        error: error instanceof Error ? error.message : String(error)
+      })
      return []
    }
  }
@@ -371,7 +382,9 @@ export class DiscreteMaterialPlanDAO {

      return allResults
    } catch (error) {
-      console.error('[DiscreteMaterialPlanDAO] Query by source numbers distinct error:', error)
+      log.error('Query by source numbers distinct error', {
+        error: error instanceof Error ? error.message : String(error)
+      })
      return []
    }
  }
@@ -410,7 +423,9 @@ export class DiscreteMaterialPlanDAO {
        return result.rows
      }
    } catch (error) {
-      console.error('[DiscreteMaterialPlanDAO] Query by source number error:', error)
+      log.error('Query by source number error', {
+        error: error instanceof Error ? error.message : String(error)
+      })
      return []
    }
  }
@@ -451,7 +466,9 @@ export class DiscreteMaterialPlanDAO {
        return result.rows
      }
    } catch (error) {
-      console.error('[DiscreteMaterialPlanDAO] Query by plan number error:', error)
+      log.error('Query by plan number error', {
+        error: error instanceof Error ? error.message : String(error)
+      })
      return []
    }
  }
@@ -499,7 +516,9 @@ export class DiscreteMaterialPlanDAO {
        return result.rows
      }
    } catch (error) {
-      console.error('[DiscreteMaterialPlanDAO] Query by plan numbers error:', error)
+      log.error('Query by plan numbers error', {
+        error: error instanceof Error ? error.message : String(error)
+      })
      return []
    }
  }
@@ -517,13 +536,16 @@ export class DiscreteMaterialPlanDAO {

      const sqlString = `SELECT COUNT(*) as count FROM ${tableName}`

-      const result = this.dbType === 'sqlserver'
-        ? await (dbService as SqlServerService).query(sqlString)
-        : await (dbService as MySqlService).query(sqlString)
+      const result =
+        this.dbType === 'sqlserver'
+          ? await (dbService as SqlServerService).query(sqlString)
+          : await (dbService as MySqlService).query(sqlString)

      return result.rows.length > 0 ? (result.rows[0].count as number) : 0
    } catch (error) {
-      console.error('[DiscreteMaterialPlanDAO] Count all error:', error)
+      log.error('Count all error', {
+        error: error instanceof Error ? error.message : String(error)
+      })
      return 0
    }
  }
@@ -562,7 +584,9 @@ export class DiscreteMaterialPlanDAO {
        return result.rows.length > 0 ? (result.rows[0].count as number) : 0
      }
    } catch (error) {
-      console.error('[DiscreteMaterialPlanDAO] Count by plan number error:', error)
+      log.error('Count by plan number error', {
+        error: error instanceof Error ? error.message : String(error)
+      })
      return 0
    }
  }
@@ -594,9 +618,7 @@ export class DiscreteMaterialPlanDAO {
          `

          const result = await (dbService as SqlServerService).queryWithParams(sqlString, params)
-          return result.rows
-            .map(row => row.MaterialName as string)
-            .filter(Boolean)
+          return result.rows.map((row) => row.MaterialName as string).filter(Boolean)
        } else {
          const placeholders = sourceNumbers.map(() => '?').join(',')

@@ -608,9 +630,7 @@ export class DiscreteMaterialPlanDAO {
          `

          const result = await (dbService as MySqlService).query(sqlString, sourceNumbers)
-          return result.rows
-            .map(row => row.MaterialName as string)
-            .filter(Boolean)
+          return result.rows.map((row) => row.MaterialName as string).filter(Boolean)
        }
      } else {
        const sqlString = `
@@ -619,16 +639,17 @@ export class DiscreteMaterialPlanDAO {
          WHERE MaterialName IS NOT NULL
        `

-        const result = this.dbType === 'sqlserver'
-          ? await (dbService as SqlServerService).query(sqlString)
-          : await (dbService as MySqlService).query(sqlString)
+        const result =
+          this.dbType === 'sqlserver'
+            ? await (dbService as SqlServerService).query(sqlString)
+            : await (dbService as MySqlService).query(sqlString)

-        return result.rows
-          .map(row => row.MaterialName as string)
-          .filter(Boolean)
+        return result.rows.map((row) => row.MaterialName as string).filter(Boolean)
      }
    } catch (error) {
-      console.error('[DiscreteMaterialPlanDAO] Get unique material names error:', error)
+      log.error('Get unique material names error', {
+        error: error instanceof Error ? error.message : String(error)
+      })
      return []
    }
  }
@@ -652,13 +673,16 @@ export class DiscreteMaterialPlanDAO {
        FROM ${tableName}
      `

-      const result = this.dbType === 'sqlserver'
-        ? await (dbService as SqlServerService).query(sqlString)
-        : await (dbService as MySqlService).query(sqlString)
+      const result =
+        this.dbType === 'sqlserver'
+          ? await (dbService as SqlServerService).query(sqlString)
+          : await (dbService as MySqlService).query(sqlString)

      return result.rows.length > 0 ? result.rows[0] : {}
    } catch (error) {
-      console.error('[DiscreteMaterialPlanDAO] Get statistics error:', error)
+      log.error('Get statistics error', {
+        error: error instanceof Error ? error.message : String(error)
+      })
      return {}
    }
  }
--- a/src/main/services/database/entities/DiscreteMaterialPlan.ts
+++ b/src/main/services/database/entities/DiscreteMaterialPlan.ts
@@ -0,0 +1,143 @@
+/**
+ * TypeORM Entity for DiscreteMaterialPlanData table
+ */
+
+import { Entity, PrimaryGeneratedColumn, Column, Index } from 'typeorm'
+
+@Entity('DiscreteMaterialPlanData')
+export class DiscreteMaterialPlan {
+  @PrimaryGeneratedColumn()
+  id!: number
+
+  @Column({ name: 'Factory', type: 'nvarchar', length: 100, nullable: true })
+  factory!: string | null
+
+  @Column({ name: 'MaterialStatus', type: 'nvarchar', length: 50, nullable: true })
+  materialStatus!: string | null
+
+  @Index()
+  @Column({ name: 'PlanNumber', type: 'nvarchar', length: 100, nullable: true })
+  planNumber!: string | null
+
+  @Index()
+  @Column({ name: 'SourceNumber', type: 'nvarchar', length: 100, nullable: true })
+  sourceNumber!: string | null
+
+  @Column({ name: 'MaterialType', type: 'nvarchar', length: 100, nullable: true })
+  materialType!: string | null
+
+  @Column({ name: 'ProductCode', type: 'nvarchar', length: 100, nullable: true })
+  productCode!: string | null
+
+  @Column({ name: 'ProductName', type: 'nvarchar', length: 255, nullable: true })
+  productName!: string | null
+
+  @Column({ name: 'ProductUnit', type: 'nvarchar', length: 50, nullable: true })
+  productUnit!: string | null
+
+  @Column({ name: 'ProductPlanQuantity', type: 'decimal', precision: 18, scale: 4, nullable: true })
+  productPlanQuantity!: number | null
+
+  @Column({ name: 'UseDepartment', type: 'nvarchar', length: 100, nullable: true })
+  useDepartment!: string | null
+
+  @Column({ name: 'Remark', type: 'nvarchar', length: 500, nullable: true })
+  remark!: string | null
+
+  @Column({ name: 'Creator', type: 'nvarchar', length: 100, nullable: true })
+  creator!: string | null
+
+  @Column({ name: 'CreateDate', type: 'datetime', nullable: true })
+  createDate!: Date | null
+
+  @Column({ name: 'Approver', type: 'nvarchar', length: 100, nullable: true })
+  approver!: string | null
+
+  @Column({ name: 'ApproveDate', type: 'datetime', nullable: true })
+  approveDate!: Date | null
+
+  @Column({ name: 'SequenceNumber', type: 'int', nullable: true })
+  sequenceNumber!: number | null
+
+  @Index()
+  @Column({ name: 'MaterialCode', type: 'nvarchar', length: 100, nullable: true })
+  materialCode!: string | null
+
+  @Column({ name: 'MaterialName', type: 'nvarchar', length: 255, nullable: true })
+  materialName!: string | null
+
+  @Column({ name: 'Specification', type: 'nvarchar', length: 255, nullable: true })
+  specification!: string | null
+
+  @Column({ name: 'Model', type: 'nvarchar', length: 255, nullable: true })
+  model!: string | null
+
+  @Column({ name: 'DrawingNumber', type: 'nvarchar', length: 100, nullable: true })
+  drawingNumber!: string | null
+
+  @Column({ name: 'MaterialQuality', type: 'nvarchar', length: 100, nullable: true })
+  materialQuality!: string | null
+
+  @Column({ name: 'PlanQuantity', type: 'decimal', precision: 18, scale: 4, nullable: true })
+  planQuantity!: number | null
+
+  @Column({ name: 'Unit', type: 'nvarchar', length: 50, nullable: true })
+  unit!: string | null
+
+  @Column({ name: 'RequiredDate', type: 'datetime', nullable: true })
+  requiredDate!: Date | null
+
+  @Column({ name: 'Warehouse', type: 'nvarchar', length: 100, nullable: true })
+  warehouse!: string | null
+
+  @Column({ name: 'UnitUsage', type: 'decimal', precision: 18, scale: 6, nullable: true })
+  unitUsage!: number | null
+
+  @Column({
+    name: 'CumulativeOutputQuantity',
+    type: 'decimal',
+    precision: 18,
+    scale: 4,
+    nullable: true
+  })
+  cumulativeOutputQuantity!: number | null
+
+  @Column({ name: 'BOMVersion', type: 'nvarchar', length: 50, nullable: true })
+  bomVersion!: string | null
+}
+
+/**
+ * Material plan record interface for type-safe operations
+ */
+export interface MaterialPlanRecordData {
+  id?: number
+  factory?: string | null
+  materialStatus?: string | null
+  planNumber?: string | null
+  sourceNumber?: string | null
+  materialType?: string | null
+  productCode?: string | null
+  productName?: string | null
+  productUnit?: string | null
+  productPlanQuantity?: number | null
+  useDepartment?: string | null
+  remark?: string | null
+  creator?: string | null
+  createDate?: Date | null
+  approver?: string | null
+  approveDate?: Date | null
+  sequenceNumber?: number | null
+  materialCode?: string | null
+  materialName?: string | null
+  specification?: string | null
+  model?: string | null
+  drawingNumber?: string | null
+  materialQuality?: string | null
+  planQuantity?: number | null
+  unit?: string | null
+  requiredDate?: Date | null
+  warehouse?: string | null
+  unitUsage?: number | null
+  cumulativeOutputQuantity?: number | null
+  bomVersion?: string | null
+}
--- a/src/main/services/database/entities/MaterialsToBeDeleted.ts
+++ b/src/main/services/database/entities/MaterialsToBeDeleted.ts
@@ -0,0 +1,27 @@
+/**
+ * TypeORM Entity for MaterialsToBeDeleted table
+ */
+
+import { Entity, PrimaryGeneratedColumn, Column, Index } from 'typeorm'
+
+@Entity('MaterialsToBeDeleted')
+export class MaterialsToBeDeleted {
+  @PrimaryGeneratedColumn()
+  id!: number
+
+  @Index({ unique: true })
+  @Column({ name: 'MaterialCode', type: 'nvarchar', length: 255, nullable: false })
+  materialCode!: string
+
+  @Column({ name: 'ManagerName', type: 'nvarchar', length: 255, nullable: true })
+  managerName!: string | null
+}
+
+/**
+ * Material record interface for type-safe operations
+ */
+export interface MaterialRecordData {
+  id?: number
+  materialCode: string
+  managerName: string | null
+}
--- a/src/main/services/database/materials-to-be-deleted-dao.ts
+++ b/src/main/services/database/materials-to-be-deleted-dao.ts
@@ -11,6 +11,9 @@
 import { MySqlService } from './mysql'
 import { SqlServerService } from './sql-server'
 import sql from 'mssql'
+import { createLogger } from '../logger'
+
+const log = createLogger('MaterialsToBeDeletedDAO')

 /**
 * Material record interface
@@ -132,7 +135,7 @@ export class MaterialsToBeDeletedDAO {
   */
  async upsertMaterial(materialCode: string, managerName: string): Promise<boolean> {
    if (!materialCode || !materialCode.trim()) {
-      console.error('[MaterialsToBeDeletedDAO] MaterialCode cannot be empty')
+      log.error('MaterialCode cannot be empty')
      return false
    }

@@ -167,7 +170,9 @@ export class MaterialsToBeDeletedDAO {

      return true
    } catch (error) {
-      console.error('[MaterialsToBeDeletedDAO] Upsert material error:', error)
+      log.error('Upsert material error', {
+        error: error instanceof Error ? error.message : String(error)
+      })
      return false
    }
  }
@@ -177,7 +182,9 @@ export class MaterialsToBeDeletedDAO {
   * @param materials - List of materials with materialCode and managerName
   * @returns Statistics object
   */
-  async upsertBatch(materials: { materialCode: string; managerName: string }[]): Promise<UpsertStats> {
+  async upsertBatch(
+    materials: { materialCode: string; managerName: string }[]
+  ): Promise<UpsertStats> {
    if (!materials || materials.length === 0) {
      return { total: 0, success: 0, failed: 0 }
    }
@@ -227,12 +234,17 @@ export class MaterialsToBeDeletedDAO {

          stats.success++
        } catch (error) {
-          console.error('[MaterialsToBeDeletedDAO] Error upserting material:', materialCode, error)
+          log.error('Error upserting material', {
+            materialCode,
+            error: error instanceof Error ? error.message : String(error)
+          })
          stats.failed++
        }
      }
    } catch (error) {
-      console.error('[MaterialsToBeDeletedDAO] Batch upsert error:', error)
+      log.error('Batch upsert error', {
+        error: error instanceof Error ? error.message : String(error)
+      })
      stats.failed = stats.total - stats.success
    }

@@ -256,13 +268,16 @@ export class MaterialsToBeDeletedDAO {
        WHERE MaterialCode IS NOT NULL
      `

-      const result = this.dbType === 'sqlserver'
-        ? await (dbService as SqlServerService).query(sqlString)
-        : await (dbService as MySqlService).query(sqlString)
+      const result =
+        this.dbType === 'sqlserver'
+          ? await (dbService as SqlServerService).query(sqlString)
+          : await (dbService as MySqlService).query(sqlString)

-      return new Set(result.rows.map(row => row.MaterialCode as string).filter(Boolean))
+      return new Set(result.rows.map((row) => row.MaterialCode as string).filter(Boolean))
    } catch (error) {
-      console.error('[MaterialsToBeDeletedDAO] Get all material codes error:', error)
+      log.error('Get all material codes error', {
+        error: error instanceof Error ? error.message : String(error)
+      })
      return new Set()
    }
  }
@@ -283,17 +298,20 @@ export class MaterialsToBeDeletedDAO {
        ORDER BY ManagerName, MaterialCode
      `

-      const result = this.dbType === 'sqlserver'
-        ? await (dbService as SqlServerService).query(sqlString)
-        : await (dbService as MySqlService).query(sqlString)
+      const result =
+        this.dbType === 'sqlserver'
+          ? await (dbService as SqlServerService).query(sqlString)
+          : await (dbService as MySqlService).query(sqlString)

-      return result.rows.map(row => ({
+      return result.rows.map((row) => ({
        id: row.ID as number,
        materialCode: row.MaterialCode as string,
        managerName: row.ManagerName as string
      }))
    } catch (error) {
-      console.error('[MaterialsToBeDeletedDAO] Get all records error:', error)
+      log.error('Get all records error', {
+        error: error instanceof Error ? error.message : String(error)
+      })
      return []
    }
  }
@@ -320,7 +338,7 @@ export class MaterialsToBeDeletedDAO {
          managerName: { value: managerName, type: sql.NVarChar }
        })

-        return result.rows.map(row => ({
+        return result.rows.map((row) => ({
          id: row.ID as number,
          materialCode: row.MaterialCode as string,
          managerName: row.ManagerName as string
@@ -335,14 +353,16 @@ export class MaterialsToBeDeletedDAO {

        const result = await (dbService as MySqlService).query(sqlString, [managerName])

-        return result.rows.map(row => ({
+        return result.rows.map((row) => ({
          id: row.ID as number,
          materialCode: row.MaterialCode as string,
          managerName: row.ManagerName as string
        }))
      }
    } catch (error) {
-      console.error('[MaterialsToBeDeletedDAO] Get materials by manager error:', error)
+      log.error('Get materials by manager error', {
+        error: error instanceof Error ? error.message : String(error)
+      })
      return []
    }
  }
@@ -363,13 +383,16 @@ export class MaterialsToBeDeletedDAO {
        ORDER BY ManagerName
      `

-      const result = this.dbType === 'sqlserver'
-        ? await (dbService as SqlServerService).query(sqlString)
-        : await (dbService as MySqlService).query(sqlString)
+      const result =
+        this.dbType === 'sqlserver'
+          ? await (dbService as SqlServerService).query(sqlString)
+          : await (dbService as MySqlService).query(sqlString)

-      return result.rows.map(row => row.ManagerName as string).filter(Boolean)
+      return result.rows.map((row) => row.ManagerName as string).filter(Boolean)
    } catch (error) {
-      console.error('[MaterialsToBeDeletedDAO] Get managers error:', error)
+      log.error('Get managers error', {
+        error: error instanceof Error ? error.message : String(error)
+      })
      return []
    }
  }
@@ -427,7 +450,9 @@ export class MaterialsToBeDeletedDAO {
        }
      }
    } catch (error) {
-      console.error('[MaterialsToBeDeletedDAO] Get record by material code error:', error)
+      log.error('Get record by material code error', {
+        error: error instanceof Error ? error.message : String(error)
+      })
      return null
    }
  }
@@ -467,7 +492,9 @@ export class MaterialsToBeDeletedDAO {
        return result.rowCount > 0
      }
    } catch (error) {
-      console.error('[MaterialsToBeDeletedDAO] Delete by material code error:', error)
+      log.error('Delete by material code error', {
+        error: error instanceof Error ? error.message : String(error)
+      })
      return false
    }
  }
@@ -504,7 +531,9 @@ export class MaterialsToBeDeletedDAO {
        return result.rowCount
      }
    } catch (error) {
-      console.error('[MaterialsToBeDeletedDAO] Delete by manager error:', error)
+      log.error('Delete by manager error', {
+        error: error instanceof Error ? error.message : String(error)
+      })
      return 0
    }
  }
@@ -520,13 +549,16 @@ export class MaterialsToBeDeletedDAO {

      const sqlString = `DELETE FROM ${tableName}`

-      const result = this.dbType === 'sqlserver'
-        ? await (dbService as SqlServerService).query(sqlString)
-        : await (dbService as MySqlService).query(sqlString)
+      const result =
+        this.dbType === 'sqlserver'
+          ? await (dbService as SqlServerService).query(sqlString)
+          : await (dbService as MySqlService).query(sqlString)

      return result.rowCount
    } catch (error) {
-      console.error('[MaterialsToBeDeletedDAO] Delete all materials error:', error)
+      log.error('Delete all materials error', {
+        error: error instanceof Error ? error.message : String(error)
+      })
      return 0
    }
  }
@@ -579,7 +611,9 @@ export class MaterialsToBeDeletedDAO {
        }
      }
    } catch (error) {
-      console.error('[MaterialsToBeDeletedDAO] Delete by material codes error:', error)
+      log.error('Delete by material codes error', {
+        error: error instanceof Error ? error.message : String(error)
+      })
    }

    return totalDeleted
@@ -622,7 +656,9 @@ export class MaterialsToBeDeletedDAO {
        return result.rows.length > 0 && (result.rows[0].count as number) > 0
      }
    } catch (error) {
-      console.error('[MaterialsToBeDeletedDAO] Material exists error:', error)
+      log.error('Material exists error', {
+        error: error instanceof Error ? error.message : String(error)
+      })
      return false
    }
  }
@@ -638,13 +674,16 @@ export class MaterialsToBeDeletedDAO {

      const sqlString = `SELECT COUNT(*) as count FROM ${tableName}`

-      const result = this.dbType === 'sqlserver'
-        ? await (dbService as SqlServerService).query(sqlString)
-        : await (dbService as MySqlService).query(sqlString)
+      const result =
+        this.dbType === 'sqlserver'
+          ? await (dbService as SqlServerService).query(sqlString)
+          : await (dbService as MySqlService).query(sqlString)

      return result.rows.length > 0 ? (result.rows[0].count as number) : 0
    } catch (error) {
-      console.error('[MaterialsToBeDeletedDAO] Count all error:', error)
+      log.error('Count all error', {
+        error: error instanceof Error ? error.message : String(error)
+      })
      return 0
    }
  }
@@ -683,7 +722,9 @@ export class MaterialsToBeDeletedDAO {
        return result.rows.length > 0 ? (result.rows[0].count as number) : 0
      }
    } catch (error) {
-      console.error('[MaterialsToBeDeletedDAO] Count by manager error:', error)
+      log.error('Count by manager error', {
+        error: error instanceof Error ? error.message : String(error)
+      })
      return 0
    }
  }
@@ -706,9 +747,10 @@ export class MaterialsToBeDeletedDAO {
        WHERE MaterialCode IS NOT NULL
      `

-      const statsResult = this.dbType === 'sqlserver'
-        ? await (dbService as SqlServerService).query(statsSql)
-        : await (dbService as MySqlService).query(statsSql)
+      const statsResult =
+        this.dbType === 'sqlserver'
+          ? await (dbService as SqlServerService).query(statsSql)
+          : await (dbService as MySqlService).query(statsSql)

      const stats = statsResult.rows[0] || {}

@@ -721,11 +763,12 @@ export class MaterialsToBeDeletedDAO {
        ORDER BY count DESC
      `

-      const managerResult = this.dbType === 'sqlserver'
-        ? await (dbService as SqlServerService).query(managerSql)
-        : await (dbService as MySqlService).query(managerSql)
+      const managerResult =
+        this.dbType === 'sqlserver'
+          ? await (dbService as SqlServerService).query(managerSql)
+          : await (dbService as MySqlService).query(managerSql)

-      const materialsPerManager = managerResult.rows.map(row => ({
+      const materialsPerManager = managerResult.rows.map((row) => ({
        [row.ManagerName as string]: row.count as number
      }))

@@ -735,7 +778,9 @@ export class MaterialsToBeDeletedDAO {
        materialsPerManager
      }
    } catch (error) {
-      console.error('[MaterialsToBeDeletedDAO] Get statistics error:', error)
+      log.error('Get statistics error', {
+        error: error instanceof Error ? error.message : String(error)
+      })
      return {
        totalMaterials: 0,
        uniqueManagers: 0,
--- a/src/main/services/database/repositories/DiscreteMaterialPlanRepository.ts
+++ b/src/main/services/database/repositories/DiscreteMaterialPlanRepository.ts
@@ -0,0 +1,281 @@
+/**
+ * Repository for DiscreteMaterialPlan entity
+ *
+ * Provides type-safe database operations for discrete material plan data.
+ */
+
+import { DataSource, Repository, In } from 'typeorm'
+import { DiscreteMaterialPlan, MaterialPlanRecordData } from '../entities/DiscreteMaterialPlan'
+import { getDataSource } from '../data-source'
+import { createLogger } from '../../logger'
+
+const log = createLogger('DiscreteMaterialPlanRepository')
+
+/**
+ * DiscreteMaterialPlan Repository class
+ */
+export class DiscreteMaterialPlanRepository {
+  private repository: Repository<DiscreteMaterialPlan> | null = null
+  private dataSource: DataSource | null = null
+
+  /**
+   * Get the repository instance
+   */
+  private async getRepository(): Promise<Repository<DiscreteMaterialPlan>> {
+    if (!this.repository) {
+      this.dataSource = getDataSource()
+      if (!this.dataSource.isInitialized) {
+        await this.dataSource.initialize()
+      }
+      this.repository = this.dataSource.getRepository(DiscreteMaterialPlan)
+    }
+    return this.repository
+  }
+
+  /**
+   * Query all records
+   */
+  async queryAll(): Promise<DiscreteMaterialPlan[]> {
+    try {
+      const repo = await this.getRepository()
+      return await repo.find()
+    } catch (error) {
+      log.error('Query all failed', {
+        error: error instanceof Error ? error.message : String(error)
+      })
+      return []
+    }
+  }
+
+  /**
+   * Query all records with deduplication by MaterialCode
+   */
+  async queryAllDistinctByMaterialCode(): Promise<DiscreteMaterialPlan[]> {
+    try {
+      const repo = await this.getRepository()
+
+      const query = `
+        WITH RankedRecords AS (
+          SELECT *,
+            ROW_NUMBER() OVER (
+              PARTITION BY MaterialCode
+              ORDER BY CreateDate ASC, SequenceNumber ASC
+            ) AS rn
+          FROM DiscreteMaterialPlanData
+          WHERE MaterialCode IS NOT NULL
+        )
+        SELECT * FROM RankedRecords WHERE rn = 1
+      `
+
+      return await repo.query(query)
+    } catch (error) {
+      log.error('Query all distinct by material code failed', {
+        error: error instanceof Error ? error.message : String(error)
+      })
+      return []
+    }
+  }
+
+  /**
+   * Query by source numbers (production order numbers)
+   */
+  async queryBySourceNumbers(sourceNumbers: string[]): Promise<DiscreteMaterialPlan[]> {
+    if (!sourceNumbers.length) return []
+
+    try {
+      const repo = await this.getRepository()
+      const batchSize = 2000
+      const allResults: DiscreteMaterialPlan[] = []
+
+      for (let i = 0; i < sourceNumbers.length; i += batchSize) {
+        const batch = sourceNumbers.slice(i, i + batchSize)
+        const results = await repo.find({
+          where: { sourceNumber: In(batch) }
+        })
+        allResults.push(...results)
+      }
+
+      return allResults
+    } catch (error) {
+      log.error('Query by source numbers failed', {
+        count: sourceNumbers.length,
+        error: error instanceof Error ? error.message : String(error)
+      })
+      return []
+    }
+  }
+
+  /**
+   * Query by source numbers with deduplication by MaterialCode
+   */
+  async queryBySourceNumbersDistinct(sourceNumbers: string[]): Promise<DiscreteMaterialPlan[]> {
+    if (!sourceNumbers.length) return []
+
+    try {
+      const repo = await this.getRepository()
+      const batchSize = 2000
+      const allResults: DiscreteMaterialPlan[] = []
+
+      for (let i = 0; i < sourceNumbers.length; i += batchSize) {
+        const batch = sourceNumbers.slice(i, i + batchSize)
+
+        const query = `
+          WITH RankedRecords AS (
+            SELECT *,
+              ROW_NUMBER() OVER (
+                PARTITION BY MaterialCode
+                ORDER BY CreateDate ASC, SequenceNumber ASC
+              ) AS rn
+            FROM DiscreteMaterialPlanData
+            WHERE SourceNumber IN (?) AND MaterialCode IS NOT NULL
+          )
+          SELECT * FROM RankedRecords WHERE rn = 1
+        `
+
+        const results = await repo.query(query, [batch])
+        allResults.push(...results)
+      }
+
+      return allResults
+    } catch (error) {
+      log.error('Query by source numbers distinct failed', {
+        count: sourceNumbers.length,
+        error: error instanceof Error ? error.message : String(error)
+      })
+      return []
+    }
+  }
+
+  /**
+   * Query by single source number
+   */
+  async queryBySourceNumber(sourceNumber: string): Promise<DiscreteMaterialPlan[]> {
+    try {
+      const repo = await this.getRepository()
+      return await repo.find({ where: { sourceNumber } })
+    } catch (error) {
+      log.error('Query by source number failed', {
+        sourceNumber,
+        error: error instanceof Error ? error.message : String(error)
+      })
+      return []
+    }
+  }
+
+  /**
+   * Query by plan number
+   */
+  async queryByPlanNumber(planNumber: string): Promise<DiscreteMaterialPlan[]> {
+    try {
+      const repo = await this.getRepository()
+      return await repo.find({ where: { planNumber } })
+    } catch (error) {
+      log.error('Query by plan number failed', {
+        planNumber,
+        error: error instanceof Error ? error.message : String(error)
+      })
+      return []
+    }
+  }
+
+  /**
+   * Query by multiple plan numbers
+   */
+  async queryByPlanNumbers(planNumbers: string[]): Promise<DiscreteMaterialPlan[]> {
+    if (!planNumbers.length) return []
+
+    try {
+      const repo = await this.getRepository()
+      return await repo.find({
+        where: { planNumber: In(planNumbers) }
+      })
+    } catch (error) {
+      log.error('Query by plan numbers failed', {
+        count: planNumbers.length,
+        error: error instanceof Error ? error.message : String(error)
+      })
+      return []
+    }
+  }
+
+  /**
+   * Count all records
+   */
+  async countAll(): Promise<number> {
+    try {
+      const repo = await this.getRepository()
+      return await repo.count()
+    } catch {
+      return 0
+    }
+  }
+
+  /**
+   * Get unique material names
+   */
+  async getUniqueMaterialNames(sourceNumbers?: string[]): Promise<string[]> {
+    try {
+      const repo = await this.getRepository()
+
+      let query = repo
+        .createQueryBuilder('m')
+        .select('DISTINCT m.materialName', 'materialName')
+        .where('m.materialName IS NOT NULL')
+
+      if (sourceNumbers && sourceNumbers.length > 0) {
+        query = query.andWhere('m.sourceNumber IN (:...sourceNumbers)', { sourceNumbers })
+      }
+
+      const result = await query.orderBy('m.materialName', 'ASC').getRawMany()
+      return result.map((r) => r.materialName).filter(Boolean)
+    } catch (error) {
+      log.error('Get unique material names failed', {
+        error: error instanceof Error ? error.message : String(error)
+      })
+      return []
+    }
+  }
+
+  /**
+   * Get statistics
+   */
+  async getStatistics(): Promise<{
+    totalRecords: number
+    uniquePlans: number
+    uniqueOrders: number
+    earliestRecord: Date | null
+    latestRecord: Date | null
+  }> {
+    try {
+      const repo = await this.getRepository()
+
+      const result = await repo
+        .createQueryBuilder('m')
+        .select('COUNT(*)', 'totalRecords')
+        .addSelect('COUNT(DISTINCT m.planNumber)', 'uniquePlans')
+        .addSelect('COUNT(DISTINCT m.sourceNumber)', 'uniqueOrders')
+        .addSelect('MIN(m.createDate)', 'earliestRecord')
+        .addSelect('MAX(m.createDate)', 'latestRecord')
+        .getRawOne()
+
+      return {
+        totalRecords: parseInt(result?.totalRecords || '0', 10),
+        uniquePlans: parseInt(result?.uniquePlans || '0', 10),
+        uniqueOrders: parseInt(result?.uniqueOrders || '0', 10),
+        earliestRecord: result?.earliestRecord || null,
+        latestRecord: result?.latestRecord || null
+      }
+    } catch (error) {
+      log.error('Get statistics failed', {
+        error: error instanceof Error ? error.message : String(error)
+      })
+      return {
+        totalRecords: 0,
+        uniquePlans: 0,
+        uniqueOrders: 0,
+        earliestRecord: null,
+        latestRecord: null
+      }
+    }
+  }
+}
--- a/src/main/services/database/repositories/MaterialsToBeDeletedRepository.ts
+++ b/src/main/services/database/repositories/MaterialsToBeDeletedRepository.ts
@@ -0,0 +1,266 @@
+/**
+ * Repository for MaterialsToBeDeleted entity
+ *
+ * Provides type-safe database operations for materials to be deleted.
+ */
+
+import { DataSource, Repository, In } from 'typeorm'
+import { MaterialsToBeDeleted, MaterialRecordData } from '../entities/MaterialsToBeDeleted'
+import { getDataSource } from '../data-source'
+import { createLogger } from '../../logger'
+
+const log = createLogger('MaterialsToBeDeletedRepository')
+
+/**
+ * Upsert statistics
+ */
+export interface UpsertStats {
+  total: number
+  success: number
+  failed: number
+}
+
+/**
+ * MaterialsToBeDeleted Repository class
+ */
+export class MaterialsToBeDeletedRepository {
+  private repository: Repository<MaterialsToBeDeleted> | null = null
+  private dataSource: DataSource | null = null
+
+  /**
+   * Get the repository instance
+   */
+  private async getRepository(): Promise<Repository<MaterialsToBeDeleted>> {
+    if (!this.repository) {
+      this.dataSource = getDataSource()
+      if (!this.dataSource.isInitialized) {
+        await this.dataSource.initialize()
+      }
+      this.repository = this.dataSource.getRepository(MaterialsToBeDeleted)
+    }
+    return this.repository
+  }
+
+  /**
+   * Insert or update a single material record
+   */
+  async upsert(materialCode: string, managerName: string | null): Promise<boolean> {
+    try {
+      const repo = await this.getRepository()
+
+      // Use upsert pattern
+      let entity = await repo.findOne({ where: { materialCode } })
+
+      if (entity) {
+        entity.managerName = managerName
+      } else {
+        entity = repo.create({ materialCode, managerName })
+      }
+
+      await repo.save(entity)
+      log.debug('Upserted material', { materialCode })
+      return true
+    } catch (error) {
+      log.error('Upsert material failed', {
+        materialCode,
+        error: error instanceof Error ? error.message : String(error)
+      })
+      return false
+    }
+  }
+
+  /**
+   * Insert or update multiple material records in batch
+   */
+  async upsertBatch(materials: MaterialRecordData[]): Promise<UpsertStats> {
+    const stats: UpsertStats = {
+      total: materials.length,
+      success: 0,
+      failed: 0
+    }
+
+    try {
+      const repo = await this.getRepository()
+
+      for (const material of materials) {
+        if (!material.materialCode?.trim()) {
+          stats.failed++
+          continue
+        }
+
+        try {
+          let entity = await repo.findOne({ where: { materialCode: material.materialCode } })
+
+          if (entity) {
+            entity.managerName = material.managerName
+          } else {
+            entity = repo.create({
+              materialCode: material.materialCode,
+              managerName: material.managerName
+            })
+          }
+
+          await repo.save(entity)
+          stats.success++
+        } catch {
+          stats.failed++
+        }
+      }
+
+      log.info('Batch upsert completed', stats)
+      return stats
+    } catch (error) {
+      log.error('Batch upsert failed', {
+        error: error instanceof Error ? error.message : String(error)
+      })
+      stats.failed = stats.total - stats.success
+      return stats
+    }
+  }
+
+  /**
+   * Get all material codes as a set
+   */
+  async getAllMaterialCodes(): Promise<Set<string>> {
+    try {
+      const repo = await this.getRepository()
+      const records = await repo.find({
+        select: ['materialCode'],
+        where: { materialCode: In([]) } // This will be overridden
+      })
+
+      // Use query builder for better performance
+      const result = await repo
+        .createQueryBuilder('m')
+        .select('m.materialCode')
+        .where('m.materialCode IS NOT NULL')
+        .getMany()
+
+      return new Set(result.map((r) => r.materialCode).filter(Boolean))
+    } catch (error) {
+      log.error('Get all material codes failed', {
+        error: error instanceof Error ? error.message : String(error)
+      })
+      return new Set()
+    }
+  }
+
+  /**
+   * Get all records
+   */
+  async getAllRecords(): Promise<MaterialsToBeDeleted[]> {
+    try {
+      const repo = await this.getRepository()
+      return await repo.find({
+        order: { managerName: 'ASC', materialCode: 'ASC' }
+      })
+    } catch (error) {
+      log.error('Get all records failed', {
+        error: error instanceof Error ? error.message : String(error)
+      })
+      return []
+    }
+  }
+
+  /**
+   * Get materials by manager name
+   */
+  async getByManager(managerName: string): Promise<MaterialsToBeDeleted[]> {
+    try {
+      const repo = await this.getRepository()
+      return await repo.find({
+        where: { managerName },
+        order: { materialCode: 'ASC' }
+      })
+    } catch (error) {
+      log.error('Get by manager failed', {
+        managerName,
+        error: error instanceof Error ? error.message : String(error)
+      })
+      return []
+    }
+  }
+
+  /**
+   * Get unique manager names
+   */
+  async getManagers(): Promise<string[]> {
+    try {
+      const repo = await this.getRepository()
+      const result = await repo
+        .createQueryBuilder('m')
+        .select('DISTINCT m.managerName', 'managerName')
+        .where('m.managerName IS NOT NULL')
+        .orderBy('m.managerName', 'ASC')
+        .getRawMany()
+
+      return result.map((r) => r.managerName).filter(Boolean)
+    } catch (error) {
+      log.error('Get managers failed', {
+        error: error instanceof Error ? error.message : String(error)
+      })
+      return []
+    }
+  }
+
+  /**
+   * Delete by material code
+   */
+  async deleteByMaterialCode(materialCode: string): Promise<boolean> {
+    try {
+      const repo = await this.getRepository()
+      const result = await repo.delete({ materialCode })
+      return (result.affected ?? 0) > 0
+    } catch (error) {
+      log.error('Delete by material code failed', {
+        materialCode,
+        error: error instanceof Error ? error.message : String(error)
+      })
+      return false
+    }
+  }
+
+  /**
+   * Delete multiple materials by codes
+   */
+  async deleteByMaterialCodes(materialCodes: string[]): Promise<number> {
+    if (!materialCodes.length) return 0
+
+    try {
+      const repo = await this.getRepository()
+      const result = await repo.delete({ materialCode: In(materialCodes) })
+      return result.affected ?? 0
+    } catch (error) {
+      log.error('Delete by material codes failed', {
+        count: materialCodes.length,
+        error: error instanceof Error ? error.message : String(error)
+      })
+      return 0
+    }
+  }
+
+  /**
+   * Check if a material exists
+   */
+  async exists(materialCode: string): Promise<boolean> {
+    try {
+      const repo = await this.getRepository()
+      const count = await repo.count({ where: { materialCode } })
+      return count > 0
+    } catch {
+      return false
+    }
+  }
+
+  /**
+   * Count all records
+   */
+  async countAll(): Promise<number> {
+    try {
+      const repo = await this.getRepository()
+      return await repo.count()
+    } catch {
+      return 0
+    }
+  }
+}
--- a/src/main/services/erp/ErpBrowserManager.ts
+++ b/src/main/services/erp/ErpBrowserManager.ts
@@ -0,0 +1,208 @@
+/**
+ * ERP Browser Manager
+ *
+ * Manages browser lifecycle for ERP automation.
+ * Separates browser management from authentication logic.
+ */
+
+import { chromium, type Browser, type BrowserContext, type Page } from 'playwright'
+import { createLogger } from '../logger'
+
+const log = createLogger('ErpBrowserManager')
+
+/**
+ * Browser configuration options
+ */
+export interface BrowserConfig {
+  headless?: boolean
+  slowMo?: number
+  viewport?: { width: number; height: number }
+  ignoreHTTPSErrors?: boolean
+  acceptDownloads?: boolean
+}
+
+/**
+ * Default browser configuration
+ */
+const DEFAULT_CONFIG: Required<BrowserConfig> = {
+  headless: false,
+  slowMo: 100,
+  viewport: { width: 1920, height: 1080 },
+  ignoreHTTPSErrors: true,
+  acceptDownloads: true
+}
+
+/**
+ * Browser session containing all browser-related objects
+ */
+export interface BrowserSession {
+  browser: Browser
+  context: BrowserContext
+  page: Page
+}
+
+/**
+ * ErpBrowserManager class
+ * Manages browser lifecycle independently from ERP authentication
+ */
+export class ErpBrowserManager {
+  private config: Required<BrowserConfig>
+  private session: BrowserSession | null = null
+
+  constructor(config?: BrowserConfig) {
+    this.config = { ...DEFAULT_CONFIG, ...config }
+  }
+
+  /**
+   * Launch a new browser instance
+   */
+  async launch(): Promise<Browser> {
+    if (this.session?.browser?.isConnected()) {
+      log.debug('Browser already running, returning existing instance')
+      return this.session.browser
+    }
+
+    log.info('Launching browser', { headless: this.config.headless })
+
+    const browser = await chromium.launch({
+      headless: this.config.headless,
+      slowMo: this.config.slowMo,
+      args: [
+        '--ignore-certificate-errors',
+        '--ignore-ssl-errors',
+        '--ignore-certificate-errors-spki-list',
+        '--disable-web-security'
+      ]
+    })
+
+    log.info('Browser launched successfully')
+    return browser
+  }
+
+  /**
+   * Create a new browser context
+   */
+  async createContext(browser?: Browser): Promise<BrowserContext> {
+    const browserInstance = browser || (await this.launch())
+
+    log.debug('Creating browser context')
+
+    const context = await browserInstance.newContext({
+      acceptDownloads: this.config.acceptDownloads,
+      viewport: this.config.viewport,
+      ignoreHTTPSErrors: this.config.ignoreHTTPSErrors,
+      javaScriptEnabled: true
+    })
+
+    log.debug('Browser context created')
+    return context
+  }
+
+  /**
+   * Create a new page in the context
+   */
+  async createPage(context?: BrowserContext): Promise<Page> {
+    let contextInstance: BrowserContext
+
+    if (context) {
+      contextInstance = context
+    } else if (this.session?.context) {
+      contextInstance = this.session.context
+    } else {
+      const browser = await this.launch()
+      contextInstance = await this.createContext(browser)
+    }
+
+    log.debug('Creating new page')
+    const page = await contextInstance.newPage()
+    log.debug('Page created')
+
+    return page
+  }
+
+  /**
+   * Initialize a complete browser session
+   * This creates browser, context, and page in one call
+   */
+  async initialize(): Promise<BrowserSession> {
+    if (this.session) {
+      log.debug('Returning existing browser session')
+      return this.session
+    }
+
+    const browser = await this.launch()
+    const context = await this.createContext(browser)
+    const page = await this.createPage(context)
+
+    this.session = { browser, context, page }
+    log.info('Browser session initialized')
+
+    return this.session
+  }
+
+  /**
+   * Get the current session
+   */
+  getSession(): BrowserSession | null {
+    return this.session
+  }
+
+  /**
+   * Check if browser is running
+   */
+  isRunning(): boolean {
+    return this.session?.browser?.isConnected() ?? false
+  }
+
+  /**
+   * Close the browser and cleanup
+   */
+  async close(): Promise<void> {
+    if (!this.session) {
+      log.debug('No browser session to close')
+      return
+    }
+
+    log.info('Closing browser session')
+
+    try {
+      if (this.session.context) {
+        await this.session.context.close()
+      }
+    } catch (error) {
+      log.warn('Error closing context', {
+        error: error instanceof Error ? error.message : String(error)
+      })
+    }
+
+    try {
+      if (this.session.browser) {
+        await this.session.browser.close()
+      }
+    } catch (error) {
+      log.warn('Error closing browser', {
+        error: error instanceof Error ? error.message : String(error)
+      })
+    }
+
+    this.session = null
+    log.info('Browser session closed')
+  }
+
+  /**
+   * Navigate to a URL
+   */
+  async navigate(url: string, options?: { timeout?: number }): Promise<void> {
+    const page = this.session?.page
+    if (!page) {
+      throw new Error('No page available. Call initialize() first.')
+    }
+
+    log.info('Navigating to URL', { url })
+    await page.goto(url, { timeout: options?.timeout ?? 30000 })
+    await page.waitForLoadState('domcontentloaded', { timeout: options?.timeout ?? 10000 })
+    log.debug('Page loaded')
+  }
+}
+
+export default ErpBrowserManager
--- a/src/main/services/erp/erp-auth.ts
+++ b/src/main/services/erp/erp-auth.ts
@@ -1,5 +1,8 @@
 import { chromium, type BrowserContext, type Page } from 'playwright'
 import type { ErpConfig, ErpSession } from '../../types/erp.types'
+import { createLogger } from '../logger'
+
+const log = createLogger('ErpAuthService')

 /**
 * ERP Authentication Service
@@ -91,7 +94,7 @@ export class ErpAuthService {
    try {
      await page.waitForLoadState('domcontentloaded', { timeout: 10000 })
    } catch (e) {
-      console.log('Page load state check timed out, continuing...')
+      log.warn('Page load state check timed out, continuing')
    }

    // Handle force login confirmation dialog if present (Python: get_by_role("button", name="确定"))
@@ -99,15 +102,15 @@ export class ErpAuthService {
      const confirmBtn = mainFrame.getByRole('button', { name: '确定' })
      const count = await confirmBtn.count()
      if (count > 0) {
-        console.log('Force login detected, clicking confirm button')
+        log.info('Force login detected, clicking confirm button')
        await confirmBtn.first().click()
        await page.waitForTimeout(2000)
      } else {
-        console.log('Normal login, no confirmation dialog')
+        log.debug('Normal login, no confirmation dialog')
      }
-    } catch (e) {
+    } catch {
      // No force login dialog, continue
-      console.log('Normal login, no confirmation dialog')
+      log.debug('Normal login, no confirmation dialog')
    }

    // Create session with mainFrame (Python returns main_frame as part of login result)
--- a/src/main/services/erp/order-resolver.ts
+++ b/src/main/services/erp/order-resolver.ts
@@ -156,7 +156,7 @@ export class OrderNumberResolver {
      // Update mappings with database results
      for (const mapping of mappings) {
        if (mapping.inputType === 'productionId') {
-          const dbResult = productionIdMappings.find(m => m.input === mapping.input)
+          const dbResult = productionIdMappings.find((m) => m.input === mapping.input)
          if (dbResult) {
            mapping.orderNumber = dbResult.orderNumber
            mapping.isValid = dbResult.isValid
@@ -265,7 +265,7 @@ export class OrderNumberResolver {
      const message = error instanceof Error ? error.message : '未知数据库错误'

      // Return all as failed with error
-      return productionIds.map(pid => ({
+      return productionIds.map((pid) => ({
        input: pid,
        productionId: pid,
        isValid: false,
@@ -294,7 +294,7 @@ export class OrderNumberResolver {
      `

      const result = await this.mysqlService.query(query, orderNumbers)
-      return result.rows.map(row => row[DB_CONFIG.FIELD_ORDER_NUMBER] as string)
+      return result.rows.map((row) => row[DB_CONFIG.FIELD_ORDER_NUMBER] as string)
    } catch (error) {
      console.warn('[OrderResolver] Failed to verify order numbers:', error)
      return orderNumbers // Skip verification on error
@@ -345,9 +345,7 @@ export class OrderNumberResolver {
   * @returns List of valid production order numbers
   */
  getValidOrderNumbers(mappings: OrderMapping[]): string[] {
-    return mappings
-      .filter(m => m.isValid && m.orderNumber)
-      .map(m => m.orderNumber!)
+    return mappings.filter((m) => m.isValid && m.orderNumber).map((m) => m.orderNumber!)
  }

  /**
@@ -356,8 +354,6 @@ export class OrderNumberResolver {
   * @returns List of warning messages
   */
  getWarnings(mappings: OrderMapping[]): string[] {
-    return mappings
-      .filter(m => !m.isValid && m.error)
-      .map(m => m.error!)
+    return mappings.filter((m) => !m.isValid && m.error).map((m) => m.error!)
  }
 }
--- a/src/main/services/logger/index.ts
+++ b/src/main/services/logger/index.ts
@@ -0,0 +1,97 @@
+/**
+ * Unified logging system using Winston
+ * Console + File transports with daily rotation
+ */
+
+import winston from 'winston'
+import DailyRotateFile from 'winston-daily-rotate-file'
+import path from 'path'
+import { app } from 'electron'
+import fs from 'fs'
+
+// Get log directory - use app.getPath('logs') in production, or local logs dir in development
+function getLogDir(): string {
+  if (app && app.isReady()) {
+    return app.getPath('logs')
+  }
+  // Fallback for development or before app is ready
+  const devLogDir = path.join(process.cwd(), 'logs')
+  if (!fs.existsSync(devLogDir)) {
+    fs.mkdirSync(devLogDir, { recursive: true })
+  }
+  return devLogDir
+}
+
+// Custom format for console output
+const consoleFormat = winston.format.combine(
+  winston.format.timestamp({ format: 'YYYY-MM-DD HH:mm:ss' }),
+  winston.format.colorize(),
+  winston.format.printf(({ timestamp, level, message, context, ...meta }) => {
+    const contextStr = context ? `[${context}]` : ''
+    const metaStr = Object.keys(meta).length > 0 ? ` ${JSON.stringify(meta)}` : ''
+    return `${timestamp} [${level}]${contextStr} ${message}${metaStr}`
+  })
+)
+
+// Custom format for file output
+const fileFormat = winston.format.combine(
+  winston.format.timestamp({ format: 'YYYY-MM-DD HH:mm:ss' }),
+  winston.format.json()
+)
+
+// Daily rotate file transport configuration
+const createFileTransport = (level?: string): DailyRotateFile => {
+  return new DailyRotateFile({
+    filename: path.join(getLogDir(), 'app-%DATE%.log'),
+    datePattern: 'YYYY-MM-DD',
+    zippedArchive: true,
+    maxSize: '20m',
+    maxFiles: '14d',
+    level,
+    format: fileFormat
+  })
+}
+
+// Create the logger instance
+const logger = winston.createLogger({
+  level: process.env.LOG_LEVEL || 'info',
+  defaultMeta: { service: 'erpauto' },
+  transports: [
+    // Console transport - always enabled
+    new winston.transports.Console({
+      format: consoleFormat
+    }),
+    // File transport for all levels
+    createFileTransport()
+  ]
+})
+
+// Add error-specific file transport in production
+if (process.env.NODE_ENV === 'production') {
+  logger.add(
+    new DailyRotateFile({
+      filename: path.join(getLogDir(), 'error-%DATE%.log'),
+      datePattern: 'YYYY-MM-DD',
+      zippedArchive: true,
+      maxSize: '20m',
+      maxFiles: '14d',
+      level: 'error',
+      format: fileFormat
+    })
+  )
+}
+
+/**
+ * Create a child logger with a specific context
+ * @param context - The context/module name for the logger
+ * @returns A child logger instance
+ */
+export function createLogger(context: string): winston.Logger {
+  return logger.child({ context })
+}
+
+// Export the main logger for direct use
+export default logger
+
+// Export log level types for convenience
+export type LogLevel = 'error' | 'warn' | 'info' | 'debug' | 'verbose'
--- a/src/main/services/user/bip-users-dao.ts
+++ b/src/main/services/user/bip-users-dao.ts
@@ -229,11 +229,12 @@ export class BIPUsersDAO {
        ORDER BY UserName
      `

-      const result = this.dbType === 'sqlserver'
-        ? await (dbService as SqlServerService).query(sqlString)
-        : await (dbService as MySqlService).query(sqlString)
+      const result =
+        this.dbType === 'sqlserver'
+          ? await (dbService as SqlServerService).query(sqlString)
+          : await (dbService as MySqlService).query(sqlString)

-      return result.rows.map(row => ({
+      return result.rows.map((row) => ({
        id: row.ID as number,
        username: row.UserName as string,
        userType: row.UserType as 'Admin' | 'User' | 'Guest',
--- a/src/main/types/errors.ts
+++ b/src/main/types/errors.ts
@@ -0,0 +1,169 @@
+/**
+ * Custom error types for the application
+ * Provides structured error handling with codes and context
+ */
+
+/**
+ * Base error class for all application errors
+ */
+export abstract class BaseError extends Error {
+  public readonly code: string
+  public readonly cause?: Error
+
+  constructor(name: string, message: string, code: string, cause?: Error) {
+    super(message)
+    this.name = name
+    this.code = code
+    this.cause = cause
+
+    // Maintains proper stack trace for where error was thrown (only in V8)
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor)
+    }
+  }
+
+  /**
+   * Get a JSON representation of the error for logging/serialization
+   */
+  toJSON(): Record<string, unknown> {
+    return {
+      name: this.name,
+      message: this.message,
+      code: this.code,
+      cause: this.cause?.message
+    }
+  }
+}
+
+/**
+ * Error codes for ERP connection errors
+ */
+export const ERP_ERROR_CODES = {
+  CONNECTION_FAILED: 'ERP_CONNECTION_FAILED',
+  LOGIN_FAILED: 'ERP_LOGIN_FAILED',
+  TIMEOUT: 'ERP_TIMEOUT',
+  NAVIGATION_ERROR: 'ERP_NAVIGATION_ERROR',
+  ELEMENT_NOT_FOUND: 'ERP_ELEMENT_NOT_FOUND',
+  SESSION_EXPIRED: 'ERP_SESSION_EXPIRED',
+  BROWSER_CRASH: 'ERP_BROWSER_CRASH'
+} as const
+
+/**
+ * Error thrown when ERP connection, login, or browser automation fails
+ */
+export class ErpConnectionError extends BaseError {
+  constructor(
+    message: string,
+    code: (typeof ERP_ERROR_CODES)[keyof typeof ERP_ERROR_CODES] = ERP_ERROR_CODES.CONNECTION_FAILED,
+    cause?: Error
+  ) {
+    super('ErpConnectionError', message, code, cause)
+  }
+}
+
+/**
+ * Error codes for database errors
+ */
+export const DATABASE_ERROR_CODES = {
+  CONNECTION_FAILED: 'DB_CONNECTION_FAILED',
+  QUERY_FAILED: 'DB_QUERY_FAILED',
+  TIMEOUT: 'DB_TIMEOUT',
+  INVALID_PARAMS: 'DB_INVALID_PARAMS',
+  RECORD_NOT_FOUND: 'DB_RECORD_NOT_FOUND',
+  TRANSACTION_FAILED: 'DB_TRANSACTION_FAILED'
+} as const
+
+/**
+ * Error thrown when database operations fail
+ */
+export class DatabaseQueryError extends BaseError {
+  constructor(
+    message: string,
+    code: (typeof DATABASE_ERROR_CODES)[keyof typeof DATABASE_ERROR_CODES] = DATABASE_ERROR_CODES.QUERY_FAILED,
+    cause?: Error
+  ) {
+    super('DatabaseQueryError', message, code, cause)
+  }
+}
+
+/**
+ * Error codes for validation errors
+ */
+export const VALIDATION_ERROR_CODES = {
+  INVALID_INPUT: 'VAL_INVALID_INPUT',
+  MISSING_REQUIRED: 'VAL_MISSING_REQUIRED',
+  INVALID_FORMAT: 'VAL_INVALID_FORMAT',
+  OUT_OF_RANGE: 'VAL_OUT_OF_RANGE',
+  INVALID_TYPE: 'VAL_INVALID_TYPE'
+} as const
+
+/**
+ * Error thrown when input validation fails
+ */
+export class ValidationError extends BaseError {
+  constructor(
+    message: string,
+    code: (typeof VALIDATION_ERROR_CODES)[keyof typeof VALIDATION_ERROR_CODES] = VALIDATION_ERROR_CODES.INVALID_INPUT,
+    cause?: Error
+  ) {
+    super('ValidationError', message, code, cause)
+  }
+}
+
+/**
+ * Type guard to check if an error is a BaseError
+ */
+export function isBaseError(error: unknown): error is BaseError {
+  return error instanceof BaseError
+}
+
+/**
+ * Type guard to check if an error is an ErpConnectionError
+ */
+export function isErpConnectionError(error: unknown): error is ErpConnectionError {
+  return error instanceof ErpConnectionError
+}
+
+/**
+ * Type guard to check if an error is a DatabaseQueryError
+ */
+export function isDatabaseQueryError(error: unknown): error is DatabaseQueryError {
+  return error instanceof DatabaseQueryError
+}
+
+/**
+ * Type guard to check if an error is a ValidationError
+ */
+export function isValidationError(error: unknown): error is ValidationError {
+  return error instanceof ValidationError
+}
+
+/**
+ * Get a user-friendly error message from any error type
+ * In production, generic errors are sanitized to avoid leaking sensitive info
+ */
+export function getErrorMessage(error: unknown): string {
+  if (isBaseError(error)) {
+    // BaseError messages are developer-controlled and safe
+    return error.message
+  }
+  if (error instanceof Error) {
+    // In production, return a generic message to avoid leaking sensitive info
+    // (e.g., database connection strings, file paths, server names)
+    if (process.env.NODE_ENV === 'production') {
+      return 'An unexpected error occurred'
+    }
+    return error.message
+  }
+  return 'An unknown error occurred'
+}
+
+/**
+ * Get error code from any error type
+ */
+export function getErrorCode(error: unknown): string {
+  if (isBaseError(error)) {
+    return error.code
+  }
+  return 'UNKNOWN_ERROR'
+}
--- a/src/main/types/settings.types.ts
+++ b/src/main/types/settings.types.ts
@@ -22,7 +22,11 @@ export type MatchMode = 'substring' | 'exact'
 /**
 * Validation data source options
 */
-export type ValidationDataSource = 'database_full' | 'database_filtered' | 'excel_existing' | 'excel_full'
+export type ValidationDataSource =
+  | 'database_full'
+  | 'database_filtered'
+  | 'excel_existing'
+  | 'excel_full'

 /**
 * ERP configuration
--- a/src/preload/index.d.ts
+++ b/src/preload/index.d.ts
@@ -9,7 +9,12 @@ import type {
  CurrentUserResponse
 } from '../main/ipc/auth-handler'
 import type { ValidationRequest, ValidationResponse } from '../main/types/validation.types'
-import type { SettingsData, UserType, ConnectionTestResult, SaveSettingsResult } from '../main/types/settings.types'
+import type {
+  SettingsData,
+  UserType,
+  ConnectionTestResult,
+  SaveSettingsResult
+} from '../main/types/settings.types'

 /**
 * Order number resolver API
--- a/src/preload/index.ts
+++ b/src/preload/index.ts
@@ -70,18 +70,15 @@ const api = {
    validate: (request: ValidationRequest) => ipcRenderer.invoke('validation:validate', request),
    setSharedProductionIds: (productionIds: string[]) =>
      ipcRenderer.invoke('validation:setSharedProductionIds', productionIds),
-    getSharedProductionIds: () =>
-      ipcRenderer.invoke('validation:getSharedProductionIds'),
-    getCleanerData: () =>
-      ipcRenderer.invoke('validation:getCleanerData')
+    getSharedProductionIds: () => ipcRenderer.invoke('validation:getSharedProductionIds'),
+    getCleanerData: () => ipcRenderer.invoke('validation:getCleanerData')
  },

  // Materials service
  materials: {
    upsertBatch: (materials: { materialCode: string; managerName: string }[]) =>
      ipcRenderer.invoke('materials:upsertBatch', { materials }),
-    delete: (materialCodes: string[]) =>
-      ipcRenderer.invoke('materials:delete', { materialCodes }),
+    delete: (materialCodes: string[]) => ipcRenderer.invoke('materials:delete', { materialCodes }),
    getManagers: () => ipcRenderer.invoke('materials:getManagers'),
    getByManager: (managerName: string) =>
      ipcRenderer.invoke('materials:getByManager', managerName),
--- a/src/renderer/src/App.tsx
+++ b/src/renderer/src/App.tsx
@@ -9,17 +9,11 @@
 */

 import React, { useState, useEffect } from 'react'
-import {
-  LayoutDashboard,
-  Download,
-  Trash2,
-  Settings,
-  Database,
-  User,
-  LogOut
-} from 'lucide-react'
+import { LayoutDashboard, Download, Trash2, Settings, Database, User, LogOut } from 'lucide-react'
 import LoginDialog from './components/LoginDialog'
-import UserSelectionDialog, { type UserInfo as SelectedUserInfo } from './components/UserSelectionDialog'
+import UserSelectionDialog, {
+  type UserInfo as SelectedUserInfo
+} from './components/UserSelectionDialog'
 import ExtractorPage from './pages/ExtractorPage'
 import CleanerPage from './pages/CleanerPage'
 import SettingsPage from './pages/SettingsPage'
@@ -225,7 +219,12 @@ function App(): React.JSX.Element {

  // Show login dialog if not authenticated
  if (!isAuthenticated) {
-    console.log('Render: not authenticated, showLoginDialog:', showLoginDialog, 'computerName:', computerName)
+    console.log(
+      'Render: not authenticated, showLoginDialog:',
+      showLoginDialog,
+      'computerName:',
+      computerName
+    )
    return (
      <>
        <LoginDialog
@@ -245,26 +244,28 @@ function App(): React.JSX.Element {
          onCancel={handleUserSelectionCancel}
        />

-        {errorMessage && (
-          <div className="error-toast">{errorMessage}</div>
-        )}
+        {errorMessage && <div className="error-toast">{errorMessage}</div>}

        {/* If showLoginDialog is false but not authenticated, show a message */}
        {!showLoginDialog && !showUserSelection && (
-          <div style={{
-            display: 'flex',
-            alignItems: 'center',
-            justifyContent: 'center',
-            minHeight: '100vh',
-            backgroundColor: '#f5f7fa'
-          }}>
-            <div style={{
-              padding: '40px',
-              backgroundColor: '#fff',
-              borderRadius: '8px',
-              boxShadow: '0 2px 8px rgba(0,0,0,0.1)',
-              textAlign: 'center'
-            }}>
+          <div
+            style={{
+              display: 'flex',
+              alignItems: 'center',
+              justifyContent: 'center',
+              minHeight: '100vh',
+              backgroundColor: '#f5f7fa'
+            }}
+          >
+            <div
+              style={{
+                padding: '40px',
+                backgroundColor: '#fff',
+                borderRadius: '8px',
+                boxShadow: '0 2px 8px rgba(0,0,0,0.1)',
+                textAlign: 'center'
+              }}
+            >
              <p style={{ color: '#52c41a', fontSize: '18px', fontWeight: 600 }}>
                欢迎，{currentUser?.username}！
              </p>
@@ -299,12 +300,11 @@ function App(): React.JSX.Element {
  const navItems = [
    { id: 'extractor', label: '数据提取 (Extractor)', icon: <Download size={18} /> },
    { id: 'cleaner', label: '物料验证与清理 (Cleaner)', icon: <Trash2 size={18} /> },
-    { id: 'settings', label: '系统设置 (Settings)', icon: <Settings size={18} /> },
-  ];
+    { id: 'settings', label: '系统设置 (Settings)', icon: <Settings size={18} /> }
+  ]

  return (
    <div className="flex flex-col h-screen bg-slate-50 text-slate-800 font-sans overflow-hidden">
-
      {/* ================= 顶部导航与标题栏 ================= */}
      <header
        className="h-16 bg-slate-900 text-slate-300 flex items-center justify-between px-4 shadow-md z-20 flex-shrink-0"
@@ -317,13 +317,20 @@ function App(): React.JSX.Element {
            <div className="w-3 h-3 rounded-full bg-green-500"></div>
          </div>

-          <div className="flex items-center gap-2 text-white font-bold text-lg cursor-pointer" onClick={() => setCurrentPage('home')} style={{ WebkitAppRegion: 'no-drag' } as any}>
+          <div
+            className="flex items-center gap-2 text-white font-bold text-lg cursor-pointer"
+            onClick={() => setCurrentPage('home')}
+            style={{ WebkitAppRegion: 'no-drag' } as any}
+          >
            <LayoutDashboard size={22} className="text-blue-500" />
            <span>ERP Auto</span>
          </div>
        </div>

-        <nav className="flex items-center gap-2 bg-slate-800 p-1 rounded-lg" style={{ WebkitAppRegion: 'no-drag' } as any}>
+        <nav
+          className="flex items-center gap-2 bg-slate-800 p-1 rounded-lg"
+          style={{ WebkitAppRegion: 'no-drag' } as any}
+        >
          {navItems.map((item) => (
            <button
              key={item.id}
@@ -340,14 +347,20 @@ function App(): React.JSX.Element {
          ))}
        </nav>

-        <div className="flex items-center gap-4 text-sm" style={{ WebkitAppRegion: 'no-drag' } as any}>
+        <div
+          className="flex items-center gap-4 text-sm"
+          style={{ WebkitAppRegion: 'no-drag' } as any}
+        >
          <div className="flex items-center gap-2 text-xs bg-slate-800 px-3 py-1.5 rounded-full border border-slate-700">
            <Database size={14} className="text-green-500" />
            <span className="text-slate-300">数据库已连接</span>
          </div>
          <div className="flex items-center gap-2 bg-slate-800 px-3 py-1.5 rounded-full">
            <User size={16} className="text-slate-400" />
-            <span className="font-medium text-slate-200" title={`User Type: ${currentUser?.userType}`}>
+            <span
+              className="font-medium text-slate-200"
+              title={`User Type: ${currentUser?.userType}`}
+            >
              {currentUser?.username}
            </span>
            {shouldShowLogout && (
--- a/src/renderer/src/assets/main.css
+++ b/src/renderer/src/assets/main.css
@@ -1,4 +1,4 @@
-@import "tailwindcss";
+@import 'tailwindcss';
@import './base.css';

 body {
--- a/src/renderer/src/components/LoginDialog.tsx
+++ b/src/renderer/src/components/LoginDialog.tsx
@@ -120,9 +120,7 @@ export const LoginDialog: React.FC<LoginDialogProps> = ({
          </button>
        </div>

-        <div className="login-version">
-          v1.0
-        </div>
+        <div className="login-version">v1.0</div>
      </div>

      <style>{`
--- a/src/renderer/src/components/UserSelectionDialog.tsx
+++ b/src/renderer/src/components/UserSelectionDialog.tsx
@@ -45,7 +45,7 @@ export const UserSelectionDialog: React.FC<UserSelectionDialogProps> = ({
      return
    }

-    const selectedUser = users.find(u => u.id === selectedUserId)
+    const selectedUser = users.find((u) => u.id === selectedUserId)
    if (selectedUser) {
      onSelectUser(selectedUser)
    }
@@ -102,17 +102,12 @@ export const UserSelectionDialog: React.FC<UserSelectionDialogProps> = ({
          >
            确认
          </button>
-          <button
-            className="btn btn-secondary"
-            onClick={onCancel}
-          >
+          <button className="btn btn-secondary" onClick={onCancel}>
            取消
          </button>
        </div>

-        <div className="user-selection-hint-footer">
-          双击用户可直接选择
-        </div>
+        <div className="user-selection-hint-footer">双击用户可直接选择</div>
      </div>

      <style>{`
--- a/src/renderer/src/components/ui/Button.tsx
+++ b/src/renderer/src/components/ui/Button.tsx
@@ -0,0 +1,80 @@
+/**
+ * Button Component
+ *
+ * A reusable button component with variants and sizes.
+ */
+
+import React from 'react'
+
+type ButtonVariant = 'primary' | 'secondary' | 'danger' | 'ghost'
+type ButtonSize = 'sm' | 'md' | 'lg'
+
+interface ButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
+  variant?: ButtonVariant
+  size?: ButtonSize
+  loading?: boolean
+  icon?: React.ReactNode
+  children: React.ReactNode
+}
+
+const variantStyles: Record<ButtonVariant, string> = {
+  primary: 'bg-blue-600 hover:bg-blue-700 text-white border-transparent',
+  secondary: 'bg-gray-100 hover:bg-gray-200 text-gray-800 border-gray-300',
+  danger: 'bg-red-600 hover:bg-red-700 text-white border-transparent',
+  ghost: 'bg-transparent hover:bg-gray-100 text-gray-700 border-transparent'
+}
+
+const sizeStyles: Record<ButtonSize, string> = {
+  sm: 'px-3 py-1.5 text-sm',
+  md: 'px-4 py-2 text-base',
+  lg: 'px-6 py-3 text-lg'
+}
+
+export function Button({
+  variant = 'primary',
+  size = 'md',
+  loading = false,
+  icon,
+  children,
+  className = '',
+  disabled,
+  ...props
+}: ButtonProps) {
+  const baseStyles =
+    'inline-flex items-center justify-center font-medium rounded-lg border transition-colors duration-150 focus:outline-none focus:ring-2 focus:ring-offset-2 focus:ring-blue-500 disabled:opacity-50 disabled:cursor-not-allowed'
+
+  return (
+    <button
+      className={`${baseStyles} ${variantStyles[variant]} ${sizeStyles[size]} ${className}`}
+      disabled={disabled || loading}
+      {...props}
+    >
+      {loading && (
+        <svg
+          className="animate-spin -ml-1 mr-2 h-4 w-4"
+          xmlns="http://www.w3.org/2000/svg"
+          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>
+      )}
+      {icon && !loading && <span className="mr-2">{icon}</span>}
+      {children}
+    </button>
+  )
+}
+
+export default Button
--- a/src/renderer/src/components/ui/Modal.tsx
+++ b/src/renderer/src/components/ui/Modal.tsx
@@ -0,0 +1,92 @@
+/**
+ * Modal Component
+ *
+ * A reusable modal dialog component.
+ */
+
+import React, { useEffect, useCallback } from 'react'
+import { X } from 'lucide-react'
+
+interface ModalProps {
+  isOpen: boolean
+  onClose: () => void
+  title?: string
+  children: React.ReactNode
+  size?: 'sm' | 'md' | 'lg' | 'xl'
+  showCloseButton?: boolean
+}
+
+const sizeStyles: Record<string, string> = {
+  sm: 'max-w-sm',
+  md: 'max-w-md',
+  lg: 'max-w-lg',
+  xl: 'max-w-xl'
+}
+
+export function Modal({
+  isOpen,
+  onClose,
+  title,
+  children,
+  size = 'md',
+  showCloseButton = true
+}: ModalProps) {
+  // Handle escape key
+  const handleKeyDown = useCallback(
+    (event: KeyboardEvent) => {
+      if (event.key === 'Escape') {
+        onClose()
+      }
+    },
+    [onClose]
+  )
+
+  useEffect(() => {
+    if (isOpen) {
+      document.addEventListener('keydown', handleKeyDown)
+      document.body.style.overflow = 'hidden'
+    }
+
+    return () => {
+      document.removeEventListener('keydown', handleKeyDown)
+      document.body.style.overflow = 'unset'
+    }
+  }, [isOpen, handleKeyDown])
+
+  if (!isOpen) return null
+
+  return (
+    <div className="fixed inset-0 z-50 overflow-y-auto">
+      {/* Backdrop */}
+      <div className="fixed inset-0 bg-black bg-opacity-50 transition-opacity" onClick={onClose} />
+
+      {/* Modal container */}
+      <div className="flex min-h-full items-center justify-center p-4">
+        <div
+          className={`relative w-full ${sizeStyles[size]} bg-white rounded-lg shadow-xl transform transition-all`}
+          onClick={(e) => e.stopPropagation()}
+        >
+          {/* Header */}
+          {(title || showCloseButton) && (
+            <div className="flex items-center justify-between px-6 py-4 border-b border-gray-200">
+              {title && <h3 className="text-lg font-semibold text-gray-900">{title}</h3>}
+              {showCloseButton && (
+                <button
+                  onClick={onClose}
+                  className="p-1 text-gray-400 hover:text-gray-600 focus:outline-none focus:ring-2 focus:ring-blue-500 rounded"
+                >
+                  <X className="w-5 h-5" />
+                </button>
+              )}
+            </div>
+          )}
+
+          {/* Content */}
+          <div className="px-6 py-4">{children}</div>
+        </div>
+      </div>
+    </div>
+  )
+}
+
+export default Modal
--- a/src/renderer/src/components/ui/Toast.tsx
+++ b/src/renderer/src/components/ui/Toast.tsx
@@ -0,0 +1,90 @@
+/**
+ * Toast Component
+ *
+ * A toast notification component for displaying messages.
+ */
+
+import React from 'react'
+import { CheckCircle, XCircle, AlertTriangle, Info, X } from 'lucide-react'
+import { useAppStore, selectToasts } from '../../stores/useAppStore'
+
+type ToastType = 'success' | 'error' | 'warning' | 'info'
+
+interface ToastItemProps {
+  id: string
+  type: ToastType
+  message: string
+  onClose: (id: string) => void
+}
+
+const typeStyles: Record<ToastType, { bg: string; border: string; icon: string }> = {
+  success: {
+    bg: 'bg-green-50',
+    border: 'border-green-200',
+    icon: 'text-green-500'
+  },
+  error: {
+    bg: 'bg-red-50',
+    border: 'border-red-200',
+    icon: 'text-red-500'
+  },
+  warning: {
+    bg: 'bg-yellow-50',
+    border: 'border-yellow-200',
+    icon: 'text-yellow-500'
+  },
+  info: {
+    bg: 'bg-blue-50',
+    border: 'border-blue-200',
+    icon: 'text-blue-500'
+  }
+}
+
+const ToastIcon: Record<ToastType, React.ReactNode> = {
+  success: <CheckCircle className="w-5 h-5" />,
+  error: <XCircle className="w-5 h-5" />,
+  warning: <AlertTriangle className="w-5 h-5" />,
+  info: <Info className="w-5 h-5" />
+}
+
+function ToastItem({ id, type, message, onClose }: ToastItemProps) {
+  const styles = typeStyles[type]
+
+  return (
+    <div
+      className={`flex items-center gap-3 px-4 py-3 rounded-lg border ${styles.bg} ${styles.border} shadow-lg min-w-72`}
+    >
+      <span className={styles.icon}>{ToastIcon[type]}</span>
+      <p className="flex-1 text-sm text-gray-800">{message}</p>
+      <button
+        onClick={() => onClose(id)}
+        className="p-1 text-gray-400 hover:text-gray-600 focus:outline-none"
+      >
+        <X className="w-4 h-4" />
+      </button>
+    </div>
+  )
+}
+
+export function Toast() {
+  const toasts = useAppStore(selectToasts)
+  const removeToast = useAppStore((state) => state.removeToast)
+
+  if (toasts.length === 0) return null
+
+  return (
+    <div className="fixed bottom-4 right-4 z-50 flex flex-col gap-2">
+      {toasts.map((toast) => (
+        <ToastItem
+          key={toast.id}
+          id={toast.id}
+          type={toast.type}
+          message={toast.message}
+          onClose={removeToast}
+        />
+      ))}
+    </div>
+  )
+}
+
+export default Toast
--- a/src/renderer/src/hooks/useAuth.ts
+++ b/src/renderer/src/hooks/useAuth.ts
@@ -0,0 +1,211 @@
+/**
+ * IPC Hook for Authentication operations
+ *
+ * Provides a React-friendly interface for auth IPC calls
+ * with loading state, error handling, and user data management.
+ */
+
+import { useState, useCallback } from 'react'
+
+// Types based on the user types
+interface UserInfo {
+  id: number
+  username: string
+  userType: 'Admin' | 'User' | 'Guest'
+  computerName?: string
+}
+
+interface LoginCredentials {
+  username: string
+  password: string
+}
+
+interface UseAuthState {
+  loading: boolean
+  user: UserInfo | null
+  error: string | null
+  isAuthenticated: boolean
+}
+
+interface UseAuthReturn extends UseAuthState {
+  login: (credentials: LoginCredentials) => Promise<boolean>
+  silentLogin: () => Promise<{ success: boolean; requiresUserSelection?: boolean }>
+  logout: () => Promise<void>
+  getCurrentUser: () => Promise<UserInfo | null>
+  getAllUsers: () => Promise<UserInfo[]>
+  switchUser: (userInfo: UserInfo) => Promise<boolean>
+  isAdmin: () => Promise<boolean>
+  reset: () => void
+}
+
+/**
+ * Hook for authentication operations
+ */
+export function useAuth(): UseAuthReturn {
+  const [state, setState] = useState<UseAuthState>({
+    loading: false,
+    user: null,
+    error: null,
+    isAuthenticated: false
+  })
+
+  const login = useCallback(async (credentials: LoginCredentials): Promise<boolean> => {
+    setState((prev) => ({ ...prev, loading: true, error: null }))
+
+    try {
+      const result = await window.electron.ipcRenderer.invoke('auth:login', credentials)
+
+      if (result.success && result.userInfo) {
+        setState({
+          loading: false,
+          user: result.userInfo,
+          error: null,
+          isAuthenticated: true
+        })
+        return true
+      } else {
+        setState((prev) => ({
+          ...prev,
+          loading: false,
+          error: result.error || 'Login failed'
+        }))
+        return false
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : 'Unknown error'
+      setState((prev) => ({ ...prev, loading: false, error: message }))
+      return false
+    }
+  }, [])
+
+  const silentLogin = useCallback(async (): Promise<{
+    success: boolean
+    requiresUserSelection?: boolean
+  }> => {
+    setState((prev) => ({ ...prev, loading: true, error: null }))
+
+    try {
+      const result = await window.electron.ipcRenderer.invoke('auth:silentLogin')
+
+      if (result.success && result.userInfo) {
+        setState({
+          loading: false,
+          user: result.userInfo,
+          error: null,
+          isAuthenticated: true
+        })
+        return { success: true, requiresUserSelection: result.requiresUserSelection }
+      } else {
+        setState((prev) => ({
+          ...prev,
+          loading: false,
+          error: result.error || null
+        }))
+        return { success: false }
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : 'Unknown error'
+      setState((prev) => ({ ...prev, loading: false, error: message }))
+      return { success: false }
+    }
+  }, [])
+
+  const logout = useCallback(async (): Promise<void> => {
+    try {
+      await window.electron.ipcRenderer.invoke('auth:logout')
+      setState({
+        loading: false,
+        user: null,
+        error: null,
+        isAuthenticated: false
+      })
+    } catch (error) {
+      console.error('Logout error:', error)
+    }
+  }, [])
+
+  const getCurrentUser = useCallback(async (): Promise<UserInfo | null> => {
+    try {
+      const result = await window.electron.ipcRenderer.invoke('auth:getCurrentUser')
+      if (result.isAuthenticated && result.userInfo) {
+        setState((prev) => ({
+          ...prev,
+          user: result.userInfo,
+          isAuthenticated: true
+        }))
+        return result.userInfo
+      }
+      return null
+    } catch {
+      return null
+    }
+  }, [])
+
+  const getAllUsers = useCallback(async (): Promise<UserInfo[]> => {
+    try {
+      return await window.electron.ipcRenderer.invoke('auth:getAllUsers')
+    } catch {
+      return []
+    }
+  }, [])
+
+  const switchUser = useCallback(async (userInfo: UserInfo): Promise<boolean> => {
+    setState((prev) => ({ ...prev, loading: true, error: null }))
+
+    try {
+      const result = await window.electron.ipcRenderer.invoke('auth:switchUser', userInfo)
+
+      if (result.success && result.userInfo) {
+        setState({
+          loading: false,
+          user: result.userInfo,
+          error: null,
+          isAuthenticated: true
+        })
+        return true
+      } else {
+        setState((prev) => ({
+          ...prev,
+          loading: false,
+          error: result.error || 'Switch user failed'
+        }))
+        return false
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : 'Unknown error'
+      setState((prev) => ({ ...prev, loading: false, error: message }))
+      return false
+    }
+  }, [])
+
+  const isAdmin = useCallback(async (): Promise<boolean> => {
+    try {
+      return await window.electron.ipcRenderer.invoke('auth:isAdmin')
+    } catch {
+      return false
+    }
+  }, [])
+
+  const reset = useCallback(() => {
+    setState({
+      loading: false,
+      user: null,
+      error: null,
+      isAuthenticated: false
+    })
+  }, [])
+
+  return {
+    ...state,
+    login,
+    silentLogin,
+    logout,
+    getCurrentUser,
+    getAllUsers,
+    switchUser,
+    isAdmin,
+    reset
+  }
+}
+
+export default useAuth
--- a/src/renderer/src/hooks/useCleaner.ts
+++ b/src/renderer/src/hooks/useCleaner.ts
@@ -0,0 +1,74 @@
+/**
+ * IPC Hook for Cleaner operations
+ *
+ * Provides a React-friendly interface for cleaner IPC calls
+ * with loading state, error handling, and data management.
+ */
+
+import { useState, useCallback } from 'react'
+
+// Types based on the cleaner types
+interface CleanerInput {
+  orderNumbers: string[]
+  materialCodes: string[]
+  dryRun: boolean
+}
+
+interface CleanerResult {
+  processedCount: number
+  errors: string[]
+}
+
+interface UseCleanerState {
+  loading: boolean
+  data: CleanerResult | null
+  error: string | null
+}
+
+interface UseCleanerReturn extends UseCleanerState {
+  execute: (input: CleanerInput) => Promise<CleanerResult | null>
+  reset: () => void
+}
+
+/**
+ * Hook for executing cleaner operations
+ */
+export function useCleaner(): UseCleanerReturn {
+  const [state, setState] = useState<UseCleanerState>({
+    loading: false,
+    data: null,
+    error: null
+  })
+
+  const execute = useCallback(async (input: CleanerInput): Promise<CleanerResult | null> => {
+    setState({ loading: true, data: null, error: null })
+
+    try {
+      const result = await window.electron.ipcRenderer.invoke('cleaner:run', input)
+
+      if (result.success) {
+        setState({ loading: false, data: result.data, error: null })
+        return result.data
+      } else {
+        setState({ loading: false, data: null, error: result.error || 'Unknown error' })
+        return null
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : 'Unknown error'
+      setState({ loading: false, data: null, error: message })
+      return null
+    }
+  }, [])
+
+  const reset = useCallback(() => {
+    setState({ loading: false, data: null, error: null })
+  }, [])
+
+  return {
+    ...state,
+    execute,
+    reset
+  }
+}
+
+export default useCleaner
--- a/src/renderer/src/hooks/useExtractor.ts
+++ b/src/renderer/src/hooks/useExtractor.ts
@@ -0,0 +1,73 @@
+/**
+ * IPC Hook for Extractor operations
+ *
+ * Provides a React-friendly interface for extractor IPC calls
+ * with loading state, error handling, and data management.
+ */
+
+import { useState, useCallback } from 'react'
+
+// Types based on the extractor types
+interface ExtractorInput {
+  orderNumbers: string[]
+  batchSize?: number
+}
+
+interface ExtractorResult {
+  data: Record<string, unknown>[]
+  errors: string[]
+}
+
+interface UseExtractorState {
+  loading: boolean
+  data: ExtractorResult | null
+  error: string | null
+}
+
+interface UseExtractorReturn extends UseExtractorState {
+  execute: (input: ExtractorInput) => Promise<ExtractorResult | null>
+  reset: () => void
+}
+
+/**
+ * Hook for executing extractor operations
+ */
+export function useExtractor(): UseExtractorReturn {
+  const [state, setState] = useState<UseExtractorState>({
+    loading: false,
+    data: null,
+    error: null
+  })
+
+  const execute = useCallback(async (input: ExtractorInput): Promise<ExtractorResult | null> => {
+    setState({ loading: true, data: null, error: null })
+
+    try {
+      const result = await window.electron.ipcRenderer.invoke('extractor:run', input)
+
+      if (result.success) {
+        setState({ loading: false, data: result.data, error: null })
+        return result.data
+      } else {
+        setState({ loading: false, data: null, error: result.error || 'Unknown error' })
+        return null
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : 'Unknown error'
+      setState({ loading: false, data: null, error: message })
+      return null
+    }
+  }, [])
+
+  const reset = useCallback(() => {
+    setState({ loading: false, data: null, error: null })
+  }, [])
+
+  return {
+    ...state,
+    execute,
+    reset
+  }
+}
+
+export default useExtractor
--- a/src/renderer/src/hooks/useValidation.ts
+++ b/src/renderer/src/hooks/useValidation.ts
@@ -0,0 +1,152 @@
+/**
+ * IPC Hook for Validation operations
+ *
+ * Provides a React-friendly interface for validation IPC calls
+ * with loading state, error handling, and data management.
+ */
+
+import { useState, useCallback } from 'react'
+
+// Types based on validation types
+interface ValidationRequest {
+  mode: 'database_full' | 'database_filtered'
+  productionIdFile?: string
+  useSharedProductionIds?: boolean
+}
+
+interface ValidationResult {
+  materialName: string
+  materialCode: string
+  specification: string
+  model: string
+  managerName: string
+  isMarkedForDeletion: boolean
+  matchedTypeKeyword?: string
+}
+
+interface ValidationStats {
+  totalRecords: number
+  matchedCount: number
+  markedCount: number
+}
+
+interface ValidationResponse {
+  success: boolean
+  results?: ValidationResult[]
+  stats?: ValidationStats
+  error?: string
+}
+
+interface UseValidationState {
+  loading: boolean
+  data: ValidationResult[] | null
+  stats: ValidationStats | null
+  error: string | null
+}
+
+interface UseValidationReturn extends UseValidationState {
+  validate: (request: ValidationRequest) => Promise<ValidationResponse | null>
+  setSharedProductionIds: (ids: string[]) => Promise<void>
+  getSharedProductionIds: () => Promise<string[]>
+  getCleanerData: () => Promise<{ orderNumbers: string[]; materialCodes: string[] } | null>
+  reset: () => void
+}
+
+/**
+ * Hook for validation operations
+ */
+export function useValidation(): UseValidationReturn {
+  const [state, setState] = useState<UseValidationState>({
+    loading: false,
+    data: null,
+    stats: null,
+    error: null
+  })
+
+  const validate = useCallback(
+    async (request: ValidationRequest): Promise<ValidationResponse | null> => {
+      setState((prev) => ({ ...prev, loading: true, error: null }))
+
+      try {
+        const result = await window.electron.ipcRenderer.invoke('validation:validate', request)
+
+        if (result.success) {
+          setState({
+            loading: false,
+            data: result.results || null,
+            stats: result.stats || null,
+            error: null
+          })
+          return result
+        } else {
+          setState((prev) => ({
+            ...prev,
+            loading: false,
+            error: result.error || 'Validation failed'
+          }))
+          return result
+        }
+      } catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown error'
+        setState((prev) => ({ ...prev, loading: false, error: message }))
+        return null
+      }
+    },
+    []
+  )
+
+  const setSharedProductionIds = useCallback(async (ids: string[]): Promise<void> => {
+    try {
+      await window.electron.ipcRenderer.invoke('validation:setSharedProductionIds', ids)
+    } catch (error) {
+      console.error('Failed to set shared production IDs:', error)
+    }
+  }, [])
+
+  const getSharedProductionIds = useCallback(async (): Promise<string[]> => {
+    try {
+      const result = await window.electron.ipcRenderer.invoke('validation:getSharedProductionIds')
+      return result?.productionIds || []
+    } catch {
+      return []
+    }
+  }, [])
+
+  const getCleanerData = useCallback(async (): Promise<{
+    orderNumbers: string[]
+    materialCodes: string[]
+  } | null> => {
+    try {
+      const result = await window.electron.ipcRenderer.invoke('validation:getCleanerData')
+      if (result.success) {
+        return {
+          orderNumbers: result.orderNumbers || [],
+          materialCodes: result.materialCodes || []
+        }
+      }
+      return null
+    } catch {
+      return null
+    }
+  }, [])
+
+  const reset = useCallback(() => {
+    setState({
+      loading: false,
+      data: null,
+      stats: null,
+      error: null
+    })
+  }, [])
+
+  return {
+    ...state,
+    validate,
+    setSharedProductionIds,
+    getSharedProductionIds,
+    getCleanerData,
+    reset
+  }
+}
+
+export default useValidation
--- a/src/renderer/src/pages/CleanerPage.tsx
+++ b/src/renderer/src/pages/CleanerPage.tsx
@@ -103,13 +103,11 @@ const CleanerPage: React.FC = () => {
  const filteredResults = React.useMemo(() => {
    let results = validationResults
    if (!isAdmin && currentUsername) {
-      results = results.filter(r => r.managerName === currentUsername || !r.managerName)
+      results = results.filter((r) => r.managerName === currentUsername || !r.managerName)
    } else if (managers.length > 0 && selectedManagers.size > 0) {
-      results = results.filter(
-        r => selectedManagers.has(r.managerName) || !r.managerName
-      )
+      results = results.filter((r) => selectedManagers.has(r.managerName) || !r.managerName)
    }
-    results = results.filter(r => !hiddenItems.has(r.materialCode))
+    results = results.filter((r) => !hiddenItems.has(r.materialCode))
    return results
  }, [validationResults, isAdmin, currentUsername, managers, selectedManagers, hiddenItems])

@@ -129,18 +127,12 @@ const CleanerPage: React.FC = () => {
      if (response.success && response.results) {
        setValidationResults(response.results)
        const markedCodes = new Set(
-          response.results
-            .filter(r => r.isMarkedForDeletion)
-            .map(r => r.materialCode)
+          response.results.filter((r) => r.isMarkedForDeletion).map((r) => r.materialCode)
        )
        setSelectedItems(markedCodes)

        if (isAdmin) {
-          const uniqueManagers = new Set(
-            response.results
-              .map(r => r.managerName)
-              .filter(Boolean)
-          )
+          const uniqueManagers = new Set(response.results.map((r) => r.managerName).filter(Boolean))
          setManagers([...uniqueManagers])
          setSelectedManagers(uniqueManagers)
        }
@@ -155,7 +147,7 @@ const CleanerPage: React.FC = () => {
  }

  const handleCheckboxToggle = (materialCode: string) => {
-    setSelectedItems(prev => {
+    setSelectedItems((prev) => {
      const newSet = new Set(prev)
      if (newSet.has(materialCode)) newSet.delete(materialCode)
      else newSet.add(materialCode)
@@ -183,14 +175,18 @@ const CleanerPage: React.FC = () => {
    }

    if (missingManager.length > 0) {
-      alert(`以下已勾选的记录缺少负责人信息，无法保存：\n\n${missingManager.slice(0, 10).join('\n')}`)
+      alert(
+        `以下已勾选的记录缺少负责人信息，无法保存：\n\n${missingManager.slice(0, 10).join('\n')}`
+      )
      return
    }

-    if (materialsToUpsert.length === 0 && materialsToDelete.length === 0) return alert('没有需要处理的记录')
+    if (materialsToUpsert.length === 0 && materialsToDelete.length === 0)
+      return alert('没有需要处理的记录')

    const confirmParts: string[] = []
-    if (materialsToUpsert.length > 0) confirmParts.push(`写入/更新 ${materialsToUpsert.length} 条记录`)
+    if (materialsToUpsert.length > 0)
+      confirmParts.push(`写入/更新 ${materialsToUpsert.length} 条记录`)
    if (materialsToDelete.length > 0) confirmParts.push(`删除 ${materialsToDelete.length} 条记录`)

    if (!window.confirm(`确认以下操作吗？\n\n${confirmParts.join('\n')}`)) return
@@ -215,8 +211,8 @@ const CleanerPage: React.FC = () => {

      // Reload managers if admin
      if (isAdmin) {
-         const resp = await window.electron.materials.getManagers()
-         setManagers(resp.managers)
+        const resp = await window.electron.materials.getManagers()
+        setManagers(resp.managers)
      }
    } catch (err) {
      alert(err instanceof Error ? err.message : '操作失败')
@@ -240,8 +236,10 @@ const CleanerPage: React.FC = () => {
      const orderNumberList = cleanerDataResult.orderNumbers || []
      const materialCodeList = cleanerDataResult.materialCodes || []

-      if (orderNumberList.length === 0) throw new Error('没有订单号数据。请先到数据提取页面输入 Production ID。')
-      if (materialCodeList.length === 0) throw new Error('没有物料代码数据。请确认已在物料清理界面确认要删除的物料。')
+      if (orderNumberList.length === 0)
+        throw new Error('没有订单号数据。请先到数据提取页面输入 Production ID。')
+      if (materialCodeList.length === 0)
+        throw new Error('没有物料代码数据。请确认已在物料清理界面确认要删除的物料。')

      const response = await window.electron.cleaner.runCleaner({
        orderNumbers: orderNumberList,
@@ -250,11 +248,11 @@ const CleanerPage: React.FC = () => {
      })

      if (response.success && response.data) {
-         let msg = `清理执行完毕:\n处理订单: ${response.data.ordersProcessed}\n删除物料: ${response.data.materialsDeleted}\n跳过物料: ${response.data.materialsSkipped}`
-         if (response.data.errors.length) {
-            msg += `\n错误: ${response.data.errors.join(', ')}`
-         }
-         alert(msg)
+        let msg = `清理执行完毕:\n处理订单: ${response.data.ordersProcessed}\n删除物料: ${response.data.materialsDeleted}\n跳过物料: ${response.data.materialsSkipped}`
+        if (response.data.errors.length) {
+          msg += `\n错误: ${response.data.errors.join(', ')}`
+        }
+        alert(msg)
      } else {
        throw new Error(response.error || '清理失败')
      }
@@ -267,10 +265,8 @@ const CleanerPage: React.FC = () => {

  return (
    <div className="h-full flex flex-col xl:flex-row gap-6 animate-in fade-in slide-in-from-bottom-4 duration-500">
-
      {/* 左栏：数据源与执行控制区 */}
      <div className="xl:w-[380px] flex-shrink-0 flex flex-col gap-5">
-
        {/* 1. 数据来源选择 (仅 Admin 可见) */}
        {isAdmin && (
          <div className="bg-white rounded-xl shadow-sm border border-slate-200 p-5">
@@ -280,7 +276,9 @@ const CleanerPage: React.FC = () => {
            </h3>

            <div className="space-y-3">
-              <label className={`flex items-start gap-3 p-3 rounded-lg border cursor-pointer transition-colors ${valMode === 'full' ? 'bg-blue-50 border-blue-200' : 'hover:bg-slate-50 border-slate-200'}`}>
+              <label
+                className={`flex items-start gap-3 p-3 rounded-lg border cursor-pointer transition-colors ${valMode === 'full' ? 'bg-blue-50 border-blue-200' : 'hover:bg-slate-50 border-slate-200'}`}
+              >
                <input
                  type="radio"
                  name="valMode"
@@ -294,7 +292,9 @@ const CleanerPage: React.FC = () => {
                </div>
              </label>

-              <label className={`flex items-start gap-3 p-3 rounded-lg border cursor-pointer transition-colors ${valMode === 'filtered' ? 'bg-blue-50 border-blue-200' : 'hover:bg-slate-50 border-slate-200'}`}>
+              <label
+                className={`flex items-start gap-3 p-3 rounded-lg border cursor-pointer transition-colors ${valMode === 'filtered' ? 'bg-blue-50 border-blue-200' : 'hover:bg-slate-50 border-slate-200'}`}
+              >
                <input
                  type="radio"
                  name="valMode"
@@ -303,12 +303,16 @@ const CleanerPage: React.FC = () => {
                  onChange={() => setValMode('filtered')}
                />
                <div className="w-full">
-                  <div className="text-sm font-medium text-slate-800">数据库 - ProductionID 过滤</div>
+                  <div className="text-sm font-medium text-slate-800">
+                    数据库 - ProductionID 过滤
+                  </div>
                  <div className="text-xs text-slate-500 mt-0.5">仅校验指定订单号相关的物料</div>
                  {valMode === 'filtered' && (
                    <div className="mt-3 text-xs text-blue-700 bg-blue-100/50 rounded p-2 flex items-start gap-1.5">
                      <Layers size={14} className="mt-0.5 flex-shrink-0" />
-                      <span>自动使用<strong>【数据提取】</strong>模块中共享的订单号列表进行过滤。</span>
+                      <span>
+                        自动使用<strong>【数据提取】</strong>模块中共享的订单号列表进行过滤。
+                      </span>
                    </div>
                  )}
                </div>
@@ -329,23 +333,30 @@ const CleanerPage: React.FC = () => {
                <button
                  onClick={() => setSelectedManagers(new Set(managers))}
                  className="text-xs text-blue-600 hover:underline"
-                >全选</button>
+                >
+                  全选
+                </button>
                <button
                  onClick={() => setSelectedManagers(new Set())}
                  className="text-xs text-slate-500 hover:underline"
-                >取消全选</button>
+                >
+                  取消全选
+                </button>
              </div>
            </div>

            <div className="grid grid-cols-2 gap-2 mt-3 max-h-[120px] overflow-y-auto pr-1">
-              {managers.map(manager => (
-                <label key={manager} className="flex items-center gap-2 text-sm text-slate-700 cursor-pointer hover:bg-slate-50 p-1.5 rounded">
+              {managers.map((manager) => (
+                <label
+                  key={manager}
+                  className="flex items-center gap-2 text-sm text-slate-700 cursor-pointer hover:bg-slate-50 p-1.5 rounded"
+                >
                  <input
                    type="checkbox"
                    className="rounded text-blue-600"
                    checked={selectedManagers.has(manager)}
                    onChange={(e) => {
-                      setSelectedManagers(prev => {
+                      setSelectedManagers((prev) => {
                        const newSet = new Set(prev)
                        if (e.target.checked) newSet.add(manager)
                        else newSet.delete(manager)
@@ -356,7 +367,9 @@ const CleanerPage: React.FC = () => {
                  {manager || '未分配'}
                </label>
              ))}
-              {managers.length === 0 && <div className="text-sm text-slate-400">暂无负责人数据</div>}
+              {managers.length === 0 && (
+                <div className="text-sm text-slate-400">暂无负责人数据</div>
+              )}
            </div>
          </div>
        )}
@@ -367,7 +380,9 @@ const CleanerPage: React.FC = () => {
            <div className="flex items-center justify-between bg-amber-50/50 p-3 rounded-lg border border-amber-200 mb-4">
              <div>
                <div className="font-semibold text-sm text-amber-900">预览模式 (Dry-Run)</div>
-                <div className="text-xs text-amber-700/80 mt-0.5">仅执行页面操作定位，不保存更改</div>
+                <div className="text-xs text-amber-700/80 mt-0.5">
+                  仅执行页面操作定位，不保存更改
+                </div>
              </div>
              <button
                onClick={() => setDryRun(!dryRun)}
@@ -392,39 +407,41 @@ const CleanerPage: React.FC = () => {

      {/* 右栏：结果表格与工具栏 */}
      <div className="flex-1 bg-white rounded-xl shadow-sm border border-slate-200 flex flex-col overflow-hidden min-h-[500px]">
-
        {/* 顶部操作条 */}
        <div className="bg-slate-50 border-b border-slate-200 px-4 py-3 flex justify-between items-center">
          <div className="flex flex-wrap items-center gap-2">
            <button
-              onClick={() => setSelectedItems(new Set(filteredResults.map(r => r.materialCode)))}
+              onClick={() => setSelectedItems(new Set(filteredResults.map((r) => r.materialCode)))}
              className="text-xs bg-white border border-slate-300 text-slate-700 px-2.5 py-1.5 rounded shadow-sm hover:bg-slate-50 flex items-center gap-1"
            >
-              <CheckSquare size={14} className="text-blue-600"/> 全选
+              <CheckSquare size={14} className="text-blue-600" /> 全选
            </button>
            <button
              onClick={() => setSelectedItems(new Set())}
              className="text-xs bg-white border border-slate-300 text-slate-700 px-2.5 py-1.5 rounded shadow-sm hover:bg-slate-50 flex items-center gap-1"
            >
-              <Square size={14} className="text-slate-400"/> 取消
+              <Square size={14} className="text-slate-400" /> 取消
            </button>

            <div className="w-px h-4 bg-slate-300 mx-1"></div>

            <button
              onClick={() => {
-                const checkedCodes = filteredResults.filter(r => selectedItems.has(r.materialCode)).map(r => r.materialCode)
-                if (checkedCodes.length) setHiddenItems(prev => new Set([...prev, ...checkedCodes]))
+                const checkedCodes = filteredResults
+                  .filter((r) => selectedItems.has(r.materialCode))
+                  .map((r) => r.materialCode)
+                if (checkedCodes.length)
+                  setHiddenItems((prev) => new Set([...prev, ...checkedCodes]))
              }}
              className="text-xs bg-white border border-slate-300 text-slate-700 px-2.5 py-1.5 rounded shadow-sm hover:bg-slate-50 flex items-center gap-1"
            >
-              <EyeOff size={14}/> 隐藏勾选
+              <EyeOff size={14} /> 隐藏勾选
            </button>
            <button
              onClick={() => setHiddenItems(new Set())}
              className="text-xs bg-white border border-slate-300 text-slate-700 px-2.5 py-1.5 rounded shadow-sm hover:bg-slate-50 flex items-center gap-1"
            >
-              <Eye size={14}/> 显示全部
+              <Eye size={14} /> 显示全部
            </button>

            <div className="w-px h-4 bg-slate-300 mx-1"></div>
@@ -458,37 +475,77 @@ const CleanerPage: React.FC = () => {
                <th className="px-4 py-3">材料代码</th>
                <th className="px-4 py-3">规格</th>
                <th className="px-4 py-3">型号</th>
-                <th className="px-4 py-3 w-40">负责人 <span className="text-[10px] font-normal text-slate-400">(双击编辑)</span></th>
+                <th className="px-4 py-3 w-40">
+                  负责人 <span className="text-[10px] font-normal text-slate-400">(双击编辑)</span>
+                </th>
              </tr>
            </thead>
            <tbody className="divide-y divide-slate-100">
              {filteredResults.length === 0 ? (
                <tr>
                  <td colSpan={6} className="px-4 py-8 text-center text-slate-400 text-sm">
-                    {validationResults.length === 0 ? '暂无数据，请点击左侧按钮获取并校验物料' : '当前筛选条件下暂无数据'}
+                    {validationResults.length === 0
+                      ? '暂无数据，请点击左侧按钮获取并校验物料'
+                      : '当前筛选条件下暂无数据'}
                  </td>
                </tr>
              ) : (
-                filteredResults.map(result => {
+                filteredResults.map((result) => {
                  const isChecked = selectedItems.has(result.materialCode)
                  const trClass = isChecked ? 'bg-blue-50/30' : 'hover:bg-slate-50'
                  const noManager = !result.managerName?.trim()
-                  const managerCellClass = noManager ? 'text-amber-500 text-xs italic' : 'text-slate-700'
+                  const managerCellClass = noManager
+                    ? 'text-amber-500 text-xs italic'
+                    : 'text-slate-700'

                  return (
-                    <tr key={result.materialCode} className={`${trClass} transition-colors ${noManager && isChecked ? 'bg-amber-50/20' : ''}`}>
+                    <tr
+                      key={result.materialCode}
+                      className={`${trClass} transition-colors ${noManager && isChecked ? 'bg-amber-50/20' : ''}`}
+                    >
                      <td className="px-4 py-3 text-center truncate">
                        {isChecked ? (
-                          <CheckSquare onClick={() => handleCheckboxToggle(result.materialCode)} size={16} className="text-blue-600 inline cursor-pointer" />
+                          <CheckSquare
+                            onClick={() => handleCheckboxToggle(result.materialCode)}
+                            size={16}
+                            className="text-blue-600 inline cursor-pointer"
+                          />
                        ) : (
-                          <Square onClick={() => handleCheckboxToggle(result.materialCode)} size={16} className="text-slate-300 inline cursor-pointer" />
+                          <Square
+                            onClick={() => handleCheckboxToggle(result.materialCode)}
+                            size={16}
+                            className="text-slate-300 inline cursor-pointer"
+                          />
                        )}
                      </td>
-                      <td className="px-4 py-3 font-medium text-slate-800 truncate" title={result.materialName}>{result.materialName}</td>
-                      <td className="px-4 py-3 font-mono text-xs text-slate-600 truncate" title={result.materialCode}>{result.materialCode}</td>
-                      <td className="px-4 py-3 text-slate-500 text-xs truncate" title={result.specification}>{result.specification || '-'}</td>
-                      <td className="px-4 py-3 text-slate-500 text-xs truncate" title={result.model}>{result.model || '-'}</td>
-                      <td className={`px-4 py-3 truncate ${managerCellClass}`} title={result.managerName || '空(待分配)'}>
+                      <td
+                        className="px-4 py-3 font-medium text-slate-800 truncate"
+                        title={result.materialName}
+                      >
+                        {result.materialName}
+                      </td>
+                      <td
+                        className="px-4 py-3 font-mono text-xs text-slate-600 truncate"
+                        title={result.materialCode}
+                      >
+                        {result.materialCode}
+                      </td>
+                      <td
+                        className="px-4 py-3 text-slate-500 text-xs truncate"
+                        title={result.specification}
+                      >
+                        {result.specification || '-'}
+                      </td>
+                      <td
+                        className="px-4 py-3 text-slate-500 text-xs truncate"
+                        title={result.model}
+                      >
+                        {result.model || '-'}
+                      </td>
+                      <td
+                        className={`px-4 py-3 truncate ${managerCellClass}`}
+                        title={result.managerName || '空(待分配)'}
+                      >
                        {result.managerName || '空(待分配)'}
                      </td>
                    </tr>
@@ -503,7 +560,8 @@ const CleanerPage: React.FC = () => {
        <div className="bg-white border-t border-slate-200 p-4 flex justify-between items-center shadow-[0_-4px_6px_-1px_rgba(0,0,0,0.05)] z-10">
          <div className="flex items-center gap-3">
            <div className="text-sm text-slate-600 font-medium">
-              共计 {filteredResults.length} 条记录 | 已选中 <span className="text-blue-600">{selectedItems.size}</span> 条
+              共计 {filteredResults.length} 条记录 | 已选中{' '}
+              <span className="text-blue-600">{selectedItems.size}</span> 条
            </div>
            {isAdmin && dryRun && (
              <span className="text-xs bg-amber-100 text-amber-700 px-2 py-1 rounded border border-amber-200">
@@ -528,13 +586,12 @@ const CleanerPage: React.FC = () => {
              disabled={isRunning || validationResults.length === 0}
              className={`${isAdmin && dryRun ? 'bg-amber-500 hover:bg-amber-600' : 'bg-red-600 hover:bg-red-700 shadow-red-500/30'} text-white px-8 py-2.5 rounded-lg font-medium shadow-md transition-all flex items-center gap-2 disabled:opacity-50`}
            >
-              <Play size={18} fill="currentColor" /> {isAdmin && dryRun ? '开始预览执行' : '正式执行 ERP 清理'}
+              <Play size={18} fill="currentColor" />{' '}
+              {isAdmin && dryRun ? '开始预览执行' : '正式执行 ERP 清理'}
            </button>
          </div>
        </div>
-
      </div>
-
    </div>
  )
 }
--- a/src/renderer/src/pages/ExtractorPage.tsx
+++ b/src/renderer/src/pages/ExtractorPage.tsx
@@ -38,8 +38,8 @@ const ExtractorPage: React.FC = () => {
    if (orderNumbers.trim()) {
      const orderNumberList = orderNumbers
        .split('\n')
-        .map(line => line.trim())
-        .filter(line => line.length > 0)
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0)
      window.electron.validation.setSharedProductionIds(orderNumberList)
    }
  }, [orderNumbers])
@@ -104,7 +104,10 @@ const ExtractorPage: React.FC = () => {

  useEffect(() => {
    if (progress) {
-      setLogs(prev => [...prev, `[${new Date().toLocaleTimeString()}] [Info] ${progress.message}`])
+      setLogs((prev) => [
+        ...prev,
+        `[${new Date().toLocaleTimeString()}] [Info] ${progress.message}`
+      ])
    }
  }, [progress])

@@ -114,7 +117,9 @@ const ExtractorPage: React.FC = () => {
      <aside className="w-80 bg-white border border-slate-200 flex flex-col shadow-sm z-10 flex-shrink-0 animate-in slide-in-from-left duration-300 rounded-xl overflow-hidden h-full">
        <div className="flex-1 flex flex-col p-5 space-y-3 h-full">
          <div>
-            <label className="text-sm font-medium text-slate-700">支持输入总排号或者生产订单号</label>
+            <label className="text-sm font-medium text-slate-700">
+              支持输入总排号或者生产订单号
+            </label>
            <p className="text-xs text-slate-500 leading-relaxed mt-1">
              在此输入的数据将在“数据提取”与“物料清理”模块中自动共享，每行一个。
            </p>
@@ -130,8 +135,20 @@ const ExtractorPage: React.FC = () => {
          ></textarea>

          <div className="flex items-center justify-between text-xs text-slate-500 pt-2">
-            <span>共解析: <strong className="text-slate-700">{orderNumbers.split('\n').filter(l => l.trim()).length}</strong> 个订单</span>
-            <button className="text-slate-400 hover:text-slate-600" onClick={handleReset} disabled={isRunning}>清空</button>
+            <span>
+              共解析:{' '}
+              <strong className="text-slate-700">
+                {orderNumbers.split('\n').filter((l) => l.trim()).length}
+              </strong>{' '}
+              个订单
+            </span>
+            <button
+              className="text-slate-400 hover:text-slate-600"
+              onClick={handleReset}
+              disabled={isRunning}
+            >
+              清空
+            </button>
          </div>
        </div>
      </aside>
@@ -144,7 +161,9 @@ const ExtractorPage: React.FC = () => {
              <Download size={20} className="text-blue-600" />
              批量数据提取
            </h2>
-            <p className="text-sm text-slate-500">将遍历左侧列表中的所有生产订单，依次自动执行数据导出并保存。</p>
+            <p className="text-sm text-slate-500">
+              将遍历左侧列表中的所有生产订单，依次自动执行数据导出并保存。
+            </p>
            {error && <p className="text-sm text-red-500 mt-2">{error}</p>}
          </div>

@@ -161,21 +180,27 @@ const ExtractorPage: React.FC = () => {
        {/* 结果展示 */}
        {result && (
          <div className="bg-white rounded-xl shadow-sm border border-slate-200 p-6 flex flex-col gap-4">
-             <h3 className="text-emerald-600 font-semibold text-lg border-b pb-2">提取结果</h3>
-             <div className="grid grid-cols-3 gap-4">
-                <div className="bg-slate-50 p-4 rounded-lg border border-slate-100 flex flex-col items-center justify-center">
-                  <span className="text-slate-500 text-sm">下载文件数</span>
-                  <span className="text-2xl font-bold text-slate-800">{result.downloadedFiles.length}</span>
-                </div>
-                <div className="bg-slate-50 p-4 rounded-lg border border-slate-100 flex flex-col items-center justify-center">
-                  <span className="text-slate-500 text-sm">记录数</span>
-                  <span className="text-2xl font-bold text-slate-800">{result.recordCount}</span>
-                </div>
-                <div className="bg-slate-50 p-4 rounded-lg border border-slate-100 flex flex-col items-center justify-center">
-                  <span className="text-slate-500 text-sm">错误数</span>
-                  <span className={`text-2xl font-bold ${result.errors.length > 0 ? 'text-red-500' : 'text-slate-800'}`}>{result.errors.length}</span>
-                </div>
-             </div>
+            <h3 className="text-emerald-600 font-semibold text-lg border-b pb-2">提取结果</h3>
+            <div className="grid grid-cols-3 gap-4">
+              <div className="bg-slate-50 p-4 rounded-lg border border-slate-100 flex flex-col items-center justify-center">
+                <span className="text-slate-500 text-sm">下载文件数</span>
+                <span className="text-2xl font-bold text-slate-800">
+                  {result.downloadedFiles.length}
+                </span>
+              </div>
+              <div className="bg-slate-50 p-4 rounded-lg border border-slate-100 flex flex-col items-center justify-center">
+                <span className="text-slate-500 text-sm">记录数</span>
+                <span className="text-2xl font-bold text-slate-800">{result.recordCount}</span>
+              </div>
+              <div className="bg-slate-50 p-4 rounded-lg border border-slate-100 flex flex-col items-center justify-center">
+                <span className="text-slate-500 text-sm">错误数</span>
+                <span
+                  className={`text-2xl font-bold ${result.errors.length > 0 ? 'text-red-500' : 'text-slate-800'}`}
+                >
+                  {result.errors.length}
+                </span>
+              </div>
+            </div>
          </div>
        )}

@@ -187,12 +212,26 @@ const ExtractorPage: React.FC = () => {
            </div>
            <div className="flex items-center gap-3">
              <span className="text-xs text-slate-500">进度: {progress?.progress || 0}%</span>
-              <button className="text-xs text-slate-400 hover:text-white transition-colors" onClick={() => setLogs([])}>清空</button>
+              <button
+                className="text-xs text-slate-400 hover:text-white transition-colors"
+                onClick={() => setLogs([])}
+              >
+                清空
+              </button>
            </div>
          </div>
          <div className="flex-1 p-4 font-mono text-sm overflow-y-auto leading-relaxed">
            {logs.map((log, index) => (
-              <div key={index} className={log.includes('[System]') ? 'text-emerald-500' : log.includes('error') || log.includes('失败') ? 'text-red-400' : 'text-slate-400'}>
+              <div
+                key={index}
+                className={
+                  log.includes('[System]')
+                    ? 'text-emerald-500'
+                    : log.includes('error') || log.includes('失败')
+                      ? 'text-red-400'
+                      : 'text-slate-400'
+                }
+              >
                {log}
              </div>
            ))}
--- a/src/renderer/src/pages/SettingsPage.tsx
+++ b/src/renderer/src/pages/SettingsPage.tsx
@@ -20,7 +20,10 @@ const SettingsPage: React.FC = () => {

  const [isModified, setIsModified] = useState(false)
  const [isLoading, setIsLoading] = useState(true)
-  const [message, setMessage] = useState<{ type: 'success' | 'error' | 'info'; text: string } | null>(null)
+  const [message, setMessage] = useState<{
+    type: 'success' | 'error' | 'info'
+    text: string
+  } | null>(null)

  useEffect(() => {
    loadSettings()
@@ -82,9 +85,10 @@ const SettingsPage: React.FC = () => {

  return (
    <div className="max-w-2xl mx-auto animate-in fade-in slide-in-from-bottom-4 duration-500 mt-6">
-
      {message && (
-        <div className={`fixed top-5 left-1/2 -translate-x-1/2 px-6 py-3 rounded-lg shadow-lg z-[10000] text-sm font-medium transition-all ${message.type === 'success' ? 'bg-emerald-50 text-emerald-600 border border-emerald-200' : 'bg-red-50 text-red-600 border border-red-200'}`}>
+        <div
+          className={`fixed top-5 left-1/2 -translate-x-1/2 px-6 py-3 rounded-lg shadow-lg z-[10000] text-sm font-medium transition-all ${message.type === 'success' ? 'bg-emerald-50 text-emerald-600 border border-emerald-200' : 'bg-red-50 text-red-600 border border-red-200'}`}
+        >
          {message.text}
        </div>
      )}
@@ -102,7 +106,9 @@ const SettingsPage: React.FC = () => {

        <div className="p-6 space-y-6 bg-white">
          <div>
-            <label className="block text-sm font-medium text-slate-700 mb-1.5">ERP 基础访问地址 (URL)</label>
+            <label className="block text-sm font-medium text-slate-700 mb-1.5">
+              ERP 基础访问地址 (URL)
+            </label>
            <input
              type="url"
              placeholder="https://erp.example.com"
@@ -114,7 +120,9 @@ const SettingsPage: React.FC = () => {

          <div className="grid grid-cols-2 gap-5">
            <div>
-              <label className="block text-sm font-medium text-slate-700 mb-1.5">登录账号 (Username)</label>
+              <label className="block text-sm font-medium text-slate-700 mb-1.5">
+                登录账号 (Username)
+              </label>
              <input
                type="text"
                placeholder="输入 ERP 账号"
@@ -124,7 +132,9 @@ const SettingsPage: React.FC = () => {
              />
            </div>
            <div>
-              <label className="block text-sm font-medium text-slate-700 mb-1.5">登录密码 (Password)</label>
+              <label className="block text-sm font-medium text-slate-700 mb-1.5">
+                登录密码 (Password)
+              </label>
              <input
                type="password"
                placeholder="••••••••"
--- a/src/renderer/src/stores/useAppStore.ts
+++ b/src/renderer/src/stores/useAppStore.ts
@@ -0,0 +1,115 @@
+/**
+ * Application Store using Zustand
+ *
+ * Manages global application state including errors, notifications, and UI state.
+ */
+
+import { create } from 'zustand'
+
+// Toast/notification type
+interface Toast {
+  id: string
+  type: 'success' | 'error' | 'warning' | 'info'
+  message: string
+  duration?: number
+}
+
+interface AppState {
+  // Global error state
+  globalError: string | null
+
+  // Toast notifications
+  toasts: Toast[]
+
+  // UI state
+  sidebarCollapsed: boolean
+  currentPage: string
+
+  // Actions
+  setGlobalError: (error: string | null) => void
+  clearGlobalError: () => void
+
+  addToast: (toast: Omit<Toast, 'id'>) => void
+  removeToast: (id: string) => void
+  clearToasts: () => void
+
+  setSidebarCollapsed: (collapsed: boolean) => void
+  toggleSidebar: () => void
+  setCurrentPage: (page: string) => void
+}
+
+/**
+ * Generate a unique ID for toasts
+ */
+const generateId = (): string => {
+  return `toast-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`
+}
+
+/**
+ * Application store for managing global state
+ */
+export const useAppStore = create<AppState>((set, get) => ({
+  globalError: null,
+  toasts: [],
+  sidebarCollapsed: false,
+  currentPage: 'extractor',
+
+  setGlobalError: (error) => set({ globalError: error }),
+
+  clearGlobalError: () => set({ globalError: null }),
+
+  addToast: (toast) => {
+    const id = generateId()
+    const newToast = { ...toast, id }
+
+    set((state) => ({
+      toasts: [...state.toasts, newToast]
+    }))
+
+    // Auto-remove toast after duration (default 5 seconds)
+    const duration = toast.duration ?? 5000
+    if (duration > 0) {
+      setTimeout(() => {
+        get().removeToast(id)
+      }, duration)
+    }
+  },
+
+  removeToast: (id) =>
+    set((state) => ({
+      toasts: state.toasts.filter((t) => t.id !== id)
+    })),
+
+  clearToasts: () => set({ toasts: [] }),
+
+  setSidebarCollapsed: (collapsed) => set({ sidebarCollapsed: collapsed }),
+
+  toggleSidebar: () => set((state) => ({ sidebarCollapsed: !state.sidebarCollapsed })),
+
+  setCurrentPage: (page) => set({ currentPage: page })
+}))
+
+// Convenience functions for toast notifications
+export const showSuccess = (message: string, duration?: number) => {
+  useAppStore.getState().addToast({ type: 'success', message, duration })
+}
+
+export const showError = (message: string, duration?: number) => {
+  useAppStore.getState().addToast({ type: 'error', message, duration })
+}
+
+export const showWarning = (message: string, duration?: number) => {
+  useAppStore.getState().addToast({ type: 'warning', message, duration })
+}
+
+export const showInfo = (message: string, duration?: number) => {
+  useAppStore.getState().addToast({ type: 'info', message, duration })
+}
+
+// Selectors
+export const selectGlobalError = (state: AppState) => state.globalError
+export const selectToasts = (state: AppState) => state.toasts
+export const selectSidebarCollapsed = (state: AppState) => state.sidebarCollapsed
+export const selectCurrentPage = (state: AppState) => state.currentPage
+
+export default useAppStore
--- a/src/renderer/src/stores/useUserStore.ts
+++ b/src/renderer/src/stores/useUserStore.ts
@@ -0,0 +1,67 @@
+/**
+ * User Store using Zustand
+ *
+ * Manages global user authentication state across the application.
+ */
+
+import { create } from 'zustand'
+
+// User info interface matching the backend types
+interface UserInfo {
+  id: number
+  username: string
+  userType: 'Admin' | 'User' | 'Guest'
+  computerName?: string
+}
+
+interface UserState {
+  user: UserInfo | null
+  isAuthenticated: boolean
+  loading: boolean
+  error: string | null
+
+  // Actions
+  setUser: (user: UserInfo | null) => void
+  setAuthenticated: (isAuthenticated: boolean) => void
+  setLoading: (loading: boolean) => void
+  setError: (error: string | null) => void
+  clearUser: () => void
+}
+
+/**
+ * User store for managing authentication state
+ */
+export const useUserStore = create<UserState>((set) => ({
+  user: null,
+  isAuthenticated: false,
+  loading: false,
+  error: null,
+
+  setUser: (user) =>
+    set({
+      user,
+      isAuthenticated: user !== null,
+      error: null
+    }),
+
+  setAuthenticated: (isAuthenticated) => set({ isAuthenticated }),
+
+  setLoading: (loading) => set({ loading }),
+
+  setError: (error) => set({ error }),
+
+  clearUser: () =>
+    set({
+      user: null,
+      isAuthenticated: false,
+      error: null
+    })
+}))
+
+// Selectors for common state access patterns
+export const selectUser = (state: UserState) => state.user
+export const selectIsAuthenticated = (state: UserState) => state.isAuthenticated
+export const selectIsAdmin = (state: UserState) => state.user?.userType === 'Admin'
+export const selectUsername = (state: UserState) => state.user?.username ?? ''
+
+export default useUserStore
--- a/tests/e2e/auth-flow.test.ts
+++ b/tests/e2e/auth-flow.test.ts
@@ -0,0 +1,93 @@
+/**
+ * E2E Tests for Authentication Flow
+ *
+ * Tests the complete authentication workflow including:
+ * - Silent login
+ * - Manual login
+ * - Logout
+ * - Session management
+ */
+
+import { test, expect, ElectronApplication, Page } from '@playwright/test'
+import { _electron as electron } from 'playwright'
+import path from 'path'
+
+let electronApp: ElectronApplication
+let page: Page
+
+test.describe('Authentication Flow', () => {
+  test.beforeAll(async () => {
+    // Launch Electron app
+    electronApp = await electron.launch({
+      args: [path.join(__dirname, '../../out/main/index.js')],
+      env: {
+        ...process.env,
+        NODE_ENV: 'test'
+      }
+    })
+
+    // Get the first window
+    page = await electronApp.firstWindow()
+
+    // Wait for app to load
+    await page.waitForLoadState('domcontentloaded')
+  })
+
+  test.afterAll(async () => {
+    await electronApp.close()
+  })
+
+  test('should show login dialog on first load', async () => {
+    // Check if login dialog or main content is visible
+    const loginDialog = page.locator('[data-testid="login-dialog"]')
+    const mainContent = page.locator('[data-testid="main-content"]')
+
+    // Either login dialog or main content should be visible
+    const isLoginVisible = await loginDialog.isVisible().catch(() => false)
+    const isMainVisible = await mainContent.isVisible().catch(() => false)
+
+    expect(isLoginVisible || isMainVisible).toBe(true)
+  })
+
+  test('should have login form elements', async () => {
+    // Check for login form elements if login dialog is visible
+    const usernameInput = page.locator('input[type="text"], input[name="username"]')
+    const passwordInput = page.locator('input[type="password"], input[name="password"]')
+    const loginButton = page.locator('button:has-text("登录"), button:has-text("Login")')
+
+    // Check if at least one of each exists
+    const hasUsername = await usernameInput.count()
+    const hasPassword = await passwordInput.count()
+    const hasLoginButton = await loginButton.count()
+
+    // If login dialog is shown, these elements should exist
+    if (hasUsername > 0 || hasPassword > 0) {
+      expect(hasUsername).toBeGreaterThan(0)
+      expect(hasPassword).toBeGreaterThan(0)
+      expect(hasLoginButton).toBeGreaterThan(0)
+    }
+  })
+
+  test('should show error on invalid credentials', async () => {
+    const usernameInput = page.locator('input[type="text"], input[name="username"]').first()
+    const passwordInput = page.locator('input[type="password"], input[name="password"]').first()
+    const loginButton = page.locator('button:has-text("登录"), button:has-text("Login")').first()
+
+    // Only test if login form is visible
+    if (await usernameInput.isVisible().catch(() => false)) {
+      await usernameInput.fill('invalid_user')
+      await passwordInput.fill('invalid_password')
+      await loginButton.click()
+
+      // Wait for error message
+      await page.waitForTimeout(1000)
+
+      // Check for error message
+      const errorMessage = page.locator('.error, [role="alert"], .text-red')
+      const hasError = await errorMessage.count()
+
+      // Either error shown or still on login page
+      expect(hasError >= 0).toBe(true)
+    }
+  })
+})
--- a/tests/unit/errors.test.ts
+++ b/tests/unit/errors.test.ts
@@ -0,0 +1,208 @@
+/**
+ * Error Types Unit Tests
+ */
+
+import { describe, it, expect } from 'vitest'
+import {
+  BaseError,
+  ErpConnectionError,
+  DatabaseQueryError,
+  ValidationError,
+  ERP_ERROR_CODES,
+  DATABASE_ERROR_CODES,
+  VALIDATION_ERROR_CODES,
+  isBaseError,
+  isErpConnectionError,
+  isDatabaseQueryError,
+  isValidationError,
+  getErrorMessage,
+  getErrorCode
+} from '../../src/main/types/errors'
+
+// Concrete implementation for testing abstract BaseError
+class TestError extends BaseError {
+  constructor(message: string, code: string, cause?: Error) {
+    super('TestError', message, code, cause)
+  }
+}
+
+describe('Error Types', () => {
+  describe('BaseError', () => {
+    it('should create an error with name, message, and code', () => {
+      const error = new TestError('Test message', 'TEST_CODE')
+
+      expect(error.name).toBe('TestError')
+      expect(error.message).toBe('Test message')
+      expect(error.code).toBe('TEST_CODE')
+      expect(error.cause).toBeUndefined()
+    })
+
+    it('should capture cause when provided', () => {
+      const cause = new Error('Original error')
+      const error = new TestError('Test message', 'TEST_CODE', cause)
+
+      expect(error.cause).toBe(cause)
+    })
+
+    it('should serialize to JSON correctly', () => {
+      const error = new TestError('Test message', 'TEST_CODE')
+      const json = error.toJSON()
+
+      expect(json).toEqual({
+        name: 'TestError',
+        message: 'Test message',
+        code: 'TEST_CODE',
+        cause: undefined
+      })
+    })
+
+    it('should be an instance of Error', () => {
+      const error = new TestError('Test message', 'TEST_CODE')
+
+      expect(error).toBeInstanceOf(Error)
+    })
+  })
+
+  describe('ErpConnectionError', () => {
+    it('should create with default code', () => {
+      const error = new ErpConnectionError('Connection failed')
+
+      expect(error.name).toBe('ErpConnectionError')
+      expect(error.code).toBe(ERP_ERROR_CODES.CONNECTION_FAILED)
+    })
+
+    it('should create with specific code', () => {
+      const error = new ErpConnectionError('Login failed', ERP_ERROR_CODES.LOGIN_FAILED)
+
+      expect(error.code).toBe(ERP_ERROR_CODES.LOGIN_FAILED)
+    })
+
+    it('should accept cause', () => {
+      const cause = new Error('Network timeout')
+      const error = new ErpConnectionError('Timeout', ERP_ERROR_CODES.TIMEOUT, cause)
+
+      expect(error.cause).toBe(cause)
+    })
+  })
+
+  describe('DatabaseQueryError', () => {
+    it('should create with default code', () => {
+      const error = new DatabaseQueryError('Query failed')
+
+      expect(error.name).toBe('DatabaseQueryError')
+      expect(error.code).toBe(DATABASE_ERROR_CODES.QUERY_FAILED)
+    })
+
+    it('should create with specific code', () => {
+      const error = new DatabaseQueryError(
+        'Connection failed',
+        DATABASE_ERROR_CODES.CONNECTION_FAILED
+      )
+
+      expect(error.code).toBe(DATABASE_ERROR_CODES.CONNECTION_FAILED)
+    })
+  })
+
+  describe('ValidationError', () => {
+    it('should create with default code', () => {
+      const error = new ValidationError('Invalid input')
+
+      expect(error.name).toBe('ValidationError')
+      expect(error.code).toBe(VALIDATION_ERROR_CODES.INVALID_INPUT)
+    })
+
+    it('should create with specific code', () => {
+      const error = new ValidationError('Missing field', VALIDATION_ERROR_CODES.MISSING_REQUIRED)
+
+      expect(error.code).toBe(VALIDATION_ERROR_CODES.MISSING_REQUIRED)
+    })
+  })
+
+  describe('Type Guards', () => {
+    it('isBaseError should return true for BaseError instances', () => {
+      const error = new ValidationError('Test')
+
+      expect(isBaseError(error)).toBe(true)
+      expect(isBaseError(new Error('Test'))).toBe(false)
+      expect(isBaseError('string')).toBe(false)
+    })
+
+    it('isErpConnectionError should return true only for ErpConnectionError', () => {
+      const erpError = new ErpConnectionError('Test')
+      const dbError = new DatabaseQueryError('Test')
+
+      expect(isErpConnectionError(erpError)).toBe(true)
+      expect(isErpConnectionError(dbError)).toBe(false)
+    })
+
+    it('isDatabaseQueryError should return true only for DatabaseQueryError', () => {
+      const dbError = new DatabaseQueryError('Test')
+      const valError = new ValidationError('Test')
+
+      expect(isDatabaseQueryError(dbError)).toBe(true)
+      expect(isDatabaseQueryError(valError)).toBe(false)
+    })
+
+    it('isValidationError should return true only for ValidationError', () => {
+      const valError = new ValidationError('Test')
+      const erpError = new ErpConnectionError('Test')
+
+      expect(isValidationError(valError)).toBe(true)
+      expect(isValidationError(erpError)).toBe(false)
+    })
+  })
+
+  describe('Helper Functions', () => {
+    it('getErrorMessage should return message from BaseError', () => {
+      const error = new ValidationError('Invalid input')
+
+      expect(getErrorMessage(error)).toBe('Invalid input')
+    })
+
+    it('getErrorMessage should return message from standard Error', () => {
+      const error = new Error('Standard error')
+
+      // In non-production, it returns the actual message
+      expect(getErrorMessage(error)).toBe('Standard error')
+    })
+
+    it('getErrorMessage should handle unknown types', () => {
+      expect(getErrorMessage('string error')).toBe('string error')
+      expect(getErrorMessage(null)).toBe('An unknown error occurred')
+      expect(getErrorMessage(undefined)).toBe('An unknown error occurred')
+    })
+
+    it('getErrorCode should return code from BaseError', () => {
+      const error = new ValidationError('Test', VALIDATION_ERROR_CODES.MISSING_REQUIRED)
+
+      expect(getErrorCode(error)).toBe(VALIDATION_ERROR_CODES.MISSING_REQUIRED)
+    })
+
+    it('getErrorCode should return UNKNOWN_ERROR for non-BaseError', () => {
+      const error = new Error('Test')
+
+      expect(getErrorCode(error)).toBe('UNKNOWN_ERROR')
+    })
+  })
+
+  describe('Error Codes', () => {
+    it('ERP_ERROR_CODES should have all expected codes', () => {
+      expect(ERP_ERROR_CODES.CONNECTION_FAILED).toBe('ERP_CONNECTION_FAILED')
+      expect(ERP_ERROR_CODES.LOGIN_FAILED).toBe('ERP_LOGIN_FAILED')
+      expect(ERP_ERROR_CODES.TIMEOUT).toBe('ERP_TIMEOUT')
+      expect(ERP_ERROR_CODES.SESSION_EXPIRED).toBe('ERP_SESSION_EXPIRED')
+    })
+
+    it('DATABASE_ERROR_CODES should have all expected codes', () => {
+      expect(DATABASE_ERROR_CODES.CONNECTION_FAILED).toBe('DB_CONNECTION_FAILED')
+      expect(DATABASE_ERROR_CODES.QUERY_FAILED).toBe('DB_QUERY_FAILED')
+      expect(DATABASE_ERROR_CODES.TIMEOUT).toBe('DB_TIMEOUT')
+    })
+
+    it('VALIDATION_ERROR_CODES should have all expected codes', () => {
+      expect(VALIDATION_ERROR_CODES.INVALID_INPUT).toBe('VAL_INVALID_INPUT')
+      expect(VALIDATION_ERROR_CODES.MISSING_REQUIRED).toBe('VAL_MISSING_REQUIRED')
+      expect(VALIDATION_ERROR_CODES.INVALID_FORMAT).toBe('VAL_INVALID_FORMAT')
+    })
+  })
+})
--- a/tests/unit/logger.test.ts
+++ b/tests/unit/logger.test.ts
@@ -0,0 +1,78 @@
+/**
+ * Logger Unit Tests
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+
+// Mock winston since we don't need actual file logging in tests
+vi.mock('winston', () => ({
+  default: {
+    createLogger: vi.fn(() => ({
+      add: vi.fn(),
+      child: vi.fn(() => ({
+        info: vi.fn(),
+        error: vi.fn(),
+        warn: vi.fn(),
+        debug: vi.fn()
+      })),
+      info: vi.fn(),
+      error: vi.fn(),
+      warn: vi.fn(),
+      debug: vi.fn()
+    })),
+    format: {
+      combine: vi.fn(),
+      timestamp: vi.fn(),
+      colorize: vi.fn(),
+      printf: vi.fn(),
+      json: vi.fn()
+    },
+    transports: {
+      Console: vi.fn()
+    }
+  }
+}))
+
+vi.mock('winston-daily-rotate-file', () => ({
+  default: vi.fn()
+}))
+
+vi.mock('electron', () => ({
+  app: {
+    isReady: vi.fn(() => false),
+    getPath: vi.fn(() => './logs')
+  }
+}))
+
+describe('Logger', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+  })
+
+  afterEach(() => {
+    vi.resetModules()
+  })
+
+  it('should create a logger with context', async () => {
+    const { createLogger } = await import('../../src/main/services/logger')
+    const logger = createLogger('TestContext')
+
+    expect(logger).toBeDefined()
+    expect(logger.child).toBeDefined()
+  })
+
+  it('should have log methods', async () => {
+    const { createLogger } = await import('../../src/main/services/logger')
+    const logger = createLogger('TestContext')
+
+    expect(typeof logger.info).toBe('function')
+    expect(typeof logger.error).toBe('function')
+    expect(typeof logger.warn).toBe('function')
+    expect(typeof logger.debug).toBe('function')
+  })
+
+  it('should export default logger', async () => {
+    const logger = await import('../../src/main/services/logger')
+    expect(logger.default).toBeDefined()
+  })
+})
--- a/tests/unit/repositories.test.ts
+++ b/tests/unit/repositories.test.ts
@@ -0,0 +1,67 @@
+/**
+ * Repository Unit Tests
+ *
+ * Tests for TypeORM repository patterns.
+ * Note: These tests mock the database connections.
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+
+// Mock TypeORM
+vi.mock('typeorm', () => ({
+  DataSource: vi.fn(() => ({
+    initialize: vi.fn().mockResolvedValue({}),
+    isInitialized: false,
+    getRepository: vi.fn(),
+    destroy: vi.fn()
+  })),
+  Repository: vi.fn(),
+  In: vi.fn((arr) => arr)
+}))
+
+vi.mock('../../src/main/services/logger', () => ({
+  createLogger: vi.fn(() => ({
+    info: vi.fn(),
+    error: vi.fn(),
+    warn: vi.fn(),
+    debug: vi.fn()
+  }))
+}))
+
+describe('MaterialsToBeDeletedRepository', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+  })
+
+  it('should be defined', async () => {
+    const { MaterialsToBeDeletedRepository } =
+      await import('../../src/main/services/database/repositories/MaterialsToBeDeletedRepository')
+    expect(MaterialsToBeDeletedRepository).toBeDefined()
+  })
+
+  it('should create repository instance', async () => {
+    const { MaterialsToBeDeletedRepository } =
+      await import('../../src/main/services/database/repositories/MaterialsToBeDeletedRepository')
+    const repo = new MaterialsToBeDeletedRepository()
+    expect(repo).toBeDefined()
+  })
+})
+
+describe('DiscreteMaterialPlanRepository', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+  })
+
+  it('should be defined', async () => {
+    const { DiscreteMaterialPlanRepository } =
+      await import('../../src/main/services/database/repositories/DiscreteMaterialPlanRepository')
+    expect(DiscreteMaterialPlanRepository).toBeDefined()
+  })
+
+  it('should create repository instance', async () => {
+    const { DiscreteMaterialPlanRepository } =
+      await import('../../src/main/services/database/repositories/DiscreteMaterialPlanRepository')
+    const repo = new DiscreteMaterialPlanRepository()
+    expect(repo).toBeDefined()
+  })
+})
--- a/tests/unit/schemas.test.ts
+++ b/tests/unit/schemas.test.ts
@@ -0,0 +1,227 @@
+/**
+ * Zod Schemas Unit Tests
+ */
+
+import { describe, it, expect } from 'vitest'
+import {
+  ExtractorInputSchema,
+  validateExtractorInput
+} from '../../src/main/schemas/extractor.schema'
+import { CleanerInputSchema, validateCleanerInput } from '../../src/main/schemas/cleaner.schema'
+import { LoginRequestSchema, validateLoginRequest } from '../../src/main/schemas/auth.schema'
+
+describe('Extractor Schema', () => {
+  describe('ExtractorInputSchema', () => {
+    it('should validate valid input', () => {
+      const input = {
+        orderNumbers: ['SC12345678901234', 'SC98765432109876'],
+        batchSize: 10
+      }
+
+      const result = ExtractorInputSchema.safeParse(input)
+
+      expect(result.success).toBe(true)
+    })
+
+    it('should apply default batchSize', () => {
+      const input = {
+        orderNumbers: ['SC12345678901234']
+      }
+
+      const result = ExtractorInputSchema.safeParse(input)
+
+      expect(result.success).toBe(true)
+      if (result.success) {
+        expect(result.data.batchSize).toBe(10)
+      }
+    })
+
+    it('should reject empty orderNumbers array', () => {
+      const input = {
+        orderNumbers: []
+      }
+
+      const result = ExtractorInputSchema.safeParse(input)
+
+      expect(result.success).toBe(false)
+    })
+
+    it('should reject missing orderNumbers', () => {
+      const input = {}
+
+      const result = ExtractorInputSchema.safeParse(input)
+
+      expect(result.success).toBe(false)
+    })
+
+    it('should reject empty string in orderNumbers', () => {
+      const input = {
+        orderNumbers: ['', 'SC12345678901234']
+      }
+
+      const result = ExtractorInputSchema.safeParse(input)
+
+      expect(result.success).toBe(false)
+    })
+  })
+
+  describe('validateExtractorInput', () => {
+    it('should return success for valid input', () => {
+      const input = {
+        orderNumbers: ['SC12345678901234']
+      }
+
+      const result = validateExtractorInput(input)
+
+      expect(result.success).toBe(true)
+      expect(result.data).toBeDefined()
+    })
+
+    it('should return error message for invalid input', () => {
+      const input = {
+        orderNumbers: []
+      }
+
+      const result = validateExtractorInput(input)
+
+      expect(result.success).toBe(false)
+      expect(result.error).toBeDefined()
+    })
+  })
+})
+
+describe('Cleaner Schema', () => {
+  describe('CleanerInputSchema', () => {
+    it('should validate valid input', () => {
+      const input = {
+        orderNumbers: ['SC12345678901234'],
+        materialCodes: ['MAT001', 'MAT002'],
+        dryRun: true
+      }
+
+      const result = CleanerInputSchema.safeParse(input)
+
+      expect(result.success).toBe(true)
+    })
+
+    it('should validate with empty materialCodes', () => {
+      const input = {
+        orderNumbers: ['SC12345678901234'],
+        materialCodes: [],
+        dryRun: false
+      }
+
+      const result = CleanerInputSchema.safeParse(input)
+
+      expect(result.success).toBe(true)
+    })
+
+    it('should reject missing dryRun', () => {
+      const input = {
+        orderNumbers: ['SC12345678901234'],
+        materialCodes: ['MAT001']
+      }
+
+      const result = CleanerInputSchema.safeParse(input)
+
+      expect(result.success).toBe(false)
+    })
+
+    it('should reject non-boolean dryRun', () => {
+      const input = {
+        orderNumbers: ['SC12345678901234'],
+        materialCodes: [],
+        dryRun: 'yes'
+      }
+
+      const result = CleanerInputSchema.safeParse(input)
+
+      expect(result.success).toBe(false)
+    })
+  })
+
+  describe('validateCleanerInput', () => {
+    it('should return success for valid input', () => {
+      const input = {
+        orderNumbers: ['SC12345678901234'],
+        materialCodes: ['MAT001'],
+        dryRun: false
+      }
+
+      const result = validateCleanerInput(input)
+
+      expect(result.success).toBe(true)
+    })
+  })
+})
+
+describe('Auth Schema', () => {
+  describe('LoginRequestSchema', () => {
+    it('should validate valid input', () => {
+      const input = {
+        username: 'testuser',
+        password: 'testpass'
+      }
+
+      const result = LoginRequestSchema.safeParse(input)
+
+      expect(result.success).toBe(true)
+    })
+
+    it('should reject empty username', () => {
+      const input = {
+        username: '',
+        password: 'testpass'
+      }
+
+      const result = LoginRequestSchema.safeParse(input)
+
+      expect(result.success).toBe(false)
+    })
+
+    it('should reject empty password', () => {
+      const input = {
+        username: 'testuser',
+        password: ''
+      }
+
+      const result = LoginRequestSchema.safeParse(input)
+
+      expect(result.success).toBe(false)
+    })
+
+    it('should reject missing fields', () => {
+      const input = {}
+
+      const result = LoginRequestSchema.safeParse(input)
+
+      expect(result.success).toBe(false)
+    })
+  })
+
+  describe('validateLoginRequest', () => {
+    it('should return success for valid input', () => {
+      const input = {
+        username: 'admin',
+        password: 'password123'
+      }
+
+      const result = validateLoginRequest(input)
+
+      expect(result.success).toBe(true)
+      expect(result.data).toBeDefined()
+      expect(result.data?.username).toBe('admin')
+    })
+
+    it('should return error for invalid input', () => {
+      const input = {
+        username: ''
+      }
+
+      const result = validateLoginRequest(input)
+
+      expect(result.success).toBe(false)
+      expect(result.error).toBeDefined()
+    })
+  })
+})
--- a/tsconfig.node.json
+++ b/tsconfig.node.json
@@ -6,6 +6,15 @@
    "types": ["electron-vite/node"],
    "noUnusedLocals": false,
    "noUnusedParameters": false,
-    "strict": false
+    "strict": true,
+    "noImplicitAny": true,
+    "strictNullChecks": true,
+    "strictFunctionTypes": true,
+    "noImplicitThis": true,
+    "alwaysStrict": true,
+    "noUnusedParameters": false,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true,
+    "esModuleInterop": true
  }
 }