Upload 41 files

.dockerignore

@@ -0,0 +1,35 @@
+__pycache__
+*.pyc
+.git
+.venv
+tests
+
+# Git repository files
+.git/
+.gitignore
+
+# Node modules
+node_modules/
+frontend/node_modules/
+
+# Environment files (Ensure sensitive data isn't accidentally included)
+.env
+frontend/.env
+
+# Build artifacts (Frontend build happens inside container, but good practice)
+dist/
+build/
+frontend/dist/
+frontend/build/
+
+# Logs
+logs/
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+
+# OS generated files
+.DS_Store
+Thumbs.db

.env.example

@@ -0,0 +1 @@
+MAIL_POINT_API_URL=https://your-endpoint.com # 使用 https://github.com/HChaoHui/msOauth2api 进行部署拿到URL

.gitignore

@@ -0,0 +1,3 @@
+.env
+account/*
+account copy/

Dockerfile

@@ -0,0 +1,35 @@
+FROM node:lts-alpine AS frontend-builder
+
+WORKDIR /app/frontend
+
+RUN npm install -g pnpm
+
+COPY frontend/package.json frontend/pnpm-lock.yaml ./
+
+RUN pnpm install --frozen-lockfile
+
+COPY frontend/ ./
+
+RUN pnpm build
+
+FROM python:3.10-slim AS final
+
+WORKDIR /app
+
+COPY requirements.txt ./
+RUN pip install --no-cache-dir --upgrade pip && \
+    pip install --no-cache-dir -r requirements.txt
+
+RUN mkdir account
+
+RUN mkdir -p templates static
+
+COPY run.py ./
+COPY utils/ ./utils/
+
+COPY --from=frontend-builder /app/frontend/dist/index.html ./templates/
+COPY --from=frontend-builder /app/frontend/dist/* ./static/
+
+EXPOSE 5000
+
+CMD ["python", "run.py"] 

LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

README.md

@@ -1,10 +1,135 @@
----
-title: Pikpakauto
-emoji: 😻
-colorFrom: pink
-colorTo: gray
-sdk: docker
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# PikPak 自动邀请
+
+一个帮助管理PikPak邀请的工具，包含前端界面和后端服务。
+
+**理论上输入账号后，一下都不用点，等着把列表里面账号注册完成就行**
+
+## 项目结构
+
+- `frontend/`: 前端代码，使用 pnpm 管理依赖
+- 后端: Python 实现的服务
+
+## 环境变量
+(可选) MAIL_POINT_API_URL 使用：https://github.com/HChaoHui/msOauth2api 部署后获得
+
+如果不提供此环境变量，需要(邮箱，密码)支持imap登录
+
+## 部署方式
+
+### 前端部署
+
+```bash
+# 进入前端目录
+cd frontend
+
+# 安装依赖
+pnpm install
+
+# 开发模式运行
+pnpm dev
+
+# 构建生产版本
+pnpm build
+```
+
+### 后端部署
+
+#### 1. 环境变量
+复制 .env.example 到 .env
+
+修改环境变量的值
+
+```bash
+MAIL_POINT_API_URL=https://your-endpoint.com
+```
+
+#### 2. 源码运行
+
+```bash
+# 安装依赖
+pip install -r requirements.txt
+
+# 运行应用
+python run.py
+```
+
+### Docker 部署
+
+项目提供了 Dockerfile，可以一键构建包含前后端的完整应用。
+
+#### 运行 Docker 容器
+
+```bash
+# 创建并运行容器
+docker run -d \
+  --name pikpak-auto \
+  -p 5000:5000 \
+  -e MAIL_POINT_API_URL=https://your-endpoint.com \
+  -v $(pwd)/account:/app/account \
+  vichus/pikpak-invitation:latest
+```
+
+参数说明：
+- `-d`: 后台运行容器
+- `-p 5000:5000`: 将容器内的 5000 端口映射到主机的 5000 端口
+- `-e MAIL_POINT_API_URL=...`: 设置环境变量
+- `-v $(pwd)/account:/app/account`: 将本地 account 目录挂载到容器内，保存账号数据
+
+#### 4. 查看容器日志
+
+```bash
+docker logs -f pikpak-auto
+```
+
+#### 5. 停止和重启容器
+
+```bash
+# 停止容器
+docker stop pikpak-auto
+
+# 重启容器
+docker start pikpak-auto
+```
+
+注意：Windows 用户在使用 PowerShell 时，挂载卷的命令可能需要修改为：
+```powershell
+docker run -d --name pikpak-auto -p 5000:5000 -e MAIL_POINT_API_URL=https://your-endpoint.com -v ${PWD}/account:/app/account vichus/pikpak-invitation
+```
+
+### Docker Compose 部署
+
+如果你更喜欢使用 Docker Compose 进行部署，请按照以下步骤操作：
+
+#### 1. 启动服务
+
+启动前记得修改 `docker-compose.yml` 的环境变量
+
+```bash
+# 在项目根目录下启动服务
+docker-compose up -d
+```
+
+#### 2. 查看日志
+
+```bash
+# 查看服务日志
+docker-compose logs -f
+```
+
+#### 3. 停止和重启服务
+
+```bash
+# 停止服务
+docker-compose down
+
+# 重启服务
+docker-compose up -d
+```
+
+鸣谢：
+
+[Pikpak-Auto-Invitation](https://github.com/Bear-biscuit/Pikpak-Auto-Invitation)
+
+[纸鸢地址发布页](https://kiteyuan.info/)
+
+[msOauth2api](https://github.com/HChaoHui/msOauth2api)

docker-compose.yml

@@ -0,0 +1,13 @@
+version: '3'
+
+services:
+  pikpak-auto:
+    image: vichus/pikpak-invitation:latest
+    container_name: pikpak-auto
+    ports:
+      - "5000:5000"
+    environment:
+      - MAIL_POINT_API_URL=https://your-endpoint.com
+    volumes:
+      - ./account:/app/account
+    restart: unless-stopped

frontend/.gitignore

@@ -0,0 +1,24 @@
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+lerna-debug.log*
+
+node_modules
+dist
+dist-ssr
+*.local
+
+# Editor directories and files
+.vscode/*
+!.vscode/extensions.json
+.idea
+.DS_Store
+*.suo
+*.ntvs*
+*.njsproj
+*.sln
+*.sw?

frontend/README.md

@@ -0,0 +1,54 @@
+# React + TypeScript + Vite
+
+This template provides a minimal setup to get React working in Vite with HMR and some ESLint rules.
+
+Currently, two official plugins are available:
+
+- [@vitejs/plugin-react](https://github.com/vitejs/vite-plugin-react/blob/main/packages/plugin-react) uses [Babel](https://babeljs.io/) for Fast Refresh
+- [@vitejs/plugin-react-swc](https://github.com/vitejs/vite-plugin-react/blob/main/packages/plugin-react-swc) uses [SWC](https://swc.rs/) for Fast Refresh
+
+## Expanding the ESLint configuration
+
+If you are developing a production application, we recommend updating the configuration to enable type-aware lint rules:
+
+```js
+export default tseslint.config({
+  extends: [
+    // Remove ...tseslint.configs.recommended and replace with this
+    ...tseslint.configs.recommendedTypeChecked,
+    // Alternatively, use this for stricter rules
+    ...tseslint.configs.strictTypeChecked,
+    // Optionally, add this for stylistic rules
+    ...tseslint.configs.stylisticTypeChecked,
+  ],
+  languageOptions: {
+    // other options...
+    parserOptions: {
+      project: ['./tsconfig.node.json', './tsconfig.app.json'],
+      tsconfigRootDir: import.meta.dirname,
+    },
+  },
+})
+```
+
+You can also install [eslint-plugin-react-x](https://github.com/Rel1cx/eslint-react/tree/main/packages/plugins/eslint-plugin-react-x) and [eslint-plugin-react-dom](https://github.com/Rel1cx/eslint-react/tree/main/packages/plugins/eslint-plugin-react-dom) for React-specific lint rules:
+
+```js
+// eslint.config.js
+import reactX from 'eslint-plugin-react-x'
+import reactDom from 'eslint-plugin-react-dom'
+
+export default tseslint.config({
+  plugins: {
+    // Add the react-x and react-dom plugins
+    'react-x': reactX,
+    'react-dom': reactDom,
+  },
+  rules: {
+    // other rules...
+    // Enable its recommended typescript rules
+    ...reactX.configs['recommended-typescript'].rules,
+    ...reactDom.configs.recommended.rules,
+  },
+})
+```

frontend/eslint.config.js

@@ -0,0 +1,28 @@
+import js from '@eslint/js'
+import globals from 'globals'
+import reactHooks from 'eslint-plugin-react-hooks'
+import reactRefresh from 'eslint-plugin-react-refresh'
+import tseslint from 'typescript-eslint'
+
+export default tseslint.config(
+  { ignores: ['dist'] },
+  {
+    extends: [js.configs.recommended, ...tseslint.configs.recommended],
+    files: ['**/*.{ts,tsx}'],
+    languageOptions: {
+      ecmaVersion: 2020,
+      globals: globals.browser,
+    },
+    plugins: {
+      'react-hooks': reactHooks,
+      'react-refresh': reactRefresh,
+    },
+    rules: {
+      ...reactHooks.configs.recommended.rules,
+      'react-refresh/only-export-components': [
+        'warn',
+        { allowConstantExport: true },
+      ],
+    },
+  },
+)

frontend/index.html

@@ -0,0 +1,13 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <link rel="icon" type="image/svg+xml" href="/vite.svg" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>PikPak 自助邀请助手</title>
+  </head>
+  <body>
+    <div id="root" style="width: 100%; height: 100%;"></div>
+    <script type="module" src="/src/main.tsx"></script>
+  </body>
+</html>

frontend/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "frontend",
+  "private": true,
+  "version": "0.0.0",
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "tsc -b && vite build",
+    "lint": "eslint .",
+    "preview": "vite preview"
+  },
+  "dependencies": {
+    "@ant-design/icons": "^6.0.0",
+    "@ant-design/v5-patch-for-react-19": "^1.0.3",
+    "antd": "^5.24.9",
+    "axios": "^1.9.0",
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0",
+    "react-router-dom": "^7.5.3"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.22.0",
+    "@types/react": "^19.0.10",
+    "@types/react-dom": "^19.0.4",
+    "@vitejs/plugin-react": "^4.3.4",
+    "eslint": "^9.22.0",
+    "eslint-plugin-react-hooks": "^5.2.0",
+    "eslint-plugin-react-refresh": "^0.4.19",
+    "globals": "^16.0.0",
+    "typescript": "~5.7.2",
+    "typescript-eslint": "^8.26.1",
+    "vite": "^6.3.1"
+  }
+}

frontend/src/App.css

@@ -0,0 +1,102 @@
+/* App.css */
+* {
+  margin: 0;
+  padding: 0;
+  box-sizing: border-box;
+}
+
+body {
+  font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, 'Helvetica Neue', Arial,
+    'Noto Sans', sans-serif, 'Apple Color Emoji', 'Segoe UI Emoji', 'Segoe UI Symbol',
+    'Noto Color Emoji';
+  background-color: #f0f2f5;
+}
+
+/* Remove old layout styles */
+/*
+.app-container {
+  display: flex;
+  flex-direction: column;
+  min-height: 100vh;
+}
+
+.content-container {
+  flex: 1;
+  padding: 20px;
+}
+
+@media (max-width: 768px) {
+  .content-container {
+    padding: 10px;
+  }
+}
+*/
+
+/* Remove or comment out #root restrictions to allow full width */
+/*
+#root {
+  max-width: 1280px;
+  margin: 0 auto;
+  padding: 2rem;
+  text-align: center;
+}
+*/
+
+/* Add styles for the logo in the sidebar */
+.sidebar-logo {
+  height: 32px;
+  margin: 16px;
+  background: rgba(255, 255, 255, 0.2);
+  border-radius: 4px;
+  text-align: center;
+  line-height: 32px;
+  color: white;
+  font-weight: bold;
+  overflow: hidden;
+  white-space: nowrap; /* Prevent text wrap when collapsed */
+}
+
+/* Remove the rule for the now-deleted .site-layout element */
+/* 
+.site-layout {
+  flex: 1;
+}
+*/
+
+/* Keep other potentially useful styles if needed, e.g., card, logo animation, etc. */
+/* These might be template defaults or used elsewhere, review if needed */
+.logo {
+  height: 6em;
+  padding: 1.5em;
+  will-change: filter;
+  transition: filter 300ms;
+}
+.logo:hover {
+  filter: drop-shadow(0 0 2em #646cffaa);
+}
+.logo.react:hover {
+  filter: drop-shadow(0 0 2em #61dafbaa);
+}
+
+@keyframes logo-spin {
+  from {
+    transform: rotate(0deg);
+  }
+  to {
+    transform: rotate(360deg);
+  }
+}
+
+@media (prefers-reduced-motion: no-preference) {
+  a:nth-of-type(2) .logo {
+    animation: logo-spin infinite 20s linear;
+  }
+}
+
+.card {
+  padding: 2em;
+}
+
+.read-the-docs {
+  color: #888;
+}

frontend/src/App.tsx

@@ -0,0 +1,88 @@
+import React, { useState } from 'react';
+import { BrowserRouter as Router, Routes, Route, Navigate, useLocation, Link } from 'react-router-dom';
+import { ConfigProvider, Layout, Menu } from 'antd';
+import { 
+  UserAddOutlined, 
+  CheckCircleOutlined, 
+  HistoryOutlined 
+} from '@ant-design/icons';
+import zhCN from 'antd/lib/locale/zh_CN';
+import './App.css';
+
+// 导入页面组件 (needed in MainLayout)
+import Register from './pages/Register';
+import Activate from './pages/Activate';
+import History from './pages/History';
+
+const { Sider, Content } = Layout;
+
+// Define the new MainLayout component
+const MainLayout: React.FC = () => {
+  const [collapsed, setCollapsed] = useState(false); // Move state here
+  const location = useLocation(); // Move hook call here
+  const currentPath = location.pathname;
+
+  // Move menu items definition here
+  const items = [
+    {
+      key: '/register',
+      icon: <UserAddOutlined />,
+      label: <Link to="/register">账号注册</Link>,
+    },
+    {
+      key: '/activate',
+      icon: <CheckCircleOutlined />,
+      label: <Link to="/activate">账号激活</Link>,
+    },
+    {
+      key: '/history',
+      icon: <HistoryOutlined />,
+      label: <Link to="/history">历史账号</Link>,
+    },
+  ];
+
+  // Move the Layout JSX structure here
+  return (
+    <Layout style={{ minHeight: '100vh' }}>
+      <Sider collapsible collapsed={collapsed} onCollapse={(value) => setCollapsed(value)}>
+        <div className="sidebar-logo">
+          {collapsed ? "P" : "PikPak 自动邀请"} 
+        </div>
+        <Menu theme="dark" mode="inline" selectedKeys={[currentPath]} items={items} />
+      </Sider>
+      <Content style={{ margin: '0', width: '100%' }}>
+        <div 
+          className="site-layout-background" 
+          style={{
+            padding: 24, 
+            minHeight: '100vh',
+            background: '#fff', 
+            boxShadow: '0 1px 3px rgba(0,0,0,0.12), 0 1px 2px rgba(0,0,0,0.24)'
+          }}
+        >
+          {/* Routes are rendered here, inside the Router context */}
+          <Routes>
+            <Route path="/" element={<Navigate to="/register" replace />} />
+            <Route path="/register" element={<Register />} />
+            <Route path="/activate" element={<Activate />} />
+            <Route path="/history" element={<History />} />
+          </Routes>
+        </div>
+      </Content>
+    </Layout>
+  );
+};
+
+// Simplify the App component
+function App() {
+  return (
+    <ConfigProvider locale={zhCN}>
+      <Router>
+        {/* Render MainLayout inside Router */}
+        <MainLayout /> 
+      </Router>
+    </ConfigProvider>
+  );
+}
+
+export default App;

frontend/src/components/Header/index.css

@@ -0,0 +1,32 @@
+/* Comment out or remove old container style 
+.header-container {
+  display: flex;
+  align-items: center;
+  padding: 0 24px;
+  background-color: #001529;
+  color: white;
+  height: 64px;
+}
+*/
+
+/* Add new style for Layout.Header */
+.header-layout {
+  display: flex;        /* Use flexbox for alignment */
+  align-items: center;  /* Vertically center items */
+  padding: 0 30px;      /* Adjust horizontal padding */
+}
+
+.logo {
+  font-size: 20px;
+  font-weight: bold;
+  margin-right: 30px; /* Adjust margin for spacing */
+}
+
+.logo a {
+  /* color: white; Remove this, Layout.Header theme handles it */
+  text-decoration: none;
+}
+
+.header-menu {
+  flex: 1; /* Keep this to fill remaining space */
+} 

frontend/src/components/Header/index.tsx

@@ -0,0 +1,41 @@
+import React from 'react';
+import { Menu, Layout } from 'antd';
+import { Link, useLocation } from 'react-router-dom';
+import './index.css';
+
+const Header: React.FC = () => {
+  const location = useLocation();
+  const currentPath = location.pathname;
+
+  const items = [
+    {
+      key: '/register',
+      label: <Link to="/register">账号注册</Link>,
+    },
+    {
+      key: '/activate',
+      label: <Link to="/activate">账号激活</Link>,
+    },
+    {
+      key: '/history',
+      label: <Link to="/history">历史账号</Link>,
+    },
+  ];
+
+  return (
+    <Layout.Header className="header-layout">
+      <div className="logo">
+        <Link to="/">PikPak 自动邀请</Link>
+      </div>
+      <Menu 
+        theme="dark" 
+        mode="horizontal" 
+        selectedKeys={[currentPath]} 
+        items={items}
+        className="header-menu"
+      />
+    </Layout.Header>
+  );
+};
+
+export default Header; 

frontend/src/index.css

@@ -0,0 +1,68 @@
+:root {
+  font-family: system-ui, Avenir, Helvetica, Arial, sans-serif;
+  line-height: 1.5;
+  font-weight: 400;
+
+  color-scheme: light dark;
+  color: rgba(255, 255, 255, 0.87);
+  background-color: #242424;
+
+  font-synthesis: none;
+  text-rendering: optimizeLegibility;
+  -webkit-font-smoothing: antialiased;
+  -moz-osx-font-smoothing: grayscale;
+}
+
+a {
+  font-weight: 500;
+  color: #646cff;
+  text-decoration: inherit;
+}
+a:hover {
+  color: #535bf2;
+}
+
+body {
+  margin: 0;
+  display: flex;
+  place-items: center;
+  min-width: 320px;
+  min-height: 100vh;
+}
+
+h1 {
+  font-size: 3.2em;
+  line-height: 1.1;
+}
+
+button {
+  border-radius: 8px;
+  border: 1px solid transparent;
+  padding: 0.6em 1.2em;
+  font-size: 1em;
+  font-weight: 500;
+  font-family: inherit;
+  background-color: #1a1a1a;
+  cursor: pointer;
+  transition: border-color 0.25s;
+}
+button:hover {
+  border-color: #646cff;
+}
+button:focus,
+button:focus-visible {
+  outline: 4px auto -webkit-focus-ring-color;
+}
+
+@media (prefers-color-scheme: light) {
+  :root {
+    color: #213547;
+    background-color: #ffffff;
+  }
+  a:hover {
+    color: #747bff;
+  }
+  button {
+    background-color: #f9f9f9;
+  }
+}

frontend/src/main.tsx

@@ -0,0 +1,11 @@
+import { StrictMode } from 'react'
+import { createRoot } from 'react-dom/client'
+import './index.css'
+import App from './App.tsx'
+import '@ant-design/v5-patch-for-react-19'
+
+createRoot(document.getElementById('root')!).render(
+  <StrictMode>
+    <App />
+  </StrictMode>,
+)

frontend/src/pages/Activate/index.css

@@ -0,0 +1,25 @@
+.activate-container {
+  display: flex;
+  justify-content: center;
+  max-width: 800px;
+  margin: 0 auto;
+  max-height: calc(100vh - 80px);
+}
+
+.activate-card {
+  width: 100%;
+  height: calc(100vh - 80px);
+  overflow-y: auto;
+}
+
+.key-input-container {
+  display: flex;
+  margin-bottom: 24px;
+  gap: 16px;
+}
+
+.results-container {
+  margin-top: 24px;
+  border-top: 1px solid #f0f0f0;
+  padding-top: 16px;
+} 

frontend/src/pages/Activate/index.tsx

@@ -0,0 +1,383 @@
+import React, { useState, useEffect } from 'react';
+import { Card, Input, Button, Typography, Tag, message, Result, Spin, Row, Col, Table, Space } from 'antd';
+import './index.css';
+import { activateAccounts, fetchAccounts } from '../../services/api';
+import type { ColumnsType } from 'antd/es/table';
+
+const { Paragraph } = Typography;
+
+interface AccountResult {
+  status: 'success' | 'error';
+  account: string;
+  message?: string;
+  result?: any;
+  updated?: boolean;
+}
+
+interface Account {
+  email: string;
+  name: string;
+  filename: string;
+  user_id?: string;
+  version?: string;
+  device_id?: string;
+  timestamp?: string;
+  invite_code?: string; // 新增邀请码字段
+  // 其他账户属性...
+}
+
+// 格式化时间戳
+const formatTimestamp = (timestampStr?: string): string => {
+  if (!timestampStr) return '-';
+  try {
+    const timestamp = parseInt(timestampStr, 10);
+    if (isNaN(timestamp)) return '无效时间戳';
+    // 检查时间戳是否是毫秒级，如果不是（例如秒级），乘以1000
+    const date = new Date(timestamp < 10000000000 ? timestamp * 1000 : timestamp);
+    return date.toLocaleString('zh-CN'); // 使用本地化格式
+  } catch (e) {
+    console.error("Error formatting timestamp:", e);
+    return '格式化错误';
+  }
+};
+
+const Activate: React.FC = () => {
+  const [key, setKey] = useState('');
+  const [loading, setLoading] = useState(false);
+  const [results, setResults] = useState<AccountResult[]>([]);
+  const [view, setView] = useState<'initial' | 'loading' | 'accounts' | 'success_summary'>('initial');
+  const [successMessage, setSuccessMessage] = useState<string>('');
+  
+  // 状态
+  const [accounts, setAccounts] = useState<Account[]>([]);
+  const [selectedAccounts, setSelectedAccounts] = useState<string[]>([]);
+  const [loadingAccounts, setLoadingAccounts] = useState(false);
+  const [activatingAccount, setActivatingAccount] = useState<string>(''); // 当前正在激活的单个账号
+
+  // 组件加载时获取账户列表
+  useEffect(() => {
+    loadAccounts();
+  }, []);
+
+  // 加载账户列表函数
+  const loadAccounts = async () => {
+    setLoadingAccounts(true);
+    setView('loading');
+    try {
+      const response = await fetchAccounts();
+      if (response.data.status === 'success') {
+        setAccounts(response.data.accounts || []);
+        setView('accounts'); // 加载成功后显示账户列表
+      } else {
+        message.error(response.data.message || '获取账户列表失败');
+        setView('initial'); // 失败返回初始状态
+      }
+    } catch (error: any) {
+      console.error('获取账户错误:', error);
+      message.error('获取账户列表时出错: ' + (error.message || '未知错误'));
+      setView('initial'); // 异常返回初始状态
+    } finally {
+      setLoadingAccounts(false);
+    }
+  };
+
+  // 处理所选行变化
+  const onSelectChange = (selectedRowKeys: React.Key[]) => {
+    setSelectedAccounts(selectedRowKeys as string[]);
+  };
+
+  // 激活单个账号
+  const handleActivateSingle = async (account: string) => {
+    if (!key.trim()) {
+      message.error('请输入激活密钥');
+      return;
+    }
+
+    const account_name = account.split('@')[0];
+
+    setActivatingAccount(account_name);
+    setLoading(true);
+    try {
+      // 使用之前的API，但只针对单个账号
+      const response = await activateAccounts(key, [account_name], false);
+      const data = response.data;
+
+      if (data.status === 'success') {
+        const result = data.results.find((r: any) => r.account === account);
+        message.success(`账号 ${account} 激活${result?.status === 'success' ? '成功' : '失败'}`);
+        
+        // 更新当前结果列表中对应的账号状态
+        const updatedResults = [...results];
+        const index = updatedResults.findIndex((r: AccountResult) => r.account === account);
+        if (index !== -1) {
+          const updatedAccount = data.results.find((r: any) => r.account === account);
+          if (updatedAccount) {
+            updatedResults[index] = updatedAccount;
+            setResults(updatedResults);
+          }
+        }
+      } else {
+        message.error(data.message || '激活操作返回错误');
+      }
+    } catch (error: any) {
+      console.error('激活错误:', error);
+      message.error(error.message || '激活过程中发生网络或未知错误');
+    } finally {
+      setLoading(false);
+      setActivatingAccount('');
+    }
+  };
+
+  // 激活所有账户
+  const handleActivateAll = async () => {
+    await handleActivate(true, []);
+  };
+
+  // 激活选定账户
+  const handleActivateSelected = async () => {
+    if (selectedAccounts.length === 0) {
+      message.warning('请至少选择一个账户进行激活');
+      return;
+    }
+    await handleActivate(false, selectedAccounts);
+  };
+
+  // 激活账户通用函数
+  const handleActivate = async (activateAll: boolean, names: string[]) => {
+    if (!key.trim()) {
+      message.error('请输入激活密钥');
+      return;
+    }
+
+    setLoading(true);
+    setView('loading'); // 设置为加载中视图
+    setResults([]);
+    setSuccessMessage('');
+
+    try {
+      const response = await activateAccounts(key, names, activateAll);
+      const data = response.data;
+
+      if (data.status === 'success') {
+        // message.success(data.message || '激活成功完成'); // 使用下方摘要信息
+        setResults(data.results || []);
+        setSuccessMessage(data.message || '激活成功完成');
+        setView('success_summary'); // 显示成功摘要视图
+        setSelectedAccounts([]); // 清空选择，为下次做准备
+      } else if (data.status === 'error') {
+        message.error(data.message || '激活操作返回错误');
+        setView('accounts'); // 激活失败返回账户列表视图
+      } else {
+        message.warning('收到未知的响应状态');
+        setView('accounts'); // 未知状态也返回账户列表
+      }
+
+    } catch (error: any) {
+      console.error('激活错误:', error);
+      message.error(error.message || '激活过程中发生网络或未知错误');
+      setView('accounts'); // 异常返回账户列表
+    } finally {
+      setLoading(false);
+    }
+  };
+
+  // 返回账户选择视图
+  const handleContinueActivating = () => {
+    // setView('accounts'); // 先不切换视图，等待加载完成
+    setResults([]); // 可以选择性清空结果
+    setSuccessMessage('');
+    loadAccounts(); // 重新加载账户列表，加载函数内部会设置视图
+  };
+
+  // 表格列定义
+  const columns: ColumnsType<Account> = [
+    {
+      title: '邀请码',
+      dataIndex: 'invite_code',
+      key: 'invite_code',
+      width: '15%',
+      render: (invite_code?: string) => invite_code || '-',
+      ellipsis: true,
+    },
+    {
+      title: '名称',
+      dataIndex: 'name',
+      key: 'name',
+      width: '15%',
+    },
+    {
+      title: '邮箱',
+      dataIndex: 'email',
+      key: 'email',
+      render: (text) => <span style={{ fontWeight: 'bold' }}>{text}</span>,
+      ellipsis: true,
+    },
+    {
+      title: 'Device ID',
+      dataIndex: 'device_id',
+      key: 'device_id',
+      width: '30%',
+      ellipsis: true,
+    },
+    {
+      title: '创建时间',
+      dataIndex: 'timestamp',
+      key: 'timestamp',
+      width: '20%',
+      render: (timestamp) => formatTimestamp(timestamp),
+      sorter: (a, b) => parseInt(a.timestamp || '0') - parseInt(b.timestamp || '0'),
+      defaultSortOrder: 'descend',
+    }
+  ];
+
+  // 表格行选择配置
+  const rowSelection = {
+    selectedRowKeys: selectedAccounts,
+    onChange: onSelectChange,
+  };
+
+  // 结果表格列定义（现在用于成功摘要）
+  const successResultColumns: ColumnsType<AccountResult> = [
+    {
+      title: '邮箱',
+      dataIndex: 'account',
+      key: 'account',
+      width: '50%',
+    },
+    {
+      title: '状态',
+      key: 'status',
+      width: '30%',
+      render: (_, record) => (
+        record.status === 'success' 
+          ? <Tag color="success">已激活{record.updated && ' (数据已更新)'}</Tag>
+          : <Tag color="error">{record.message || '激活失败'}</Tag>
+      ),
+    },
+    {
+      title: '操作',
+      key: 'action',
+      width: '20%',
+      render: (_, record) => (
+        record.status === 'error' && (
+          <Button 
+            type="primary" 
+            size="small" 
+            onClick={() => handleActivateSingle(record.account)}
+            loading={loading && activatingAccount === record.account}
+          >
+            重试
+          </Button>
+        )
+      ),
+    }
+  ];
+
+  return (
+    <div className="activate-container">
+      <Card title="PikPak 账号激活" className="activate-card" variant="borderless">
+        <div style={{ marginBottom: '20px' }}>
+          <Row gutter={16} align="middle">
+            <Col span={16}>
+              <Input.Password 
+                placeholder="请输入激活密钥" 
+                value={key} 
+                onChange={e => setKey(e.target.value)} 
+                style={{ width: '100%' }}
+                size="large"
+                disabled={view === 'loading'} // 加载时禁用
+              />
+            </Col>
+            <Col span={8}>
+              <Space>
+                <Button 
+                  type="primary" 
+                  onClick={handleActivateSelected} 
+                  loading={loading && view === 'loading'} // 仅在加载中且是当前操作时显示loading
+                  disabled={selectedAccounts.length === 0 || view !== 'accounts'} // 仅在账户视图且有选择时可用
+                  size="large"
+                >
+                  激活选定 ({selectedAccounts.length})
+                </Button>
+                <Button 
+                  onClick={handleActivateAll} 
+                  loading={loading && view === 'loading'} // 同上
+                  disabled={view !== 'accounts'} // 仅在账户视图可用
+                  size="large"
+                >
+                  激活全部
+                </Button>
+              </Space>
+            </Col>
+          </Row>
+          <Paragraph style={{ marginTop: '8px', color: '#888' }}>
+            激活密钥在 <a href="https://kiteyuan.info" target="_blank" rel="noopener noreferrer">纸鸢佬的导航</a>
+          </Paragraph>
+        </div>
+        
+        {/* 加载中提示 */} 
+        {view === 'loading' && (
+           <div style={{ textAlign: 'center', padding: '40px 0' }}>
+             <Spin size="large" />
+           </div>
+        )}
+
+        {/* 账户列表视图 */} 
+        {view === 'accounts' && (
+          <div className="accounts-container">
+            <Table
+              rowSelection={rowSelection}
+              columns={columns}
+              dataSource={accounts}
+              rowKey="filename"
+              loading={loadingAccounts} // 表格自身的加载状态
+              pagination={{ pageSize: 10 }}
+              size="middle"
+              locale={{ emptyText: '未找到账户数据，请先注册账户' }}
+              summary={() => (
+                <Table.Summary fixed>
+                  <Table.Summary.Row>
+                    <Table.Summary.Cell index={0} colSpan={columns.length + 1}>
+                      <div style={{ textAlign: 'left', padding: '8px 0' }}>
+                        已选择 {selectedAccounts.length} 个账户 (共 {accounts.length} 个)
+                      </div>
+                    </Table.Summary.Cell>
+                  </Table.Summary.Row>
+                </Table.Summary>
+              )}
+            />
+          </div>
+        )}
+        
+        {/* 成功摘要视图 */} 
+        {view === 'success_summary' && (
+          <div className="results-container" style={{ marginTop: '30px' }}>
+            <Result
+              status="success"
+              title="激活操作完成"
+              subTitle={successMessage}
+              extra={[
+                <Button type="primary" key="continue" onClick={handleContinueActivating}>
+                  继续激活
+                </Button>,
+              ]}
+            />
+            {/* 可选：显示简化的成功列表 */} 
+            {results.length > 0 && (
+               <Table
+                 columns={successResultColumns}
+                 dataSource={results} // 显示所有结果，包括成功和失败的
+                 rowKey="account"
+                 pagination={{ pageSize: 5 }} // 分页显示
+                 size="small"
+                 style={{ marginTop: '20px' }}
+               />
+            )}
+          </div>
+        )}
+      </Card>
+    </div>
+  );
+};
+
+export default Activate; 

frontend/src/pages/History/index.css

@@ -0,0 +1,30 @@
+.history-container {
+  max-width: 1000px;
+  margin: 0 auto;
+}
+
+.history-card {
+  width: 100%;
+
+}
+
+.history-card .ant-card-body {
+  padding: 0;
+}
+
+.account-details {
+  margin-top: 16px;
+}
+
+.token-container {
+  max-width: 100%;
+  overflow-x: auto;
+  overflow-y: hidden;
+  padding: 8px;
+  background-color: #f5f5f5;
+  border-radius: 4px;
+  margin-top: 4px;
+  word-break: break-all;
+  white-space: normal;
+  font-family: monospace;
+} 

frontend/src/pages/History/index.tsx

@@ -0,0 +1,327 @@
+import React, { useState, useEffect } from 'react';
+import { Table, Card, Button, message, Modal, Typography, Tag, Space, Popconfirm } from 'antd';
+import { ReloadOutlined, DeleteOutlined, InfoCircleOutlined } from '@ant-design/icons';
+import { fetchAccounts as apiFetchAccounts, deleteAccount, deleteAccounts } from '../../services/api';
+import './index.css';
+
+const { Text, Paragraph } = Typography;
+
+interface AccountInfo {
+  name?: string;
+  email?: string;
+  password?: string;
+  user_id?: string;
+  device_id?: string;
+  version?: string;
+  access_token?: string;
+  refresh_token?: string;
+  filename: string;
+  captcha_token?: string;
+  timestamp?: number;
+  invite_code?: string; // 新增邀请码字段
+}
+
+const History: React.FC = () => {
+  const [accounts, setAccounts] = useState<AccountInfo[]>([]);
+  const [loading, setLoading] = useState(false);
+  const [visible, setVisible] = useState(false);
+  const [currentAccount, setCurrentAccount] = useState<AccountInfo | null>(null);
+  const [selectedRowKeys, setSelectedRowKeys] = useState<React.Key[]>([]);
+  const [batchDeleteVisible, setBatchDeleteVisible] = useState(false);
+  const [batchDeleteLoading, setBatchDeleteLoading] = useState(false);
+
+  // 修改 fetchAccounts 函数以调用 API
+  const fetchAccounts = async () => {
+    setLoading(true);
+    try {
+      const response = await apiFetchAccounts(); // Call the imported API function
+      if (response.data && response.data.status === 'success') {
+        // Map the response to ensure consistency, though AccountInfo is now optional
+        const fetchedAccounts = response.data.accounts.map((acc: any) => ({
+          ...acc,
+          name: acc.name || acc.filename, // Use filename as name if name is missing
+        }));
+        setAccounts(fetchedAccounts);
+        // 清空选择
+        setSelectedRowKeys([]);
+      } else {
+        message.error(response.data.message || '获取账号列表失败');
+      }
+    } catch (error: any) {
+      console.error('获取账号错误:', error);
+      message.error(`获取账号列表失败: ${error.message || '未知错误'}`);
+    }
+    setLoading(false);
+  };
+
+  useEffect(() => {
+    fetchAccounts();
+  }, []);
+
+  const handleDelete = async (filename: string) => {
+    setLoading(true);
+    try {
+      // 调用删除账号API
+      const response = await deleteAccount(filename);
+
+      if (response.data && response.data.status === 'success') {
+        // 从状态中移除账号
+        setAccounts(prevAccounts => prevAccounts.filter(acc => acc.filename !== filename));
+        message.success(response.data.message || '账号已成功删除');
+      } else {
+        // 显示API返回的错误消息
+        message.error(response.data.message || '删除账号失败');
+      }
+    } catch (error: any) {
+      console.error('删除账号错误:', error);
+      // 显示捕获到的错误消息
+      message.error(`删除账号出错: ${error.message || '未知错误'}`);
+    } finally {
+      // 确保 loading 状态在所有情况下都设置为 false
+      setLoading(false);
+    }
+  };
+
+  // 批量删除账号
+  const handleBatchDelete = async () => {
+    if (selectedRowKeys.length === 0) {
+      message.warning('请至少选择一个账号');
+      return;
+    }
+
+    setBatchDeleteLoading(true);
+    try {
+      // 从选中的键中提取文件名
+      const filenames = selectedRowKeys.map(key => key.toString());
+      
+      // 调用批量删除API
+      const response = await deleteAccounts(filenames);
+      
+      if (response.data && (response.data.status === 'success' || response.data.status === 'partial')) {
+        // 从状态中移除成功删除的账号
+        if (response.data.results && response.data.results.success) {
+          const successFilenames = response.data.results.success;
+          setAccounts(prevAccounts => 
+            prevAccounts.filter(acc => !successFilenames.includes(acc.filename))
+          );
+        }
+        
+        // 显示成功消息
+        message.success(response.data.message || '账号已成功删除');
+        
+        // 清空选择
+        setSelectedRowKeys([]);
+      } else {
+        // 显示API返回的错误消息
+        message.error(response.data.message || '批量删除账号失败');
+      }
+    } catch (error: any) {
+      console.error('批量删除账号错误:', error);
+      message.error(`批量删除账号出错: ${error.message || '未知错误'}`);
+    } finally {
+      setBatchDeleteLoading(false);
+      setBatchDeleteVisible(false); // 关闭确认对话框
+    }
+  };
+
+  const showAccountDetails = (account: AccountInfo) => {
+    setCurrentAccount(account);
+    setVisible(true);
+  };
+
+  // 表格行选择配置
+  const rowSelection = {
+    selectedRowKeys,
+    onChange: (newSelectedRowKeys: React.Key[]) => {
+      setSelectedRowKeys(newSelectedRowKeys);
+    }
+  };
+
+  const columns = [
+    {
+      title: '名称',
+      dataIndex: 'name',
+      key: 'name',
+    },
+    {
+      title: '邮箱',
+      dataIndex: 'email',
+      key: 'email',
+    },
+    {
+      title: '状态',
+      key: 'status',
+      render: (_: any, record: AccountInfo) => {
+        if (record.access_token) {
+          return <Tag color="green">已激活</Tag>;
+        } else if (record.email) { // Check if email exists as an indicator of more complete info
+          return <Tag color="orange">未激活</Tag>;
+        } else {
+          return <Tag color="default">信息不完整</Tag>; // Indicate incomplete info
+        }
+      },
+    },
+    {
+      title: '邀请码',
+      dataIndex: 'invite_code',
+      key: 'invite_code',
+      render: (invite_code?: string) => invite_code || '-',
+    },
+    {
+      title: '修改日期',
+      dataIndex: 'timestamp',
+      key: 'timestamp',
+      render: (timestamp: number) => {
+        // 这里需要类型转换
+        return (new Date(timestamp*1)).toLocaleString();
+      },
+    },
+    {
+      title: '操作',
+      key: 'action',
+      render: (_: any, record: AccountInfo) => {
+        const isIncomplete = !record.email; // Consider incomplete if email is missing
+        return (
+          <Space size="middle">
+            <Button 
+              type="text" 
+              icon={<InfoCircleOutlined />}
+              onClick={() => showAccountDetails(record)}
+              disabled={isIncomplete} // Disable if incomplete
+            >
+              详情
+            </Button>
+            <Popconfirm
+              title="确定要删除此账号吗？"
+              onConfirm={() => handleDelete(record.filename)}
+              okText="确定"
+              cancelText="取消"
+            >
+              <Button type="text" danger icon={<DeleteOutlined />}>
+                删除
+              </Button>
+            </Popconfirm>
+          </Space>
+        );
+      },
+    },
+  ];
+
+  return (
+    <div className="history-container">
+      <Card 
+        title="PikPak 历史账号" 
+        className="history-card"
+        extra={
+          <Space>
+            {selectedRowKeys.length > 0 && (
+              <Button
+                danger
+                icon={<DeleteOutlined />}
+                onClick={() => setBatchDeleteVisible(true)}
+              >
+                批量删除 ({selectedRowKeys.length})
+              </Button>
+            )}
+            <Button 
+              type="primary" 
+              icon={<ReloadOutlined />} 
+              onClick={fetchAccounts} 
+              loading={loading}
+            >
+              刷新
+            </Button>
+          </Space>
+        }
+      >
+        <Table 
+          rowSelection={rowSelection}
+          columns={columns} 
+          dataSource={accounts} 
+          rowKey="filename" 
+          loading={loading}
+          pagination={{ pageSize: 10 }}
+        />
+      </Card>
+
+      {/* 账号详情模态框 */}
+      <Modal
+        title="账号详情"
+        open={visible}
+        onCancel={() => setVisible(false)}
+        footer={[
+          <Button key="close" onClick={() => setVisible(false)}>
+            关闭
+          </Button>
+        ]}
+        width={700}
+      >
+        {currentAccount && (
+          <div className="account-details">
+            <Paragraph>
+              <Text strong>名称：</Text> {currentAccount.name || '未提供'}
+            </Paragraph>
+            <Paragraph>
+              <Text strong>邮箱：</Text> {currentAccount.email || '未提供'}
+            </Paragraph>
+            <Paragraph>
+              <Text strong>密码：</Text> {currentAccount.password || '未提供'}
+            </Paragraph>
+            <Paragraph>
+              <Text strong>用户ID：</Text> {currentAccount.user_id || '未提供'}
+            </Paragraph>
+            <Paragraph>
+              <Text strong>设备ID：</Text> {currentAccount.device_id || '未提供'}
+            </Paragraph>
+            <Paragraph>
+              <Text strong>版本：</Text> {currentAccount.version || '未提供'}
+            </Paragraph>
+            <Paragraph>
+              <Text strong>Access Token：</Text>
+              <div className="token-container">
+                {currentAccount.access_token || '无'}
+              </div>
+            </Paragraph>
+            <Paragraph>
+              <Text strong>Refresh Token：</Text>
+              <div className="token-container">
+                {currentAccount.refresh_token || '无'}
+              </div>
+            </Paragraph>
+            <Paragraph>
+              <Text strong>邀请码：</Text> {currentAccount.invite_code || '未提供'}
+            </Paragraph>
+            <Paragraph>
+              <Text strong>文件名：</Text> {currentAccount.filename}
+            </Paragraph>
+          </div>
+        )}
+      </Modal>
+
+      {/* 批量删除确认对话框 */}
+      <Modal
+        title="确认批量删除"
+        open={batchDeleteVisible}
+        onCancel={() => setBatchDeleteVisible(false)}
+        footer={[
+          <Button key="cancel" onClick={() => setBatchDeleteVisible(false)}>
+            取消
+          </Button>,
+          <Button 
+            key="delete" 
+            type="primary" 
+            danger 
+            loading={batchDeleteLoading}
+            onClick={handleBatchDelete}
+          >
+            删除
+          </Button>
+        ]}
+      >
+        <p>确定要删除选中的 {selectedRowKeys.length} 个账号吗？此操作不可撤销。</p>
+      </Modal>
+    </div>
+  );
+};
+
+export default History; 

frontend/src/pages/Register/index.css

@@ -0,0 +1,106 @@
+.register-container {
+  display: flex;
+  justify-content: space-between;
+  align-items: flex-start;
+  padding: 10px 20px 10px 10px;
+  gap: 20px;
+  height: calc(100vh - 50px);
+  background-color: #f0f2f5;
+
+  @media screen and (max-width: 1024px) {
+    flex-direction: column;
+    height: auto;
+  }
+}
+
+.register-card {
+  position: relative;
+  width: 100%;
+  max-width: 1000px;
+  height: 100%;
+}
+
+.register-right {
+  position: relative;
+  width: 100%;
+  max-width: 1000px;
+  height: calc(100vh - 70px);
+  display: grid;
+  grid-template-rows: 49.6% 49.6%;
+  gap: 5px;
+}
+
+.register-right .register-card {
+  height: 100%;
+}
+
+.register-card .ant-card-body > .steps-content {
+  margin-top: 24px;
+}
+
+.steps-action {
+  margin-top: 24px;
+  text-align: right;
+  position: absolute;
+  bottom: 10px;
+  right: 10px;
+}
+
+#captcha-container {
+  margin: 24px 0;
+  min-height: 150px;
+  border: 1px solid #eee;
+  padding: 12px;
+  display: flex;
+  justify-content: center;
+  align-items: center;
+}
+
+.right-panel-list {
+  max-height: 400px;
+  overflow-y: auto;
+}
+
+.right-panel-list-item {
+  margin-bottom: 10px;
+  padding: 8px;
+  border: 1px solid #eee;
+  border-radius: 4px;
+  transition: background-color 0.3s ease;
+}
+
+.right-panel-list-item.processing {
+  background-color: #e6f7ff;
+}
+
+.right-panel-list-item-status {
+  margin-top: 5px;
+}
+
+.right-panel-list-item-message {
+  margin-top: 5px;
+  font-size: 12px;
+  word-break: break-all;
+}
+
+.right-panel-list-item-message.error {
+  color: #ff4d4f;
+}
+
+.right-panel-list-item-message.success {
+  color: #52c41a;
+}
+
+pre {
+  background-color: #fafafa;
+  padding: 10px;
+  border-radius: 4px;
+  white-space: pre-wrap;
+  word-break: break-all;
+} 
+
+.step-content-container {
+  --max-height: calc(100vh - 80px);
+  max-height: calc(var(--max-height) / 2);
+  overflow-y: auto;
+}

frontend/src/pages/Register/index.tsx

@@ -0,0 +1,1586 @@
+import React, { useState, useEffect } from "react";
+import {
+  Form,
+  Input,
+  Button,
+  Card,
+  message,
+  Switch,
+  Row,
+  Col,
+  Tag,
+  Spin,
+  Checkbox,
+  Progress,
+} from "antd";
+import { CheckboxChangeEvent } from "antd/es/checkbox";
+import "./index.css";
+import {
+  testProxy,
+  initialize,
+  verifyCaptha,
+  getEmailVerificationCode,
+  register,
+} from "../../services/api";
+import {
+  CheckCircleOutlined,
+  CloseCircleOutlined,
+  SyncOutlined,
+  SafetyCertificateOutlined,
+  MailOutlined,
+} from "@ant-design/icons";
+
+const { TextArea } = Input;
+
+// 定义账号信息接口
+interface AccountInfo {
+  id: number;
+  account: string;
+  password: string;
+  clientId: string;
+  token: string;
+  status:
+    | "pending"
+    | "processing"
+    | "initializing"
+    | "captcha_pending"
+    | "email_pending"
+    | "success"
+    | "error";
+  message?: string;
+}
+
+const Register: React.FC = () => {
+  const [current, setCurrent] = useState(0);
+  const [form] = Form.useForm();
+  const [useProxy, setUseProxy] = useState(false);
+  const [loading, setLoading] = useState(false); // Represents the overall batch processing state
+  const [accountList, setAccountList] = useState<AccountInfo[]>([]);
+  const [processingIndex, setProcessingIndex] = useState<number>(-1); // -1 indicates not started, >= 0 is the index being processed
+  const [testingProxy, setTestingProxy] = useState(false);
+  const [proxyTestResult, setProxyTestResult] = useState<
+    "idle" | "success" | "error"
+  >("idle");
+  const [isCaptchaVerified, setIsCaptchaVerified] = useState(false);
+  const [captchaLoading, setCaptchaLoading] = useState(false);
+  const [emailVerifyLoading, setEmailVerifyLoading] = useState(false); // Loading state for email verification step
+  const [allAccountsProcessed, setAllAccountsProcessed] = useState(false); // Checklist item 1: Add state
+  const [autoFetchLoading, setAutoFetchLoading] = useState(false); // 新增状态
+  const [saveInviteCode, setSaveInviteCode] = useState(false); // Added state for checkbox
+  
+  // 添加错误跟踪和重试状态
+  const [captchaError, setCaptchaError] = useState<string | null>(null);
+  const [emailVerificationError, setEmailVerificationError] = useState<string | null>(null);
+  const [registrationError, setRegistrationError] = useState<string | null>(null);
+
+  // 添加重置表单函数
+  const resetForm = () => {
+    // 保留邀请码
+    const savedInviteCode = form.getFieldValue("invite_code");
+    
+    // 重置表单
+    form.resetFields(["accountInfo", "verification_code"]);
+    if (savedInviteCode && saveInviteCode) {
+      form.setFieldValue("invite_code", savedInviteCode);
+    }
+    
+    // 重置状态
+    setLoading(false);
+    setAccountList([]);
+    setProcessingIndex(-1);
+    setCurrent(0);
+    setIsCaptchaVerified(false);
+    setCaptchaLoading(false);
+    setEmailVerifyLoading(false);
+    setAllAccountsProcessed(false);
+    setAutoFetchLoading(false);
+    
+    // 重置错误状态
+    setCaptchaError(null);
+    setEmailVerificationError(null);
+    setRegistrationError(null);
+    
+    message.success("已重置，可以开始新一轮注册");
+  };
+
+  // Load saved invite code on mount
+  useEffect(() => {
+    try {
+      const savedCode = localStorage.getItem("savedInviteCode");
+      if (savedCode) {
+        form.setFieldsValue({ invite_code: savedCode });
+        setSaveInviteCode(true);
+      }
+    } catch (error) {
+      console.error("无法访问 localStorage:", error);
+      // Don't block rendering, just log error
+    }
+  }, [form]); // Run once on mount, depends on form instance
+
+  // 初始化重试的专门函数
+  const handleRetryInitialization = () => {
+    if (processingIndex >= 0 && processingIndex < accountList.length) {
+      handleInitializeCurrentAccount(processingIndex);
+    }
+  };
+  
+  // 更新移动到下一账号或完成的函数，重置错误状态
+  const moveToNextAccountOrComplete = () => {
+    // 重置所有错误状态
+    setCaptchaError(null);
+    setEmailVerificationError(null);
+    setRegistrationError(null);
+    
+    const nextIndex = processingIndex + 1;
+    if (nextIndex >= accountList.length) {
+      setAllAccountsProcessed(true);
+      setLoading(false);
+      message.success("所有账号均已处理完毕!");
+    } else {
+      setAllAccountsProcessed(false);
+      setAccountList((prev) =>
+        prev.map((acc) =>
+          acc.id === nextIndex ? { ...acc, status: "pending" } : acc
+        )
+      );
+      handleStartNextAccount(nextIndex);
+    }
+    setCurrent(3);
+  };
+
+  const handleStartNextAccount = (nextIndex: number) => {
+    if (nextIndex >= 0 && nextIndex < accountList.length) {
+      // Reset states for the next account's steps
+      setProcessingIndex(nextIndex);
+      setCurrent(0);
+      setIsCaptchaVerified(false);
+      setCaptchaLoading(false);
+      setEmailVerifyLoading(false);
+      form.setFieldsValue({ verification_code: "" }); // Clear previous code
+    } else {
+      message.info("所有账号均已处理。");
+    }
+  };
+
+  const handleInitializeCurrentAccount = async (index: number) => {
+    if (index < 0 || index >= accountList.length) {
+      console.warn(
+        "handleInitializeCurrentAccount called with invalid index or empty list",
+        index,
+        accountList.length
+      );
+      return;
+    }
+
+    const account = accountList[index];
+    const inviteCode = form.getFieldValue("invite_code");
+    const proxyUrl = form.getFieldValue("use_proxy")
+      ? form.getFieldValue("proxy_url")
+      : undefined;
+
+    setAccountList((prev) =>
+      prev.map((acc) =>
+        acc.id === account.id
+          ? { ...acc, status: "initializing", message: "开始初始化..." }
+          : acc
+      )
+    );
+
+    try {
+      const dataToSend: any = {
+        invite_code: inviteCode,
+        email: account.account,
+        use_proxy: !!proxyUrl,
+      };
+      if (proxyUrl) {
+        dataToSend.proxy_url = proxyUrl;
+      }
+
+      let formData = new FormData();
+      for (const key in dataToSend) {
+        formData.append(key, dataToSend[key]);
+      }
+
+      const response = await initialize(formData);
+      const responseData = response.data;
+      console.log(
+        `[${account.account}] Initialize API response:`,
+        responseData
+      );
+
+      if (responseData.status === "success") {
+        setAccountList((prev) =>
+          prev.map((acc) =>
+            acc.id === account.id
+              ? {
+                  ...acc,
+                  status: "captcha_pending",
+                  message: responseData.message || "初始化成功, 等待验证码",
+                }
+              : acc
+          )
+        );
+        setCurrent(1); // Move to captcha step for this account
+
+        // 直接调用过滑块验证
+        setTimeout(() => {
+          handleCaptchaVerification();
+        }, 1000);
+      } else {
+        throw new Error(responseData.message || "初始化返回失败状态");
+      }
+    } catch (error: any) {
+      console.error(`[${account.account}] 初始化失败:`, error);
+      const errorMessage = error.message || "未知错误";
+      // Update status first
+      setAccountList((prev) =>
+        prev.map((acc) =>
+          acc.id === account.id
+            ? {
+                ...acc,
+                status: "error",
+                message: `初始化失败: ${errorMessage}`,
+              }
+            : acc
+        )
+      );
+      // 不再自动跳到下一个账号，让用户选择是重试还是跳过
+      // moveToNextAccountOrComplete(); // 移除这行代码
+    }
+  };
+
+  const startProcessing = async () => {
+    try {
+      const values = await form.validateFields([
+        "invite_code",
+        "accountInfo",
+        "use_proxy",
+        "proxy_url",
+      ]); // Validate needed fields
+      setLoading(true);
+      setAccountList([]);
+      setProcessingIndex(-1);
+      setCurrent(0);
+      setIsCaptchaVerified(false);
+      setCaptchaLoading(false);
+
+      const lines = values.accountInfo
+        .split("\n")
+        .filter((line: string) => line.trim() !== "");
+      const parsedAccounts: AccountInfo[] = [];
+      let formatError = false;
+      for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const parts = line.split("----");
+        if (
+          parts.length < 4 ||
+          parts.some((part: string) => part.trim() === "")
+        ) {
+          message.error(`第 ${i + 1} 行格式错误或包含空字段，请检查！`);
+          formatError = true;
+          break; // Stop parsing on first error
+        }
+        parsedAccounts.push({
+          id: i,
+          account: parts[0].trim(),
+          password: parts[1].trim(),
+          clientId: parts[2].trim(),
+          token: parts[3].trim(),
+          status: "pending",
+        });
+      }
+
+      if (formatError) {
+        setLoading(false);
+        return;
+      }
+
+      if (parsedAccounts.length === 0) {
+        message.warning("请输入至少一条有效的账号信息。");
+        setLoading(false);
+        return;
+      }
+      // console.log(parsedAccounts, "----------------"); // Keep user's log if desired
+      setAccountList(parsedAccounts);
+      setProcessingIndex(0); // Start with the first account
+      setLoading(true); // Ensure loading is true when processing starts
+      setAllAccountsProcessed(false); // Reset completion flag
+      setCurrent(0); // Ensure starting at step 0
+      setIsCaptchaVerified(false); // Reset step-specific states
+      setCaptchaLoading(false);
+      setEmailVerifyLoading(false);
+    } catch (error) {
+      console.error("表单验证失败或解析错误:", error);
+      setLoading(false);
+      // Validation errors are handled by Antd form
+    }
+  };
+
+  const handleCaptchaVerification = async () => {
+    if (processingIndex < 0 || processingIndex >= accountList.length) return;
+    const currentAccount = accountList[processingIndex];
+
+    setCaptchaLoading(true);
+    setIsCaptchaVerified(false);
+    setCaptchaError(null); // 重置验证码错误状态
+    
+    try {
+      console.log(`[${currentAccount.account}] 调用 verifyCaptha API...`);
+      let formData = new FormData();
+      formData.append("email", currentAccount.account); // Pass current email
+      const response = await verifyCaptha(formData);
+      const responseData = response.data;
+      console.log(
+        `[${currentAccount.account}] verifyCaptha API response:`,
+        responseData
+      );
+
+      if (responseData.status === "success") {
+        message.success(responseData.message || "验证成功！");
+        setIsCaptchaVerified(true); // Set verification success
+        // 可以点击下一步
+        setAccountList((prev) =>
+          prev.map((acc) =>
+            acc.id === currentAccount.id
+              ? {
+                  ...acc,
+                  status: "email_pending",
+                  message: "验证码成功, 等待邮箱验证",
+                }
+              : acc
+          )
+        );
+        // 验证成功时自动移至下一步
+        setCurrent(2);
+        // DO NOT call next() here, user clicks the button
+        // 获取验证码
+        setTimeout(() => {
+          handleAutoFetchCode();
+        }, 200);
+      } else {
+        const errorMessage = responseData.message || "验证失败，请确保已完成滑块验证后重试";
+        message.error(errorMessage);
+        setIsCaptchaVerified(false);
+        setCaptchaError(errorMessage); // 设置错误信息
+        
+        // 更新账号状态为错误，但保持在当前步骤
+        setAccountList((prev) =>
+          prev.map((acc) =>
+            acc.id === currentAccount.id
+              ? { 
+                  ...acc, 
+                  message: `滑块验证失败: ${errorMessage}` 
+                }
+              : acc
+          )
+        );
+      }
+    } catch (error: any) {
+      // Added type annotation
+      console.error(`[${currentAccount.account}] 验证码 API 调用失败:`, error);
+      const errorMessage = error.message || "未知错误";
+      message.error(`验证码验证出错: ${errorMessage}`);
+      setIsCaptchaVerified(false);
+      setCaptchaError(errorMessage); // 设置错误信息
+      
+      // 更新账号状态为错误，但保持在当前步骤
+      setAccountList((prev) =>
+        prev.map((acc) =>
+          acc.id === currentAccount.id
+            ? { 
+                ...acc, 
+                message: `滑块验证出错: ${errorMessage}` 
+              }
+            : acc
+        )
+      );
+    } finally {
+      setCaptchaLoading(false);
+      // 移除这里的setCurrent(2)，让步骤只在验证成功时前进
+      // setCurrent(2);
+    }
+  };
+
+  // 添加滑块验证重试功能
+  const handleRetryCaptcha = () => {
+    setCaptchaError(null);
+    handleCaptchaVerification();
+  };
+
+  const handleEmailVerification = async () => {
+    if (processingIndex < 0 || processingIndex >= accountList.length) return;
+    const currentAccount = accountList[processingIndex];
+    const verificationCode = form.getFieldValue("verification_code"); // Get code from form
+
+    if (!verificationCode) {
+      message.error("请输入邮箱验证码！");
+      return;
+    }
+
+    setEmailVerifyLoading(true);
+    setRegistrationError(null); // 重置注册错误状态
+    setAccountList((prev) =>
+      prev.map((acc) =>
+        acc.id === currentAccount.id
+          ? { ...acc, message: "正在提交注册信息..." }
+          : acc
+      )
+    ); // 更新提示信息
+
+    try {
+      console.log(`[${currentAccount.account}] 调用注册 API...`, {
+        code: verificationCode,
+      });
+
+      // --- 替换模拟代码为实际 API 调用 ---
+      // 准备数据
+      const formData = new FormData();
+      formData.append("email", currentAccount.account);
+      formData.append("verification_code", verificationCode);
+
+      const response = await register(formData);
+      const responseData = response.data;
+      console.log(
+        `[${currentAccount.account}] Register API response:`,
+        responseData
+      );
+
+      // 处理响应
+      if (responseData.status === "success") {
+        // 成功情况
+        console.log(`[${currentAccount.account}] 注册成功`);
+        message.success(responseData.message || "注册成功!");
+        // 更新状态和消息
+        setAccountList((prev) =>
+          prev.map((acc) =>
+            acc.id === currentAccount.id
+              ? {
+                  ...acc,
+                  status: "success",
+                  message: responseData.message || "注册成功",
+                  // 可选: 存储 responseData.account_info
+                }
+              : acc
+          )
+        );
+        // 移动到下一步或完成
+        moveToNextAccountOrComplete();
+        setLoading(false);
+      } else {
+        // 失败情况 (后端返回非成功状态)
+        const errorMessage = responseData.message || "注册返回失败状态";
+        throw new Error(errorMessage);
+      }
+      // --- 结束替换 ---
+    } catch (error: any) {
+      console.error(`[${currentAccount.account}] 注册失败:`, error);
+      const errorMessage = error.message || "未知错误";
+      message.error(`注册失败: ${errorMessage}`);
+      setRegistrationError(errorMessage); // 设置注册错误状态
+      
+      // 更新状态和消息，但不移动到下一个账号
+      setAccountList((prev) =>
+        prev.map((acc) =>
+          acc.id === currentAccount.id
+            ? { ...acc, message: `注册失败: ${errorMessage}` }
+            : acc
+        )
+      );
+    } finally {
+      setEmailVerifyLoading(false);
+    }
+  };
+
+  // 添加注册重试功能
+  const handleRetryRegistration = () => {
+    setRegistrationError(null);
+    handleEmailVerification();
+  };
+
+  const getCurrentAccount = () => {
+    if (processingIndex >= 0 && processingIndex < accountList.length) {
+      return accountList[processingIndex];
+    }
+    return null;
+  };
+
+  const handleTestProxy = async () => {
+    setProxyTestResult("idle");
+    const proxyUrl = form.getFieldValue("proxy_url");
+    if (!proxyUrl || !proxyUrl.trim()) {
+      message.error("请输入代理地址再进行测试！");
+      return;
+    }
+    if (!proxyUrl.startsWith("http://") && !proxyUrl.startsWith("https://")) {
+      message.warning(
+        "代理地址格式似乎不正确，请检查 (应以 http:// 或 https:// 开头)"
+      );
+    }
+
+    setTestingProxy(true);
+    const formData = new FormData();
+    formData.append("proxy_url", proxyUrl);
+
+    try {
+      const response = await testProxy(formData);
+      const responseData = response.data;
+      if (responseData.status === "success") {
+        setProxyTestResult("success");
+      } else {
+        setProxyTestResult("error");
+      }
+    } catch (error: any) {
+      console.error("测试代理失败:", error);
+      setProxyTestResult("error");
+    } finally {
+      setTestingProxy(false);
+    }
+  };
+
+  useEffect(() => {
+    if (
+      accountList.length > 0 &&
+      processingIndex < accountList.length &&
+      accountList[processingIndex].status === "pending"
+    ) {
+      console.log("useEffect triggering initialization for index 0");
+      // Call the initialization function for the first account
+      handleInitializeCurrentAccount(processingIndex);
+    }
+    // Dependencies: run when the index changes or the list is populated
+  }, [processingIndex, accountList]);
+
+  const handleAutoFetchCode = async () => {
+    const currentAccount = getCurrentAccount();
+    setAutoFetchLoading(true);
+    setEmailVerificationError(null); // 重置验证码获取错误状态
+    
+    try {
+      const formData = new FormData();
+      formData.append("email", currentAccount?.account || "");
+      formData.append("password", currentAccount?.password || "");
+      formData.append("token", currentAccount?.token || "");
+      formData.append("client_id", currentAccount?.clientId || "");
+
+      const response = await getEmailVerificationCode(formData);
+
+      const result = response.data;
+
+      if (result.status === "success" && result.verification_code) {
+        form.setFieldValue("verification_code", result.verification_code);
+        message.success(result.msg || "验证码已自动填入");
+        console.log("收到验证码：", result.verification_code);
+        
+        // 验证邮箱
+        setTimeout(() => {
+          handleEmailVerification();
+        }, 1000);
+      } else {
+        // 显示后端返回的更具体的错误信息
+        const errorMessage = result.msg || "未能获取验证码，请检查邮箱和密码或手动输入";
+        message.error(errorMessage);
+        setEmailVerificationError(errorMessage); // 设置错误信息
+        
+        // 更新账号状态显示错误
+        if (currentAccount) {
+          setAccountList((prev) =>
+            prev.map((acc) =>
+              acc.id === currentAccount.id
+                ? { 
+                    ...acc, 
+                    message: `获取验证码失败: ${errorMessage}` 
+                  }
+                : acc
+            )
+          );
+        }
+      }
+    } catch (error: any) {
+      const errorMessage = error.message || "未知错误";
+      message.error(`获取验证码时出错: ${errorMessage}`);
+      setEmailVerificationError(errorMessage); // 设置错误信息
+      console.error("Auto fetch code error:", error);
+      
+      // 更新账号状态显示错误
+      if (currentAccount) {
+        setAccountList((prev) =>
+          prev.map((acc) =>
+            acc.id === currentAccount.id
+              ? { 
+                  ...acc, 
+                  message: `获取验证码出错: ${errorMessage}` 
+                }
+              : acc
+          )
+        );
+      }
+    } finally {
+      setAutoFetchLoading(false);
+    }
+  };
+
+  // 添加获取验证码重试功能
+  const handleRetryEmailVerification = () => {
+    setEmailVerificationError(null);
+    handleAutoFetchCode();
+  };
+
+  const handleSaveInviteCodeChange = (e: CheckboxChangeEvent) => {
+    const isChecked = e.target.checked;
+    setSaveInviteCode(isChecked);
+    const currentCode = form.getFieldValue("invite_code");
+    try {
+      if (isChecked && currentCode) {
+        localStorage.setItem("savedInviteCode", currentCode);
+      } else {
+        localStorage.removeItem("savedInviteCode");
+      }
+    } catch (error) {
+      console.error("无法访问 localStorage:", error);
+      message.error("无法保存邀请码设置，存储不可用。");
+    }
+  };
+
+  const handleInviteCodeInputChange = (
+    e: React.ChangeEvent<HTMLInputElement>
+  ) => {
+    const newCode = e.target.value;
+    if (saveInviteCode) {
+      try {
+        if (newCode) {
+          localStorage.setItem("savedInviteCode", newCode);
+        } else {
+          // If code is cleared while save is checked, remove from storage
+          localStorage.removeItem("savedInviteCode");
+        }
+      } catch (error) {
+        console.error("无法访问 localStorage:", error);
+        // Optionally show message, but might be too noisy on every input change
+      }
+    }
+  };
+
+  const steps = [
+    {
+      title: "初始化",
+      content: (() => {
+        const currentAccount = getCurrentAccount();
+        const status = currentAccount?.status || "pending";
+
+        // 根据状态决定不同的初始化步骤样式
+        if (status === "pending") {
+          return (
+            <div
+              className="step-content-container"
+              style={{ textAlign: "center", padding: "12px" }}
+            >
+              <div
+                style={{
+                  fontSize: "42px",
+                  color: "#8c8c8c",
+                  marginBottom: "10px",
+                }}
+              >
+                <SafetyCertificateOutlined />
+              </div>
+              <h3
+                style={{
+                  marginBottom: "10px",
+                  fontSize: "18px",
+                  fontWeight: "bold",
+                }}
+              >
+                等待初始化
+              </h3>
+              <p style={{ color: "#666", marginBottom: "10px" }}>
+                系统准备就绪，正在等待开始初始化流程
+              </p>
+              <Progress percent={0} status="normal" />
+            </div>
+          );
+        } else if (status === "initializing") {
+          return (
+            <div
+              className="step-content-container"
+              style={{ textAlign: "center", padding: "12px" }}
+            >
+              <div
+                style={{
+                  fontSize: "42px",
+                  color: "#1890ff",
+                  marginBottom: "10px",
+                }}
+              >
+                <SyncOutlined spin />
+              </div>
+              <h3
+                style={{
+                  marginBottom: "10px",
+                  fontSize: "18px",
+                  fontWeight: "bold",
+                }}
+              >
+                正在初始化
+              </h3>
+              <p style={{ color: "#666", marginBottom: "10px" }}>
+                系统正在准备您的注册环境，请稍候...
+              </p>
+              <Progress percent={25} status="active" />
+            </div>
+          );
+        } else if (status === "error") {
+          return (
+            <div
+              className="step-content-container"
+              style={{ textAlign: "center", padding: "12px" }}
+            >
+              <div
+                style={{
+                  fontSize: "42px",
+                  color: "#ff4d4f",
+                  marginBottom: "10px",
+                }}
+              >
+                <CloseCircleOutlined />
+              </div>
+              <h3
+                style={{
+                  marginBottom: "10px",
+                  fontSize: "18px",
+                  fontWeight: "bold",
+                }}
+              >
+                初始化失败
+              </h3>
+              <p style={{ color: "#666", marginBottom: "10px" }}>
+                {currentAccount?.message ||
+                  "初始化过程中遇到错误，请检查网络或代理设置"}
+              </p>
+              <Progress percent={25} status="exception" />
+              <div style={{ marginTop: "8px" }}>
+                <Button
+                  type="primary"
+                  danger
+                  onClick={handleRetryInitialization}
+                  style={{ marginRight: "8px" }}
+                >
+                  重试初始化
+                </Button>
+                <Button
+                  onClick={moveToNextAccountOrComplete}
+                >
+                  跳过此账号
+                </Button>
+              </div>
+            </div>
+          );
+        } else {
+          // 其他状态表示已初始化完���
+          return (
+            <div
+              className="step-content-container"
+              style={{ textAlign: "center", padding: "12px" }}
+            >
+              <div
+                style={{
+                  fontSize: "42px",
+                  color: "#52c41a",
+                  marginBottom: "10px",
+                }}
+              >
+                <CheckCircleOutlined />
+              </div>
+              <h3
+                style={{
+                  marginBottom: "10px",
+                  fontSize: "18px",
+                  fontWeight: "bold",
+                }}
+              >
+                初始化完成
+              </h3>
+              <p style={{ color: "#666", marginBottom: "10px" }}>
+                环境准备就绪，可以继续下一步操作
+              </p>
+              <Progress percent={100} status="success" />
+            </div>
+          );
+        }
+      })(),
+    },
+    {
+      title: "滑块验证",
+      content: (() => {
+        // 滑块验证步骤的UI
+        if (captchaLoading) {
+          return (
+            <div
+              className="step-content-container"
+              style={{ textAlign: "center", padding: "12px" }}
+            >
+              <div
+                style={{
+                  fontSize: "42px",
+                  color: "#1890ff",
+                  marginBottom: "10px",
+                }}
+              >
+                <SyncOutlined spin />
+              </div>
+              <h3
+                style={{
+                  marginBottom: "10px",
+                  fontSize: "18px",
+                  fontWeight: "bold",
+                }}
+              >
+                正在进行滑块验证
+              </h3>
+              <p style={{ color: "#666", marginBottom: "10px" }}>
+                系统正在自动完成滑块验证，请稍候...
+              </p>
+              <Progress percent={50} status="active" />
+            </div>
+          );
+        } else if (isCaptchaVerified) {
+          return (
+            <div
+              className="step-content-container"
+              style={{ textAlign: "center", padding: "12px" }}
+            >
+              <div
+                style={{
+                  fontSize: "42px",
+                  color: "#52c41a",
+                  marginBottom: "10px",
+                }}
+              >
+                <CheckCircleOutlined />
+              </div>
+              <h3
+                style={{
+                  marginBottom: "10px",
+                  fontSize: "18px",
+                  fontWeight: "bold",
+                }}
+              >
+                滑块验证成功
+              </h3>
+              <p style={{ color: "#666", marginBottom: "10px" }}>
+                成功完成滑块验证，验证码已发送至邮箱
+              </p>
+              <Progress percent={100} status="success" />
+            </div>
+          );
+        } else if (captchaError) {
+          // 滑块验证失败时显示错误和重试按钮
+          return (
+            <div
+              className="step-content-container"
+              style={{ textAlign: "center", padding: "12px" }}
+            >
+              <div
+                style={{
+                  fontSize: "42px",
+                  color: "#ff4d4f",
+                  marginBottom: "10px",
+                }}
+              >
+                <CloseCircleOutlined />
+              </div>
+              <h3
+                style={{
+                  marginBottom: "10px",
+                  fontSize: "18px",
+                  fontWeight: "bold",
+                }}
+              >
+                滑块验证失败
+              </h3>
+              <p style={{ color: "#666", marginBottom: "10px" }}>
+                {captchaError}
+              </p>
+              <Progress percent={50} status="exception" />
+              <div style={{ marginTop: "8px" }}>
+                <Button
+                  type="primary"
+                  danger
+                  onClick={handleRetryCaptcha}
+                  style={{ marginRight: "8px" }}
+                >
+                  重试滑块验证
+                </Button>
+                <Button
+                  onClick={moveToNextAccountOrComplete}
+                >
+                  跳过此账号
+                </Button>
+              </div>
+            </div>
+          );
+        } else {
+          return (
+            <div
+              className="step-content-container"
+              style={{ textAlign: "center", padding: "12px" }}
+            >
+              <div
+                style={{
+                  fontSize: "42px",
+                  color: "#8c8c8c",
+                  marginBottom: "10px",
+                }}
+              >
+                <SyncOutlined />
+              </div>
+              <h3
+                style={{
+                  marginBottom: "10px",
+                  fontSize: "18px",
+                  fontWeight: "bold",
+                }}
+              >
+                等待滑块验证
+              </h3>
+              <p style={{ color: "#666", marginBottom: "10px" }}>
+                点击下方的"开始验证"按钮进行滑块验证
+              </p>
+              <Progress percent={40} status="normal" />
+            </div>
+          );
+        }
+      })(),
+    },
+    {
+      title: "邮箱验证",
+      content: (() => {
+        const currentAccount = getCurrentAccount();
+        
+        // 根据不同状态显示不同内容
+        if (emailVerifyLoading) {
+          return (
+            <div
+              className="step-content-container"
+              style={{ textAlign: "center", padding: "12px" }}
+            >
+              <div
+                style={{
+                  fontSize: "42px",
+                  color: "#1890ff",
+                  marginBottom: "10px",
+                }}
+              >
+                <SyncOutlined spin />
+              </div>
+              <h3
+                style={{
+                  marginBottom: "10px",
+                  fontSize: "18px",
+                  fontWeight: "bold",
+                }}
+              >
+                正在验证
+              </h3>
+              <p style={{ color: "#666", marginBottom: "10px" }}>
+                正在验证您的邮箱验证码，请稍候...
+              </p>
+              <Progress percent={75} status="active" />
+            </div>
+          );
+        } else if (registrationError) {
+          // 注册失败时显示
+          return (
+            <div
+              className="step-content-container"
+              style={{ textAlign: "center", padding: "12px" }}
+            >
+              <div
+                style={{
+                  fontSize: "42px",
+                  color: "#ff4d4f",
+                  marginBottom: "10px",
+                }}
+              >
+                <CloseCircleOutlined />
+              </div>
+              <h3
+                style={{
+                  marginBottom: "10px",
+                  fontSize: "18px",
+                  fontWeight: "bold",
+                }}
+              >
+                注册失败
+              </h3>
+              <p style={{ color: "#666", marginBottom: "10px" }}>
+                {registrationError}
+              </p>
+              <Form form={form}>
+              <Form.Item
+                name="verification_code"
+                style={{ maxWidth: "300px", margin: "0 auto 10px" }}
+              >
+                <Input placeholder="输入邮箱验证码" />
+              </Form.Item>
+              </Form>
+              <div style={{ marginTop: "8px" }}>
+                <Button
+                  type="primary"
+                  danger
+                  onClick={handleRetryRegistration}
+                  style={{ marginRight: "8px" }}
+                >
+                  重试注册
+                </Button>
+                <Button
+                  onClick={moveToNextAccountOrComplete}
+                >
+                  跳过此账号
+                </Button>
+              </div>
+            </div>
+          );
+        } else if (emailVerificationError) {
+          // 获取验证码失败时显示
+          return (
+            <div
+              className="step-content-container"
+              style={{ textAlign: "center", padding: "12px" }}
+            >
+              <div
+                style={{
+                  fontSize: "42px",
+                  color: "#ff4d4f",
+                  marginBottom: "10px",
+                }}
+              >
+                <CloseCircleOutlined />
+              </div>
+              <h3
+                style={{
+                  marginBottom: "10px",
+                  fontSize: "18px",
+                  fontWeight: "bold",
+                }}
+              >
+                获取验证码失败
+              </h3>
+              <p style={{ color: "#666", marginBottom: "10px" }}>
+                {emailVerificationError}
+              </p>
+              <div style={{ marginTop: "8px" }}>
+                <Button
+                  type="primary"
+                  danger
+                  onClick={handleRetryEmailVerification}
+                  style={{ marginRight: "8px" }}
+                >
+                  重试获取验证码
+                </Button>
+                <Button
+                  onClick={moveToNextAccountOrComplete}
+                >
+                  跳过此账号
+                </Button>
+              </div>
+            </div>
+          );
+        } else {
+          // 默认显示内容
+          return (
+            <div
+              className="step-content-container"
+              style={{ textAlign: "center", padding: "12px" }}
+            >
+              <div
+                style={{
+                  fontSize: "42px",
+                  color: "#1890ff",
+                  marginBottom: "10px",
+                }}
+              >
+                <MailOutlined />
+              </div>
+              <h3
+                style={{
+                  marginBottom: "10px",
+                  fontSize: "18px",
+                  fontWeight: "bold",
+                }}
+              >
+                邮箱验证
+              </h3>
+              <p style={{ color: "#666", marginBottom: "10px" }}>
+                {currentAccount ? `验证码已发送至 ${currentAccount.account}` : "验证码已发送至邮箱"}
+              </p>
+              <Form.Item
+                label="验证码"
+                name="verification_code"
+                style={{ maxWidth: "300px", margin: "0 auto 10px" }}
+              >
+                <Input placeholder="输入邮箱验证码" />
+              </Form.Item>
+              <Button
+                type="default"
+                onClick={handleAutoFetchCode}
+                loading={autoFetchLoading}
+                style={{ marginRight: "8px" }}
+              >
+                自动获取验证码
+              </Button>
+              <Progress percent={60} status="active" style={{ marginTop: "10px" }} />
+            </div>
+          );
+        }
+      })(),
+    },
+    {
+      title: "结果",
+      content: (() => {
+        if (allAccountsProcessed) {
+          return (
+            <div
+              className="step-content-container"
+              style={{ textAlign: "center", padding: "12px" }}
+            >
+              <div
+                style={{
+                  fontSize: "42px",
+                  color: "#52c41a",
+                  marginBottom: "10px",
+                }}
+              >
+                <CheckCircleOutlined />
+              </div>
+              <h3
+                style={{
+                  marginBottom: "10px",
+                  fontSize: "18px",
+                  fontWeight: "bold",
+                }}
+              >
+                所有账号处理完成！
+              </h3>
+              <p style={{ color: "#666", marginBottom: "10px" }}>
+                所有账号已处理完毕，可以在右侧查看处理结果
+              </p>
+              <Progress percent={100} status="success" />
+            </div>
+          );
+        } else {
+          return (
+            <div
+              className="step-content-container"
+              style={{ textAlign: "center", padding: "12px" }}
+            >
+              <div
+                style={{
+                  fontSize: "42px",
+                  color: "#8c8c8c",
+                  marginBottom: "10px",
+                }}
+              >
+                <SyncOutlined />
+              </div>
+              <h3
+                style={{
+                  marginBottom: "10px",
+                  fontSize: "18px",
+                  fontWeight: "bold",
+                }}
+              >
+                等待完成注册
+              </h3>
+              <p style={{ color: "#666", marginBottom: "10px" }}>
+                等待完成前面的步骤
+              </p>
+              <Progress percent={0} status="normal" />
+            </div>
+          );
+        }
+      })(),
+    },
+  ];
+
+  const next = () => {
+    if (current < steps.length - 1) {
+      setCurrent(current + 1);
+    }
+  };
+
+  const handleMainButtonClick = async () => {
+    if (current === 0) {
+      // 初始化页面
+      const currentAccount = getCurrentAccount();
+      
+      // 如果当前有错误状态的账号，提供重试选项
+      if (currentAccount && currentAccount.status === "error") {
+        handleRetryInitialization();
+      } else {
+        await startProcessing();
+      }
+    } else if (current === 1) {
+      // 滑块验证页面
+      if (captchaError) {
+        // 如果有错误，重试滑块验证
+        handleRetryCaptcha();
+      } else if (isCaptchaVerified) {
+        next(); // 验证已通过，移至下一步
+      } else {
+        // 未开始验证，显示警告
+        console.log("请先完成滑块验证！");
+        message.warning("请先完成滑块验证！");
+      }
+    } else if (current === 2) {
+      // 邮箱验证页面
+      if (registrationError) {
+        // 注册失败，重试注册
+        handleRetryRegistration();
+      } else if (emailVerificationError) {
+        // 获取验证码失败，重试获取
+        handleRetryEmailVerification();
+      } else {
+        // 正常验证
+        await handleEmailVerification();
+      }
+    } else if (current === 3) {
+      // 结果页面
+      if (allAccountsProcessed) {
+        // 如果所有账号都已处理完成，重置表单
+        resetForm();
+      } else {
+        // 否则，开始处理下一个账号
+        handleStartNextAccount(processingIndex + 1);
+      }
+    }
+  };
+
+  let mainButtonText = "开始处理";
+  let mainButtonLoading = loading;
+  let mainButtonDisabled = false;
+
+  if (current === 0) {
+    const currentAccount = getCurrentAccount();
+    if (currentAccount && currentAccount.status === "error") {
+      mainButtonText = "重试初��化";
+      mainButtonDisabled = false;
+    } else {
+      mainButtonText = "开始处理";
+      mainButtonDisabled = loading || processingIndex !== -1; // Disable if already processing
+    }
+  } else if (current === 1) {
+    // 滑块验证页面
+    if (captchaError) {
+      mainButtonText = "重试滑块验证";
+      mainButtonLoading = captchaLoading;
+    } else if (isCaptchaVerified) {
+      mainButtonText = "下一步";
+      mainButtonDisabled = false;
+    } else {
+      mainButtonText = "开始验证";
+      mainButtonLoading = captchaLoading;
+    }
+  } else if (current === 2) {
+    // 邮箱验证页面
+    if (registrationError) {
+      mainButtonText = "重试注册";
+      mainButtonLoading = emailVerifyLoading;
+    } else if (emailVerificationError) {
+      mainButtonText = "重试获取验证码";
+      mainButtonLoading = autoFetchLoading;
+    } else {
+      mainButtonText = "验证邮箱";
+      mainButtonLoading = emailVerifyLoading;
+      mainButtonDisabled = form.getFieldValue("verification_code") === "";
+    }
+  } else if (current === 3) {
+    if (allAccountsProcessed) {
+      mainButtonText = "完成并重置";
+    } else if (processingIndex === accountList.length - 1) {
+      mainButtonText = "完成";
+    } else {
+      mainButtonText = "开始下一个账号";
+    }
+  }
+
+  return (
+    <div className="register-container">
+      <Card title="PikPak 账号注册" variant="borderless" className="register-card">
+        <Row gutter={24}>
+          <Col xs={24} md={24}>
+            {" "}
+            {/* 左侧表单 */}
+            <Form
+              form={form}
+              layout="vertical"
+              initialValues={{
+                accountInfo: "",
+                use_proxy: false,
+                proxy_url: "http://127.0.0.1:7890",
+              }}
+            >
+              <Form.Item label="邀请码" required>
+                <Row align="middle" gutter={8}>
+                  <Col flex="auto">
+                    <Form.Item
+                      name="invite_code"
+                      noStyle
+                      rules={[{ required: true, message: "请输入邀请码" }]}
+                    >
+                      <Input
+                        placeholder="请输入邀请码"
+                        disabled={loading}
+                        onChange={handleInviteCodeInputChange}
+                      />
+                    </Form.Item>
+                  </Col>
+                  <Col>
+                    <Checkbox
+                      checked={saveInviteCode}
+                      onChange={handleSaveInviteCodeChange}
+                      disabled={loading}
+                    >
+                      保存
+                    </Checkbox>
+                  </Col>
+                </Row>
+              </Form.Item>
+              <Form.Item
+                label="微软邮箱信息 (每行一条)"
+                name="accountInfo"
+                rules={[
+                  { required: true, message: "请输入账号信息" },
+                  // 可选：添加更复杂的自定义验证器
+                ]}
+              >
+                <TextArea
+                  rows={10}
+                  placeholder="格式: 账号----密码----clientId----授权令牌"
+                  disabled={loading}
+                />
+              </Form.Item>
+              <Form.Item
+                label="使用代理"
+                name="use_proxy"
+                valuePropName="checked"
+              >
+                <Switch
+                  onChange={(checked) => setUseProxy(checked)}
+                  disabled={loading}
+                />
+              </Form.Item>
+              {useProxy && (
+                <Form.Item label="代理地址" required={useProxy}>
+                  <div
+                    style={{
+                      display: "flex",
+                      gap: "8px",
+                      alignItems: "center",
+                    }}
+                  >
+                    <Form.Item
+                      name="proxy_url"
+                      rules={[
+                        { required: useProxy, message: "请输入代理地址" },
+                      ]}
+                      style={{ flexGrow: 1, marginBottom: 0 }}
+                    >
+                      <Input
+                        placeholder="例如: http://127.0.0.1:7890"
+                        disabled={loading}
+                        onChange={() => setProxyTestResult("idle")}
+                      />
+                    </Form.Item>
+                    <Button
+                      onClick={handleTestProxy}
+                      loading={testingProxy}
+                      disabled={loading}
+                    >
+                      测试代理
+                    </Button>
+                    {proxyTestResult === "success" && (
+                      <CheckCircleOutlined
+                        style={{ color: "#52c41a", fontSize: "18px" }}
+                      />
+                    )}
+                    {proxyTestResult === "error" && (
+                      <CloseCircleOutlined
+                        style={{ color: "#ff4d4f", fontSize: "18px" }}
+                      />
+                    )}
+                  </div>
+                </Form.Item>
+              )}
+            </Form>
+          </Col>
+        </Row>{" "}
+        {/* Add current to key */}
+        <div className="steps-action">
+          {current <= 3 && (
+            <Button
+              type="primary"
+              onClick={handleMainButtonClick}
+              loading={mainButtonLoading}
+              disabled={mainButtonDisabled}
+            >
+              {mainButtonText}
+            </Button>
+          )}
+        </div>
+      </Card>
+      <div className="register-right">
+        {/* 右侧状态/说明 */}
+        <Row gutter={24}>
+          <Card
+            className="register-card"
+            title={`处理状态 ${
+              processingIndex >= 0
+                ? `(账号 ${processingIndex + 1} / ${accountList.length})`
+                : ""
+            }`}
+          >
+            {processingIndex === -1 && accountList.length === 0 && (
+              <div>
+                <p>请在左侧输入微软邮箱信息，每行一条，格式如下:</p>
+                <pre>
+                  <code>邮箱----密码----clientId----授权令牌</code>
+                </pre>
+                <p>例如:</p>
+                <pre>
+                  <code>
+                    [email protected]_abc----token_xyz
+                  </code>
+                </pre>
+                <p>输入完成后，点击"开始处理"开始处理。</p>
+              </div>
+            )}
+            {(processingIndex !== -1 || accountList.length > 0) && (
+              <div style={{ maxHeight: "calc(50vh - 127px)", overflowY: "auto" }}>
+                {accountList.map((acc, index) => (
+                  <div
+                    key={acc.id}
+                    style={{
+                      marginBottom: "10px",
+                      padding: "8px",
+                      border:
+                        index === processingIndex
+                          ? "2px solid #1890ff"
+                          : "1px solid #eee",
+                      borderRadius: "4px",
+                      background:
+                        index === processingIndex ? "#e6f7ff" : "transparent",
+                      opacity:
+                        acc.status === "success" || acc.status === "error"
+                          ? 0.7
+                          : 1,
+                    }}
+                  >
+                    <Spin
+                      spinning={
+                        acc.status === "processing" ||
+                        acc.status === "initializing"
+                      }
+                      size="small"
+                      style={{ marginRight: "8px" }}
+                    >
+                      <strong>账号:</strong> {acc.account}
+                    </Spin>
+                    <div style={{ marginTop: "5px" }}>
+                      <strong>状态:</strong>{" "}
+                      {acc.status === "pending" && <Tag>待处理</Tag>}
+                      {acc.status === "processing" && (
+                        <Tag color="processing">处理中</Tag>
+                      )}
+                      {acc.status === "initializing" && (
+                        <Tag color="processing">初始化中</Tag>
+                      )}
+                      {acc.status === "captcha_pending" && (
+                        <Tag color="warning">等待验证码</Tag>
+                      )}
+                      {acc.status === "email_pending" && (
+                        <Tag color="warning">等待邮箱验证</Tag>
+                      )}
+                      {acc.status === "success" && (
+                        <Tag color="success">注册成功</Tag>
+                      )}
+                      {acc.status === "error" && (
+                        <Tag color="error">失败</Tag>
+                      )}
+                    </div>
+                    {acc.message && (
+                      <div style={{ marginTop: "5px", fontSize: "12px" }}>
+                        <strong>消息:</strong>{" "}
+                        <span style={{ 
+                          color: acc.message && (acc.message.includes("失败") || acc.message.includes("错误"))
+                            ? "#ff4d4f" 
+                            : acc.message && acc.message.includes("成功") 
+                              ? "#52c41a" 
+                              : "#666" 
+                        }}>
+                          {acc.message}
+                        </span>
+                        {acc.message && (acc.message.includes("失败") || acc.message.includes("错误")) && (
+                          <span>
+                            <Button 
+                              size="small" 
+                              type="text" 
+                              danger
+                              style={{ marginLeft: "4px" }}
+                              onClick={() => {
+                                // 根据消息类型确定重试哪个步骤
+                                if (index === processingIndex) {
+                                  if (acc.message && acc.message.includes("初始化失败")) {
+                                    handleRetryInitialization();
+                                  } else if (acc.message && acc.message.includes("滑块验证")) {
+                                    handleRetryCaptcha();
+                                  } else if (acc.message && acc.message.includes("获取验证码")) {
+                                    handleRetryEmailVerification();
+                                  } else if (acc.message && acc.message.includes("注册失败")) {
+                                    handleRetryRegistration();
+                                  }
+                                } else {
+                                  // 如果不是当前处理的账号，先切换到它
+                                  setProcessingIndex(index);
+                                  message.info(`已切换到账号 ${acc.account}`);
+                                }
+                              }}
+                            >
+                              重试
+                            </Button>
+                            <Button
+                              size="small"
+                              type="text"
+                              style={{ marginLeft: "4px" }}
+                              onClick={() => {
+                                if (index === processingIndex) {
+                                  // 如果是当前处理的账号，直接跳过
+                                  moveToNextAccountOrComplete();
+                                } else {
+                                  // 如果不是当前处理的账号，提示不能跳过
+                                  message.info(`只能跳过当前正在处理的账号`);
+                                }
+                              }}
+                            >
+                              跳过
+                            </Button>
+                          </span>
+                        )}
+                      </div>
+                    )}
+                  </div>
+                ))}
+              </div>
+            )}
+          </Card>
+        </Row>
+        <Row gutter={24}>
+          <Card title={steps[current].title} className="register-card">
+            {steps[current].content}
+          </Card>
+        </Row>
+      </div>
+    </div>
+  );
+};
+
+export default Register;

frontend/src/services/api.ts

@@ -0,0 +1,94 @@
+import axios from 'axios';
+
+const api = axios.create({
+  baseURL: '/api',
+  timeout: 100000,
+  headers: {
+    'Content-Type': 'application/json',
+  },
+});
+
+
+// 测试代理
+export const testProxy = async (data: any) => {
+  return api.post('/test_proxy', data);
+};
+
+// 初始化注册
+export const initialize = async (data: any) => {
+  return api.post('/initialize', data, {
+    headers: {
+      'Content-Type': 'multipart/form-data',
+    },
+  });
+};
+
+// 验证验证码
+export const verifyCaptha = async (data:any) => {
+  return api.post('/verify_captcha',data, {
+    headers: {
+      'Content-Type': 'multipart/form-data',
+    },
+  });
+};
+
+// 注册账号
+export const register = async (data: any) => {
+  return api.post('/register', data, {
+    headers: {
+      'Content-Type': 'multipart/form-data',
+    },
+  });
+};
+
+// 获取邮箱验证码
+export const getEmailVerificationCode = async (data: any) => {
+  return api.post('/get_email_verification_code', data);
+};
+
+// 激活账号
+export const activateAccounts = async (key: string, names: string[], all: boolean=false) => {
+  return api.post('/activate_account_with_names', { key, names, all });
+};
+
+// 获取账号列表
+export const fetchAccounts = async () => {
+  return api.get('/fetch_accounts');
+};
+
+// 删除账号
+export const deleteAccount = async (filename: string) => {
+  const formData = new FormData();
+  formData.append('filename', filename);
+  return api.post('/delete_account', formData, {
+    headers: {
+      'Content-Type': 'multipart/form-data',
+    },
+  });
+};
+
+// 批量删除账号
+export const deleteAccounts = async (filenames: string[]) => {
+  const formData = new FormData();
+  
+  // 将多个文件名添加到 FormData
+  filenames.forEach(filename => {
+    formData.append('filenames', filename);
+  });
+  
+  return api.post('/delete_account', formData, {
+    headers: {
+      'Content-Type': 'multipart/form-data',
+    },
+  });
+};
+
+// 更新账号
+export const updateAccount = async (filename: string, accountData: any) => {
+  return api.post('/update_account', {
+    filename,
+    account_data: accountData,
+  });
+};
+
+export default api; 

frontend/src/vite-env.d.ts

@@ -0,0 +1 @@
+/// <reference types="vite/client" />

frontend/tsconfig.app.json

@@ -0,0 +1,26 @@
+{
+  "compilerOptions": {
+    "tsBuildInfoFile": "./node_modules/.tmp/tsconfig.app.tsbuildinfo",
+    "target": "ES2020",
+    "useDefineForClassFields": true,
+    "lib": ["ES2020", "DOM", "DOM.Iterable"],
+    "module": "ESNext",
+    "skipLibCheck": true,
+
+    /* Bundler mode */
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "isolatedModules": true,
+    "moduleDetection": "force",
+    "noEmit": true,
+    "jsx": "react-jsx",
+
+    /* Linting */
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedSideEffectImports": true
+  },
+  "include": ["src"]
+}

frontend/tsconfig.json

@@ -0,0 +1,7 @@
+{
+  "files": [],
+  "references": [
+    { "path": "./tsconfig.app.json" },
+    { "path": "./tsconfig.node.json" }
+  ]
+}

frontend/tsconfig.node.json

@@ -0,0 +1,24 @@
+{
+  "compilerOptions": {
+    "tsBuildInfoFile": "./node_modules/.tmp/tsconfig.node.tsbuildinfo",
+    "target": "ES2022",
+    "lib": ["ES2023"],
+    "module": "ESNext",
+    "skipLibCheck": true,
+
+    /* Bundler mode */
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "isolatedModules": true,
+    "moduleDetection": "force",
+    "noEmit": true,
+
+    /* Linting */
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedSideEffectImports": true
+  },
+  "include": ["vite.config.ts"]
+}

frontend/vite.config.ts

@@ -0,0 +1,21 @@
+import { defineConfig } from 'vite'
+import react from '@vitejs/plugin-react'
+
+// https://vite.dev/config/
+export default defineConfig({
+  plugins: [react()],
+  server: {
+    port: 5678,
+    proxy: {
+      '/api': {
+        target: 'http://localhost:5000',
+        changeOrigin: true,
+      }
+    },
+  },
+  resolve: {
+    alias: {
+      '@': '/src',
+    },
+  },
+})

run.py

@@ -0,0 +1,1102 @@
+import json
+import os
+import time
+import uuid
+import argparse  # 导入参数解析库
+import random
+import string
+import logging
+
+import requests
+from flask import Flask, render_template, request, jsonify, send_from_directory
+from flask_cors import CORS
+
+
+# 导入 pikpak.py 中的函数
+from utils.pk_email import connect_imap
+from utils.pikpak import (
+    sign_encrypt,
+    captcha_image_parse,
+    ramdom_version,
+    random_rtc_token,
+    PikPak,
+    save_account_info,
+    test_proxy,
+)
+
+# 导入 email_client
+from utils.email_client import EmailClient
+
+# 重试参数
+max_retries = 3
+retry_delay = 1.0
+
+# 设置日志
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+# 定义一个retry函数，用于重试指定的函数
+def retry_function(func, *args, max_retries=3, delay=1, **kwargs):
+    """
+    对指定函数进行重试
+    
+    Args:
+        func: 要重试的函数
+        *args: 传递给函数的位置参数
+        max_retries: 最大重试次数，默认为3
+        delay: 每次重试之间的延迟（秒），默认为1
+        **kwargs: 传递给函数的关键字参数
+        
+    Returns:
+        函数的返回值，如果所有重试都失败则返回None
+    """
+    retries = 0
+    result = None
+    
+    while retries < max_retries:
+        if retries > 0:
+            logger.info(f"第 {retries} 次重试函数 {func.__name__}...")
+        
+        result = func(*args, **kwargs)
+        
+        # 如果函数返回非None结果，视为成功
+        if result is not None:
+            if retries > 0:
+                logger.info(f"在第 {retries} 次重试后成功")
+            return result
+        
+        # 如果达到最大重试次数，返回最后一次结果
+        if retries >= max_retries - 1:
+            logger.warning(f"函数 {func.__name__} 在 {max_retries} 次尝试后失败")
+            break
+        
+        # 等待指定的延迟时间
+        time.sleep(delay)
+        retries += 1
+    
+    return result
+
+# 解析命令行参数
+parser = argparse.ArgumentParser(description="PikPak 自动邀请注册系统")
+args = parser.parse_args()
+
+app = Flask(__name__, static_url_path='/assets')
+# cors
+CORS(app, resources={r"/*": {"origins": "*"}})
+app.secret_key = os.urandom(24)
+
+# 全局字典用于存储用户处理过程中的数据，以 email 为键
+user_process_data = {}
+
+@app.route("/api/health")
+def health_check():
+    
+    in_huggingface = (
+        os.environ.get("SPACE_ID") is not None or os.environ.get("SYSTEM") == "spaces"
+    )
+
+    return jsonify(
+        {
+            "status": "OK",
+        }
+    )
+
+
+@app.route("/api/initialize", methods=["POST"])
+def initialize():
+    # 获取用户表单输入
+    use_proxy = request.form.get("use_proxy") == "true"
+    proxy_url = request.form.get("proxy_url", "")
+    invite_code = request.form.get("invite_code", "")
+    email = request.form.get("email", "")
+
+    # 初始化参数
+    current_version = ramdom_version()
+    version = current_version["v"]
+    algorithms = current_version["algorithms"]
+    client_id = "YNxT9w7GMdWvEOKa"
+    client_secret = "dbw2OtmVEeuUvIptb1Coyg"
+    package_name = "com.pikcloud.pikpak"
+    device_id = str(uuid.uuid4()).replace("-", "")
+    rtc_token = random_rtc_token()
+
+    # 将这些参数存储到会话中以便后续使用
+    # session["use_proxy"] = use_proxy
+    # session["proxy_url"] = proxy_url
+    # session["invite_code"] = invite_code
+    # session["email"] = email
+    # session["version"] = version
+    # session["algorithms"] = algorithms
+    # session["client_id"] = client_id
+    # session["client_secret"] = client_secret
+    # session["package_name"] = package_name
+    # session["device_id"] = device_id
+    # session["rtc_token"] = rtc_token
+
+    # 如果启用代理，则测试代理
+    proxy_status = None
+    if use_proxy:
+        proxy_status = test_proxy(proxy_url)
+
+    # 创建PikPak实例
+    pikpak = PikPak(
+        invite_code,
+        client_id,
+        device_id,
+        version,
+        algorithms,
+        email,
+        rtc_token,
+        client_secret,
+        package_name,
+        use_proxy=use_proxy,
+        proxy_http=proxy_url,
+        proxy_https=proxy_url,
+    )
+
+    # 初始化验证码
+    init_result = pikpak.init("POST:/v1/auth/verification")
+    if (
+        not init_result
+        or not isinstance(init_result, dict)
+        or "captcha_token" not in init_result
+    ):
+        return jsonify(
+            {"status": "error", "message": "初始化失败，请检查网络连接或代理设置"}
+        )
+
+    # 将用户数据存储在全局字典中
+    user_data = {
+        "use_proxy": use_proxy,
+        "proxy_url": proxy_url,
+        "invite_code": invite_code,
+        "email": email,
+        "version": version,
+        "algorithms": algorithms,
+        "client_id": client_id,
+        "client_secret": client_secret,
+        "package_name": package_name,
+        "device_id": device_id,
+        "rtc_token": rtc_token,
+        "captcha_token": pikpak.captcha_token, # Store captcha_token here
+    }
+    user_process_data[email] = user_data
+
+    # 将验证码令牌保存到会话中 - REMOVED
+    # session["captcha_token"] = pikpak.captcha_token
+
+    return jsonify(
+        {
+            "status": "success",
+            "message": "初始化成功，请进行滑块验证",
+            "email": email, # Return email to client
+            "proxy_status": proxy_status,
+            "version": version,
+            "device_id": device_id,
+            "rtc_token": rtc_token,
+        }
+    )
+
+
+@app.route("/api/verify_captcha", methods=["POST"])
+def verify_captcha():
+    # 尝试从表单或JSON获取email
+    email = request.form.get('email')
+    if not email and request.is_json:
+        data = request.get_json()
+        email = data.get('email')
+
+    if not email:
+        return jsonify({"status": "error", "message": "请求中未提供Email"})
+
+    # 从全局字典获取用户数据
+    user_data = user_process_data.get(email)
+    if not user_data:
+        return jsonify({"status": "error", "message": "会话数据不存在或已过期，请重新初始化"})
+
+    # 从 user_data 中获取存储的数据
+    device_id = user_data.get("device_id")
+    # email = user_data.get("email") # Email is now the key, already have it
+    invite_code = user_data.get("invite_code")
+    client_id = user_data.get("client_id")
+    version = user_data.get("version")
+    algorithms = user_data.get("algorithms")
+    rtc_token = user_data.get("rtc_token")
+    client_secret = user_data.get("client_secret")
+    package_name = user_data.get("package_name")
+    use_proxy = user_data.get("use_proxy")
+    proxy_url = user_data.get("proxy_url")
+    captcha_token = user_data.get("captcha_token", "") # Use get with default
+
+    # Check if essential data is present (device_id is checked as example)
+    if not device_id:
+        return jsonify({"status": "error", "message": "必要的会话数据丢失，请重新初始化"})
+
+
+    # 创建PikPak实例 (使用从 user_data 获取的数据)
+    pikpak = PikPak(
+        invite_code,
+        client_id,
+        device_id,
+        version,
+        algorithms,
+        email,
+        rtc_token,
+        client_secret,
+        package_name,
+        use_proxy=use_proxy,
+        proxy_http=proxy_url,
+        proxy_https=proxy_url,
+    )
+
+    # 从 user_data 设置验证码令牌
+    pikpak.captcha_token = captcha_token
+
+    # 尝试验证码验证
+    max_attempts = 5
+    captcha_result = None
+
+    for attempt in range(max_attempts):
+        try:
+            captcha_result = captcha_image_parse(pikpak, device_id)
+            if (
+                captcha_result
+                and "response_data" in captcha_result
+                and captcha_result["response_data"].get("result") == "accept"
+            ):
+                break
+            time.sleep(2)
+        except Exception as e:
+            time.sleep(2)
+
+    if (
+        not captcha_result
+        or "response_data" not in captcha_result
+        or captcha_result["response_data"].get("result") != "accept"
+    ):
+        return jsonify({"status": "error", "message": "滑块验证失败，请重试"})
+
+    # 滑块验证加密
+    try:
+        executor_info = pikpak.executor()
+        if not executor_info:
+            return jsonify({"status": "error", "message": "获取executor信息失败"})
+
+        sign_encrypt_info = sign_encrypt(
+            executor_info,
+            pikpak.captcha_token,
+            rtc_token,
+            pikpak.use_proxy,
+            pikpak.proxies,
+        )
+        if (
+            not sign_encrypt_info
+            or "request_id" not in sign_encrypt_info
+            or "sign" not in sign_encrypt_info
+        ):
+            return jsonify({"status": "error", "message": "签名加密失败"})
+
+        # 更新验证码令牌
+        report_result = pikpak.report(
+            sign_encrypt_info["request_id"],
+            sign_encrypt_info["sign"],
+            captcha_result["pid"],
+            captcha_result["traceid"],
+        )
+
+        # 请求邮箱验证码
+        verification_result = pikpak.verification()
+        if (
+            not verification_result
+            or not isinstance(verification_result, dict)
+            or "verification_id" not in verification_result
+        ):
+            return jsonify({"status": "error", "message": "请求验证码失败"})
+
+        # 将更新的数据保存到 user_data 中
+        user_data["captcha_token"] = pikpak.captcha_token
+        user_data["verification_id"] = pikpak.verification_id
+
+        return jsonify({"status": "success", "message": "验证码已发送到邮箱，请查收"})
+
+    except Exception as e:
+        import traceback
+
+        error_trace = traceback.format_exc()
+        return jsonify(
+            {
+                "status": "error",
+                "message": f"验证过程出错: {str(e)}",
+                "trace": error_trace,
+            }
+        )
+
+def gen_password():
+    # 生成12位密码
+    return "".join(random.choices(string.ascii_letters + string.digits, k=12))
+
+@app.route("/api/register", methods=["POST"])
+def register():
+    # 从表单获取验证码和email
+    verification_code = request.form.get("verification_code")
+    email = request.form.get('email') # Get email from form
+
+    if not email:
+        return jsonify({"status": "error", "message": "请求中未提供Email"})
+
+    if not verification_code:
+        return jsonify({"status": "error", "message": "验证码不能为空"})
+
+    # 从全局字典获取用户数据
+    user_data = user_process_data.get(email)
+    if not user_data:
+        return jsonify({"status": "error", "message": "会话数据不存在或已过期，请重新初始化"})
+
+
+    # 从 user_data 中获取存储的数据
+    device_id = user_data.get("device_id")
+    # email = user_data.get("email") # Already have email
+    invite_code = user_data.get("invite_code")
+    client_id = user_data.get("client_id")
+    version = user_data.get("version")
+    algorithms = user_data.get("algorithms")
+    rtc_token = user_data.get("rtc_token")
+    client_secret = user_data.get("client_secret")
+    package_name = user_data.get("package_name")
+    use_proxy = user_data.get("use_proxy")
+    proxy_url = user_data.get("proxy_url")
+    verification_id = user_data.get("verification_id")
+    captcha_token = user_data.get("captcha_token", "")
+
+    # Check if essential data is present
+    if not device_id or not verification_id:
+        return jsonify({"status": "error", "message": "必要的会话数据丢失，请重新初始化"})
+
+    # 创建PikPak实例
+    pikpak = PikPak(
+        invite_code,
+        client_id,
+        device_id,
+        version,
+        algorithms,
+        email,
+        rtc_token,
+        client_secret,
+        package_name,
+        use_proxy=use_proxy,
+        proxy_http=proxy_url,
+        proxy_https=proxy_url,
+    )
+
+    # 从 user_data 中设置验证码令牌和验证ID
+    pikpak.captcha_token = captcha_token
+    pikpak.verification_id = verification_id
+
+    # 验证验证码
+    pikpak.verify_post(verification_code)
+
+    # 刷新时间戳并加密签名值
+    pikpak.init("POST:/v1/auth/signup")
+
+    # 注册并登录
+    name = email.split("@")[0]
+    password = gen_password()  # 默认密码
+    signup_result = pikpak.signup(name, password, verification_code)
+
+    # 填写邀请码
+    pikpak.activation_code()
+
+    if (
+        not signup_result
+        or not isinstance(signup_result, dict)
+        or "access_token" not in signup_result
+    ):
+        return jsonify({"status": "error", "message": "注册失败，请检查验证码或重试"})
+
+    # 保存账号信息到JSON文件
+    account_info = {
+        "captcha_token": pikpak.captcha_token,
+        "timestamp": pikpak.timestamp,
+        "name": name,
+        "email": email,
+        "password": password,
+        "device_id": device_id,
+        "version": version,
+        "user_id": signup_result.get("sub", ""),
+        "access_token": signup_result.get("access_token", ""),
+        "refresh_token": signup_result.get("refresh_token", ""),
+        "invite_code": invite_code,
+    }
+
+    # 保存账号信息
+    account_file = save_account_info(name, account_info)
+
+    return jsonify(
+        {
+            "status": "success",
+            "message": "注册成功！账号已保存。",
+            "account_info": account_info,
+        }
+    )
+
+
+@app.route("/api/test_proxy", methods=["POST"])
+def test_proxy_route():
+    proxy_url = request.form.get("proxy_url", "http://127.0.0.1:7890")
+    result = test_proxy(proxy_url)
+
+    return jsonify(
+        {
+            "status": "success" if result else "error",
+            "message": "代理连接测试成功" if result else "代理连接测试失败",
+        }
+    )
+
+
+@app.route("/api/get_verification", methods=["POST"])
+def get_verification():
+    """
+    处理获取验证码的请求
+    """
+    email_user = request.form["email"]
+    email_password = request.form["password"]
+
+    # 先尝试从收件箱获取验证码
+    result = connect_imap(email_user, email_password, "INBOX")
+
+    # 如果收件箱没有找到验证码，则尝试从垃圾邮件中查找
+    if result["code"] == 0:
+        result = connect_imap(email_user, email_password, "Junk")
+
+    return jsonify(result)
+
+
+@app.route("/api/fetch_accounts", methods=["GET"])
+def fetch_accounts():
+    # 获取account文件夹中的所有JSON文件
+    account_files = []
+    for file in os.listdir("account"):
+        if file.endswith(".json"):
+            file_path = os.path.join("account", file)
+            try:
+                with open(file_path, "r", encoding="utf-8") as f:
+                    account_data = json.load(f)
+                    if isinstance(account_data, dict):
+                        # 添加文件名属性，用于后续操作
+                        account_data["filename"] = file
+                        account_files.append(account_data)
+            except Exception as e:
+                logger.error(f"Error reading {file}: {str(e)}")
+
+    if not account_files:
+        return jsonify(
+            {"status": "info", "message": "没有找到保存的账号", "accounts": []}
+        )
+    account_files.sort(key=lambda x: x.get("timestamp", ""), reverse=True)
+
+    return jsonify(
+        {
+            "status": "success",
+            "message": f"找到 {len(account_files)} 个账号",
+            "accounts": account_files,
+        }
+    )
+
+
+@app.route("/api/update_account", methods=["POST"])
+def update_account():
+    data = request.json
+    if not data or "filename" not in data or "account_data" not in data:
+        return jsonify({"status": "error", "message": "请求数据不完整"})
+
+    filename = data.get("filename")
+    account_data = data.get("account_data")
+
+    # 安全检查文件名
+    if not filename or ".." in filename or not filename.endswith(".json"):
+        return jsonify({"status": "error", "message": "无效的文件名"})
+
+    file_path = os.path.join("account", filename)
+
+    try:
+        with open(file_path, "w", encoding="utf-8") as f:
+            json.dump(account_data, f, indent=4, ensure_ascii=False)
+
+        return jsonify({"status": "success", "message": "账号已成功更新"})
+    except Exception as e:
+        return jsonify({"status": "error", "message": f"更新账号时出错: {str(e)}"})
+
+
+@app.route("/api/delete_account", methods=["POST"])
+def delete_account():
+    # 检查是否是单个文件名还是文件名列表
+    if 'filenames' in request.form:
+        # 批量删除模式
+        filenames = request.form.getlist('filenames')
+        if not filenames:
+            return jsonify({"status": "error", "message": "未提供文件名"})
+        
+        results = {
+            "success": [],
+            "failed": []
+        }
+        
+        for filename in filenames:
+            # 安全检查文件名
+            if ".." in filename or not filename.endswith(".json"):
+                results["failed"].append({"filename": filename, "reason": "无效的文件名"})
+                continue
+            
+            file_path = os.path.join("account", filename)
+            
+            try:
+                # 检查文件是否存在
+                if not os.path.exists(file_path):
+                    results["failed"].append({"filename": filename, "reason": "账号文件不存在"})
+                    continue
+                
+                # 删除文件
+                os.remove(file_path)
+                results["success"].append(filename)
+            except Exception as e:
+                results["failed"].append({"filename": filename, "reason": str(e)})
+        
+        # 返回批量删除结果
+        if len(results["success"]) > 0:
+            if len(results["failed"]) > 0:
+                message = f"成功删除 {len(results['success'])} 个账号，{len(results['failed'])} 个账号删除失败"
+                status = "partial"
+            else:
+                message = f"成功删除 {len(results['success'])} 个账号"
+                status = "success"
+        else:
+            message = "所有账号删除失败"
+            status = "error"
+            
+        return jsonify({
+            "status": status,
+            "message": message,
+            "results": results
+        })
+    else:
+        # 保持向后兼容 - 单个文件删除模式
+        filename = request.form.get("filename")
+
+        if not filename:
+            return jsonify({"status": "error", "message": "未提供文件名"})
+
+        # 安全检查文件名
+        if ".." in filename or not filename.endswith(".json"):
+            return jsonify({"status": "error", "message": "无效的文件名"})
+
+        file_path = os.path.join("account", filename)
+
+        try:
+            # 检查文件是否存在
+            if not os.path.exists(file_path):
+                return jsonify({"status": "error", "message": "账号文件不存在"})
+
+            # 删除文件
+            os.remove(file_path)
+
+            return jsonify({"status": "success", "message": "账号已成功删除"})
+        except Exception as e:
+            return jsonify({"status": "error", "message": f"删除账号时出错: {str(e)}"})
+
+@app.route("/api/activate_account_with_names", methods=["POST"])
+def activate_account_with_names():
+    try:
+        data = request.json
+        key = data.get("key")
+        names = data.get("names", [])  # 获取指定的账户名称列表
+        all_accounts = data.get("all", False)  # 获取是否处理所有账户的标志
+
+        if not key:
+            return jsonify({"status": "error", "message": "密钥不能为空"})
+            
+        if not all_accounts and (not names or not isinstance(names, list)):
+            return jsonify({"status": "error", "message": "请提供有效的账户名称列表或设置 all=true"})
+
+        # 存储账号数据及其文件路径
+        accounts_with_paths = []
+        for file in os.listdir("account"):
+            if file.endswith(".json"):
+                # 如果 all=true 或者文件名在指定的names列表中，则处理该文件
+                file_name_without_ext = os.path.splitext(file)[0]
+                if all_accounts or file_name_without_ext in names or file in names:
+                    file_path = os.path.join("account", file)
+                    with open(file_path, "r", encoding="utf-8") as f:
+                        account_data = json.load(f)
+                        # 保存文件路径以便后续更新
+                        accounts_with_paths.append(
+                            {"path": file_path, "data": account_data}
+                        )
+
+        if not accounts_with_paths:
+            return jsonify({"status": "error", "message": "未找到指定的账号数据"})
+
+        # 使用多线程处理每个账号
+        import threading
+        import queue
+
+        # 创建结果队列
+        result_queue = queue.Queue()
+
+        # 定义线程处理函数
+        def process_account(account_with_path, account_key, result_q):
+            try:
+                file_path = account_with_path["path"]
+                single_account = account_with_path["data"]
+
+                response = requests.post(
+                    headers={
+                        "Content-Type": "application/json",
+                        "referer": "https://inject.kiteyuan.info/",
+                        "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Safari/537.36 Edg/134.0.0.0",
+                    },
+                    url="https://inject.kiteyuan.info/infoInject",
+                    json={"info": single_account, "key": account_key},
+                    timeout=30,
+                )
+
+                # 将结果放入队列
+                if response.status_code == 200:
+                    api_result = response.json()
+
+                    # 检查API是否返回了正确的数据格式
+                    if isinstance(api_result, dict) and api_result.get("code") == 200 and "data" in api_result:
+                        # 获取返回的数据对象
+                        account_data = api_result.get("data", {})
+                        
+                        if account_data and isinstance(account_data, dict):
+                            # 更新账号信息
+                            updated_account = single_account.copy()
+
+                            # 更新令牌信息 (从data子对象中提取)
+                            for key in ["access_token", "refresh_token", "captcha_token", "timestamp", "device_id", "user_id"]:
+                                if key in account_data:
+                                    updated_account[key] = account_data[key]
+
+                            # 保存更新后的账号数据
+                            with open(file_path, "w", encoding="utf-8") as f:
+                                json.dump(updated_account, f, indent=4, ensure_ascii=False)
+
+                            # 将更新后的数据放入结果队列
+                            result_q.put(
+                                {
+                                    "status": "success",
+                                    "account": single_account.get("email", "未知邮箱"),
+                                    "result": account_data,
+                                    "updated": True,
+                                }
+                            )
+                        else:
+                            # 返回的data不是字典类型
+                            result_q.put(
+                                {
+                                    "status": "error",
+                                    "account": single_account.get("email", "未知邮箱"),
+                                    "message": "返回的数据格式不符合预期",
+                                    "result": api_result,
+                                }
+                            )
+                    else:
+                        # API返回错误码或格式不符合预期
+                        error_msg = api_result.get("msg", "未知错误")
+                        result_q.put(
+                            {
+                                "status": "error",
+                                "account": single_account.get("email", "未知邮箱"),
+                                "message": f"激活失败: {error_msg}",
+                                "result": api_result,
+                            }
+                        )
+                else:
+                    result_q.put(
+                        {
+                            "status": "error",
+                            "account": single_account.get("email", "未知邮箱"),
+                            "message": f"激活失败: HTTP {response.status_code}-{response.json().get('detail', '未知错误')}",
+                            "result": response.text,
+                        }
+                    )
+            except Exception as e:
+                result_q.put(
+                    {
+                        "status": "error",
+                        "account": single_account.get("email", "未知邮箱"),
+                        "message": f"处理失败: {str(e)}",
+                    }
+                )
+
+        # 创建并启动线程
+        threads = []
+        for account_with_path in accounts_with_paths:
+            thread = threading.Thread(
+                target=process_account, args=(account_with_path, key, result_queue)
+            )
+            threads.append(thread)
+            thread.start()
+
+        # 等待所有线程完成
+        for thread in threads:
+            thread.join()
+
+        # 收集所有结果
+        results = []
+        while not result_queue.empty():
+            results.append(result_queue.get())
+
+        # 统计成功和失败的数量
+        success_count = sum(1 for r in results if r["status"] == "success")
+        updated_count = sum(
+            1
+            for r in results
+            if r.get("status") == "success" and r.get("updated", False)
+        )
+
+        return jsonify(
+            {
+                "status": "success",
+                "message": f"账号激活完成: {success_count}/{len(accounts_with_paths)}个成功, {updated_count}个已更新数据",
+                "results": results,
+            }
+        )
+
+    except Exception as e:
+        return jsonify({"status": "error", "message": f"操作失败: {str(e)}"})
+
+
+@app.route("/api/check_email_inventory", methods=["GET"])
+def check_email_inventory():
+    try:
+        # 发送请求到库存API
+        response = requests.get(
+            url="https://zizhu.shanyouxiang.com/kucun",
+            headers={
+                "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Safari/537.36"
+            },
+            timeout=10,
+        )
+
+        if response.status_code == 200:
+            return jsonify({"status": "success", "inventory": response.json()})
+        else:
+            return jsonify(
+                {
+                    "status": "error",
+                    "message": f"获取库存失败: HTTP {response.status_code}",
+                }
+            )
+
+    except Exception as e:
+        return jsonify({"status": "error", "message": f"获取库存时出错: {str(e)}"})
+
+
+@app.route("/api/check_balance", methods=["GET"])
+def check_balance():
+    try:
+        # 从请求参数中获取卡号
+        card = request.args.get("card")
+
+        if not card:
+            return jsonify({"status": "error", "message": "未提供卡号参数"})
+
+        # 发送请求到余额查询API
+        response = requests.get(
+            url="https://zizhu.shanyouxiang.com/yue",
+            params={"card": card},
+            headers={
+                "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Safari/537.36"
+            },
+            timeout=10,
+        )
+
+        if response.status_code == 200:
+            return jsonify({"status": "success", "balance": response.json()})
+        else:
+            return jsonify(
+                {
+                    "status": "error",
+                    "message": f"查询余额失败: HTTP {response.status_code}",
+                }
+            )
+
+    except Exception as e:
+        return jsonify({"status": "error", "message": f"查询余额时出错: {str(e)}"})
+
+
+@app.route("/api/extract_emails", methods=["GET"])
+def extract_emails():
+    try:
+        # 从请求参数中获取必需的参数
+        card = request.args.get("card")
+        shuliang = request.args.get("shuliang")
+        leixing = request.args.get("leixing")
+        # 获取前端传递的重试次数计数器，如果没有则初始化为0
+        frontend_retry_count = int(request.args.get("retry_count", "0"))
+
+        # 验证必需的参数
+        if not card:
+            return jsonify({"status": "error", "message": "未提供卡号参数"})
+
+        if not shuliang:
+            return jsonify({"status": "error", "message": "未提供提取数量参数"})
+
+        if not leixing or leixing not in ["outlook", "hotmail"]:
+            return jsonify(
+                {
+                    "status": "error",
+                    "message": "提取类型参数无效，必须为 outlook 或 hotmail",
+                }
+            )
+
+        # 尝试将数量转换为整数
+        try:
+            shuliang_int = int(shuliang)
+            if shuliang_int < 1 or shuliang_int > 2000:
+                return jsonify(
+                    {"status": "error", "message": "提取数量必须在1到2000之间"}
+                )
+        except ValueError:
+            return jsonify({"status": "error", "message": "提取数量必须为整数"})
+
+        # 后端重试计数器
+        retry_count = 0
+        max_retries = 20  # 单次后端请求的最大重试次数
+        retry_delay = 0  # 每次重试间隔秒数
+
+        # 记录总的前端+后端重试次数，用于展示给用户
+        total_retry_count = frontend_retry_count
+
+        while retry_count < max_retries:
+            # 发送请求到邮箱提取API
+            response = requests.get(
+                url="https://zizhu.shanyouxiang.com/huoqu",
+                params={"card": card, "shuliang": shuliang, "leixing": leixing},
+                headers={
+                    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Safari/537.36"
+                },
+                timeout=10,  # 降低单次请求的超时时间，以便更快地进行重试
+            )
+
+            if response.status_code == 200:
+                # 检查响应是否为JSON格式，如果是，通常表示没有库存
+                try:
+                    json_response = response.json()
+                    if isinstance(json_response, dict) and "msg" in json_response:
+                        # 没有库存，需要重试
+                        retry_count += 1
+                        total_retry_count += 1
+
+                        # 如果达到后端最大重试次数，返回特殊状态让前端继续重试
+                        if retry_count >= max_retries:
+                            return jsonify(
+                                {
+                                    "status": "retry",
+                                    "message": f"暂无库存: {json_response['msg']}，已重试{total_retry_count}次，继续尝试中...",
+                                    "retry_count": total_retry_count,
+                                }
+                            )
+
+                        # 等待一段时间后重试
+                        time.sleep(retry_delay)
+                        continue
+                except ValueError:
+                    # 不是JSON格式，可能是成功的文本列表响应
+                    pass
+
+                # 处理文本响应
+                response_text = response.text.strip()
+
+                # 解析响应文本为邮箱列表
+                emails = []
+                if response_text:
+                    for line in response_text.split("\n"):
+                        if line.strip():
+                            emails.append(line.strip())
+
+                # 如果没有实际提取到邮箱（可能是空文本响应），继续重试
+                if not emails:
+                    retry_count += 1
+                    total_retry_count += 1
+
+                    if retry_count >= max_retries:
+                        return jsonify(
+                            {
+                                "status": "retry",
+                                "message": f"未能获取到邮箱，已重试{total_retry_count}次，继续尝试中...",
+                                "retry_count": total_retry_count,
+                            }
+                        )
+
+                    time.sleep(retry_delay)
+                    continue
+
+                # 成功获取到邮箱，返回结果
+                return jsonify(
+                    {
+                        "status": "success",
+                        "emails": emails,
+                        "count": len(emails),
+                        "retries": total_retry_count,
+                        "message": f"成功获取{len(emails)}个邮箱，总共重试{total_retry_count}次",
+                    }
+                )
+            else:
+                # 请求失败，返回错误
+                return jsonify(
+                    {
+                        "status": "error",
+                        "message": f"提取邮箱失败: HTTP {response.status_code}",
+                        "response": response.text,
+                    }
+                )
+
+        # 如果执行到这里，说明超过了最大重试次数
+        return jsonify(
+            {
+                "status": "retry",
+                "message": f"暂无邮箱库存，已重试{total_retry_count}次，继续尝试中...",
+                "retry_count": total_retry_count,
+            }
+        )
+
+    except Exception as e:
+        return jsonify({"status": "error", "message": f"提取邮箱时出错: {str(e)}"})
+
+
+# --- 新增API：通过EmailClient获取验证码 ---
+@app.route('/api/get_email_verification_code', methods=['POST'])
+def get_email_verification_code_api():
+    """
+    通过 EmailClient (通常是基于HTTP API的邮件服务) 获取验证码。
+    接收 JSON 或 Form data。
+    必需参数: email, token, client_id
+    可选参数: password, api_base_url, mailbox, code_regex, max_retries, retry_delay
+    
+    如���EmailClient方法失败，将尝试使用connect_imap作为备用方法。
+    如果用户之前已配置代理，也会使用相同的代理设置。
+    """
+    global max_retries, retry_delay
+    if request.is_json:
+        data = request.get_json()
+    else:
+        data = request.form
+
+    email = data.get('email')
+    token = data.get('token') # 对应 EmailClient 的 refresh_token
+    client_id = data.get('client_id')
+    
+    if not all([email, token, client_id]):
+        return jsonify({"status": "error", "message": "缺少必需参数: email, token, client_id"}), 400
+
+    # 获取可选参数
+    password = data.get('password')
+    api_base_url = data.get('api_base_url') # 如果提供，将覆盖 EmailClient 的默认设置
+    mailbox = data.get('mailbox', "INBOX")
+    code_regex = data.get('code_regex', r'\b\d{6}\b') # 默认匹配6位数字
+    
+    # 检查是否在用户处理数据中有该邮箱，并提取代理设置
+    use_proxy = False
+    proxy_url = None
+    if email in user_process_data:
+        user_data = user_process_data.get(email, {})
+        use_proxy = user_data.get("use_proxy", False)
+        proxy_url = user_data.get("proxy_url", "") if use_proxy else None
+        logger.info(f"为邮箱 {email} 使用代理设置: {use_proxy}, {proxy_url}")
+
+    try:
+        # 实例化 EmailClient，传入代理设置
+        email_client = EmailClient(api_base_url=api_base_url)
+        
+        # 设置代理（如果 EmailClient 类支持代理配置）
+        if use_proxy and proxy_url and hasattr(email_client, 'set_proxy'):
+            email_client.set_proxy(proxy_url)
+        elif use_proxy and proxy_url:
+            logger.warning("EmailClient 类不支持设置代理")
+
+        # 使用重试机制调用获取验证码的方法
+        verification_code = retry_function(
+            email_client.get_verification_code,
+            token=token,
+            client_id=client_id,
+            email=email,
+            password=password,
+            mailbox=mailbox,
+            code_regex=code_regex,
+            max_retries=max_retries,
+            delay=retry_delay
+        )
+
+        if verification_code:
+            return jsonify({"status": "success", "verification_code": verification_code})
+        else:
+            # EmailClient 失败，尝试使用connect_imap作为备用方法
+            logger.info(f"EmailClient在{max_retries}次尝试后未能找到验证码，尝试使用connect_imap作为备用方法")
+            
+            # 检查是否有password参数
+            if not password:
+                return jsonify({"status": "error", "msg": "EmailClient失败，且未提供password参数，无法使用备用方法"}), 200
+                
+            # 先尝试从收件箱获取验证码，传入代理设置
+            result = connect_imap(email, password, "INBOX", use_proxy=use_proxy, proxy_url=proxy_url)
+
+            # 如果收件箱没有找到验证码，则尝试从垃圾邮件中查找
+            if result["code"] == 0:
+                result = connect_imap(email, password, "Junk", use_proxy=use_proxy, proxy_url=proxy_url)
+            
+            logger.info(f"catch 当前Oauth登录失败，IMAP结果如下：{result['msg']}")
+            result["msg"] = f"当前Oauth登录失败，IMAP结果如下：{result['msg']}"
+            if result["code"] == 0:
+                return jsonify({"status": "error", "msg": "收件箱和垃圾邮件中均未找到验证码"}), 200
+            elif result["code"] == 200:
+                return jsonify({"status": "success", "verification_code": result["verification_code"], "msg": result["msg"]})
+            else:
+                return jsonify({"status": "error", "msg": result["msg"]}), 200
+
+    except Exception as e:
+        # 捕获实例化或调用过程中的其他潜在错误
+        logger.error(f"处理 /api/get_email_verification_code 时出错: {str(e)}")
+        import traceback
+        logger.error(traceback.format_exc())
+        
+        # 如果有password参数，尝试使用connect_imap作为备用方法
+        if password:
+            logger.info(f"EmailClient出现异常，尝试使用connect_imap作为备用方法")
+            try:
+                # 先尝试从收件箱获取验证码，传入代理设置
+                result = connect_imap(email, password, "INBOX", use_proxy=use_proxy, proxy_url=proxy_url)
+                
+                # 如果收件箱没有找到验证码，则尝试从垃圾邮件中查找
+                if result["code"] == 0:
+                    result = connect_imap(email, password, "Junk", use_proxy=use_proxy, proxy_url=proxy_url)
+                    
+                logger.info(f"catch 当前Oauth登录失败，IMAP结果如下：{result['msg']}")
+                result["msg"] = f"当前Oauth登录失败，IMAP结果如下：{result['msg']}"
+                if result["code"] == 0:
+                    return jsonify({"status": "error", "msg": "收件箱和垃圾邮件中均未找到验证���"}), 200
+                elif result["code"] == 200:
+                    return jsonify({"status": "success", "verification_code": result["verification_code"], "msg": result["msg"]})
+                else:
+                    return jsonify({"status": "error", "msg": result["msg"]}), 200
+            except Exception as backup_error:
+                logger.error(f"备用方法connect_imap也失败: {str(backup_error)}")
+                return jsonify({"status": "error", "message": f"主要和备用验证码获取方法均出现错误"}), 500
+        
+        return jsonify({"status": "error", "message": f"处理请求时发生内部错误"}), 500
+
+
+
+# 处理所有前端路由
+@app.route('/', defaults={'path': ''})
+@app.route('/<path:path>')
+def serve(path):
+    #favicon vite.svg
+    if path == 'favicon.ico' or path == 'vite.svg':
+        return send_from_directory("static", path)
+    # 对于所有其他请求 - 返回index.html (SPA入口点)
+    return render_template('index.html')
+
+if __name__ == "__main__":
+    app.run(debug=False, host="0.0.0.0", port=5000)

utils/email_client.py

@@ -0,0 +1,371 @@
+import requests
+import re
+import json
+import logging
+import os
+from typing import Dict, List, Optional, Any
+from dotenv import load_dotenv
+
+# 加载环境变量，强制覆盖已存在的环境变量
+load_dotenv(override=True)
+
+# 配置日志
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger('email_client')
+
+# 添加一条日志，显示加载的环境变量值（如果存在）
+mail_api_url = os.getenv('MAIL_POINT_API_URL', '')
+logger.info(f"加载的MAIL_POINT_API_URL环境变量值: {mail_api_url}")
+
+class EmailClient:
+    """邮件客户端类，封装邮件API操作"""
+    
+    def __init__(self, api_base_url: Optional[str] = None, use_proxy: bool = False, proxy_url: Optional[str] = None):
+        """
+        初始化邮件客户端
+        
+        Args:
+            api_base_url: API基础URL，如不提供则从环境变量MAIL_POINT_API_URL读取
+            use_proxy: 是否使用代理
+            proxy_url: 代理服务器URL (例如 "http://127.0.0.1:7890")
+        """
+        if api_base_url is None:
+            # 添加调试信息，查看API_URL是否正确加载
+            api_base_url = os.getenv('MAIL_POINT_API_URL', '')
+            logger.info(f"使用的MAIL_POINT_API_URL环境变量值: {api_base_url}")
+
+        self.api_base_url = api_base_url.rstrip('/')
+        self.session = requests.Session()
+        
+        # 初始化代理设置
+        self.use_proxy = use_proxy
+        self.proxy_url = proxy_url
+        
+        # 如果启用代理，设置代理
+        if self.use_proxy and self.proxy_url:
+            self.set_proxy(self.proxy_url)
+    
+    def set_proxy(self, proxy_url: str) -> None:
+        """
+        设置代理服务器
+        
+        Args:
+            proxy_url: 代理服务器URL (例如 "http://127.0.0.1:7890")
+        """
+        if not proxy_url:
+            logger.warning("代理URL为空，不设置代理")
+            return
+            
+        # 为会话设置代理
+        self.proxy_url = proxy_url
+        self.use_proxy = True
+        
+        # 设置代理，支持HTTP和HTTPS
+        proxies = {
+            "http": proxy_url,
+            "https": proxy_url
+        }
+        self.session.proxies.update(proxies)
+        logger.info(f"已设置代理: {proxy_url}")
+    
+    def _make_request(self, endpoint: str, method: str = "POST", **params) -> Dict[str, Any]:
+        """
+        发送API请求
+        
+        Args:
+            endpoint: API端点
+            method: 请求方法，GET或POST
+            **params: 请求参数
+            
+        Returns:
+            API响应的JSON数据
+        """
+        url = f"{self.api_base_url}{endpoint}"
+        
+        try:
+            if method.upper() == "GET":
+                response = self.session.get(url, params=params)
+            else:  # POST
+                response = self.session.post(url, json=params)
+            
+            response.raise_for_status()
+            return response.json()
+        except requests.RequestException as e:
+            logger.error(f"API请求失败: {str(e)}")
+            return {"error": str(e), "status": "failed"}
+    
+    def get_latest_email(self, refresh_token: str, client_id: str, email: str, 
+                        mailbox: str = "INBOX", response_type: str = "json", 
+                        password: Optional[str] = None) -> Dict[str, Any]:
+        """
+        获取最新一封邮件
+        
+        Args:
+            refresh_token: 刷新令牌
+            client_id: 客户端ID
+            email: 邮箱地址
+            mailbox: 邮箱文件夹，INBOX或Junk
+            response_type: 返回格式，json或html
+            password: 可选密码
+            
+        Returns:
+            包含最新邮件信息的字典
+        """
+        params = {
+            'refresh_token': refresh_token,
+            'client_id': client_id,
+            'email': email,
+            'mailbox': mailbox,
+            'response_type': response_type
+        }
+
+        if password:
+            params['password'] = password
+        
+        return self._make_request('/api/mail-new', **params)
+    
+    def get_all_emails(self, refresh_token: str, client_id: str, email: str,
+                     mailbox: str = "INBOX", password: Optional[str] = None) -> Dict[str, Any]:
+        """
+        获取全部邮件
+        
+        Args:
+            refresh_token: 刷新令牌
+            client_id: 客户端ID
+            email: 邮箱地址
+            mailbox: 邮箱文件夹，INBOX或Junk
+            password: 可选密码
+            
+        Returns:
+            包含所有邮件信息的字典
+        """
+        params = {
+            'refresh_token': refresh_token,
+            'client_id': client_id,
+            'email': email,
+            'mailbox': mailbox
+        }
+        
+        if password:
+            params['password'] = password
+        
+        return self._make_request('/api/mail-all', **params)
+    
+    def process_inbox(self, refresh_token: str, client_id: str, email: str,
+                    password: Optional[str] = None) -> Dict[str, Any]:
+        """
+        清空收件箱
+        
+        Args:
+            refresh_token: 刷新令牌
+            client_id: 客户端ID
+            email: 邮箱地址
+            password: 可选密码
+            
+        Returns:
+            操作结果字典
+        """
+        params = {
+            'refresh_token': refresh_token,
+            'client_id': client_id,
+            'email': email
+        }
+        
+        if password:
+            params['password'] = password
+        
+        return self._make_request('/api/process-inbox', **params)
+    
+    def process_junk(self, refresh_token: str, client_id: str, email: str,
+                   password: Optional[str] = None) -> Dict[str, Any]:
+        """
+        清空垃圾箱
+        
+        Args:
+            refresh_token: 刷新令牌
+            client_id: 客户端ID
+            email: 邮箱地址
+            password: 可选密码
+            
+        Returns:
+            操作结果字典
+        """
+        params = {
+            'refresh_token': refresh_token,
+            'client_id': client_id,
+            'email': email
+        }
+        
+        if password:
+            params['password'] = password
+        
+        return self._make_request('/api/process-junk', **params)
+    
+    def send_email(self, refresh_token: str, client_id: str, email: str, to: str,
+                 subject: str, text: Optional[str] = None, html: Optional[str] = None,
+                 send_password: Optional[str] = None) -> Dict[str, Any]:
+        """
+        发送邮件
+        
+        Args:
+            refresh_token: 刷新令牌
+            client_id: 客户端ID
+            email: 发件人邮箱地址
+            to: 收件人邮箱地址
+            subject: 邮件主题
+            text: 邮件的纯文本内容（与html二选一）
+            html: 邮件的HTML内容（与text二选一）
+            send_password: 可选发送密码
+            
+        Returns:
+            操作结果字典
+        """
+        if not text and not html:
+            raise ValueError("必须提供text或html参数")
+        
+        params = {
+            'refresh_token': refresh_token,
+            'client_id': client_id,
+            'email': email,
+            'to': to,
+            'subject': subject
+        }
+        
+        if text:
+            params['text'] = text
+        if html:
+            params['html'] = html
+        if send_password:
+            params['send_password'] = send_password
+        
+        return self._make_request('/api/send-mail', **params)
+
+    def get_verification_code(self, token: str, client_id: str, email: str, 
+                              password: Optional[str] = None, mailbox: str = "INBOX", 
+                              code_regex: str = r'\\b\\d{6}\\b') -> Optional[str]:
+        """
+        获取最新邮件中的验证码
+
+        Args:
+            token: 刷新令牌 (对应API的refresh_token)
+            client_id: 客户端ID
+            email: 邮箱地址
+            password: 可选密码
+            mailbox: 邮箱文件夹，INBOX或Junk (默认为INBOX)
+            code_regex: 用于匹配验证码的正则表达式 (默认为匹配6位数字)
+
+        Returns:
+            找到的验证码字符串，如果未找到或出错则返回None
+        """
+        logger.info(f"尝试从邮箱 {email} 的 {mailbox} 获取验证码")
+        
+        # 调用 get_latest_email 获取邮件内容, 先从INBOX获取
+        latest_email_data = self.get_latest_email(
+            refresh_token=token,
+            client_id=client_id,
+            email=email,
+            mailbox="INBOX",
+            response_type='json', # 需要JSON格式来解析内容
+            password=password
+        )
+
+        if not latest_email_data or (latest_email_data.get('send') is not None and isinstance(latest_email_data.get('send'), str) and 'PikPak' not in latest_email_data.get('send')):
+            logger.error(f"在 INBOX 获取邮箱 {email} 最新邮件失败，尝试从Junk获取")
+            latest_email_data = self.get_latest_email(
+                refresh_token=token,
+                client_id=client_id,
+                email=email,
+                mailbox="Junk",
+            )
+
+            logger.info(f"Junk latest_email_data: {latest_email_data.get('send')}")
+            if not latest_email_data or (latest_email_data.get('send') is not None and isinstance(latest_email_data.get('send'), str) and 'PikPak' not in latest_email_data.get('send')):
+                logger.error(f"在 Junk 获取邮箱 {email} 最新邮件失败")
+                return None
+
+        # 假设邮件正文在 'text' 或 'body' 字段
+        email_content = latest_email_data.get('text') or latest_email_data.get('body')
+
+        if not email_content:
+            logger.warning(f"邮箱 {email} 的最新邮件数据中未找到 'text' 或 'body' 字段")
+            return None
+
+        # 使用正则表达式搜索验证码
+        try:
+            match = re.search(code_regex, email_content)
+            if match:
+                verification_code = match.group(0) # 通常验证码是整个匹配项
+                logger.info(f"在邮箱 {email} 的邮件中成功找到验证码: {verification_code}")
+                return verification_code
+            else:
+                logger.info(f"在邮箱 {email} 的最新邮件中未找到符合模式 {code_regex} 的验证码")
+                return None
+        except re.error as e:
+            logger.error(f"提供的正则表达式 '{code_regex}' 无效: {e}")
+            return None
+        except Exception as e:
+            logger.error(f"解析邮件内容或匹配验证码时发生未知错误: {e}")
+            return None
+
+def parse_email_credentials(credentials_str: str) -> List[Dict[str, str]]:
+    """
+    解析邮箱凭证字符串，提取邮箱、密码、Client ID和Token
+    
+    Args:
+        credentials_str: 包含凭证信息的字符串
+        
+    Returns:
+        凭证列表，每个凭证为一个字典
+    """
+    credentials_list = []
+    pattern = r'(.+?)----(.+?)----(.+?)----(.+?)(?:\n|$)'
+    matches = re.finditer(pattern, credentials_str.strip())
+    
+    for match in matches:
+        if len(match.groups()) == 4:
+            email, password, client_id, token = match.groups()
+            credentials_list.append({
+                'email': email.strip(),
+                'password': password.strip(),
+                'client_id': client_id.strip(),
+                'token': token.strip()
+            })
+    
+    return credentials_list
+
+def load_credentials_from_file(file_path: str) -> str:
+    """
+    从文件加载凭证信息
+    
+    Args:
+        file_path: 文件路径
+        
+    Returns:
+        包含凭证的字符串
+    """
+    try:
+        with open(file_path, 'r', encoding='utf-8') as file:
+            content = file.read()
+            # 提取多行字符串v的内容
+            match = re.search(r'v\s*=\s*"""(.*?)"""', content, re.DOTALL)
+            if match:
+                return match.group(1)
+        return ""
+    except Exception as e:
+        logger.error(f"加载凭证文件失败: {str(e)}")
+        return ""
+
+def format_json_output(json_data: Dict) -> str:
+    """
+    格式化JSON输出
+    
+    Args:
+        json_data: JSON数据
+        
+    Returns:
+        格式化后的字符串
+    """
+    return json.dumps(json_data, ensure_ascii=False, indent=2) 

utils/pikpak.py

@@ -0,0 +1,876 @@
+# coding:utf-8
+import hashlib
+import json
+import random
+import time
+import uuid
+import requests
+from PIL import Image
+from io import BytesIO
+import base64
+import os
+
+
+def ca_f_encrypt(frames, index, pid, use_proxy=False, proxies=None):
+    url = "https://api.kiteyuan.info/cafEncrypt"
+
+    payload = json.dumps({
+        "frames": frames,
+        "index": index,
+        "pid": pid
+    })
+    headers = {
+            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/123.0.0.0 Safari/537.36",
+            "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7",
+            "Accept-Language": "zh-CN,zh;q=0.9,en-US;q=0.8,en;q=0.7",
+            "Connection": "keep-alive",
+            'Content-Type': 'application/json',
+            "Upgrade-Insecure-Requests": "1",
+            "Sec-Fetch-Dest": "document",
+            "Sec-Fetch-Mode": "navigate",
+            "Sec-Fetch-Site": "none",
+            "Sec-Fetch-User": "?1"
+        }
+
+    try:
+        # response = requests.request("POST", url, headers=headers, data=payload, proxies=proxies if use_proxy else None)
+        response = requests.request("POST", url, headers=headers, data=payload, proxies=None)
+        response.raise_for_status()
+        if not response.text:
+            print(f"API响应为空: {url}")
+            return {"f": "", "ca": ["", "", "", ""]}
+        
+        # 解析响应以确保与 text.py 行为一致
+        result = json.loads(response.text)
+        if "f" not in result or "ca" not in result:
+            print(f"API响应缺少关键字段: {result}")
+            return {"f": "", "ca": ["", "", "", ""]}
+        return result
+    except requests.exceptions.RequestException as e:
+        print(f"API请求失败: {e}")
+        if use_proxy:
+            print(f"当前使用的代理: {proxies}")
+        return {"f": "", "ca": ["", "", "", ""]}
+    except json.JSONDecodeError as e:
+        print(f"JSON解析错误: {e}, 响应内容: {response.text}")
+        return {"f": "", "ca": ["", "", "", ""]}
+
+
+def image_parse(image, frames, use_proxy=False, proxies=None):
+    url = "https://api.kiteyuan.info/imageParse"
+
+    payload = json.dumps({
+        "image": image,
+        "frames": frames
+    })
+    headers = {
+            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/123.0.0.0 Safari/537.36",
+            "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7",
+            "Accept-Language": "zh-CN,zh;q=0.9,en-US;q=0.8,en;q=0.7",
+            "Connection": "keep-alive",
+            'Content-Type': 'application/json',
+            "Upgrade-Insecure-Requests": "1",
+            "Sec-Fetch-Dest": "document",
+            "Sec-Fetch-Mode": "navigate",
+            "Sec-Fetch-Site": "none",
+            "Sec-Fetch-User": "?1"
+        }
+
+    try:
+        # response = requests.request("POST", url, headers=headers, data=payload, proxies=proxies if use_proxy else None)
+        response = requests.request("POST", url, headers=headers, data=payload, proxies=None)
+        response.raise_for_status()  # 检查HTTP状态码
+        if not response.text:
+            print(f"API响应为空: {url}")
+            return {"best_index": 0}  # 返回一个默认值
+        
+        # 解析响应以确保与 text.py 行为一致
+        result = json.loads(response.text)
+        if "best_index" not in result:
+            print(f"API响应缺少best_index字段: {result}")
+            return {"best_index": 0}
+        return result
+    except requests.exceptions.RequestException as e:
+        print(f"API请求失败: {e}")
+        if use_proxy:
+            print(f"当前使用的代理: {proxies}")
+        return {"best_index": 0}  # 返回一个默认值
+    except json.JSONDecodeError as e:
+        print(f"JSON解析错误: {e}, 响应内容: {response.text}")
+        return {"best_index": 0}  # 返回一个默认值
+
+
+def sign_encrypt(code, captcha_token, rtc_token, use_proxy=False, proxies=None):
+    url = "https://api.kiteyuan.info/signEncrypt"
+
+    # 检查 code 是否为空或 None
+    if not code:
+        print("code 参数为空，无法进行加密")
+        return {"request_id": "", "sign": ""}
+
+    # 如果 code 是字符串而不是对象，则直接使用
+    if isinstance(code, str):
+        payload_data = code
+    else:
+        try:
+            payload_data = json.dumps(code)
+        except (TypeError, ValueError) as e:
+            print(f"code 参数序列化失败: {e}")
+            return {"request_id": "", "sign": ""}
+
+    try:
+        payload = json.dumps({
+            "code": payload_data,
+            "captcha_token": captcha_token,
+            "rtc_token": rtc_token
+        })
+        headers = {
+            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/123.0.0.0 Safari/537.36",
+            "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7",
+            "Accept-Language": "zh-CN,zh;q=0.9,en-US;q=0.8,en;q=0.7",
+            "Connection": "keep-alive",
+            'Content-Type': 'application/json',
+            "Upgrade-Insecure-Requests": "1",
+            "Sec-Fetch-Dest": "document",
+            "Sec-Fetch-Mode": "navigate",
+            "Sec-Fetch-Site": "none",
+            "Sec-Fetch-User": "?1"
+        }
+
+        # response = requests.request("POST", url, headers=headers, data=payload, proxies=proxies if use_proxy else None, timeout=30)
+        response = requests.request("POST", url, headers=headers, data=payload, proxies=None, timeout=30)
+        response.raise_for_status()
+        if not response.text:
+            print(f"API响应为空: {url}")
+            return {"request_id": "", "sign": ""}
+        
+        # 解析响应以确保与 text.py 行为一致
+        result = json.loads(response.text)
+        if "request_id" not in result or "sign" not in result:
+            print(f"API响应缺少关键字段: {result}")
+            return {"request_id": "", "sign": ""}
+        return result
+    except requests.exceptions.RequestException as e:
+        print(f"API请求失败: {e}")
+        if use_proxy:
+            print(f"当前使用的代理: {proxies}")
+        return {"request_id": "", "sign": ""}
+    except json.JSONDecodeError as e:
+        print(f"JSON解析错误: {e}, 响应内容: {response.text}")
+        return {"request_id": "", "sign": ""}
+    except Exception as e:
+        print(f"未知错误: {e}")
+        return {"request_id": "", "sign": ""}
+
+
+def d_encrypt(pid, device_id, f, use_proxy=False, proxies=None):
+    url = "https://api.kiteyuan.info/dEncrypt"
+
+    payload = json.dumps({
+        "pid": pid,
+        "device_id": device_id,
+        "f": f
+    })
+    headers = {
+            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/123.0.0.0 Safari/537.36",
+            "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7",
+            "Accept-Language": "zh-CN,zh;q=0.9,en-US;q=0.8,en;q=0.7",
+            "Connection": "keep-alive",
+            'Content-Type': 'application/json',
+            "Upgrade-Insecure-Requests": "1",
+            "Sec-Fetch-Dest": "document",
+            "Sec-Fetch-Mode": "navigate",
+            "Sec-Fetch-Site": "none",
+            "Sec-Fetch-User": "?1"
+        }
+
+    try:
+        # response = requests.request("POST", url, headers=headers, data=payload, proxies=proxies if use_proxy else None)
+        response = requests.request("POST", url, headers=headers, data=payload, proxies=None)
+        response.raise_for_status()
+        if not response.text:
+            print(f"API响应为空: {url}")
+            return ""
+        return response.text
+    except requests.exceptions.RequestException as e:
+        print(f"API请求失败: {e}")
+        if use_proxy:
+            print(f"当前使用的代理: {proxies}")
+        return ""
+
+
+# md5加密算法
+def captcha_sign_encrypt(encrypt_string, salts):
+    for salt in salts:
+        encrypt_string = hashlib.md5((encrypt_string + salt["salt"]).encode("utf-8")).hexdigest()
+    return encrypt_string
+
+
+def captcha_image_parse(pikpak, device_id):
+    try:
+        # 获取frames信息
+        frames_info = pikpak.gen()
+        if not frames_info or not isinstance(frames_info, dict) or "pid" not in frames_info or "frames" not in frames_info:
+            print("获取frames_info失败，返回内容:", frames_info)
+            return {"response_data": {"result": "reject"}, "pid": "", "traceid": ""}
+        
+        if "traceid" not in frames_info:
+            frames_info["traceid"] = ""
+            
+        # 下载验证码图片
+        captcha_image = image_download(device_id, frames_info["pid"], frames_info["traceid"], pikpak.use_proxy, pikpak.proxies)
+        if not captcha_image:
+            print("图片下载失败")
+            return {"response_data": {"result": "reject"}, "pid": frames_info["pid"], "traceid": frames_info["traceid"]}
+        
+        # 读取图片数据并转换为 PIL.Image
+        img = Image.open(BytesIO(captcha_image))
+        
+        # 将图片转换为 Base64 编码
+        buffered = BytesIO()
+        img.save(buffered, format="PNG")  # 可根据图片格式调整 format
+        base64_image = base64.b64encode(buffered.getvalue()).decode()
+        
+        # 获取最佳滑块位置
+        best_index = image_parse(base64_image, frames_info["frames"], pikpak.use_proxy, pikpak.proxies)
+        if "best_index" not in best_index:
+            print("图片分析失败, 返回内容:", best_index)
+            return {"response_data": {"result": "reject"}, "pid": frames_info["pid"], "traceid": frames_info["traceid"]}
+        
+        # 滑块加密
+        json_data = ca_f_encrypt(frames_info["frames"], best_index["best_index"], frames_info["pid"], pikpak.use_proxy, pikpak.proxies)
+        if "f" not in json_data or "ca" not in json_data:
+            print("加密计算失败, 返回内容:", json_data)
+            return {"response_data": {"result": "reject"}, "pid": frames_info["pid"], "traceid": frames_info["traceid"]}
+        
+        f = json_data['f']
+        npac = json_data['ca']
+        
+        # d加密
+        d = d_encrypt(frames_info["pid"], device_id, f, pikpak.use_proxy, pikpak.proxies)
+        if not d:
+            print("d_encrypt失败")
+            return {"response_data": {"result": "reject"}, "pid": frames_info["pid"], "traceid": frames_info["traceid"]}
+        
+        # 验证
+        verify2 = pikpak.image_verify(frames_info["pid"], frames_info["traceid"], f, npac[0], npac[1], npac[2], npac[3], d)
+        
+        return {
+            "response_data": verify2,
+            "pid": frames_info["pid"],
+            "traceid": frames_info["traceid"],
+        }
+    except Exception as e:
+        print(f"滑块验证过程中出错: {e}")
+        import traceback
+        traceback.print_exc()
+        return {"response_data": {"result": "reject"}, "pid": "", "traceid": ""}
+
+
+def image_download(device_id, pid, traceid, use_proxy=False, proxies=None):
+    url = f"https://user.mypikpak.com/pzzl/image?deviceid={device_id}&pid={pid}&traceid={traceid}"
+
+    headers = {
+        'pragma': 'no-cache',
+        'priority': 'u=1, i'
+    }
+
+    try:
+        response = requests.get(url, headers=headers, proxies=proxies if use_proxy else None)
+        response.raise_for_status()
+        if response.status_code == 200:
+            return response.content  # 直接返回图片的二进制数据
+        else:
+            print(f"下载失败，状态码: {response.status_code}")
+            return None
+    except requests.exceptions.RequestException as e:
+        print(f"图片下载失败: {e}")
+        if use_proxy:
+            print(f"当前使用的代理: {proxies}")
+        return None
+
+
+def ramdom_version():
+    version_list = [
+        {
+            "v": "1.42.6",
+            "algorithms": [{"alg": "md5", "salt": "frupTFdxwcJ5mcL3R8"},
+                           {"alg": "md5", "salt": "jB496fSFfbWLhWyqV"},
+                           {"alg": "md5", "salt": "xYLtzn8LT5h3KbAalCjc/Wf"},
+                           {"alg": "md5", "salt": "PSHSbm1SlxbvkwNk4mZrJhBZ1vsHCtEdm3tsRiy1IPUnqi1FNB5a2F"},
+                           {"alg": "md5", "salt": "SX/WvPCRzgkLIp99gDnLaCs0jGn2+urx7vz/"},
+                           {"alg": "md5", "salt": "OGdm+dgLk5EpK4O1nDB+Z4l"},
+                           {"alg": "md5", "salt": "nwtOQpz2xFLIE3EmrDwMKe/Vlw2ubhRcnS2R23bwx9wMh+C3Sg"},
+                           {"alg": "md5", "salt": "FI/9X9jbnTLa61RHprndT0GkVs18Chd"}]
+
+        },
+        {
+            "v": "1.47.1",
+            "algorithms": [{'alg': 'md5', 'salt': 'Gez0T9ijiI9WCeTsKSg3SMlx'}, {'alg': 'md5', 'salt': 'zQdbalsolyb1R/'},
+                           {'alg': 'md5', 'salt': 'ftOjr52zt51JD68C3s'},
+                           {'alg': 'md5', 'salt': 'yeOBMH0JkbQdEFNNwQ0RI9T3wU/v'},
+                           {'alg': 'md5', 'salt': 'BRJrQZiTQ65WtMvwO'},
+                           {'alg': 'md5', 'salt': 'je8fqxKPdQVJiy1DM6Bc9Nb1'},
+                           {'alg': 'md5', 'salt': 'niV'}, {'alg': 'md5', 'salt': '9hFCW2R1'},
+                           {'alg': 'md5', 'salt': 'sHKHpe2i96'},
+                           {'alg': 'md5', 'salt': 'p7c5E6AcXQ/IJUuAEC9W6'}, {'alg': 'md5', 'salt': ''},
+                           {'alg': 'md5', 'salt': 'aRv9hjc9P+Pbn+u3krN6'},
+                           {'alg': 'md5', 'salt': 'BzStcgE8qVdqjEH16l4'},
+                           {'alg': 'md5', 'salt': 'SqgeZvL5j9zoHP95xWHt'},
+                           {'alg': 'md5', 'salt': 'zVof5yaJkPe3VFpadPof'}]
+        },
+        {
+            "v": "1.48.3",
+            "algorithms": [{'alg': 'md5', 'salt': 'aDhgaSE3MsjROCmpmsWqP1sJdFJ'},
+                           {'alg': 'md5', 'salt': '+oaVkqdd8MJuKT+uMr2AYKcd9tdWge3XPEPR2hcePUknd'},
+                           {'alg': 'md5', 'salt': 'u/sd2GgT2fTytRcKzGicHodhvIltMntA3xKw2SRv7S48OdnaQIS5mn'},
+                           {'alg': 'md5', 'salt': '2WZiae2QuqTOxBKaaqCNHCW3olu2UImelkDzBn'},
+                           {'alg': 'md5', 'salt': '/vJ3upic39lgmrkX855Qx'},
+                           {'alg': 'md5', 'salt': 'yNc9ruCVMV7pGV7XvFeuLMOcy1'},
+                           {'alg': 'md5', 'salt': '4FPq8mT3JQ1jzcVxMVfwFftLQm33M7i'},
+                           {'alg': 'md5', 'salt': 'xozoy5e3Ea'}]
+        },
+        {
+            "v": "1.49.3",
+            "algorithms": [{'alg': 'md5', 'salt': '7xOq4Z8s'}, {'alg': 'md5', 'salt': 'QE9/9+IQco'},
+                           {'alg': 'md5', 'salt': 'WdX5J9CPLZp'}, {'alg': 'md5', 'salt': 'NmQ5qFAXqH3w984cYhMeC5TJR8j'},
+                           {'alg': 'md5', 'salt': 'cc44M+l7GDhav'}, {'alg': 'md5', 'salt': 'KxGjo/wHB+Yx8Lf7kMP+/m9I+'},
+                           {'alg': 'md5', 'salt': 'wla81BUVSmDkctHDpUT'},
+                           {'alg': 'md5', 'salt': 'c6wMr1sm1WxiR3i8LDAm3W'},
+                           {'alg': 'md5', 'salt': 'hRLrEQCFNYi0PFPV'},
+                           {'alg': 'md5', 'salt': 'o1J41zIraDtJPNuhBu7Ifb/q3'},
+                           {'alg': 'md5', 'salt': 'U'}, {'alg': 'md5', 'salt': 'RrbZvV0CTu3gaZJ56PVKki4IeP'},
+                           {'alg': 'md5', 'salt': 'NNuRbLckJqUp1Do0YlrKCUP'},
+                           {'alg': 'md5', 'salt': 'UUwnBbipMTvInA0U0E9'},
+                           {'alg': 'md5', 'salt': 'VzGc'}]
+        },
+        {
+            "v": "1.51.2",
+            "algorithms": [{'alg': 'md5', 'salt': 'vPjelkvqcWoCsQO1CnkVod8j2GbcE0yEHEwJ3PKSKW'},
+                           {'alg': 'md5', 'salt': 'Rw5aO9MHuhY'}, {'alg': 'md5', 'salt': 'Gk111qdZkPw/xgj'},
+                           {'alg': 'md5', 'salt': '/aaQ4/f8HNpyzPOtIF3rG/UEENiRRvpIXku3WDWZHuaIq+0EOF'},
+                           {'alg': 'md5', 'salt': '6p1gxZhV0CNuKV2QO5vpibkR8IJeFURvqNIKXWOIyv1A'},
+                           {'alg': 'md5', 'salt': 'gWR'},
+                           {'alg': 'md5', 'salt': 'iPD'}, {'alg': 'md5', 'salt': 'ASEm+P75YfKzQRW6eRDNNTd'},
+                           {'alg': 'md5', 'salt': '2fauuwVCxLCpL/FQ/iJ5NpOPb7gRZs0EWJwe/2YNPQr3ore+ZiIri6s/tYayG'}]
+        }
+    ]
+    return version_list[0]
+    # return random.choice(version_list)
+
+
+def random_rtc_token():
+    # 生成 8 组 16 进制数，每组 4 位，使用冒号分隔
+    ipv6_parts = ["{:04x}".format(random.randint(0, 0xFFFF)) for _ in range(8)]
+    ipv6_address = ":".join(ipv6_parts)
+    return ipv6_address
+
+
+class PikPak:
+    def __init__(self, invite_code, client_id, device_id, version, algorithms, email, rtc_token,
+                 client_secret, package_name, use_proxy=False, proxy_http=None, proxy_https=None):
+        # 初始化实例属性
+        self.invite_code = invite_code  # 邀请码
+        self.client_id = client_id  # 客户端ID
+        self.device_id = device_id  # 设备ID
+        self.timestamp = 0  # 时间戳
+        self.algorithms = algorithms  # 版本盐值
+        self.version = version  # 版本
+        self.email = email  # 邮箱
+        self.rtc_token = rtc_token  # RTC Token
+        self.captcha_token = ""  # Captcha Token
+        self.client_secret = client_secret  # Client Secret
+        self.user_id = ""  # 用户ID
+        self.access_token = ""  # 登录令牌
+        self.refresh_token = ""  # 刷新令牌
+        self.verification_token = ""  # Verification Token
+        self.captcha_sign = ""  # Captcha Sign
+        self.verification_id = ""  # Verification ID
+        self.package_name = package_name  # 客户端包名
+        self.use_proxy = use_proxy  # 是否使用代理
+
+        # 代理配置
+        if use_proxy:
+            self.proxies = {
+                "http": proxy_http or "http://127.0.0.1:7890",
+                "https": proxy_https or "http://127.0.0.1:7890",
+            }
+        else:
+            self.proxies = None
+
+    def send_request(self, method, url, headers=None, params=None, json_data=None, data=None, use_proxy=None):
+        headers = headers or {}
+        # 如果未指定use_proxy，则使用类的全局设置
+        use_proxy = self.use_proxy if use_proxy is None else use_proxy
+        
+        # 确保当use_proxy为True时，有可用的代理配置
+        if use_proxy and not self.proxies:
+            # 如果类的use_proxy为True但proxies未设置，使用默认代理
+            proxies = {
+                "http": "http://127.0.0.1:7890",
+                "https": "http://127.0.0.1:7890"
+            }
+        else:
+            proxies = self.proxies if use_proxy else None
+
+        try:
+            response = requests.request(
+                method=method,
+                url=url,
+                headers=headers,
+                params=params,
+                json=json_data,
+                data=data,
+                proxies=proxies,
+                timeout=30  # 添加超时设置
+            )
+            response.raise_for_status()  # 检查HTTP状态码
+            
+            print(response.text)
+            try:
+                return response.json()
+            except json.JSONDecodeError:
+                return response.text
+        except requests.exceptions.RequestException as e:
+            print(f"请求失败: {url}, 错误: {e}")
+            if use_proxy:
+                print(f"当前使用的代理: {proxies}")
+            # 返回一个空的响应对象
+            return {}
+
+    def gen(self):
+        url = "https://user.mypikpak.com/pzzl/gen"
+        params = {"deviceid": self.device_id, "traceid": ""}
+        headers = {"Host": "user.mypikpak.com", "accept": "application/json, text/plain, */*"}
+        response = self.send_request("GET", url, headers=headers, params=params)
+        # 检查响应是否有效
+        if not response or not isinstance(response, dict) or "pid" not in response or "frames" not in response:
+            print(f"gen请求返回无效响应: {response}")
+        return response
+
+    def image_verify(self, pid, trace_id, f, n, p, a, c, d):
+        url = "https://user.mypikpak.com/pzzl/verify"
+        params = {"pid": pid, "deviceid": self.device_id, "traceid": trace_id, "f": f, "n": n, "p": p, "a": a, "c": c,
+                  "d": d}
+        headers = {"Host": "user.mypikpak.com", "accept": "application/json, text/plain, */*"}
+        response = self.send_request("GET", url, headers=headers, params=params)
+        # 检查响应是否有效
+        if not response or not isinstance(response, dict) or "result" not in response:
+            print(f"image_verify请求返回无效响应: {response}")
+            return {"result": "reject"}
+        return response
+
+    def executor(self):
+        url = "https://api-drive.mypikpak.com/captcha-jsonp/v2/executor?callback=handleJsonpResult_" + str(int(time.time() * 1000))
+        headers = {'pragma': 'no-cache', 'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36'}
+        
+        try:
+            # 使用普通 requests 而不是 self.send_request 以获取原始响应
+            response = requests.get(url, headers=headers, proxies=self.proxies if self.use_proxy else None, timeout=30)
+            response.raise_for_status()  # 检查 HTTP 状态码
+            
+            content = response.text
+            print(f"executor 原始响应: {content}")
+            
+            # 如果内容为空，直接返回空字符串
+            if not content:
+                print("executor 响应内容为空")
+                return ""
+            
+            # 处理 JSONP 响应格式
+            if "handleJsonpResult" in content:
+                # 提取 JSON 部分，JSONP 格式通常是 callback(json数据)
+                start_index = content.find('(')
+                end_index = content.rfind(')')
+                
+                if start_index != -1 and end_index != -1:
+                    json_str = content[start_index + 1:end_index]
+                    # 有时 JSONP 响应中包含反引号，需要去除
+                    if json_str.startswith('`') and json_str.endswith('`'):
+                        json_str = json_str[1:-1]
+                    
+                    return json_str
+                else:
+                    print(f"无法从JSONP响应中提取有效内容: {content}")
+                    return ""
+            elif isinstance(content, str) and (content.startswith('{') or content.startswith('[')):
+                # 可能是直接返回的 JSON 字符串
+                return content
+            else:
+                print(f"未知的响应格式: {content}")
+                return ""
+        except requests.exceptions.RequestException as e:
+            print(f"执行 executor 请求失败: {e}")
+            return ""
+        except Exception as e:
+            print(f"解析 executor 响应失败: {e}")
+            return ""
+
+    def report(self, request_id, sign, pid, trace_id):
+        url = "https://user.mypikpak.com/credit/v1/report"
+        params = {
+            "deviceid": self.device_id,
+            "captcha_token": self.captcha_token,
+            "request_id": request_id,
+            "sign": sign,
+            "type": "pzzlSlider",
+            "result": 0,
+            "data": pid,
+            "traceid": trace_id,
+            "rtc_token": self.rtc_token
+        }
+        headers = {'pragma': 'no-cache', 'priority': 'u=1, i'}
+        response = self.send_request("GET", url, params=params, headers=headers)
+        # 检查响应是否有效
+        if not response or not isinstance(response, dict) or "captcha_token" not in response:
+            print(f"report请求返回无效响应: {response}")
+        else:
+            self.captcha_token = response.get('captcha_token')
+        return response
+
+    def verification(self):
+        url = 'https://user.mypikpak.com/v1/auth/verification'
+        params = {"email": self.email, "target": "ANY", "usage": "REGISTER", "locale": "zh-CN",
+                  "client_id": self.client_id}
+        headers = {'host': 'user.mypikpak.com', 'x-captcha-token': self.captcha_token, 'x-device-id': self.device_id,
+                   "x-client-id": self.client_id}
+        response = self.send_request("POST", url, headers=headers, data=params)
+        # 检查响应是否有效
+        if not response or not isinstance(response, dict) or "verification_id" not in response:
+            print(f"verification请求返回无效响应: {response}")
+        else:
+            self.verification_id = response.get('verification_id')
+        return response
+
+    def verify_post(self, verification_code):
+        url = "https://user.mypikpak.com/v1/auth/verification/verify"
+        params = {"client_id": self.client_id}
+        payload = {"client_id": self.client_id, "verification_id": self.verification_id,
+                   "verification_code": verification_code}
+        headers = {"X-Device-Id": self.device_id}
+        response = self.send_request("POST", url, headers=headers, json_data=payload, params=params)
+        # 检查响应是否有效
+        if not response or not isinstance(response, dict) or "verification_token" not in response:
+            print(f"verify_post请求返回无效响应: {response}")
+        else:
+            self.verification_token = response.get('verification_token')
+        return response
+
+    def init(self, action):
+        self.refresh_captcha_sign()
+        url = "https://user.mypikpak.com/v1/shield/captcha/init"
+        params = {"client_id": self.client_id}
+        payload = {
+            "action": action,
+            "captcha_token": self.captcha_token,
+            "client_id": self.client_id,
+            "device_id": self.device_id,
+            "meta": {
+                "captcha_sign": "1." + self.captcha_sign,
+                "user_id": self.user_id,
+                "package_name": self.package_name,
+                "client_version": self.version,
+                "email": self.email,
+                "timestamp": self.timestamp
+            }
+        }
+        headers = {"x-device-id": self.device_id}
+        response = self.send_request("POST", url, headers=headers, json_data=payload, params=params)
+        # 检查响应是否有效
+        if not response or not isinstance(response, dict) or "captcha_token" not in response:
+            print(f"init请求返回无效响应: {response}")
+        else:
+            self.captcha_token = response.get('captcha_token')
+        return response
+
+    def signup(self, name, password, verification_code):
+        url = "https://user.mypikpak.com/v1/auth/signup"
+        params = {"client_id": self.client_id}
+        payload = {
+            "captcha_token": self.captcha_token,
+            "client_id": self.client_id,
+            "client_secret": self.client_secret,
+            "email": self.email,
+            "name": name,
+            "password": password,
+            "verification_code": verification_code,
+            "verification_token": self.verification_token
+        }
+        headers = {"X-Device-Id": self.device_id}
+        response = self.send_request("POST", url, headers=headers, json_data=payload, params=params)
+        # 检查响应是否有效
+        if not response or not isinstance(response, dict):
+            print(f"signup请求返回无效响应: {response}")
+        else:
+            self.access_token = response.get('access_token', '')
+            self.refresh_token = response.get('refresh_token', '')
+            self.user_id = response.get('sub', '')
+        return response
+
+    def activation_code(self):
+        url = "https://api-drive.mypikpak.com/vip/v1/order/activation-code"
+        payload = {"activation_code": self.invite_code, "data": {}}
+        headers = {
+            "Host": "api-drive.mypikpak.com",
+            "authorization": "Bearer " + self.access_token,
+            "x-captcha-token": self.captcha_token,
+            "x-device-id": self.device_id,
+            'x-system-language': "ko",
+            'content-type': 'application/json'
+        }
+        response = self.send_request("POST", url, headers=headers, json_data=payload)
+        # 检查响应是否有效
+        if not response or not isinstance(response, dict):
+            print(f"activation_code请求返回无效响应: {response}")
+        return response
+
+    def files_task(self, task_link):
+        url = "https://api-drive.mypikpak.com/drive/v1/files"
+        payload = {
+            "kind": "drive#file",
+            "folder_type": "DOWNLOAD",
+            "upload_type": "UPLOAD_TYPE_URL",
+            "url": {"url": task_link},
+            "params": {"with_thumbnail": "true", "from": "manual"}
+        }
+        headers = {
+            "Authorization": "Bearer " + self.access_token,
+            "x-device-id": self.device_id,
+            "x-captcha-token": self.captcha_token,
+            "Content-Type": "application/json"
+        }
+        response = self.send_request("POST", url, headers=headers, json_data=payload)
+        # 检查响应是否有效
+        if not response or not isinstance(response, dict):
+            print(f"files_task请求返回无效响应: {response}")
+        return response
+
+    def refresh_captcha_sign(self):
+        self.timestamp = str(int(time.time()) * 1000)
+        encrypt_string = self.client_id + self.version + self.package_name + self.device_id + self.timestamp
+        self.captcha_sign = captcha_sign_encrypt(encrypt_string, self.algorithms)
+
+
+def save_account_info(name, account_info):
+    # 保证account目录存在
+    if not os.path.exists("./account"):
+        os.makedirs("./account")
+    with open("./account/" + name + ".json", "w", encoding="utf-8") as f:
+        json.dump(account_info, f, ensure_ascii=False, indent=4)
+
+
+def test_proxy(proxy_url):
+    """测试代理连接是否可用"""
+    test_url = "https://mypikpak.com"  # 改为 PikPak 的网站，更可能连通
+    proxies = {
+        "http": proxy_url,
+        "https": proxy_url
+    }
+    
+    try:
+        response = requests.get(test_url, proxies=proxies, timeout=10)  # 增加超时时间
+        response.raise_for_status()
+        print(f"代理连接测试成功: {proxy_url}")
+        return True
+    except Exception as e:
+        print(f"代理连接测试失败: {proxy_url}, 错误: {e}")
+        return False
+
+
+# 程序运行主函数
+def main():
+    try:
+        # 1、初始化参数
+        current_version = ramdom_version()
+        version = current_version['v']
+        algorithms = current_version['algorithms']
+        client_id = "YNxT9w7GMdWvEOKa"
+        client_secret = "dbw2OtmVEeuUvIptb1Coyg"
+        package_name = "com.pikcloud.pikpak"
+        device_id = str(uuid.uuid4()).replace("-", "")
+        rtc_token = random_rtc_token()
+        print(f"当前版本:{version} 设备号:{device_id} 令牌:{rtc_token}")
+        
+        # 询问用户是否使用代理
+        use_proxy_input = input('是否启用代理(y/n)：').strip().lower()
+        use_proxy = use_proxy_input == 'y' or use_proxy_input == 'yes'
+        
+        proxy_http = None
+        proxy_https = None
+        
+        if use_proxy:
+            # 询问用户是否使用默认代理
+            default_proxy = input('是否使用默认代理地址 http://127.0.0.1:7890 (y/n)：').strip().lower()
+            if default_proxy == 'y' or default_proxy == 'yes':
+                proxy_url = "http://127.0.0.1:7890"
+                print("已启用代理，使用默认地址:", proxy_url)
+                
+                # 测试默认代理连接
+                if not test_proxy(proxy_url):
+                    retry = input("默认代理连接测试失败，是否继续使用(y/n)：").strip().lower()
+                    if retry != 'y' and retry != 'yes':
+                        print("已取消代理设置，将直接连接")
+                        use_proxy = False
+                        proxy_url = None
+                
+                if use_proxy:
+                    proxy_http = proxy_url
+                    proxy_https = proxy_url
+            else:
+                # 用户自定义代理地址和端口
+                proxy_host = input('请输入代理主机地址 (默认127.0.0.1): ').strip()
+                proxy_host = proxy_host if proxy_host else '127.0.0.1'
+                
+                proxy_port = input('请输入代理端口 (默认7890): ').strip()
+                proxy_port = proxy_port if proxy_port else '7890'
+                
+                proxy_protocol = input('请输入代理协议 (http/https/socks5，默认http): ').strip().lower()
+                proxy_protocol = proxy_protocol if proxy_protocol in ['http', 'https', 'socks5'] else 'http'
+                
+                proxy_url = f"{proxy_protocol}://{proxy_host}:{proxy_port}"
+                print(f"已设置代理地址: {proxy_url}")
+                
+                # 测试自定义代理连接
+                if not test_proxy(proxy_url):
+                    retry = input("自定义代理连接测试失败，是否继续使用(y/n)：").strip().lower()
+                    if retry != 'y' and retry != 'yes':
+                        print("已取消代理设置，将直接连接")
+                        use_proxy = False
+                        proxy_url = None
+                
+                if use_proxy:
+                    proxy_http = proxy_url
+                    proxy_https = proxy_url
+        else:
+            print("未启用代理，直接连接")
+        
+        invite_code = input('请输入你的邀请码：')
+        email = input("请输入注册用的邮箱：")
+        # 2、实例化PikPak类，传入代理设置
+        pikpak = PikPak(invite_code, client_id, device_id, version, algorithms, email, rtc_token, client_secret,
+                        package_name, use_proxy=use_proxy, proxy_http=proxy_http, proxy_https=proxy_https)
+        
+        # 3、刷新timestamp，加密sign值。
+        init_result = pikpak.init("POST:/v1/auth/verification")
+        if not init_result or not isinstance(init_result, dict) or "captcha_token" not in init_result:
+            print("初始化失败，请检查网络连接或代理设置")
+            input("按任意键退出程序")
+            return
+            
+        # 4、图片滑块分析
+        max_attempts = 5  # 最大尝试次数
+        captcha_result = None
+        
+        for attempt in range(max_attempts):
+            print(f"尝试滑块验证 ({attempt+1}/{max_attempts})...")
+            try:
+                captcha_result = captcha_image_parse(pikpak, device_id)
+                print(captcha_result)
+                
+                if captcha_result and "response_data" in captcha_result and captcha_result['response_data'].get('result') == 'accept':
+                    print("滑块验证成功!")
+                    break
+                else:
+                    print('滑块验证失败, 正在重新尝试...')
+                    time.sleep(2)  # 延迟2秒再次尝试
+            except Exception as e:
+                print(f"滑块验证过程出错: {e}")
+                import traceback
+                traceback.print_exc()
+                time.sleep(2)  # 出错后延迟2秒再次尝试
+        
+        if not captcha_result or "response_data" not in captcha_result or captcha_result['response_data'].get('result') != 'accept':
+            print("滑块验证失败，达到最大尝试次数")
+            input("按任意键退出程序")
+            return
+            
+        # 5、滑块验证加密
+        try:
+            executor_info = pikpak.executor()
+            if not executor_info:
+                print("获取executor信息失败")
+                input("按任意键退出程序")
+                return
+                
+            sign_encrypt_info = sign_encrypt(executor_info, pikpak.captcha_token, rtc_token, pikpak.use_proxy, pikpak.proxies)
+            if not sign_encrypt_info or "request_id" not in sign_encrypt_info or "sign" not in sign_encrypt_info:
+                print("签名加密失败")
+                print(f"executor_info: {executor_info}")
+                print(f"captcha_token: {pikpak.captcha_token}")
+                print(f"rtc_token: {rtc_token}")
+                input("按任意键退出程序")
+                return
+                
+            # 更新 captcha_token
+            pikpak.report(sign_encrypt_info['request_id'], sign_encrypt_info['sign'], captcha_result['pid'],
+                        captcha_result['traceid'])
+            
+            # 发送邮箱验证码
+            verification_result = pikpak.verification()
+            if not verification_result or not isinstance(verification_result, dict) or "verification_id" not in verification_result:
+                print("请求验证码失败")
+                input("按任意键退出程序")
+                return
+        except Exception as e:
+            print(f"验证过程出错: {e}")
+            import traceback
+            traceback.print_exc()
+            input("按任意键退出程序")
+            return
+            
+        # 6、提交验证码
+        verification_code = input("请输入接收到的验证码：")
+        pikpak.verify_post(verification_code)
+        
+        # 7、刷新timestamp，加密sign值
+        pikpak.init("POST:/v1/auth/signup")
+        
+        # 8、注册登录
+        name = email.split("@")[0]
+        password = "zhiyuan233"
+        pikpak.signup(name, password, verification_code)
+        
+        # 9、填写邀请码
+        pikpak.activation_code()
+        
+        # 准备账号信息
+        account_info = {
+            "version": pikpak.version,
+            "device_id": pikpak.device_id,
+            "email": pikpak.email,
+            "captcha_token": pikpak.captcha_token,
+            "access_token": pikpak.access_token,
+            "refresh_token": pikpak.refresh_token,
+            "user_id": pikpak.user_id,
+            "timestamp": pikpak.timestamp,
+            "password": password,
+            "name": name
+        }
+        
+        print("请保存好账号信息备用：", json.dumps(account_info, indent=4, ensure_ascii=False))
+        
+        # 确认是否保存账号信息
+        save_info = input("是否保存账号信息到文件(y/n)：").strip().lower()
+        if save_info == 'y' or save_info == 'yes':
+            try:
+                # 创建account目录（如果不存在）
+                if not os.path.exists("./account"):
+                    os.makedirs("./account")
+                save_account_info(name, account_info)
+                print(f"账号信息已保存到 ./account/{name}.json")
+            except Exception as e:
+                print(f"保存账号信息失败: {e}")
+        
+        input("运行完成，回车结束程序：")
+    except KeyboardInterrupt:
+        print("\n程序被用户中断")
+    except Exception as e:
+        print(f"程序运行出错: {e}")
+        import traceback
+        traceback.print_exc()
+        input("按任意键退出程序")
+
+
+if __name__ == "__main__":
+    print("开发者声明：免费转载需标注出处：B站-纸鸢花的花语，此工具仅供交流学习和技术分析，严禁用于任何商业牟利行为。（包括但不限于倒卖、二改倒卖、引流、冒充作者、广告植入...）")
+    main()

utils/pk_email.py

@@ -0,0 +1,116 @@
+import imaplib
+import re
+import email
+import socket
+import socks  # 增加 socks 库支持
+
+# IMAP 服务器信息
+IMAP_SERVER = 'imap.shanyouxiang.com'
+IMAP_PORT = 993  # IMAP SSL 端口
+
+# 邮件发送者列表（用于查找验证码）
+VERIFICATION_SENDERS = ['[email protected]']
+
+
+# --------------------------- IMAP 获取验证码 ---------------------------
+
+def connect_imap(email_user, email_password, folder='INBOX', use_proxy=False, proxy_url=None):
+    """
+    使用 IMAP 连接并检查指定文件夹中的验证码邮件
+    支持通过代理连接
+    
+    参数:
+        email_user: 邮箱用户名
+        email_password: 邮箱密码
+        folder: 要检查的文件夹
+        use_proxy: 是否使用代理
+        proxy_url: 代理服务器URL (例如 "http://127.0.0.1:7890")
+    """
+    original_socket = None
+    
+    try:
+        # 如果启用代理，设置SOCKS代理
+        if use_proxy and proxy_url:
+            # 解析代理URL
+            if proxy_url.startswith(('http://', 'https://')):
+                # 从HTTP代理URL提取主机和端口
+                from urllib.parse import urlparse
+                parsed = urlparse(proxy_url)
+                proxy_host = parsed.hostname
+                proxy_port = parsed.port or 80
+                
+                # 保存原始socket
+                original_socket = socket.socket
+                
+                # 设置socks代理
+                socks.set_default_proxy(socks.PROXY_TYPE_HTTP, proxy_host, proxy_port)
+                socket.socket = socks.socksocket
+                
+                print(f"使用代理连接IMAP服务器: {proxy_url}")
+        
+        # 连接 IMAP 服务器
+        mail = imaplib.IMAP4_SSL(IMAP_SERVER, IMAP_PORT)
+        mail.login(email_user, email_password)  # 直接使用邮箱密码登录
+
+        # 选择文件夹
+        status, _ = mail.select(folder)
+        if status != 'OK':
+            return {"code": 0, "msg": f"无法访问 {folder} 文件夹"}
+
+        # 搜索邮件
+        status, messages = mail.search(None, 'ALL')
+        if status != 'OK' or not messages[0]:
+            return {"code": 0, "msg": f"{folder} 文件夹为空"}
+
+        message_ids = messages[0].split()
+        verification_code = None
+        timestamp = None
+
+        for msg_id in message_ids[::-1]:  # 从最新邮件开始查找
+            status, msg_data = mail.fetch(msg_id, '(RFC822)')
+            if status != 'OK':
+                continue
+
+            for response_part in msg_data:
+                if isinstance(response_part, tuple):
+                    msg = email.message_from_bytes(response_part[1])
+                    from_email = msg['From']
+
+                    if any(sender in from_email for sender in VERIFICATION_SENDERS):
+                        timestamp = msg['Date']
+
+                        # 解析邮件正文
+                        if msg.is_multipart():
+                            for part in msg.walk():
+                                if part.get_content_type() == 'text/html':
+                                    body = part.get_payload(decode=True).decode('utf-8')
+                                    break
+                        else:
+                            body = msg.get_payload(decode=True).decode('utf-8')
+
+                        # 提取验证码
+                        match = re.search(r'\b(\d{6})\b', body)
+                        if match:
+                            verification_code = match.group(1)
+                            break
+
+            if verification_code:
+                break
+
+        mail.logout()
+
+        if verification_code:
+            return {"code": 200, "verification_code": verification_code, "time": timestamp,
+                    "msg": f"成功获取验证码 ({folder})"}
+        else:
+            return {"code": 0, "msg": f"{folder} 中未找到验证码"}
+
+    except imaplib.IMAP4.error as e:
+        return {"code": 401, "msg": "IMAP 认证失败，请检查邮箱和密码是否正确，或者邮箱是否支持IMAP登录"}
+    except Exception as e:
+        return {"code": 500, "msg": f"错误: {str(e)}"}
+    finally:
+        # 恢复原始socket
+        if original_socket:
+            socket.socket = original_socket
+